milvus-io
/
milvus
mirror of https://github.com/milvus-io/milvus.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Rename proto master/index_service/proxy_service (#5973) 

* rename proto proxy_service to proxy

Signed-off-by: yudong.cai <yudong.cai@zilliz.com>

* rename proto index_service to index_coord

Signed-off-by: yudong.cai <yudong.cai@zilliz.com>

* rename proto master to root_coord

Signed-off-by: yudong.cai <yudong.cai@zilliz.com>
pull/5979/head^2
Cai Yudong 2021-06-22 16:14:09 +08:00 committed by GitHub
parent 80bb418136
commit d5f4ee6f44
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
26 changed files with 560 additions and 572 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
docs/developer_guides/chap06_root_coordinator.md
View File

@ -28,8 +28,8 @@ type RootCoord interface {
DropIndex(ctx context.Context, req *milvuspb.DropIndexRequest) (*commonpb.Status, error)
//global timestamp allocator
AllocTimestamp(ctx context.Context, req *masterpb.AllocTimestampRequest) (*masterpb.AllocTimestampResponse, error)
AllocID(ctx context.Context, req *masterpb.AllocIDRequest) (*masterpb.AllocIDResponse, error)
AllocTimestamp(ctx context.Context, req *rootcoordpb.AllocTimestampRequest) (*rootcoordpb.AllocTimestampResponse, error)
AllocID(ctx context.Context, req *rootcoordpb.AllocIDRequest) (*rootcoordpb.AllocIDResponse, error)
UpdateChannelTimeTick(ctx context.Context, req *internalpb.ChannelTimeTickMsg) (*commonpb.Status, error)
//segment

4
internal/allocator/id.go
View File

@ -21,7 +21,7 @@ import (
rcc "github.com/milvus-io/milvus/internal/distributed/rootcoord/client"
"github.com/milvus-io/milvus/internal/log"
"github.com/milvus-io/milvus/internal/proto/commonpb"
"github.com/milvus-io/milvus/internal/proto/masterpb"
"github.com/milvus-io/milvus/internal/proto/rootcoordpb"
"github.com/milvus-io/milvus/internal/types"
"github.com/milvus-io/milvus/internal/util/typeutil"
)
@ -103,7 +103,7 @@ func (ia *IDAllocator) syncID() (bool, error) {
}
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
req := &masterpb.AllocIDRequest{
req := &rootcoordpb.AllocIDRequest{
Base: &commonpb.MsgBase{
MsgType: commonpb.MsgType_RequestID,
MsgID: 0,

6
internal/datacoord/allocator.go
View File

@ -16,7 +16,7 @@ import (
"github.com/milvus-io/milvus/internal/types"
"github.com/milvus-io/milvus/internal/proto/commonpb"
"github.com/milvus-io/milvus/internal/proto/masterpb"
"github.com/milvus-io/milvus/internal/proto/rootcoordpb"
)
type allocator interface {
@ -36,7 +36,7 @@ func newAllocator(rootCoordClient types.RootCoord) *rootCoordAllocator {
func (allocator *rootCoordAllocator) allocTimestamp() (Timestamp, error) {
ctx := context.TODO()
resp, err := allocator.rootCoordClient.AllocTimestamp(ctx, &masterpb.AllocTimestampRequest{
resp, err := allocator.rootCoordClient.AllocTimestamp(ctx, &rootcoordpb.AllocTimestampRequest{
Base: &commonpb.MsgBase{
MsgType: commonpb.MsgType_RequestTSO,
MsgID: -1, // todo add msg id
@ -53,7 +53,7 @@ func (allocator *rootCoordAllocator) allocTimestamp() (Timestamp, error) {
func (allocator *rootCoordAllocator) allocID() (UniqueID, error) {
ctx := context.TODO()
resp, err := allocator.rootCoordClient.AllocID(ctx, &masterpb.AllocIDRequest{
resp, err := allocator.rootCoordClient.AllocID(ctx, &rootcoordpb.AllocIDRequest{
Base: &commonpb.MsgBase{
MsgType: commonpb.MsgType_RequestID,
MsgID: -1, // todo add msg id

10
internal/datacoord/mock_test.go
View File

@ -22,9 +22,9 @@ import (
"github.com/milvus-io/milvus/internal/proto/commonpb"
"github.com/milvus-io/milvus/internal/proto/datapb"
"github.com/milvus-io/milvus/internal/proto/internalpb"
"github.com/milvus-io/milvus/internal/proto/masterpb"
"github.com/milvus-io/milvus/internal/proto/milvuspb"
"github.com/milvus-io/milvus/internal/proto/proxypb"
"github.com/milvus-io/milvus/internal/proto/rootcoordpb"
"github.com/milvus-io/milvus/internal/proto/schemapb"
)
@ -243,11 +243,11 @@ func (m *mockRootCoordService) DropIndex(ctx context.Context, req *milvuspb.Drop
}
//global timestamp allocator
func (m *mockRootCoordService) AllocTimestamp(ctx context.Context, req *masterpb.AllocTimestampRequest) (*masterpb.AllocTimestampResponse, error) {
func (m *mockRootCoordService) AllocTimestamp(ctx context.Context, req *rootcoordpb.AllocTimestampRequest) (*rootcoordpb.AllocTimestampResponse, error) {
val := atomic.AddInt64(&m.cnt, int64(req.Count))
phy := time.Now().UnixNano() / int64(time.Millisecond)
ts := tsoutil.ComposeTS(phy, val)
return &masterpb.AllocTimestampResponse{
return &rootcoordpb.AllocTimestampResponse{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_Success,
Reason: "",
@ -257,9 +257,9 @@ func (m *mockRootCoordService) AllocTimestamp(ctx context.Context, req *masterpb
}, nil
}
func (m *mockRootCoordService) AllocID(ctx context.Context, req *masterpb.AllocIDRequest) (*masterpb.AllocIDResponse, error) {
func (m *mockRootCoordService) AllocID(ctx context.Context, req *rootcoordpb.AllocIDRequest) (*rootcoordpb.AllocIDResponse, error) {
val := atomic.AddInt64(&m.cnt, int64(req.Count))
return &masterpb.AllocIDResponse{
return &rootcoordpb.AllocIDResponse{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_Success,
Reason: "",

4
internal/datanode/allocator.go
View File

@ -20,7 +20,7 @@ import (
"github.com/milvus-io/milvus/internal/types"
"github.com/milvus-io/milvus/internal/proto/commonpb"
"github.com/milvus-io/milvus/internal/proto/masterpb"
"github.com/milvus-io/milvus/internal/proto/rootcoordpb"
)
type allocatorInterface interface {
@ -42,7 +42,7 @@ func newAllocator(s types.RootCoord) *allocator {
func (alloc *allocator) allocID() (UniqueID, error) {
ctx := context.TODO()
resp, err := alloc.rootCoord.AllocID(ctx, &masterpb.AllocIDRequest{
resp, err := alloc.rootCoord.AllocID(ctx, &rootcoordpb.AllocIDRequest{
Base: &commonpb.MsgBase{
MsgType: commonpb.MsgType_RequestID,
MsgID: 1, // GOOSE TODO

4
internal/datanode/data_node.go
View File

@ -37,8 +37,8 @@ import (
"github.com/milvus-io/milvus/internal/proto/commonpb"
"github.com/milvus-io/milvus/internal/proto/datapb"
"github.com/milvus-io/milvus/internal/proto/internalpb"
"github.com/milvus-io/milvus/internal/proto/masterpb"
"github.com/milvus-io/milvus/internal/proto/milvuspb"
"github.com/milvus-io/milvus/internal/proto/rootcoordpb"
)
const (
@ -225,7 +225,7 @@ var FilterThreshold Timestamp
// Start will update DataNode state to HEALTHY
func (node *DataNode) Start() error {
rep, err := node.rootCoord.AllocTimestamp(node.ctx, &masterpb.AllocTimestampRequest{
rep, err := node.rootCoord.AllocTimestamp(node.ctx, &rootcoordpb.AllocTimestampRequest{
Base: &commonpb.MsgBase{
MsgType: commonpb.MsgType_RequestTSO,
MsgID: 0,

10
internal/datanode/mock_test.go
View File

@ -35,8 +35,8 @@ import (
"github.com/milvus-io/milvus/internal/proto/datapb"
"github.com/milvus-io/milvus/internal/proto/etcdpb"
"github.com/milvus-io/milvus/internal/proto/internalpb"
"github.com/milvus-io/milvus/internal/proto/masterpb"
"github.com/milvus-io/milvus/internal/proto/milvuspb"
"github.com/milvus-io/milvus/internal/proto/rootcoordpb"
"github.com/milvus-io/milvus/internal/proto/schemapb"
)
@ -482,8 +482,8 @@ func (m *RootCoordFactory) setCollectionName(name string) {
m.collectionName = name
}
func (m *RootCoordFactory) AllocID(ctx context.Context, in *masterpb.AllocIDRequest) (*masterpb.AllocIDResponse, error) {
resp := &masterpb.AllocIDResponse{
func (m *RootCoordFactory) AllocID(ctx context.Context, in *rootcoordpb.AllocIDRequest) (*rootcoordpb.AllocIDResponse, error) {
resp := &rootcoordpb.AllocIDResponse{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
}}
@ -503,8 +503,8 @@ func (m *RootCoordFactory) AllocID(ctx context.Context, in *masterpb.AllocIDRequ
return resp, nil
}
func (m *RootCoordFactory) AllocTimestamp(ctx context.Context, in *masterpb.AllocTimestampRequest) (*masterpb.AllocTimestampResponse, error) {
resp := &masterpb.AllocTimestampResponse{
func (m *RootCoordFactory) AllocTimestamp(ctx context.Context, in *rootcoordpb.AllocTimestampRequest) (*rootcoordpb.AllocTimestampResponse, error) {
resp := &rootcoordpb.AllocTimestampResponse{
Status: &commonpb.Status{},
Timestamp: 1000,
}

4
internal/distributed/indexcoord/client/client.go
View File

@ -38,7 +38,7 @@ type UniqueID = typeutil.UniqueID
type Client struct {
ctx context.Context
grpcClient indexpb.IndexServiceClient
grpcClient indexpb.IndexCoordClient
conn *grpc.ClientConn
addr string
@ -130,7 +130,7 @@ func (c *Client) connect() error {
return err
}
log.Debug("IndexCoordClient connect success")
c.grpcClient = indexpb.NewIndexServiceClient(c.conn)
c.grpcClient = indexpb.NewIndexCoordClient(c.conn)
return nil
}

2
internal/distributed/indexcoord/service.go
View File

@ -169,7 +169,7 @@ func (s *Server) startGrpcLoop(grpcPort int) {
grpc.MaxSendMsgSize(math.MaxInt32),
grpc.UnaryInterceptor(ot.UnaryServerInterceptor(opts...)),
grpc.StreamInterceptor(ot.StreamServerInterceptor(opts...)))
indexpb.RegisterIndexServiceServer(s.grpcServer, s)
indexpb.RegisterIndexCoordServer(s.grpcServer, s)
go funcutil.CheckGrpcReady(ctx, s.grpcErrChan)
if err := s.grpcServer.Serve(lis); err != nil {

4
internal/distributed/proxy/client/client.go
View File

@ -30,7 +30,7 @@ import (
)
type Client struct {
grpcClient proxypb.ProxyNodeServiceClient
grpcClient proxypb.ProxyClient
conn *grpc.ClientConn
ctx context.Context
@ -90,7 +90,7 @@ func (c *Client) connect() error {
return err
}
log.Debug("ProxyNodeClient connect success")
c.grpcClient = proxypb.NewProxyNodeServiceClient(c.conn)
c.grpcClient = proxypb.NewProxyClient(c.conn)
return nil
}

2
internal/distributed/proxy/service.go
View File

@ -102,7 +102,7 @@ func (s *Server) startGrpcLoop(grpcPort int) {
grpc_opentracing.UnaryServerInterceptor(opts...)),
grpc.StreamInterceptor(
grpc_opentracing.StreamServerInterceptor(opts...)))
proxypb.RegisterProxyNodeServiceServer(s.grpcServer, s)
proxypb.RegisterProxyServer(s.grpcServer, s)
milvuspb.RegisterMilvusServiceServer(s.grpcServer, s)
go funcutil.CheckGrpcReady(ctx, s.grpcErrChan)

14
internal/distributed/rootcoord/client/client.go
View File

@ -23,9 +23,9 @@ import (
"github.com/milvus-io/milvus/internal/log"
"github.com/milvus-io/milvus/internal/proto/commonpb"
"github.com/milvus-io/milvus/internal/proto/internalpb"
"github.com/milvus-io/milvus/internal/proto/masterpb"
"github.com/milvus-io/milvus/internal/proto/milvuspb"
"github.com/milvus-io/milvus/internal/proto/proxypb"
"github.com/milvus-io/milvus/internal/proto/rootcoordpb"
"github.com/milvus-io/milvus/internal/util/retry"
"github.com/milvus-io/milvus/internal/util/sessionutil"
"github.com/milvus-io/milvus/internal/util/trace"
@ -36,7 +36,7 @@ import (
// GrpcClient grpc client
type GrpcClient struct {
grpcClient masterpb.MasterServiceClient
grpcClient rootcoordpb.RootCoordClient
conn *grpc.ClientConn
ctx context.Context
@ -153,7 +153,7 @@ func (c *GrpcClient) connect() error {
return err
}
log.Debug("RootCoordClient try reconnect success")
c.grpcClient = masterpb.NewMasterServiceClient(c.conn)
c.grpcClient = rootcoordpb.NewRootCoordClient(c.conn)
return nil
}
@ -306,18 +306,18 @@ func (c *GrpcClient) DescribeIndex(ctx context.Context, in *milvuspb.DescribeInd
}
// AllocTimestamp global timestamp allocator
func (c *GrpcClient) AllocTimestamp(ctx context.Context, in *masterpb.AllocTimestampRequest) (*masterpb.AllocTimestampResponse, error) {
func (c *GrpcClient) AllocTimestamp(ctx context.Context, in *rootcoordpb.AllocTimestampRequest) (*rootcoordpb.AllocTimestampResponse, error) {
ret, err := c.recall(func() (interface{}, error) {
return c.grpcClient.AllocTimestamp(ctx, in)
})
return ret.(*masterpb.AllocTimestampResponse), err
return ret.(*rootcoordpb.AllocTimestampResponse), err
}
func (c *GrpcClient) AllocID(ctx context.Context, in *masterpb.AllocIDRequest) (*masterpb.AllocIDResponse, error) {
func (c *GrpcClient) AllocID(ctx context.Context, in *rootcoordpb.AllocIDRequest) (*rootcoordpb.AllocIDResponse, error) {
ret, err := c.recall(func() (interface{}, error) {
return c.grpcClient.AllocID(ctx, in)
})
return ret.(*masterpb.AllocIDResponse), err
return ret.(*rootcoordpb.AllocIDResponse), err
}
// UpdateChannelTimeTick used to handle ChannelTimeTickMsg

14
internal/distributed/rootcoord/service.go
View File

@ -32,9 +32,9 @@ import (
"github.com/milvus-io/milvus/internal/msgstream"
"github.com/milvus-io/milvus/internal/proto/commonpb"
"github.com/milvus-io/milvus/internal/proto/internalpb"
"github.com/milvus-io/milvus/internal/proto/masterpb"
"github.com/milvus-io/milvus/internal/proto/milvuspb"
"github.com/milvus-io/milvus/internal/proto/proxypb"
"github.com/milvus-io/milvus/internal/proto/rootcoordpb"
"github.com/milvus-io/milvus/internal/rootcoord"
"github.com/milvus-io/milvus/internal/types"
"github.com/milvus-io/milvus/internal/util/funcutil"
@ -226,11 +226,9 @@ func (s *Server) startGrpcLoop(grpcPort int) {
s.grpcServer = grpc.NewServer(
grpc.MaxRecvMsgSize(math.MaxInt32),
grpc.MaxSendMsgSize(math.MaxInt32),
grpc.UnaryInterceptor(
grpc_opentracing.UnaryServerInterceptor(opts...)),
grpc.StreamInterceptor(
grpc_opentracing.StreamServerInterceptor(opts...)))
masterpb.RegisterMasterServiceServer(s.grpcServer, s)
grpc.UnaryInterceptor(grpc_opentracing.UnaryServerInterceptor(opts...)),
grpc.StreamInterceptor(grpc_opentracing.StreamServerInterceptor(opts...)))
rootcoordpb.RegisterRootCoordServer(s.grpcServer, s)
go funcutil.CheckGrpcReady(ctx, s.grpcErrChan)
if err := s.grpcServer.Serve(lis); err != nil {
@ -346,11 +344,11 @@ func (s *Server) DescribeIndex(ctx context.Context, in *milvuspb.DescribeIndexRe
}
// AllocTimestamp global timestamp allocator
func (s *Server) AllocTimestamp(ctx context.Context, in *masterpb.AllocTimestampRequest) (*masterpb.AllocTimestampResponse, error) {
func (s *Server) AllocTimestamp(ctx context.Context, in *rootcoordpb.AllocTimestampRequest) (*rootcoordpb.AllocTimestampResponse, error) {
return s.rootCoord.AllocTimestamp(ctx, in)
}
func (s *Server) AllocID(ctx context.Context, in *masterpb.AllocIDRequest) (*masterpb.AllocIDResponse, error) {
func (s *Server) AllocID(ctx context.Context, in *rootcoordpb.AllocIDRequest) (*rootcoordpb.AllocIDResponse, error) {
return s.rootCoord.AllocID(ctx, in)
}

6
internal/distributed/rootcoord/service_test.go
View File

@ -30,9 +30,9 @@ import (
"github.com/milvus-io/milvus/internal/proto/datapb"
"github.com/milvus-io/milvus/internal/proto/etcdpb"
"github.com/milvus-io/milvus/internal/proto/internalpb"
"github.com/milvus-io/milvus/internal/proto/masterpb"
"github.com/milvus-io/milvus/internal/proto/milvuspb"
"github.com/milvus-io/milvus/internal/proto/proxypb"
"github.com/milvus-io/milvus/internal/proto/rootcoordpb"
"github.com/milvus-io/milvus/internal/proto/schemapb"
"github.com/milvus-io/milvus/internal/rootcoord"
"github.com/milvus-io/milvus/internal/types"
@ -289,7 +289,7 @@ func TestGrpcService(t *testing.T) {
})
t.Run("alloc time stamp", func(t *testing.T) {
req := &masterpb.AllocTimestampRequest{
req := &rootcoordpb.AllocTimestampRequest{
Count: 1,
}
rsp, err := svr.AllocTimestamp(ctx, req)
@ -298,7 +298,7 @@ func TestGrpcService(t *testing.T) {
})
t.Run("alloc id", func(t *testing.T) {
req := &masterpb.AllocIDRequest{
req := &rootcoordpb.AllocIDRequest{
Count: 1,
}
rsp, err := svr.AllocID(ctx, req)

2
internal/proto/index_service.proto → internal/proto/index_coord.proto
View File

@ -8,7 +8,7 @@ import "common.proto";
import "internal.proto";
import "milvus.proto";
service IndexService {
service IndexCoord {
rpc GetComponentStates(internal.GetComponentStatesRequest) returns (internal.ComponentStates) {}
rpc GetTimeTickChannel(internal.GetTimeTickChannelRequest) returns(milvus.StringResponse) {}
rpc GetStatisticsChannel(internal.GetStatisticsChannelRequest) returns(milvus.StringResponse){}

314
internal/proto/indexpb/index_service.pb.go → internal/proto/indexpb/index_coord.pb.go
View File

@ -1,5 +1,5 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: index_service.proto
// source: index_coord.proto
package indexpb
@ -40,7 +40,7 @@ func (m *RegisterNodeRequest) Reset() { *m = RegisterNodeRequest{} }
func (m *RegisterNodeRequest) String() string { return proto.CompactTextString(m) }
func (*RegisterNodeRequest) ProtoMessage() {}
func (*RegisterNodeRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_a5d2036b4df73e0a, []int{0}
return fileDescriptor_f9e019eb3fda53c2, []int{0}
}
func (m *RegisterNodeRequest) XXX_Unmarshal(b []byte) error {
@ -94,7 +94,7 @@ func (m *RegisterNodeResponse) Reset() { *m = RegisterNodeResponse{} }
func (m *RegisterNodeResponse) String() string { return proto.CompactTextString(m) }
func (*RegisterNodeResponse) ProtoMessage() {}
func (*RegisterNodeResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_a5d2036b4df73e0a, []int{1}
return fileDescriptor_f9e019eb3fda53c2, []int{1}
}
func (m *RegisterNodeResponse) XXX_Unmarshal(b []byte) error {
@ -140,7 +140,7 @@ func (m *GetIndexStatesRequest) Reset() { *m = GetIndexStatesRequest{} }
func (m *GetIndexStatesRequest) String() string { return proto.CompactTextString(m) }
func (*GetIndexStatesRequest) ProtoMessage() {}
func (*GetIndexStatesRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_a5d2036b4df73e0a, []int{2}
return fileDescriptor_f9e019eb3fda53c2, []int{2}
}
func (m *GetIndexStatesRequest) XXX_Unmarshal(b []byte) error {
@ -183,7 +183,7 @@ func (m *IndexInfo) Reset() { *m = IndexInfo{} }
func (m *IndexInfo) String() string { return proto.CompactTextString(m) }
func (*IndexInfo) ProtoMessage() {}
func (*IndexInfo) Descriptor() ([]byte, []int) {
return fileDescriptor_a5d2036b4df73e0a, []int{3}
return fileDescriptor_f9e019eb3fda53c2, []int{3}
}
func (m *IndexInfo) XXX_Unmarshal(b []byte) error {
@ -251,7 +251,7 @@ func (m *GetIndexStatesResponse) Reset() { *m = GetIndexStatesResponse{}
func (m *GetIndexStatesResponse) String() string { return proto.CompactTextString(m) }
func (*GetIndexStatesResponse) ProtoMessage() {}
func (*GetIndexStatesResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_a5d2036b4df73e0a, []int{4}
return fileDescriptor_f9e019eb3fda53c2, []int{4}
}
func (m *GetIndexStatesResponse) XXX_Unmarshal(b []byte) error {
@ -304,7 +304,7 @@ func (m *CreateIndexRequest) Reset() { *m = CreateIndexRequest{} }
func (m *CreateIndexRequest) String() string { return proto.CompactTextString(m) }
func (*CreateIndexRequest) ProtoMessage() {}
func (*CreateIndexRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_a5d2036b4df73e0a, []int{5}
return fileDescriptor_f9e019eb3fda53c2, []int{5}
}
func (m *CreateIndexRequest) XXX_Unmarshal(b []byte) error {
@ -397,7 +397,7 @@ func (m *BuildIndexRequest) Reset() { *m = BuildIndexRequest{} }
func (m *BuildIndexRequest) String() string { return proto.CompactTextString(m) }
func (*BuildIndexRequest) ProtoMessage() {}
func (*BuildIndexRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_a5d2036b4df73e0a, []int{6}
return fileDescriptor_f9e019eb3fda53c2, []int{6}
}
func (m *BuildIndexRequest) XXX_Unmarshal(b []byte) error {
@ -472,7 +472,7 @@ func (m *BuildIndexResponse) Reset() { *m = BuildIndexResponse{} }
func (m *BuildIndexResponse) String() string { return proto.CompactTextString(m) }
func (*BuildIndexResponse) ProtoMessage() {}
func (*BuildIndexResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_a5d2036b4df73e0a, []int{7}
return fileDescriptor_f9e019eb3fda53c2, []int{7}
}
func (m *BuildIndexResponse) XXX_Unmarshal(b []byte) error {
@ -518,7 +518,7 @@ func (m *GetIndexFilePathsRequest) Reset() { *m = GetIndexFilePathsReque
func (m *GetIndexFilePathsRequest) String() string { return proto.CompactTextString(m) }
func (*GetIndexFilePathsRequest) ProtoMessage() {}
func (*GetIndexFilePathsRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_a5d2036b4df73e0a, []int{8}
return fileDescriptor_f9e019eb3fda53c2, []int{8}
}
func (m *GetIndexFilePathsRequest) XXX_Unmarshal(b []byte) error {
@ -559,7 +559,7 @@ func (m *IndexFilePathInfo) Reset() { *m = IndexFilePathInfo{} }
func (m *IndexFilePathInfo) String() string { return proto.CompactTextString(m) }
func (*IndexFilePathInfo) ProtoMessage() {}
func (*IndexFilePathInfo) Descriptor() ([]byte, []int) {
return fileDescriptor_a5d2036b4df73e0a, []int{9}
return fileDescriptor_f9e019eb3fda53c2, []int{9}
}
func (m *IndexFilePathInfo) XXX_Unmarshal(b []byte) error {
@ -613,7 +613,7 @@ func (m *GetIndexFilePathsResponse) Reset() { *m = GetIndexFilePathsResp
func (m *GetIndexFilePathsResponse) String() string { return proto.CompactTextString(m) }
func (*GetIndexFilePathsResponse) ProtoMessage() {}
func (*GetIndexFilePathsResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_a5d2036b4df73e0a, []int{10}
return fileDescriptor_f9e019eb3fda53c2, []int{10}
}
func (m *GetIndexFilePathsResponse) XXX_Unmarshal(b []byte) error {
@ -667,7 +667,7 @@ func (m *IndexMeta) Reset() { *m = IndexMeta{} }
func (m *IndexMeta) String() string { return proto.CompactTextString(m) }
func (*IndexMeta) ProtoMessage() {}
func (*IndexMeta) Descriptor() ([]byte, []int) {
return fileDescriptor_a5d2036b4df73e0a, []int{11}
return fileDescriptor_f9e019eb3fda53c2, []int{11}
}
func (m *IndexMeta) XXX_Unmarshal(b []byte) error {
@ -762,7 +762,7 @@ func (m *DropIndexRequest) Reset() { *m = DropIndexRequest{} }
func (m *DropIndexRequest) String() string { return proto.CompactTextString(m) }
func (*DropIndexRequest) ProtoMessage() {}
func (*DropIndexRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_a5d2036b4df73e0a, []int{12}
return fileDescriptor_f9e019eb3fda53c2, []int{12}
}
func (m *DropIndexRequest) XXX_Unmarshal(b []byte) error {
@ -806,71 +806,71 @@ func init() {
proto.RegisterType((*DropIndexRequest)(nil), "milvus.proto.index.DropIndexRequest")
}
func init() { proto.RegisterFile("index_service.proto", fileDescriptor_a5d2036b4df73e0a) }
func init() { proto.RegisterFile("index_coord.proto", fileDescriptor_f9e019eb3fda53c2) }
var fileDescriptor_a5d2036b4df73e0a = []byte{
// 971 bytes of a gzipped FileDescriptorProto
var fileDescriptor_f9e019eb3fda53c2 = []byte{
// 970 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x56, 0x4f, 0x6f, 0x1b, 0x45,
0x14, 0xcf, 0x7a, 0x1b, 0xff, 0x79, 0x36, 0x51, 0x33, 0x2d, 0xd5, 0xe2, 0x52, 0xd5, 0x59, 0x0a,
0x18, 0xd4, 0x3a, 0x95, 0x4b, 0xe1, 0x84, 0x04, 0x89, 0x45, 0x64, 0xa1, 0x56, 0xd1, 0x34, 0xe2,
0x80, 0x84, 0xac, 0x89, 0xf7, 0x25, 0x19, 0x75, 0xff, 0x38, 0x3b, 0xe3, 0x88, 0xdc, 0xb9, 0x73,
0x03, 0xf1, 0x41, 0x10, 0x9f, 0x83, 0x13, 0x07, 0xbe, 0x0c, 0x9a, 0xd9, 0xd9, 0xed, 0xee, 0x7a,
0x9d, 0x38, 0x24, 0x70, 0xea, 0x6d, 0xdf, 0x9b, 0xf7, 0xe6, 0x37, 0xef, 0xf7, 0xde, 0xfc, 0x76,
0xe0, 0x0e, 0x0f, 0x3d, 0xfc, 0x71, 0x22, 0x30, 0x3e, 0xe3, 0x53, 0x1c, 0xcc, 0xe2, 0x48, 0x46,
0x84, 0x04, 0xdc, 0x3f, 0x9b, 0x8b, 0xc4, 0x1a, 0xe8, 0x88, 0x6e, 0x67, 0x1a, 0x05, 0x41, 0x14,
0x26, 0xbe, 0xee, 0x06, 0x0f, 0x25, 0xc6, 0x21, 0xf3, 0x8d, 0xdd, 0xc9, 0x67, 0xb8, 0xbf, 0x5a,
0x70, 0x87, 0xe2, 0x31, 0x17, 0x12, 0xe3, 0x97, 0x91, 0x87, 0x14, 0x4f, 0xe7, 0x28, 0x24, 0x79,
0x0a, 0xb7, 0x0e, 0x99, 0x40, 0xc7, 0xea, 0x59, 0xfd, 0xf6, 0xf0, 0xfd, 0x41, 0x01, 0xc6, 0xec,
0xff, 0x42, 0x1c, 0xef, 0x30, 0x81, 0x54, 0x47, 0x92, 0xcf, 0xa1, 0xc1, 0x3c, 0x2f, 0x46, 0x21,
0x9c, 0xda, 0x05, 0x49, 0x5f, 0x27, 0x31, 0x34, 0x0d, 0x26, 0xf7, 0xa0, 0x1e, 0x46, 0x1e, 0x8e,
0x47, 0x8e, 0xdd, 0xb3, 0xfa, 0x36, 0x35, 0x96, 0xfb, 0xb3, 0x05, 0x77, 0x8b, 0x27, 0x13, 0xb3,
0x28, 0x14, 0x48, 0x9e, 0x41, 0x5d, 0x48, 0x26, 0xe7, 0xc2, 0x1c, 0xee, 0x7e, 0x25, 0xce, 0x2b,
0x1d, 0x42, 0x4d, 0x28, 0xd9, 0x81, 0x36, 0x0f, 0xb9, 0x9c, 0xcc, 0x58, 0xcc, 0x82, 0xf4, 0x84,
0x5b, 0x83, 0x12, 0x7b, 0x86, 0xa8, 0x71, 0xc8, 0xe5, 0xbe, 0x0e, 0xa4, 0xc0, 0xb3, 0x6f, 0xf7,
0x4b, 0x78, 0x77, 0x0f, 0xe5, 0x58, 0x71, 0xac, 0x76, 0x47, 0x91, 0x92, 0xf5, 0x08, 0xde, 0xd1,
0xcc, 0xef, 0xcc, 0xb9, 0xef, 0x8d, 0x47, 0xea, 0x60, 0x76, 0xdf, 0xa6, 0x45, 0xa7, 0xfb, 0x87,
0x05, 0x2d, 0x9d, 0x3c, 0x0e, 0x8f, 0x22, 0xf2, 0x1c, 0xd6, 0xd5, 0xd1, 0x12, 0x86, 0x37, 0x86,
0x0f, 0x2b, 0x8b, 0x78, 0x83, 0x45, 0x93, 0x68, 0xe2, 0x42, 0x27, 0xbf, 0xab, 0x2e, 0xc4, 0xa6,
0x05, 0x1f, 0x71, 0xa0, 0xa1, 0xed, 0x8c, 0xd2, 0xd4, 0x24, 0x0f, 0x00, 0x92, 0x21, 0x0a, 0x59,
0x80, 0xce, 0xad, 0x9e, 0xd5, 0x6f, 0xd1, 0x96, 0xf6, 0xbc, 0x64, 0x01, 0xaa, 0x56, 0xc4, 0xc8,
0x44, 0x14, 0x3a, 0xeb, 0x7a, 0xc9, 0x58, 0xee, 0x4f, 0x16, 0xdc, 0x2b, 0x57, 0x7e, 0x9d, 0x66,
0x3c, 0x4f, 0x92, 0x50, 0xf5, 0xc1, 0xee, 0xb7, 0x87, 0x0f, 0x06, 0x8b, 0x53, 0x3c, 0xc8, 0xa8,
0xa2, 0x26, 0xd8, 0xfd, 0xb3, 0x06, 0x64, 0x37, 0x46, 0x26, 0x51, 0xaf, 0xa5, 0xec, 0x97, 0x29,
0xb1, 0x2a, 0x28, 0x29, 0x16, 0x5e, 0x2b, 0x17, 0xbe, 0x9c, 0x31, 0x07, 0x1a, 0x67, 0x18, 0x0b,
0x1e, 0x85, 0x9a, 0x2e, 0x9b, 0xa6, 0x26, 0xb9, 0x0f, 0xad, 0x00, 0x25, 0x9b, 0xcc, 0x98, 0x3c,
0x31, 0x7c, 0x35, 0x95, 0x63, 0x9f, 0xc9, 0x13, 0x85, 0xe7, 0x31, 0xb3, 0x28, 0x9c, 0x7a, 0xcf,
0x56, 0x78, 0xca, 0xa3, 0x56, 0xf5, 0x34, 0xca, 0xf3, 0x19, 0xa6, 0xd3, 0xd8, 0xd0, 0x2c, 0x6c,
0x55, 0x52, 0xf7, 0x2d, 0x9e, 0x7f, 0xc7, 0xfc, 0x39, 0xee, 0x33, 0x1e, 0x53, 0x50, 0x59, 0xc9,
0x34, 0x92, 0x91, 0x29, 0x3b, 0xdd, 0xa4, 0xb9, 0xea, 0x26, 0x6d, 0x9d, 0x66, 0x66, 0xfa, 0xb7,
0x1a, 0x6c, 0x26, 0x24, 0xfd, 0x6f, 0x94, 0x16, 0xb9, 0x59, 0xbf, 0x84, 0x9b, 0xfa, 0x4d, 0x70,
0xd3, 0xf8, 0x57, 0xdc, 0x04, 0x40, 0xf2, 0xd4, 0x5c, 0x67, 0xe2, 0x57, 0xb8, 0xb6, 0xee, 0x57,
0xe0, 0xa4, 0x97, 0xec, 0x1b, 0xee, 0xa3, 0x66, 0xe3, 0x6a, 0x0a, 0xf3, 0x8b, 0x05, 0x9b, 0x85,
0x7c, 0xad, 0x34, 0xff, 0xd5, 0x81, 0x49, 0x1f, 0x6e, 0x27, 0x2c, 0x1f, 0x71, 0x1f, 0x4d, 0x3b,
0x6d, 0xdd, 0xce, 0x0d, 0x5e, 0xa8, 0x42, 0x1d, 0xec, 0xbd, 0x8a, 0xda, 0xae, 0xc3, 0xe8, 0x08,
0x20, 0x07, 0x9b, 0xe8, 0xc8, 0x87, 0x4b, 0x75, 0x24, 0x4f, 0x08, 0x6d, 0x1d, 0x65, 0x07, 0xfb,
0xbb, 0x66, 0x34, 0xf9, 0x05, 0x4a, 0xb6, 0xd2, 0xd8, 0x67, 0xba, 0x5d, 0xbb, 0x92, 0x6e, 0x3f,
0x84, 0xf6, 0x11, 0xe3, 0xfe, 0xc4, 0xe8, 0xab, 0xad, 0xaf, 0x0b, 0x28, 0x17, 0xd5, 0x1e, 0xf2,
0x05, 0xd8, 0x31, 0x9e, 0x6a, 0x91, 0x59, 0x52, 0xc8, 0xc2, 0x35, 0xa5, 0x2a, 0xa3, 0xb2, 0x0b,
0xeb, 0x55, 0x5d, 0x20, 0x5b, 0xd0, 0x09, 0x58, 0xfc, 0x7a, 0xe2, 0xa1, 0x8f, 0x12, 0x3d, 0xa7,
0xde, 0xb3, 0xfa, 0x4d, 0xda, 0x56, 0xbe, 0x51, 0xe2, 0xca, 0xfd, 0x8c, 0x1b, 0xf9, 0x9f, 0x71,
0x5e, 0x06, 0x9b, 0x45, 0x19, 0xec, 0x42, 0x33, 0xc6, 0xe9, 0xf9, 0xd4, 0x47, 0xcf, 0x69, 0xe9,
0x0d, 0x33, 0xdb, 0x7d, 0x0c, 0xb7, 0x47, 0x71, 0x34, 0x2b, 0x48, 0x4b, 0x4e, 0x17, 0xac, 0x82,
0x2e, 0x0c, 0xff, 0xaa, 0x43, 0x27, 0x21, 0x2e, 0x79, 0xe1, 0x90, 0x19, 0x90, 0x3d, 0x94, 0xbb,
0x51, 0x30, 0x8b, 0x42, 0x0c, 0x65, 0xf2, 0xe7, 0x21, 0x4f, 0x97, 0xfc, 0xb4, 0x17, 0x43, 0x0d,
0x64, 0xf7, 0xa3, 0x25, 0x19, 0xa5, 0x70, 0x77, 0x8d, 0x04, 0x1a, 0xf1, 0x80, 0x07, 0x78, 0xc0,
0xa7, 0xaf, 0x77, 0x4f, 0x58, 0x18, 0xa2, 0x7f, 0x11, 0x62, 0x29, 0x34, 0x45, 0xfc, 0xa0, 0x98,
0x61, 0x8c, 0x57, 0x32, 0xe6, 0xe1, 0x71, 0x3a, 0xf6, 0xee, 0x1a, 0x39, 0x85, 0xbb, 0x7b, 0xa8,
0xd1, 0xb9, 0x90, 0x7c, 0x2a, 0x52, 0xc0, 0xe1, 0x72, 0xc0, 0x85, 0xe0, 0x2b, 0x42, 0x4e, 0xa1,
0x93, 0x7f, 0x54, 0x91, 0x8f, 0xab, 0x26, 0xad, 0xe2, 0x41, 0xd8, 0xed, 0x5f, 0x1e, 0x98, 0x81,
0xfc, 0x00, 0xf0, 0x66, 0x58, 0xc9, 0x6a, 0xc3, 0xbc, 0xd8, 0xa5, 0x72, 0x58, 0xb6, 0x3d, 0x87,
0x8d, 0xe2, 0x6b, 0x84, 0x7c, 0x52, 0x95, 0x5b, 0xf9, 0x56, 0xeb, 0x7e, 0xba, 0x4a, 0x68, 0x06,
0x15, 0xc3, 0xe6, 0x82, 0x6e, 0x91, 0xc7, 0x17, 0x6d, 0x51, 0x96, 0xee, 0xee, 0x93, 0x15, 0xa3,
0x33, 0xcc, 0x7d, 0x68, 0x65, 0xb7, 0x86, 0x3c, 0xaa, 0xca, 0x2e, 0x5f, 0xaa, 0xee, 0x45, 0x8a,
0xe9, 0xae, 0x0d, 0x7f, 0xb7, 0x8d, 0xca, 0xe9, 0x96, 0xbf, 0xbd, 0x56, 0x37, 0x7f, 0xad, 0x0e,
0xa0, 0x9d, 0x7b, 0x99, 0x92, 0xca, 0x59, 0x5e, 0x7c, 0xba, 0x5e, 0xd2, 0xb7, 0x9d, 0xcf, 0xbe,
0x1f, 0x1e, 0x73, 0x79, 0x32, 0x3f, 0x54, 0x2b, 0xdb, 0x49, 0xe8, 0x13, 0x1e, 0x99, 0xaf, 0xed,
0xb4, 0x80, 0x6d, 0x9d, 0xbd, 0xad, 0x51, 0x66, 0x87, 0x87, 0x75, 0x6d, 0x3e, 0xfb, 0x27, 0x00,
0x00, 0xff, 0xff, 0x41, 0x8a, 0x38, 0xec, 0x30, 0x0e, 0x00, 0x00,
0x14, 0xef, 0x7a, 0x1b, 0xff, 0x79, 0x36, 0x51, 0x33, 0x94, 0x6a, 0x71, 0xa9, 0xea, 0x2c, 0x05,
0x0c, 0x6a, 0x9d, 0xca, 0xa5, 0x70, 0x42, 0x82, 0xc4, 0x22, 0xb2, 0x50, 0xab, 0x68, 0x1a, 0x71,
0x40, 0x42, 0xd6, 0xc4, 0xfb, 0x92, 0x8c, 0xba, 0xff, 0xb2, 0x33, 0xae, 0xc8, 0x9d, 0x3b, 0x37,
0x10, 0x1f, 0x04, 0xf1, 0x39, 0x38, 0x70, 0xe2, 0xcb, 0xa0, 0x99, 0x9d, 0xdd, 0xee, 0xae, 0xd7,
0x89, 0x43, 0x0a, 0x27, 0x6e, 0xfb, 0xde, 0xbc, 0x37, 0xbf, 0x79, 0xbf, 0xf7, 0xe6, 0xb7, 0x03,
0x5b, 0x3c, 0xf4, 0xf0, 0x87, 0xd9, 0x3c, 0x8a, 0x12, 0x6f, 0x14, 0x27, 0x91, 0x8c, 0x08, 0x09,
0xb8, 0xff, 0x6a, 0x21, 0x52, 0x6b, 0xa4, 0xd7, 0xfb, 0xbd, 0x79, 0x14, 0x04, 0x51, 0x98, 0xfa,
0xfa, 0x9b, 0x3c, 0x94, 0x98, 0x84, 0xcc, 0x37, 0x76, 0xaf, 0x98, 0xe1, 0xfe, 0x62, 0xc1, 0xdb,
0x14, 0x4f, 0xb8, 0x90, 0x98, 0x3c, 0x8f, 0x3c, 0xa4, 0x78, 0xb6, 0x40, 0x21, 0xc9, 0x63, 0xb8,
0x79, 0xc4, 0x04, 0x3a, 0xd6, 0xc0, 0x1a, 0x76, 0xc7, 0xef, 0x8d, 0x4a, 0x30, 0x66, 0xff, 0x67,
0xe2, 0x64, 0x97, 0x09, 0xa4, 0x3a, 0x92, 0x7c, 0x06, 0x2d, 0xe6, 0x79, 0x09, 0x0a, 0xe1, 0x34,
0x2e, 0x48, 0xfa, 0x2a, 0x8d, 0xa1, 0x59, 0x30, 0xb9, 0x03, 0xcd, 0x30, 0xf2, 0x70, 0x3a, 0x71,
0xec, 0x81, 0x35, 0xb4, 0xa9, 0xb1, 0xdc, 0x9f, 0x2c, 0xb8, 0x5d, 0x3e, 0x99, 0x88, 0xa3, 0x50,
0x20, 0x79, 0x02, 0x4d, 0x21, 0x99, 0x5c, 0x08, 0x73, 0xb8, 0xbb, 0xb5, 0x38, 0x2f, 0x74, 0x08,
0x35, 0xa1, 0x64, 0x17, 0xba, 0x3c, 0xe4, 0x72, 0x16, 0xb3, 0x84, 0x05, 0xd9, 0x09, 0xb7, 0x47,
0x15, 0xf6, 0x0c, 0x51, 0xd3, 0x90, 0xcb, 0x03, 0x1d, 0x48, 0x81, 0xe7, 0xdf, 0xee, 0x17, 0xf0,
0xce, 0x3e, 0xca, 0xa9, 0xe2, 0x58, 0xed, 0x8e, 0x22, 0x23, 0xeb, 0x01, 0xbc, 0xa5, 0x99, 0xdf,
0x5d, 0x70, 0xdf, 0x9b, 0x4e, 0xd4, 0xc1, 0xec, 0xa1, 0x4d, 0xcb, 0x4e, 0xf7, 0x77, 0x0b, 0x3a,
0x3a, 0x79, 0x1a, 0x1e, 0x47, 0xe4, 0x29, 0x6c, 0xa8, 0xa3, 0xa5, 0x0c, 0x6f, 0x8e, 0xef, 0xd7,
0x16, 0xf1, 0x1a, 0x8b, 0xa6, 0xd1, 0xc4, 0x85, 0x5e, 0x71, 0x57, 0x5d, 0x88, 0x4d, 0x4b, 0x3e,
0xe2, 0x40, 0x4b, 0xdb, 0x39, 0xa5, 0x99, 0x49, 0xee, 0x01, 0xa4, 0x23, 0x14, 0xb2, 0x00, 0x9d,
0x9b, 0x03, 0x6b, 0xd8, 0xa1, 0x1d, 0xed, 0x79, 0xce, 0x02, 0x54, 0xad, 0x48, 0x90, 0x89, 0x28,
0x74, 0x36, 0xf4, 0x92, 0xb1, 0xdc, 0x1f, 0x2d, 0xb8, 0x53, 0xad, 0xfc, 0x3a, 0xcd, 0x78, 0x9a,
0x26, 0xa1, 0xea, 0x83, 0x3d, 0xec, 0x8e, 0xef, 0x8d, 0x96, 0xa7, 0x78, 0x94, 0x53, 0x45, 0x4d,
0xb0, 0xfb, 0x47, 0x03, 0xc8, 0x5e, 0x82, 0x4c, 0xa2, 0x5e, 0xcb, 0xd8, 0xaf, 0x52, 0x62, 0xd5,
0x50, 0x52, 0x2e, 0xbc, 0x51, 0x2d, 0x7c, 0x35, 0x63, 0x0e, 0xb4, 0x5e, 0x61, 0x22, 0x78, 0x14,
0x6a, 0xba, 0x6c, 0x9a, 0x99, 0xe4, 0x2e, 0x74, 0x02, 0x94, 0x6c, 0x16, 0x33, 0x79, 0x6a, 0xf8,
0x6a, 0x2b, 0xc7, 0x01, 0x93, 0xa7, 0x0a, 0xcf, 0x63, 0x66, 0x51, 0x38, 0xcd, 0x81, 0xad, 0xf0,
0x94, 0x47, 0xad, 0xea, 0x69, 0x94, 0xe7, 0x31, 0x66, 0xd3, 0xd8, 0xd2, 0x2c, 0x6c, 0xd7, 0x52,
0xf7, 0x0d, 0x9e, 0x7f, 0xcb, 0xfc, 0x05, 0x1e, 0x30, 0x9e, 0x50, 0x50, 0x59, 0xe9, 0x34, 0x92,
0x89, 0x29, 0x3b, 0xdb, 0xa4, 0xbd, 0xee, 0x26, 0x5d, 0x9d, 0x66, 0x66, 0xfa, 0xd7, 0x06, 0x6c,
0xa5, 0x24, 0xfd, 0x67, 0x94, 0x96, 0xb9, 0xd9, 0xb8, 0x84, 0x9b, 0xe6, 0x9b, 0xe0, 0xa6, 0xf5,
0x8f, 0xb8, 0x09, 0x80, 0x14, 0xa9, 0xb9, 0xce, 0xc4, 0xaf, 0x71, 0x6d, 0xdd, 0x2f, 0xc1, 0xc9,
0x2e, 0xd9, 0xd7, 0xdc, 0x47, 0xcd, 0xc6, 0xd5, 0x14, 0xe6, 0x67, 0x0b, 0xb6, 0x4a, 0xf9, 0x5a,
0x69, 0xfe, 0xad, 0x03, 0x93, 0x21, 0xdc, 0x4a, 0x59, 0x3e, 0xe6, 0x3e, 0x9a, 0x76, 0xda, 0xba,
0x9d, 0x9b, 0xbc, 0x54, 0x85, 0x3a, 0xd8, 0xbb, 0x35, 0xb5, 0x5d, 0x87, 0xd1, 0x09, 0x40, 0x01,
0x36, 0xd5, 0x91, 0x0f, 0x56, 0xea, 0x48, 0x91, 0x10, 0xda, 0x39, 0xce, 0x0f, 0xf6, 0x57, 0xc3,
0x68, 0xf2, 0x33, 0x94, 0x6c, 0xad, 0xb1, 0xcf, 0x75, 0xbb, 0x71, 0x25, 0xdd, 0xbe, 0x0f, 0xdd,
0x63, 0xc6, 0xfd, 0x99, 0xd1, 0x57, 0x5b, 0x5f, 0x17, 0x50, 0x2e, 0xaa, 0x3d, 0xe4, 0x73, 0xb0,
0x13, 0x3c, 0xd3, 0x22, 0xb3, 0xa2, 0x90, 0xa5, 0x6b, 0x4a, 0x55, 0x46, 0x6d, 0x17, 0x36, 0xea,
0xba, 0x40, 0xb6, 0xa1, 0x17, 0xb0, 0xe4, 0xe5, 0xcc, 0x43, 0x1f, 0x25, 0x7a, 0x4e, 0x73, 0x60,
0x0d, 0xdb, 0xb4, 0xab, 0x7c, 0x93, 0xd4, 0x55, 0xf8, 0x19, 0xb7, 0x8a, 0x3f, 0xe3, 0xa2, 0x0c,
0xb6, 0xcb, 0x32, 0xd8, 0x87, 0x76, 0x82, 0xf3, 0xf3, 0xb9, 0x8f, 0x9e, 0xd3, 0xd1, 0x1b, 0xe6,
0xb6, 0xfb, 0x10, 0x6e, 0x4d, 0x92, 0x28, 0x2e, 0x49, 0x4b, 0x41, 0x17, 0xac, 0x92, 0x2e, 0x8c,
0xff, 0x6c, 0x02, 0xe8, 0xd0, 0x3d, 0xf5, 0xbe, 0x21, 0x31, 0x90, 0x7d, 0x94, 0x7b, 0x51, 0x10,
0x47, 0x21, 0x86, 0x32, 0xfd, 0xef, 0x90, 0xc7, 0x2b, 0x7e, 0xd9, 0xcb, 0xa1, 0x06, 0xb0, 0xff,
0xe1, 0x8a, 0x8c, 0x4a, 0xb8, 0x7b, 0x83, 0x04, 0x1a, 0xf1, 0x90, 0x07, 0x78, 0xc8, 0xe7, 0x2f,
0xf7, 0x4e, 0x59, 0x18, 0xa2, 0x7f, 0x11, 0x62, 0x25, 0x34, 0x43, 0x7c, 0xbf, 0x9c, 0x61, 0x8c,
0x17, 0x32, 0xe1, 0xe1, 0x49, 0x36, 0xf4, 0xee, 0x0d, 0x72, 0x06, 0xb7, 0xf7, 0x51, 0xa3, 0x73,
0x21, 0xf9, 0x5c, 0x64, 0x80, 0xe3, 0xd5, 0x80, 0x4b, 0xc1, 0x57, 0x84, 0x9c, 0x43, 0xaf, 0xf8,
0xa4, 0x22, 0x1f, 0xd5, 0xcd, 0x59, 0xcd, 0x73, 0xb0, 0x3f, 0xbc, 0x3c, 0x30, 0x07, 0xf9, 0x1e,
0xe0, 0xf5, 0xa8, 0x92, 0xf5, 0x46, 0x79, 0xb9, 0x4b, 0xd5, 0xb0, 0x7c, 0x7b, 0x0e, 0x9b, 0xe5,
0xb7, 0x08, 0xf9, 0xb8, 0x2e, 0xb7, 0xf6, 0xa5, 0xd6, 0xff, 0x64, 0x9d, 0xd0, 0x1c, 0x2a, 0x81,
0xad, 0x25, 0xd5, 0x22, 0x0f, 0x2f, 0xda, 0xa2, 0x2a, 0xdc, 0xfd, 0x47, 0x6b, 0x46, 0xe7, 0x98,
0x07, 0xd0, 0xc9, 0xef, 0x0c, 0x79, 0x50, 0x97, 0x5d, 0xbd, 0x52, 0xfd, 0x8b, 0xf4, 0xd2, 0xbd,
0x31, 0xfe, 0xcd, 0x36, 0x1a, 0xa7, 0x5b, 0xfe, 0xff, 0xb5, 0x7a, 0xf3, 0xd7, 0xea, 0x10, 0xba,
0x85, 0x77, 0x29, 0xa9, 0x9d, 0xe5, 0xe5, 0x87, 0xeb, 0x25, 0x7d, 0xdb, 0xfd, 0xf4, 0xbb, 0xf1,
0x09, 0x97, 0xa7, 0x8b, 0x23, 0xb5, 0xb2, 0x93, 0x86, 0x3e, 0xe2, 0x91, 0xf9, 0xda, 0xc9, 0x0a,
0xd8, 0xd1, 0xd9, 0x3b, 0x1a, 0x25, 0x3e, 0x3a, 0x6a, 0x6a, 0xf3, 0xc9, 0xdf, 0x01, 0x00, 0x00,
0xff, 0xff, 0x85, 0x95, 0xb2, 0x56, 0x2c, 0x0e, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
@ -881,10 +881,10 @@ var _ grpc.ClientConn
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4
// IndexServiceClient is the client API for IndexService service.
// IndexCoordClient is the client API for IndexCoord service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type IndexServiceClient interface {
type IndexCoordClient interface {
GetComponentStates(ctx context.Context, in *internalpb.GetComponentStatesRequest, opts ...grpc.CallOption) (*internalpb.ComponentStates, error)
GetTimeTickChannel(ctx context.Context, in *internalpb.GetTimeTickChannelRequest, opts ...grpc.CallOption) (*milvuspb.StringResponse, error)
GetStatisticsChannel(ctx context.Context, in *internalpb.GetStatisticsChannelRequest, opts ...grpc.CallOption) (*milvuspb.StringResponse, error)
@ -895,88 +895,88 @@ type IndexServiceClient interface {
DropIndex(ctx context.Context, in *DropIndexRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
}
type indexServiceClient struct {
type indexCoordClient struct {
cc *grpc.ClientConn
}
func NewIndexServiceClient(cc *grpc.ClientConn) IndexServiceClient {
return &indexServiceClient{cc}
func NewIndexCoordClient(cc *grpc.ClientConn) IndexCoordClient {
return &indexCoordClient{cc}
}
func (c *indexServiceClient) GetComponentStates(ctx context.Context, in *internalpb.GetComponentStatesRequest, opts ...grpc.CallOption) (*internalpb.ComponentStates, error) {
func (c *indexCoordClient) GetComponentStates(ctx context.Context, in *internalpb.GetComponentStatesRequest, opts ...grpc.CallOption) (*internalpb.ComponentStates, error) {
out := new(internalpb.ComponentStates)
err := c.cc.Invoke(ctx, "/milvus.proto.index.IndexService/GetComponentStates", in, out, opts...)
err := c.cc.Invoke(ctx, "/milvus.proto.index.IndexCoord/GetComponentStates", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *indexServiceClient) GetTimeTickChannel(ctx context.Context, in *internalpb.GetTimeTickChannelRequest, opts ...grpc.CallOption) (*milvuspb.StringResponse, error) {
func (c *indexCoordClient) GetTimeTickChannel(ctx context.Context, in *internalpb.GetTimeTickChannelRequest, opts ...grpc.CallOption) (*milvuspb.StringResponse, error) {
out := new(milvuspb.StringResponse)
err := c.cc.Invoke(ctx, "/milvus.proto.index.IndexService/GetTimeTickChannel", in, out, opts...)
err := c.cc.Invoke(ctx, "/milvus.proto.index.IndexCoord/GetTimeTickChannel", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *indexServiceClient) GetStatisticsChannel(ctx context.Context, in *internalpb.GetStatisticsChannelRequest, opts ...grpc.CallOption) (*milvuspb.StringResponse, error) {
func (c *indexCoordClient) GetStatisticsChannel(ctx context.Context, in *internalpb.GetStatisticsChannelRequest, opts ...grpc.CallOption) (*milvuspb.StringResponse, error) {
out := new(milvuspb.StringResponse)
err := c.cc.Invoke(ctx, "/milvus.proto.index.IndexService/GetStatisticsChannel", in, out, opts...)
err := c.cc.Invoke(ctx, "/milvus.proto.index.IndexCoord/GetStatisticsChannel", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *indexServiceClient) RegisterNode(ctx context.Context, in *RegisterNodeRequest, opts ...grpc.CallOption) (*RegisterNodeResponse, error) {
func (c *indexCoordClient) RegisterNode(ctx context.Context, in *RegisterNodeRequest, opts ...grpc.CallOption) (*RegisterNodeResponse, error) {
out := new(RegisterNodeResponse)
err := c.cc.Invoke(ctx, "/milvus.proto.index.IndexService/RegisterNode", in, out, opts...)
err := c.cc.Invoke(ctx, "/milvus.proto.index.IndexCoord/RegisterNode", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *indexServiceClient) BuildIndex(ctx context.Context, in *BuildIndexRequest, opts ...grpc.CallOption) (*BuildIndexResponse, error) {
func (c *indexCoordClient) BuildIndex(ctx context.Context, in *BuildIndexRequest, opts ...grpc.CallOption) (*BuildIndexResponse, error) {
out := new(BuildIndexResponse)
err := c.cc.Invoke(ctx, "/milvus.proto.index.IndexService/BuildIndex", in, out, opts...)
err := c.cc.Invoke(ctx, "/milvus.proto.index.IndexCoord/BuildIndex", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *indexServiceClient) GetIndexStates(ctx context.Context, in *GetIndexStatesRequest, opts ...grpc.CallOption) (*GetIndexStatesResponse, error) {
func (c *indexCoordClient) GetIndexStates(ctx context.Context, in *GetIndexStatesRequest, opts ...grpc.CallOption) (*GetIndexStatesResponse, error) {
out := new(GetIndexStatesResponse)
err := c.cc.Invoke(ctx, "/milvus.proto.index.IndexService/GetIndexStates", in, out, opts...)
err := c.cc.Invoke(ctx, "/milvus.proto.index.IndexCoord/GetIndexStates", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *indexServiceClient) GetIndexFilePaths(ctx context.Context, in *GetIndexFilePathsRequest, opts ...grpc.CallOption) (*GetIndexFilePathsResponse, error) {
func (c *indexCoordClient) GetIndexFilePaths(ctx context.Context, in *GetIndexFilePathsRequest, opts ...grpc.CallOption) (*GetIndexFilePathsResponse, error) {
out := new(GetIndexFilePathsResponse)
err := c.cc.Invoke(ctx, "/milvus.proto.index.IndexService/GetIndexFilePaths", in, out, opts...)
err := c.cc.Invoke(ctx, "/milvus.proto.index.IndexCoord/GetIndexFilePaths", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *indexServiceClient) DropIndex(ctx context.Context, in *DropIndexRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
func (c *indexCoordClient) DropIndex(ctx context.Context, in *DropIndexRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
out := new(commonpb.Status)
err := c.cc.Invoke(ctx, "/milvus.proto.index.IndexService/DropIndex", in, out, opts...)
err := c.cc.Invoke(ctx, "/milvus.proto.index.IndexCoord/DropIndex", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// IndexServiceServer is the server API for IndexService service.
type IndexServiceServer interface {
// IndexCoordServer is the server API for IndexCoord service.
type IndexCoordServer interface {
GetComponentStates(context.Context, *internalpb.GetComponentStatesRequest) (*internalpb.ComponentStates, error)
GetTimeTickChannel(context.Context, *internalpb.GetTimeTickChannelRequest) (*milvuspb.StringResponse, error)
GetStatisticsChannel(context.Context, *internalpb.GetStatisticsChannelRequest) (*milvuspb.StringResponse, error)
@ -987,222 +987,222 @@ type IndexServiceServer interface {
DropIndex(context.Context, *DropIndexRequest) (*commonpb.Status, error)
}
// UnimplementedIndexServiceServer can be embedded to have forward compatible implementations.
type UnimplementedIndexServiceServer struct {
// UnimplementedIndexCoordServer can be embedded to have forward compatible implementations.
type UnimplementedIndexCoordServer struct {
}
func (*UnimplementedIndexServiceServer) GetComponentStates(ctx context.Context, req *internalpb.GetComponentStatesRequest) (*internalpb.ComponentStates, error) {
func (*UnimplementedIndexCoordServer) GetComponentStates(ctx context.Context, req *internalpb.GetComponentStatesRequest) (*internalpb.ComponentStates, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetComponentStates not implemented")
}
func (*UnimplementedIndexServiceServer) GetTimeTickChannel(ctx context.Context, req *internalpb.GetTimeTickChannelRequest) (*milvuspb.StringResponse, error) {
func (*UnimplementedIndexCoordServer) GetTimeTickChannel(ctx context.Context, req *internalpb.GetTimeTickChannelRequest) (*milvuspb.StringResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetTimeTickChannel not implemented")
}
func (*UnimplementedIndexServiceServer) GetStatisticsChannel(ctx context.Context, req *internalpb.GetStatisticsChannelRequest) (*milvuspb.StringResponse, error) {
func (*UnimplementedIndexCoordServer) GetStatisticsChannel(ctx context.Context, req *internalpb.GetStatisticsChannelRequest) (*milvuspb.StringResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetStatisticsChannel not implemented")
}
func (*UnimplementedIndexServiceServer) RegisterNode(ctx context.Context, req *RegisterNodeRequest) (*RegisterNodeResponse, error) {
func (*UnimplementedIndexCoordServer) RegisterNode(ctx context.Context, req *RegisterNodeRequest) (*RegisterNodeResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method RegisterNode not implemented")
}
func (*UnimplementedIndexServiceServer) BuildIndex(ctx context.Context, req *BuildIndexRequest) (*BuildIndexResponse, error) {
func (*UnimplementedIndexCoordServer) BuildIndex(ctx context.Context, req *BuildIndexRequest) (*BuildIndexResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method BuildIndex not implemented")
}
func (*UnimplementedIndexServiceServer) GetIndexStates(ctx context.Context, req *GetIndexStatesRequest) (*GetIndexStatesResponse, error) {
func (*UnimplementedIndexCoordServer) GetIndexStates(ctx context.Context, req *GetIndexStatesRequest) (*GetIndexStatesResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetIndexStates not implemented")
}
func (*UnimplementedIndexServiceServer) GetIndexFilePaths(ctx context.Context, req *GetIndexFilePathsRequest) (*GetIndexFilePathsResponse, error) {
func (*UnimplementedIndexCoordServer) GetIndexFilePaths(ctx context.Context, req *GetIndexFilePathsRequest) (*GetIndexFilePathsResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetIndexFilePaths not implemented")
}
func (*UnimplementedIndexServiceServer) DropIndex(ctx context.Context, req *DropIndexRequest) (*commonpb.Status, error) {
func (*UnimplementedIndexCoordServer) DropIndex(ctx context.Context, req *DropIndexRequest) (*commonpb.Status, error) {
return nil, status.Errorf(codes.Unimplemented, "method DropIndex not implemented")
}
func RegisterIndexServiceServer(s *grpc.Server, srv IndexServiceServer) {
s.RegisterService(&_IndexService_serviceDesc, srv)
func RegisterIndexCoordServer(s *grpc.Server, srv IndexCoordServer) {
s.RegisterService(&_IndexCoord_serviceDesc, srv)
}
func _IndexService_GetComponentStates_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
func _IndexCoord_GetComponentStates_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(internalpb.GetComponentStatesRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(IndexServiceServer).GetComponentStates(ctx, in)
return srv.(IndexCoordServer).GetComponentStates(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/milvus.proto.index.IndexService/GetComponentStates",
FullMethod: "/milvus.proto.index.IndexCoord/GetComponentStates",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(IndexServiceServer).GetComponentStates(ctx, req.(*internalpb.GetComponentStatesRequest))
return srv.(IndexCoordServer).GetComponentStates(ctx, req.(*internalpb.GetComponentStatesRequest))
}
return interceptor(ctx, in, info, handler)
}
func _IndexService_GetTimeTickChannel_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
func _IndexCoord_GetTimeTickChannel_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(internalpb.GetTimeTickChannelRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(IndexServiceServer).GetTimeTickChannel(ctx, in)
return srv.(IndexCoordServer).GetTimeTickChannel(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/milvus.proto.index.IndexService/GetTimeTickChannel",
FullMethod: "/milvus.proto.index.IndexCoord/GetTimeTickChannel",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(IndexServiceServer).GetTimeTickChannel(ctx, req.(*internalpb.GetTimeTickChannelRequest))
return srv.(IndexCoordServer).GetTimeTickChannel(ctx, req.(*internalpb.GetTimeTickChannelRequest))
}
return interceptor(ctx, in, info, handler)
}
func _IndexService_GetStatisticsChannel_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
func _IndexCoord_GetStatisticsChannel_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(internalpb.GetStatisticsChannelRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(IndexServiceServer).GetStatisticsChannel(ctx, in)
return srv.(IndexCoordServer).GetStatisticsChannel(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/milvus.proto.index.IndexService/GetStatisticsChannel",
FullMethod: "/milvus.proto.index.IndexCoord/GetStatisticsChannel",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(IndexServiceServer).GetStatisticsChannel(ctx, req.(*internalpb.GetStatisticsChannelRequest))
return srv.(IndexCoordServer).GetStatisticsChannel(ctx, req.(*internalpb.GetStatisticsChannelRequest))
}
return interceptor(ctx, in, info, handler)
}
func _IndexService_RegisterNode_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
func _IndexCoord_RegisterNode_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(RegisterNodeRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(IndexServiceServer).RegisterNode(ctx, in)
return srv.(IndexCoordServer).RegisterNode(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/milvus.proto.index.IndexService/RegisterNode",
FullMethod: "/milvus.proto.index.IndexCoord/RegisterNode",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(IndexServiceServer).RegisterNode(ctx, req.(*RegisterNodeRequest))
return srv.(IndexCoordServer).RegisterNode(ctx, req.(*RegisterNodeRequest))
}
return interceptor(ctx, in, info, handler)
}
func _IndexService_BuildIndex_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
func _IndexCoord_BuildIndex_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(BuildIndexRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(IndexServiceServer).BuildIndex(ctx, in)
return srv.(IndexCoordServer).BuildIndex(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/milvus.proto.index.IndexService/BuildIndex",
FullMethod: "/milvus.proto.index.IndexCoord/BuildIndex",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(IndexServiceServer).BuildIndex(ctx, req.(*BuildIndexRequest))
return srv.(IndexCoordServer).BuildIndex(ctx, req.(*BuildIndexRequest))
}
return interceptor(ctx, in, info, handler)
}
func _IndexService_GetIndexStates_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
func _IndexCoord_GetIndexStates_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetIndexStatesRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(IndexServiceServer).GetIndexStates(ctx, in)
return srv.(IndexCoordServer).GetIndexStates(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/milvus.proto.index.IndexService/GetIndexStates",
FullMethod: "/milvus.proto.index.IndexCoord/GetIndexStates",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(IndexServiceServer).GetIndexStates(ctx, req.(*GetIndexStatesRequest))
return srv.(IndexCoordServer).GetIndexStates(ctx, req.(*GetIndexStatesRequest))
}
return interceptor(ctx, in, info, handler)
}
func _IndexService_GetIndexFilePaths_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
func _IndexCoord_GetIndexFilePaths_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetIndexFilePathsRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(IndexServiceServer).GetIndexFilePaths(ctx, in)
return srv.(IndexCoordServer).GetIndexFilePaths(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/milvus.proto.index.IndexService/GetIndexFilePaths",
FullMethod: "/milvus.proto.index.IndexCoord/GetIndexFilePaths",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(IndexServiceServer).GetIndexFilePaths(ctx, req.(*GetIndexFilePathsRequest))
return srv.(IndexCoordServer).GetIndexFilePaths(ctx, req.(*GetIndexFilePathsRequest))
}
return interceptor(ctx, in, info, handler)
}
func _IndexService_DropIndex_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
func _IndexCoord_DropIndex_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(DropIndexRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(IndexServiceServer).DropIndex(ctx, in)
return srv.(IndexCoordServer).DropIndex(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/milvus.proto.index.IndexService/DropIndex",
FullMethod: "/milvus.proto.index.IndexCoord/DropIndex",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(IndexServiceServer).DropIndex(ctx, req.(*DropIndexRequest))
return srv.(IndexCoordServer).DropIndex(ctx, req.(*DropIndexRequest))
}
return interceptor(ctx, in, info, handler)
}
var _IndexService_serviceDesc = grpc.ServiceDesc{
ServiceName: "milvus.proto.index.IndexService",
HandlerType: (*IndexServiceServer)(nil),
var _IndexCoord_serviceDesc = grpc.ServiceDesc{
ServiceName: "milvus.proto.index.IndexCoord",
HandlerType: (*IndexCoordServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "GetComponentStates",
Handler: _IndexService_GetComponentStates_Handler,
Handler: _IndexCoord_GetComponentStates_Handler,
},
{
MethodName: "GetTimeTickChannel",
Handler: _IndexService_GetTimeTickChannel_Handler,
Handler: _IndexCoord_GetTimeTickChannel_Handler,
},
{
MethodName: "GetStatisticsChannel",
Handler: _IndexService_GetStatisticsChannel_Handler,
Handler: _IndexCoord_GetStatisticsChannel_Handler,
},
{
MethodName: "RegisterNode",
Handler: _IndexService_RegisterNode_Handler,
Handler: _IndexCoord_RegisterNode_Handler,
},
{
MethodName: "BuildIndex",
Handler: _IndexService_BuildIndex_Handler,
Handler: _IndexCoord_BuildIndex_Handler,
},
{
MethodName: "GetIndexStates",
Handler: _IndexService_GetIndexStates_Handler,
Handler: _IndexCoord_GetIndexStates_Handler,
},
{
MethodName: "GetIndexFilePaths",
Handler: _IndexService_GetIndexFilePaths_Handler,
Handler: _IndexCoord_GetIndexFilePaths_Handler,
},
{
MethodName: "DropIndex",
Handler: _IndexService_DropIndex_Handler,
Handler: _IndexCoord_DropIndex_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "index_service.proto",
Metadata: "index_coord.proto",
}
// IndexNodeClient is the client API for IndexNode service.
@ -1382,5 +1382,5 @@ var _IndexNode_serviceDesc = grpc.ServiceDesc{
},
},
Streams: []grpc.StreamDesc{},
Metadata: "index_service.proto",
Metadata: "index_coord.proto",
}

2
internal/proto/proxy_service.proto → internal/proto/proxy.proto
View File

@ -7,7 +7,7 @@ import "common.proto";
import "internal.proto";
import "milvus.proto";
service ProxyNodeService {
service Proxy {
rpc GetComponentStates(internal.GetComponentStatesRequest) returns (internal.ComponentStates) {}
rpc GetStatisticsChannel(internal.GetStatisticsChannelRequest) returns(milvus.StringResponse){}

175
internal/proto/proxypb/proxy_service.pb.go → internal/proto/proxypb/proxy.pb.go
View File

@ -1,5 +1,5 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: proxy_service.proto
// source: proxy.proto
package proxypb
@ -40,7 +40,7 @@ func (m *InvalidateCollMetaCacheRequest) Reset() { *m = InvalidateCollMe
func (m *InvalidateCollMetaCacheRequest) String() string { return proto.CompactTextString(m) }
func (*InvalidateCollMetaCacheRequest) ProtoMessage() {}
func (*InvalidateCollMetaCacheRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_34ca2fbc94d169de, []int{0}
return fileDescriptor_700b50b08ed8dbaf, []int{0}
}
func (m *InvalidateCollMetaCacheRequest) XXX_Unmarshal(b []byte) error {
@ -95,7 +95,7 @@ func (m *ReleaseDQLMessageStreamRequest) Reset() { *m = ReleaseDQLMessag
func (m *ReleaseDQLMessageStreamRequest) String() string { return proto.CompactTextString(m) }
func (*ReleaseDQLMessageStreamRequest) ProtoMessage() {}
func (*ReleaseDQLMessageStreamRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_34ca2fbc94d169de, []int{1}
return fileDescriptor_700b50b08ed8dbaf, []int{1}
}
func (m *ReleaseDQLMessageStreamRequest) XXX_Unmarshal(b []byte) error {
@ -142,37 +142,36 @@ func init() {
proto.RegisterType((*ReleaseDQLMessageStreamRequest)(nil), "milvus.proto.proxy.ReleaseDQLMessageStreamRequest")
}
func init() { proto.RegisterFile("proxy_service.proto", fileDescriptor_34ca2fbc94d169de) }
func init() { proto.RegisterFile("proxy.proto", fileDescriptor_700b50b08ed8dbaf) }
var fileDescriptor_34ca2fbc94d169de = []byte{
// 428 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x92, 0xd1, 0x8a, 0xd3, 0x40,
0x14, 0x86, 0x37, 0xb6, 0xac, 0x38, 0x86, 0x55, 0x46, 0x61, 0x97, 0xa8, 0x4b, 0x89, 0xa0, 0x45,
0x30, 0x29, 0xd1, 0x27, 0x68, 0x02, 0xa5, 0x60, 0x8b, 0x26, 0x77, 0xde, 0x94, 0x49, 0x72, 0x48,
0x07, 0x26, 0x33, 0x69, 0x66, 0x52, 0xf4, 0x15, 0xbc, 0xf6, 0x71, 0x7c, 0x38, 0xc9, 0x24, 0x6d,
0x4d, 0xdb, 0x54, 0xf4, 0x6e, 0xce, 0xc9, 0x77, 0xf8, 0xcf, 0x7f, 0xf2, 0xa3, 0x67, 0x45, 0x29,
0xbe, 0x7d, 0x5f, 0x49, 0x28, 0xb7, 0x34, 0x01, 0xa7, 0x28, 0x85, 0x12, 0x18, 0xe7, 0x94, 0x6d,
0x2b, 0xd9, 0x54, 0x8e, 0x26, 0x2c, 0x33, 0x11, 0x79, 0x2e, 0x78, 0xd3, 0xb3, 0x6e, 0x28, 0x57,
0x50, 0x72, 0xc2, 0xda, 0xda, 0xfc, 0x73, 0xc2, 0xfe, 0x69, 0xa0, 0xfb, 0x39, 0xdf, 0x12, 0x46,
0x53, 0xa2, 0xc0, 0x17, 0x8c, 0x2d, 0x40, 0x11, 0x9f, 0x24, 0x6b, 0x08, 0x61, 0x53, 0x81, 0x54,
0x78, 0x82, 0x86, 0x31, 0x91, 0x70, 0x67, 0x8c, 0x8c, 0xf1, 0x63, 0xef, 0xa5, 0xd3, 0x51, 0x6c,
0xa5, 0x16, 0x32, 0x9b, 0x12, 0x09, 0xa1, 0x26, 0xf1, 0x2d, 0x7a, 0x98, 0xc6, 0x2b, 0x4e, 0x72,
0xb8, 0x7b, 0x30, 0x32, 0xc6, 0x8f, 0xc2, 0xeb, 0x34, 0x5e, 0x92, 0x1c, 0xf0, 0x5b, 0xf4, 0x24,
0x11, 0x8c, 0x41, 0xa2, 0xa8, 0xe0, 0x0d, 0x30, 0xd0, 0xc0, 0xcd, 0xa1, 0x5d, 0x83, 0xf6, 0x0f,
0x03, 0xdd, 0x87, 0xc0, 0x80, 0x48, 0x08, 0xbe, 0x7c, 0x5a, 0x80, 0x94, 0x24, 0x83, 0x48, 0x95,
0x40, 0xf2, 0xff, 0x5f, 0x0b, 0xa3, 0x61, 0x1a, 0xcf, 0x03, 0xbd, 0xd3, 0x20, 0xd4, 0x6f, 0x6c,
0x23, 0xf3, 0x20, 0x3d, 0x0f, 0xf4, 0x3a, 0x83, 0xb0, 0xd3, 0xf3, 0x7e, 0x0d, 0xd1, 0xd3, 0xcf,
0xf5, 0x65, 0x97, 0x22, 0x85, 0xa8, 0x39, 0x3f, 0x2e, 0x10, 0x9e, 0x81, 0xf2, 0x45, 0x5e, 0x08,
0x0e, 0x5c, 0x45, 0x8a, 0x28, 0x90, 0x78, 0xd2, 0x5d, 0x63, 0x7f, 0xfa, 0x53, 0xb4, 0xb5, 0x61,
0xbd, 0xe9, 0x99, 0x38, 0xc2, 0xed, 0x2b, 0xbc, 0x41, 0xcf, 0x67, 0xa0, 0x4b, 0x2a, 0x15, 0x4d,
0xa4, 0xbf, 0x26, 0x9c, 0x03, 0xc3, 0x5e, 0xbf, 0xe6, 0x09, 0xbc, 0x53, 0x7d, 0xdd, 0x9d, 0x69,
0x8b, 0x48, 0x95, 0x94, 0x67, 0x21, 0xc8, 0x42, 0x70, 0x09, 0xf6, 0x15, 0x2e, 0xd1, 0xab, 0x6e,
0x38, 0x9a, 0x9b, 0xec, 0x23, 0x72, 0xac, 0xad, 0xf3, 0xe7, 0x5c, 0xce, 0x93, 0xf5, 0xe2, 0xec,
0xaf, 0xaa, 0x57, 0xad, 0x6a, 0x9b, 0x04, 0x99, 0x33, 0x50, 0x41, 0xba, 0xb3, 0xf7, 0xae, 0xdf,
0xde, 0x1e, 0xfa, 0x47, 0x5b, 0x0c, 0xdd, 0xf6, 0x84, 0xeb, 0xbc, 0xa1, 0xcb, 0x49, 0xfc, 0x8b,
0xa1, 0xe9, 0xc7, 0xaf, 0x5e, 0x46, 0xd5, 0xba, 0x8a, 0xeb, 0x2f, 0x6e, 0x83, 0xbe, 0xa7, 0xa2,
0x7d, 0xb9, 0x3b, 0x43, 0xae, 0x9e, 0x76, 0xb5, 0x62, 0x11, 0xc7, 0xd7, 0xba, 0xfc, 0xf0, 0x3b,
0x00, 0x00, 0xff, 0xff, 0x1b, 0x9a, 0x9b, 0xba, 0xf6, 0x03, 0x00, 0x00,
var fileDescriptor_700b50b08ed8dbaf = []byte{
// 413 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x52, 0xd1, 0x0a, 0xd3, 0x30,
0x14, 0x5d, 0xdd, 0x9c, 0x98, 0x95, 0x09, 0x41, 0xd8, 0xa8, 0x3a, 0x46, 0x05, 0x1d, 0x82, 0xeb,
0xa8, 0x7e, 0xc1, 0x5a, 0x18, 0x03, 0x27, 0xda, 0xbd, 0xf9, 0x22, 0x69, 0x7b, 0xe9, 0x02, 0x69,
0xd2, 0x35, 0xe9, 0xd0, 0x5f, 0xf0, 0xd9, 0x1f, 0xf1, 0x0f, 0xa5, 0x69, 0xb7, 0xd9, 0x6d, 0x9d,
0xe8, 0x5b, 0xcf, 0xcd, 0xb9, 0x9c, 0x73, 0x6e, 0x0f, 0x1a, 0x64, 0xb9, 0xf8, 0xf6, 0x7d, 0x9e,
0xe5, 0x42, 0x09, 0x8c, 0x53, 0xca, 0x0e, 0x85, 0xac, 0xd0, 0x5c, 0xbf, 0x58, 0x66, 0x24, 0xd2,
0x54, 0xf0, 0x6a, 0x66, 0x0d, 0x29, 0x57, 0x90, 0x73, 0xc2, 0x6a, 0x6c, 0xfe, 0xb9, 0x61, 0xff,
0x34, 0xd0, 0x64, 0xcd, 0x0f, 0x84, 0xd1, 0x98, 0x28, 0xf0, 0x04, 0x63, 0x1b, 0x50, 0xc4, 0x23,
0xd1, 0x0e, 0x02, 0xd8, 0x17, 0x20, 0x15, 0x5e, 0xa0, 0x5e, 0x48, 0x24, 0x8c, 0x8d, 0xa9, 0x31,
0x1b, 0xb8, 0xcf, 0xe7, 0x0d, 0xc5, 0x5a, 0x6a, 0x23, 0x93, 0x25, 0x91, 0x10, 0x68, 0x26, 0x1e,
0xa1, 0x47, 0x71, 0xf8, 0x95, 0x93, 0x14, 0xc6, 0x0f, 0xa6, 0xc6, 0xec, 0x71, 0xd0, 0x8f, 0xc3,
0x8f, 0x24, 0x05, 0xfc, 0x1a, 0x3d, 0x89, 0x04, 0x63, 0x10, 0x29, 0x2a, 0x78, 0x45, 0xe8, 0x6a,
0xc2, 0xf0, 0x3c, 0x2e, 0x89, 0xf6, 0x0f, 0x03, 0x4d, 0x02, 0x60, 0x40, 0x24, 0xf8, 0x9f, 0x3f,
0x6c, 0x40, 0x4a, 0x92, 0xc0, 0x56, 0xe5, 0x40, 0xd2, 0xff, 0xb7, 0x85, 0x51, 0x2f, 0x0e, 0xd7,
0xbe, 0xf6, 0xd4, 0x0d, 0xf4, 0x37, 0xb6, 0x91, 0x79, 0x96, 0x5e, 0xfb, 0xda, 0x4e, 0x37, 0x68,
0xcc, 0xdc, 0x5f, 0x3d, 0xf4, 0xf0, 0x53, 0x79, 0x59, 0x9c, 0x21, 0xbc, 0x02, 0xe5, 0x89, 0x34,
0x13, 0x1c, 0xb8, 0xda, 0x2a, 0xa2, 0x40, 0xe2, 0x45, 0x53, 0xfb, 0x74, 0xef, 0x6b, 0x6a, 0xed,
0xdd, 0x7a, 0xd5, 0xb2, 0x71, 0x41, 0xb7, 0x3b, 0x78, 0x8f, 0x9e, 0xae, 0x40, 0x43, 0x2a, 0x15,
0x8d, 0xa4, 0xb7, 0x23, 0x9c, 0x03, 0xc3, 0x6e, 0xbb, 0xe6, 0x15, 0xf9, 0xa8, 0xfa, 0xb2, 0xb9,
0x53, 0x83, 0xad, 0xca, 0x29, 0x4f, 0x02, 0x90, 0x99, 0xe0, 0x12, 0xec, 0x0e, 0xce, 0xd1, 0x8b,
0x66, 0x23, 0xaa, 0x43, 0x9c, 0x7a, 0x71, 0xa9, 0x5d, 0xd5, 0xf1, 0x7e, 0x89, 0xac, 0x67, 0x37,
0xff, 0x4f, 0x69, 0xb5, 0x28, 0x63, 0x12, 0x64, 0xae, 0x40, 0xf9, 0xf1, 0x31, 0xde, 0x9b, 0xf6,
0x78, 0x27, 0xd2, 0x3f, 0xc6, 0x62, 0x68, 0xd4, 0xd2, 0xa8, 0xdb, 0x81, 0xee, 0xd7, 0xef, 0x2f,
0x81, 0x96, 0xef, 0xbf, 0xb8, 0x09, 0x55, 0xbb, 0x22, 0x2c, 0x5f, 0x9c, 0x8a, 0xfa, 0x96, 0x8a,
0xfa, 0xcb, 0x39, 0x06, 0x72, 0xf4, 0xb6, 0xa3, 0x15, 0xb3, 0x30, 0xec, 0x6b, 0xf8, 0xee, 0x77,
0x00, 0x00, 0x00, 0xff, 0xff, 0x46, 0xe1, 0x7c, 0xd9, 0xe3, 0x03, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
@ -183,10 +182,10 @@ var _ grpc.ClientConn
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4
// ProxyNodeServiceClient is the client API for ProxyNodeService service.
// ProxyClient is the client API for Proxy service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type ProxyNodeServiceClient interface {
type ProxyClient interface {
GetComponentStates(ctx context.Context, in *internalpb.GetComponentStatesRequest, opts ...grpc.CallOption) (*internalpb.ComponentStates, error)
GetStatisticsChannel(ctx context.Context, in *internalpb.GetStatisticsChannelRequest, opts ...grpc.CallOption) (*milvuspb.StringResponse, error)
InvalidateCollectionMetaCache(ctx context.Context, in *InvalidateCollMetaCacheRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
@ -194,61 +193,61 @@ type ProxyNodeServiceClient interface {
ReleaseDQLMessageStream(ctx context.Context, in *ReleaseDQLMessageStreamRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
}
type proxyNodeServiceClient struct {
type proxyClient struct {
cc *grpc.ClientConn
}
func NewProxyNodeServiceClient(cc *grpc.ClientConn) ProxyNodeServiceClient {
return &proxyNodeServiceClient{cc}
func NewProxyClient(cc *grpc.ClientConn) ProxyClient {
return &proxyClient{cc}
}
func (c *proxyNodeServiceClient) GetComponentStates(ctx context.Context, in *internalpb.GetComponentStatesRequest, opts ...grpc.CallOption) (*internalpb.ComponentStates, error) {
func (c *proxyClient) GetComponentStates(ctx context.Context, in *internalpb.GetComponentStatesRequest, opts ...grpc.CallOption) (*internalpb.ComponentStates, error) {
out := new(internalpb.ComponentStates)
err := c.cc.Invoke(ctx, "/milvus.proto.proxy.ProxyNodeService/GetComponentStates", in, out, opts...)
err := c.cc.Invoke(ctx, "/milvus.proto.proxy.Proxy/GetComponentStates", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *proxyNodeServiceClient) GetStatisticsChannel(ctx context.Context, in *internalpb.GetStatisticsChannelRequest, opts ...grpc.CallOption) (*milvuspb.StringResponse, error) {
func (c *proxyClient) GetStatisticsChannel(ctx context.Context, in *internalpb.GetStatisticsChannelRequest, opts ...grpc.CallOption) (*milvuspb.StringResponse, error) {
out := new(milvuspb.StringResponse)
err := c.cc.Invoke(ctx, "/milvus.proto.proxy.ProxyNodeService/GetStatisticsChannel", in, out, opts...)
err := c.cc.Invoke(ctx, "/milvus.proto.proxy.Proxy/GetStatisticsChannel", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *proxyNodeServiceClient) InvalidateCollectionMetaCache(ctx context.Context, in *InvalidateCollMetaCacheRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
func (c *proxyClient) InvalidateCollectionMetaCache(ctx context.Context, in *InvalidateCollMetaCacheRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
out := new(commonpb.Status)
err := c.cc.Invoke(ctx, "/milvus.proto.proxy.ProxyNodeService/InvalidateCollectionMetaCache", in, out, opts...)
err := c.cc.Invoke(ctx, "/milvus.proto.proxy.Proxy/InvalidateCollectionMetaCache", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *proxyNodeServiceClient) GetDdChannel(ctx context.Context, in *internalpb.GetDdChannelRequest, opts ...grpc.CallOption) (*milvuspb.StringResponse, error) {
func (c *proxyClient) GetDdChannel(ctx context.Context, in *internalpb.GetDdChannelRequest, opts ...grpc.CallOption) (*milvuspb.StringResponse, error) {
out := new(milvuspb.StringResponse)
err := c.cc.Invoke(ctx, "/milvus.proto.proxy.ProxyNodeService/GetDdChannel", in, out, opts...)
err := c.cc.Invoke(ctx, "/milvus.proto.proxy.Proxy/GetDdChannel", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *proxyNodeServiceClient) ReleaseDQLMessageStream(ctx context.Context, in *ReleaseDQLMessageStreamRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
func (c *proxyClient) ReleaseDQLMessageStream(ctx context.Context, in *ReleaseDQLMessageStreamRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
out := new(commonpb.Status)
err := c.cc.Invoke(ctx, "/milvus.proto.proxy.ProxyNodeService/ReleaseDQLMessageStream", in, out, opts...)
err := c.cc.Invoke(ctx, "/milvus.proto.proxy.Proxy/ReleaseDQLMessageStream", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// ProxyNodeServiceServer is the server API for ProxyNodeService service.
type ProxyNodeServiceServer interface {
// ProxyServer is the server API for Proxy service.
type ProxyServer interface {
GetComponentStates(context.Context, *internalpb.GetComponentStatesRequest) (*internalpb.ComponentStates, error)
GetStatisticsChannel(context.Context, *internalpb.GetStatisticsChannelRequest) (*milvuspb.StringResponse, error)
InvalidateCollectionMetaCache(context.Context, *InvalidateCollMetaCacheRequest) (*commonpb.Status, error)
@ -256,145 +255,145 @@ type ProxyNodeServiceServer interface {
ReleaseDQLMessageStream(context.Context, *ReleaseDQLMessageStreamRequest) (*commonpb.Status, error)
}
// UnimplementedProxyNodeServiceServer can be embedded to have forward compatible implementations.
type UnimplementedProxyNodeServiceServer struct {
// UnimplementedProxyServer can be embedded to have forward compatible implementations.
type UnimplementedProxyServer struct {
}
func (*UnimplementedProxyNodeServiceServer) GetComponentStates(ctx context.Context, req *internalpb.GetComponentStatesRequest) (*internalpb.ComponentStates, error) {
func (*UnimplementedProxyServer) GetComponentStates(ctx context.Context, req *internalpb.GetComponentStatesRequest) (*internalpb.ComponentStates, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetComponentStates not implemented")
}
func (*UnimplementedProxyNodeServiceServer) GetStatisticsChannel(ctx context.Context, req *internalpb.GetStatisticsChannelRequest) (*milvuspb.StringResponse, error) {
func (*UnimplementedProxyServer) GetStatisticsChannel(ctx context.Context, req *internalpb.GetStatisticsChannelRequest) (*milvuspb.StringResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetStatisticsChannel not implemented")
}
func (*UnimplementedProxyNodeServiceServer) InvalidateCollectionMetaCache(ctx context.Context, req *InvalidateCollMetaCacheRequest) (*commonpb.Status, error) {
func (*UnimplementedProxyServer) InvalidateCollectionMetaCache(ctx context.Context, req *InvalidateCollMetaCacheRequest) (*commonpb.Status, error) {
return nil, status.Errorf(codes.Unimplemented, "method InvalidateCollectionMetaCache not implemented")
}
func (*UnimplementedProxyNodeServiceServer) GetDdChannel(ctx context.Context, req *internalpb.GetDdChannelRequest) (*milvuspb.StringResponse, error) {
func (*UnimplementedProxyServer) GetDdChannel(ctx context.Context, req *internalpb.GetDdChannelRequest) (*milvuspb.StringResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetDdChannel not implemented")
}
func (*UnimplementedProxyNodeServiceServer) ReleaseDQLMessageStream(ctx context.Context, req *ReleaseDQLMessageStreamRequest) (*commonpb.Status, error) {
func (*UnimplementedProxyServer) ReleaseDQLMessageStream(ctx context.Context, req *ReleaseDQLMessageStreamRequest) (*commonpb.Status, error) {
return nil, status.Errorf(codes.Unimplemented, "method ReleaseDQLMessageStream not implemented")
}
func RegisterProxyNodeServiceServer(s *grpc.Server, srv ProxyNodeServiceServer) {
s.RegisterService(&_ProxyNodeService_serviceDesc, srv)
func RegisterProxyServer(s *grpc.Server, srv ProxyServer) {
s.RegisterService(&_Proxy_serviceDesc, srv)
}
func _ProxyNodeService_GetComponentStates_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
func _Proxy_GetComponentStates_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(internalpb.GetComponentStatesRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ProxyNodeServiceServer).GetComponentStates(ctx, in)
return srv.(ProxyServer).GetComponentStates(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/milvus.proto.proxy.ProxyNodeService/GetComponentStates",
FullMethod: "/milvus.proto.proxy.Proxy/GetComponentStates",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ProxyNodeServiceServer).GetComponentStates(ctx, req.(*internalpb.GetComponentStatesRequest))
return srv.(ProxyServer).GetComponentStates(ctx, req.(*internalpb.GetComponentStatesRequest))
}
return interceptor(ctx, in, info, handler)
}
func _ProxyNodeService_GetStatisticsChannel_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
func _Proxy_GetStatisticsChannel_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(internalpb.GetStatisticsChannelRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ProxyNodeServiceServer).GetStatisticsChannel(ctx, in)
return srv.(ProxyServer).GetStatisticsChannel(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/milvus.proto.proxy.ProxyNodeService/GetStatisticsChannel",
FullMethod: "/milvus.proto.proxy.Proxy/GetStatisticsChannel",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ProxyNodeServiceServer).GetStatisticsChannel(ctx, req.(*internalpb.GetStatisticsChannelRequest))
return srv.(ProxyServer).GetStatisticsChannel(ctx, req.(*internalpb.GetStatisticsChannelRequest))
}
return interceptor(ctx, in, info, handler)
}
func _ProxyNodeService_InvalidateCollectionMetaCache_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
func _Proxy_InvalidateCollectionMetaCache_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(InvalidateCollMetaCacheRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ProxyNodeServiceServer).InvalidateCollectionMetaCache(ctx, in)
return srv.(ProxyServer).InvalidateCollectionMetaCache(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/milvus.proto.proxy.ProxyNodeService/InvalidateCollectionMetaCache",
FullMethod: "/milvus.proto.proxy.Proxy/InvalidateCollectionMetaCache",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ProxyNodeServiceServer).InvalidateCollectionMetaCache(ctx, req.(*InvalidateCollMetaCacheRequest))
return srv.(ProxyServer).InvalidateCollectionMetaCache(ctx, req.(*InvalidateCollMetaCacheRequest))
}
return interceptor(ctx, in, info, handler)
}
func _ProxyNodeService_GetDdChannel_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
func _Proxy_GetDdChannel_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(internalpb.GetDdChannelRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ProxyNodeServiceServer).GetDdChannel(ctx, in)
return srv.(ProxyServer).GetDdChannel(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/milvus.proto.proxy.ProxyNodeService/GetDdChannel",
FullMethod: "/milvus.proto.proxy.Proxy/GetDdChannel",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ProxyNodeServiceServer).GetDdChannel(ctx, req.(*internalpb.GetDdChannelRequest))
return srv.(ProxyServer).GetDdChannel(ctx, req.(*internalpb.GetDdChannelRequest))
}
return interceptor(ctx, in, info, handler)
}
func _ProxyNodeService_ReleaseDQLMessageStream_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
func _Proxy_ReleaseDQLMessageStream_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ReleaseDQLMessageStreamRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ProxyNodeServiceServer).ReleaseDQLMessageStream(ctx, in)
return srv.(ProxyServer).ReleaseDQLMessageStream(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/milvus.proto.proxy.ProxyNodeService/ReleaseDQLMessageStream",
FullMethod: "/milvus.proto.proxy.Proxy/ReleaseDQLMessageStream",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ProxyNodeServiceServer).ReleaseDQLMessageStream(ctx, req.(*ReleaseDQLMessageStreamRequest))
return srv.(ProxyServer).ReleaseDQLMessageStream(ctx, req.(*ReleaseDQLMessageStreamRequest))
}
return interceptor(ctx, in, info, handler)
}
var _ProxyNodeService_serviceDesc = grpc.ServiceDesc{
ServiceName: "milvus.proto.proxy.ProxyNodeService",
HandlerType: (*ProxyNodeServiceServer)(nil),
var _Proxy_serviceDesc = grpc.ServiceDesc{
ServiceName: "milvus.proto.proxy.Proxy",
HandlerType: (*ProxyServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "GetComponentStates",
Handler: _ProxyNodeService_GetComponentStates_Handler,
Handler: _Proxy_GetComponentStates_Handler,
},
{
MethodName: "GetStatisticsChannel",
Handler: _ProxyNodeService_GetStatisticsChannel_Handler,
Handler: _Proxy_GetStatisticsChannel_Handler,
},
{
MethodName: "InvalidateCollectionMetaCache",
Handler: _ProxyNodeService_InvalidateCollectionMetaCache_Handler,
Handler: _Proxy_InvalidateCollectionMetaCache_Handler,
},
{
MethodName: "GetDdChannel",
Handler: _ProxyNodeService_GetDdChannel_Handler,
Handler: _Proxy_GetDdChannel_Handler,
},
{
MethodName: "ReleaseDQLMessageStream",
Handler: _ProxyNodeService_ReleaseDQLMessageStream_Handler,
Handler: _Proxy_ReleaseDQLMessageStream_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "proxy_service.proto",
Metadata: "proxy.proto",
}

8
internal/proto/master.proto → internal/proto/root_coord.proto
View File

@ -1,14 +1,14 @@
syntax = "proto3";
package milvus.proto.master;
package milvus.proto.rootcoord;
option go_package="github.com/milvus-io/milvus/internal/proto/masterpb";
option go_package="github.com/milvus-io/milvus/internal/proto/rootcoordpb";
import "common.proto";
import "milvus.proto";
import "internal.proto";
import "proxy_service.proto";
import "proxy.proto";
service MasterService {
service RootCoord {
rpc GetComponentStates(internal.GetComponentStatesRequest) returns (internal.ComponentStates) {}
rpc GetTimeTickChannel(internal.GetTimeTickChannelRequest) returns(milvus.StringResponse) {}
rpc GetStatisticsChannel(internal.GetStatisticsChannelRequest) returns(milvus.StringResponse){}

484
internal/proto/masterpb/master.pb.go → internal/proto/rootcoordpb/root_coord.pb.go
View File

File diff suppressed because it is too large Load Diff

4
internal/proxy/timestamp.go
View File

@ -17,7 +17,7 @@ import (
"time"
"github.com/milvus-io/milvus/internal/proto/commonpb"
"github.com/milvus-io/milvus/internal/proto/masterpb"
"github.com/milvus-io/milvus/internal/proto/rootcoordpb"
"github.com/milvus-io/milvus/internal/types"
)
@ -38,7 +38,7 @@ func NewTimestampAllocator(ctx context.Context, rc types.RootCoord, peerID Uniqu
func (ta *TimestampAllocator) Alloc(count uint32) ([]Timestamp, error) {
ctx, cancel := context.WithTimeout(ta.ctx, 5*time.Second)
req := &masterpb.AllocTimestampRequest{
req := &rootcoordpb.AllocTimestampRequest{
Base: &commonpb.MsgBase{
MsgType: commonpb.MsgType_RequestTSO,
MsgID: 0,

26
internal/rootcoord/root_coord.go
View File

@ -32,10 +32,10 @@ import (
"github.com/milvus-io/milvus/internal/proto/etcdpb"
"github.com/milvus-io/milvus/internal/proto/indexpb"
"github.com/milvus-io/milvus/internal/proto/internalpb"
"github.com/milvus-io/milvus/internal/proto/masterpb"
"github.com/milvus-io/milvus/internal/proto/milvuspb"
"github.com/milvus-io/milvus/internal/proto/proxypb"
"github.com/milvus-io/milvus/internal/proto/querypb"
"github.com/milvus-io/milvus/internal/proto/rootcoordpb"
"github.com/milvus-io/milvus/internal/proto/schemapb"
"github.com/milvus-io/milvus/internal/tso"
"github.com/milvus-io/milvus/internal/types"
@ -47,14 +47,6 @@ import (
"go.uber.org/zap"
)
// internalpb -> internalpb
// proxypb(proxy_service)
// querypb(query_service)
// datapb(data_service)
// indexpb(index_service)
// milvuspb -> milvuspb
// masterpb2 -> masterpb (master_service)
// ------------------ struct -----------------------
// DdOperation used to save ddMsg into ETCD
@ -1826,10 +1818,10 @@ func (c *Core) ShowSegments(ctx context.Context, in *milvuspb.ShowSegmentsReques
return t.Rsp, nil
}
func (c *Core) AllocTimestamp(ctx context.Context, in *masterpb.AllocTimestampRequest) (*masterpb.AllocTimestampResponse, error) {
func (c *Core) AllocTimestamp(ctx context.Context, in *rootcoordpb.AllocTimestampRequest) (*rootcoordpb.AllocTimestampResponse, error) {
code := c.stateCode.Load().(internalpb.StateCode)
if code != internalpb.StateCode_Healthy {
return &masterpb.AllocTimestampResponse{
return &rootcoordpb.AllocTimestampResponse{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: fmt.Sprintf("state code = %s", internalpb.StateCode_name[int32(code)]),
@ -1841,7 +1833,7 @@ func (c *Core) AllocTimestamp(ctx context.Context, in *masterpb.AllocTimestampRe
ts, err := c.TSOAllocator(in.Count)
if err != nil {
log.Debug("AllocTimestamp failed", zap.Int64("msgID", in.Base.MsgID), zap.Error(err))
return &masterpb.AllocTimestampResponse{
return &rootcoordpb.AllocTimestampResponse{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: "AllocTimestamp failed: " + err.Error(),
@ -1851,7 +1843,7 @@ func (c *Core) AllocTimestamp(ctx context.Context, in *masterpb.AllocTimestampRe
}, nil
}
// log.Printf("AllocTimestamp : %d", ts)
return &masterpb.AllocTimestampResponse{
return &rootcoordpb.AllocTimestampResponse{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_Success,
Reason: "",
@ -1861,10 +1853,10 @@ func (c *Core) AllocTimestamp(ctx context.Context, in *masterpb.AllocTimestampRe
}, nil
}
func (c *Core) AllocID(ctx context.Context, in *masterpb.AllocIDRequest) (*masterpb.AllocIDResponse, error) {
func (c *Core) AllocID(ctx context.Context, in *rootcoordpb.AllocIDRequest) (*rootcoordpb.AllocIDResponse, error) {
code := c.stateCode.Load().(internalpb.StateCode)
if code != internalpb.StateCode_Healthy {
return &masterpb.AllocIDResponse{
return &rootcoordpb.AllocIDResponse{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: fmt.Sprintf("state code = %s", internalpb.StateCode_name[int32(code)]),
@ -1876,7 +1868,7 @@ func (c *Core) AllocID(ctx context.Context, in *masterpb.AllocIDRequest) (*maste
start, _, err := c.IDAllocator(in.Count)
if err != nil {
log.Debug("AllocID failed", zap.Int64("msgID", in.Base.MsgID), zap.Error(err))
return &masterpb.AllocIDResponse{
return &rootcoordpb.AllocIDResponse{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: "AllocID failed: " + err.Error(),
@ -1886,7 +1878,7 @@ func (c *Core) AllocID(ctx context.Context, in *masterpb.AllocIDRequest) (*maste
}, nil
}
log.Debug("AllocID", zap.Int64("id start", start), zap.Uint32("count", in.Count))
return &masterpb.AllocIDResponse{
return &rootcoordpb.AllocIDResponse{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_Success,
Reason: "",

10
internal/rootcoord/root_coord_test.go
View File

@ -29,10 +29,10 @@ import (
"github.com/milvus-io/milvus/internal/proto/etcdpb"
"github.com/milvus-io/milvus/internal/proto/indexpb"
"github.com/milvus-io/milvus/internal/proto/internalpb"
"github.com/milvus-io/milvus/internal/proto/masterpb"
"github.com/milvus-io/milvus/internal/proto/milvuspb"
"github.com/milvus-io/milvus/internal/proto/proxypb"
"github.com/milvus-io/milvus/internal/proto/querypb"
"github.com/milvus-io/milvus/internal/proto/rootcoordpb"
"github.com/milvus-io/milvus/internal/proto/schemapb"
"github.com/milvus-io/milvus/internal/types"
"github.com/milvus-io/milvus/internal/util/sessionutil"
@ -1429,7 +1429,7 @@ func TestMasterService(t *testing.T) {
})
t.Run("alloc time tick", func(t *testing.T) {
req := &masterpb.AllocTimestampRequest{
req := &rootcoordpb.AllocTimestampRequest{
Base: &commonpb.MsgBase{
MsgType: commonpb.MsgType_Undefined,
MsgID: 3000,
@ -1445,7 +1445,7 @@ func TestMasterService(t *testing.T) {
})
t.Run("alloc id", func(t *testing.T) {
req := &masterpb.AllocIDRequest{
req := &rootcoordpb.AllocIDRequest{
Base: &commonpb.MsgBase{
MsgType: commonpb.MsgType_Undefined,
MsgID: 3001,
@ -1716,7 +1716,7 @@ func TestMasterService(t *testing.T) {
core.TSOAllocator = func(count uint32) (typeutil.Timestamp, error) {
return 0, fmt.Errorf("tso allcoator error test")
}
r1 := &masterpb.AllocTimestampRequest{
r1 := &rootcoordpb.AllocTimestampRequest{
Base: &commonpb.MsgBase{
MsgType: commonpb.MsgType_Undefined,
MsgID: 5000,
@ -1729,7 +1729,7 @@ func TestMasterService(t *testing.T) {
assert.Nil(t, err)
assert.NotEqual(t, commonpb.ErrorCode_Success, p1.Status.ErrorCode)
r2 := &masterpb.AllocIDRequest{
r2 := &rootcoordpb.AllocIDRequest{
Base: &commonpb.MsgBase{
MsgType: commonpb.MsgType_Undefined,
MsgID: 3001,

4
internal/rootcoord/timestamp_test.go
View File

@ -22,9 +22,9 @@ import (
"github.com/milvus-io/milvus/internal/proto/commonpb"
"github.com/milvus-io/milvus/internal/proto/datapb"
"github.com/milvus-io/milvus/internal/proto/indexpb"
"github.com/milvus-io/milvus/internal/proto/masterpb"
"github.com/milvus-io/milvus/internal/proto/milvuspb"
"github.com/milvus-io/milvus/internal/proto/querypb"
"github.com/milvus-io/milvus/internal/proto/rootcoordpb"
"github.com/milvus-io/milvus/internal/types"
"github.com/milvus-io/milvus/internal/util/sessionutil"
"github.com/stretchr/testify/assert"
@ -124,7 +124,7 @@ func BenchmarkAllocTimestamp(b *testing.B) {
b.ResetTimer()
for i := 0; i < b.N; i++ {
req := masterpb.AllocTimestampRequest{
req := rootcoordpb.AllocTimestampRequest{
Base: &commonpb.MsgBase{
MsgID: int64(i),
},

6
internal/types/types.go
View File

@ -18,10 +18,10 @@ import (
"github.com/milvus-io/milvus/internal/proto/datapb"
"github.com/milvus-io/milvus/internal/proto/indexpb"
"github.com/milvus-io/milvus/internal/proto/internalpb"
"github.com/milvus-io/milvus/internal/proto/masterpb"
"github.com/milvus-io/milvus/internal/proto/milvuspb"
"github.com/milvus-io/milvus/internal/proto/proxypb"
"github.com/milvus-io/milvus/internal/proto/querypb"
"github.com/milvus-io/milvus/internal/proto/rootcoordpb"
"github.com/milvus-io/milvus/internal/util/sessionutil"
)
@ -101,8 +101,8 @@ type RootCoord interface {
DropIndex(ctx context.Context, req *milvuspb.DropIndexRequest) (*commonpb.Status, error)
//global timestamp allocator
AllocTimestamp(ctx context.Context, req *masterpb.AllocTimestampRequest) (*masterpb.AllocTimestampResponse, error)
AllocID(ctx context.Context, req *masterpb.AllocIDRequest) (*masterpb.AllocIDResponse, error)
AllocTimestamp(ctx context.Context, req *rootcoordpb.AllocTimestampRequest) (*rootcoordpb.AllocTimestampResponse, error)
AllocID(ctx context.Context, req *rootcoordpb.AllocIDRequest) (*rootcoordpb.AllocIDResponse, error)
UpdateChannelTimeTick(ctx context.Context, req *internalpb.ChannelTimeTickMsg) (*commonpb.Status, error)
//segment

9
scripts/proto_gen_go.sh
View File

@ -24,8 +24,7 @@ mkdir -p indexcgopb
mkdir -p internalpb
mkdir -p milvuspb
mkdir -p masterpb
mkdir -p rootcoordpb
mkdir -p milvuspb
mkdir -p proxypb
@ -42,12 +41,12 @@ ${protoc} --go_out=plugins=grpc,paths=source_relative:./indexcgopb index_cgo_msg
#${protoc} --go_out=plugins=grpc,paths=source_relative:./internalpb internal_msg.proto
${protoc} --go_out=plugins=grpc,paths=source_relative:./masterpb master.proto
${protoc} --go_out=plugins=grpc,paths=source_relative:./rootcoordpb root_coord.proto
${protoc} --go_out=plugins=grpc,paths=source_relative:./internalpb internal.proto
${protoc} --go_out=plugins=grpc,paths=source_relative:./milvuspb milvus.proto
${protoc} --go_out=plugins=grpc,paths=source_relative:./proxypb proxy_service.proto
${protoc} --go_out=plugins=grpc,paths=source_relative:./indexpb index_service.proto
${protoc} --go_out=plugins=grpc,paths=source_relative:./proxypb proxy.proto
${protoc} --go_out=plugins=grpc,paths=source_relative:./indexpb index_coord.proto
${protoc} --go_out=plugins=grpc,paths=source_relative:./datapb data_coord.proto
${protoc} --go_out=plugins=grpc,paths=source_relative:./querypb query_service.proto
${protoc} --go_out=plugins=grpc,paths=source_relative:./planpb plan.proto