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

Replace old proto with new proto 

Signed-off-by: zhenshan.cao <zhenshan.cao@zilliz.com>
pull/4973/head^2
zhenshan.cao 2021-01-18 21:39:56 +08:00 committed by yefu.chen
parent d22c2cd203
commit 76d92e73d1
14 changed files with 669 additions and 369 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
internal/core/src/pb/common.pb.cc
View File

@ -249,21 +249,22 @@ const char descriptor_table_protodef_common_2eproto[] PROTOBUF_SECTION_VARIABLE(
"PE\020\027\022\021\n\rOUT_OF_MEMORY\020\030\022\024\n\017DD_REQUEST_RA"
"CE\020\350\007*N\n\nIndexState\022\010\n\004NONE\020\000\022\014\n\010UNISSUE"
"D\020\001\022\016\n\nINPROGRESS\020\002\022\014\n\010FINISHED\020\003\022\n\n\006FAI"
"LED\020\004*\360\003\n\007MsgType\022\t\n\005kNone\020\000\022\025\n\021kCreateC"
"LED\020\004*\245\004\n\007MsgType\022\t\n\005kNone\020\000\022\025\n\021kCreateC"
"ollection\020d\022\023\n\017kDropCollection\020e\022\022\n\016kHas"
"Collection\020f\022\027\n\023kDescribeCollection\020g\022\024\n"
"\020kShowCollections\020h\022\022\n\016kGetSysConfigs\020i\022"
"\025\n\020kCreatePartition\020\310\001\022\023\n\016kDropPartition"
"\020\311\001\022\022\n\rkHasPartition\020\312\001\022\027\n\022kDescribePart"
"ition\020\313\001\022\024\n\017kShowPartitions\020\314\001\022\021\n\014kCreat"
"eIndex\020\254\002\022\023\n\016kDescribeIndex\020\255\002\022\033\n\026kDescr"
"ibeIndexProgress\020\256\002\022\014\n\007kInsert\020\220\003\022\014\n\007kDe"
"lete\020\221\003\022\013\n\006kFlush\020\222\003\022\014\n\007kSearch\020\364\003\022\022\n\rkS"
"earchResult\020\365\003\022\016\n\tkTimeTick\020\260\t\022\024\n\017kQuery"
"NodeStats\020\261\t\022\017\n\nkLoadIndex\020\262\t\022\017\n\nkReques"
"tID\020\263\t\022\020\n\013kRequestTSO\020\264\tBBZ@github.com/z"
"illiztech/milvus-distributed/internal/pr"
"oto/commonpbb\006proto3"
"eIndex\020\254\002\022\023\n\016kDescribeIndex\020\255\002\022\014\n\007kInser"
"t\020\220\003\022\014\n\007kDelete\020\221\003\022\013\n\006kFlush\020\222\003\022\014\n\007kSear"
"ch\020\364\003\022\022\n\rkSearchResult\020\365\003\022\023\n\016kGetIndexSt"
"ate\020\366\003\022\035\n\030kGetCollectionStatistics\020\367\003\022\034\n"
"\027kGetPartitionStatistics\020\370\003\022\016\n\tkTimeTick"
"\020\260\t\022\024\n\017kQueryNodeStats\020\261\t\022\017\n\nkLoadIndex\020"
"\262\t\022\017\n\nkRequestID\020\263\t\022\020\n\013kRequestTSO\020\264\tBBZ"
"@github.com/zilliztech/milvus-distribute"
"d/internal/proto/commonpbb\006proto3"
;
static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_common_2eproto_deps[1] = {
};
@ -279,7 +280,7 @@ static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_com
static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_common_2eproto_once;
static bool descriptor_table_common_2eproto_initialized = false;
const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_common_2eproto = {
&descriptor_table_common_2eproto_initialized, descriptor_table_protodef_common_2eproto, "common.proto", 1620,
&descriptor_table_common_2eproto_initialized, descriptor_table_protodef_common_2eproto, "common.proto", 1673,
&descriptor_table_common_2eproto_once, descriptor_table_common_2eproto_sccs, descriptor_table_common_2eproto_deps, 7, 0,
schemas, file_default_instances, TableStruct_common_2eproto::offsets,
file_level_metadata_common_2eproto, 7, file_level_enum_descriptors_common_2eproto, file_level_service_descriptors_common_2eproto,
@ -364,12 +365,14 @@ bool MsgType_IsValid(int value) {
case 204:
case 300:
case 301:
case 302:
case 400:
case 401:
case 402:
case 500:
case 501:
case 502:
case 503:
case 504:
case 1200:
case 1201:
case 1202:

4
internal/core/src/pb/common.pb.h
View File

@ -186,12 +186,14 @@ enum MsgType : int {
kShowPartitions = 204,
kCreateIndex = 300,
kDescribeIndex = 301,
kDescribeIndexProgress = 302,
kInsert = 400,
kDelete = 401,
kFlush = 402,
kSearch = 500,
kSearchResult = 501,
kGetIndexState = 502,
kGetCollectionStatistics = 503,
kGetPartitionStatistics = 504,
kTimeTick = 1200,
kQueryNodeStats = 1201,
kLoadIndex = 1202,

22
internal/master/grpc_service.go
View File

@ -3,11 +3,11 @@ package master
import (
"context"
"fmt"
"time"
"github.com/zilliztech/milvus-distributed/internal/proto/commonpb"
"github.com/zilliztech/milvus-distributed/internal/proto/datapb"
"github.com/zilliztech/milvus-distributed/internal/proto/internalpb2"
"github.com/zilliztech/milvus-distributed/internal/proto/masterpb"
"github.com/zilliztech/milvus-distributed/internal/proto/milvuspb"
)
@ -468,6 +468,26 @@ func (s *Master) GetIndexState(ctx context.Context, req *milvuspb.IndexStateRequ
return task.resp, nil
}
func (s *Master) GetCollectionStatistics(ctx context.Context, request *milvuspb.CollectionStatsRequest) (*milvuspb.CollectionStatsResponse, error) {
panic("implement me")
}
func (s *Master) GetPartitionStatistics(ctx context.Context, request *milvuspb.PartitionStatsRequest) (*milvuspb.PartitionStatsResponse, error) {
panic("implement me")
}
func (s *Master) GetServiceStates(ctx context.Context, empty *commonpb.Empty) (*internalpb2.ServiceStates, error) {
panic("implement me")
}
func (s *Master) GetTimeTickChannel(ctx context.Context, empty *commonpb.Empty) (*milvuspb.StringResponse, error) {
panic("implement me")
}
func (s *Master) GetStatisticsChannel(ctx context.Context, empty *commonpb.Empty) (*milvuspb.StringResponse, error) {
panic("implement me")
}
func (s *Master) DescribeSegment(ctx context.Context, request *milvuspb.DescribeSegmentRequest) (*milvuspb.DescribeSegmentResponse, error) {
panic("implement me")
}

2
internal/master/index_task.go
View File

@ -155,7 +155,7 @@ type getIndexStateTask struct {
}
func (task *getIndexStateTask) Type() commonpb.MsgType {
return commonpb.MsgType_kDescribeIndexProgress
return commonpb.MsgType_kGetIndexState
}
func (task *getIndexStateTask) Ts() (Timestamp, error) {

13
internal/msgstream/msg.go
View File

@ -2,7 +2,6 @@ package msgstream
import (
"context"
"fmt"
"github.com/golang/protobuf/proto"
"github.com/zilliztech/milvus-distributed/internal/proto/commonpb"
@ -66,11 +65,6 @@ func (it *InsertMsg) Marshal(input TsMsg) ([]byte, error) {
if err != nil {
return nil, err
}
headerMsg := commonpb.MsgHeader{}
err2 := proto.Unmarshal(mb, &headerMsg)
if err2 != nil {
fmt.Println(err2.Error())
}
return mb, nil
}
@ -388,13 +382,6 @@ func (cc *CreateCollectionMsg) Marshal(input TsMsg) ([]byte, error) {
if err != nil {
return nil, err
}
headerMsg := commonpb.MsgHeader{}
err2 := proto.Unmarshal(mb, &headerMsg)
if err2 != nil {
fmt.Println(err2.Error())
}
return mb, nil
}

14
internal/msgstream/msgstream.go
View File

@ -2,7 +2,6 @@ package msgstream
import (
"context"
"fmt"
"log"
"reflect"
"strconv"
@ -234,14 +233,6 @@ func (ms *PulsarMsgStream) Produce(msgPack *MsgPack) error {
}
msg := &pulsar.ProducerMessage{Payload: mb}
if v.Msgs[i].Type() == commonpb.MsgType_kDelete {
headerMsg := commonpb.MsgHeader{}
err := proto.Unmarshal(mb, &headerMsg)
if err != nil {
fmt.Println(err.Error())
}
}
var child opentracing.Span
if v.Msgs[i].Type() == commonpb.MsgType_kInsert ||
@ -395,10 +386,7 @@ func (ms *PulsarMsgStream) bufMsgPackToChannel() {
(*ms.consumers[chosen]).AckID(pulsarMsg.ID())
headerMsg := commonpb.MsgHeader{}
payload := pulsarMsg.Payload()
err := proto.Unmarshal(payload, &headerMsg)
//delete2, _ := ms.unmarshal.Unmarshal(payload, commonpb.MsgType_kDelete)
//fmt.Println(delete2)
err := proto.Unmarshal(pulsarMsg.Payload(), &headerMsg)
if err != nil {
log.Printf("Failed to unmarshal message header, error = %v", err)
continue

4
internal/proto/common.proto
View File

@ -86,7 +86,6 @@ enum MsgType {
/* Definition Requests: Index */
kCreateIndex = 300;
kDescribeIndex = 301;
kDescribeIndexProgress = 302;
/* Manipulation Requests */
kInsert = 400;
@ -96,6 +95,9 @@ enum MsgType {
/* Query */
kSearch = 500;
kSearchResult = 501;
kGetIndexState = 502;
kGetCollectionStatistics = 503;
kGetPartitionStatistics = 504;
/* System Control */
kTimeTick = 1200;

202
internal/proto/commonpb/common.pb.go
View File

@ -167,16 +167,18 @@ const (
MsgType_kDescribePartition MsgType = 203
MsgType_kShowPartitions MsgType = 204
// Definition Requests: Index
MsgType_kCreateIndex MsgType = 300
MsgType_kDescribeIndex MsgType = 301
MsgType_kDescribeIndexProgress MsgType = 302
MsgType_kCreateIndex MsgType = 300
MsgType_kDescribeIndex MsgType = 301
// Manipulation Requests
MsgType_kInsert MsgType = 400
MsgType_kDelete MsgType = 401
MsgType_kFlush MsgType = 402
// Query
MsgType_kSearch MsgType = 500
MsgType_kSearchResult MsgType = 501
MsgType_kSearch MsgType = 500
MsgType_kSearchResult MsgType = 501
MsgType_kGetIndexState MsgType = 502
MsgType_kGetCollectionStatistics MsgType = 503
MsgType_kGetPartitionStatistics MsgType = 504
// System Control
MsgType_kTimeTick MsgType = 1200
MsgType_kQueryNodeStats MsgType = 1201
@ -200,12 +202,14 @@ var MsgType_name = map[int32]string{
204: "kShowPartitions",
300: "kCreateIndex",
301: "kDescribeIndex",
302: "kDescribeIndexProgress",
400: "kInsert",
401: "kDelete",
402: "kFlush",
500: "kSearch",
501: "kSearchResult",
502: "kGetIndexState",
503: "kGetCollectionStatistics",
504: "kGetPartitionStatistics",
1200: "kTimeTick",
1201: "kQueryNodeStats",
1202: "kLoadIndex",
@ -214,31 +218,33 @@ var MsgType_name = map[int32]string{
}
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,
"kRequestID": 1203,
"kRequestTSO": 1204,
"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,
"kInsert": 400,
"kDelete": 401,
"kFlush": 402,
"kSearch": 500,
"kSearchResult": 501,
"kGetIndexState": 502,
"kGetCollectionStatistics": 503,
"kGetPartitionStatistics": 504,
"kTimeTick": 1200,
"kQueryNodeStats": 1201,
"kLoadIndex": 1202,
"kRequestID": 1203,
"kRequestTSO": 1204,
}
func (x MsgType) String() string {
@ -579,70 +585,72 @@ func init() {
func init() { proto.RegisterFile("common.proto", fileDescriptor_555bd8c177793206) }
var fileDescriptor_555bd8c177793206 = []byte{
// 1038 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x54, 0x5b, 0x6f, 0xe3, 0x44,
0x14, 0xde, 0x5c, 0xda, 0xd4, 0x27, 0x69, 0x3a, 0x9d, 0xde, 0x02, 0x5b, 0xa1, 0x2a, 0x4f, 0x55,
0xa5, 0x6d, 0x11, 0x48, 0xf0, 0xb4, 0x12, 0xae, 0x3d, 0x69, 0x47, 0xeb, 0x4b, 0x76, 0xec, 0x2c,
0x5d, 0x5e, 0x2c, 0x27, 0x9e, 0x4d, 0x2c, 0x3b, 0x71, 0xf0, 0x38, 0x0b, 0xd9, 0x5f, 0x01, 0xfb,
0x3b, 0x00, 0x71, 0x7b, 0xe0, 0x27, 0x70, 0xfb, 0x21, 0x3c, 0xf2, 0x00, 0xef, 0x68, 0xec, 0xb8,
0x09, 0x68, 0x79, 0x9b, 0xf3, 0x9d, 0xf9, 0xbe, 0xf9, 0xce, 0x99, 0x99, 0x03, 0xad, 0x51, 0x32,
0x9d, 0x26, 0xb3, 0xcb, 0x79, 0x9a, 0x64, 0x09, 0x3e, 0x98, 0x86, 0xf1, 0xcb, 0x85, 0x28, 0xa2,
0xcb, 0x22, 0xd5, 0x6d, 0xc0, 0x16, 0x99, 0xce, 0xb3, 0x65, 0xd7, 0x83, 0x6d, 0x27, 0xf3, 0xb3,
0x85, 0xc0, 0x8f, 0x01, 0x78, 0x9a, 0x26, 0xa9, 0x37, 0x4a, 0x02, 0xde, 0xa9, 0x9c, 0x55, 0xce,
0xdb, 0xef, 0xbd, 0x73, 0xf9, 0x06, 0xf2, 0x25, 0x91, 0xdb, 0xb4, 0x24, 0xe0, 0x4c, 0xe1, 0xe5,
0x12, 0x1f, 0xc3, 0x76, 0xca, 0x7d, 0x91, 0xcc, 0x3a, 0xd5, 0xb3, 0xca, 0xb9, 0xc2, 0x56, 0x51,
0xf7, 0x03, 0x68, 0x3d, 0xe1, 0xcb, 0x67, 0x7e, 0xbc, 0xe0, 0x7d, 0x3f, 0x4c, 0x31, 0x82, 0x5a,
0xc4, 0x97, 0xb9, 0xbe, 0xc2, 0xe4, 0x12, 0x1f, 0xc2, 0xd6, 0x4b, 0x99, 0x5e, 0x11, 0x8b, 0xa0,
0x7b, 0x0a, 0xf5, 0xeb, 0x38, 0x19, 0xae, 0xb3, 0x92, 0xd1, 0x2a, 0xb3, 0x8f, 0xa0, 0xa1, 0x06,
0x41, 0xca, 0x85, 0xc0, 0x6d, 0xa8, 0x86, 0xf3, 0x95, 0x5e, 0x35, 0x9c, 0x63, 0x0c, 0xf5, 0x79,
0x92, 0x66, 0xb9, 0x5a, 0x8d, 0xe5, 0xeb, 0xee, 0xeb, 0x0a, 0x34, 0x4c, 0x31, 0xbe, 0xf6, 0x05,
0xc7, 0x1f, 0xc2, 0xce, 0x54, 0x8c, 0xbd, 0x6c, 0x39, 0x2f, 0xab, 0x3c, 0x7d, 0x63, 0x95, 0xa6,
0x18, 0xbb, 0xcb, 0x39, 0x67, 0x8d, 0x69, 0xb1, 0x90, 0x4e, 0xa6, 0x62, 0x4c, 0xf5, 0x95, 0x72,
0x11, 0xe0, 0x53, 0x50, 0xb2, 0x70, 0xca, 0x45, 0xe6, 0x4f, 0xe7, 0x9d, 0xda, 0x59, 0xe5, 0xbc,
0xce, 0xd6, 0x00, 0x7e, 0x1b, 0x76, 0x44, 0xb2, 0x48, 0x47, 0x9c, 0xea, 0x9d, 0x7a, 0x4e, 0xbb,
0x8f, 0xbb, 0x8f, 0x41, 0x31, 0xc5, 0xf8, 0x96, 0xfb, 0x01, 0x4f, 0xf1, 0xbb, 0x50, 0x1f, 0xfa,
0xa2, 0x70, 0xd4, 0xfc, 0x7f, 0x47, 0xb2, 0x02, 0x96, 0xef, 0xbc, 0xf8, 0xa9, 0x0e, 0xca, 0xfd,
0x4d, 0xe0, 0x26, 0x34, 0x9c, 0x81, 0xa6, 0x11, 0xc7, 0x41, 0x0f, 0xf0, 0x21, 0xa0, 0x81, 0x45,
0xee, 0xfa, 0x44, 0x73, 0x89, 0xee, 0x11, 0xc6, 0x6c, 0x86, 0x2a, 0x18, 0x43, 0x5b, 0xb3, 0x2d,
0x8b, 0x68, 0xae, 0xd7, 0x53, 0xa9, 0x41, 0x74, 0x54, 0xc5, 0x47, 0xb0, 0xdf, 0x27, 0xcc, 0xa4,
0x8e, 0x43, 0x6d, 0xcb, 0xd3, 0x89, 0x45, 0x89, 0x8e, 0x6a, 0xf8, 0x2d, 0x38, 0xd2, 0x6c, 0xc3,
0x20, 0x9a, 0x2b, 0x61, 0xcb, 0x76, 0x3d, 0x72, 0x47, 0x1d, 0xd7, 0x41, 0x75, 0xa9, 0x4d, 0x0d,
0x83, 0xdc, 0xa8, 0x86, 0xa7, 0xb2, 0x9b, 0x81, 0x49, 0x2c, 0x17, 0x6d, 0x49, 0x9d, 0x12, 0xd5,
0xa9, 0x49, 0x2c, 0x29, 0x87, 0x1a, 0xf8, 0x18, 0x70, 0x09, 0x53, 0x4b, 0x27, 0x77, 0x9e, 0xfb,
0xbc, 0x4f, 0xd0, 0x0e, 0x7e, 0x08, 0x27, 0x25, 0xbe, 0x79, 0x8e, 0x6a, 0x12, 0xa4, 0x60, 0x04,
0xad, 0x32, 0xe9, 0xda, 0xfd, 0x27, 0x08, 0x36, 0xd5, 0x99, 0xfd, 0x31, 0x23, 0x9a, 0xcd, 0x74,
0xd4, 0xdc, 0x84, 0x9f, 0x11, 0xcd, 0xb5, 0x99, 0x47, 0x75, 0xd4, 0x92, 0xe6, 0x4b, 0xd8, 0x21,
0x2a, 0xd3, 0x6e, 0x3d, 0x46, 0x9c, 0x81, 0xe1, 0xa2, 0x5d, 0xd9, 0x82, 0x1e, 0x35, 0x48, 0x5e,
0x51, 0xcf, 0x1e, 0x58, 0x3a, 0x6a, 0xe3, 0x3d, 0x68, 0x9a, 0xc4, 0x55, 0xcb, 0x9e, 0xec, 0xc9,
0xf3, 0x35, 0x55, 0xbb, 0x25, 0x25, 0x82, 0x70, 0x07, 0x0e, 0x35, 0xd5, 0x92, 0x24, 0x8d, 0x11,
0xd5, 0x25, 0x5e, 0xcf, 0x36, 0x74, 0xc2, 0xd0, 0xbe, 0x2c, 0xf0, 0x3f, 0x19, 0x6a, 0x10, 0x84,
0x37, 0x18, 0x3a, 0x31, 0xc8, 0x9a, 0x71, 0xb0, 0xc1, 0x28, 0x33, 0x92, 0x71, 0x28, 0x8b, 0xb9,
0x1e, 0x50, 0x43, 0x5f, 0x35, 0xaa, 0xb8, 0xb4, 0x23, 0xbc, 0x0f, 0xbb, 0x65, 0x31, 0x96, 0x41,
0x1d, 0x17, 0x1d, 0xe3, 0x13, 0x38, 0x28, 0x21, 0x93, 0xb8, 0x8c, 0x6a, 0x45, 0x57, 0x4f, 0xe4,
0x5e, 0x7b, 0xe0, 0x7a, 0x76, 0xcf, 0x33, 0x89, 0x69, 0xb3, 0xe7, 0xa8, 0x83, 0x0f, 0x61, 0x4f,
0xd7, 0x3d, 0x46, 0x9e, 0x0e, 0x88, 0xe3, 0x7a, 0x4c, 0xd5, 0x08, 0xfa, 0xa3, 0x71, 0x61, 0x01,
0xd0, 0x59, 0xc0, 0x3f, 0x97, 0x3f, 0x9f, 0xe3, 0x1d, 0xa8, 0x5b, 0xb6, 0x45, 0xd0, 0x03, 0xdc,
0x82, 0x9d, 0x81, 0x45, 0x1d, 0x67, 0x40, 0x74, 0x54, 0xc1, 0x6d, 0x00, 0x6a, 0xf5, 0x99, 0x7d,
0xc3, 0xe4, 0xab, 0xaa, 0xca, 0x6c, 0x8f, 0x5a, 0xd4, 0xb9, 0xcd, 0x9f, 0x08, 0xc0, 0xf6, 0xaa,
0x3f, 0xf5, 0x8b, 0x3f, 0x6b, 0xf9, 0xf7, 0xca, 0x7f, 0x89, 0x02, 0x5b, 0x91, 0x95, 0xcc, 0x38,
0x7a, 0x20, 0x4b, 0x8a, 0xb4, 0x94, 0xfb, 0x19, 0xd7, 0x92, 0x38, 0xe6, 0xa3, 0x2c, 0x4c, 0x66,
0x28, 0xc0, 0x07, 0xb0, 0x17, 0xe9, 0x69, 0x32, 0xdf, 0x00, 0xb9, 0xbc, 0x99, 0xe8, 0xd6, 0x17,
0x1b, 0xd8, 0x0b, 0x59, 0x68, 0xa4, 0x73, 0x31, 0x4a, 0xc3, 0xe1, 0xa6, 0xc2, 0x58, 0xbe, 0xc1,
0xc8, 0x99, 0x24, 0x9f, 0xad, 0x41, 0x81, 0x26, 0xb9, 0xc4, 0x0d, 0xcf, 0x9c, 0xa5, 0xd0, 0x92,
0xd9, 0x8b, 0x70, 0x2c, 0x50, 0x88, 0x8f, 0x00, 0xad, 0x2c, 0xf4, 0xfd, 0x34, 0x0b, 0x73, 0xfe,
0xcf, 0x15, 0x7c, 0x00, 0xed, 0xdc, 0xc2, 0x1a, 0xfc, 0x45, 0xfe, 0x8f, 0x5d, 0x69, 0x61, 0x8d,
0xfd, 0x5a, 0xc1, 0x27, 0x80, 0xef, 0x2d, 0xac, 0x13, 0xbf, 0x55, 0x64, 0x63, 0x73, 0x0b, 0xf7,
0xa0, 0x40, 0xbf, 0x57, 0xf0, 0x3e, 0xb4, 0x56, 0xc7, 0xe5, 0xfd, 0x45, 0x5f, 0x55, 0x8b, 0xa3,
0x56, 0x0a, 0x05, 0xf8, 0x75, 0x15, 0x3f, 0x84, 0xe3, 0x7f, 0x83, 0xfd, 0x34, 0x19, 0xcb, 0x69,
0x86, 0xbe, 0x91, 0x7d, 0x6e, 0x44, 0x74, 0x26, 0x78, 0x9a, 0xa1, 0x2f, 0x6a, 0x79, 0xa4, 0xf3,
0x98, 0x67, 0x1c, 0x7d, 0x59, 0xc3, 0x4d, 0xd8, 0x8e, 0x7a, 0xf1, 0x42, 0x4c, 0xd0, 0xeb, 0x22,
0xe5, 0x70, 0x3f, 0x1d, 0x4d, 0xd0, 0x5f, 0xb5, 0xdc, 0x7e, 0x11, 0x31, 0x2e, 0x16, 0x71, 0x86,
0xfe, 0xae, 0xe1, 0x36, 0x28, 0x91, 0x1b, 0x4e, 0xb9, 0x1b, 0x8e, 0x22, 0xf4, 0xad, 0x92, 0xbb,
0x7e, 0xba, 0xe0, 0xe9, 0xd2, 0x4a, 0x02, 0x2e, 0x6f, 0x5f, 0xa0, 0xef, 0x14, 0xbc, 0x07, 0x10,
0x19, 0x89, 0x1f, 0x14, 0xf6, 0xbe, 0x2f, 0x00, 0xc6, 0x3f, 0x5d, 0x70, 0x91, 0x51, 0x1d, 0xfd,
0x20, 0xbf, 0x64, 0xb3, 0x04, 0x5c, 0xc7, 0x46, 0x3f, 0x2a, 0xd7, 0xd7, 0x9f, 0x7c, 0x34, 0x0e,
0xb3, 0xc9, 0x62, 0x28, 0x87, 0xd3, 0xd5, 0xab, 0x30, 0x8e, 0xc3, 0x57, 0x19, 0x1f, 0x4d, 0xae,
0x8a, 0xc1, 0xf5, 0x28, 0x08, 0x45, 0x96, 0x86, 0xc3, 0x45, 0xc6, 0x83, 0xab, 0x70, 0x96, 0xf1,
0x74, 0xe6, 0xc7, 0x57, 0xf9, 0x34, 0xbb, 0x2a, 0xa6, 0xd9, 0x7c, 0x38, 0xdc, 0xce, 0xe3, 0xf7,
0xff, 0x09, 0x00, 0x00, 0xff, 0xff, 0xbf, 0x87, 0x1d, 0x81, 0xb0, 0x06, 0x00, 0x00,
// 1062 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x54, 0xcb, 0x6e, 0xe3, 0x36,
0x17, 0x1e, 0x5f, 0x12, 0x47, 0xc7, 0x8e, 0xc3, 0x30, 0x37, 0xff, 0x7f, 0xd3, 0x22, 0xf0, 0x2a,
0x08, 0x30, 0x49, 0xd1, 0x02, 0xed, 0x6a, 0x80, 0x3a, 0x12, 0x9d, 0x10, 0x23, 0x4b, 0x1e, 0x4a,
0x9e, 0x66, 0xba, 0x11, 0x64, 0x8b, 0x63, 0x0b, 0x92, 0x2d, 0x57, 0xa4, 0xa7, 0xf5, 0x3c, 0x45,
0x3b, 0xef, 0xd0, 0x5d, 0x0b, 0xf4, 0xb6, 0xe8, 0x23, 0xf4, 0xf6, 0x20, 0x7d, 0x80, 0xde, 0x96,
0x05, 0x25, 0x2b, 0x36, 0x8a, 0xe9, 0x8e, 0xe7, 0xfb, 0x78, 0x3e, 0x9e, 0xef, 0x90, 0x87, 0xd0,
0x18, 0x25, 0xd3, 0x69, 0x32, 0xbb, 0x9c, 0xa7, 0x89, 0x4c, 0xf0, 0xc1, 0x34, 0x8c, 0x5f, 0x2c,
0x44, 0x1e, 0x5d, 0xe6, 0x54, 0xbb, 0x06, 0x5b, 0x64, 0x3a, 0x97, 0xcb, 0xb6, 0x07, 0xdb, 0x8e,
0xf4, 0xe5, 0x42, 0xe0, 0x47, 0x00, 0x3c, 0x4d, 0x93, 0xd4, 0x1b, 0x25, 0x01, 0x6f, 0x95, 0xce,
0x4a, 0xe7, 0xcd, 0x77, 0xde, 0xba, 0x7c, 0x4d, 0xf2, 0x25, 0x51, 0xdb, 0xf4, 0x24, 0xe0, 0x4c,
0xe3, 0xc5, 0x12, 0x1f, 0xc3, 0x76, 0xca, 0x7d, 0x91, 0xcc, 0x5a, 0xe5, 0xb3, 0xd2, 0xb9, 0xc6,
0x56, 0x51, 0xfb, 0x3d, 0x68, 0x3c, 0xe6, 0xcb, 0xa7, 0x7e, 0xbc, 0xe0, 0x7d, 0x3f, 0x4c, 0x31,
0x82, 0x4a, 0xc4, 0x97, 0x99, 0xbe, 0xc6, 0xd4, 0x12, 0x1f, 0xc2, 0xd6, 0x0b, 0x45, 0xaf, 0x12,
0xf3, 0xa0, 0x7d, 0x0a, 0xd5, 0xeb, 0x38, 0x19, 0xae, 0x59, 0x95, 0xd1, 0x28, 0xd8, 0x87, 0x50,
0xeb, 0x04, 0x41, 0xca, 0x85, 0xc0, 0x4d, 0x28, 0x87, 0xf3, 0x95, 0x5e, 0x39, 0x9c, 0x63, 0x0c,
0xd5, 0x79, 0x92, 0xca, 0x4c, 0xad, 0xc2, 0xb2, 0x75, 0xfb, 0x55, 0x09, 0x6a, 0x3d, 0x31, 0xbe,
0xf6, 0x05, 0xc7, 0xef, 0xc3, 0xce, 0x54, 0x8c, 0x3d, 0xb9, 0x9c, 0x17, 0x2e, 0x4f, 0x5f, 0xeb,
0xb2, 0x27, 0xc6, 0xee, 0x72, 0xce, 0x59, 0x6d, 0x9a, 0x2f, 0x54, 0x25, 0x53, 0x31, 0xa6, 0xc6,
0x4a, 0x39, 0x0f, 0xf0, 0x29, 0x68, 0x32, 0x9c, 0x72, 0x21, 0xfd, 0xe9, 0xbc, 0x55, 0x39, 0x2b,
0x9d, 0x57, 0xd9, 0x1a, 0xc0, 0xff, 0x87, 0x1d, 0x91, 0x2c, 0xd2, 0x11, 0xa7, 0x46, 0xab, 0x9a,
0xa5, 0xdd, 0xc7, 0xed, 0x47, 0xa0, 0xf5, 0xc4, 0xf8, 0x96, 0xfb, 0x01, 0x4f, 0xf1, 0xdb, 0x50,
0x1d, 0xfa, 0x22, 0xaf, 0xa8, 0xfe, 0xdf, 0x15, 0x29, 0x07, 0x2c, 0xdb, 0x79, 0xf1, 0x43, 0x15,
0xb4, 0xfb, 0x9b, 0xc0, 0x75, 0xa8, 0x39, 0x03, 0x5d, 0x27, 0x8e, 0x83, 0x1e, 0xe0, 0x43, 0x40,
0x03, 0x8b, 0xdc, 0xf5, 0x89, 0xee, 0x12, 0xc3, 0x23, 0x8c, 0xd9, 0x0c, 0x95, 0x30, 0x86, 0xa6,
0x6e, 0x5b, 0x16, 0xd1, 0x5d, 0xaf, 0xdb, 0xa1, 0x26, 0x31, 0x50, 0x19, 0x1f, 0xc1, 0x7e, 0x9f,
0xb0, 0x1e, 0x75, 0x1c, 0x6a, 0x5b, 0x9e, 0x41, 0x2c, 0x4a, 0x0c, 0x54, 0xc1, 0xff, 0x83, 0x23,
0xdd, 0x36, 0x4d, 0xa2, 0xbb, 0x0a, 0xb6, 0x6c, 0xd7, 0x23, 0x77, 0xd4, 0x71, 0x1d, 0x54, 0x55,
0xda, 0xd4, 0x34, 0xc9, 0x4d, 0xc7, 0xf4, 0x3a, 0xec, 0x66, 0xd0, 0x23, 0x96, 0x8b, 0xb6, 0x94,
0x4e, 0x81, 0x1a, 0xb4, 0x47, 0x2c, 0x25, 0x87, 0x6a, 0xf8, 0x18, 0x70, 0x01, 0x53, 0xcb, 0x20,
0x77, 0x9e, 0xfb, 0xac, 0x4f, 0xd0, 0x0e, 0x7e, 0x03, 0x4e, 0x0a, 0x7c, 0xf3, 0x9c, 0x4e, 0x8f,
0x20, 0x0d, 0x23, 0x68, 0x14, 0xa4, 0x6b, 0xf7, 0x1f, 0x23, 0xd8, 0x54, 0x67, 0xf6, 0x87, 0x8c,
0xe8, 0x36, 0x33, 0x50, 0x7d, 0x13, 0x7e, 0x4a, 0x74, 0xd7, 0x66, 0x1e, 0x35, 0x50, 0x43, 0x15,
0x5f, 0xc0, 0x0e, 0xe9, 0x30, 0xfd, 0xd6, 0x63, 0xc4, 0x19, 0x98, 0x2e, 0xda, 0x55, 0x2d, 0xe8,
0x52, 0x93, 0x64, 0x8e, 0xba, 0xf6, 0xc0, 0x32, 0x50, 0x13, 0xef, 0x41, 0xbd, 0x47, 0xdc, 0x4e,
0xd1, 0x93, 0x3d, 0x75, 0xbe, 0xde, 0xd1, 0x6f, 0x49, 0x81, 0x20, 0xdc, 0x82, 0x43, 0xbd, 0x63,
0xa9, 0x24, 0x9d, 0x91, 0x8e, 0x4b, 0xbc, 0xae, 0x6d, 0x1a, 0x84, 0xa1, 0x7d, 0x65, 0xf0, 0x5f,
0x0c, 0x35, 0x09, 0xc2, 0x1b, 0x19, 0x06, 0x31, 0xc9, 0x3a, 0xe3, 0x60, 0x23, 0xa3, 0x60, 0x54,
0xc6, 0xa1, 0x32, 0x73, 0x3d, 0xa0, 0xa6, 0xb1, 0x6a, 0x54, 0x7e, 0x69, 0x47, 0x78, 0x1f, 0x76,
0x0b, 0x33, 0x96, 0x49, 0x1d, 0x17, 0x1d, 0xe3, 0x13, 0x38, 0x28, 0xa0, 0x1e, 0x71, 0x19, 0xd5,
0xf3, 0xae, 0x9e, 0xa8, 0xbd, 0xf6, 0xc0, 0xf5, 0xec, 0xae, 0xd7, 0x23, 0x3d, 0x9b, 0x3d, 0x43,
0x2d, 0x7c, 0x08, 0x7b, 0x86, 0xe1, 0x31, 0xf2, 0x64, 0x40, 0x1c, 0xd7, 0x63, 0x1d, 0x9d, 0xa0,
0xdf, 0x6a, 0x17, 0x16, 0x00, 0x9d, 0x05, 0xfc, 0x53, 0x35, 0xf9, 0x1c, 0xef, 0x40, 0xd5, 0xb2,
0x2d, 0x82, 0x1e, 0xe0, 0x06, 0xec, 0x0c, 0x2c, 0xea, 0x38, 0x03, 0x62, 0xa0, 0x12, 0x6e, 0x02,
0x50, 0xab, 0xcf, 0xec, 0x1b, 0xa6, 0x5e, 0x55, 0x59, 0xb1, 0x5d, 0x6a, 0x51, 0xe7, 0x36, 0x7b,
0x22, 0x00, 0xdb, 0xab, 0xfe, 0x54, 0x2f, 0xbe, 0xa8, 0x66, 0xe3, 0x95, 0x4d, 0x89, 0x06, 0x5b,
0x91, 0x95, 0xcc, 0x38, 0x7a, 0xa0, 0x2c, 0x45, 0x7a, 0xca, 0x7d, 0xc9, 0xf5, 0x24, 0x8e, 0xf9,
0x48, 0x86, 0xc9, 0x0c, 0x05, 0xf8, 0x00, 0xf6, 0x22, 0x23, 0x4d, 0xe6, 0x1b, 0x20, 0x57, 0x37,
0x13, 0xdd, 0xfa, 0x62, 0x03, 0x7b, 0xae, 0x8c, 0x46, 0x06, 0x17, 0xa3, 0x34, 0x1c, 0x6e, 0x2a,
0x8c, 0xd5, 0x1b, 0x8c, 0x9c, 0x49, 0xf2, 0xc9, 0x1a, 0x14, 0x68, 0x92, 0x49, 0xdc, 0x70, 0xe9,
0x2c, 0x85, 0x9e, 0xcc, 0x9e, 0x87, 0x63, 0x81, 0x42, 0x7c, 0x04, 0x68, 0x55, 0x42, 0xdf, 0x4f,
0x65, 0x98, 0xe5, 0xff, 0x58, 0xc2, 0x07, 0xd0, 0xcc, 0x4a, 0x58, 0x83, 0x3f, 0xa9, 0xf9, 0xd8,
0x55, 0x25, 0xac, 0xb1, 0x9f, 0x4b, 0xf8, 0x04, 0xf0, 0x7d, 0x09, 0x6b, 0xe2, 0x97, 0x92, 0x6a,
0x6c, 0x56, 0xc2, 0x3d, 0x28, 0xd0, 0xaf, 0x25, 0xbc, 0x0f, 0x8d, 0xd5, 0x71, 0x59, 0x7f, 0xd1,
0x97, 0xe5, 0xfc, 0xa8, 0x95, 0x42, 0x0e, 0x7e, 0xa5, 0x5a, 0x59, 0x8b, 0xe8, 0x4c, 0xf0, 0x54,
0xa2, 0xcf, 0x2a, 0x59, 0x64, 0xf0, 0x98, 0x4b, 0x8e, 0x3e, 0xaf, 0xe0, 0x3a, 0x6c, 0x47, 0xdd,
0x78, 0x21, 0x26, 0xe8, 0x55, 0x4e, 0x39, 0xdc, 0x4f, 0x47, 0x13, 0xf4, 0x7b, 0x25, 0xab, 0x30,
0x8f, 0x18, 0x17, 0x8b, 0x58, 0xa2, 0x3f, 0x2a, 0x99, 0xfe, 0x0d, 0x97, 0xeb, 0xfb, 0x44, 0x7f,
0x56, 0xf0, 0x9b, 0xd0, 0x52, 0xe0, 0xba, 0x3f, 0x8a, 0x09, 0x85, 0x0c, 0x47, 0x02, 0xfd, 0x55,
0xc1, 0xa7, 0x70, 0xa2, 0xe8, 0xfb, 0xda, 0x37, 0xd8, 0xbf, 0x2b, 0xb8, 0x09, 0x5a, 0xe4, 0x86,
0x53, 0xee, 0x86, 0xa3, 0x08, 0x7d, 0xad, 0x65, 0x56, 0x9f, 0x2c, 0x78, 0xba, 0xb4, 0x92, 0x80,
0xab, 0xad, 0x02, 0x7d, 0xa3, 0xe1, 0x3d, 0x80, 0xc8, 0x4c, 0xfc, 0x20, 0xf7, 0xf4, 0x6d, 0x0e,
0x30, 0xfe, 0xf1, 0x82, 0x0b, 0x49, 0x0d, 0xf4, 0x9d, 0x9a, 0xe3, 0x7a, 0x01, 0xb8, 0x8e, 0x8d,
0xbe, 0xd7, 0xae, 0xaf, 0x3f, 0xfa, 0x60, 0x1c, 0xca, 0xc9, 0x62, 0xa8, 0x7e, 0xb4, 0xab, 0x97,
0x61, 0x1c, 0x87, 0x2f, 0x25, 0x1f, 0x4d, 0xae, 0xf2, 0xdf, 0xee, 0x61, 0x10, 0x0a, 0x99, 0x86,
0xc3, 0x85, 0xe4, 0xc1, 0x55, 0x38, 0x93, 0x3c, 0x9d, 0xf9, 0xf1, 0x55, 0xf6, 0x05, 0x5e, 0xe5,
0x5f, 0xe0, 0x7c, 0x38, 0xdc, 0xce, 0xe2, 0x77, 0xff, 0x09, 0x00, 0x00, 0xff, 0xff, 0x31, 0x9c,
0x64, 0xd6, 0xe5, 0x06, 0x00, 0x00,
}

12
internal/proto/master.proto
View File

@ -5,6 +5,7 @@ option go_package="github.com/zilliztech/milvus-distributed/internal/proto/maste
import "common.proto";
import "milvus.proto";
import "internal.proto";
import "data_service.proto";
message IDRequest {
@ -66,8 +67,7 @@ service MasterService {
*/
rpc DescribeCollection(milvus.DescribeCollectionRequest) returns (milvus.DescribeCollectionResponse) {}
// rpc GetCollectionStatistics(milvus.CollectionStatsRequest) returns (milvus.CollectionStatsResponse) {}
rpc GetCollectionStatistics(milvus.CollectionStatsRequest) returns (milvus.CollectionStatsResponse) {}
/**
* @brief This method is used to list all collections.
@ -97,7 +97,7 @@ service MasterService {
*/
rpc HasPartition(milvus.HasPartitionRequest) returns (milvus.BoolResponse) {}
// rpc GetPartitionStatistics(milvus.PartitionStatsRequest) returns (milvus.PartitionStatsResponse) {}
rpc GetPartitionStatistics(milvus.PartitionStatsRequest) returns (milvus.PartitionStatsResponse) {}
/**
* @brief This method is used to show partition information
@ -121,4 +121,10 @@ service MasterService {
// todo move to data service
rpc AssignSegmentID(data.AssignSegIDRequest) returns (data.AssignSegIDResponse) {}
rpc GetServiceStates(common.Empty) returns (internal.ServiceStates) {}
rpc GetTimeTickChannel(common.Empty) returns (milvus.StringResponse) {}
rpc GetStatisticsChannel(common.Empty) returns (milvus.StringResponse) {}
}

270
internal/proto/masterpb/master.pb.go
View File

@ -9,6 +9,7 @@ import (
proto "github.com/golang/protobuf/proto"
commonpb "github.com/zilliztech/milvus-distributed/internal/proto/commonpb"
datapb "github.com/zilliztech/milvus-distributed/internal/proto/datapb"
internalpb2 "github.com/zilliztech/milvus-distributed/internal/proto/internalpb2"
milvuspb "github.com/zilliztech/milvus-distributed/internal/proto/milvuspb"
grpc "google.golang.org/grpc"
codes "google.golang.org/grpc/codes"
@ -241,47 +242,54 @@ func init() {
func init() { proto.RegisterFile("master.proto", fileDescriptor_f9c348dec43a6705) }
var fileDescriptor_f9c348dec43a6705 = []byte{
// 630 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x95, 0xdd, 0x6e, 0xd3, 0x30,
0x14, 0xc7, 0xf7, 0xc5, 0xd0, 0xce, 0x9a, 0x16, 0x19, 0x2e, 0xa6, 0x30, 0xb1, 0x51, 0x89, 0xad,
0xeb, 0x46, 0x82, 0xb6, 0x17, 0x60, 0x5d, 0x24, 0x16, 0x89, 0x49, 0x28, 0x2d, 0x17, 0x80, 0xa6,
0xca, 0x49, 0xad, 0xd6, 0x52, 0x12, 0x97, 0xd8, 0xe9, 0xd0, 0x9e, 0x85, 0x87, 0x45, 0xf9, 0x72,
0x92, 0x2e, 0x69, 0x83, 0xe0, 0xd2, 0xf6, 0x2f, 0xbf, 0xff, 0xb1, 0x8f, 0x15, 0x43, 0xcb, 0xc3,
0x5c, 0x90, 0x40, 0x9b, 0x07, 0x4c, 0x30, 0xf4, 0xd2, 0xa3, 0xee, 0x22, 0xe4, 0xc9, 0x48, 0x4b,
0x96, 0xd4, 0x96, 0xc3, 0x3c, 0x8f, 0xf9, 0xc9, 0xa4, 0xda, 0x2a, 0x22, 0x2a, 0x9a, 0x60, 0x81,
0xc7, 0x9c, 0x04, 0x0b, 0xea, 0x90, 0x64, 0xae, 0x3b, 0x84, 0x3d, 0xd3, 0xb0, 0xc8, 0xcf, 0x90,
0x70, 0x81, 0x3e, 0xc0, 0x8e, 0x8d, 0x39, 0x39, 0xd8, 0x3c, 0xde, 0xec, 0xed, 0x5f, 0x1e, 0x6a,
0xa5, 0x80, 0x54, 0x7c, 0xc7, 0xa7, 0x03, 0xcc, 0x89, 0x15, 0x93, 0xe8, 0x15, 0x3c, 0x73, 0x58,
0xe8, 0x8b, 0x83, 0xad, 0xe3, 0xcd, 0x9e, 0x62, 0x25, 0x83, 0xee, 0x14, 0x20, 0x92, 0xf2, 0x39,
0xf3, 0x39, 0x41, 0x57, 0xb0, 0xcb, 0x05, 0x16, 0x21, 0x4f, 0xbd, 0xaf, 0x2b, 0xbd, 0xc3, 0x18,
0xb1, 0x52, 0x14, 0xb5, 0x61, 0xcb, 0x34, 0x62, 0xeb, 0xb6, 0xb5, 0x65, 0x1a, 0x79, 0xd0, 0x76,
0x31, 0x68, 0x04, 0x30, 0xe2, 0xec, 0x3f, 0x94, 0x5f, 0xb2, 0x2e, 0x60, 0x3f, 0xb6, 0xfe, 0x4b,
0xfd, 0x87, 0xb0, 0x27, 0xa8, 0x47, 0xb8, 0xc0, 0xde, 0x3c, 0xde, 0xc6, 0x8e, 0x95, 0x4f, 0x54,
0xe7, 0x5e, 0xfe, 0x56, 0x40, 0xb9, 0x8b, 0xdb, 0x38, 0x4c, 0x7a, 0x84, 0xc6, 0xf0, 0xe2, 0x26,
0x20, 0x58, 0x90, 0x1b, 0xe6, 0xba, 0xc4, 0x11, 0x94, 0xf9, 0xe8, 0xa2, 0x1c, 0x9f, 0x0e, 0x96,
0xb1, 0xf4, 0x4c, 0xd4, 0x55, 0xc5, 0x76, 0x37, 0xd0, 0x0f, 0x68, 0x1b, 0x01, 0x9b, 0x17, 0xf4,
0xfd, 0x4a, 0x7d, 0x19, 0x6a, 0x28, 0x1f, 0x83, 0x72, 0x8b, 0x79, 0xc1, 0x7d, 0x56, 0xe9, 0x2e,
0x31, 0x99, 0xfa, 0x6d, 0x25, 0x3a, 0x60, 0xcc, 0xcd, 0xfa, 0xd2, 0xdd, 0x40, 0x0f, 0x80, 0x0c,
0xc2, 0x9d, 0x80, 0xda, 0xc5, 0x03, 0xd2, 0xaa, 0x77, 0xf0, 0x04, 0xcc, 0xa2, 0xf4, 0xc6, 0xbc,
0x0c, 0x76, 0xa1, 0x33, 0x9c, 0xb1, 0x87, 0x7c, 0x8d, 0xd7, 0x9c, 0x5b, 0x99, 0xca, 0x12, 0xcf,
0x1b, 0xb1, 0x32, 0xed, 0x1e, 0x3a, 0x49, 0x7b, 0xbf, 0xe0, 0x40, 0xd0, 0x78, 0x8f, 0xe7, 0x2b,
0x2e, 0x81, 0xa4, 0x1a, 0xb6, 0xe9, 0x1b, 0x28, 0x51, 0x7b, 0x73, 0xf9, 0x59, 0xed, 0x15, 0xf8,
0x5b, 0xf5, 0x3d, 0xb4, 0x6e, 0x31, 0xcf, 0xcd, 0xbd, 0xba, 0x0b, 0xf0, 0x44, 0xdc, 0xa8, 0xff,
0x14, 0xda, 0xd1, 0xa1, 0xc9, 0x8f, 0x79, 0x4d, 0xe9, 0x25, 0x28, 0x4b, 0xe8, 0x37, 0x41, 0x65,
0x94, 0x0f, 0x9d, 0xec, 0x46, 0x0c, 0xc9, 0xd4, 0x23, 0xbe, 0xa8, 0xe9, 0xc1, 0x12, 0x95, 0xa5,
0x5d, 0x34, 0x83, 0x65, 0x9e, 0x03, 0xad, 0xa8, 0x94, 0x74, 0x81, 0xa3, 0xd3, 0xda, 0x6a, 0x97,
0x82, 0x7a, 0xeb, 0x41, 0x19, 0xf2, 0x15, 0xf6, 0x93, 0x2b, 0x63, 0xfa, 0x13, 0xf2, 0xab, 0x26,
0xa3, 0x40, 0x34, 0xec, 0xfa, 0x0c, 0x94, 0x6c, 0x63, 0x89, 0xf8, 0x6c, 0xe5, 0xe6, 0x4b, 0xea,
0x7e, 0x13, 0x54, 0x6e, 0xc0, 0x06, 0xe5, 0x13, 0x11, 0xf1, 0x6c, 0x94, 0x4e, 0xd0, 0x49, 0xe5,
0xe7, 0x39, 0x90, 0xc5, 0x9c, 0xae, 0xe5, 0x0a, 0x87, 0xd4, 0xbe, 0x76, 0x5d, 0xe6, 0x8c, 0xe4,
0xdf, 0xfb, 0x48, 0xab, 0x78, 0x79, 0xb5, 0xfc, 0x21, 0x52, 0x8f, 0xeb, 0x01, 0xa9, 0xfd, 0x0c,
0xcf, 0x63, 0xad, 0x69, 0xa0, 0x37, 0x95, 0xb8, 0x7c, 0x96, 0xd5, 0xa3, 0xda, 0xf5, 0xc2, 0x41,
0x74, 0xae, 0x39, 0xa7, 0x53, 0x3f, 0x6d, 0xb2, 0x69, 0xa0, 0x77, 0xe5, 0xaf, 0xa2, 0xb7, 0x5f,
0x93, 0x4c, 0x2e, 0x3f, 0x59, 0x87, 0x65, 0x19, 0x83, 0xc1, 0xf7, 0x8f, 0x53, 0x2a, 0x66, 0xa1,
0x1d, 0x35, 0x5c, 0x7f, 0xa4, 0xae, 0x4b, 0x1f, 0x05, 0x71, 0x66, 0x7a, 0x22, 0x78, 0x3f, 0xa1,
0x5c, 0x04, 0xd4, 0x0e, 0x05, 0x99, 0xe8, 0xd4, 0x17, 0x24, 0xf0, 0xb1, 0xab, 0xc7, 0x56, 0x3d,
0x29, 0x79, 0x6e, 0xdb, 0xbb, 0xf1, 0xf8, 0xea, 0x4f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x73, 0x1a,
0x8c, 0x11, 0xca, 0x08, 0x00, 0x00,
// 747 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x96, 0xfb, 0x6e, 0xd3, 0x3c,
0x18, 0xc6, 0x77, 0xfa, 0xf6, 0x69, 0xef, 0x7a, 0x18, 0x66, 0x82, 0x29, 0x4c, 0x6c, 0x14, 0xd8,
0xba, 0x03, 0x29, 0xda, 0x6e, 0x80, 0x75, 0x41, 0x5d, 0x25, 0x26, 0xa1, 0xb6, 0x80, 0x06, 0x9a,
0xa6, 0x24, 0xb5, 0x5a, 0x8b, 0x24, 0x2e, 0x79, 0xdd, 0x0e, 0x76, 0x1f, 0xdc, 0x2f, 0xca, 0xc9,
0x49, 0xba, 0xa4, 0x0d, 0x62, 0x7f, 0xda, 0xfe, 0xf9, 0x79, 0xde, 0x93, 0x12, 0x43, 0xc9, 0xd6,
0x51, 0x50, 0x57, 0x1d, 0xb9, 0x5c, 0x70, 0xf2, 0xd8, 0x66, 0xd6, 0x64, 0x8c, 0xc1, 0x4a, 0x0d,
0x8e, 0x94, 0x92, 0xc9, 0x6d, 0x9b, 0x3b, 0xc1, 0xa6, 0x52, 0x4a, 0x22, 0x4a, 0x85, 0x39, 0x82,
0xba, 0x8e, 0x6e, 0x85, 0x6b, 0xd2, 0xd7, 0x85, 0x7e, 0x83, 0xd4, 0x9d, 0x30, 0x93, 0x06, 0x7b,
0xb5, 0x2e, 0xac, 0xb5, 0xb5, 0x0e, 0xfd, 0x31, 0xa6, 0x28, 0xc8, 0x5b, 0x58, 0x31, 0x74, 0xa4,
0x5b, 0x8b, 0xbb, 0x8b, 0xf5, 0xf5, 0x93, 0x6d, 0x35, 0x65, 0x18, 0x1a, 0x5d, 0xe2, 0xa0, 0xa9,
0x23, 0xed, 0xf8, 0x24, 0xd9, 0x84, 0xff, 0x4c, 0x3e, 0x76, 0xc4, 0xd6, 0xd2, 0xee, 0x62, 0xbd,
0xdc, 0x09, 0x16, 0xb5, 0x01, 0x80, 0x27, 0x8a, 0x23, 0xee, 0x20, 0x25, 0xa7, 0xb0, 0x8a, 0x42,
0x17, 0x63, 0x0c, 0x75, 0x9f, 0x65, 0xea, 0x76, 0x7d, 0xa4, 0x13, 0xa2, 0xa4, 0x02, 0x4b, 0x6d,
0xcd, 0x57, 0x5d, 0xee, 0x2c, 0xb5, 0xb5, 0xd8, 0x68, 0x39, 0x69, 0xd4, 0x03, 0xe8, 0x21, 0x7f,
0x80, 0xf0, 0x53, 0xaa, 0x13, 0x58, 0xf7, 0x55, 0xff, 0x25, 0xfe, 0x6d, 0x58, 0x13, 0xcc, 0xa6,
0x28, 0x74, 0x7b, 0xe4, 0xa7, 0xb1, 0xd2, 0x89, 0x37, 0xb2, 0x7d, 0x4f, 0x7e, 0x3f, 0x82, 0xf2,
0xa5, 0xdf, 0xd6, 0x6e, 0xd0, 0x23, 0x72, 0x03, 0x1b, 0xe7, 0x2e, 0xd5, 0x05, 0x3d, 0xe7, 0x96,
0x45, 0x4d, 0xc1, 0xb8, 0x43, 0x8e, 0xd3, 0xf6, 0xe1, 0x62, 0x1a, 0x0b, 0x6b, 0xa2, 0xcc, 0x0a,
0xb6, 0xb6, 0x40, 0xbe, 0x41, 0x45, 0x73, 0xf9, 0x28, 0x21, 0x7f, 0x98, 0x29, 0x9f, 0x86, 0x0a,
0x8a, 0xdf, 0x40, 0xf9, 0x42, 0xc7, 0x84, 0xf6, 0x41, 0xa6, 0x76, 0x8a, 0x89, 0xa4, 0x5f, 0x64,
0xa2, 0x4d, 0xce, 0xad, 0xa8, 0x2f, 0xb5, 0x05, 0x72, 0x0b, 0x44, 0xa3, 0x68, 0xba, 0xcc, 0x48,
0x16, 0x48, 0xcd, 0xce, 0xe0, 0x1e, 0x18, 0x59, 0x35, 0x0a, 0xf3, 0xd2, 0x78, 0x02, 0x4f, 0x5b,
0x54, 0xc4, 0x47, 0x5e, 0xca, 0x0c, 0x05, 0x33, 0x91, 0x1c, 0x65, 0xb7, 0x27, 0x85, 0x62, 0x64,
0x7d, 0x5c, 0x0c, 0x96, 0xbe, 0x16, 0x54, 0xbb, 0x43, 0x7e, 0x1b, 0x03, 0x98, 0xd3, 0xaf, 0x34,
0x15, 0xd9, 0x1d, 0x15, 0x62, 0xa5, 0xdb, 0x35, 0x54, 0x83, 0xb1, 0xfa, 0xa8, 0xbb, 0x82, 0xf9,
0xb5, 0x3d, 0x9a, 0x31, 0x7c, 0x92, 0x2a, 0x38, 0x1e, 0x57, 0x50, 0xf6, 0xc6, 0x2a, 0x16, 0x3f,
0xc8, 0x1d, 0xbd, 0xbf, 0x95, 0xbe, 0x86, 0xd2, 0x85, 0x8e, 0xb1, 0x72, 0x3d, 0x6f, 0xf0, 0xee,
0x09, 0x17, 0x9a, 0x3b, 0x84, 0x27, 0x2d, 0x2a, 0xe4, 0xdd, 0x44, 0xf7, 0xb3, 0xbb, 0x91, 0x22,
0x71, 0x76, 0x37, 0xa6, 0x59, 0x69, 0xca, 0xa0, 0xe2, 0x75, 0x4a, 0x9e, 0x63, 0x4e, 0xbd, 0x52,
0x50, 0xe4, 0x75, 0x58, 0x04, 0x95, 0x56, 0x0e, 0x54, 0xa3, 0xf1, 0xef, 0xd2, 0x81, 0x4d, 0x1d,
0x91, 0xd3, 0xf8, 0x29, 0x6a, 0xf6, 0x58, 0xdf, 0x83, 0xa5, 0x9f, 0x09, 0x25, 0x2f, 0x94, 0xf0,
0x00, 0xc9, 0x7e, 0x6e, 0xb4, 0x53, 0x46, 0xf5, 0xf9, 0xa0, 0x34, 0xf9, 0x04, 0xeb, 0xc1, 0x9c,
0xb6, 0x9d, 0x3e, 0xfd, 0x99, 0xe3, 0x91, 0x20, 0x0a, 0x8e, 0xda, 0x10, 0xca, 0x51, 0x62, 0x81,
0xf0, 0xc1, 0xcc, 0xe4, 0x53, 0xd2, 0x87, 0x45, 0x50, 0x99, 0x80, 0x01, 0xe5, 0x16, 0x15, 0xfe,
0xae, 0xe7, 0x4e, 0xc9, 0x5e, 0xe6, 0xf5, 0x18, 0x88, 0x6c, 0xf6, 0xe7, 0x72, 0x89, 0x22, 0x55,
0xce, 0x2c, 0x8b, 0x9b, 0x3d, 0xf9, 0xab, 0xda, 0x51, 0x33, 0x9e, 0x1d, 0x6a, 0xfc, 0xd7, 0x55,
0x76, 0xf3, 0x01, 0x29, 0xfb, 0x01, 0xfe, 0xf7, 0x65, 0xdb, 0x1a, 0x79, 0x9e, 0x89, 0xcb, 0x37,
0x88, 0xb2, 0x93, 0x7b, 0x9e, 0x28, 0x44, 0xf5, 0x0c, 0x91, 0x0d, 0x9c, 0xb0, 0xc9, 0x6d, 0x8d,
0xbc, 0x4e, 0xdf, 0xf2, 0x1e, 0x3a, 0xaa, 0x64, 0x62, 0xf1, 0xbd, 0x79, 0x98, 0xf4, 0xf8, 0x0c,
0x1b, 0x2d, 0x2a, 0xc2, 0xff, 0xb0, 0x5f, 0x25, 0x24, 0x4a, 0xe6, 0x24, 0xbc, 0xb7, 0x47, 0xe2,
0x97, 0xf2, 0x2a, 0x7d, 0x26, 0x5f, 0x5e, 0x29, 0x85, 0xda, 0x02, 0xf9, 0x02, 0xa4, 0x45, 0x85,
0x57, 0xde, 0x1e, 0x33, 0xbf, 0x9f, 0x0f, 0x75, 0xc7, 0xa1, 0xd6, 0x4c, 0xe5, 0x97, 0xd9, 0x33,
0x2e, 0x5c, 0xe6, 0x0c, 0x12, 0x01, 0x5f, 0xc1, 0xa6, 0x17, 0xb0, 0xfc, 0x14, 0x3d, 0x9c, 0x74,
0xb3, 0xf9, 0xf5, 0xdd, 0x80, 0x89, 0xe1, 0xd8, 0xf0, 0x6e, 0x37, 0xee, 0x98, 0x65, 0xb1, 0x3b,
0x41, 0xcd, 0x61, 0x23, 0xb8, 0xf0, 0xa6, 0xcf, 0x50, 0xb8, 0xcc, 0x18, 0x0b, 0xda, 0x6f, 0x44,
0x89, 0x37, 0x7c, 0xc9, 0x46, 0xd0, 0xbe, 0x91, 0x61, 0xac, 0xfa, 0xeb, 0xd3, 0x3f, 0x01, 0x00,
0x00, 0xff, 0xff, 0x8b, 0xde, 0xd8, 0x75, 0xd3, 0x0a, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
@ -324,6 +332,7 @@ type MasterServiceClient interface {
//
// @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.
//
@ -344,6 +353,7 @@ type MasterServiceClient interface {
//
// @return BoolResponse
HasPartition(ctx context.Context, in *milvuspb.HasPartitionRequest, opts ...grpc.CallOption) (*milvuspb.BoolResponse, error)
GetPartitionStatistics(ctx context.Context, in *milvuspb.PartitionStatsRequest, opts ...grpc.CallOption) (*milvuspb.PartitionStatsResponse, error)
//*
// @brief This method is used to show partition information
//
@ -360,6 +370,9 @@ type MasterServiceClient interface {
AllocID(ctx context.Context, in *IDRequest, opts ...grpc.CallOption) (*IDResponse, error)
// todo move to data service
AssignSegmentID(ctx context.Context, in *datapb.AssignSegIDRequest, opts ...grpc.CallOption) (*datapb.AssignSegIDResponse, error)
GetServiceStates(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*internalpb2.ServiceStates, error)
GetTimeTickChannel(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*milvuspb.StringResponse, error)
GetStatisticsChannel(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*milvuspb.StringResponse, error)
}
type masterServiceClient struct {
@ -406,6 +419,15 @@ func (c *masterServiceClient) DescribeCollection(ctx context.Context, in *milvus
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...)
@ -442,6 +464,15 @@ func (c *masterServiceClient) HasPartition(ctx context.Context, in *milvuspb.Has
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...)
@ -523,6 +554,33 @@ func (c *masterServiceClient) AssignSegmentID(ctx context.Context, in *datapb.As
return out, nil
}
func (c *masterServiceClient) GetServiceStates(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*internalpb2.ServiceStates, error) {
out := new(internalpb2.ServiceStates)
err := c.cc.Invoke(ctx, "/milvus.proto.master.MasterService/GetServiceStates", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *masterServiceClient) GetTimeTickChannel(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*milvuspb.StringResponse, error) {
out := new(milvuspb.StringResponse)
err := c.cc.Invoke(ctx, "/milvus.proto.master.MasterService/GetTimeTickChannel", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *masterServiceClient) GetStatisticsChannel(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*milvuspb.StringResponse, error) {
out := new(milvuspb.StringResponse)
err := c.cc.Invoke(ctx, "/milvus.proto.master.MasterService/GetStatisticsChannel", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// MasterServiceServer is the server API for MasterService service.
type MasterServiceServer interface {
//*
@ -553,6 +611,7 @@ type MasterServiceServer interface {
//
// @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.
//
@ -573,6 +632,7 @@ type MasterServiceServer interface {
//
// @return BoolResponse
HasPartition(context.Context, *milvuspb.HasPartitionRequest) (*milvuspb.BoolResponse, error)
GetPartitionStatistics(context.Context, *milvuspb.PartitionStatsRequest) (*milvuspb.PartitionStatsResponse, error)
//*
// @brief This method is used to show partition information
//
@ -589,6 +649,9 @@ type MasterServiceServer interface {
AllocID(context.Context, *IDRequest) (*IDResponse, error)
// todo move to data service
AssignSegmentID(context.Context, *datapb.AssignSegIDRequest) (*datapb.AssignSegIDResponse, error)
GetServiceStates(context.Context, *commonpb.Empty) (*internalpb2.ServiceStates, error)
GetTimeTickChannel(context.Context, *commonpb.Empty) (*milvuspb.StringResponse, error)
GetStatisticsChannel(context.Context, *commonpb.Empty) (*milvuspb.StringResponse, error)
}
// UnimplementedMasterServiceServer can be embedded to have forward compatible implementations.
@ -607,6 +670,9 @@ func (*UnimplementedMasterServiceServer) HasCollection(ctx context.Context, req
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")
}
@ -619,6 +685,9 @@ func (*UnimplementedMasterServiceServer) DropPartition(ctx context.Context, req
func (*UnimplementedMasterServiceServer) HasPartition(ctx context.Context, req *milvuspb.HasPartitionRequest) (*milvuspb.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")
}
@ -646,6 +715,15 @@ func (*UnimplementedMasterServiceServer) AllocID(ctx context.Context, req *IDReq
func (*UnimplementedMasterServiceServer) AssignSegmentID(ctx context.Context, req *datapb.AssignSegIDRequest) (*datapb.AssignSegIDResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method AssignSegmentID not implemented")
}
func (*UnimplementedMasterServiceServer) GetServiceStates(ctx context.Context, req *commonpb.Empty) (*internalpb2.ServiceStates, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetServiceStates not implemented")
}
func (*UnimplementedMasterServiceServer) GetTimeTickChannel(ctx context.Context, req *commonpb.Empty) (*milvuspb.StringResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetTimeTickChannel not implemented")
}
func (*UnimplementedMasterServiceServer) GetStatisticsChannel(ctx context.Context, req *commonpb.Empty) (*milvuspb.StringResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetStatisticsChannel not implemented")
}
func RegisterMasterServiceServer(s *grpc.Server, srv MasterServiceServer) {
s.RegisterService(&_MasterService_serviceDesc, srv)
@ -723,6 +801,24 @@ func _MasterService_DescribeCollection_Handler(srv interface{}, ctx context.Cont
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 {
@ -795,6 +891,24 @@ func _MasterService_HasPartition_Handler(srv interface{}, ctx context.Context, d
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 {
@ -957,6 +1071,60 @@ func _MasterService_AssignSegmentID_Handler(srv interface{}, ctx context.Context
return interceptor(ctx, in, info, handler)
}
func _MasterService_GetServiceStates_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.(MasterServiceServer).GetServiceStates(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/milvus.proto.master.MasterService/GetServiceStates",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(MasterServiceServer).GetServiceStates(ctx, req.(*commonpb.Empty))
}
return interceptor(ctx, in, info, handler)
}
func _MasterService_GetTimeTickChannel_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.(MasterServiceServer).GetTimeTickChannel(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/milvus.proto.master.MasterService/GetTimeTickChannel",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(MasterServiceServer).GetTimeTickChannel(ctx, req.(*commonpb.Empty))
}
return interceptor(ctx, in, info, handler)
}
func _MasterService_GetStatisticsChannel_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.(MasterServiceServer).GetStatisticsChannel(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/milvus.proto.master.MasterService/GetStatisticsChannel",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(MasterServiceServer).GetStatisticsChannel(ctx, req.(*commonpb.Empty))
}
return interceptor(ctx, in, info, handler)
}
var _MasterService_serviceDesc = grpc.ServiceDesc{
ServiceName: "milvus.proto.master.MasterService",
HandlerType: (*MasterServiceServer)(nil),
@ -977,6 +1145,10 @@ var _MasterService_serviceDesc = grpc.ServiceDesc{
MethodName: "DescribeCollection",
Handler: _MasterService_DescribeCollection_Handler,
},
{
MethodName: "GetCollectionStatistics",
Handler: _MasterService_GetCollectionStatistics_Handler,
},
{
MethodName: "ShowCollections",
Handler: _MasterService_ShowCollections_Handler,
@ -993,6 +1165,10 @@ var _MasterService_serviceDesc = grpc.ServiceDesc{
MethodName: "HasPartition",
Handler: _MasterService_HasPartition_Handler,
},
{
MethodName: "GetPartitionStatistics",
Handler: _MasterService_GetPartitionStatistics_Handler,
},
{
MethodName: "ShowPartitions",
Handler: _MasterService_ShowPartitions_Handler,
@ -1029,6 +1205,18 @@ var _MasterService_serviceDesc = grpc.ServiceDesc{
MethodName: "AssignSegmentID",
Handler: _MasterService_AssignSegmentID_Handler,
},
{
MethodName: "GetServiceStates",
Handler: _MasterService_GetServiceStates_Handler,
},
{
MethodName: "GetTimeTickChannel",
Handler: _MasterService_GetTimeTickChannel_Handler,
},
{
MethodName: "GetStatisticsChannel",
Handler: _MasterService_GetStatisticsChannel_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "master.proto",

31
internal/proto/milvus.proto
View File

@ -32,6 +32,11 @@ message BoolResponse {
bool value = 2;
}
message StringResponse {
common.Status status = 1;
string value = 2;
}
message DescribeCollectionRequest {
common.MsgBase base = 1;
string db_name = 2;
@ -62,8 +67,8 @@ message CollectionStatsRequest {
}
message CollectionStatsResponse {
repeated common.KeyValuePair stats = 1;
common.Status status = 2;
common.Status status = 1;
repeated common.KeyValuePair stats = 2;
}
@ -73,8 +78,8 @@ message ShowCollectionRequest {
}
message ShowCollectionResponse {
repeated string collection_names = 1;
common.Status status = 2;
common.Status status = 1;
repeated string collection_names = 2;
}
@ -122,8 +127,8 @@ message PartitionStatsRequest {
}
message PartitionStatsResponse {
repeated common.KeyValuePair stats = 1;
common.Status status = 2;
common.Status status = 1;
repeated common.KeyValuePair stats = 2;
}
message ShowPartitionRequest {
@ -134,9 +139,9 @@ message ShowPartitionRequest {
}
message ShowPartitionResponse {
repeated string partition_names = 1;
repeated int64 partitionIDs = 2;
common.Status status = 3;
common.Status status = 1;
repeated string partition_names = 2;
repeated int64 partitionIDs = 3;
}
message DescribeSegmentRequest {
@ -210,9 +215,9 @@ message InsertRequest {
}
message InsertResponse {
int64 rowID_begin = 1;
int64 rowID_end = 2;
common.Status status = 3;
common.Status status = 1;
int64 rowID_begin = 2;
int64 rowID_end = 3;
}
enum PlaceholderType {
@ -284,4 +289,6 @@ service MilvusService {
rpc Insert(InsertRequest) returns (InsertResponse) {}
rpc Search(SearchRequest) returns (SearchResults) {}
rpc Flush(FlushRequest) returns (common.Status) {}
rpc GetDdChannel(common.Empty) returns (StringResponse) {}
}

432
internal/proto/milvuspb/milvus.pb.go
View File

@ -275,6 +275,53 @@ func (m *BoolResponse) GetValue() bool {
return false
}
type StringResponse struct {
Status *commonpb.Status `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
Value string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *StringResponse) Reset() { *m = StringResponse{} }
func (m *StringResponse) String() string { return proto.CompactTextString(m) }
func (*StringResponse) ProtoMessage() {}
func (*StringResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_02345ba45cc0e303, []int{4}
}
func (m *StringResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_StringResponse.Unmarshal(m, b)
}
func (m *StringResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_StringResponse.Marshal(b, m, deterministic)
}
func (m *StringResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_StringResponse.Merge(m, src)
}
func (m *StringResponse) XXX_Size() int {
return xxx_messageInfo_StringResponse.Size(m)
}
func (m *StringResponse) XXX_DiscardUnknown() {
xxx_messageInfo_StringResponse.DiscardUnknown(m)
}
var xxx_messageInfo_StringResponse proto.InternalMessageInfo
func (m *StringResponse) GetStatus() *commonpb.Status {
if m != nil {
return m.Status
}
return nil
}
func (m *StringResponse) GetValue() string {
if m != nil {
return m.Value
}
return ""
}
type DescribeCollectionRequest struct {
Base *commonpb.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"`
@ -288,7 +335,7 @@ func (m *DescribeCollectionRequest) Reset() { *m = DescribeCollectionReq
func (m *DescribeCollectionRequest) String() string { return proto.CompactTextString(m) }
func (*DescribeCollectionRequest) ProtoMessage() {}
func (*DescribeCollectionRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_02345ba45cc0e303, []int{4}
return fileDescriptor_02345ba45cc0e303, []int{5}
}
func (m *DescribeCollectionRequest) XXX_Unmarshal(b []byte) error {
@ -342,7 +389,7 @@ func (m *DescribeCollectionResponse) Reset() { *m = DescribeCollectionRe
func (m *DescribeCollectionResponse) String() string { return proto.CompactTextString(m) }
func (*DescribeCollectionResponse) ProtoMessage() {}
func (*DescribeCollectionResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_02345ba45cc0e303, []int{5}
return fileDescriptor_02345ba45cc0e303, []int{6}
}
func (m *DescribeCollectionResponse) XXX_Unmarshal(b []byte) error {
@ -390,7 +437,7 @@ func (m *LoadCollectionRequest) Reset() { *m = LoadCollectionRequest{} }
func (m *LoadCollectionRequest) String() string { return proto.CompactTextString(m) }
func (*LoadCollectionRequest) ProtoMessage() {}
func (*LoadCollectionRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_02345ba45cc0e303, []int{6}
return fileDescriptor_02345ba45cc0e303, []int{7}
}
func (m *LoadCollectionRequest) XXX_Unmarshal(b []byte) error {
@ -445,7 +492,7 @@ func (m *ReleaseCollectionRequest) Reset() { *m = ReleaseCollectionReque
func (m *ReleaseCollectionRequest) String() string { return proto.CompactTextString(m) }
func (*ReleaseCollectionRequest) ProtoMessage() {}
func (*ReleaseCollectionRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_02345ba45cc0e303, []int{7}
return fileDescriptor_02345ba45cc0e303, []int{8}
}
func (m *ReleaseCollectionRequest) XXX_Unmarshal(b []byte) error {
@ -500,7 +547,7 @@ func (m *CollectionStatsRequest) Reset() { *m = CollectionStatsRequest{}
func (m *CollectionStatsRequest) String() string { return proto.CompactTextString(m) }
func (*CollectionStatsRequest) ProtoMessage() {}
func (*CollectionStatsRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_02345ba45cc0e303, []int{8}
return fileDescriptor_02345ba45cc0e303, []int{9}
}
func (m *CollectionStatsRequest) XXX_Unmarshal(b []byte) error {
@ -543,8 +590,8 @@ func (m *CollectionStatsRequest) GetCollectionName() string {
}
type CollectionStatsResponse struct {
Stats []*commonpb.KeyValuePair `protobuf:"bytes,1,rep,name=stats,proto3" json:"stats,omitempty"`
Status *commonpb.Status `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"`
Status *commonpb.Status `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
Stats []*commonpb.KeyValuePair `protobuf:"bytes,2,rep,name=stats,proto3" json:"stats,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
@ -554,7 +601,7 @@ func (m *CollectionStatsResponse) Reset() { *m = CollectionStatsResponse
func (m *CollectionStatsResponse) String() string { return proto.CompactTextString(m) }
func (*CollectionStatsResponse) ProtoMessage() {}
func (*CollectionStatsResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_02345ba45cc0e303, []int{9}
return fileDescriptor_02345ba45cc0e303, []int{10}
}
func (m *CollectionStatsResponse) XXX_Unmarshal(b []byte) error {
@ -575,16 +622,16 @@ func (m *CollectionStatsResponse) XXX_DiscardUnknown() {
var xxx_messageInfo_CollectionStatsResponse proto.InternalMessageInfo
func (m *CollectionStatsResponse) GetStats() []*commonpb.KeyValuePair {
func (m *CollectionStatsResponse) GetStatus() *commonpb.Status {
if m != nil {
return m.Stats
return m.Status
}
return nil
}
func (m *CollectionStatsResponse) GetStatus() *commonpb.Status {
func (m *CollectionStatsResponse) GetStats() []*commonpb.KeyValuePair {
if m != nil {
return m.Status
return m.Stats
}
return nil
}
@ -601,7 +648,7 @@ func (m *ShowCollectionRequest) Reset() { *m = ShowCollectionRequest{} }
func (m *ShowCollectionRequest) String() string { return proto.CompactTextString(m) }
func (*ShowCollectionRequest) ProtoMessage() {}
func (*ShowCollectionRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_02345ba45cc0e303, []int{10}
return fileDescriptor_02345ba45cc0e303, []int{11}
}
func (m *ShowCollectionRequest) XXX_Unmarshal(b []byte) error {
@ -637,8 +684,8 @@ func (m *ShowCollectionRequest) GetDbName() string {
}
type ShowCollectionResponse struct {
CollectionNames []string `protobuf:"bytes,1,rep,name=collection_names,json=collectionNames,proto3" json:"collection_names,omitempty"`
Status *commonpb.Status `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"`
Status *commonpb.Status `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
CollectionNames []string `protobuf:"bytes,2,rep,name=collection_names,json=collectionNames,proto3" json:"collection_names,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
@ -648,7 +695,7 @@ func (m *ShowCollectionResponse) Reset() { *m = ShowCollectionResponse{}
func (m *ShowCollectionResponse) String() string { return proto.CompactTextString(m) }
func (*ShowCollectionResponse) ProtoMessage() {}
func (*ShowCollectionResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_02345ba45cc0e303, []int{11}
return fileDescriptor_02345ba45cc0e303, []int{12}
}
func (m *ShowCollectionResponse) XXX_Unmarshal(b []byte) error {
@ -669,16 +716,16 @@ func (m *ShowCollectionResponse) XXX_DiscardUnknown() {
var xxx_messageInfo_ShowCollectionResponse proto.InternalMessageInfo
func (m *ShowCollectionResponse) GetCollectionNames() []string {
func (m *ShowCollectionResponse) GetStatus() *commonpb.Status {
if m != nil {
return m.CollectionNames
return m.Status
}
return nil
}
func (m *ShowCollectionResponse) GetStatus() *commonpb.Status {
func (m *ShowCollectionResponse) GetCollectionNames() []string {
if m != nil {
return m.Status
return m.CollectionNames
}
return nil
}
@ -697,7 +744,7 @@ func (m *CreatePartitionRequest) Reset() { *m = CreatePartitionRequest{}
func (m *CreatePartitionRequest) String() string { return proto.CompactTextString(m) }
func (*CreatePartitionRequest) ProtoMessage() {}
func (*CreatePartitionRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_02345ba45cc0e303, []int{12}
return fileDescriptor_02345ba45cc0e303, []int{13}
}
func (m *CreatePartitionRequest) XXX_Unmarshal(b []byte) error {
@ -760,7 +807,7 @@ func (m *DropPartitionRequest) Reset() { *m = DropPartitionRequest{} }
func (m *DropPartitionRequest) String() string { return proto.CompactTextString(m) }
func (*DropPartitionRequest) ProtoMessage() {}
func (*DropPartitionRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_02345ba45cc0e303, []int{13}
return fileDescriptor_02345ba45cc0e303, []int{14}
}
func (m *DropPartitionRequest) XXX_Unmarshal(b []byte) error {
@ -823,7 +870,7 @@ func (m *HasPartitionRequest) Reset() { *m = HasPartitionRequest{} }
func (m *HasPartitionRequest) String() string { return proto.CompactTextString(m) }
func (*HasPartitionRequest) ProtoMessage() {}
func (*HasPartitionRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_02345ba45cc0e303, []int{14}
return fileDescriptor_02345ba45cc0e303, []int{15}
}
func (m *HasPartitionRequest) XXX_Unmarshal(b []byte) error {
@ -886,7 +933,7 @@ func (m *LoadPartitonRequest) Reset() { *m = LoadPartitonRequest{} }
func (m *LoadPartitonRequest) String() string { return proto.CompactTextString(m) }
func (*LoadPartitonRequest) ProtoMessage() {}
func (*LoadPartitonRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_02345ba45cc0e303, []int{15}
return fileDescriptor_02345ba45cc0e303, []int{16}
}
func (m *LoadPartitonRequest) XXX_Unmarshal(b []byte) error {
@ -949,7 +996,7 @@ func (m *ReleasePartitionRequest) Reset() { *m = ReleasePartitionRequest
func (m *ReleasePartitionRequest) String() string { return proto.CompactTextString(m) }
func (*ReleasePartitionRequest) ProtoMessage() {}
func (*ReleasePartitionRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_02345ba45cc0e303, []int{16}
return fileDescriptor_02345ba45cc0e303, []int{17}
}
func (m *ReleasePartitionRequest) XXX_Unmarshal(b []byte) error {
@ -1012,7 +1059,7 @@ func (m *PartitionStatsRequest) Reset() { *m = PartitionStatsRequest{} }
func (m *PartitionStatsRequest) String() string { return proto.CompactTextString(m) }
func (*PartitionStatsRequest) ProtoMessage() {}
func (*PartitionStatsRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_02345ba45cc0e303, []int{17}
return fileDescriptor_02345ba45cc0e303, []int{18}
}
func (m *PartitionStatsRequest) XXX_Unmarshal(b []byte) error {
@ -1062,8 +1109,8 @@ func (m *PartitionStatsRequest) GetPartitionName() string {
}
type PartitionStatsResponse struct {
Stats []*commonpb.KeyValuePair `protobuf:"bytes,1,rep,name=stats,proto3" json:"stats,omitempty"`
Status *commonpb.Status `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"`
Status *commonpb.Status `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
Stats []*commonpb.KeyValuePair `protobuf:"bytes,2,rep,name=stats,proto3" json:"stats,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
@ -1073,7 +1120,7 @@ func (m *PartitionStatsResponse) Reset() { *m = PartitionStatsResponse{}
func (m *PartitionStatsResponse) String() string { return proto.CompactTextString(m) }
func (*PartitionStatsResponse) ProtoMessage() {}
func (*PartitionStatsResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_02345ba45cc0e303, []int{18}
return fileDescriptor_02345ba45cc0e303, []int{19}
}
func (m *PartitionStatsResponse) XXX_Unmarshal(b []byte) error {
@ -1094,16 +1141,16 @@ func (m *PartitionStatsResponse) XXX_DiscardUnknown() {
var xxx_messageInfo_PartitionStatsResponse proto.InternalMessageInfo
func (m *PartitionStatsResponse) GetStats() []*commonpb.KeyValuePair {
func (m *PartitionStatsResponse) GetStatus() *commonpb.Status {
if m != nil {
return m.Stats
return m.Status
}
return nil
}
func (m *PartitionStatsResponse) GetStatus() *commonpb.Status {
func (m *PartitionStatsResponse) GetStats() []*commonpb.KeyValuePair {
if m != nil {
return m.Status
return m.Stats
}
return nil
}
@ -1122,7 +1169,7 @@ func (m *ShowPartitionRequest) Reset() { *m = ShowPartitionRequest{} }
func (m *ShowPartitionRequest) String() string { return proto.CompactTextString(m) }
func (*ShowPartitionRequest) ProtoMessage() {}
func (*ShowPartitionRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_02345ba45cc0e303, []int{19}
return fileDescriptor_02345ba45cc0e303, []int{20}
}
func (m *ShowPartitionRequest) XXX_Unmarshal(b []byte) error {
@ -1172,9 +1219,9 @@ func (m *ShowPartitionRequest) GetCollectionID() int64 {
}
type ShowPartitionResponse struct {
PartitionNames []string `protobuf:"bytes,1,rep,name=partition_names,json=partitionNames,proto3" json:"partition_names,omitempty"`
PartitionIDs []int64 `protobuf:"varint,2,rep,packed,name=partitionIDs,proto3" json:"partitionIDs,omitempty"`
Status *commonpb.Status `protobuf:"bytes,3,opt,name=status,proto3" json:"status,omitempty"`
Status *commonpb.Status `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
PartitionNames []string `protobuf:"bytes,2,rep,name=partition_names,json=partitionNames,proto3" json:"partition_names,omitempty"`
PartitionIDs []int64 `protobuf:"varint,3,rep,packed,name=partitionIDs,proto3" json:"partitionIDs,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
@ -1184,7 +1231,7 @@ func (m *ShowPartitionResponse) Reset() { *m = ShowPartitionResponse{} }
func (m *ShowPartitionResponse) String() string { return proto.CompactTextString(m) }
func (*ShowPartitionResponse) ProtoMessage() {}
func (*ShowPartitionResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_02345ba45cc0e303, []int{20}
return fileDescriptor_02345ba45cc0e303, []int{21}
}
func (m *ShowPartitionResponse) XXX_Unmarshal(b []byte) error {
@ -1205,6 +1252,13 @@ func (m *ShowPartitionResponse) XXX_DiscardUnknown() {
var xxx_messageInfo_ShowPartitionResponse proto.InternalMessageInfo
func (m *ShowPartitionResponse) GetStatus() *commonpb.Status {
if m != nil {
return m.Status
}
return nil
}
func (m *ShowPartitionResponse) GetPartitionNames() []string {
if m != nil {
return m.PartitionNames
@ -1219,13 +1273,6 @@ func (m *ShowPartitionResponse) GetPartitionIDs() []int64 {
return nil
}
func (m *ShowPartitionResponse) GetStatus() *commonpb.Status {
if m != nil {
return m.Status
}
return nil
}
type DescribeSegmentRequest struct {
Base *commonpb.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
CollectionID int64 `protobuf:"varint,2,opt,name=collectionID,proto3" json:"collectionID,omitempty"`
@ -1239,7 +1286,7 @@ func (m *DescribeSegmentRequest) Reset() { *m = DescribeSegmentRequest{}
func (m *DescribeSegmentRequest) String() string { return proto.CompactTextString(m) }
func (*DescribeSegmentRequest) ProtoMessage() {}
func (*DescribeSegmentRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_02345ba45cc0e303, []int{21}
return fileDescriptor_02345ba45cc0e303, []int{22}
}
func (m *DescribeSegmentRequest) XXX_Unmarshal(b []byte) error {
@ -1293,7 +1340,7 @@ func (m *DescribeSegmentResponse) Reset() { *m = DescribeSegmentResponse
func (m *DescribeSegmentResponse) String() string { return proto.CompactTextString(m) }
func (*DescribeSegmentResponse) ProtoMessage() {}
func (*DescribeSegmentResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_02345ba45cc0e303, []int{22}
return fileDescriptor_02345ba45cc0e303, []int{23}
}
func (m *DescribeSegmentResponse) XXX_Unmarshal(b []byte) error {
@ -1341,7 +1388,7 @@ func (m *ShowSegmentRequest) Reset() { *m = ShowSegmentRequest{} }
func (m *ShowSegmentRequest) String() string { return proto.CompactTextString(m) }
func (*ShowSegmentRequest) ProtoMessage() {}
func (*ShowSegmentRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_02345ba45cc0e303, []int{23}
return fileDescriptor_02345ba45cc0e303, []int{24}
}
func (m *ShowSegmentRequest) XXX_Unmarshal(b []byte) error {
@ -1395,7 +1442,7 @@ func (m *ShowSegmentResponse) Reset() { *m = ShowSegmentResponse{} }
func (m *ShowSegmentResponse) String() string { return proto.CompactTextString(m) }
func (*ShowSegmentResponse) ProtoMessage() {}
func (*ShowSegmentResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_02345ba45cc0e303, []int{24}
return fileDescriptor_02345ba45cc0e303, []int{25}
}
func (m *ShowSegmentResponse) XXX_Unmarshal(b []byte) error {
@ -1445,7 +1492,7 @@ func (m *CreateIndexRequest) Reset() { *m = CreateIndexRequest{} }
func (m *CreateIndexRequest) String() string { return proto.CompactTextString(m) }
func (*CreateIndexRequest) ProtoMessage() {}
func (*CreateIndexRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_02345ba45cc0e303, []int{25}
return fileDescriptor_02345ba45cc0e303, []int{26}
}
func (m *CreateIndexRequest) XXX_Unmarshal(b []byte) error {
@ -1516,7 +1563,7 @@ func (m *DescribeIndexRequest) Reset() { *m = DescribeIndexRequest{} }
func (m *DescribeIndexRequest) String() string { return proto.CompactTextString(m) }
func (*DescribeIndexRequest) ProtoMessage() {}
func (*DescribeIndexRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_02345ba45cc0e303, []int{26}
return fileDescriptor_02345ba45cc0e303, []int{27}
}
func (m *DescribeIndexRequest) XXX_Unmarshal(b []byte) error {
@ -1584,7 +1631,7 @@ func (m *IndexDescription) Reset() { *m = IndexDescription{} }
func (m *IndexDescription) String() string { return proto.CompactTextString(m) }
func (*IndexDescription) ProtoMessage() {}
func (*IndexDescription) Descriptor() ([]byte, []int) {
return fileDescriptor_02345ba45cc0e303, []int{27}
return fileDescriptor_02345ba45cc0e303, []int{28}
}
func (m *IndexDescription) XXX_Unmarshal(b []byte) error {
@ -1631,7 +1678,7 @@ func (m *DescribeIndexResponse) Reset() { *m = DescribeIndexResponse{} }
func (m *DescribeIndexResponse) String() string { return proto.CompactTextString(m) }
func (*DescribeIndexResponse) ProtoMessage() {}
func (*DescribeIndexResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_02345ba45cc0e303, []int{28}
return fileDescriptor_02345ba45cc0e303, []int{29}
}
func (m *DescribeIndexResponse) XXX_Unmarshal(b []byte) error {
@ -1681,7 +1728,7 @@ func (m *IndexStateRequest) Reset() { *m = IndexStateRequest{} }
func (m *IndexStateRequest) String() string { return proto.CompactTextString(m) }
func (*IndexStateRequest) ProtoMessage() {}
func (*IndexStateRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_02345ba45cc0e303, []int{29}
return fileDescriptor_02345ba45cc0e303, []int{30}
}
func (m *IndexStateRequest) XXX_Unmarshal(b []byte) error {
@ -1749,7 +1796,7 @@ func (m *IndexStateResponse) Reset() { *m = IndexStateResponse{} }
func (m *IndexStateResponse) String() string { return proto.CompactTextString(m) }
func (*IndexStateResponse) ProtoMessage() {}
func (*IndexStateResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_02345ba45cc0e303, []int{30}
return fileDescriptor_02345ba45cc0e303, []int{31}
}
func (m *IndexStateResponse) XXX_Unmarshal(b []byte) error {
@ -1800,7 +1847,7 @@ func (m *InsertRequest) Reset() { *m = InsertRequest{} }
func (m *InsertRequest) String() string { return proto.CompactTextString(m) }
func (*InsertRequest) ProtoMessage() {}
func (*InsertRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_02345ba45cc0e303, []int{31}
return fileDescriptor_02345ba45cc0e303, []int{32}
}
func (m *InsertRequest) XXX_Unmarshal(b []byte) error {
@ -1864,9 +1911,9 @@ func (m *InsertRequest) GetHashKeys() []uint32 {
}
type InsertResponse struct {
RowIDBegin int64 `protobuf:"varint,1,opt,name=rowID_begin,json=rowIDBegin,proto3" json:"rowID_begin,omitempty"`
RowIDEnd int64 `protobuf:"varint,2,opt,name=rowID_end,json=rowIDEnd,proto3" json:"rowID_end,omitempty"`
Status *commonpb.Status `protobuf:"bytes,3,opt,name=status,proto3" json:"status,omitempty"`
Status *commonpb.Status `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
RowIDBegin int64 `protobuf:"varint,2,opt,name=rowID_begin,json=rowIDBegin,proto3" json:"rowID_begin,omitempty"`
RowIDEnd int64 `protobuf:"varint,3,opt,name=rowID_end,json=rowIDEnd,proto3" json:"rowID_end,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
@ -1876,7 +1923,7 @@ func (m *InsertResponse) Reset() { *m = InsertResponse{} }
func (m *InsertResponse) String() string { return proto.CompactTextString(m) }
func (*InsertResponse) ProtoMessage() {}
func (*InsertResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_02345ba45cc0e303, []int{32}
return fileDescriptor_02345ba45cc0e303, []int{33}
}
func (m *InsertResponse) XXX_Unmarshal(b []byte) error {
@ -1897,6 +1944,13 @@ func (m *InsertResponse) XXX_DiscardUnknown() {
var xxx_messageInfo_InsertResponse proto.InternalMessageInfo
func (m *InsertResponse) GetStatus() *commonpb.Status {
if m != nil {
return m.Status
}
return nil
}
func (m *InsertResponse) GetRowIDBegin() int64 {
if m != nil {
return m.RowIDBegin
@ -1911,13 +1965,6 @@ func (m *InsertResponse) GetRowIDEnd() int64 {
return 0
}
func (m *InsertResponse) GetStatus() *commonpb.Status {
if m != nil {
return m.Status
}
return nil
}
type PlaceholderValue struct {
Tag string `protobuf:"bytes,1,opt,name=tag,proto3" json:"tag,omitempty"`
Type PlaceholderType `protobuf:"varint,2,opt,name=type,proto3,enum=milvus.proto.milvus.PlaceholderType" json:"type,omitempty"`
@ -1932,7 +1979,7 @@ func (m *PlaceholderValue) Reset() { *m = PlaceholderValue{} }
func (m *PlaceholderValue) String() string { return proto.CompactTextString(m) }
func (*PlaceholderValue) ProtoMessage() {}
func (*PlaceholderValue) Descriptor() ([]byte, []int) {
return fileDescriptor_02345ba45cc0e303, []int{33}
return fileDescriptor_02345ba45cc0e303, []int{34}
}
func (m *PlaceholderValue) XXX_Unmarshal(b []byte) error {
@ -1985,7 +2032,7 @@ func (m *PlaceholderGroup) Reset() { *m = PlaceholderGroup{} }
func (m *PlaceholderGroup) String() string { return proto.CompactTextString(m) }
func (*PlaceholderGroup) ProtoMessage() {}
func (*PlaceholderGroup) Descriptor() ([]byte, []int) {
return fileDescriptor_02345ba45cc0e303, []int{34}
return fileDescriptor_02345ba45cc0e303, []int{35}
}
func (m *PlaceholderGroup) XXX_Unmarshal(b []byte) error {
@ -2030,7 +2077,7 @@ func (m *SearchRequest) Reset() { *m = SearchRequest{} }
func (m *SearchRequest) String() string { return proto.CompactTextString(m) }
func (*SearchRequest) ProtoMessage() {}
func (*SearchRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_02345ba45cc0e303, []int{35}
return fileDescriptor_02345ba45cc0e303, []int{36}
}
func (m *SearchRequest) XXX_Unmarshal(b []byte) error {
@ -2106,7 +2153,7 @@ func (m *Hits) Reset() { *m = Hits{} }
func (m *Hits) String() string { return proto.CompactTextString(m) }
func (*Hits) ProtoMessage() {}
func (*Hits) Descriptor() ([]byte, []int) {
return fileDescriptor_02345ba45cc0e303, []int{36}
return fileDescriptor_02345ba45cc0e303, []int{37}
}
func (m *Hits) XXX_Unmarshal(b []byte) error {
@ -2160,7 +2207,7 @@ func (m *SearchResults) Reset() { *m = SearchResults{} }
func (m *SearchResults) String() string { return proto.CompactTextString(m) }
func (*SearchResults) ProtoMessage() {}
func (*SearchResults) Descriptor() ([]byte, []int) {
return fileDescriptor_02345ba45cc0e303, []int{37}
return fileDescriptor_02345ba45cc0e303, []int{38}
}
func (m *SearchResults) XXX_Unmarshal(b []byte) error {
@ -2208,7 +2255,7 @@ func (m *FlushRequest) Reset() { *m = FlushRequest{} }
func (m *FlushRequest) String() string { return proto.CompactTextString(m) }
func (*FlushRequest) ProtoMessage() {}
func (*FlushRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_02345ba45cc0e303, []int{38}
return fileDescriptor_02345ba45cc0e303, []int{39}
}
func (m *FlushRequest) XXX_Unmarshal(b []byte) error {
@ -2256,6 +2303,7 @@ func init() {
proto.RegisterType((*DropCollectionRequest)(nil), "milvus.proto.milvus.DropCollectionRequest")
proto.RegisterType((*HasCollectionRequest)(nil), "milvus.proto.milvus.HasCollectionRequest")
proto.RegisterType((*BoolResponse)(nil), "milvus.proto.milvus.BoolResponse")
proto.RegisterType((*StringResponse)(nil), "milvus.proto.milvus.StringResponse")
proto.RegisterType((*DescribeCollectionRequest)(nil), "milvus.proto.milvus.DescribeCollectionRequest")
proto.RegisterType((*DescribeCollectionResponse)(nil), "milvus.proto.milvus.DescribeCollectionResponse")
proto.RegisterType((*LoadCollectionRequest)(nil), "milvus.proto.milvus.LoadCollectionRequest")
@ -2296,106 +2344,108 @@ func init() {
func init() { proto.RegisterFile("milvus.proto", fileDescriptor_02345ba45cc0e303) }
var fileDescriptor_02345ba45cc0e303 = []byte{
// 1575 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x58, 0xdd, 0x6e, 0x1b, 0x45,
0x14, 0xce, 0xd8, 0x8e, 0x9b, 0x9c, 0xd8, 0x8e, 0x33, 0xf9, 0x73, 0xdd, 0x96, 0xa6, 0x0b, 0x6d,
0xdc, 0xbf, 0x04, 0xa5, 0x20, 0xe0, 0x02, 0xa9, 0x75, 0xdd, 0xa6, 0x56, 0xdb, 0x34, 0x5a, 0x87,
0x8a, 0x80, 0x2a, 0x33, 0xf6, 0x0e, 0xf1, 0xc2, 0xda, 0x6b, 0x76, 0xd6, 0x49, 0xd3, 0x2b, 0x04,
0x12, 0x48, 0x80, 0x80, 0x5b, 0x24, 0xae, 0x10, 0xd7, 0x08, 0x8a, 0xc4, 0x1b, 0x20, 0xf1, 0x2e,
0x88, 0x47, 0x40, 0x42, 0x33, 0xbb, 0x5e, 0xef, 0x6e, 0x66, 0x63, 0xb7, 0x51, 0xb1, 0x73, 0xe7,
0x39, 0x3e, 0x73, 0xce, 0x77, 0x7e, 0x66, 0xf6, 0xcc, 0x07, 0xa9, 0xa6, 0x6e, 0xec, 0x76, 0xd8,
0x4a, 0xdb, 0x32, 0x6d, 0x13, 0xcf, 0xfa, 0x57, 0x2b, 0xce, 0x22, 0x9f, 0xaa, 0x9b, 0xcd, 0xa6,
0xd9, 0x72, 0x84, 0xf9, 0x14, 0xab, 0x37, 0x68, 0x93, 0x38, 0x2b, 0xe5, 0x67, 0x04, 0x8b, 0x37,
0x2d, 0x4a, 0x6c, 0x7a, 0xd3, 0x34, 0x0c, 0x5a, 0xb7, 0x75, 0xb3, 0xa5, 0xd2, 0x4f, 0x3a, 0x94,
0xd9, 0xf8, 0x55, 0x48, 0xd4, 0x08, 0xa3, 0x39, 0xb4, 0x84, 0x0a, 0x53, 0x6b, 0xa7, 0x57, 0x02,
0xb6, 0x5d, 0x9b, 0xf7, 0xd9, 0x4e, 0x91, 0x30, 0xaa, 0x0a, 0x4d, 0xbc, 0x08, 0x27, 0xb4, 0x5a,
0xb5, 0x45, 0x9a, 0x34, 0x17, 0x5b, 0x42, 0x85, 0x49, 0x35, 0xa9, 0xd5, 0x36, 0x48, 0x93, 0xe2,
0x0b, 0x90, 0xa9, 0x7b, 0xf6, 0xb9, 0x24, 0x17, 0x17, 0xff, 0x87, 0xa4, 0x78, 0x01, 0x92, 0x0e,
0xbc, 0x5c, 0x62, 0x09, 0x15, 0x52, 0xaa, 0xbb, 0x52, 0xbe, 0x42, 0x30, 0x5f, 0xb2, 0xcc, 0xf6,
0x28, 0x80, 0xe4, 0x60, 0xe6, 0xee, 0x10, 0xf6, 0x42, 0xb1, 0x2c, 0xc3, 0x74, 0xcf, 0xab, 0xa3,
0x20, 0x07, 0xb3, 0x0d, 0xa9, 0xa2, 0x69, 0x1a, 0x2a, 0x65, 0x6d, 0xb3, 0xc5, 0x28, 0xbe, 0x06,
0x49, 0x66, 0x13, 0xbb, 0xc3, 0x5c, 0x14, 0xa7, 0xa4, 0x28, 0x2a, 0x42, 0x45, 0x75, 0x55, 0xf1,
0x1c, 0x8c, 0xef, 0x12, 0xa3, 0xe3, 0x80, 0x98, 0x50, 0x9d, 0x85, 0xf2, 0x1d, 0x82, 0x93, 0x25,
0xca, 0xea, 0x96, 0x5e, 0xa3, 0xa3, 0x11, 0xec, 0xf7, 0x08, 0xf2, 0x32, 0x44, 0x47, 0x89, 0xfd,
0x6d, 0xaf, 0xe5, 0x62, 0x62, 0xd3, 0xf9, 0xe0, 0x26, 0xf7, 0xb4, 0xf4, 0xbc, 0x55, 0x84, 0xc0,
0xeb, 0xcc, 0xaf, 0x11, 0xcc, 0xdf, 0x33, 0x89, 0x36, 0x1a, 0x09, 0xfa, 0x16, 0x41, 0x4e, 0xa5,
0x06, 0x25, 0x6c, 0x44, 0x2a, 0xf6, 0x0d, 0x82, 0x05, 0x5f, 0xee, 0x6c, 0x62, 0xb3, 0x61, 0xc2,
0xf9, 0x92, 0x5f, 0x77, 0x61, 0x38, 0x6e, 0xf7, 0xbc, 0x01, 0xe3, 0xbc, 0x25, 0x78, 0xf3, 0xc4,
0x0b, 0x53, 0x6b, 0xe7, 0xa4, 0x80, 0xee, 0xd2, 0xfd, 0x87, 0xfc, 0x70, 0x6c, 0x12, 0xdd, 0x52,
0x1d, 0x7d, 0x5f, 0xdb, 0xc5, 0x06, 0x6e, 0x3b, 0xa5, 0x06, 0xf3, 0x95, 0x86, 0xb9, 0xf7, 0x22,
0xab, 0xa4, 0x3c, 0x86, 0x85, 0xb0, 0x0f, 0x37, 0xd6, 0x8b, 0x90, 0x0d, 0x25, 0xcc, 0x09, 0x7b,
0x52, 0x9d, 0x0e, 0x66, 0xec, 0x39, 0xa3, 0xfb, 0x9d, 0x97, 0x5d, 0x7c, 0x56, 0x36, 0x89, 0x65,
0xeb, 0x43, 0xee, 0x42, 0x7c, 0x1e, 0x32, 0xed, 0x2e, 0x0e, 0x47, 0x2f, 0x21, 0xf4, 0xd2, 0x9e,
0x54, 0xe4, 0xeb, 0x37, 0x04, 0x73, 0xfc, 0x2b, 0x73, 0x9c, 0x30, 0xff, 0x8a, 0x60, 0xf6, 0x0e,
0x61, 0xc7, 0x09, 0xf2, 0x53, 0x04, 0xb3, 0xfc, 0xca, 0x74, 0x30, 0x0f, 0x17, 0xf2, 0x32, 0x4c,
0x07, 0x21, 0xb3, 0x5c, 0x42, 0x9c, 0x83, 0x4c, 0x00, 0x33, 0x53, 0xfe, 0x40, 0xb0, 0xe8, 0xde,
0xac, 0x23, 0x91, 0xeb, 0x81, 0x81, 0x3f, 0x45, 0x30, 0xef, 0x21, 0x1e, 0xf6, 0x05, 0x3c, 0x68,
0x8b, 0x7c, 0x81, 0x60, 0x21, 0x0c, 0x7a, 0x28, 0xd7, 0xf4, 0x2f, 0x08, 0xe6, 0xf8, 0x1d, 0x3a,
0x12, 0x35, 0x57, 0x20, 0xd5, 0x93, 0x94, 0x4b, 0x22, 0x75, 0x71, 0x35, 0x20, 0x53, 0x7e, 0x40,
0xce, 0x87, 0xc5, 0x07, 0xd8, 0x4d, 0x9c, 0xa4, 0x63, 0x90, 0xac, 0x63, 0xb8, 0x1b, 0x4f, 0x52,
0x2e, 0xf1, 0x74, 0xc5, 0xb9, 0x1b, 0xbf, 0xcc, 0x97, 0xcc, 0xf8, 0xe0, 0xc9, 0xe4, 0xc3, 0x40,
0x77, 0x7c, 0xab, 0xd0, 0x9d, 0x26, 0x6d, 0xd9, 0xcf, 0x9f, 0xce, 0x70, 0x32, 0x62, 0x07, 0x93,
0x81, 0x4f, 0xc3, 0x24, 0x73, 0xfc, 0x94, 0x4b, 0x02, 0x68, 0x5c, 0xed, 0x09, 0x94, 0x06, 0x2c,
0x1e, 0x40, 0x73, 0x94, 0x49, 0x32, 0x07, 0x27, 0xf4, 0x96, 0x46, 0x1f, 0x7b, 0x60, 0xba, 0x4b,
0x1e, 0x38, 0xe6, 0x45, 0xf9, 0x5f, 0x82, 0x5e, 0x82, 0x29, 0x5f, 0xa9, 0xdc, 0xb0, 0xfd, 0x22,
0xe5, 0x23, 0x98, 0x0d, 0xa0, 0x39, 0x4a, 0xd0, 0x2f, 0x01, 0x78, 0x19, 0xed, 0xb6, 0x8a, 0x4f,
0xa2, 0xfc, 0x83, 0x00, 0x3b, 0x93, 0x40, 0x99, 0x27, 0x63, 0x98, 0xc7, 0xe7, 0x0c, 0xc0, 0x87,
0x3a, 0x35, 0x34, 0xff, 0xbd, 0x33, 0x29, 0x24, 0xe2, 0xef, 0x12, 0xa4, 0xe8, 0x63, 0xdb, 0x22,
0xd5, 0x36, 0xb1, 0x48, 0x93, 0xe5, 0xc6, 0x07, 0xbd, 0x5f, 0xa6, 0xc4, 0xb6, 0x4d, 0xb1, 0x4b,
0xf9, 0x8b, 0xcf, 0x10, 0x6e, 0x57, 0x8d, 0x7a, 0xc4, 0x67, 0x00, 0x44, 0x87, 0x3a, 0x7f, 0x8f,
0x3b, 0x7f, 0x0b, 0x89, 0xb8, 0x84, 0x0d, 0xc8, 0x8a, 0x08, 0x9c, 0x70, 0xda, 0xdc, 0x6a, 0x68,
0x0b, 0x0a, 0x6d, 0xc1, 0x6f, 0x41, 0xd2, 0xcd, 0x5e, 0x6c, 0xd0, 0xec, 0xb9, 0x1b, 0x94, 0x9f,
0xf8, 0x13, 0x3f, 0x98, 0xb8, 0xa3, 0xf4, 0xe5, 0x16, 0x60, 0x07, 0xa8, 0xd6, 0x43, 0xdf, 0x45,
0x15, 0x7a, 0xe2, 0xb9, 0x8b, 0x70, 0xac, 0xea, 0x8c, 0x1e, 0x92, 0x30, 0xe5, 0x4f, 0x04, 0x33,
0x42, 0x8f, 0x7b, 0xa3, 0xc7, 0xb7, 0xb4, 0x9f, 0x22, 0xc0, 0xfe, 0x38, 0x8e, 0x92, 0xe9, 0xd7,
0x9d, 0x0f, 0xb2, 0x13, 0x49, 0x66, 0xed, 0xac, 0x74, 0x8f, 0xcf, 0x99, 0xa3, 0xad, 0xfc, 0x8b,
0x20, 0x5d, 0x6e, 0x31, 0x6a, 0xd9, 0xa3, 0x3f, 0x8f, 0xe0, 0xd7, 0x60, 0xc2, 0x32, 0xf7, 0xaa,
0x1a, 0xb1, 0x89, 0x7b, 0x2f, 0x9c, 0x94, 0xc2, 0x2b, 0x1a, 0x66, 0x4d, 0x3d, 0x61, 0x99, 0x7b,
0x25, 0x62, 0x13, 0x7c, 0x0a, 0x26, 0x1b, 0x84, 0x35, 0xaa, 0x1f, 0xd3, 0x7d, 0x96, 0x4b, 0x2e,
0xc5, 0x0b, 0x69, 0x75, 0x82, 0x0b, 0xee, 0xd2, 0x7d, 0xa6, 0x7c, 0x8e, 0x20, 0xd3, 0x8d, 0xdf,
0x4d, 0xff, 0x59, 0x98, 0xb2, 0xcc, 0xbd, 0x72, 0xa9, 0x5a, 0xa3, 0x3b, 0x7a, 0x4b, 0xe4, 0x21,
0xae, 0x82, 0x10, 0x15, 0xb9, 0x84, 0x1b, 0x74, 0x14, 0x68, 0x4b, 0x73, 0xef, 0xfe, 0x09, 0x21,
0xb8, 0xd5, 0xd2, 0x9e, 0xef, 0x93, 0xbc, 0x0b, 0xd9, 0x4d, 0x83, 0xd4, 0x69, 0xc3, 0x34, 0x34,
0x6a, 0x89, 0x53, 0x89, 0xb3, 0x10, 0xb7, 0xc9, 0x8e, 0x7b, 0xb8, 0xf9, 0x4f, 0xfc, 0x26, 0x24,
0xec, 0xfd, 0x76, 0xb7, 0xc2, 0xaf, 0x48, 0x8f, 0x8f, 0xcf, 0xcc, 0xd6, 0x7e, 0x9b, 0xaa, 0x62,
0x07, 0x5e, 0x80, 0xa4, 0x20, 0x93, 0x38, 0xa8, 0x78, 0x21, 0xa5, 0xba, 0x2b, 0xe5, 0x51, 0xc0,
0xef, 0xba, 0x65, 0x76, 0xda, 0xb8, 0x0c, 0xa9, 0x76, 0x4f, 0xd6, 0x1d, 0xf0, 0xce, 0xf7, 0xf3,
0x26, 0x40, 0xab, 0x81, 0xad, 0xca, 0xdf, 0x08, 0xd2, 0x15, 0x4a, 0xac, 0x7a, 0xe3, 0x38, 0xcc,
0xe8, 0x3c, 0xe3, 0x1a, 0x33, 0xdc, 0x63, 0xca, 0x7f, 0xe2, 0xcb, 0x30, 0xe3, 0x0b, 0xa8, 0xba,
0xc3, 0x13, 0x94, 0x4b, 0x0a, 0x4e, 0x34, 0xdb, 0x0e, 0x25, 0x4e, 0xb9, 0x0b, 0x89, 0x3b, 0xba,
0x2d, 0xcc, 0xf0, 0x8f, 0x30, 0x12, 0x1f, 0x61, 0xfe, 0x13, 0x9f, 0xf4, 0xf5, 0x6d, 0x4c, 0x14,
0xc0, 0x6b, 0x4e, 0x41, 0xb5, 0x9a, 0x96, 0x5b, 0x99, 0x98, 0xea, 0xae, 0x94, 0x77, 0x7b, 0x99,
0x63, 0x1d, 0x23, 0x30, 0x37, 0x3f, 0xc3, 0xa5, 0x80, 0x21, 0xd1, 0xd0, 0x6d, 0xe6, 0x3a, 0x15,
0xbf, 0x95, 0xcf, 0x10, 0xa4, 0x6e, 0x1b, 0x1d, 0x36, 0xcc, 0x9a, 0x5c, 0xba, 0x0e, 0xd3, 0xa1,
0x4e, 0xc5, 0x13, 0x90, 0xd8, 0x78, 0xb0, 0x71, 0x2b, 0x3b, 0x86, 0x67, 0x20, 0xfd, 0xf0, 0xd6,
0xcd, 0xad, 0x07, 0x6a, 0xb5, 0x58, 0xde, 0xb8, 0xa1, 0x6e, 0x67, 0x35, 0x9c, 0x85, 0x94, 0x2b,
0xba, 0x7d, 0xef, 0xc1, 0x8d, 0xad, 0x2c, 0x5d, 0xfb, 0x31, 0x0b, 0xe9, 0xfb, 0x02, 0x69, 0x85,
0x5a, 0xbb, 0x7a, 0x9d, 0xe2, 0x2a, 0x64, 0xc3, 0x1c, 0x3a, 0xbe, 0x22, 0x6d, 0xdb, 0x08, 0xaa,
0x3d, 0x7f, 0x58, 0x4e, 0x95, 0x31, 0xfc, 0x3e, 0x64, 0x82, 0xec, 0x37, 0xbe, 0x24, 0x35, 0x2f,
0xa5, 0xc8, 0xfb, 0x19, 0xaf, 0x42, 0x3a, 0xc0, 0x66, 0xe3, 0x8b, 0x52, 0xdb, 0x32, 0xc6, 0x3b,
0x7f, 0x4e, 0xaa, 0xea, 0x27, 0xa4, 0x1d, 0xf4, 0x41, 0x86, 0x34, 0x02, 0xbd, 0x94, 0x46, 0xed,
0x87, 0x9e, 0xc0, 0xcc, 0x01, 0xc2, 0x13, 0x5f, 0x95, 0xda, 0x8f, 0x22, 0x46, 0xfb, 0xb9, 0xd8,
0x03, 0x7c, 0x90, 0x74, 0xc6, 0x2b, 0xf2, 0x0a, 0x44, 0xf1, 0xe5, 0xf9, 0xd5, 0x81, 0xf5, 0xbd,
0xc4, 0xed, 0xc2, 0xe2, 0x3a, 0xb5, 0x83, 0x7c, 0xa5, 0xce, 0x6c, 0xbd, 0xce, 0xf0, 0x65, 0x79,
0x7b, 0x49, 0x99, 0xd6, 0xfc, 0x95, 0xc1, 0x94, 0x3d, 0xbf, 0x06, 0x4c, 0x07, 0x79, 0x43, 0x16,
0x51, 0x31, 0x29, 0x83, 0x99, 0xbf, 0x3c, 0x90, 0xae, 0xe7, 0xed, 0x11, 0x4c, 0x87, 0xa8, 0xc2,
0xa8, 0xe8, 0xa4, 0x84, 0x62, 0xbf, 0xea, 0x6d, 0x43, 0x3a, 0xc0, 0xe9, 0x45, 0xb4, 0xb7, 0x8c,
0xf7, 0xeb, 0x67, 0xfa, 0x11, 0xa4, 0xfc, 0xd4, 0x1b, 0x2e, 0x44, 0x1d, 0x9c, 0x03, 0x86, 0x07,
0x3a, 0x37, 0xdb, 0xce, 0xb9, 0xf1, 0x36, 0xb3, 0x08, 0x07, 0x12, 0x2e, 0xad, 0x1f, 0xf2, 0x0f,
0xbc, 0x53, 0xe3, 0xb3, 0x7e, 0xe5, 0xb0, 0x53, 0xf3, 0xac, 0xb9, 0x61, 0xb0, 0xb0, 0x4e, 0xed,
0x00, 0x87, 0xe3, 0xb6, 0xae, 0xbc, 0x95, 0xa4, 0x14, 0x55, 0x44, 0x2b, 0xc9, 0x99, 0x21, 0x65,
0x0c, 0xeb, 0x90, 0x09, 0x70, 0x1f, 0x2c, 0xa2, 0xd8, 0x32, 0x46, 0x27, 0x7f, 0x69, 0x10, 0x55,
0xcf, 0xd5, 0x3b, 0x30, 0xe5, 0x7b, 0xd6, 0xe2, 0xe5, 0x43, 0x3a, 0xd6, 0xff, 0x0c, 0xec, 0x97,
0xb6, 0x06, 0xa4, 0x03, 0x8f, 0xa0, 0xa8, 0x6e, 0x95, 0xbc, 0x30, 0x23, 0x02, 0x90, 0xbe, 0xa9,
0x94, 0x31, 0x5c, 0x83, 0xf4, 0x3a, 0xb5, 0x7b, 0x73, 0x39, 0xbe, 0x10, 0xfd, 0x2a, 0xf2, 0xbf,
0x76, 0xf2, 0xcb, 0x7d, 0xf5, 0x3c, 0x1f, 0x15, 0x48, 0x3a, 0x23, 0x2e, 0x56, 0x22, 0x36, 0xf9,
0xe6, 0xff, 0xfc, 0xcb, 0x87, 0xea, 0x78, 0x46, 0x55, 0x48, 0x3a, 0x03, 0x4a, 0x84, 0xd1, 0xc0,
0xdc, 0x97, 0x3f, 0x5c, 0x47, 0x4c, 0x38, 0xca, 0x18, 0x2e, 0xc3, 0xb8, 0x98, 0x4c, 0xb0, 0xfc,
0x60, 0xfa, 0xa7, 0x96, 0x3e, 0x15, 0x2c, 0x16, 0xdf, 0xbb, 0xbe, 0xa3, 0xdb, 0x8d, 0x4e, 0x8d,
0xff, 0xb3, 0xfa, 0x44, 0x37, 0x0c, 0xfd, 0x89, 0x4d, 0xeb, 0x8d, 0x55, 0x67, 0xd7, 0x55, 0x4d,
0x67, 0xb6, 0xa5, 0xd7, 0x3a, 0x36, 0xd5, 0x56, 0xf5, 0x96, 0x4d, 0xad, 0x16, 0x31, 0x56, 0x85,
0x29, 0x57, 0xa3, 0x5d, 0xab, 0x25, 0xc5, 0xfa, 0xda, 0x7f, 0x01, 0x00, 0x00, 0xff, 0xff, 0xa4,
0x89, 0x87, 0x99, 0xdd, 0x1f, 0x00, 0x00,
// 1604 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x59, 0x5d, 0x6f, 0x1b, 0x45,
0x17, 0xce, 0xc6, 0x8e, 0x9b, 0x9c, 0xd8, 0x8e, 0x33, 0xf9, 0x72, 0xdd, 0xf6, 0x6d, 0xba, 0xef,
0xdb, 0x26, 0xfd, 0x4a, 0x5e, 0xa5, 0x20, 0xe0, 0x02, 0xa9, 0x4d, 0x9c, 0xa6, 0x56, 0xdb, 0x34,
0xac, 0x43, 0x45, 0xa8, 0x2a, 0x33, 0xf6, 0x0e, 0xf1, 0xc2, 0x7a, 0xd7, 0xec, 0x8c, 0x93, 0xa6,
0x57, 0x08, 0x24, 0x90, 0x00, 0x01, 0xb7, 0xdc, 0x22, 0xae, 0x11, 0x14, 0x89, 0x7f, 0x80, 0xc4,
0x7f, 0x41, 0x88, 0x5f, 0x80, 0x84, 0x76, 0x66, 0xb3, 0xde, 0xdd, 0xcc, 0xc6, 0xa6, 0xa6, 0xd8,
0xb9, 0xdb, 0x39, 0x3e, 0x73, 0xe6, 0x39, 0x1f, 0x33, 0x73, 0xe6, 0x31, 0xa4, 0x1b, 0x86, 0xb9,
0xd7, 0xa2, 0x4b, 0x4d, 0xc7, 0x66, 0x36, 0x9a, 0x0a, 0x8e, 0x96, 0xc4, 0xa0, 0x90, 0xae, 0xd9,
0x8d, 0x86, 0x6d, 0x09, 0x61, 0x21, 0x4d, 0x6b, 0x75, 0xd2, 0xc0, 0x62, 0xa4, 0x7e, 0xa7, 0xc0,
0xdc, 0x9a, 0x43, 0x30, 0x23, 0x6b, 0xb6, 0x69, 0x92, 0x1a, 0x33, 0x6c, 0x4b, 0x23, 0x1f, 0xb4,
0x08, 0x65, 0xe8, 0xff, 0x90, 0xac, 0x62, 0x4a, 0xf2, 0xca, 0xbc, 0xb2, 0x38, 0xbe, 0x72, 0x76,
0x29, 0x64, 0xdb, 0xb3, 0x79, 0x9f, 0xee, 0xae, 0x62, 0x4a, 0x34, 0xae, 0x89, 0xe6, 0xe0, 0x94,
0x5e, 0xad, 0x58, 0xb8, 0x41, 0xf2, 0xc3, 0xf3, 0xca, 0xe2, 0x98, 0x96, 0xd2, 0xab, 0x9b, 0xb8,
0x41, 0xd0, 0x25, 0xc8, 0xd6, 0x7c, 0xfb, 0xae, 0x24, 0x9f, 0xe0, 0xbf, 0x47, 0xa4, 0x68, 0x16,
0x52, 0x02, 0x5e, 0x3e, 0x39, 0xaf, 0x2c, 0xa6, 0x35, 0x6f, 0xa4, 0x7e, 0xa6, 0xc0, 0x4c, 0xd1,
0xb1, 0x9b, 0x83, 0x00, 0xd2, 0x05, 0x33, 0x7d, 0x07, 0xd3, 0x17, 0x8a, 0x65, 0x01, 0x26, 0xda,
0xab, 0x0a, 0x05, 0x39, 0x98, 0x1d, 0x48, 0xaf, 0xda, 0xb6, 0xa9, 0x11, 0xda, 0xb4, 0x2d, 0x4a,
0xd0, 0x0d, 0x48, 0x51, 0x86, 0x59, 0x8b, 0x7a, 0x28, 0xce, 0x48, 0x51, 0x94, 0xb9, 0x8a, 0xe6,
0xa9, 0xa2, 0x69, 0x18, 0xd9, 0xc3, 0x66, 0x4b, 0x80, 0x18, 0xd5, 0xc4, 0x40, 0x7d, 0x04, 0xd9,
0x32, 0x73, 0x0c, 0x6b, 0xf7, 0x1f, 0x34, 0x3e, 0x76, 0x68, 0xfc, 0x2b, 0x05, 0x4e, 0x17, 0x09,
0xad, 0x39, 0x46, 0x95, 0x0c, 0x46, 0x24, 0xbf, 0x56, 0xa0, 0x20, 0x43, 0xd4, 0x8b, 0xef, 0xaf,
0xfb, 0xf5, 0x3c, 0xcc, 0x27, 0x5d, 0x0c, 0x4f, 0xf2, 0xb6, 0x62, 0x7b, 0xb5, 0x32, 0x17, 0xf8,
0x65, 0xff, 0xb9, 0x02, 0x33, 0xf7, 0x6c, 0xac, 0x0f, 0x46, 0x80, 0xbe, 0x54, 0x20, 0xaf, 0x11,
0x93, 0x60, 0x3a, 0x20, 0x19, 0xfb, 0x42, 0x81, 0xd9, 0x40, 0xec, 0x18, 0x66, 0xb4, 0x9f, 0x70,
0x3e, 0x75, 0xcf, 0xd2, 0x28, 0x9c, 0x5e, 0xaa, 0xe7, 0x15, 0x18, 0x71, 0xbf, 0x68, 0x7e, 0x78,
0x3e, 0xb1, 0x38, 0xbe, 0x72, 0x41, 0x3a, 0xe7, 0x2e, 0x39, 0x78, 0xe8, 0xee, 0xa8, 0x2d, 0x6c,
0x38, 0x9a, 0xd0, 0x57, 0xab, 0x30, 0x53, 0xae, 0xdb, 0xfb, 0x2f, 0x32, 0x4b, 0xea, 0x13, 0x98,
0x8d, 0xae, 0xd1, 0x8b, 0xaf, 0x97, 0x21, 0x17, 0x89, 0xb2, 0x70, 0x7b, 0x4c, 0x9b, 0x08, 0x87,
0x99, 0xaa, 0x3f, 0xb9, 0x69, 0xe7, 0x77, 0xd6, 0x16, 0x76, 0x98, 0xd1, 0xe7, 0x2a, 0x44, 0x17,
0x21, 0xdb, 0x3c, 0xc4, 0x21, 0xf4, 0x92, 0x5c, 0x2f, 0xe3, 0x4b, 0x79, 0xbc, 0x7e, 0x54, 0x60,
0xda, 0xbd, 0xc2, 0x4e, 0x12, 0xe6, 0x1f, 0x14, 0x98, 0xba, 0x83, 0xe9, 0x49, 0x82, 0xfc, 0x4c,
0x81, 0x29, 0xf7, 0xc8, 0x14, 0x98, 0xfb, 0x0b, 0x79, 0x01, 0x26, 0xc2, 0x90, 0x69, 0x3e, 0xc9,
0x4b, 0x3a, 0x1b, 0xc2, 0x4c, 0xd5, 0x9f, 0x15, 0x98, 0xf3, 0x4e, 0xd6, 0x81, 0x88, 0x75, 0xd7,
0xc0, 0x9f, 0x29, 0x30, 0xe3, 0x23, 0xee, 0xf7, 0x01, 0xdc, 0x6d, 0x89, 0x7c, 0xa2, 0xc0, 0x6c,
0x14, 0x74, 0x5f, 0x8e, 0xe9, 0xef, 0x15, 0x98, 0x76, 0xcf, 0xd0, 0x81, 0xc8, 0xb9, 0x0a, 0xe9,
0xb6, 0xa4, 0x54, 0xe4, 0xa1, 0x4b, 0x68, 0x21, 0x99, 0xfa, 0x8d, 0x22, 0x2e, 0x96, 0x00, 0xe0,
0x5e, 0x02, 0x27, 0x29, 0xb3, 0x61, 0x59, 0x99, 0xb9, 0xd8, 0x7c, 0x49, 0xa9, 0x48, 0xf3, 0x89,
0xf9, 0x84, 0x8b, 0x2d, 0x28, 0xe3, 0xcd, 0xc0, 0x61, 0xfb, 0x56, 0x26, 0xbb, 0x0d, 0x62, 0xb1,
0xe7, 0x0f, 0x67, 0x34, 0x18, 0xc3, 0x47, 0x83, 0x81, 0xce, 0xc2, 0x18, 0x15, 0xeb, 0x94, 0x8a,
0x3c, 0xa6, 0x09, 0xad, 0x2d, 0x50, 0xeb, 0x30, 0x77, 0x04, 0x4d, 0x2f, 0xb1, 0xca, 0xc3, 0x29,
0xc3, 0xd2, 0xc9, 0x13, 0x1f, 0xcc, 0xe1, 0xd0, 0x75, 0x1c, 0xb9, 0x49, 0xf9, 0x57, 0x9c, 0x9e,
0x87, 0xf1, 0x40, 0xd4, 0x3d, 0xb7, 0x83, 0x22, 0xf5, 0x3d, 0x98, 0x0a, 0xa1, 0xe9, 0xc5, 0xe9,
0xff, 0x00, 0xf8, 0x11, 0x15, 0xb5, 0x91, 0xd0, 0x02, 0x12, 0xf5, 0x77, 0x05, 0x90, 0xe8, 0x04,
0x4a, 0x6e, 0x30, 0xfa, 0xb9, 0x7d, 0xce, 0x01, 0xbc, 0x6b, 0x10, 0x53, 0x0f, 0x9e, 0x3b, 0x63,
0x5c, 0xc2, 0x7f, 0x2e, 0x42, 0x9a, 0x3c, 0x61, 0x0e, 0xae, 0x34, 0xb1, 0x83, 0x1b, 0x34, 0x3f,
0xd2, 0xed, 0x51, 0x31, 0xce, 0xa7, 0x6d, 0xf1, 0x59, 0xea, 0xaf, 0x6e, 0x0f, 0xe1, 0x55, 0xd5,
0xa0, 0x7b, 0x7c, 0x0e, 0x80, 0x57, 0xa8, 0xf8, 0x79, 0x44, 0xfc, 0xcc, 0x25, 0xfc, 0x10, 0x36,
0x21, 0xc7, 0x3d, 0x10, 0xee, 0x34, 0x5d, 0xab, 0x91, 0x29, 0x4a, 0x64, 0x0a, 0x7a, 0x0d, 0x52,
0x5e, 0xf4, 0xba, 0x3e, 0x68, 0xbd, 0x09, 0xea, 0xb7, 0x0a, 0xcc, 0x44, 0x02, 0xd7, 0x4b, 0x5d,
0x6e, 0x03, 0x12, 0x40, 0xf5, 0x36, 0xfa, 0x43, 0x54, 0x91, 0x27, 0x9e, 0x37, 0x88, 0xfa, 0xaa,
0x4d, 0x1a, 0x11, 0x09, 0x55, 0x7f, 0x51, 0x60, 0x92, 0xeb, 0xb9, 0xab, 0x91, 0x93, 0x9b, 0xda,
0x0f, 0x15, 0x40, 0x41, 0x3f, 0x7a, 0x89, 0xf4, 0xcb, 0xe2, 0x6e, 0x15, 0x9e, 0x64, 0x57, 0xce,
0x4b, 0xe7, 0x04, 0x16, 0x13, 0xda, 0xea, 0x9f, 0x0a, 0x64, 0x4a, 0x16, 0x25, 0x0e, 0x1b, 0xfc,
0x7e, 0x04, 0xbd, 0x04, 0xa3, 0x8e, 0xbd, 0x5f, 0xd1, 0x31, 0xc3, 0xde, 0xb9, 0x70, 0x5a, 0x0a,
0x6f, 0xd5, 0xb4, 0xab, 0xda, 0x29, 0xc7, 0xde, 0x2f, 0x62, 0x86, 0xd1, 0x19, 0x18, 0xab, 0x63,
0x5a, 0xaf, 0xbc, 0x4f, 0x0e, 0x68, 0x3e, 0x35, 0x9f, 0x58, 0xcc, 0x68, 0xa3, 0xae, 0xe0, 0x2e,
0x39, 0xa0, 0xea, 0xc7, 0x0a, 0x64, 0x0f, 0xfd, 0xef, 0x25, 0xfc, 0xe7, 0x61, 0xdc, 0xb1, 0xf7,
0x4b, 0xc5, 0x4a, 0x95, 0xec, 0x1a, 0x96, 0x77, 0x23, 0x00, 0x17, 0xad, 0xba, 0x12, 0x17, 0x85,
0x50, 0x20, 0x96, 0xee, 0xdd, 0x06, 0xa3, 0x5c, 0xb0, 0x6e, 0xe9, 0xea, 0x1e, 0xe4, 0xb6, 0x4c,
0x5c, 0x23, 0x75, 0xdb, 0xd4, 0x89, 0xc3, 0x77, 0x25, 0xca, 0x41, 0x82, 0xe1, 0x5d, 0x6f, 0x73,
0xbb, 0x9f, 0xe8, 0x55, 0x48, 0xb2, 0x83, 0xe6, 0x61, 0x86, 0xff, 0x27, 0xdd, 0x3e, 0x01, 0x33,
0xdb, 0x07, 0x4d, 0xa2, 0xf1, 0x19, 0x68, 0x16, 0x52, 0x9c, 0x4c, 0x12, 0x0d, 0x41, 0x5a, 0xf3,
0x46, 0xea, 0xe3, 0xd0, 0xba, 0x1b, 0x8e, 0xdd, 0x6a, 0xa2, 0x12, 0xa4, 0x9b, 0x6d, 0x99, 0x1b,
0x84, 0xf8, 0xcd, 0x1a, 0x05, 0xad, 0x85, 0xa6, 0xaa, 0xbf, 0x29, 0x90, 0x29, 0x13, 0xec, 0xd4,
0xea, 0x27, 0xa1, 0x47, 0x77, 0x23, 0xae, 0x53, 0xd3, 0xdb, 0xa6, 0xee, 0x27, 0xba, 0x0a, 0x93,
0x01, 0x87, 0x2a, 0xbb, 0x6e, 0x80, 0xf2, 0x29, 0x4e, 0xb8, 0xe6, 0x9a, 0x91, 0xc0, 0xa9, 0x77,
0x21, 0x79, 0xc7, 0x60, 0xdc, 0x8c, 0x7b, 0x09, 0x2b, 0xfc, 0x12, 0x76, 0x3f, 0xd1, 0xe9, 0x40,
0xdd, 0x0e, 0xf3, 0x04, 0xf8, 0xc5, 0xc9, 0x79, 0x5c, 0xdb, 0xf1, 0x32, 0x33, 0xac, 0x79, 0x23,
0xf5, 0xad, 0x76, 0xe4, 0x68, 0xcb, 0x64, 0xf4, 0xf9, 0xaa, 0x12, 0x41, 0xb2, 0x6e, 0x78, 0xfd,
0x76, 0x5a, 0xe3, 0xdf, 0xea, 0x47, 0x0a, 0xa4, 0x6f, 0x9b, 0x2d, 0xda, 0xcf, 0x9c, 0x5c, 0xb9,
0x09, 0x13, 0x91, 0x4a, 0x45, 0xa3, 0x90, 0xdc, 0x7c, 0xb0, 0xb9, 0x9e, 0x1b, 0x42, 0x93, 0x90,
0x79, 0xb8, 0xbe, 0xb6, 0xfd, 0x40, 0xab, 0xac, 0x96, 0x36, 0x6f, 0x69, 0x3b, 0x39, 0x1d, 0xe5,
0x20, 0xed, 0x89, 0x6e, 0xdf, 0x7b, 0x70, 0x6b, 0x3b, 0x47, 0x56, 0xfe, 0xc8, 0x41, 0xe6, 0x3e,
0x47, 0x5a, 0x26, 0xce, 0x9e, 0x51, 0x23, 0xa8, 0x02, 0xb9, 0x28, 0x41, 0x8f, 0xae, 0x49, 0xcb,
0x36, 0x86, 0xc7, 0x2f, 0x1c, 0x17, 0x53, 0x75, 0x08, 0x3d, 0x82, 0x6c, 0x98, 0x5a, 0x47, 0x57,
0xa4, 0xe6, 0xa5, 0xfc, 0x7b, 0x27, 0xe3, 0x15, 0xc8, 0x84, 0xa8, 0x72, 0x74, 0x59, 0x6a, 0x5b,
0x46, 0xa7, 0x17, 0x2e, 0x48, 0x55, 0x83, 0x6c, 0xb7, 0x40, 0x1f, 0x66, 0x48, 0x63, 0xd0, 0x4b,
0x69, 0xd4, 0x4e, 0xe8, 0x31, 0x4c, 0x1e, 0x21, 0x3c, 0xd1, 0x75, 0xa9, 0xfd, 0x38, 0x62, 0xb4,
0xd3, 0x12, 0xfb, 0x80, 0x8e, 0x92, 0xce, 0x68, 0x49, 0x9e, 0x81, 0x38, 0xbe, 0xbc, 0xb0, 0xdc,
0xb5, 0xbe, 0x1f, 0xb8, 0x3d, 0x98, 0xdb, 0x20, 0x2c, 0xcc, 0x57, 0x1a, 0x94, 0x19, 0x35, 0x8a,
0xae, 0xca, 0xcb, 0x4b, 0xca, 0xb4, 0x16, 0xae, 0x75, 0xa7, 0xec, 0xaf, 0x6b, 0xc2, 0x44, 0x98,
0x37, 0xa4, 0x31, 0x19, 0x93, 0x32, 0x98, 0x85, 0xab, 0x5d, 0xe9, 0xfa, 0xab, 0x3d, 0x86, 0x89,
0x08, 0x55, 0x18, 0xe7, 0x9d, 0x94, 0x50, 0xec, 0x94, 0xbd, 0x1d, 0xc8, 0x84, 0x38, 0xbd, 0x98,
0xf2, 0x96, 0xf1, 0x7e, 0x9d, 0x4c, 0x3f, 0x86, 0x74, 0x90, 0x7a, 0x43, 0x8b, 0x71, 0x1b, 0xe7,
0x88, 0xe1, 0xae, 0xf6, 0xcd, 0x8e, 0xd8, 0x37, 0xfe, 0x64, 0x1a, 0xb3, 0x80, 0x84, 0x4b, 0xeb,
0x84, 0xfc, 0x1d, 0x7f, 0xd7, 0x04, 0xac, 0x5f, 0x3b, 0x6e, 0xd7, 0xfc, 0xdd, 0xd8, 0x50, 0x98,
0xdd, 0x20, 0x2c, 0xc4, 0xe1, 0x78, 0xa5, 0x2b, 0x2f, 0x25, 0x29, 0x45, 0x15, 0x53, 0x4a, 0x72,
0x66, 0x48, 0x1d, 0x42, 0x06, 0x64, 0x43, 0xdc, 0x07, 0x8d, 0x49, 0xb6, 0x8c, 0xd1, 0x29, 0x5c,
0xe9, 0x46, 0xd5, 0x5f, 0xea, 0x4d, 0x18, 0x0f, 0x3c, 0x6b, 0xd1, 0xc2, 0x31, 0x15, 0x1b, 0x7c,
0x06, 0x76, 0x0a, 0x5b, 0x1d, 0x32, 0xa1, 0x47, 0x50, 0x5c, 0xb5, 0x4a, 0x5e, 0x98, 0x31, 0x0e,
0x48, 0xdf, 0x54, 0xea, 0x10, 0xaa, 0x42, 0x66, 0x83, 0xb0, 0x76, 0x5f, 0x8e, 0x2e, 0xc5, 0xbf,
0x8a, 0x82, 0xaf, 0x9d, 0xc2, 0x42, 0x47, 0x3d, 0x7f, 0x8d, 0x32, 0xa4, 0x44, 0x8b, 0x8b, 0xd4,
0x98, 0x49, 0x81, 0xfe, 0xbf, 0xf0, 0xdf, 0x63, 0x75, 0x7c, 0xa3, 0x1a, 0xa4, 0x44, 0x83, 0x12,
0x63, 0x34, 0xd4, 0xf7, 0x15, 0x8e, 0xd7, 0xe1, 0x1d, 0x8e, 0x3a, 0x84, 0x4a, 0x30, 0xc2, 0x3b,
0x13, 0x24, 0xdf, 0x98, 0xc1, 0xae, 0xa5, 0x53, 0x06, 0xdf, 0x80, 0xf4, 0x06, 0x61, 0x45, 0x7d,
0xad, 0x8e, 0x2d, 0x8b, 0x98, 0xa8, 0x20, 0x55, 0x5f, 0x6f, 0x34, 0xd9, 0x41, 0x8c, 0xc7, 0xe1,
0x7f, 0x74, 0xd5, 0xa1, 0xd5, 0xd5, 0xb7, 0x6f, 0xee, 0x1a, 0xac, 0xde, 0xaa, 0xba, 0xb3, 0x97,
0x9f, 0x1a, 0xa6, 0x69, 0x3c, 0x65, 0xa4, 0x56, 0x5f, 0x16, 0x13, 0xae, 0xeb, 0x06, 0x65, 0x8e,
0x51, 0x6d, 0x31, 0xa2, 0x2f, 0x1b, 0x16, 0x23, 0x8e, 0x85, 0xcd, 0x65, 0x6e, 0xd2, 0xd3, 0x68,
0x56, 0xab, 0x29, 0x3e, 0xbe, 0xf1, 0x57, 0x00, 0x00, 0x00, 0xff, 0xff, 0x7e, 0x56, 0x43, 0xfd,
0x8d, 0x20, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
@ -2431,6 +2481,7 @@ type MilvusServiceClient interface {
Insert(ctx context.Context, in *InsertRequest, opts ...grpc.CallOption) (*InsertResponse, error)
Search(ctx context.Context, in *SearchRequest, opts ...grpc.CallOption) (*SearchResults, error)
Flush(ctx context.Context, in *FlushRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
GetDdChannel(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*StringResponse, error)
}
type milvusServiceClient struct {
@ -2630,6 +2681,15 @@ func (c *milvusServiceClient) Flush(ctx context.Context, in *FlushRequest, opts
return out, nil
}
func (c *milvusServiceClient) GetDdChannel(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*StringResponse, error) {
out := new(StringResponse)
err := c.cc.Invoke(ctx, "/milvus.proto.milvus.MilvusService/GetDdChannel", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// MilvusServiceServer is the server API for MilvusService service.
type MilvusServiceServer interface {
CreateCollection(context.Context, *CreateCollectionRequest) (*commonpb.Status, error)
@ -2653,6 +2713,7 @@ type MilvusServiceServer interface {
Insert(context.Context, *InsertRequest) (*InsertResponse, error)
Search(context.Context, *SearchRequest) (*SearchResults, error)
Flush(context.Context, *FlushRequest) (*commonpb.Status, error)
GetDdChannel(context.Context, *commonpb.Empty) (*StringResponse, error)
}
// UnimplementedMilvusServiceServer can be embedded to have forward compatible implementations.
@ -2722,6 +2783,9 @@ func (*UnimplementedMilvusServiceServer) Search(ctx context.Context, req *Search
func (*UnimplementedMilvusServiceServer) Flush(ctx context.Context, req *FlushRequest) (*commonpb.Status, error) {
return nil, status.Errorf(codes.Unimplemented, "method Flush not implemented")
}
func (*UnimplementedMilvusServiceServer) GetDdChannel(ctx context.Context, req *commonpb.Empty) (*StringResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetDdChannel not implemented")
}
func RegisterMilvusServiceServer(s *grpc.Server, srv MilvusServiceServer) {
s.RegisterService(&_MilvusService_serviceDesc, srv)
@ -3105,6 +3169,24 @@ func _MilvusService_Flush_Handler(srv interface{}, ctx context.Context, dec func
return interceptor(ctx, in, info, handler)
}
func _MilvusService_GetDdChannel_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.(MilvusServiceServer).GetDdChannel(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/milvus.proto.milvus.MilvusService/GetDdChannel",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(MilvusServiceServer).GetDdChannel(ctx, req.(*commonpb.Empty))
}
return interceptor(ctx, in, info, handler)
}
var _MilvusService_serviceDesc = grpc.ServiceDesc{
ServiceName: "milvus.proto.milvus.MilvusService",
HandlerType: (*MilvusServiceServer)(nil),
@ -3193,6 +3275,10 @@ var _MilvusService_serviceDesc = grpc.ServiceDesc{
MethodName: "Flush",
Handler: _MilvusService_Flush_Handler,
},
{
MethodName: "GetDdChannel",
Handler: _MilvusService_GetDdChannel_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "milvus.proto",

2
internal/proxynode/grpc_service.go
View File

@ -753,7 +753,7 @@ func (p *Proxy) DescribeIndexProgress(ctx context.Context, req *servicepb.Descri
Condition: NewTaskCondition(ctx),
IndexStateRequest: milvuspb.IndexStateRequest{
Base: &commonpb.MsgBase{
MsgType: commonpb.MsgType_kDescribeIndexProgress,
MsgType: commonpb.MsgType_kGetIndexState,
SourceID: Params.ProxyID(),
},
CollectionName: req.CollectionName,

5
internal/util/typeutil/service.go
View File

@ -4,10 +4,13 @@ import (
"github.com/zilliztech/milvus-distributed/internal/proto/internalpb2"
)
type Component interface {
type Service interface {
Init()
Start()
Stop()
}
type Component interface {
GetServiceStates() (internalpb2.ServiceStates, error)
GetTimeTickChannel() (string, error)
GetStatisticsChannel() (string, error)