Fix rocksdb illegal instruction in some machine

Signed-off-by: yukun <kun.yu@zilliz.com>

docs/developer_guides/chap06_master.md

@@ -13,7 +13,7 @@ type Master interface {
   CreateCollection(req CreateCollectionRequest) error
   DropCollection(req DropCollectionRequest) error
   HasCollection(req HasCollectionRequest) (bool, error)
-  DescribeCollection(req DescribeCollectionRequest) (CollectionDescriptionResponse, error)
+  DescribeCollection(req DescribeCollectionRequest) (DescribeCollectionResponse, error)
   GetCollectionStatistics(req CollectionStatsRequest) (CollectionStatsResponse, error)
   ShowCollections(req ShowCollectionRequest) (ShowCollectionResponse, error)
   
@@ -52,6 +52,7 @@ type RequestBase struct {
 type CreateCollectionRequest struct {
   RequestBase
   DbName string
+  CollectionName string
   Schema []bytes
 }
 ```
@@ -85,7 +86,7 @@ type DescribeCollectionRequest struct {
   CollectionName string
 }
 
-type CollectionDescriptionResponse struct {
+type DescribeCollectionResponse struct {
   Schema []bytes
 }
 ```
@@ -168,11 +169,10 @@ type PartitionStatsResponse struct {
 * *ShowPartitions*
 
 ```go
-type CreatePartitionRequest struct {
+type ShowPartitionRequest struct {
   RequestBase
   DbName string
   CollectionName string
-  PartitionName string
 }
 
 type ShowPartitionResponse struct {
@@ -188,7 +188,7 @@ type CreateIndexRequest struct {
   DbName string
   CollectionName string
   FieldName string
-  Params []KeyValuePair
+  Params [] KeyValuePair
 }
 ```
 

docs/developer_guides/chap07_query_service.md

@@ -192,6 +192,7 @@ type QueryNode interface {
 
 ```go
 type AddQueryChannelRequest struct {
+  RequestBase
   RequestChannelID string
   ResultChannelID string
 }

internal/core/src/pb/CMakeLists.txt

@@ -1,7 +1,7 @@
 get_property(PROTOC_EXCUTABLE GLOBAL PROPERTY PROTOC_EXCUTABLE )
 
 
-set(proto_file_names common.proto etcd_meta.proto schema.proto service_msg.proto index_cgo_msg.proto index_builder.proto)
+set(proto_file_names common.proto etcd_meta.proto schema.proto service_msg.proto index_cgo_msg.proto)
 
 set( PROTO_PATH          "${MILVUS_SOURCE_DIR}/../proto/" )
 

internal/kv/rocksdb/cwrapper/CMakeLists.txt

@@ -22,10 +22,8 @@ macro( build_rocksdb )
     set( ROCKSDB_CMAKE_ARGS
          "-DWITH_GFLAGS=OFF"
          "-DROCKSDB_BUILD_SHARED=OFF"
-#         "-DWITH_SNAPPY=ON"
-#         "-DWITH_LZ4=ON"
-#         "-DWITH_ZSTD=ON"
-#         "-DWITH_BZ2=ON"
+         #This is used to solve 'illegal instruction' problem in some machine
+         "-DPORTABLE=ON"
          "-DCMAKE_INSTALL_PREFIX=${CMAKE_CURRENT_BINARY_DIR}"
           )
 

internal/kv/rocksdb/cwrapper/build.sh

@@ -50,4 +50,4 @@ echo ${CMAKE_CMD}
 if [[ ! ${jobs+1} ]]; then
     jobs=$(nproc)
 fi
-make -j ${jobs}
+make -j ${jobs} VERBOSE=0

internal/proto/data_service.proto

@@ -0,0 +1,130 @@
+syntax = "proto3";
+
+package milvus.proto.data;
+
+option go_package = "github.com/zilliztech/milvus-distributed/internal/proto/datapb";
+
+import "common.proto";
+import "internal.proto";
+
+
+message RegisterNodeRequest {
+  internal.MsgBase base = 1;
+  common.Address address = 2;
+}
+
+message RegisterNodeResponse {
+  internal.InitParams init_params = 1;
+}
+
+
+message SegIDRequest {
+  int32 count = 1;
+  string channelID = 2;
+  int64  collectionID = 3;
+  int64 partitionID = 4;
+}
+
+message AssignSegIDRequest {
+  int64 nodeID = 1;
+  string peer_role = 2;
+  repeated SegIDRequest segIDRequests = 3;
+}
+
+
+message SegIDAssignment {
+  int64 segID = 1;
+  int32 channelID = 2;
+  uint32 count = 3;
+  int64 collectionID = 4;
+  int64 partitionID = 5;
+  uint64 expire_time = 6;
+  common.Status status = 7;
+}
+
+message AssignSegIDResponse {
+  repeated SegIDAssignment segIDAssignments = 1;
+}
+
+message FlushRequest {
+  internal.MsgBase base = 1;
+  int64 dbID = 2;
+  int64 collectionID = 4;
+}
+
+message ShowSegmentRequest {
+  internal.MsgBase base = 1;
+  int64  collectionID = 2;
+  int64  partitionID = 3;
+}
+
+message ShowSegmentResponse {
+  repeated int64 segmentIDs = 1;
+}
+
+enum SegmentState {
+  SegmentNone = 0;
+  SegmentNotExist = 1;
+  SegmentGrowing = 2;
+  SegmentSealed = 3;
+}
+
+
+message SegmentStatesRequest {
+  internal.MsgBase base = 1;
+  int64  segmentID = 2;
+}
+
+message SegmentStatesResponse {
+  SegmentState state = 1;
+  uint64 create_time = 2;
+  uint64 sealed_time = 3;
+}
+
+
+message InsertBinlogPathRequest {
+  internal.MsgBase base = 1;
+  int64 segmentID = 2;
+}
+
+message InsertBinlogPathsResponse {
+  repeated int64 fieldIDs = 1;
+  repeated internal.StringList paths = 2;
+}
+
+
+message InsertChannelRequest  {
+  internal.MsgBase base = 1;
+  int64  dbID = 2;
+  int64  collectionID = 3;
+}
+
+
+message WatchDmChannelRequest {
+  internal.MsgBase base = 1;
+  repeated  string channelIDs = 2;
+}
+
+
+message FlushSegRequest {
+  internal.MsgBase base = 1;
+  int64  dbID = 2;
+  int64 collectionID = 3;
+  repeated int64 segmentIDs = 4;
+}
+
+
+service DataService {
+
+   rpc RegisterNode(RegisterNodeRequest) returns (RegisterNodeResponse) {}
+   rpc Flush(FlushRequest) returns (common.Status) {}
+
+   rpc AssignSegmentID(AssignSegIDRequest) returns (AssignSegIDResponse) {}
+   rpc ShowSegments(ShowSegmentRequest) returns (ShowSegmentResponse) {}
+
+   rpc GetSegmentStates(SegmentStatesRequest) returns (SegmentStatesResponse) {}
+   rpc GetInsertBinlogPaths(InsertBinlogPathRequest) returns (InsertBinlogPathsResponse) {}
+
+   rpc GetInsertChannels(InsertChannelRequest) returns (internal.StringList) {}
+
+}

internal/proto/index_service.proto

@@ -0,0 +1,84 @@
+syntax = "proto3";
+
+package milvus.proto.index;
+
+option go_package = "github.com/zilliztech/milvus-distributed/internal/proto/indexpb";
+
+import "common.proto";
+import "internal.proto";
+
+
+message RegisterNodeRequest {
+  internal.MsgBase base = 1;
+  common.Address address = 2;
+}
+
+message RegisterNodeResponse {
+  internal.InitParams init_params = 1;
+}
+
+
+enum IndexState {
+  NONE = 0;
+  UNISSUED = 1;
+  INPROGRESS = 2;
+  FINISHED = 3;
+  FAILED = 4;
+}
+
+message IndexStatesRequest {
+  int64  indexID = 1;
+}
+
+message IndexStatesResponse {
+  common.Status status = 1;
+  IndexState state = 2;
+  int64 indexID = 3;
+}
+
+message BuildIndexRequest {
+  repeated string data_paths = 2;
+  repeated common.KeyValuePair type_params = 3;
+  repeated common.KeyValuePair index_params = 4;
+}
+
+message BuildIndexResponse {
+  common.Status status = 1;
+  int64 indexID = 2;
+}
+
+message IndexFilePathRequest {
+  int64 indexID = 1;
+}
+
+message IndexFilePathsResponse {
+  common.Status status = 1;
+  int64 indexID = 2;
+  repeated string index_file_paths = 3;
+}
+
+message IndexMeta {
+  IndexState state = 1;
+  int64   indexID = 2;
+  int64 enque_time = 3;
+  int64 schedule_time = 4;
+  int64 build_complete_time = 5;
+  BuildIndexRequest req = 6;
+  repeated string index_file_paths = 7;
+}
+
+/****************IndexService************************/
+service IndexService {
+  /**
+   * @brief This method is used to create collection
+   *
+   * @param CollectionSchema, use to provide collection information to be created.
+   *
+   * @return Status
+   */
+  rpc RegisterNode(RegisterNodeRequest) returns (RegisterNodeResponse) {}
+  rpc BuildIndex(BuildIndexRequest) returns (BuildIndexResponse){}
+  rpc GetIndexStates(IndexStatesRequest) returns (IndexStatesResponse) {}
+  rpc GetIndexFilePaths(IndexFilePathRequest) returns (IndexFilePathsResponse){}
+
+}

internal/proto/indexpb/index_service.pb.go

@@ -0,0 +1,788 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: index_service.proto
+
+package indexpb
+
+import (
+	context "context"
+	fmt "fmt"
+	proto "github.com/golang/protobuf/proto"
+	commonpb "github.com/zilliztech/milvus-distributed/internal/proto/commonpb"
+	internalpb2 "github.com/zilliztech/milvus-distributed/internal/proto/internalpb2"
+	grpc "google.golang.org/grpc"
+	codes "google.golang.org/grpc/codes"
+	status "google.golang.org/grpc/status"
+	math "math"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
+
+type IndexState int32
+
+const (
+	IndexState_NONE       IndexState = 0
+	IndexState_UNISSUED   IndexState = 1
+	IndexState_INPROGRESS IndexState = 2
+	IndexState_FINISHED   IndexState = 3
+	IndexState_FAILED     IndexState = 4
+)
+
+var IndexState_name = map[int32]string{
+	0: "NONE",
+	1: "UNISSUED",
+	2: "INPROGRESS",
+	3: "FINISHED",
+	4: "FAILED",
+}
+
+var IndexState_value = map[string]int32{
+	"NONE":       0,
+	"UNISSUED":   1,
+	"INPROGRESS": 2,
+	"FINISHED":   3,
+	"FAILED":     4,
+}
+
+func (x IndexState) String() string {
+	return proto.EnumName(IndexState_name, int32(x))
+}
+
+func (IndexState) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor_a5d2036b4df73e0a, []int{0}
+}
+
+type RegisterNodeRequest struct {
+	Base                 *internalpb2.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
+	Address              *commonpb.Address    `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
+	XXX_unrecognized     []byte               `json:"-"`
+	XXX_sizecache        int32                `json:"-"`
+}
+
+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}
+}
+
+func (m *RegisterNodeRequest) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_RegisterNodeRequest.Unmarshal(m, b)
+}
+func (m *RegisterNodeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_RegisterNodeRequest.Marshal(b, m, deterministic)
+}
+func (m *RegisterNodeRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_RegisterNodeRequest.Merge(m, src)
+}
+func (m *RegisterNodeRequest) XXX_Size() int {
+	return xxx_messageInfo_RegisterNodeRequest.Size(m)
+}
+func (m *RegisterNodeRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_RegisterNodeRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_RegisterNodeRequest proto.InternalMessageInfo
+
+func (m *RegisterNodeRequest) GetBase() *internalpb2.MsgBase {
+	if m != nil {
+		return m.Base
+	}
+	return nil
+}
+
+func (m *RegisterNodeRequest) GetAddress() *commonpb.Address {
+	if m != nil {
+		return m.Address
+	}
+	return nil
+}
+
+type RegisterNodeResponse struct {
+	InitParams           *internalpb2.InitParams `protobuf:"bytes,1,opt,name=init_params,json=initParams,proto3" json:"init_params,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
+	XXX_unrecognized     []byte                  `json:"-"`
+	XXX_sizecache        int32                   `json:"-"`
+}
+
+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}
+}
+
+func (m *RegisterNodeResponse) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_RegisterNodeResponse.Unmarshal(m, b)
+}
+func (m *RegisterNodeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_RegisterNodeResponse.Marshal(b, m, deterministic)
+}
+func (m *RegisterNodeResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_RegisterNodeResponse.Merge(m, src)
+}
+func (m *RegisterNodeResponse) XXX_Size() int {
+	return xxx_messageInfo_RegisterNodeResponse.Size(m)
+}
+func (m *RegisterNodeResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_RegisterNodeResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_RegisterNodeResponse proto.InternalMessageInfo
+
+func (m *RegisterNodeResponse) GetInitParams() *internalpb2.InitParams {
+	if m != nil {
+		return m.InitParams
+	}
+	return nil
+}
+
+type IndexStatesRequest struct {
+	IndexID              int64    `protobuf:"varint,1,opt,name=indexID,proto3" json:"indexID,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *IndexStatesRequest) Reset()         { *m = IndexStatesRequest{} }
+func (m *IndexStatesRequest) String() string { return proto.CompactTextString(m) }
+func (*IndexStatesRequest) ProtoMessage()    {}
+func (*IndexStatesRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_a5d2036b4df73e0a, []int{2}
+}
+
+func (m *IndexStatesRequest) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_IndexStatesRequest.Unmarshal(m, b)
+}
+func (m *IndexStatesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_IndexStatesRequest.Marshal(b, m, deterministic)
+}
+func (m *IndexStatesRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_IndexStatesRequest.Merge(m, src)
+}
+func (m *IndexStatesRequest) XXX_Size() int {
+	return xxx_messageInfo_IndexStatesRequest.Size(m)
+}
+func (m *IndexStatesRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_IndexStatesRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_IndexStatesRequest proto.InternalMessageInfo
+
+func (m *IndexStatesRequest) GetIndexID() int64 {
+	if m != nil {
+		return m.IndexID
+	}
+	return 0
+}
+
+type IndexStatesResponse struct {
+	Status               *commonpb.Status `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
+	State                IndexState       `protobuf:"varint,2,opt,name=state,proto3,enum=milvus.proto.index.IndexState" json:"state,omitempty"`
+	IndexID              int64            `protobuf:"varint,3,opt,name=indexID,proto3" json:"indexID,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
+	XXX_unrecognized     []byte           `json:"-"`
+	XXX_sizecache        int32            `json:"-"`
+}
+
+func (m *IndexStatesResponse) Reset()         { *m = IndexStatesResponse{} }
+func (m *IndexStatesResponse) String() string { return proto.CompactTextString(m) }
+func (*IndexStatesResponse) ProtoMessage()    {}
+func (*IndexStatesResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_a5d2036b4df73e0a, []int{3}
+}
+
+func (m *IndexStatesResponse) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_IndexStatesResponse.Unmarshal(m, b)
+}
+func (m *IndexStatesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_IndexStatesResponse.Marshal(b, m, deterministic)
+}
+func (m *IndexStatesResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_IndexStatesResponse.Merge(m, src)
+}
+func (m *IndexStatesResponse) XXX_Size() int {
+	return xxx_messageInfo_IndexStatesResponse.Size(m)
+}
+func (m *IndexStatesResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_IndexStatesResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_IndexStatesResponse proto.InternalMessageInfo
+
+func (m *IndexStatesResponse) GetStatus() *commonpb.Status {
+	if m != nil {
+		return m.Status
+	}
+	return nil
+}
+
+func (m *IndexStatesResponse) GetState() IndexState {
+	if m != nil {
+		return m.State
+	}
+	return IndexState_NONE
+}
+
+func (m *IndexStatesResponse) GetIndexID() int64 {
+	if m != nil {
+		return m.IndexID
+	}
+	return 0
+}
+
+type BuildIndexRequest struct {
+	DataPaths            []string                 `protobuf:"bytes,2,rep,name=data_paths,json=dataPaths,proto3" json:"data_paths,omitempty"`
+	TypeParams           []*commonpb.KeyValuePair `protobuf:"bytes,3,rep,name=type_params,json=typeParams,proto3" json:"type_params,omitempty"`
+	IndexParams          []*commonpb.KeyValuePair `protobuf:"bytes,4,rep,name=index_params,json=indexParams,proto3" json:"index_params,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
+	XXX_unrecognized     []byte                   `json:"-"`
+	XXX_sizecache        int32                    `json:"-"`
+}
+
+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{4}
+}
+
+func (m *BuildIndexRequest) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_BuildIndexRequest.Unmarshal(m, b)
+}
+func (m *BuildIndexRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_BuildIndexRequest.Marshal(b, m, deterministic)
+}
+func (m *BuildIndexRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_BuildIndexRequest.Merge(m, src)
+}
+func (m *BuildIndexRequest) XXX_Size() int {
+	return xxx_messageInfo_BuildIndexRequest.Size(m)
+}
+func (m *BuildIndexRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_BuildIndexRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_BuildIndexRequest proto.InternalMessageInfo
+
+func (m *BuildIndexRequest) GetDataPaths() []string {
+	if m != nil {
+		return m.DataPaths
+	}
+	return nil
+}
+
+func (m *BuildIndexRequest) GetTypeParams() []*commonpb.KeyValuePair {
+	if m != nil {
+		return m.TypeParams
+	}
+	return nil
+}
+
+func (m *BuildIndexRequest) GetIndexParams() []*commonpb.KeyValuePair {
+	if m != nil {
+		return m.IndexParams
+	}
+	return nil
+}
+
+type BuildIndexResponse struct {
+	Status               *commonpb.Status `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
+	IndexID              int64            `protobuf:"varint,2,opt,name=indexID,proto3" json:"indexID,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
+	XXX_unrecognized     []byte           `json:"-"`
+	XXX_sizecache        int32            `json:"-"`
+}
+
+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{5}
+}
+
+func (m *BuildIndexResponse) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_BuildIndexResponse.Unmarshal(m, b)
+}
+func (m *BuildIndexResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_BuildIndexResponse.Marshal(b, m, deterministic)
+}
+func (m *BuildIndexResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_BuildIndexResponse.Merge(m, src)
+}
+func (m *BuildIndexResponse) XXX_Size() int {
+	return xxx_messageInfo_BuildIndexResponse.Size(m)
+}
+func (m *BuildIndexResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_BuildIndexResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_BuildIndexResponse proto.InternalMessageInfo
+
+func (m *BuildIndexResponse) GetStatus() *commonpb.Status {
+	if m != nil {
+		return m.Status
+	}
+	return nil
+}
+
+func (m *BuildIndexResponse) GetIndexID() int64 {
+	if m != nil {
+		return m.IndexID
+	}
+	return 0
+}
+
+type IndexFilePathRequest struct {
+	IndexID              int64    `protobuf:"varint,1,opt,name=indexID,proto3" json:"indexID,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *IndexFilePathRequest) Reset()         { *m = IndexFilePathRequest{} }
+func (m *IndexFilePathRequest) String() string { return proto.CompactTextString(m) }
+func (*IndexFilePathRequest) ProtoMessage()    {}
+func (*IndexFilePathRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_a5d2036b4df73e0a, []int{6}
+}
+
+func (m *IndexFilePathRequest) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_IndexFilePathRequest.Unmarshal(m, b)
+}
+func (m *IndexFilePathRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_IndexFilePathRequest.Marshal(b, m, deterministic)
+}
+func (m *IndexFilePathRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_IndexFilePathRequest.Merge(m, src)
+}
+func (m *IndexFilePathRequest) XXX_Size() int {
+	return xxx_messageInfo_IndexFilePathRequest.Size(m)
+}
+func (m *IndexFilePathRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_IndexFilePathRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_IndexFilePathRequest proto.InternalMessageInfo
+
+func (m *IndexFilePathRequest) GetIndexID() int64 {
+	if m != nil {
+		return m.IndexID
+	}
+	return 0
+}
+
+type IndexFilePathsResponse struct {
+	Status               *commonpb.Status `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
+	IndexID              int64            `protobuf:"varint,2,opt,name=indexID,proto3" json:"indexID,omitempty"`
+	IndexFilePaths       []string         `protobuf:"bytes,3,rep,name=index_file_paths,json=indexFilePaths,proto3" json:"index_file_paths,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
+	XXX_unrecognized     []byte           `json:"-"`
+	XXX_sizecache        int32            `json:"-"`
+}
+
+func (m *IndexFilePathsResponse) Reset()         { *m = IndexFilePathsResponse{} }
+func (m *IndexFilePathsResponse) String() string { return proto.CompactTextString(m) }
+func (*IndexFilePathsResponse) ProtoMessage()    {}
+func (*IndexFilePathsResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_a5d2036b4df73e0a, []int{7}
+}
+
+func (m *IndexFilePathsResponse) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_IndexFilePathsResponse.Unmarshal(m, b)
+}
+func (m *IndexFilePathsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_IndexFilePathsResponse.Marshal(b, m, deterministic)
+}
+func (m *IndexFilePathsResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_IndexFilePathsResponse.Merge(m, src)
+}
+func (m *IndexFilePathsResponse) XXX_Size() int {
+	return xxx_messageInfo_IndexFilePathsResponse.Size(m)
+}
+func (m *IndexFilePathsResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_IndexFilePathsResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_IndexFilePathsResponse proto.InternalMessageInfo
+
+func (m *IndexFilePathsResponse) GetStatus() *commonpb.Status {
+	if m != nil {
+		return m.Status
+	}
+	return nil
+}
+
+func (m *IndexFilePathsResponse) GetIndexID() int64 {
+	if m != nil {
+		return m.IndexID
+	}
+	return 0
+}
+
+func (m *IndexFilePathsResponse) GetIndexFilePaths() []string {
+	if m != nil {
+		return m.IndexFilePaths
+	}
+	return nil
+}
+
+type IndexMeta struct {
+	State                IndexState         `protobuf:"varint,1,opt,name=state,proto3,enum=milvus.proto.index.IndexState" json:"state,omitempty"`
+	IndexID              int64              `protobuf:"varint,2,opt,name=indexID,proto3" json:"indexID,omitempty"`
+	EnqueTime            int64              `protobuf:"varint,3,opt,name=enque_time,json=enqueTime,proto3" json:"enque_time,omitempty"`
+	ScheduleTime         int64              `protobuf:"varint,4,opt,name=schedule_time,json=scheduleTime,proto3" json:"schedule_time,omitempty"`
+	BuildCompleteTime    int64              `protobuf:"varint,5,opt,name=build_complete_time,json=buildCompleteTime,proto3" json:"build_complete_time,omitempty"`
+	Req                  *BuildIndexRequest `protobuf:"bytes,6,opt,name=req,proto3" json:"req,omitempty"`
+	IndexFilePaths       []string           `protobuf:"bytes,7,rep,name=index_file_paths,json=indexFilePaths,proto3" json:"index_file_paths,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
+	XXX_unrecognized     []byte             `json:"-"`
+	XXX_sizecache        int32              `json:"-"`
+}
+
+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{8}
+}
+
+func (m *IndexMeta) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_IndexMeta.Unmarshal(m, b)
+}
+func (m *IndexMeta) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_IndexMeta.Marshal(b, m, deterministic)
+}
+func (m *IndexMeta) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_IndexMeta.Merge(m, src)
+}
+func (m *IndexMeta) XXX_Size() int {
+	return xxx_messageInfo_IndexMeta.Size(m)
+}
+func (m *IndexMeta) XXX_DiscardUnknown() {
+	xxx_messageInfo_IndexMeta.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_IndexMeta proto.InternalMessageInfo
+
+func (m *IndexMeta) GetState() IndexState {
+	if m != nil {
+		return m.State
+	}
+	return IndexState_NONE
+}
+
+func (m *IndexMeta) GetIndexID() int64 {
+	if m != nil {
+		return m.IndexID
+	}
+	return 0
+}
+
+func (m *IndexMeta) GetEnqueTime() int64 {
+	if m != nil {
+		return m.EnqueTime
+	}
+	return 0
+}
+
+func (m *IndexMeta) GetScheduleTime() int64 {
+	if m != nil {
+		return m.ScheduleTime
+	}
+	return 0
+}
+
+func (m *IndexMeta) GetBuildCompleteTime() int64 {
+	if m != nil {
+		return m.BuildCompleteTime
+	}
+	return 0
+}
+
+func (m *IndexMeta) GetReq() *BuildIndexRequest {
+	if m != nil {
+		return m.Req
+	}
+	return nil
+}
+
+func (m *IndexMeta) GetIndexFilePaths() []string {
+	if m != nil {
+		return m.IndexFilePaths
+	}
+	return nil
+}
+
+func init() {
+	proto.RegisterEnum("milvus.proto.index.IndexState", IndexState_name, IndexState_value)
+	proto.RegisterType((*RegisterNodeRequest)(nil), "milvus.proto.index.RegisterNodeRequest")
+	proto.RegisterType((*RegisterNodeResponse)(nil), "milvus.proto.index.RegisterNodeResponse")
+	proto.RegisterType((*IndexStatesRequest)(nil), "milvus.proto.index.IndexStatesRequest")
+	proto.RegisterType((*IndexStatesResponse)(nil), "milvus.proto.index.IndexStatesResponse")
+	proto.RegisterType((*BuildIndexRequest)(nil), "milvus.proto.index.BuildIndexRequest")
+	proto.RegisterType((*BuildIndexResponse)(nil), "milvus.proto.index.BuildIndexResponse")
+	proto.RegisterType((*IndexFilePathRequest)(nil), "milvus.proto.index.IndexFilePathRequest")
+	proto.RegisterType((*IndexFilePathsResponse)(nil), "milvus.proto.index.IndexFilePathsResponse")
+	proto.RegisterType((*IndexMeta)(nil), "milvus.proto.index.IndexMeta")
+}
+
+func init() { proto.RegisterFile("index_service.proto", fileDescriptor_a5d2036b4df73e0a) }
+
+var fileDescriptor_a5d2036b4df73e0a = []byte{
+	// 709 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x55, 0xdf, 0x4f, 0x13, 0x41,
+	0x10, 0xe6, 0x7a, 0xa5, 0xd0, 0xa1, 0x36, 0x65, 0x4b, 0x4c, 0x53, 0xc5, 0x60, 0x8d, 0xd0, 0x90,
+	0xd8, 0x1a, 0x30, 0xfa, 0x68, 0xa8, 0x2d, 0x78, 0x51, 0x4a, 0x73, 0x15, 0x1f, 0x48, 0x4c, 0xb3,
+	0xbd, 0x1b, 0xe9, 0xc6, 0xfb, 0xc5, 0xed, 0x1e, 0x01, 0xde, 0xfc, 0x13, 0x7c, 0xf5, 0xd9, 0xbf,
+	0xc0, 0x67, 0xff, 0x38, 0x73, 0x7b, 0x77, 0x6d, 0x0f, 0x8a, 0x25, 0x1a, 0xdf, 0xba, 0xb3, 0xdf,
+	0x7c, 0xfb, 0xcd, 0x37, 0x73, 0x53, 0x28, 0x33, 0xc7, 0xc4, 0x8b, 0x01, 0x47, 0xff, 0x9c, 0x19,
+	0xd8, 0xf0, 0x7c, 0x57, 0xb8, 0x84, 0xd8, 0xcc, 0x3a, 0x0f, 0x78, 0x74, 0x6a, 0x48, 0x44, 0xb5,
+	0x60, 0xb8, 0xb6, 0xed, 0x3a, 0x51, 0xac, 0x5a, 0x64, 0x8e, 0x40, 0xdf, 0xa1, 0x56, 0x74, 0xae,
+	0x7d, 0x55, 0xa0, 0xac, 0xe3, 0x29, 0xe3, 0x02, 0xfd, 0xae, 0x6b, 0xa2, 0x8e, 0x67, 0x01, 0x72,
+	0x41, 0x76, 0x20, 0x3b, 0xa4, 0x1c, 0x2b, 0xca, 0x86, 0x52, 0x5f, 0xd9, 0x79, 0xd4, 0xb8, 0x46,
+	0x1c, 0x73, 0x1c, 0xf2, 0xd3, 0x16, 0xe5, 0xa8, 0x4b, 0x2c, 0x79, 0x09, 0x4b, 0xd4, 0x34, 0x7d,
+	0xe4, 0xbc, 0x92, 0x91, 0x69, 0x0f, 0xd3, 0x69, 0xb1, 0x90, 0xbd, 0x08, 0xa3, 0x27, 0xe0, 0xda,
+	0x09, 0xac, 0xa5, 0x25, 0x70, 0xcf, 0x75, 0x38, 0x92, 0x16, 0xac, 0x30, 0x87, 0x89, 0x81, 0x47,
+	0x7d, 0x6a, 0xf3, 0x58, 0xca, 0xe3, 0x5b, 0xa4, 0x68, 0x0e, 0x13, 0x3d, 0x09, 0xd4, 0x81, 0x8d,
+	0x7f, 0xd7, 0x1a, 0x40, 0xb4, 0xd0, 0x86, 0xbe, 0xa0, 0x02, 0x79, 0x52, 0x5d, 0x05, 0x96, 0xa4,
+	0x39, 0x5a, 0x5b, 0xb2, 0xaa, 0x7a, 0x72, 0xac, 0x7d, 0x57, 0xa0, 0x9c, 0x4a, 0x88, 0xb5, 0xec,
+	0x42, 0x8e, 0x0b, 0x2a, 0x82, 0x44, 0xc6, 0x83, 0x99, 0xa5, 0xf5, 0x25, 0x44, 0x8f, 0xa1, 0xe4,
+	0x05, 0x2c, 0x86, 0xbf, 0x50, 0xda, 0x51, 0xbc, 0xe9, 0xa2, 0x89, 0x17, 0x8d, 0xc9, 0x63, 0x7a,
+	0x04, 0x9e, 0x16, 0xa7, 0xa6, 0xc5, 0xfd, 0x52, 0x60, 0xb5, 0x15, 0x30, 0xcb, 0x94, 0x49, 0x49,
+	0x31, 0xeb, 0x00, 0x26, 0x15, 0x74, 0xe0, 0x51, 0x31, 0x0a, 0x9d, 0x57, 0xeb, 0x79, 0x3d, 0x1f,
+	0x46, 0x7a, 0x61, 0x20, 0x74, 0x51, 0x5c, 0x7a, 0x98, 0xb8, 0xa8, 0x6e, 0xa8, 0x37, 0x5d, 0x8c,
+	0xe5, 0xbf, 0xc3, 0xcb, 0x8f, 0xd4, 0x0a, 0xb0, 0x47, 0x99, 0xaf, 0x43, 0x98, 0x15, 0xb9, 0x48,
+	0xda, 0x50, 0x88, 0xc6, 0x2d, 0x26, 0xc9, 0xde, 0x95, 0x64, 0x45, 0xa6, 0xc5, 0xbd, 0x30, 0x80,
+	0x4c, 0xab, 0xff, 0x17, 0x67, 0xa7, 0x3c, 0xca, 0xa4, 0x3d, 0x7a, 0x0e, 0x6b, 0x92, 0x7f, 0x9f,
+	0x59, 0x18, 0x1a, 0x30, 0xbf, 0xe5, 0xdf, 0x14, 0xb8, 0x9f, 0x4a, 0xe1, 0xff, 0x49, 0x1b, 0xa9,
+	0x43, 0x29, 0xb2, 0xf1, 0x33, 0xb3, 0x30, 0xee, 0x97, 0x2a, 0xfb, 0x55, 0x64, 0x29, 0x01, 0xb5,
+	0x9f, 0x19, 0xc8, 0x4b, 0x4d, 0x87, 0x28, 0xe8, 0x64, 0x8e, 0x94, 0xbf, 0x9c, 0xa3, 0x6b, 0x3a,
+	0xd6, 0x01, 0xd0, 0x39, 0x0b, 0x70, 0x20, 0x98, 0x8d, 0xf1, 0x90, 0xe5, 0x65, 0xe4, 0x03, 0xb3,
+	0x91, 0x3c, 0x81, 0x7b, 0xdc, 0x18, 0xa1, 0x19, 0x58, 0x31, 0x22, 0x2b, 0x11, 0x85, 0x24, 0x28,
+	0x41, 0x0d, 0x28, 0x0f, 0xc3, 0x66, 0x0e, 0x0c, 0xd7, 0xf6, 0x2c, 0x14, 0x31, 0x74, 0x51, 0x42,
+	0x57, 0xe5, 0xd5, 0x9b, 0xf8, 0x46, 0xe2, 0x5f, 0x81, 0xea, 0xe3, 0x59, 0x25, 0x27, 0x7d, 0x7c,
+	0x3a, 0xab, 0x82, 0x1b, 0x93, 0xad, 0x87, 0x19, 0x33, 0x4d, 0x5b, 0x9a, 0x65, 0xda, 0x76, 0x17,
+	0x60, 0xe2, 0x02, 0x59, 0x86, 0x6c, 0xf7, 0xa8, 0xdb, 0x29, 0x2d, 0x90, 0x02, 0x2c, 0x1f, 0x77,
+	0xb5, 0x7e, 0xff, 0xb8, 0xd3, 0x2e, 0x29, 0xa4, 0x08, 0xa0, 0x75, 0x7b, 0xfa, 0xd1, 0x81, 0xde,
+	0xe9, 0xf7, 0x4b, 0x99, 0xf0, 0x76, 0x5f, 0xeb, 0x6a, 0xfd, 0xb7, 0x9d, 0x76, 0x49, 0x25, 0x00,
+	0xb9, 0xfd, 0x3d, 0xed, 0x7d, 0xa7, 0x5d, 0xca, 0xee, 0xfc, 0x50, 0xa1, 0x10, 0x11, 0x46, 0x4b,
+	0x96, 0x18, 0x50, 0x98, 0x5e, 0x54, 0x64, 0x6b, 0x56, 0x19, 0x33, 0xb6, 0x69, 0xb5, 0x3e, 0x1f,
+	0x18, 0x4d, 0x5c, 0x6d, 0x81, 0x7c, 0x02, 0x98, 0x38, 0x41, 0xee, 0xe6, 0x54, 0x75, 0x73, 0x1e,
+	0x6c, 0x4c, 0x6f, 0x40, 0xf1, 0x00, 0xc5, 0xd4, 0x8a, 0x23, 0x9b, 0x7f, 0x1e, 0xa7, 0x64, 0x69,
+	0x56, 0xb7, 0xe6, 0xe2, 0xc6, 0x8f, 0x7c, 0x81, 0xd5, 0xe4, 0x91, 0x71, 0x7b, 0x48, 0xfd, 0xd6,
+	0xfc, 0x6b, 0xdf, 0x6a, 0x75, 0x7b, 0x2e, 0x72, 0xea, 0xb1, 0xd6, 0xde, 0xc9, 0xeb, 0x53, 0x26,
+	0x46, 0xc1, 0x30, 0xfc, 0x1e, 0x9b, 0x57, 0xcc, 0xb2, 0xd8, 0x95, 0x40, 0x63, 0xd4, 0x8c, 0x48,
+	0x9e, 0x99, 0x8c, 0x0b, 0x9f, 0x0d, 0x03, 0x81, 0x66, 0x33, 0xf9, 0xbb, 0x68, 0x4a, 0xe6, 0xa6,
+	0x64, 0xf6, 0x86, 0xc3, 0x9c, 0x3c, 0xee, 0xfe, 0x0e, 0x00, 0x00, 0xff, 0xff, 0x65, 0x3f, 0xa4,
+	0x88, 0x55, 0x07, 0x00, 0x00,
+}
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ context.Context
+var _ grpc.ClientConn
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+const _ = grpc.SupportPackageIsVersion4
+
+// IndexServiceClient is the client API for IndexService 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 {
+	//*
+	// @brief This method is used to create collection
+	//
+	// @param CollectionSchema, use to provide collection information to be created.
+	//
+	// @return Status
+	RegisterNode(ctx context.Context, in *RegisterNodeRequest, opts ...grpc.CallOption) (*RegisterNodeResponse, error)
+	BuildIndex(ctx context.Context, in *BuildIndexRequest, opts ...grpc.CallOption) (*BuildIndexResponse, error)
+	GetIndexStates(ctx context.Context, in *IndexStatesRequest, opts ...grpc.CallOption) (*IndexStatesResponse, error)
+	GetIndexFilePaths(ctx context.Context, in *IndexFilePathRequest, opts ...grpc.CallOption) (*IndexFilePathsResponse, error)
+}
+
+type indexServiceClient struct {
+	cc *grpc.ClientConn
+}
+
+func NewIndexServiceClient(cc *grpc.ClientConn) IndexServiceClient {
+	return &indexServiceClient{cc}
+}
+
+func (c *indexServiceClient) 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...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *indexServiceClient) 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...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *indexServiceClient) GetIndexStates(ctx context.Context, in *IndexStatesRequest, opts ...grpc.CallOption) (*IndexStatesResponse, error) {
+	out := new(IndexStatesResponse)
+	err := c.cc.Invoke(ctx, "/milvus.proto.index.IndexService/GetIndexStates", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *indexServiceClient) GetIndexFilePaths(ctx context.Context, in *IndexFilePathRequest, opts ...grpc.CallOption) (*IndexFilePathsResponse, error) {
+	out := new(IndexFilePathsResponse)
+	err := c.cc.Invoke(ctx, "/milvus.proto.index.IndexService/GetIndexFilePaths", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// IndexServiceServer is the server API for IndexService service.
+type IndexServiceServer interface {
+	//*
+	// @brief This method is used to create collection
+	//
+	// @param CollectionSchema, use to provide collection information to be created.
+	//
+	// @return Status
+	RegisterNode(context.Context, *RegisterNodeRequest) (*RegisterNodeResponse, error)
+	BuildIndex(context.Context, *BuildIndexRequest) (*BuildIndexResponse, error)
+	GetIndexStates(context.Context, *IndexStatesRequest) (*IndexStatesResponse, error)
+	GetIndexFilePaths(context.Context, *IndexFilePathRequest) (*IndexFilePathsResponse, error)
+}
+
+// UnimplementedIndexServiceServer can be embedded to have forward compatible implementations.
+type UnimplementedIndexServiceServer struct {
+}
+
+func (*UnimplementedIndexServiceServer) 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) {
+	return nil, status.Errorf(codes.Unimplemented, "method BuildIndex not implemented")
+}
+func (*UnimplementedIndexServiceServer) GetIndexStates(ctx context.Context, req *IndexStatesRequest) (*IndexStatesResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method GetIndexStates not implemented")
+}
+func (*UnimplementedIndexServiceServer) GetIndexFilePaths(ctx context.Context, req *IndexFilePathRequest) (*IndexFilePathsResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method GetIndexFilePaths not implemented")
+}
+
+func RegisterIndexServiceServer(s *grpc.Server, srv IndexServiceServer) {
+	s.RegisterService(&_IndexService_serviceDesc, srv)
+}
+
+func _IndexService_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)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/milvus.proto.index.IndexService/RegisterNode",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(IndexServiceServer).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) {
+	in := new(BuildIndexRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(IndexServiceServer).BuildIndex(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/milvus.proto.index.IndexService/BuildIndex",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(IndexServiceServer).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) {
+	in := new(IndexStatesRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(IndexServiceServer).GetIndexStates(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/milvus.proto.index.IndexService/GetIndexStates",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(IndexServiceServer).GetIndexStates(ctx, req.(*IndexStatesRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _IndexService_GetIndexFilePaths_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(IndexFilePathRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(IndexServiceServer).GetIndexFilePaths(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/milvus.proto.index.IndexService/GetIndexFilePaths",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(IndexServiceServer).GetIndexFilePaths(ctx, req.(*IndexFilePathRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+var _IndexService_serviceDesc = grpc.ServiceDesc{
+	ServiceName: "milvus.proto.index.IndexService",
+	HandlerType: (*IndexServiceServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "RegisterNode",
+			Handler:    _IndexService_RegisterNode_Handler,
+		},
+		{
+			MethodName: "BuildIndex",
+			Handler:    _IndexService_BuildIndex_Handler,
+		},
+		{
+			MethodName: "GetIndexStates",
+			Handler:    _IndexService_GetIndexStates_Handler,
+		},
+		{
+			MethodName: "GetIndexFilePaths",
+			Handler:    _IndexService_GetIndexFilePaths_Handler,
+		},
+	},
+	Streams:  []grpc.StreamDesc{},
+	Metadata: "index_service.proto",
+}

internal/proto/internal.proto

@@ -0,0 +1,90 @@
+syntax = "proto3";
+package milvus.proto.internal;
+option go_package = "github.com/zilliztech/milvus-distributed/internal/proto/internalpb2";
+
+import "common.proto";
+
+enum MsgType {
+  kNone = 0;
+  /* Definition Requests: collection */
+  kCreateCollection = 100;
+  kDropCollection = 101;
+  kHasCollection = 102;
+  kDescribeCollection = 103;
+  kShowCollections = 104;
+  kGetSysConfigs = 105;
+
+  /* Definition Requests: partition */
+  kCreatePartition = 200;
+  kDropPartition = 201;
+  kHasPartition = 202;
+  kDescribePartition = 203;
+  kShowPartitions = 204;
+
+  /* Definition Requests: Index */
+  kCreateIndex = 300;
+  kDescribeIndex = 301;
+  kDescribeIndexProgress = 302;
+
+  /* Manipulation Requests */
+  kInsert = 400;
+  kDelete = 401;
+  kFlush = 402;
+
+  /* Query */
+  kSearch = 500;
+  kSearchResult = 501;
+
+  /* System Control */
+  kTimeTick = 1200;
+  kQueryNodeStats = 1201;
+  kLoadIndex = 1202;
+
+}
+
+
+enum StateCode {
+  INITIALIZING = 0;
+  HEALTHY = 1;
+  ABNORMAL = 2;
+}
+
+
+message NodeStates {
+  int64  nodeID = 1;
+  string role = 2;
+  StateCode state_code = 3;
+  repeated common.KeyValuePair extra_info = 4;
+}
+
+message ServiceStates {
+  StateCode state_code = 1;
+  repeated NodeStates node_states = 2;
+  repeated common.KeyValuePair extra_info = 3;
+}
+
+message  NodeInfo {
+  common.Address address = 1;
+  string role = 2;
+}
+
+message InitParams {
+  int64 nodeID = 1;
+  repeated common.KeyValuePair start_params = 2;
+}
+
+message StringList {
+  repeated string values = 2;
+}
+
+message MsgBase {
+  MsgType msg_type = 1;
+  int64  reqID = 2;
+  uint64 timestamp = 3;
+  int64 sourceID = 4;
+}
+
+message TimeTickMsg {
+  MsgBase base = 1;
+}
+

internal/proto/internalpb2/internal.pb.go

@@ -0,0 +1,565 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: internal.proto
+
+package internalpb2
+
+import (
+	fmt "fmt"
+	proto "github.com/golang/protobuf/proto"
+	commonpb "github.com/zilliztech/milvus-distributed/internal/proto/commonpb"
+	math "math"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
+
+type MsgType int32
+
+const (
+	MsgType_kNone MsgType = 0
+	// Definition Requests: collection
+	MsgType_kCreateCollection   MsgType = 100
+	MsgType_kDropCollection     MsgType = 101
+	MsgType_kHasCollection      MsgType = 102
+	MsgType_kDescribeCollection MsgType = 103
+	MsgType_kShowCollections    MsgType = 104
+	MsgType_kGetSysConfigs      MsgType = 105
+	// Definition Requests: partition
+	MsgType_kCreatePartition   MsgType = 200
+	MsgType_kDropPartition     MsgType = 201
+	MsgType_kHasPartition      MsgType = 202
+	MsgType_kDescribePartition MsgType = 203
+	MsgType_kShowPartitions    MsgType = 204
+	// Definition Requests: Index
+	MsgType_kCreateIndex           MsgType = 300
+	MsgType_kDescribeIndex         MsgType = 301
+	MsgType_kDescribeIndexProgress MsgType = 302
+	// Manipulation Requests
+	MsgType_kInsert MsgType = 400
+	MsgType_kDelete MsgType = 401
+	MsgType_kFlush  MsgType = 402
+	// Query
+	MsgType_kSearch       MsgType = 500
+	MsgType_kSearchResult MsgType = 501
+	// System Control
+	MsgType_kTimeTick       MsgType = 1200
+	MsgType_kQueryNodeStats MsgType = 1201
+	MsgType_kLoadIndex      MsgType = 1202
+)
+
+var MsgType_name = map[int32]string{
+	0:    "kNone",
+	100:  "kCreateCollection",
+	101:  "kDropCollection",
+	102:  "kHasCollection",
+	103:  "kDescribeCollection",
+	104:  "kShowCollections",
+	105:  "kGetSysConfigs",
+	200:  "kCreatePartition",
+	201:  "kDropPartition",
+	202:  "kHasPartition",
+	203:  "kDescribePartition",
+	204:  "kShowPartitions",
+	300:  "kCreateIndex",
+	301:  "kDescribeIndex",
+	302:  "kDescribeIndexProgress",
+	400:  "kInsert",
+	401:  "kDelete",
+	402:  "kFlush",
+	500:  "kSearch",
+	501:  "kSearchResult",
+	1200: "kTimeTick",
+	1201: "kQueryNodeStats",
+	1202: "kLoadIndex",
+}
+
+var MsgType_value = map[string]int32{
+	"kNone":                  0,
+	"kCreateCollection":      100,
+	"kDropCollection":        101,
+	"kHasCollection":         102,
+	"kDescribeCollection":    103,
+	"kShowCollections":       104,
+	"kGetSysConfigs":         105,
+	"kCreatePartition":       200,
+	"kDropPartition":         201,
+	"kHasPartition":          202,
+	"kDescribePartition":     203,
+	"kShowPartitions":        204,
+	"kCreateIndex":           300,
+	"kDescribeIndex":         301,
+	"kDescribeIndexProgress": 302,
+	"kInsert":                400,
+	"kDelete":                401,
+	"kFlush":                 402,
+	"kSearch":                500,
+	"kSearchResult":          501,
+	"kTimeTick":              1200,
+	"kQueryNodeStats":        1201,
+	"kLoadIndex":             1202,
+}
+
+func (x MsgType) String() string {
+	return proto.EnumName(MsgType_name, int32(x))
+}
+
+func (MsgType) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor_41f4a519b878ee3b, []int{0}
+}
+
+type StateCode int32
+
+const (
+	StateCode_INITIALIZING StateCode = 0
+	StateCode_HEALTHY      StateCode = 1
+	StateCode_ABNORMAL     StateCode = 2
+)
+
+var StateCode_name = map[int32]string{
+	0: "INITIALIZING",
+	1: "HEALTHY",
+	2: "ABNORMAL",
+}
+
+var StateCode_value = map[string]int32{
+	"INITIALIZING": 0,
+	"HEALTHY":      1,
+	"ABNORMAL":     2,
+}
+
+func (x StateCode) String() string {
+	return proto.EnumName(StateCode_name, int32(x))
+}
+
+func (StateCode) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor_41f4a519b878ee3b, []int{1}
+}
+
+type NodeStates struct {
+	NodeID               int64                    `protobuf:"varint,1,opt,name=nodeID,proto3" json:"nodeID,omitempty"`
+	Role                 string                   `protobuf:"bytes,2,opt,name=role,proto3" json:"role,omitempty"`
+	StateCode            StateCode                `protobuf:"varint,3,opt,name=state_code,json=stateCode,proto3,enum=milvus.proto.internal.StateCode" json:"state_code,omitempty"`
+	ExtraInfo            []*commonpb.KeyValuePair `protobuf:"bytes,4,rep,name=extra_info,json=extraInfo,proto3" json:"extra_info,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
+	XXX_unrecognized     []byte                   `json:"-"`
+	XXX_sizecache        int32                    `json:"-"`
+}
+
+func (m *NodeStates) Reset()         { *m = NodeStates{} }
+func (m *NodeStates) String() string { return proto.CompactTextString(m) }
+func (*NodeStates) ProtoMessage()    {}
+func (*NodeStates) Descriptor() ([]byte, []int) {
+	return fileDescriptor_41f4a519b878ee3b, []int{0}
+}
+
+func (m *NodeStates) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_NodeStates.Unmarshal(m, b)
+}
+func (m *NodeStates) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_NodeStates.Marshal(b, m, deterministic)
+}
+func (m *NodeStates) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_NodeStates.Merge(m, src)
+}
+func (m *NodeStates) XXX_Size() int {
+	return xxx_messageInfo_NodeStates.Size(m)
+}
+func (m *NodeStates) XXX_DiscardUnknown() {
+	xxx_messageInfo_NodeStates.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_NodeStates proto.InternalMessageInfo
+
+func (m *NodeStates) GetNodeID() int64 {
+	if m != nil {
+		return m.NodeID
+	}
+	return 0
+}
+
+func (m *NodeStates) GetRole() string {
+	if m != nil {
+		return m.Role
+	}
+	return ""
+}
+
+func (m *NodeStates) GetStateCode() StateCode {
+	if m != nil {
+		return m.StateCode
+	}
+	return StateCode_INITIALIZING
+}
+
+func (m *NodeStates) GetExtraInfo() []*commonpb.KeyValuePair {
+	if m != nil {
+		return m.ExtraInfo
+	}
+	return nil
+}
+
+type ServiceStates struct {
+	StateCode            StateCode                `protobuf:"varint,1,opt,name=state_code,json=stateCode,proto3,enum=milvus.proto.internal.StateCode" json:"state_code,omitempty"`
+	NodeStates           []*NodeStates            `protobuf:"bytes,2,rep,name=node_states,json=nodeStates,proto3" json:"node_states,omitempty"`
+	ExtraInfo            []*commonpb.KeyValuePair `protobuf:"bytes,3,rep,name=extra_info,json=extraInfo,proto3" json:"extra_info,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
+	XXX_unrecognized     []byte                   `json:"-"`
+	XXX_sizecache        int32                    `json:"-"`
+}
+
+func (m *ServiceStates) Reset()         { *m = ServiceStates{} }
+func (m *ServiceStates) String() string { return proto.CompactTextString(m) }
+func (*ServiceStates) ProtoMessage()    {}
+func (*ServiceStates) Descriptor() ([]byte, []int) {
+	return fileDescriptor_41f4a519b878ee3b, []int{1}
+}
+
+func (m *ServiceStates) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_ServiceStates.Unmarshal(m, b)
+}
+func (m *ServiceStates) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_ServiceStates.Marshal(b, m, deterministic)
+}
+func (m *ServiceStates) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ServiceStates.Merge(m, src)
+}
+func (m *ServiceStates) XXX_Size() int {
+	return xxx_messageInfo_ServiceStates.Size(m)
+}
+func (m *ServiceStates) XXX_DiscardUnknown() {
+	xxx_messageInfo_ServiceStates.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ServiceStates proto.InternalMessageInfo
+
+func (m *ServiceStates) GetStateCode() StateCode {
+	if m != nil {
+		return m.StateCode
+	}
+	return StateCode_INITIALIZING
+}
+
+func (m *ServiceStates) GetNodeStates() []*NodeStates {
+	if m != nil {
+		return m.NodeStates
+	}
+	return nil
+}
+
+func (m *ServiceStates) GetExtraInfo() []*commonpb.KeyValuePair {
+	if m != nil {
+		return m.ExtraInfo
+	}
+	return nil
+}
+
+type NodeInfo struct {
+	Address              *commonpb.Address `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
+	Role                 string            `protobuf:"bytes,2,opt,name=role,proto3" json:"role,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
+	XXX_unrecognized     []byte            `json:"-"`
+	XXX_sizecache        int32             `json:"-"`
+}
+
+func (m *NodeInfo) Reset()         { *m = NodeInfo{} }
+func (m *NodeInfo) String() string { return proto.CompactTextString(m) }
+func (*NodeInfo) ProtoMessage()    {}
+func (*NodeInfo) Descriptor() ([]byte, []int) {
+	return fileDescriptor_41f4a519b878ee3b, []int{2}
+}
+
+func (m *NodeInfo) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_NodeInfo.Unmarshal(m, b)
+}
+func (m *NodeInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_NodeInfo.Marshal(b, m, deterministic)
+}
+func (m *NodeInfo) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_NodeInfo.Merge(m, src)
+}
+func (m *NodeInfo) XXX_Size() int {
+	return xxx_messageInfo_NodeInfo.Size(m)
+}
+func (m *NodeInfo) XXX_DiscardUnknown() {
+	xxx_messageInfo_NodeInfo.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_NodeInfo proto.InternalMessageInfo
+
+func (m *NodeInfo) GetAddress() *commonpb.Address {
+	if m != nil {
+		return m.Address
+	}
+	return nil
+}
+
+func (m *NodeInfo) GetRole() string {
+	if m != nil {
+		return m.Role
+	}
+	return ""
+}
+
+type InitParams struct {
+	NodeID               int64                    `protobuf:"varint,1,opt,name=nodeID,proto3" json:"nodeID,omitempty"`
+	StartParams          []*commonpb.KeyValuePair `protobuf:"bytes,2,rep,name=start_params,json=startParams,proto3" json:"start_params,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
+	XXX_unrecognized     []byte                   `json:"-"`
+	XXX_sizecache        int32                    `json:"-"`
+}
+
+func (m *InitParams) Reset()         { *m = InitParams{} }
+func (m *InitParams) String() string { return proto.CompactTextString(m) }
+func (*InitParams) ProtoMessage()    {}
+func (*InitParams) Descriptor() ([]byte, []int) {
+	return fileDescriptor_41f4a519b878ee3b, []int{3}
+}
+
+func (m *InitParams) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_InitParams.Unmarshal(m, b)
+}
+func (m *InitParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_InitParams.Marshal(b, m, deterministic)
+}
+func (m *InitParams) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_InitParams.Merge(m, src)
+}
+func (m *InitParams) XXX_Size() int {
+	return xxx_messageInfo_InitParams.Size(m)
+}
+func (m *InitParams) XXX_DiscardUnknown() {
+	xxx_messageInfo_InitParams.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_InitParams proto.InternalMessageInfo
+
+func (m *InitParams) GetNodeID() int64 {
+	if m != nil {
+		return m.NodeID
+	}
+	return 0
+}
+
+func (m *InitParams) GetStartParams() []*commonpb.KeyValuePair {
+	if m != nil {
+		return m.StartParams
+	}
+	return nil
+}
+
+type StringList struct {
+	Values               []string `protobuf:"bytes,2,rep,name=values,proto3" json:"values,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *StringList) Reset()         { *m = StringList{} }
+func (m *StringList) String() string { return proto.CompactTextString(m) }
+func (*StringList) ProtoMessage()    {}
+func (*StringList) Descriptor() ([]byte, []int) {
+	return fileDescriptor_41f4a519b878ee3b, []int{4}
+}
+
+func (m *StringList) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_StringList.Unmarshal(m, b)
+}
+func (m *StringList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_StringList.Marshal(b, m, deterministic)
+}
+func (m *StringList) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_StringList.Merge(m, src)
+}
+func (m *StringList) XXX_Size() int {
+	return xxx_messageInfo_StringList.Size(m)
+}
+func (m *StringList) XXX_DiscardUnknown() {
+	xxx_messageInfo_StringList.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_StringList proto.InternalMessageInfo
+
+func (m *StringList) GetValues() []string {
+	if m != nil {
+		return m.Values
+	}
+	return nil
+}
+
+type MsgBase struct {
+	MsgType              MsgType  `protobuf:"varint,1,opt,name=msg_type,json=msgType,proto3,enum=milvus.proto.internal.MsgType" json:"msg_type,omitempty"`
+	ReqID                int64    `protobuf:"varint,2,opt,name=reqID,proto3" json:"reqID,omitempty"`
+	Timestamp            uint64   `protobuf:"varint,3,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
+	SourceID             int64    `protobuf:"varint,4,opt,name=sourceID,proto3" json:"sourceID,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *MsgBase) Reset()         { *m = MsgBase{} }
+func (m *MsgBase) String() string { return proto.CompactTextString(m) }
+func (*MsgBase) ProtoMessage()    {}
+func (*MsgBase) Descriptor() ([]byte, []int) {
+	return fileDescriptor_41f4a519b878ee3b, []int{5}
+}
+
+func (m *MsgBase) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_MsgBase.Unmarshal(m, b)
+}
+func (m *MsgBase) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_MsgBase.Marshal(b, m, deterministic)
+}
+func (m *MsgBase) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MsgBase.Merge(m, src)
+}
+func (m *MsgBase) XXX_Size() int {
+	return xxx_messageInfo_MsgBase.Size(m)
+}
+func (m *MsgBase) XXX_DiscardUnknown() {
+	xxx_messageInfo_MsgBase.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MsgBase proto.InternalMessageInfo
+
+func (m *MsgBase) GetMsgType() MsgType {
+	if m != nil {
+		return m.MsgType
+	}
+	return MsgType_kNone
+}
+
+func (m *MsgBase) GetReqID() int64 {
+	if m != nil {
+		return m.ReqID
+	}
+	return 0
+}
+
+func (m *MsgBase) GetTimestamp() uint64 {
+	if m != nil {
+		return m.Timestamp
+	}
+	return 0
+}
+
+func (m *MsgBase) GetSourceID() int64 {
+	if m != nil {
+		return m.SourceID
+	}
+	return 0
+}
+
+type TimeTickMsg struct {
+	Base                 *MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *TimeTickMsg) Reset()         { *m = TimeTickMsg{} }
+func (m *TimeTickMsg) String() string { return proto.CompactTextString(m) }
+func (*TimeTickMsg) ProtoMessage()    {}
+func (*TimeTickMsg) Descriptor() ([]byte, []int) {
+	return fileDescriptor_41f4a519b878ee3b, []int{6}
+}
+
+func (m *TimeTickMsg) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_TimeTickMsg.Unmarshal(m, b)
+}
+func (m *TimeTickMsg) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_TimeTickMsg.Marshal(b, m, deterministic)
+}
+func (m *TimeTickMsg) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_TimeTickMsg.Merge(m, src)
+}
+func (m *TimeTickMsg) XXX_Size() int {
+	return xxx_messageInfo_TimeTickMsg.Size(m)
+}
+func (m *TimeTickMsg) XXX_DiscardUnknown() {
+	xxx_messageInfo_TimeTickMsg.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_TimeTickMsg proto.InternalMessageInfo
+
+func (m *TimeTickMsg) GetBase() *MsgBase {
+	if m != nil {
+		return m.Base
+	}
+	return nil
+}
+
+func init() {
+	proto.RegisterEnum("milvus.proto.internal.MsgType", MsgType_name, MsgType_value)
+	proto.RegisterEnum("milvus.proto.internal.StateCode", StateCode_name, StateCode_value)
+	proto.RegisterType((*NodeStates)(nil), "milvus.proto.internal.NodeStates")
+	proto.RegisterType((*ServiceStates)(nil), "milvus.proto.internal.ServiceStates")
+	proto.RegisterType((*NodeInfo)(nil), "milvus.proto.internal.NodeInfo")
+	proto.RegisterType((*InitParams)(nil), "milvus.proto.internal.InitParams")
+	proto.RegisterType((*StringList)(nil), "milvus.proto.internal.StringList")
+	proto.RegisterType((*MsgBase)(nil), "milvus.proto.internal.MsgBase")
+	proto.RegisterType((*TimeTickMsg)(nil), "milvus.proto.internal.TimeTickMsg")
+}
+
+func init() { proto.RegisterFile("internal.proto", fileDescriptor_41f4a519b878ee3b) }
+
+var fileDescriptor_41f4a519b878ee3b = []byte{
+	// 788 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x54, 0xdd, 0x6e, 0x1b, 0x45,
+	0x14, 0xee, 0x7a, 0xdd, 0x38, 0x7b, 0xec, 0x3a, 0xd3, 0x93, 0xa4, 0xb5, 0x4a, 0x85, 0x8c, 0xc5,
+	0x45, 0x54, 0x89, 0x44, 0x32, 0x12, 0x82, 0x2b, 0x70, 0xe2, 0xd2, 0xac, 0x70, 0x4c, 0x58, 0x5b,
+	0x95, 0xe8, 0x8d, 0xb5, 0xde, 0x3d, 0x59, 0x0f, 0xfb, 0x33, 0x66, 0x66, 0x1c, 0xea, 0x3e, 0x05,
+	0x20, 0x1e, 0x03, 0x10, 0x70, 0xcb, 0x0b, 0xf0, 0x7b, 0xcb, 0x93, 0xc0, 0x3d, 0xda, 0x59, 0xff,
+	0xc4, 0x92, 0x8b, 0x44, 0xef, 0xe6, 0x7c, 0x73, 0xce, 0x37, 0xdf, 0x77, 0xce, 0xd9, 0x85, 0x3a,
+	0xcf, 0x34, 0xc9, 0xcc, 0x4f, 0x8e, 0xa7, 0x52, 0x68, 0x81, 0x87, 0x29, 0x4f, 0xae, 0x67, 0xaa,
+	0x88, 0x8e, 0x97, 0x97, 0x0f, 0x6a, 0x81, 0x48, 0x53, 0x91, 0x15, 0x70, 0xeb, 0x67, 0x0b, 0xa0,
+	0x2f, 0x42, 0x1a, 0x68, 0x5f, 0x93, 0xc2, 0x7b, 0xb0, 0x93, 0x89, 0x90, 0xdc, 0x6e, 0xc3, 0x6a,
+	0x5a, 0x47, 0xb6, 0xb7, 0x88, 0x10, 0xa1, 0x2c, 0x45, 0x42, 0x8d, 0x52, 0xd3, 0x3a, 0x72, 0x3c,
+	0x73, 0xc6, 0xf7, 0x01, 0x54, 0x5e, 0x35, 0x0a, 0x44, 0x48, 0x0d, 0xbb, 0x69, 0x1d, 0xd5, 0xdb,
+	0xcd, 0xe3, 0xad, 0x8f, 0x1e, 0x1b, 0xfa, 0x33, 0x11, 0x92, 0xe7, 0xa8, 0xe5, 0x11, 0x3f, 0x00,
+	0xa0, 0xe7, 0x5a, 0xfa, 0x23, 0x9e, 0x5d, 0x89, 0x46, 0xb9, 0x69, 0x1f, 0x55, 0xdb, 0x6f, 0x6c,
+	0x12, 0x2c, 0xb4, 0x7e, 0x44, 0xf3, 0xa7, 0x7e, 0x32, 0xa3, 0x4b, 0x9f, 0x4b, 0xcf, 0x31, 0x45,
+	0x6e, 0x76, 0x25, 0x5a, 0x7f, 0x59, 0x70, 0x67, 0x40, 0xf2, 0x9a, 0x07, 0x4b, 0x03, 0x9b, 0xa2,
+	0xac, 0xff, 0x2f, 0xea, 0x14, 0xaa, 0xb9, 0xe7, 0x91, 0x41, 0x54, 0xa3, 0xb4, 0x4d, 0xd5, 0x8a,
+	0x61, 0xdd, 0x39, 0x0f, 0xb2, 0x75, 0x17, 0x37, 0x8d, 0xd9, 0xaf, 0x60, 0xec, 0x29, 0xec, 0xe6,
+	0xdc, 0xf9, 0x19, 0xdf, 0x81, 0x8a, 0x1f, 0x86, 0x92, 0x94, 0x32, 0x7e, 0xaa, 0xed, 0x87, 0x5b,
+	0xa9, 0x3a, 0x45, 0x8e, 0xb7, 0x4c, 0xde, 0x36, 0xb3, 0xd6, 0x67, 0x00, 0x6e, 0xc6, 0xf5, 0xa5,
+	0x2f, 0xfd, 0xf4, 0xe5, 0xd3, 0xee, 0x42, 0x4d, 0x69, 0x5f, 0xea, 0xd1, 0xd4, 0xe4, 0x6d, 0x6f,
+	0xc2, 0x36, 0x07, 0x55, 0x53, 0x56, 0xb0, 0xb7, 0xde, 0x04, 0x18, 0x68, 0xc9, 0xb3, 0xa8, 0xc7,
+	0x95, 0xce, 0xdf, 0xba, 0xce, 0xf3, 0x0a, 0x36, 0xc7, 0x5b, 0x44, 0xad, 0x6f, 0x2c, 0xa8, 0x5c,
+	0xa8, 0xe8, 0xd4, 0x57, 0x84, 0xef, 0xc1, 0x6e, 0xaa, 0xa2, 0x91, 0x9e, 0x4f, 0x97, 0xa3, 0x7b,
+	0xfd, 0x25, 0x8d, 0xbf, 0x50, 0xd1, 0x70, 0x3e, 0x25, 0xaf, 0x92, 0x16, 0x07, 0x3c, 0x80, 0xdb,
+	0x92, 0x3e, 0x77, 0xbb, 0xc6, 0xad, 0xed, 0x15, 0x01, 0x3e, 0x04, 0x47, 0xf3, 0x94, 0x94, 0xf6,
+	0xd3, 0xa9, 0xd9, 0xd0, 0xb2, 0xb7, 0x06, 0xf0, 0x01, 0xec, 0x2a, 0x31, 0x93, 0x41, 0xde, 0x80,
+	0xb2, 0x29, 0x5b, 0xc5, 0xad, 0x0e, 0x54, 0x87, 0x3c, 0xa5, 0x21, 0x0f, 0xe2, 0x0b, 0x15, 0x61,
+	0x1b, 0xca, 0x63, 0x5f, 0xd1, 0x62, 0x00, 0xff, 0xa1, 0x2a, 0xf7, 0xe1, 0x99, 0xdc, 0x47, 0x7f,
+	0xda, 0xc6, 0x99, 0x91, 0xe7, 0xc0, 0xed, 0xb8, 0x2f, 0x32, 0x62, 0xb7, 0xf0, 0x10, 0xee, 0xc6,
+	0x67, 0x92, 0xcc, 0xbe, 0x25, 0x09, 0x05, 0x9a, 0x8b, 0x8c, 0x85, 0xb8, 0x0f, 0x7b, 0x71, 0x57,
+	0x8a, 0xe9, 0x0d, 0x90, 0x10, 0xa1, 0x1e, 0x9f, 0xfb, 0xea, 0x06, 0x76, 0x85, 0xf7, 0x61, 0x3f,
+	0xee, 0x92, 0x0a, 0x24, 0x1f, 0xdf, 0x64, 0x88, 0xf0, 0x00, 0x58, 0x3c, 0x98, 0x88, 0x2f, 0xd6,
+	0xa0, 0x62, 0x13, 0x43, 0xf1, 0x84, 0xf4, 0x60, 0xae, 0xce, 0x44, 0x76, 0xc5, 0x23, 0xc5, 0x38,
+	0x1e, 0x02, 0x5b, 0x48, 0xb8, 0xf4, 0xa5, 0xe6, 0xa6, 0xfe, 0x17, 0x0b, 0xf7, 0xa1, 0x6e, 0x24,
+	0xac, 0xc1, 0x5f, 0x2d, 0x44, 0xb8, 0x93, 0x4b, 0x58, 0x63, 0xbf, 0x59, 0x78, 0x1f, 0x70, 0x25,
+	0x61, 0x7d, 0xf1, 0xbb, 0x85, 0x07, 0xb0, 0x67, 0x24, 0xac, 0x40, 0xc5, 0xfe, 0xb0, 0xf0, 0x2e,
+	0xd4, 0x16, 0xcf, 0xb9, 0x59, 0x48, 0xcf, 0xd9, 0xb7, 0xa5, 0xe2, 0xa9, 0x05, 0x43, 0x01, 0x7e,
+	0x57, 0xc2, 0xd7, 0xe0, 0xde, 0x26, 0x78, 0x29, 0x45, 0x94, 0xaf, 0x32, 0xfb, 0xbe, 0x84, 0x35,
+	0xa8, 0xc4, 0x6e, 0xa6, 0x48, 0x6a, 0xf6, 0xa5, 0x6d, 0xa2, 0x2e, 0x25, 0xa4, 0x89, 0x7d, 0x65,
+	0x63, 0x15, 0x76, 0xe2, 0x0f, 0x93, 0x99, 0x9a, 0xb0, 0xaf, 0x8b, 0xab, 0x01, 0xf9, 0x32, 0x98,
+	0xb0, 0xbf, 0x6d, 0x23, 0xbf, 0x88, 0x3c, 0x52, 0xb3, 0x44, 0xb3, 0x7f, 0x6c, 0xac, 0x83, 0x13,
+	0x2f, 0x87, 0xcb, 0x7e, 0x70, 0x8c, 0xea, 0x4f, 0x66, 0x24, 0xe7, 0xcb, 0xcf, 0x59, 0xb1, 0x1f,
+	0x1d, 0xdc, 0x03, 0x88, 0x7b, 0xc2, 0x0f, 0x0b, 0x79, 0x3f, 0x39, 0x8f, 0xde, 0x05, 0x67, 0xf5,
+	0xc7, 0x40, 0x06, 0x35, 0xb7, 0xef, 0x0e, 0xdd, 0x4e, 0xcf, 0x7d, 0xe6, 0xf6, 0x9f, 0xb0, 0x5b,
+	0x58, 0x85, 0xca, 0xf9, 0xe3, 0x4e, 0x6f, 0x78, 0xfe, 0x29, 0xb3, 0xb0, 0x06, 0xbb, 0x9d, 0xd3,
+	0xfe, 0xc7, 0xde, 0x45, 0xa7, 0xc7, 0x4a, 0xa7, 0x8f, 0x9f, 0x9d, 0x45, 0x5c, 0x4f, 0x66, 0xe3,
+	0xfc, 0xa3, 0x39, 0x79, 0xc1, 0x93, 0x84, 0xbf, 0xd0, 0x14, 0x4c, 0x4e, 0x8a, 0x35, 0x7a, 0x2b,
+	0xe4, 0x4a, 0x4b, 0x3e, 0x9e, 0x69, 0x0a, 0x4f, 0x96, 0xcb, 0x74, 0x62, 0x76, 0x6b, 0x15, 0x4e,
+	0xc7, 0xed, 0xf1, 0x8e, 0x81, 0xde, 0xfe, 0x37, 0x00, 0x00, 0xff, 0xff, 0x10, 0x34, 0x9d, 0xf8,
+	0xe9, 0x05, 0x00, 0x00,
+}

internal/proto/master_service.proto

@@ -0,0 +1,120 @@
+syntax = "proto3";
+package milvus.proto.master;
+
+option go_package="github.com/zilliztech/milvus-distributed/internal/proto/masterpb2";
+
+import "common.proto";
+import "milvus.proto";
+import "internal.proto";
+import "service_msg.proto";
+
+
+message IDRequest {
+    internal.MsgBase base = 1;
+    uint32 count = 2;
+}
+
+message IDResponse {
+    common.Status status = 1;
+    int64 ID = 2;
+    uint32 count = 3;
+}
+
+message TsoRequest {
+    internal.MsgBase base = 1;
+    uint32 count = 3;
+}
+
+message TsoResponse {
+    common.Status status = 1;
+    uint64 timestamp = 2;
+    uint32 count = 3;
+}
+
+service MasterService {
+    /**
+     * @brief This method is used to create collection
+     *
+     * @param CreateCollectionRequest, use to provide collection information to be created.
+     *
+     * @return Status
+     */
+    rpc CreateCollection(milvus.CreateCollectionRequest) returns (common.Status){}
+    
+    /**
+     * @brief This method is used to delete collection.
+     *
+     * @param DropCollectionRequest, collection name is going to be deleted.
+     *
+     * @return Status
+     */
+    rpc DropCollection(milvus.DropCollectionRequest) returns (common.Status) {}
+
+    /**
+     * @brief This method is used to test collection existence.
+     *
+     * @param HasCollectionRequest, collection name is going to be tested.
+     *
+     * @return BoolResponse
+     */
+    rpc HasCollection(milvus.HasCollectionRequest) returns (service.BoolResponse) {}
+
+    /**
+     * @brief This method is used to get collection schema.
+     *
+     * @param DescribeCollectionRequest, target collection name.
+     *
+     * @return CollectionSchema
+     */
+    rpc DescribeCollection(milvus.DescribeCollectionRequest) returns (milvus.DescribeCollectionResponse) {}
+
+    rpc GetCollectionStatistics(milvus.CollectionStatsRequest) returns (milvus.CollectionStatsResponse) {}
+
+
+    /**
+     * @brief This method is used to list all collections.
+     *
+     * @return StringListResponse, collection name list
+     */
+    rpc ShowCollections(milvus.ShowCollectionRequest) returns (milvus.ShowCollectionResponse) {}
+
+    /**
+     * @brief This method is used to create partition
+     *
+     * @return Status
+     */
+    rpc CreatePartition(milvus.CreatePartitionRequest) returns (common.Status) {}
+
+    /**
+     * @brief This method is used to drop partition
+     *
+     * @return Status
+     */
+    rpc DropPartition(milvus.DropPartitionRequest) returns (common.Status) {}
+
+    /**
+     * @brief This method is used to test partition existence.
+     *
+     * @return BoolResponse
+     */
+    rpc HasPartition(milvus.HasPartitionRequest) returns (service.BoolResponse) {}
+
+    rpc GetPartitionStatistics(milvus.PartitionStatsRequest) returns (milvus.PartitionStatsResponse) {}
+
+    /**
+     * @brief This method is used to show partition information
+     *
+     * @param ShowPartitionRequest, target collection name.
+     *
+     * @return StringListResponse
+     */
+    rpc ShowPartitions(milvus.ShowPartitionRequest) returns (milvus.ShowPartitionResponse) {}
+
+
+    rpc CreateIndex(milvus.CreateIndexRequest) returns (common.Status) {}
+    rpc DescribeIndex(milvus.DescribeIndexRequest) returns (milvus.DescribeIndexResponse) {}
+
+    rpc AllocTimestamp(TsoRequest) returns (TsoResponse) {}
+    rpc AllocID(IDRequest) returns (IDResponse) {}
+
+}

internal/proto/masterpb2/master_service.pb.go

@@ -0,0 +1,960 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: master_service.proto
+
+package masterpb2
+
+import (
+	context "context"
+	fmt "fmt"
+	proto "github.com/golang/protobuf/proto"
+	commonpb "github.com/zilliztech/milvus-distributed/internal/proto/commonpb"
+	internalpb2 "github.com/zilliztech/milvus-distributed/internal/proto/internalpb2"
+	milvuspb "github.com/zilliztech/milvus-distributed/internal/proto/milvuspb"
+	servicepb "github.com/zilliztech/milvus-distributed/internal/proto/servicepb"
+	grpc "google.golang.org/grpc"
+	codes "google.golang.org/grpc/codes"
+	status "google.golang.org/grpc/status"
+	math "math"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
+
+type IDRequest struct {
+	Base                 *internalpb2.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
+	Count                uint32               `protobuf:"varint,2,opt,name=count,proto3" json:"count,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
+	XXX_unrecognized     []byte               `json:"-"`
+	XXX_sizecache        int32                `json:"-"`
+}
+
+func (m *IDRequest) Reset()         { *m = IDRequest{} }
+func (m *IDRequest) String() string { return proto.CompactTextString(m) }
+func (*IDRequest) ProtoMessage()    {}
+func (*IDRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_9a501bcba839fe29, []int{0}
+}
+
+func (m *IDRequest) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_IDRequest.Unmarshal(m, b)
+}
+func (m *IDRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_IDRequest.Marshal(b, m, deterministic)
+}
+func (m *IDRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_IDRequest.Merge(m, src)
+}
+func (m *IDRequest) XXX_Size() int {
+	return xxx_messageInfo_IDRequest.Size(m)
+}
+func (m *IDRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_IDRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_IDRequest proto.InternalMessageInfo
+
+func (m *IDRequest) GetBase() *internalpb2.MsgBase {
+	if m != nil {
+		return m.Base
+	}
+	return nil
+}
+
+func (m *IDRequest) GetCount() uint32 {
+	if m != nil {
+		return m.Count
+	}
+	return 0
+}
+
+type IDResponse struct {
+	Status               *commonpb.Status `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
+	ID                   int64            `protobuf:"varint,2,opt,name=ID,proto3" json:"ID,omitempty"`
+	Count                uint32           `protobuf:"varint,3,opt,name=count,proto3" json:"count,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
+	XXX_unrecognized     []byte           `json:"-"`
+	XXX_sizecache        int32            `json:"-"`
+}
+
+func (m *IDResponse) Reset()         { *m = IDResponse{} }
+func (m *IDResponse) String() string { return proto.CompactTextString(m) }
+func (*IDResponse) ProtoMessage()    {}
+func (*IDResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_9a501bcba839fe29, []int{1}
+}
+
+func (m *IDResponse) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_IDResponse.Unmarshal(m, b)
+}
+func (m *IDResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_IDResponse.Marshal(b, m, deterministic)
+}
+func (m *IDResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_IDResponse.Merge(m, src)
+}
+func (m *IDResponse) XXX_Size() int {
+	return xxx_messageInfo_IDResponse.Size(m)
+}
+func (m *IDResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_IDResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_IDResponse proto.InternalMessageInfo
+
+func (m *IDResponse) GetStatus() *commonpb.Status {
+	if m != nil {
+		return m.Status
+	}
+	return nil
+}
+
+func (m *IDResponse) GetID() int64 {
+	if m != nil {
+		return m.ID
+	}
+	return 0
+}
+
+func (m *IDResponse) GetCount() uint32 {
+	if m != nil {
+		return m.Count
+	}
+	return 0
+}
+
+type TsoRequest struct {
+	Base                 *internalpb2.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
+	Count                uint32               `protobuf:"varint,3,opt,name=count,proto3" json:"count,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
+	XXX_unrecognized     []byte               `json:"-"`
+	XXX_sizecache        int32                `json:"-"`
+}
+
+func (m *TsoRequest) Reset()         { *m = TsoRequest{} }
+func (m *TsoRequest) String() string { return proto.CompactTextString(m) }
+func (*TsoRequest) ProtoMessage()    {}
+func (*TsoRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_9a501bcba839fe29, []int{2}
+}
+
+func (m *TsoRequest) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_TsoRequest.Unmarshal(m, b)
+}
+func (m *TsoRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_TsoRequest.Marshal(b, m, deterministic)
+}
+func (m *TsoRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_TsoRequest.Merge(m, src)
+}
+func (m *TsoRequest) XXX_Size() int {
+	return xxx_messageInfo_TsoRequest.Size(m)
+}
+func (m *TsoRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_TsoRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_TsoRequest proto.InternalMessageInfo
+
+func (m *TsoRequest) GetBase() *internalpb2.MsgBase {
+	if m != nil {
+		return m.Base
+	}
+	return nil
+}
+
+func (m *TsoRequest) GetCount() uint32 {
+	if m != nil {
+		return m.Count
+	}
+	return 0
+}
+
+type TsoResponse struct {
+	Status               *commonpb.Status `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
+	Timestamp            uint64           `protobuf:"varint,2,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
+	Count                uint32           `protobuf:"varint,3,opt,name=count,proto3" json:"count,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
+	XXX_unrecognized     []byte           `json:"-"`
+	XXX_sizecache        int32            `json:"-"`
+}
+
+func (m *TsoResponse) Reset()         { *m = TsoResponse{} }
+func (m *TsoResponse) String() string { return proto.CompactTextString(m) }
+func (*TsoResponse) ProtoMessage()    {}
+func (*TsoResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_9a501bcba839fe29, []int{3}
+}
+
+func (m *TsoResponse) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_TsoResponse.Unmarshal(m, b)
+}
+func (m *TsoResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_TsoResponse.Marshal(b, m, deterministic)
+}
+func (m *TsoResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_TsoResponse.Merge(m, src)
+}
+func (m *TsoResponse) XXX_Size() int {
+	return xxx_messageInfo_TsoResponse.Size(m)
+}
+func (m *TsoResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_TsoResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_TsoResponse proto.InternalMessageInfo
+
+func (m *TsoResponse) GetStatus() *commonpb.Status {
+	if m != nil {
+		return m.Status
+	}
+	return nil
+}
+
+func (m *TsoResponse) GetTimestamp() uint64 {
+	if m != nil {
+		return m.Timestamp
+	}
+	return 0
+}
+
+func (m *TsoResponse) GetCount() uint32 {
+	if m != nil {
+		return m.Count
+	}
+	return 0
+}
+
+func init() {
+	proto.RegisterType((*IDRequest)(nil), "milvus.proto.master.IDRequest")
+	proto.RegisterType((*IDResponse)(nil), "milvus.proto.master.IDResponse")
+	proto.RegisterType((*TsoRequest)(nil), "milvus.proto.master.TsoRequest")
+	proto.RegisterType((*TsoResponse)(nil), "milvus.proto.master.TsoResponse")
+}
+
+func init() { proto.RegisterFile("master_service.proto", fileDescriptor_9a501bcba839fe29) }
+
+var fileDescriptor_9a501bcba839fe29 = []byte{
+	// 607 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x95, 0xed, 0x6e, 0xd3, 0x3c,
+	0x14, 0xc7, 0xf7, 0xf6, 0xec, 0xd1, 0x4e, 0xd7, 0x0e, 0xcc, 0x04, 0x53, 0x40, 0xdb, 0xd4, 0x2f,
+	0xac, 0xed, 0x48, 0xa4, 0xee, 0x0a, 0xd6, 0x46, 0xda, 0x2a, 0x31, 0x09, 0xa5, 0x1b, 0x12, 0x20,
+	0x28, 0x49, 0x6a, 0xb5, 0x96, 0x92, 0xb8, 0xe4, 0x38, 0x1d, 0xda, 0x45, 0x73, 0x0d, 0xa8, 0x79,
+	0x71, 0xe2, 0x2d, 0xa9, 0x82, 0xe0, 0xa3, 0x9d, 0x5f, 0x7e, 0xff, 0x1e, 0x9f, 0x93, 0x1a, 0x0e,
+	0x7d, 0x1b, 0x05, 0x0d, 0x27, 0x48, 0xc3, 0x25, 0x73, 0xa9, 0xbe, 0x08, 0xb9, 0xe0, 0xe4, 0x85,
+	0xcf, 0xbc, 0x65, 0x84, 0xc9, 0x4a, 0x4f, 0x10, 0x6d, 0xdf, 0xe5, 0xbe, 0xcf, 0x83, 0x64, 0x53,
+	0xdb, 0x2f, 0x22, 0x5a, 0x8b, 0x05, 0x82, 0x86, 0x81, 0xed, 0xa5, 0xeb, 0xe7, 0xa9, 0x6f, 0xe2,
+	0xe3, 0x2c, 0xd9, 0x6a, 0xdf, 0xc1, 0xde, 0xc8, 0xb4, 0xe8, 0x8f, 0x88, 0xa2, 0x20, 0x7d, 0xd8,
+	0x71, 0x6c, 0xa4, 0x47, 0x9b, 0xa7, 0x9b, 0x67, 0x8d, 0xfe, 0xb1, 0xae, 0xe4, 0x49, 0xd7, 0x0d,
+	0xce, 0x06, 0x36, 0x52, 0x2b, 0x66, 0xc9, 0x21, 0xfc, 0xe7, 0xf2, 0x28, 0x10, 0x47, 0x5b, 0xa7,
+	0x9b, 0x67, 0x4d, 0x2b, 0x59, 0xb4, 0x67, 0x00, 0x2b, 0x2d, 0x2e, 0x78, 0x80, 0x94, 0x5c, 0xc0,
+	0x2e, 0x0a, 0x5b, 0x44, 0x98, 0x9a, 0x5f, 0xab, 0xe6, 0xb4, 0x82, 0x71, 0x8c, 0x58, 0x29, 0x4a,
+	0x5a, 0xb0, 0x35, 0x32, 0x63, 0xeb, 0xb6, 0xb5, 0x35, 0x32, 0xf3, 0xa0, 0xed, 0x62, 0xd0, 0x47,
+	0x80, 0x5b, 0xe4, 0xff, 0xa4, 0x00, 0xc5, 0xbb, 0x84, 0x46, 0xec, 0xfd, 0x9b, 0x0a, 0xde, 0xc0,
+	0x9e, 0x60, 0x3e, 0x45, 0x61, 0xfb, 0x8b, 0xb8, 0x90, 0x1d, 0x2b, 0xdf, 0x28, 0xcf, 0xed, 0xff,
+	0x6a, 0x40, 0xf3, 0x26, 0xee, 0xec, 0x38, 0xe9, 0x15, 0x99, 0xc0, 0xb3, 0x61, 0x48, 0x6d, 0x41,
+	0x87, 0xdc, 0xf3, 0xa8, 0x2b, 0x18, 0x0f, 0xc8, 0xb9, 0x1a, 0x9f, 0x2e, 0x1e, 0x63, 0xe9, 0xa9,
+	0x68, 0xeb, 0x7e, 0x6c, 0x7b, 0x83, 0x7c, 0x81, 0x96, 0x19, 0xf2, 0x45, 0x41, 0xdf, 0x2d, 0xd5,
+	0xab, 0x50, 0x4d, 0xf9, 0x77, 0x68, 0x5e, 0xdb, 0x58, 0x70, 0x77, 0x4a, 0xdd, 0x0a, 0x93, 0xa9,
+	0xdb, 0x2a, 0x9a, 0x7d, 0x0c, 0x03, 0xce, 0xbd, 0xac, 0x31, 0xed, 0x0d, 0x72, 0x0f, 0xc4, 0xa4,
+	0xe8, 0x86, 0xcc, 0x29, 0x9e, 0x90, 0x5e, 0x5e, 0xc2, 0x13, 0x30, 0xcb, 0x32, 0x6a, 0xf3, 0x32,
+	0x78, 0x09, 0xaf, 0xae, 0xa8, 0xc8, 0x1f, 0xad, 0x6a, 0x66, 0x28, 0x98, 0x8b, 0xa4, 0x57, 0xde,
+	0x1f, 0x05, 0xc5, 0x2c, 0xfa, 0xbc, 0x1e, 0x2c, 0x73, 0x3d, 0x38, 0x18, 0xcf, 0xf9, 0x7d, 0x0e,
+	0x60, 0x45, 0xc3, 0x54, 0x2a, 0x8b, 0xeb, 0xd5, 0x62, 0x65, 0xda, 0x57, 0x38, 0x48, 0xe6, 0xea,
+	0x83, 0x1d, 0x0a, 0x16, 0x9f, 0x6d, 0x6f, 0xcd, 0xf4, 0x49, 0xaa, 0xe6, 0x7c, 0x7c, 0x82, 0xe6,
+	0x6a, 0xae, 0x72, 0x79, 0xa7, 0x72, 0xf6, 0xfe, 0x54, 0xfd, 0x0d, 0xf6, 0xaf, 0x6d, 0xcc, 0xcd,
+	0x67, 0x55, 0x93, 0xf7, 0x44, 0x5c, 0x6f, 0xf0, 0x10, 0x5e, 0x5e, 0x51, 0x21, 0x5f, 0x2e, 0xb4,
+	0xbf, 0xbc, 0x1d, 0x0a, 0x89, 0xeb, 0xdb, 0xf1, 0x98, 0x95, 0xa1, 0x0c, 0x5a, 0xab, 0x56, 0xc9,
+	0xe7, 0x58, 0x71, 0x60, 0x0a, 0x94, 0x65, 0x75, 0xeb, 0xa0, 0x32, 0xea, 0x0e, 0x1a, 0x49, 0x4f,
+	0x47, 0xc1, 0x94, 0xfe, 0x24, 0x6f, 0xd7, 0x74, 0x3d, 0x26, 0x6a, 0xb6, 0x65, 0x0e, 0xcd, 0xec,
+	0xb3, 0x4a, 0xc4, 0x9d, 0xb5, 0x9f, 0x9e, 0xa2, 0xee, 0xd6, 0x41, 0x0b, 0x05, 0xb4, 0x2e, 0x3d,
+	0x8f, 0xbb, 0xb7, 0xf2, 0x3f, 0xf7, 0x44, 0x2f, 0xb9, 0x42, 0xf5, 0xfc, 0x02, 0xd1, 0x4e, 0xab,
+	0x01, 0xa9, 0x7d, 0x0f, 0xff, 0xc7, 0xda, 0x91, 0x49, 0x8e, 0x4b, 0x71, 0x79, 0xa1, 0x6a, 0x27,
+	0x95, 0xcf, 0x33, 0xdb, 0x60, 0xf8, 0xf9, 0x72, 0xc6, 0xc4, 0x3c, 0x72, 0x56, 0x07, 0x65, 0x3c,
+	0x30, 0xcf, 0x63, 0x0f, 0x82, 0xba, 0x73, 0x23, 0x79, 0xf3, 0xdd, 0x94, 0xa1, 0x08, 0x99, 0x13,
+	0x09, 0x3a, 0x35, 0xb2, 0x1b, 0xcc, 0x88, 0x75, 0x46, 0xa2, 0x5b, 0x38, 0x7d, 0x67, 0x37, 0xde,
+	0xb8, 0xf8, 0x1d, 0x00, 0x00, 0xff, 0xff, 0xe1, 0xb5, 0xf4, 0x29, 0x38, 0x08, 0x00, 0x00,
+}
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ context.Context
+var _ grpc.ClientConn
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+const _ = grpc.SupportPackageIsVersion4
+
+// MasterServiceClient is the client API for MasterService service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
+type MasterServiceClient interface {
+	//*
+	// @brief This method is used to create collection
+	//
+	// @param CreateCollectionRequest, use to provide collection information to be created.
+	//
+	// @return Status
+	CreateCollection(ctx context.Context, in *milvuspb.CreateCollectionRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
+	//*
+	// @brief This method is used to delete collection.
+	//
+	// @param DropCollectionRequest, collection name is going to be deleted.
+	//
+	// @return Status
+	DropCollection(ctx context.Context, in *milvuspb.DropCollectionRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
+	//*
+	// @brief This method is used to test collection existence.
+	//
+	// @param HasCollectionRequest, collection name is going to be tested.
+	//
+	// @return BoolResponse
+	HasCollection(ctx context.Context, in *milvuspb.HasCollectionRequest, opts ...grpc.CallOption) (*servicepb.BoolResponse, error)
+	//*
+	// @brief This method is used to get collection schema.
+	//
+	// @param DescribeCollectionRequest, target collection name.
+	//
+	// @return CollectionSchema
+	DescribeCollection(ctx context.Context, in *milvuspb.DescribeCollectionRequest, opts ...grpc.CallOption) (*milvuspb.DescribeCollectionResponse, error)
+	GetCollectionStatistics(ctx context.Context, in *milvuspb.CollectionStatsRequest, opts ...grpc.CallOption) (*milvuspb.CollectionStatsResponse, error)
+	//*
+	// @brief This method is used to list all collections.
+	//
+	// @return StringListResponse, collection name list
+	ShowCollections(ctx context.Context, in *milvuspb.ShowCollectionRequest, opts ...grpc.CallOption) (*milvuspb.ShowCollectionResponse, error)
+	//*
+	// @brief This method is used to create partition
+	//
+	// @return Status
+	CreatePartition(ctx context.Context, in *milvuspb.CreatePartitionRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
+	//*
+	// @brief This method is used to drop partition
+	//
+	// @return Status
+	DropPartition(ctx context.Context, in *milvuspb.DropPartitionRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
+	//*
+	// @brief This method is used to test partition existence.
+	//
+	// @return BoolResponse
+	HasPartition(ctx context.Context, in *milvuspb.HasPartitionRequest, opts ...grpc.CallOption) (*servicepb.BoolResponse, error)
+	GetPartitionStatistics(ctx context.Context, in *milvuspb.PartitionStatsRequest, opts ...grpc.CallOption) (*milvuspb.PartitionStatsResponse, error)
+	//*
+	// @brief This method is used to show partition information
+	//
+	// @param ShowPartitionRequest, target collection name.
+	//
+	// @return StringListResponse
+	ShowPartitions(ctx context.Context, in *milvuspb.ShowPartitionRequest, opts ...grpc.CallOption) (*milvuspb.ShowPartitionResponse, error)
+	CreateIndex(ctx context.Context, in *milvuspb.CreateIndexRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
+	DescribeIndex(ctx context.Context, in *milvuspb.DescribeIndexRequest, opts ...grpc.CallOption) (*milvuspb.DescribeIndexResponse, error)
+	AllocTimestamp(ctx context.Context, in *TsoRequest, opts ...grpc.CallOption) (*TsoResponse, error)
+	AllocID(ctx context.Context, in *IDRequest, opts ...grpc.CallOption) (*IDResponse, error)
+}
+
+type masterServiceClient struct {
+	cc *grpc.ClientConn
+}
+
+func NewMasterServiceClient(cc *grpc.ClientConn) MasterServiceClient {
+	return &masterServiceClient{cc}
+}
+
+func (c *masterServiceClient) CreateCollection(ctx context.Context, in *milvuspb.CreateCollectionRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
+	out := new(commonpb.Status)
+	err := c.cc.Invoke(ctx, "/milvus.proto.master.MasterService/CreateCollection", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *masterServiceClient) DropCollection(ctx context.Context, in *milvuspb.DropCollectionRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
+	out := new(commonpb.Status)
+	err := c.cc.Invoke(ctx, "/milvus.proto.master.MasterService/DropCollection", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *masterServiceClient) HasCollection(ctx context.Context, in *milvuspb.HasCollectionRequest, opts ...grpc.CallOption) (*servicepb.BoolResponse, error) {
+	out := new(servicepb.BoolResponse)
+	err := c.cc.Invoke(ctx, "/milvus.proto.master.MasterService/HasCollection", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *masterServiceClient) DescribeCollection(ctx context.Context, in *milvuspb.DescribeCollectionRequest, opts ...grpc.CallOption) (*milvuspb.DescribeCollectionResponse, error) {
+	out := new(milvuspb.DescribeCollectionResponse)
+	err := c.cc.Invoke(ctx, "/milvus.proto.master.MasterService/DescribeCollection", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *masterServiceClient) GetCollectionStatistics(ctx context.Context, in *milvuspb.CollectionStatsRequest, opts ...grpc.CallOption) (*milvuspb.CollectionStatsResponse, error) {
+	out := new(milvuspb.CollectionStatsResponse)
+	err := c.cc.Invoke(ctx, "/milvus.proto.master.MasterService/GetCollectionStatistics", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *masterServiceClient) ShowCollections(ctx context.Context, in *milvuspb.ShowCollectionRequest, opts ...grpc.CallOption) (*milvuspb.ShowCollectionResponse, error) {
+	out := new(milvuspb.ShowCollectionResponse)
+	err := c.cc.Invoke(ctx, "/milvus.proto.master.MasterService/ShowCollections", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *masterServiceClient) CreatePartition(ctx context.Context, in *milvuspb.CreatePartitionRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
+	out := new(commonpb.Status)
+	err := c.cc.Invoke(ctx, "/milvus.proto.master.MasterService/CreatePartition", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *masterServiceClient) DropPartition(ctx context.Context, in *milvuspb.DropPartitionRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
+	out := new(commonpb.Status)
+	err := c.cc.Invoke(ctx, "/milvus.proto.master.MasterService/DropPartition", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *masterServiceClient) HasPartition(ctx context.Context, in *milvuspb.HasPartitionRequest, opts ...grpc.CallOption) (*servicepb.BoolResponse, error) {
+	out := new(servicepb.BoolResponse)
+	err := c.cc.Invoke(ctx, "/milvus.proto.master.MasterService/HasPartition", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *masterServiceClient) GetPartitionStatistics(ctx context.Context, in *milvuspb.PartitionStatsRequest, opts ...grpc.CallOption) (*milvuspb.PartitionStatsResponse, error) {
+	out := new(milvuspb.PartitionStatsResponse)
+	err := c.cc.Invoke(ctx, "/milvus.proto.master.MasterService/GetPartitionStatistics", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *masterServiceClient) ShowPartitions(ctx context.Context, in *milvuspb.ShowPartitionRequest, opts ...grpc.CallOption) (*milvuspb.ShowPartitionResponse, error) {
+	out := new(milvuspb.ShowPartitionResponse)
+	err := c.cc.Invoke(ctx, "/milvus.proto.master.MasterService/ShowPartitions", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *masterServiceClient) CreateIndex(ctx context.Context, in *milvuspb.CreateIndexRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
+	out := new(commonpb.Status)
+	err := c.cc.Invoke(ctx, "/milvus.proto.master.MasterService/CreateIndex", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *masterServiceClient) DescribeIndex(ctx context.Context, in *milvuspb.DescribeIndexRequest, opts ...grpc.CallOption) (*milvuspb.DescribeIndexResponse, error) {
+	out := new(milvuspb.DescribeIndexResponse)
+	err := c.cc.Invoke(ctx, "/milvus.proto.master.MasterService/DescribeIndex", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *masterServiceClient) AllocTimestamp(ctx context.Context, in *TsoRequest, opts ...grpc.CallOption) (*TsoResponse, error) {
+	out := new(TsoResponse)
+	err := c.cc.Invoke(ctx, "/milvus.proto.master.MasterService/AllocTimestamp", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *masterServiceClient) AllocID(ctx context.Context, in *IDRequest, opts ...grpc.CallOption) (*IDResponse, error) {
+	out := new(IDResponse)
+	err := c.cc.Invoke(ctx, "/milvus.proto.master.MasterService/AllocID", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// MasterServiceServer is the server API for MasterService service.
+type MasterServiceServer interface {
+	//*
+	// @brief This method is used to create collection
+	//
+	// @param CreateCollectionRequest, use to provide collection information to be created.
+	//
+	// @return Status
+	CreateCollection(context.Context, *milvuspb.CreateCollectionRequest) (*commonpb.Status, error)
+	//*
+	// @brief This method is used to delete collection.
+	//
+	// @param DropCollectionRequest, collection name is going to be deleted.
+	//
+	// @return Status
+	DropCollection(context.Context, *milvuspb.DropCollectionRequest) (*commonpb.Status, error)
+	//*
+	// @brief This method is used to test collection existence.
+	//
+	// @param HasCollectionRequest, collection name is going to be tested.
+	//
+	// @return BoolResponse
+	HasCollection(context.Context, *milvuspb.HasCollectionRequest) (*servicepb.BoolResponse, error)
+	//*
+	// @brief This method is used to get collection schema.
+	//
+	// @param DescribeCollectionRequest, target collection name.
+	//
+	// @return CollectionSchema
+	DescribeCollection(context.Context, *milvuspb.DescribeCollectionRequest) (*milvuspb.DescribeCollectionResponse, error)
+	GetCollectionStatistics(context.Context, *milvuspb.CollectionStatsRequest) (*milvuspb.CollectionStatsResponse, error)
+	//*
+	// @brief This method is used to list all collections.
+	//
+	// @return StringListResponse, collection name list
+	ShowCollections(context.Context, *milvuspb.ShowCollectionRequest) (*milvuspb.ShowCollectionResponse, error)
+	//*
+	// @brief This method is used to create partition
+	//
+	// @return Status
+	CreatePartition(context.Context, *milvuspb.CreatePartitionRequest) (*commonpb.Status, error)
+	//*
+	// @brief This method is used to drop partition
+	//
+	// @return Status
+	DropPartition(context.Context, *milvuspb.DropPartitionRequest) (*commonpb.Status, error)
+	//*
+	// @brief This method is used to test partition existence.
+	//
+	// @return BoolResponse
+	HasPartition(context.Context, *milvuspb.HasPartitionRequest) (*servicepb.BoolResponse, error)
+	GetPartitionStatistics(context.Context, *milvuspb.PartitionStatsRequest) (*milvuspb.PartitionStatsResponse, error)
+	//*
+	// @brief This method is used to show partition information
+	//
+	// @param ShowPartitionRequest, target collection name.
+	//
+	// @return StringListResponse
+	ShowPartitions(context.Context, *milvuspb.ShowPartitionRequest) (*milvuspb.ShowPartitionResponse, error)
+	CreateIndex(context.Context, *milvuspb.CreateIndexRequest) (*commonpb.Status, error)
+	DescribeIndex(context.Context, *milvuspb.DescribeIndexRequest) (*milvuspb.DescribeIndexResponse, error)
+	AllocTimestamp(context.Context, *TsoRequest) (*TsoResponse, error)
+	AllocID(context.Context, *IDRequest) (*IDResponse, error)
+}
+
+// UnimplementedMasterServiceServer can be embedded to have forward compatible implementations.
+type UnimplementedMasterServiceServer struct {
+}
+
+func (*UnimplementedMasterServiceServer) CreateCollection(ctx context.Context, req *milvuspb.CreateCollectionRequest) (*commonpb.Status, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method CreateCollection not implemented")
+}
+func (*UnimplementedMasterServiceServer) DropCollection(ctx context.Context, req *milvuspb.DropCollectionRequest) (*commonpb.Status, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method DropCollection not implemented")
+}
+func (*UnimplementedMasterServiceServer) HasCollection(ctx context.Context, req *milvuspb.HasCollectionRequest) (*servicepb.BoolResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method HasCollection not implemented")
+}
+func (*UnimplementedMasterServiceServer) DescribeCollection(ctx context.Context, req *milvuspb.DescribeCollectionRequest) (*milvuspb.DescribeCollectionResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method DescribeCollection not implemented")
+}
+func (*UnimplementedMasterServiceServer) GetCollectionStatistics(ctx context.Context, req *milvuspb.CollectionStatsRequest) (*milvuspb.CollectionStatsResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method GetCollectionStatistics not implemented")
+}
+func (*UnimplementedMasterServiceServer) ShowCollections(ctx context.Context, req *milvuspb.ShowCollectionRequest) (*milvuspb.ShowCollectionResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method ShowCollections not implemented")
+}
+func (*UnimplementedMasterServiceServer) CreatePartition(ctx context.Context, req *milvuspb.CreatePartitionRequest) (*commonpb.Status, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method CreatePartition not implemented")
+}
+func (*UnimplementedMasterServiceServer) DropPartition(ctx context.Context, req *milvuspb.DropPartitionRequest) (*commonpb.Status, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method DropPartition not implemented")
+}
+func (*UnimplementedMasterServiceServer) HasPartition(ctx context.Context, req *milvuspb.HasPartitionRequest) (*servicepb.BoolResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method HasPartition not implemented")
+}
+func (*UnimplementedMasterServiceServer) GetPartitionStatistics(ctx context.Context, req *milvuspb.PartitionStatsRequest) (*milvuspb.PartitionStatsResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method GetPartitionStatistics not implemented")
+}
+func (*UnimplementedMasterServiceServer) ShowPartitions(ctx context.Context, req *milvuspb.ShowPartitionRequest) (*milvuspb.ShowPartitionResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method ShowPartitions not implemented")
+}
+func (*UnimplementedMasterServiceServer) CreateIndex(ctx context.Context, req *milvuspb.CreateIndexRequest) (*commonpb.Status, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method CreateIndex not implemented")
+}
+func (*UnimplementedMasterServiceServer) DescribeIndex(ctx context.Context, req *milvuspb.DescribeIndexRequest) (*milvuspb.DescribeIndexResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method DescribeIndex not implemented")
+}
+func (*UnimplementedMasterServiceServer) AllocTimestamp(ctx context.Context, req *TsoRequest) (*TsoResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method AllocTimestamp not implemented")
+}
+func (*UnimplementedMasterServiceServer) AllocID(ctx context.Context, req *IDRequest) (*IDResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method AllocID not implemented")
+}
+
+func RegisterMasterServiceServer(s *grpc.Server, srv MasterServiceServer) {
+	s.RegisterService(&_MasterService_serviceDesc, srv)
+}
+
+func _MasterService_CreateCollection_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(milvuspb.CreateCollectionRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(MasterServiceServer).CreateCollection(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/milvus.proto.master.MasterService/CreateCollection",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(MasterServiceServer).CreateCollection(ctx, req.(*milvuspb.CreateCollectionRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _MasterService_DropCollection_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(milvuspb.DropCollectionRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(MasterServiceServer).DropCollection(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/milvus.proto.master.MasterService/DropCollection",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(MasterServiceServer).DropCollection(ctx, req.(*milvuspb.DropCollectionRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _MasterService_HasCollection_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(milvuspb.HasCollectionRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(MasterServiceServer).HasCollection(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/milvus.proto.master.MasterService/HasCollection",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(MasterServiceServer).HasCollection(ctx, req.(*milvuspb.HasCollectionRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _MasterService_DescribeCollection_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(milvuspb.DescribeCollectionRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(MasterServiceServer).DescribeCollection(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/milvus.proto.master.MasterService/DescribeCollection",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(MasterServiceServer).DescribeCollection(ctx, req.(*milvuspb.DescribeCollectionRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _MasterService_GetCollectionStatistics_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(milvuspb.CollectionStatsRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(MasterServiceServer).GetCollectionStatistics(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/milvus.proto.master.MasterService/GetCollectionStatistics",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(MasterServiceServer).GetCollectionStatistics(ctx, req.(*milvuspb.CollectionStatsRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _MasterService_ShowCollections_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(milvuspb.ShowCollectionRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(MasterServiceServer).ShowCollections(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/milvus.proto.master.MasterService/ShowCollections",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(MasterServiceServer).ShowCollections(ctx, req.(*milvuspb.ShowCollectionRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _MasterService_CreatePartition_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(milvuspb.CreatePartitionRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(MasterServiceServer).CreatePartition(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/milvus.proto.master.MasterService/CreatePartition",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(MasterServiceServer).CreatePartition(ctx, req.(*milvuspb.CreatePartitionRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _MasterService_DropPartition_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(milvuspb.DropPartitionRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(MasterServiceServer).DropPartition(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/milvus.proto.master.MasterService/DropPartition",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(MasterServiceServer).DropPartition(ctx, req.(*milvuspb.DropPartitionRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _MasterService_HasPartition_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(milvuspb.HasPartitionRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(MasterServiceServer).HasPartition(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/milvus.proto.master.MasterService/HasPartition",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(MasterServiceServer).HasPartition(ctx, req.(*milvuspb.HasPartitionRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _MasterService_GetPartitionStatistics_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(milvuspb.PartitionStatsRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(MasterServiceServer).GetPartitionStatistics(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/milvus.proto.master.MasterService/GetPartitionStatistics",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(MasterServiceServer).GetPartitionStatistics(ctx, req.(*milvuspb.PartitionStatsRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _MasterService_ShowPartitions_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(milvuspb.ShowPartitionRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(MasterServiceServer).ShowPartitions(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/milvus.proto.master.MasterService/ShowPartitions",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(MasterServiceServer).ShowPartitions(ctx, req.(*milvuspb.ShowPartitionRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _MasterService_CreateIndex_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(milvuspb.CreateIndexRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(MasterServiceServer).CreateIndex(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/milvus.proto.master.MasterService/CreateIndex",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(MasterServiceServer).CreateIndex(ctx, req.(*milvuspb.CreateIndexRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _MasterService_DescribeIndex_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(milvuspb.DescribeIndexRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(MasterServiceServer).DescribeIndex(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/milvus.proto.master.MasterService/DescribeIndex",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(MasterServiceServer).DescribeIndex(ctx, req.(*milvuspb.DescribeIndexRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _MasterService_AllocTimestamp_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(TsoRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(MasterServiceServer).AllocTimestamp(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/milvus.proto.master.MasterService/AllocTimestamp",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(MasterServiceServer).AllocTimestamp(ctx, req.(*TsoRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _MasterService_AllocID_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(IDRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(MasterServiceServer).AllocID(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/milvus.proto.master.MasterService/AllocID",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(MasterServiceServer).AllocID(ctx, req.(*IDRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+var _MasterService_serviceDesc = grpc.ServiceDesc{
+	ServiceName: "milvus.proto.master.MasterService",
+	HandlerType: (*MasterServiceServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "CreateCollection",
+			Handler:    _MasterService_CreateCollection_Handler,
+		},
+		{
+			MethodName: "DropCollection",
+			Handler:    _MasterService_DropCollection_Handler,
+		},
+		{
+			MethodName: "HasCollection",
+			Handler:    _MasterService_HasCollection_Handler,
+		},
+		{
+			MethodName: "DescribeCollection",
+			Handler:    _MasterService_DescribeCollection_Handler,
+		},
+		{
+			MethodName: "GetCollectionStatistics",
+			Handler:    _MasterService_GetCollectionStatistics_Handler,
+		},
+		{
+			MethodName: "ShowCollections",
+			Handler:    _MasterService_ShowCollections_Handler,
+		},
+		{
+			MethodName: "CreatePartition",
+			Handler:    _MasterService_CreatePartition_Handler,
+		},
+		{
+			MethodName: "DropPartition",
+			Handler:    _MasterService_DropPartition_Handler,
+		},
+		{
+			MethodName: "HasPartition",
+			Handler:    _MasterService_HasPartition_Handler,
+		},
+		{
+			MethodName: "GetPartitionStatistics",
+			Handler:    _MasterService_GetPartitionStatistics_Handler,
+		},
+		{
+			MethodName: "ShowPartitions",
+			Handler:    _MasterService_ShowPartitions_Handler,
+		},
+		{
+			MethodName: "CreateIndex",
+			Handler:    _MasterService_CreateIndex_Handler,
+		},
+		{
+			MethodName: "DescribeIndex",
+			Handler:    _MasterService_DescribeIndex_Handler,
+		},
+		{
+			MethodName: "AllocTimestamp",
+			Handler:    _MasterService_AllocTimestamp_Handler,
+		},
+		{
+			MethodName: "AllocID",
+			Handler:    _MasterService_AllocID_Handler,
+		},
+	},
+	Streams:  []grpc.StreamDesc{},
+	Metadata: "master_service.proto",
+}

internal/proto/milvus.proto

@@ -0,0 +1,181 @@
+syntax = "proto3";
+package milvus.proto.milvus;
+
+option go_package = "github.com/zilliztech/milvus-distributed/internal/proto/milvuspb";
+
+import "common.proto";
+import "internal.proto";
+
+message CreateCollectionRequest {
+  internal.MsgBase base = 1;
+  string dbName = 2;
+  string collectionName = 3;
+  repeated bytes schema = 4;
+}
+
+
+message DropCollectionRequest {
+  internal.MsgBase base = 1;
+  string dbName = 2;
+  string collectionName = 3;
+}
+
+message HasCollectionRequest {
+  internal.MsgBase base = 1;
+  string dbName = 2;
+  string collection_name = 3;
+}
+
+message DescribeCollectionRequest {
+  internal.MsgBase base = 1;
+  string dbName = 2;
+  string collection_name = 3;
+}
+
+message DescribeCollectionResponse {
+  repeated bytes schema = 1;
+}
+
+message LoadCollectionRequest {
+  internal.MsgBase base = 1;
+  string dbName = 2;
+  string collection_name = 3;
+}
+
+message ReleaseCollectionRequest {
+  internal.MsgBase base = 1;
+  string dbName = 2;
+  string collection_name = 3;
+}
+
+message CollectionStatsRequest {
+  internal.MsgBase base = 1;
+  string dbName = 2;
+  string collection_name = 3;
+}
+
+message CollectionStatsResponse {
+  repeated common.KeyValuePair stats = 1;
+}
+
+
+message ShowCollectionRequest {
+  internal.MsgBase base = 1;
+  string dbName = 2;
+}
+
+message ShowCollectionResponse {
+  repeated string collection_names = 1;
+}
+
+
+message CreatePartitionRequest {
+  internal.MsgBase base = 1;
+  string dbName = 2;
+  string collection_name = 3;
+  string partition_name = 4;
+}
+
+
+message DropPartitionRequest {
+  internal.MsgBase base = 1;
+  string dbName = 2;
+  string collection_name = 3;
+  string partition_name = 4;
+}
+
+message HasPartitionRequest {
+  internal.MsgBase base = 1;
+  string dbName = 2;
+  string collection_name = 3;
+  string partition_name = 4;
+}
+
+message LoadPartitonRequest {
+  internal.MsgBase base = 1;
+  string db_name = 2;
+  string collection_name = 3;
+  repeated string partition_names = 4;
+}
+
+message ReleasePartitionRequest {
+  internal.MsgBase base = 1;
+  string dbName = 2;
+  string collection_name = 3;
+  repeated  string partition_names = 4;
+}
+
+message PartitionStatsRequest  {
+  internal.MsgBase base = 1;
+  string dbName = 2;
+  string collection_name = 3;
+  string partition_name = 4;
+}
+
+message PartitionStatsResponse {
+  repeated common.KeyValuePair stats = 1;
+}
+
+message ShowPartitionRequest {
+  internal.MsgBase base = 1;
+  string dbName = 2;
+  string collection_name = 3;
+}
+
+message ShowPartitionResponse {
+  repeated  string partition_names = 1;
+}
+
+
+message CreateIndexRequest {
+  internal.MsgBase base = 1;
+  string dbName = 2;
+  string collection_name = 3;
+  string field_name = 4;
+  repeated common.KeyValuePair extra_params = 5;
+}
+
+message DescribeIndexRequest {
+  internal.MsgBase base = 1;
+  string dbName = 2;
+  string collection_name = 3;
+  string field_name = 4;
+}
+
+message IndexDescription {
+  string index_name = 1;
+  repeated common.KeyValuePair params = 2;
+}
+
+message DescribeIndexResponse {
+  repeated IndexDescription index_descriptions = 1;
+}
+
+message InsertRequest {
+  internal.MsgBase base = 1;
+  string dbName = 2;
+  string collection_name = 3;
+  string partition_name = 4;
+  repeated common.Blob row_data = 5;
+  repeated uint32  hash_keys = 6;
+}
+
+message InsertResponse {
+  int64  rowID_begin = 1;
+  int64  rowID_end = 2;
+}
+
+message SearchRequest {
+  internal.MsgBase base = 1;
+  string dbName = 2;
+  string collection_name = 3;
+  repeated  string partition_names = 4;
+  string dsl = 5;
+  repeated bytes placeholder_group = 6;
+}
+
+message FlushRequest {
+  internal.MsgBase base = 1;
+  string db_name = 2;
+  string collection_name = 3;
+}

internal/proto/proxy_service.proto

@@ -0,0 +1,37 @@
+syntax = "proto3";
+package milvus.proto.proxy;
+
+option go_package = "github.com/zilliztech/milvus-distributed/internal/proto/proxypb";
+
+import "common.proto";
+import "internal.proto";
+
+
+message RegisterNodeRequest {
+  internal.MsgBase base = 1;
+  common.Address address = 2;
+}
+
+message RegisterNodeResponse {
+  internal.InitParams init_params = 1;
+}
+
+message RegisterLinkResponse {
+  common.Address address = 1;
+}
+
+message InvalidateCollMetaCacheRequest {
+  internal.MsgBase base = 1;
+  string db_name = 2;
+  string collection_name = 3;
+}
+
+service ProxyService {
+  rpc RegisterLink(common.Empty) returns (RegisterLinkResponse) {}
+  rpc RegisterNode(RegisterNodeRequest) returns (RegisterNodeResponse) {}
+  rpc InvalidateCollectionMetaCache(InvalidateCollMetaCacheRequest) returns (common.Status) {}
+}
+
+service ProxyNodeService {
+  rpc InvalidateCollectionMetaCache(InvalidateCollMetaCacheRequest) returns (common.Status) {}
+}

internal/proto/proxypb/proxy_service.pb.go

@@ -0,0 +1,471 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: proxy_service.proto
+
+package proxypb
+
+import (
+	context "context"
+	fmt "fmt"
+	proto "github.com/golang/protobuf/proto"
+	commonpb "github.com/zilliztech/milvus-distributed/internal/proto/commonpb"
+	internalpb2 "github.com/zilliztech/milvus-distributed/internal/proto/internalpb2"
+	grpc "google.golang.org/grpc"
+	codes "google.golang.org/grpc/codes"
+	status "google.golang.org/grpc/status"
+	math "math"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
+
+type RegisterNodeRequest struct {
+	Base                 *internalpb2.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
+	Address              *commonpb.Address    `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
+	XXX_unrecognized     []byte               `json:"-"`
+	XXX_sizecache        int32                `json:"-"`
+}
+
+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_34ca2fbc94d169de, []int{0}
+}
+
+func (m *RegisterNodeRequest) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_RegisterNodeRequest.Unmarshal(m, b)
+}
+func (m *RegisterNodeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_RegisterNodeRequest.Marshal(b, m, deterministic)
+}
+func (m *RegisterNodeRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_RegisterNodeRequest.Merge(m, src)
+}
+func (m *RegisterNodeRequest) XXX_Size() int {
+	return xxx_messageInfo_RegisterNodeRequest.Size(m)
+}
+func (m *RegisterNodeRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_RegisterNodeRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_RegisterNodeRequest proto.InternalMessageInfo
+
+func (m *RegisterNodeRequest) GetBase() *internalpb2.MsgBase {
+	if m != nil {
+		return m.Base
+	}
+	return nil
+}
+
+func (m *RegisterNodeRequest) GetAddress() *commonpb.Address {
+	if m != nil {
+		return m.Address
+	}
+	return nil
+}
+
+type RegisterNodeResponse struct {
+	InitParams           *internalpb2.InitParams `protobuf:"bytes,1,opt,name=init_params,json=initParams,proto3" json:"init_params,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
+	XXX_unrecognized     []byte                  `json:"-"`
+	XXX_sizecache        int32                   `json:"-"`
+}
+
+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_34ca2fbc94d169de, []int{1}
+}
+
+func (m *RegisterNodeResponse) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_RegisterNodeResponse.Unmarshal(m, b)
+}
+func (m *RegisterNodeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_RegisterNodeResponse.Marshal(b, m, deterministic)
+}
+func (m *RegisterNodeResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_RegisterNodeResponse.Merge(m, src)
+}
+func (m *RegisterNodeResponse) XXX_Size() int {
+	return xxx_messageInfo_RegisterNodeResponse.Size(m)
+}
+func (m *RegisterNodeResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_RegisterNodeResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_RegisterNodeResponse proto.InternalMessageInfo
+
+func (m *RegisterNodeResponse) GetInitParams() *internalpb2.InitParams {
+	if m != nil {
+		return m.InitParams
+	}
+	return nil
+}
+
+type RegisterLinkResponse struct {
+	Address              *commonpb.Address `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
+	XXX_unrecognized     []byte            `json:"-"`
+	XXX_sizecache        int32             `json:"-"`
+}
+
+func (m *RegisterLinkResponse) Reset()         { *m = RegisterLinkResponse{} }
+func (m *RegisterLinkResponse) String() string { return proto.CompactTextString(m) }
+func (*RegisterLinkResponse) ProtoMessage()    {}
+func (*RegisterLinkResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_34ca2fbc94d169de, []int{2}
+}
+
+func (m *RegisterLinkResponse) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_RegisterLinkResponse.Unmarshal(m, b)
+}
+func (m *RegisterLinkResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_RegisterLinkResponse.Marshal(b, m, deterministic)
+}
+func (m *RegisterLinkResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_RegisterLinkResponse.Merge(m, src)
+}
+func (m *RegisterLinkResponse) XXX_Size() int {
+	return xxx_messageInfo_RegisterLinkResponse.Size(m)
+}
+func (m *RegisterLinkResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_RegisterLinkResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_RegisterLinkResponse proto.InternalMessageInfo
+
+func (m *RegisterLinkResponse) GetAddress() *commonpb.Address {
+	if m != nil {
+		return m.Address
+	}
+	return nil
+}
+
+type InvalidateCollMetaCacheRequest struct {
+	Base                 *internalpb2.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
+	DbName               string               `protobuf:"bytes,2,opt,name=db_name,json=dbName,proto3" json:"db_name,omitempty"`
+	CollectionName       string               `protobuf:"bytes,3,opt,name=collection_name,json=collectionName,proto3" json:"collection_name,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
+	XXX_unrecognized     []byte               `json:"-"`
+	XXX_sizecache        int32                `json:"-"`
+}
+
+func (m *InvalidateCollMetaCacheRequest) Reset()         { *m = InvalidateCollMetaCacheRequest{} }
+func (m *InvalidateCollMetaCacheRequest) String() string { return proto.CompactTextString(m) }
+func (*InvalidateCollMetaCacheRequest) ProtoMessage()    {}
+func (*InvalidateCollMetaCacheRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_34ca2fbc94d169de, []int{3}
+}
+
+func (m *InvalidateCollMetaCacheRequest) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_InvalidateCollMetaCacheRequest.Unmarshal(m, b)
+}
+func (m *InvalidateCollMetaCacheRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_InvalidateCollMetaCacheRequest.Marshal(b, m, deterministic)
+}
+func (m *InvalidateCollMetaCacheRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_InvalidateCollMetaCacheRequest.Merge(m, src)
+}
+func (m *InvalidateCollMetaCacheRequest) XXX_Size() int {
+	return xxx_messageInfo_InvalidateCollMetaCacheRequest.Size(m)
+}
+func (m *InvalidateCollMetaCacheRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_InvalidateCollMetaCacheRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_InvalidateCollMetaCacheRequest proto.InternalMessageInfo
+
+func (m *InvalidateCollMetaCacheRequest) GetBase() *internalpb2.MsgBase {
+	if m != nil {
+		return m.Base
+	}
+	return nil
+}
+
+func (m *InvalidateCollMetaCacheRequest) GetDbName() string {
+	if m != nil {
+		return m.DbName
+	}
+	return ""
+}
+
+func (m *InvalidateCollMetaCacheRequest) GetCollectionName() string {
+	if m != nil {
+		return m.CollectionName
+	}
+	return ""
+}
+
+func init() {
+	proto.RegisterType((*RegisterNodeRequest)(nil), "milvus.proto.proxy.RegisterNodeRequest")
+	proto.RegisterType((*RegisterNodeResponse)(nil), "milvus.proto.proxy.RegisterNodeResponse")
+	proto.RegisterType((*RegisterLinkResponse)(nil), "milvus.proto.proxy.RegisterLinkResponse")
+	proto.RegisterType((*InvalidateCollMetaCacheRequest)(nil), "milvus.proto.proxy.InvalidateCollMetaCacheRequest")
+}
+
+func init() { proto.RegisterFile("proxy_service.proto", fileDescriptor_34ca2fbc94d169de) }
+
+var fileDescriptor_34ca2fbc94d169de = []byte{
+	// 432 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x52, 0x4d, 0x6b, 0x14, 0x41,
+	0x10, 0xdd, 0x89, 0x92, 0x60, 0x67, 0x89, 0xd2, 0x11, 0x0c, 0xa3, 0x06, 0x9d, 0x4b, 0x72, 0x71,
+	0x06, 0x46, 0xf0, 0x2a, 0xd9, 0xe0, 0x21, 0x60, 0x96, 0x30, 0x01, 0x0f, 0xb9, 0x2c, 0x3d, 0xd3,
+	0xc5, 0x6e, 0x61, 0x4f, 0xf7, 0xd8, 0x5d, 0xb3, 0x98, 0xdc, 0xbc, 0xf8, 0x13, 0xfc, 0x3b, 0xfe,
+	0x35, 0x99, 0xee, 0xec, 0x17, 0x8e, 0x0b, 0xe2, 0xc1, 0xdb, 0x54, 0xcf, 0xab, 0x57, 0xaf, 0x5e,
+	0x3d, 0x76, 0xd8, 0x58, 0xf3, 0xf5, 0x76, 0xe2, 0xc0, 0xce, 0xb1, 0x82, 0xb4, 0xb1, 0x86, 0x0c,
+	0xe7, 0x35, 0xaa, 0x79, 0xeb, 0x42, 0x95, 0x7a, 0x44, 0x3c, 0xac, 0x4c, 0x5d, 0x1b, 0x1d, 0xde,
+	0xe2, 0x03, 0xd4, 0x04, 0x56, 0x0b, 0x15, 0xea, 0xe4, 0x5b, 0xc4, 0x0e, 0x0b, 0x98, 0xa2, 0x23,
+	0xb0, 0x63, 0x23, 0xa1, 0x80, 0x2f, 0x2d, 0x38, 0xe2, 0x39, 0x7b, 0x58, 0x0a, 0x07, 0x47, 0xd1,
+	0xab, 0xe8, 0x74, 0x3f, 0x3f, 0x4e, 0x37, 0x88, 0x97, 0x1c, 0x97, 0x6e, 0x3a, 0x12, 0x0e, 0x0a,
+	0x8f, 0xe5, 0xef, 0xd8, 0x9e, 0x90, 0xd2, 0x82, 0x73, 0x47, 0x3b, 0xbe, 0xed, 0xc5, 0x66, 0xdb,
+	0xbd, 0x90, 0xb3, 0x80, 0x29, 0x16, 0xe0, 0xe4, 0x86, 0x3d, 0xdd, 0x94, 0xe0, 0x1a, 0xa3, 0x1d,
+	0xf0, 0x11, 0xdb, 0x47, 0x8d, 0x34, 0x69, 0x84, 0x15, 0xb5, 0xbb, 0x97, 0xf2, 0xfa, 0x0f, 0x52,
+	0x2e, 0x34, 0xd2, 0x95, 0x07, 0x16, 0x0c, 0x97, 0xdf, 0xc9, 0x78, 0xc5, 0xfd, 0x11, 0xf5, 0xe7,
+	0x25, 0xf7, 0x9a, 0xd6, 0xe8, 0x6f, 0xb4, 0xfe, 0x88, 0xd8, 0xf1, 0x85, 0x9e, 0x0b, 0x85, 0x52,
+	0x10, 0x9c, 0x1b, 0xa5, 0x2e, 0x81, 0xc4, 0xb9, 0xa8, 0x66, 0xff, 0x64, 0xdd, 0x33, 0xb6, 0x27,
+	0xcb, 0x89, 0x16, 0x35, 0x78, 0xeb, 0x1e, 0x15, 0xbb, 0xb2, 0x1c, 0x8b, 0x1a, 0xf8, 0x09, 0x7b,
+	0x5c, 0x19, 0xa5, 0xa0, 0x22, 0x34, 0x3a, 0x00, 0x1e, 0x78, 0xc0, 0xc1, 0xea, 0xb9, 0x03, 0xe6,
+	0x3f, 0x77, 0xd8, 0xf0, 0xaa, 0x3b, 0xf8, 0x75, 0x48, 0x04, 0xff, 0xc4, 0x86, 0xeb, 0x9b, 0xf3,
+	0xb8, 0x77, 0xc1, 0x0f, 0x75, 0x43, 0xb7, 0xf1, 0x69, 0xfa, 0x7b, 0x70, 0xd2, 0x3e, 0xdf, 0x92,
+	0x01, 0xaf, 0x56, 0xbc, 0xdd, 0xb5, 0xf8, 0xc9, 0xb6, 0xde, 0xb5, 0x48, 0x6d, 0x1f, 0xb2, 0x7e,
+	0xf8, 0x64, 0xc0, 0x2d, 0x7b, 0xb9, 0xe9, 0x72, 0xd8, 0x74, 0xe9, 0x35, 0xcf, 0xfb, 0xc8, 0xb6,
+	0x1f, 0x26, 0x7e, 0xde, 0xeb, 0xc0, 0x35, 0x09, 0x6a, 0x5d, 0x32, 0xc8, 0xbf, 0x47, 0xec, 0x89,
+	0x77, 0xb0, 0xd3, 0xb2, 0x70, 0xf1, 0x3f, 0x08, 0x19, 0x9d, 0xdd, 0xbc, 0x9f, 0x22, 0xcd, 0xda,
+	0xb2, 0xfb, 0x93, 0xdd, 0xa1, 0x52, 0x78, 0x47, 0x50, 0xcd, 0xb2, 0xd0, 0xf5, 0x46, 0xa2, 0x23,
+	0x8b, 0x65, 0x4b, 0x20, 0xb3, 0x45, 0x9e, 0x32, 0x4f, 0x95, 0xf9, 0xf1, 0x4d, 0x59, 0xee, 0xfa,
+	0xf2, 0xed, 0xaf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xe7, 0x27, 0x63, 0xbb, 0x26, 0x04, 0x00, 0x00,
+}
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ context.Context
+var _ grpc.ClientConn
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+const _ = grpc.SupportPackageIsVersion4
+
+// ProxyServiceClient is the client API for ProxyService service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
+type ProxyServiceClient interface {
+	RegisterLink(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*RegisterLinkResponse, error)
+	RegisterNode(ctx context.Context, in *RegisterNodeRequest, opts ...grpc.CallOption) (*RegisterNodeResponse, error)
+	InvalidateCollectionMetaCache(ctx context.Context, in *InvalidateCollMetaCacheRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
+}
+
+type proxyServiceClient struct {
+	cc *grpc.ClientConn
+}
+
+func NewProxyServiceClient(cc *grpc.ClientConn) ProxyServiceClient {
+	return &proxyServiceClient{cc}
+}
+
+func (c *proxyServiceClient) RegisterLink(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*RegisterLinkResponse, error) {
+	out := new(RegisterLinkResponse)
+	err := c.cc.Invoke(ctx, "/milvus.proto.proxy.ProxyService/RegisterLink", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *proxyServiceClient) RegisterNode(ctx context.Context, in *RegisterNodeRequest, opts ...grpc.CallOption) (*RegisterNodeResponse, error) {
+	out := new(RegisterNodeResponse)
+	err := c.cc.Invoke(ctx, "/milvus.proto.proxy.ProxyService/RegisterNode", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *proxyServiceClient) InvalidateCollectionMetaCache(ctx context.Context, in *InvalidateCollMetaCacheRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
+	out := new(commonpb.Status)
+	err := c.cc.Invoke(ctx, "/milvus.proto.proxy.ProxyService/InvalidateCollectionMetaCache", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// ProxyServiceServer is the server API for ProxyService service.
+type ProxyServiceServer interface {
+	RegisterLink(context.Context, *commonpb.Empty) (*RegisterLinkResponse, error)
+	RegisterNode(context.Context, *RegisterNodeRequest) (*RegisterNodeResponse, error)
+	InvalidateCollectionMetaCache(context.Context, *InvalidateCollMetaCacheRequest) (*commonpb.Status, error)
+}
+
+// UnimplementedProxyServiceServer can be embedded to have forward compatible implementations.
+type UnimplementedProxyServiceServer struct {
+}
+
+func (*UnimplementedProxyServiceServer) RegisterLink(ctx context.Context, req *commonpb.Empty) (*RegisterLinkResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method RegisterLink not implemented")
+}
+func (*UnimplementedProxyServiceServer) RegisterNode(ctx context.Context, req *RegisterNodeRequest) (*RegisterNodeResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method RegisterNode not implemented")
+}
+func (*UnimplementedProxyServiceServer) InvalidateCollectionMetaCache(ctx context.Context, req *InvalidateCollMetaCacheRequest) (*commonpb.Status, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method InvalidateCollectionMetaCache not implemented")
+}
+
+func RegisterProxyServiceServer(s *grpc.Server, srv ProxyServiceServer) {
+	s.RegisterService(&_ProxyService_serviceDesc, srv)
+}
+
+func _ProxyService_RegisterLink_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(commonpb.Empty)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(ProxyServiceServer).RegisterLink(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/milvus.proto.proxy.ProxyService/RegisterLink",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(ProxyServiceServer).RegisterLink(ctx, req.(*commonpb.Empty))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _ProxyService_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.(ProxyServiceServer).RegisterNode(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/milvus.proto.proxy.ProxyService/RegisterNode",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(ProxyServiceServer).RegisterNode(ctx, req.(*RegisterNodeRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _ProxyService_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.(ProxyServiceServer).InvalidateCollectionMetaCache(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/milvus.proto.proxy.ProxyService/InvalidateCollectionMetaCache",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(ProxyServiceServer).InvalidateCollectionMetaCache(ctx, req.(*InvalidateCollMetaCacheRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+var _ProxyService_serviceDesc = grpc.ServiceDesc{
+	ServiceName: "milvus.proto.proxy.ProxyService",
+	HandlerType: (*ProxyServiceServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "RegisterLink",
+			Handler:    _ProxyService_RegisterLink_Handler,
+		},
+		{
+			MethodName: "RegisterNode",
+			Handler:    _ProxyService_RegisterNode_Handler,
+		},
+		{
+			MethodName: "InvalidateCollectionMetaCache",
+			Handler:    _ProxyService_InvalidateCollectionMetaCache_Handler,
+		},
+	},
+	Streams:  []grpc.StreamDesc{},
+	Metadata: "proxy_service.proto",
+}
+
+// ProxyNodeServiceClient is the client API for ProxyNodeService 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 {
+	InvalidateCollectionMetaCache(ctx context.Context, in *InvalidateCollMetaCacheRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
+}
+
+type proxyNodeServiceClient struct {
+	cc *grpc.ClientConn
+}
+
+func NewProxyNodeServiceClient(cc *grpc.ClientConn) ProxyNodeServiceClient {
+	return &proxyNodeServiceClient{cc}
+}
+
+func (c *proxyNodeServiceClient) 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...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// ProxyNodeServiceServer is the server API for ProxyNodeService service.
+type ProxyNodeServiceServer interface {
+	InvalidateCollectionMetaCache(context.Context, *InvalidateCollMetaCacheRequest) (*commonpb.Status, error)
+}
+
+// UnimplementedProxyNodeServiceServer can be embedded to have forward compatible implementations.
+type UnimplementedProxyNodeServiceServer struct {
+}
+
+func (*UnimplementedProxyNodeServiceServer) InvalidateCollectionMetaCache(ctx context.Context, req *InvalidateCollMetaCacheRequest) (*commonpb.Status, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method InvalidateCollectionMetaCache not implemented")
+}
+
+func RegisterProxyNodeServiceServer(s *grpc.Server, srv ProxyNodeServiceServer) {
+	s.RegisterService(&_ProxyNodeService_serviceDesc, srv)
+}
+
+func _ProxyNodeService_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)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/milvus.proto.proxy.ProxyNodeService/InvalidateCollectionMetaCache",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(ProxyNodeServiceServer).InvalidateCollectionMetaCache(ctx, req.(*InvalidateCollMetaCacheRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+var _ProxyNodeService_serviceDesc = grpc.ServiceDesc{
+	ServiceName: "milvus.proto.proxy.ProxyNodeService",
+	HandlerType: (*ProxyNodeServiceServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "InvalidateCollectionMetaCache",
+			Handler:    _ProxyNodeService_InvalidateCollectionMetaCache_Handler,
+		},
+	},
+	Streams:  []grpc.StreamDesc{},
+	Metadata: "proxy_service.proto",
+}

internal/proto/query_service.proto

@@ -0,0 +1,160 @@
+syntax = "proto3";
+
+package milvus.proto.query;
+
+option go_package = "github.com/zilliztech/milvus-distributed/internal/proto/querypb";
+
+import "common.proto";
+import "internal.proto";
+
+
+message RegisterNodeRequest {
+  internal.MsgBase base = 1;
+  common.Address address = 2;
+}
+
+message RegisterNodeResponse {
+  internal.InitParams init_params = 1;
+}
+
+message ShowCollectionRequest {
+  internal.MsgBase base = 1;
+  int64  dbID = 2;
+}
+
+message ShowCollectionResponse  {
+  repeated int64  collectionIDs = 1;
+}
+
+message LoadCollectionRequest {
+  internal.MsgBase base = 1;
+  int64  dbID = 2;
+  int64 collectionID = 3;
+}
+
+
+message ReleaseCollectionRequest {
+  internal.MsgBase base = 1;
+  int64  dbID = 2;
+  int64 collectionID = 3;
+}
+
+
+message ShowPartitionRequest {
+  internal.MsgBase base = 1;
+  int64  dbID = 2;
+  int64  collectionID = 3;
+}
+
+message ShowPartitionResponse  {
+  repeated int64  partitionIDs = 1;
+}
+
+
+enum PartitionState {
+  NotExist = 0;
+  NotPresent = 1;
+  OnDist = 2;
+  PartialInMemory = 3;
+  InMemory = 4;
+  PartialInGPU = 5;
+  InGPU = 6;
+}
+
+message PartitionStates {
+  int64 partitionID = 1;
+  PartitionState state = 2;
+}
+
+message PartitionStatesRequest  {
+  internal.MsgBase base = 1;
+  int64  dbID = 2;
+  int64 collectionID = 3;
+  repeated int64  partitionIDs = 4;
+}
+
+message PartitionStatesResponse {
+  repeated PartitionStates partition_descriptions = 1;
+}
+
+
+message LoadPartitonRequest {
+  internal.MsgBase base = 1;
+  int64 dbID = 2;
+  int64 collectionID = 3;
+  repeated int64 partitionIDs = 4;
+}
+
+message ReleasePartitionRequest {
+  internal.MsgBase base = 1;
+  int64 dbID = 2;
+  int64 collectionID = 3;
+  repeated int64 partitionIDs = 4;
+}
+
+message CreateQueryChannelResponse {
+  string request_channel = 1;
+  string result_channel = 2;
+}
+
+
+message AddQueryChannelRequest {
+  internal.MsgBase base = 1;
+  string request_channelID = 2;
+  string result_channelID = 3;
+}
+
+
+message RemoveQueryChannelRequest {
+  internal.MsgBase base = 1;
+  string request_channelID = 2;
+  string result_channelID = 3;
+}
+
+message WatchDmChannelRequest  {
+  internal.MsgBase base = 1;
+  repeated string channelIDs = 2;
+}
+
+
+message LoadSegmentRequest {
+  internal.MsgBase base = 1;
+  int64 dbID = 2;
+  int64 collectionID = 3;
+  repeated int64 partitionIDs = 4;
+  repeated int64 segmentIDs = 5;
+  repeated int64 fieldIDs = 6;
+}
+
+message ReleaseSegmentRequest {
+  internal.MsgBase base = 1;
+  int64 dbID = 2;
+  int64 collectionID = 3;
+  repeated int64 partitionIDs = 4;
+  repeated int64 segmentIDs = 5;
+  repeated int64 fieldIDs = 6;
+}
+
+service QueryService {
+  /**
+   * @brief This method is used to create collection
+   *
+   * @param CollectionSchema, use to provide collection information to be created.
+   *
+   * @return Status
+   */
+  rpc RegisterNode(RegisterNodeRequest) returns (RegisterNodeResponse) {}
+  rpc  ShowCollections(ShowCollectionRequest) returns (ShowCollectionResponse) {}
+  rpc  LoadCollection(LoadCollectionRequest) returns (common.Status) {}
+  rpc  ReleaseCollection(ReleaseCollectionRequest) returns (common.Status) {}
+  rpc ShowPartitions(ShowPartitionRequest) returns (ShowPartitionResponse) {}
+  rpc GetPartitionStates(PartitionStatesRequest) returns (PartitionStatesResponse) {}
+  rpc LoadPartitions(LoadPartitonRequest) returns (common.Status) {}
+  rpc ReleasePartitions(ReleasePartitionRequest) returns (common.Status) {}
+  rpc CreateQueryChannel(common.Empty ) returns (CreateQueryChannelResponse) {}
+}
+
+
+
+
+

scripts/proto_gen_go.sh

@@ -20,22 +20,43 @@ pushd ${PROTO_DIR}
 mkdir -p commonpb
 mkdir -p schemapb
 mkdir -p etcdpb
+mkdir -p indexcgopb
+
 mkdir -p internalpb
 mkdir -p servicepb
 mkdir -p masterpb
 mkdir -p indexbuilderpb
-mkdir -p indexcgopb
 mkdir -p writerpb
 
+
+mkdir -p internalpb2
+mkdir -p milvuspb
+mkdir -p proxypb
+mkdir -p masterpb2
+
+mkdir -p indexpb
+mkdir -p datapb
+mkdir -p querypb
+
+
 ${protoc} --go_out=plugins=grpc,paths=source_relative:./commonpb common.proto
 ${protoc} --go_out=plugins=grpc,paths=source_relative:./schemapb schema.proto
 ${protoc} --go_out=plugins=grpc,paths=source_relative:./etcdpb etcd_meta.proto
+${protoc} --go_out=plugins=grpc,paths=source_relative:./indexcgopb index_cgo_msg.proto
+
 ${protoc} --go_out=plugins=grpc,paths=source_relative:./internalpb internal_msg.proto
 ${protoc} --go_out=plugins=grpc,paths=source_relative:./servicepb service_msg.proto
 ${protoc} --go_out=plugins=grpc,paths=source_relative:./servicepb service.proto
 ${protoc} --go_out=plugins=grpc,paths=source_relative:./masterpb master.proto
 ${protoc} --go_out=plugins=grpc,paths=source_relative:./indexbuilderpb index_builder.proto
-${protoc} --go_out=plugins=grpc,paths=source_relative:./indexcgopb index_cgo_msg.proto
 ${protoc} --go_out=plugins=grpc,paths=source_relative:./writerpb write_node.proto
 
+${protoc} --go_out=plugins=grpc,paths=source_relative:./internalpb2 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:./masterpb2 master_service.proto
+${protoc} --go_out=plugins=grpc,paths=source_relative:./indexpb index_service.proto
+${protoc} --go_out=plugins=grpc,paths=source_relative:./datapb data_service.proto
+${protoc} --go_out=plugins=grpc,paths=source_relative:./querypb query_service.proto
+
 popd