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

Refactor query service 

Signed-off-by: xige-16 <xi.ge@zilliz.com>
pull/4973/head^2
xige-16 2021-01-22 14:28:06 +08:00 committed by yefu.chen
parent 2d2dbd7d19
commit 511aa419fa
26 changed files with 1512 additions and 928 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
configs/milvus.yaml
View File

@ -51,6 +51,10 @@ proxyNode:
address: localhost
port: 19530
queryService:
address: localhost
port: 19531
proxyService:
address: localhost
port: 19530

439
internal/core/src/pb/milvus.pb.cc
View File

@ -872,7 +872,6 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_milvus_2eproto::offsets[] PROT
~0u, // no _weak_field_map_
PROTOBUF_FIELD_OFFSET(::milvus::proto::milvus::DescribeCollectionResponse, status_),
PROTOBUF_FIELD_OFFSET(::milvus::proto::milvus::DescribeCollectionResponse, schema_),
PROTOBUF_FIELD_OFFSET(::milvus::proto::milvus::DescribeCollectionResponse, collectionid_),
~0u, // no _has_bits_
PROTOBUF_FIELD_OFFSET(::milvus::proto::milvus::LoadCollectionRequest, _internal_metadata_),
~0u, // no _extensions_
@ -1160,40 +1159,40 @@ static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOB
{ 32, -1, sizeof(::milvus::proto::milvus::StringResponse)},
{ 39, -1, sizeof(::milvus::proto::milvus::DescribeCollectionRequest)},
{ 47, -1, sizeof(::milvus::proto::milvus::DescribeCollectionResponse)},
{ 55, -1, sizeof(::milvus::proto::milvus::LoadCollectionRequest)},
{ 63, -1, sizeof(::milvus::proto::milvus::ReleaseCollectionRequest)},
{ 71, -1, sizeof(::milvus::proto::milvus::CollectionStatsRequest)},
{ 79, -1, sizeof(::milvus::proto::milvus::CollectionStatsResponse)},
{ 86, -1, sizeof(::milvus::proto::milvus::ShowCollectionRequest)},
{ 93, -1, sizeof(::milvus::proto::milvus::ShowCollectionResponse)},
{ 100, -1, sizeof(::milvus::proto::milvus::CreatePartitionRequest)},
{ 109, -1, sizeof(::milvus::proto::milvus::DropPartitionRequest)},
{ 118, -1, sizeof(::milvus::proto::milvus::HasPartitionRequest)},
{ 127, -1, sizeof(::milvus::proto::milvus::LoadPartitonRequest)},
{ 136, -1, sizeof(::milvus::proto::milvus::ReleasePartitionRequest)},
{ 145, -1, sizeof(::milvus::proto::milvus::PartitionStatsRequest)},
{ 154, -1, sizeof(::milvus::proto::milvus::PartitionStatsResponse)},
{ 161, -1, sizeof(::milvus::proto::milvus::ShowPartitionRequest)},
{ 170, -1, sizeof(::milvus::proto::milvus::ShowPartitionResponse)},
{ 178, -1, sizeof(::milvus::proto::milvus::DescribeSegmentRequest)},
{ 186, -1, sizeof(::milvus::proto::milvus::DescribeSegmentResponse)},
{ 193, -1, sizeof(::milvus::proto::milvus::ShowSegmentRequest)},
{ 201, -1, sizeof(::milvus::proto::milvus::ShowSegmentResponse)},
{ 208, -1, sizeof(::milvus::proto::milvus::CreateIndexRequest)},
{ 218, -1, sizeof(::milvus::proto::milvus::DescribeIndexRequest)},
{ 228, -1, sizeof(::milvus::proto::milvus::IndexDescription)},
{ 235, -1, sizeof(::milvus::proto::milvus::DescribeIndexResponse)},
{ 242, -1, sizeof(::milvus::proto::milvus::IndexStateRequest)},
{ 252, -1, sizeof(::milvus::proto::milvus::IndexStateResponse)},
{ 259, -1, sizeof(::milvus::proto::milvus::InsertRequest)},
{ 270, -1, sizeof(::milvus::proto::milvus::InsertResponse)},
{ 278, -1, sizeof(::milvus::proto::milvus::PlaceholderValue)},
{ 286, -1, sizeof(::milvus::proto::milvus::PlaceholderGroup)},
{ 292, -1, sizeof(::milvus::proto::milvus::SearchRequest)},
{ 303, -1, sizeof(::milvus::proto::milvus::Hits)},
{ 311, -1, sizeof(::milvus::proto::milvus::SearchResults)},
{ 318, -1, sizeof(::milvus::proto::milvus::FlushRequest)},
{ 326, -1, sizeof(::milvus::proto::milvus::RegisterLinkResponse)},
{ 54, -1, sizeof(::milvus::proto::milvus::LoadCollectionRequest)},
{ 62, -1, sizeof(::milvus::proto::milvus::ReleaseCollectionRequest)},
{ 70, -1, sizeof(::milvus::proto::milvus::CollectionStatsRequest)},
{ 78, -1, sizeof(::milvus::proto::milvus::CollectionStatsResponse)},
{ 85, -1, sizeof(::milvus::proto::milvus::ShowCollectionRequest)},
{ 92, -1, sizeof(::milvus::proto::milvus::ShowCollectionResponse)},
{ 99, -1, sizeof(::milvus::proto::milvus::CreatePartitionRequest)},
{ 108, -1, sizeof(::milvus::proto::milvus::DropPartitionRequest)},
{ 117, -1, sizeof(::milvus::proto::milvus::HasPartitionRequest)},
{ 126, -1, sizeof(::milvus::proto::milvus::LoadPartitonRequest)},
{ 135, -1, sizeof(::milvus::proto::milvus::ReleasePartitionRequest)},
{ 144, -1, sizeof(::milvus::proto::milvus::PartitionStatsRequest)},
{ 153, -1, sizeof(::milvus::proto::milvus::PartitionStatsResponse)},
{ 160, -1, sizeof(::milvus::proto::milvus::ShowPartitionRequest)},
{ 169, -1, sizeof(::milvus::proto::milvus::ShowPartitionResponse)},
{ 177, -1, sizeof(::milvus::proto::milvus::DescribeSegmentRequest)},
{ 185, -1, sizeof(::milvus::proto::milvus::DescribeSegmentResponse)},
{ 192, -1, sizeof(::milvus::proto::milvus::ShowSegmentRequest)},
{ 200, -1, sizeof(::milvus::proto::milvus::ShowSegmentResponse)},
{ 207, -1, sizeof(::milvus::proto::milvus::CreateIndexRequest)},
{ 217, -1, sizeof(::milvus::proto::milvus::DescribeIndexRequest)},
{ 227, -1, sizeof(::milvus::proto::milvus::IndexDescription)},
{ 234, -1, sizeof(::milvus::proto::milvus::DescribeIndexResponse)},
{ 241, -1, sizeof(::milvus::proto::milvus::IndexStateRequest)},
{ 251, -1, sizeof(::milvus::proto::milvus::IndexStateResponse)},
{ 258, -1, sizeof(::milvus::proto::milvus::InsertRequest)},
{ 269, -1, sizeof(::milvus::proto::milvus::InsertResponse)},
{ 277, -1, sizeof(::milvus::proto::milvus::PlaceholderValue)},
{ 285, -1, sizeof(::milvus::proto::milvus::PlaceholderGroup)},
{ 291, -1, sizeof(::milvus::proto::milvus::SearchRequest)},
{ 302, -1, sizeof(::milvus::proto::milvus::Hits)},
{ 310, -1, sizeof(::milvus::proto::milvus::SearchResults)},
{ 317, -1, sizeof(::milvus::proto::milvus::FlushRequest)},
{ 325, -1, sizeof(::milvus::proto::milvus::RegisterLinkResponse)},
};
static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = {
@ -1258,172 +1257,171 @@ const char descriptor_table_protodef_milvus_2eproto[] PROTOBUF_SECTION_VARIABLE(
"e\030\002 \001(\t\"q\n\031DescribeCollectionRequest\022*\n\004"
"base\030\001 \001(\0132\034.milvus.proto.common.MsgBase"
"\022\017\n\007db_name\030\002 \001(\t\022\027\n\017collection_name\030\003 \001"
"(\t\"\226\001\n\032DescribeCollectionResponse\022+\n\006sta"
"(\t\"\200\001\n\032DescribeCollectionResponse\022+\n\006sta"
"tus\030\001 \001(\0132\033.milvus.proto.common.Status\0225"
"\n\006schema\030\002 \001(\0132%.milvus.proto.schema.Col"
"lectionSchema\022\024\n\014collectionID\030\003 \001(\003\"m\n\025L"
"oadCollectionRequest\022*\n\004base\030\001 \001(\0132\034.mil"
"vus.proto.common.MsgBase\022\017\n\007db_name\030\002 \001("
"\t\022\027\n\017collection_name\030\003 \001(\t\"p\n\030ReleaseCol"
"lectionRequest\022*\n\004base\030\001 \001(\0132\034.milvus.pr"
"oto.common.MsgBase\022\017\n\007db_name\030\002 \001(\t\022\027\n\017c"
"ollection_name\030\003 \001(\t\"n\n\026CollectionStatsR"
"equest\022*\n\004base\030\001 \001(\0132\034.milvus.proto.comm"
"on.MsgBase\022\017\n\007db_name\030\002 \001(\t\022\027\n\017collectio"
"n_name\030\003 \001(\t\"x\n\027CollectionStatsResponse\022"
"+\n\006status\030\001 \001(\0132\033.milvus.proto.common.St"
"atus\0220\n\005stats\030\002 \003(\0132!.milvus.proto.commo"
"n.KeyValuePair\"T\n\025ShowCollectionRequest\022"
"*\n\004base\030\001 \001(\0132\034.milvus.proto.common.MsgB"
"ase\022\017\n\007db_name\030\002 \001(\t\"_\n\026ShowCollectionRe"
"sponse\022+\n\006status\030\001 \001(\0132\033.milvus.proto.co"
"mmon.Status\022\030\n\020collection_names\030\002 \003(\t\"\206\001"
"\n\026CreatePartitionRequest\022*\n\004base\030\001 \001(\0132\034"
".milvus.proto.common.MsgBase\022\017\n\007db_name\030"
"\002 \001(\t\022\027\n\017collection_name\030\003 \001(\t\022\026\n\016partit"
"ion_name\030\004 \001(\t\"\204\001\n\024DropPartitionRequest\022"
"*\n\004base\030\001 \001(\0132\034.milvus.proto.common.MsgB"
"ase\022\017\n\007db_name\030\002 \001(\t\022\027\n\017collection_name\030"
"\003 \001(\t\022\026\n\016partition_name\030\004 \001(\t\"\203\001\n\023HasPar"
"titionRequest\022*\n\004base\030\001 \001(\0132\034.milvus.pro"
"to.common.MsgBase\022\017\n\007db_name\030\002 \001(\t\022\027\n\017co"
"llection_name\030\003 \001(\t\022\026\n\016partition_name\030\004 "
"\001(\t\"\204\001\n\023LoadPartitonRequest\022*\n\004base\030\001 \001("
"\0132\034.milvus.proto.common.MsgBase\022\017\n\007db_na"
"me\030\002 \001(\t\022\027\n\017collection_name\030\003 \001(\t\022\027\n\017par"
"tition_names\030\004 \003(\t\"\210\001\n\027ReleasePartitionR"
"equest\022*\n\004base\030\001 \001(\0132\034.milvus.proto.comm"
"on.MsgBase\022\017\n\007db_name\030\002 \001(\t\022\027\n\017collectio"
"n_name\030\003 \001(\t\022\027\n\017partition_names\030\004 \003(\t\"\205\001"
"\n\025PartitionStatsRequest\022*\n\004base\030\001 \001(\0132\034."
"milvus.proto.common.MsgBase\022\017\n\007db_name\030\002"
" \001(\t\022\027\n\017collection_name\030\003 \001(\t\022\026\n\016partiti"
"on_name\030\004 \001(\t\"w\n\026PartitionStatsResponse\022"
"+\n\006status\030\001 \001(\0132\033.milvus.proto.common.St"
"atus\0220\n\005stats\030\002 \003(\0132!.milvus.proto.commo"
"n.KeyValuePair\"\202\001\n\024ShowPartitionRequest\022"
"*\n\004base\030\001 \001(\0132\034.milvus.proto.common.MsgB"
"ase\022\017\n\007db_name\030\002 \001(\t\022\027\n\017collection_name\030"
"\003 \001(\t\022\024\n\014collectionID\030\004 \001(\003\"s\n\025ShowParti"
"tionResponse\022+\n\006status\030\001 \001(\0132\033.milvus.pr"
"oto.common.Status\022\027\n\017partition_names\030\002 \003"
"(\t\022\024\n\014partitionIDs\030\003 \003(\003\"m\n\026DescribeSegm"
"entRequest\022*\n\004base\030\001 \001(\0132\034.milvus.proto."
"common.MsgBase\022\024\n\014collectionID\030\002 \001(\003\022\021\n\t"
"segmentID\030\003 \001(\003\"W\n\027DescribeSegmentRespon"
"se\022+\n\006status\030\001 \001(\0132\033.milvus.proto.common"
".Status\022\017\n\007indexID\030\002 \001(\003\"k\n\022ShowSegmentR"
"equest\022*\n\004base\030\001 \001(\0132\034.milvus.proto.comm"
"on.MsgBase\022\024\n\014collectionID\030\002 \001(\003\022\023\n\013part"
"itionID\030\003 \001(\003\"V\n\023ShowSegmentResponse\022+\n\006"
"status\030\001 \001(\0132\033.milvus.proto.common.Statu"
"s\022\022\n\nsegmentIDs\030\002 \003(\003\"\267\001\n\022CreateIndexReq"
"uest\022*\n\004base\030\001 \001(\0132\034.milvus.proto.common"
".MsgBase\022\017\n\007db_name\030\002 \001(\t\022\027\n\017collection_"
"name\030\003 \001(\t\022\022\n\nfield_name\030\004 \001(\t\0227\n\014extra_"
"params\030\005 \003(\0132!.milvus.proto.common.KeyVa"
"luePair\"\224\001\n\024DescribeIndexRequest\022*\n\004base"
"lectionSchema\"m\n\025LoadCollectionRequest\022*"
"\n\004base\030\001 \001(\0132\034.milvus.proto.common.MsgBa"
"se\022\017\n\007db_name\030\002 \001(\t\022\027\n\017collection_name\030\003"
" \001(\t\"p\n\030ReleaseCollectionRequest\022*\n\004base"
"\030\001 \001(\0132\034.milvus.proto.common.MsgBase\022\017\n\007"
"db_name\030\002 \001(\t\022\027\n\017collection_name\030\003 \001(\t\022\022"
"\n\nfield_name\030\004 \001(\t\022\022\n\nindex_name\030\005 \001(\t\"Y"
"\n\020IndexDescription\022\022\n\nindex_name\030\001 \001(\t\0221"
"\n\006params\030\002 \003(\0132!.milvus.proto.common.Key"
"ValuePair\"\207\001\n\025DescribeIndexResponse\022+\n\006s"
"tatus\030\001 \001(\0132\033.milvus.proto.common.Status"
"\022A\n\022index_descriptions\030\002 \003(\0132%.milvus.pr"
"oto.milvus.IndexDescription\"\221\001\n\021IndexSta"
"teRequest\022*\n\004base\030\001 \001(\0132\034.milvus.proto.c"
"ommon.MsgBase\022\017\n\007db_name\030\002 \001(\t\022\027\n\017collec"
"tion_name\030\003 \001(\t\022\022\n\nfield_name\030\004 \001(\t\022\022\n\ni"
"ndex_name\030\005 \001(\t\"q\n\022IndexStateResponse\022+\n"
"\006status\030\001 \001(\0132\033.milvus.proto.common.Stat"
"us\022.\n\005state\030\002 \001(\0162\037.milvus.proto.common."
"IndexState\"\275\001\n\rInsertRequest\022*\n\004base\030\001 \001"
"(\0132\034.milvus.proto.common.MsgBase\022\017\n\007db_n"
"ame\030\002 \001(\t\022\027\n\017collection_name\030\003 \001(\t\022\026\n\016pa"
"rtition_name\030\004 \001(\t\022+\n\010row_data\030\005 \003(\0132\031.m"
"ilvus.proto.common.Blob\022\021\n\thash_keys\030\006 \003"
"(\r\"e\n\016InsertResponse\022+\n\006status\030\001 \001(\0132\033.m"
"ilvus.proto.common.Status\022\023\n\013rowID_begin"
"\030\002 \001(\003\022\021\n\trowID_end\030\003 \001(\003\"c\n\020Placeholder"
"Value\022\013\n\003tag\030\001 \001(\t\0222\n\004type\030\002 \001(\0162$.milvu"
"s.proto.milvus.PlaceholderType\022\016\n\006values"
"\030\003 \003(\014\"O\n\020PlaceholderGroup\022;\n\014placeholde"
"rs\030\001 \003(\0132%.milvus.proto.milvus.Placehold"
"erValue\"\246\001\n\rSearchRequest\022*\n\004base\030\001 \001(\0132"
"\034.milvus.proto.common.MsgBase\022\017\n\007db_name"
"\030\002 \001(\t\022\027\n\017collection_name\030\003 \001(\t\022\027\n\017parti"
"tion_names\030\004 \003(\t\022\013\n\003dsl\030\005 \001(\t\022\031\n\021placeho"
"lder_group\030\006 \001(\014\"5\n\004Hits\022\013\n\003IDs\030\001 \003(\003\022\020\n"
"\010row_data\030\002 \003(\014\022\016\n\006scores\030\003 \003(\002\"J\n\rSearc"
"hResults\022+\n\006status\030\001 \001(\0132\033.milvus.proto."
"common.Status\022\014\n\004hits\030\002 \003(\014\"d\n\014FlushRequ"
"db_name\030\002 \001(\t\022\027\n\017collection_name\030\003 \001(\t\"n"
"\n\026CollectionStatsRequest\022*\n\004base\030\001 \001(\0132\034"
".milvus.proto.common.MsgBase\022\017\n\007db_name\030"
"\002 \001(\t\022\027\n\017collection_name\030\003 \001(\t\"x\n\027Collec"
"tionStatsResponse\022+\n\006status\030\001 \001(\0132\033.milv"
"us.proto.common.Status\0220\n\005stats\030\002 \003(\0132!."
"milvus.proto.common.KeyValuePair\"T\n\025Show"
"CollectionRequest\022*\n\004base\030\001 \001(\0132\034.milvus"
".proto.common.MsgBase\022\017\n\007db_name\030\002 \001(\t\"_"
"\n\026ShowCollectionResponse\022+\n\006status\030\001 \001(\013"
"2\033.milvus.proto.common.Status\022\030\n\020collect"
"ion_names\030\002 \003(\t\"\206\001\n\026CreatePartitionReque"
"st\022*\n\004base\030\001 \001(\0132\034.milvus.proto.common.M"
"sgBase\022\017\n\007db_name\030\002 \001(\t\022\027\n\017collection_na"
"me\030\003 \001(\t\022\026\n\016partition_name\030\004 \001(\t\"\204\001\n\024Dro"
"pPartitionRequest\022*\n\004base\030\001 \001(\0132\034.milvus"
".proto.common.MsgBase\022\017\n\007db_name\030\002 \001(\t\022\027"
"\n\017collection_name\030\003 \001(\t\022\026\n\016partition_nam"
"e\030\004 \001(\t\"\203\001\n\023HasPartitionRequest\022*\n\004base\030"
"\001 \001(\0132\034.milvus.proto.common.MsgBase\022\017\n\007d"
"b_name\030\002 \001(\t\022\027\n\017collection_name\030\003 \001(\t\022\026\n"
"\016partition_name\030\004 \001(\t\"\204\001\n\023LoadPartitonRe"
"quest\022*\n\004base\030\001 \001(\0132\034.milvus.proto.commo"
"n.MsgBase\022\017\n\007db_name\030\002 \001(\t\022\027\n\017collection"
"_name\030\003 \001(\t\022\027\n\017partition_names\030\004 \003(\t\"\210\001\n"
"\027ReleasePartitionRequest\022*\n\004base\030\001 \001(\0132\034"
".milvus.proto.common.MsgBase\022\017\n\007db_name\030"
"\002 \001(\t\022\027\n\017collection_name\030\003 \001(\t\022\027\n\017partit"
"ion_names\030\004 \003(\t\"\205\001\n\025PartitionStatsReques"
"t\022*\n\004base\030\001 \001(\0132\034.milvus.proto.common.Ms"
"gBase\022\017\n\007db_name\030\002 \001(\t\022\027\n\017collection_nam"
"e\030\003 \001(\t\022\026\n\016partition_name\030\004 \001(\t\"w\n\026Parti"
"tionStatsResponse\022+\n\006status\030\001 \001(\0132\033.milv"
"us.proto.common.Status\0220\n\005stats\030\002 \003(\0132!."
"milvus.proto.common.KeyValuePair\"\202\001\n\024Sho"
"wPartitionRequest\022*\n\004base\030\001 \001(\0132\034.milvus"
".proto.common.MsgBase\022\017\n\007db_name\030\002 \001(\t\022\027"
"\n\017collection_name\030\003 \001(\t\022\024\n\014collectionID\030"
"\004 \001(\003\"s\n\025ShowPartitionResponse\022+\n\006status"
"\030\001 \001(\0132\033.milvus.proto.common.Status\022\027\n\017p"
"artition_names\030\002 \003(\t\022\024\n\014partitionIDs\030\003 \003"
"(\003\"m\n\026DescribeSegmentRequest\022*\n\004base\030\001 \001"
"(\0132\034.milvus.proto.common.MsgBase\022\024\n\014coll"
"ectionID\030\002 \001(\003\022\021\n\tsegmentID\030\003 \001(\003\"W\n\027Des"
"cribeSegmentResponse\022+\n\006status\030\001 \001(\0132\033.m"
"ilvus.proto.common.Status\022\017\n\007indexID\030\002 \001"
"(\003\"k\n\022ShowSegmentRequest\022*\n\004base\030\001 \001(\0132\034"
".milvus.proto.common.MsgBase\022\024\n\014collecti"
"onID\030\002 \001(\003\022\023\n\013partitionID\030\003 \001(\003\"V\n\023ShowS"
"egmentResponse\022+\n\006status\030\001 \001(\0132\033.milvus."
"proto.common.Status\022\022\n\nsegmentIDs\030\002 \003(\003\""
"\267\001\n\022CreateIndexRequest\022*\n\004base\030\001 \001(\0132\034.m"
"ilvus.proto.common.MsgBase\022\017\n\007db_name\030\002 "
"\001(\t\022\027\n\017collection_name\030\003 \001(\t\022\022\n\nfield_na"
"me\030\004 \001(\t\0227\n\014extra_params\030\005 \003(\0132!.milvus."
"proto.common.KeyValuePair\"\224\001\n\024DescribeIn"
"dexRequest\022*\n\004base\030\001 \001(\0132\034.milvus.proto."
"common.MsgBase\022\017\n\007db_name\030\002 \001(\t\022\027\n\017colle"
"ction_name\030\003 \001(\t\022\022\n\nfield_name\030\004 \001(\t\022\022\n\n"
"index_name\030\005 \001(\t\"Y\n\020IndexDescription\022\022\n\n"
"index_name\030\001 \001(\t\0221\n\006params\030\002 \003(\0132!.milvu"
"s.proto.common.KeyValuePair\"\207\001\n\025Describe"
"IndexResponse\022+\n\006status\030\001 \001(\0132\033.milvus.p"
"roto.common.Status\022A\n\022index_descriptions"
"\030\002 \003(\0132%.milvus.proto.milvus.IndexDescri"
"ption\"\221\001\n\021IndexStateRequest\022*\n\004base\030\001 \001("
"\0132\034.milvus.proto.common.MsgBase\022\017\n\007db_na"
"me\030\002 \001(\t\022\027\n\017collection_name\030\003 \001(\t\022\022\n\nfie"
"ld_name\030\004 \001(\t\022\022\n\nindex_name\030\005 \001(\t\"q\n\022Ind"
"exStateResponse\022+\n\006status\030\001 \001(\0132\033.milvus"
".proto.common.Status\022.\n\005state\030\002 \001(\0162\037.mi"
"lvus.proto.common.IndexState\"\275\001\n\rInsertR"
"equest\022*\n\004base\030\001 \001(\0132\034.milvus.proto.comm"
"on.MsgBase\022\017\n\007db_name\030\002 \001(\t\022\027\n\017collectio"
"n_name\030\003 \001(\t\022\026\n\016partition_name\030\004 \001(\t\022+\n\010"
"row_data\030\005 \003(\0132\031.milvus.proto.common.Blo"
"b\022\021\n\thash_keys\030\006 \003(\r\"e\n\016InsertResponse\022+"
"\n\006status\030\001 \001(\0132\033.milvus.proto.common.Sta"
"tus\022\023\n\013rowID_begin\030\002 \001(\003\022\021\n\trowID_end\030\003 "
"\001(\003\"c\n\020PlaceholderValue\022\013\n\003tag\030\001 \001(\t\0222\n\004"
"type\030\002 \001(\0162$.milvus.proto.milvus.Placeho"
"lderType\022\016\n\006values\030\003 \003(\014\"O\n\020PlaceholderG"
"roup\022;\n\014placeholders\030\001 \003(\0132%.milvus.prot"
"o.milvus.PlaceholderValue\"\246\001\n\rSearchRequ"
"est\022*\n\004base\030\001 \001(\0132\034.milvus.proto.common."
"MsgBase\022\017\n\007db_name\030\002 \001(\t\022\027\n\017collection_n"
"ame\030\003 \001(\t\"r\n\024RegisterLinkResponse\022-\n\007add"
"ress\030\001 \001(\0132\034.milvus.proto.common.Address"
"\022+\n\006status\030\002 \001(\0132\033.milvus.proto.common.S"
"tatus*@\n\017PlaceholderType\022\010\n\004NONE\020\000\022\021\n\rVE"
"CTOR_BINARY\020d\022\020\n\014VECTOR_FLOAT\020e2\357\020\n\rMilv"
"usService\022_\n\020CreateCollection\022,.milvus.p"
"roto.milvus.CreateCollectionRequest\032\033.mi"
"lvus.proto.common.Status\"\000\022[\n\016DropCollec"
"tion\022*.milvus.proto.milvus.DropCollectio"
"nRequest\032\033.milvus.proto.common.Status\"\000\022"
"_\n\rHasCollection\022).milvus.proto.milvus.H"
"asCollectionRequest\032!.milvus.proto.milvu"
"s.BoolResponse\"\000\022[\n\016LoadCollection\022*.mil"
"vus.proto.milvus.LoadCollectionRequest\032\033"
".milvus.proto.common.Status\"\000\022a\n\021Release"
"Collection\022-.milvus.proto.milvus.Release"
"CollectionRequest\032\033.milvus.proto.common."
"Status\"\000\022w\n\022DescribeCollection\022..milvus."
"proto.milvus.DescribeCollectionRequest\032/"
".milvus.proto.milvus.DescribeCollectionR"
"esponse\"\000\022v\n\027GetCollectionStatistics\022+.m"
"ilvus.proto.milvus.CollectionStatsReques"
"t\032,.milvus.proto.milvus.CollectionStatsR"
"esponse\"\000\022l\n\017ShowCollections\022*.milvus.pr"
"oto.milvus.ShowCollectionRequest\032+.milvu"
"s.proto.milvus.ShowCollectionResponse\"\000\022"
"]\n\017CreatePartition\022+.milvus.proto.milvus"
".CreatePartitionRequest\032\033.milvus.proto.c"
"ommon.Status\"\000\022Y\n\rDropPartition\022).milvus"
".proto.milvus.DropPartitionRequest\032\033.mil"
"vus.proto.common.Status\"\000\022]\n\014HasPartitio"
"n\022(.milvus.proto.milvus.HasPartitionRequ"
"est\032!.milvus.proto.milvus.BoolResponse\"\000"
"\022Y\n\016LoadPartitions\022(.milvus.proto.milvus"
".LoadPartitonRequest\032\033.milvus.proto.comm"
"on.Status\"\000\022`\n\021ReleasePartitions\022,.milvu"
"s.proto.milvus.ReleasePartitionRequest\032\033"
".milvus.proto.common.Status\"\000\022s\n\026GetPart"
"itionStatistics\022*.milvus.proto.milvus.Pa"
"rtitionStatsRequest\032+.milvus.proto.milvu"
"s.PartitionStatsResponse\"\000\022i\n\016ShowPartit"
"ions\022).milvus.proto.milvus.ShowPartition"
"Request\032*.milvus.proto.milvus.ShowPartit"
"ionResponse\"\000\022U\n\013CreateIndex\022\'.milvus.pr"
"oto.milvus.CreateIndexRequest\032\033.milvus.p"
"roto.common.Status\"\000\022h\n\rDescribeIndex\022)."
"milvus.proto.milvus.DescribeIndexRequest"
"\032*.milvus.proto.milvus.DescribeIndexResp"
"onse\"\000\022b\n\rGetIndexState\022&.milvus.proto.m"
"ilvus.IndexStateRequest\032\'.milvus.proto.m"
"ilvus.IndexStateResponse\"\000\022S\n\006Insert\022\".m"
"ilvus.proto.milvus.InsertRequest\032#.milvu"
"s.proto.milvus.InsertResponse\"\000\022R\n\006Searc"
"h\022\".milvus.proto.milvus.SearchRequest\032\"."
"milvus.proto.milvus.SearchResults\"\000\022I\n\005F"
"lush\022!.milvus.proto.milvus.FlushRequest\032"
"\033.milvus.proto.common.Status\"\000\022Q\n\014GetDdC"
"hannel\022\032.milvus.proto.common.Empty\032#.mil"
"vus.proto.milvus.StringResponse\"\0002g\n\014Pro"
"xyService\022W\n\014RegisterLink\022\032.milvus.proto"
".common.Empty\032).milvus.proto.milvus.Regi"
"sterLinkResponse\"\000BBZ@github.com/zillizt"
"ech/milvus-distributed/internal/proto/mi"
"lvuspbb\006proto3"
"ame\030\003 \001(\t\022\027\n\017partition_names\030\004 \003(\t\022\013\n\003ds"
"l\030\005 \001(\t\022\031\n\021placeholder_group\030\006 \001(\014\"5\n\004Hi"
"ts\022\013\n\003IDs\030\001 \003(\003\022\020\n\010row_data\030\002 \003(\014\022\016\n\006sco"
"res\030\003 \003(\002\"J\n\rSearchResults\022+\n\006status\030\001 \001"
"(\0132\033.milvus.proto.common.Status\022\014\n\004hits\030"
"\002 \003(\014\"d\n\014FlushRequest\022*\n\004base\030\001 \001(\0132\034.mi"
"lvus.proto.common.MsgBase\022\017\n\007db_name\030\002 \001"
"(\t\022\027\n\017collection_name\030\003 \001(\t\"r\n\024RegisterL"
"inkResponse\022-\n\007address\030\001 \001(\0132\034.milvus.pr"
"oto.common.Address\022+\n\006status\030\002 \001(\0132\033.mil"
"vus.proto.common.Status*@\n\017PlaceholderTy"
"pe\022\010\n\004NONE\020\000\022\021\n\rVECTOR_BINARY\020d\022\020\n\014VECTO"
"R_FLOAT\020e2\357\020\n\rMilvusService\022_\n\020CreateCol"
"lection\022,.milvus.proto.milvus.CreateColl"
"ectionRequest\032\033.milvus.proto.common.Stat"
"us\"\000\022[\n\016DropCollection\022*.milvus.proto.mi"
"lvus.DropCollectionRequest\032\033.milvus.prot"
"o.common.Status\"\000\022_\n\rHasCollection\022).mil"
"vus.proto.milvus.HasCollectionRequest\032!."
"milvus.proto.milvus.BoolResponse\"\000\022[\n\016Lo"
"adCollection\022*.milvus.proto.milvus.LoadC"
"ollectionRequest\032\033.milvus.proto.common.S"
"tatus\"\000\022a\n\021ReleaseCollection\022-.milvus.pr"
"oto.milvus.ReleaseCollectionRequest\032\033.mi"
"lvus.proto.common.Status\"\000\022w\n\022DescribeCo"
"llection\022..milvus.proto.milvus.DescribeC"
"ollectionRequest\032/.milvus.proto.milvus.D"
"escribeCollectionResponse\"\000\022v\n\027GetCollec"
"tionStatistics\022+.milvus.proto.milvus.Col"
"lectionStatsRequest\032,.milvus.proto.milvu"
"s.CollectionStatsResponse\"\000\022l\n\017ShowColle"
"ctions\022*.milvus.proto.milvus.ShowCollect"
"ionRequest\032+.milvus.proto.milvus.ShowCol"
"lectionResponse\"\000\022]\n\017CreatePartition\022+.m"
"ilvus.proto.milvus.CreatePartitionReques"
"t\032\033.milvus.proto.common.Status\"\000\022Y\n\rDrop"
"Partition\022).milvus.proto.milvus.DropPart"
"itionRequest\032\033.milvus.proto.common.Statu"
"s\"\000\022]\n\014HasPartition\022(.milvus.proto.milvu"
"s.HasPartitionRequest\032!.milvus.proto.mil"
"vus.BoolResponse\"\000\022Y\n\016LoadPartitions\022(.m"
"ilvus.proto.milvus.LoadPartitonRequest\032\033"
".milvus.proto.common.Status\"\000\022`\n\021Release"
"Partitions\022,.milvus.proto.milvus.Release"
"PartitionRequest\032\033.milvus.proto.common.S"
"tatus\"\000\022s\n\026GetPartitionStatistics\022*.milv"
"us.proto.milvus.PartitionStatsRequest\032+."
"milvus.proto.milvus.PartitionStatsRespon"
"se\"\000\022i\n\016ShowPartitions\022).milvus.proto.mi"
"lvus.ShowPartitionRequest\032*.milvus.proto"
".milvus.ShowPartitionResponse\"\000\022U\n\013Creat"
"eIndex\022\'.milvus.proto.milvus.CreateIndex"
"Request\032\033.milvus.proto.common.Status\"\000\022h"
"\n\rDescribeIndex\022).milvus.proto.milvus.De"
"scribeIndexRequest\032*.milvus.proto.milvus"
".DescribeIndexResponse\"\000\022b\n\rGetIndexStat"
"e\022&.milvus.proto.milvus.IndexStateReques"
"t\032\'.milvus.proto.milvus.IndexStateRespon"
"se\"\000\022S\n\006Insert\022\".milvus.proto.milvus.Ins"
"ertRequest\032#.milvus.proto.milvus.InsertR"
"esponse\"\000\022R\n\006Search\022\".milvus.proto.milvu"
"s.SearchRequest\032\".milvus.proto.milvus.Se"
"archResults\"\000\022I\n\005Flush\022!.milvus.proto.mi"
"lvus.FlushRequest\032\033.milvus.proto.common."
"Status\"\000\022Q\n\014GetDdChannel\022\032.milvus.proto."
"common.Empty\032#.milvus.proto.milvus.Strin"
"gResponse\"\0002g\n\014ProxyService\022W\n\014RegisterL"
"ink\022\032.milvus.proto.common.Empty\032).milvus"
".proto.milvus.RegisterLinkResponse\"\000BBZ@"
"github.com/zilliztech/milvus-distributed"
"/internal/proto/milvuspbb\006proto3"
;
static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_milvus_2eproto_deps[2] = {
&::descriptor_table_common_2eproto,
@ -1475,7 +1473,7 @@ static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_mil
static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_milvus_2eproto_once;
static bool descriptor_table_milvus_2eproto_initialized = false;
const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_milvus_2eproto = {
&descriptor_table_milvus_2eproto_initialized, descriptor_table_protodef_milvus_2eproto, "milvus.proto", 7294,
&descriptor_table_milvus_2eproto_initialized, descriptor_table_protodef_milvus_2eproto, "milvus.proto", 7272,
&descriptor_table_milvus_2eproto_once, descriptor_table_milvus_2eproto_sccs, descriptor_table_milvus_2eproto_deps, 41, 2,
schemas, file_default_instances, TableStruct_milvus_2eproto::offsets,
file_level_metadata_milvus_2eproto, 41, file_level_enum_descriptors_milvus_2eproto, file_level_service_descriptors_milvus_2eproto,
@ -3848,15 +3846,14 @@ DescribeCollectionResponse::DescribeCollectionResponse(const DescribeCollectionR
} else {
schema_ = nullptr;
}
collectionid_ = from.collectionid_;
// @@protoc_insertion_point(copy_constructor:milvus.proto.milvus.DescribeCollectionResponse)
}
void DescribeCollectionResponse::SharedCtor() {
::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_DescribeCollectionResponse_milvus_2eproto.base);
::memset(&status_, 0, static_cast<size_t>(
reinterpret_cast<char*>(&collectionid_) -
reinterpret_cast<char*>(&status_)) + sizeof(collectionid_));
reinterpret_cast<char*>(&schema_) -
reinterpret_cast<char*>(&status_)) + sizeof(schema_));
}
DescribeCollectionResponse::~DescribeCollectionResponse() {
@ -3892,7 +3889,6 @@ void DescribeCollectionResponse::Clear() {
delete schema_;
}
schema_ = nullptr;
collectionid_ = PROTOBUF_LONGLONG(0);
_internal_metadata_.Clear();
}
@ -3918,13 +3914,6 @@ const char* DescribeCollectionResponse::_InternalParse(const char* ptr, ::PROTOB
CHK_(ptr);
} else goto handle_unusual;
continue;
// int64 collectionID = 3;
case 3:
if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
collectionid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
CHK_(ptr);
} else goto handle_unusual;
continue;
default: {
handle_unusual:
if ((tag & 7) == 4 || tag == 0) {
@ -3977,19 +3966,6 @@ bool DescribeCollectionResponse::MergePartialFromCodedStream(
break;
}
// int64 collectionID = 3;
case 3: {
if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) {
DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>(
input, &collectionid_)));
} else {
goto handle_unusual;
}
break;
}
default: {
handle_unusual:
if (tag == 0) {
@ -4029,11 +4005,6 @@ void DescribeCollectionResponse::SerializeWithCachedSizes(
2, _Internal::schema(this), output);
}
// int64 collectionID = 3;
if (this->collectionid() != 0) {
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(3, this->collectionid(), output);
}
if (_internal_metadata_.have_unknown_fields()) {
::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
_internal_metadata_.unknown_fields(), output);
@ -4061,11 +4032,6 @@ void DescribeCollectionResponse::SerializeWithCachedSizes(
2, _Internal::schema(this), target);
}
// int64 collectionID = 3;
if (this->collectionid() != 0) {
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(3, this->collectionid(), target);
}
if (_internal_metadata_.have_unknown_fields()) {
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
_internal_metadata_.unknown_fields(), target);
@ -4101,13 +4067,6 @@ size_t DescribeCollectionResponse::ByteSizeLong() const {
*schema_);
}
// int64 collectionID = 3;
if (this->collectionid() != 0) {
total_size += 1 +
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
this->collectionid());
}
int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
SetCachedSize(cached_size);
return total_size;
@ -4141,9 +4100,6 @@ void DescribeCollectionResponse::MergeFrom(const DescribeCollectionResponse& fro
if (from.has_schema()) {
mutable_schema()->::milvus::proto::schema::CollectionSchema::MergeFrom(from.schema());
}
if (from.collectionid() != 0) {
set_collectionid(from.collectionid());
}
}
void DescribeCollectionResponse::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
@ -4169,7 +4125,6 @@ void DescribeCollectionResponse::InternalSwap(DescribeCollectionResponse* other)
_internal_metadata_.Swap(&other->_internal_metadata_);
swap(status_, other->status_);
swap(schema_, other->schema_);
swap(collectionid_, other->collectionid_);
}
::PROTOBUF_NAMESPACE_ID::Metadata DescribeCollectionResponse::GetMetadata() const {

21
internal/core/src/pb/milvus.pb.h
View File

@ -1317,7 +1317,6 @@ class DescribeCollectionResponse :
enum : int {
kStatusFieldNumber = 1,
kSchemaFieldNumber = 2,
kCollectionIDFieldNumber = 3,
};
// .milvus.proto.common.Status status = 1;
bool has_status() const;
@ -1335,11 +1334,6 @@ class DescribeCollectionResponse :
::milvus::proto::schema::CollectionSchema* mutable_schema();
void set_allocated_schema(::milvus::proto::schema::CollectionSchema* schema);
// int64 collectionID = 3;
void clear_collectionid();
::PROTOBUF_NAMESPACE_ID::int64 collectionid() const;
void set_collectionid(::PROTOBUF_NAMESPACE_ID::int64 value);
// @@protoc_insertion_point(class_scope:milvus.proto.milvus.DescribeCollectionResponse)
private:
class _Internal;
@ -1347,7 +1341,6 @@ class DescribeCollectionResponse :
::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
::milvus::proto::common::Status* status_;
::milvus::proto::schema::CollectionSchema* schema_;
::PROTOBUF_NAMESPACE_ID::int64 collectionid_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
friend struct ::TableStruct_milvus_2eproto;
};
@ -7790,20 +7783,6 @@ inline void DescribeCollectionResponse::set_allocated_schema(::milvus::proto::sc
// @@protoc_insertion_point(field_set_allocated:milvus.proto.milvus.DescribeCollectionResponse.schema)
}
// int64 collectionID = 3;
inline void DescribeCollectionResponse::clear_collectionid() {
collectionid_ = PROTOBUF_LONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::int64 DescribeCollectionResponse::collectionid() const {
// @@protoc_insertion_point(field_get:milvus.proto.milvus.DescribeCollectionResponse.collectionID)
return collectionid_;
}
inline void DescribeCollectionResponse::set_collectionid(::PROTOBUF_NAMESPACE_ID::int64 value) {
collectionid_ = value;
// @@protoc_insertion_point(field_set:milvus.proto.milvus.DescribeCollectionResponse.collectionID)
}
// -------------------------------------------------------------------
// LoadCollectionRequest

52
internal/distributed/masterservice/masterservice_test.go
View File

@ -51,7 +51,6 @@ func TestGrpcService(t *testing.T) {
assert.Nil(t, err)
core.ProxyTimeTickChan = make(chan typeutil.Timestamp, 8)
core.DataNodeSegmentFlushCompletedChan = make(chan typeutil.UniqueID, 8)
timeTickArray := make([]typeutil.Timestamp, 0, 16)
core.SendTimeTick = func(ts typeutil.Timestamp) error {
@ -200,8 +199,6 @@ func TestGrpcService(t *testing.T) {
})
t.Run("describe collection", func(t *testing.T) {
collMeta, err := core.MetaTable.GetCollectionByName("testColl")
assert.Nil(t, err)
req := &milvuspb.DescribeCollectionRequest{
Base: &commonpb.MsgBase{
MsgType: commonpb.MsgType_kDescribeCollection,
@ -216,7 +213,6 @@ func TestGrpcService(t *testing.T) {
assert.Nil(t, err)
assert.Equal(t, rsp.Status.ErrorCode, commonpb.ErrorCode_SUCCESS)
assert.Equal(t, rsp.Schema.Name, "testColl")
assert.Equal(t, rsp.CollectionID, collMeta.ID)
})
t.Run("show collection", func(t *testing.T) {
@ -279,8 +275,6 @@ func TestGrpcService(t *testing.T) {
})
t.Run("show partition", func(t *testing.T) {
coll, err := core.MetaTable.GetCollectionByName("testColl")
assert.Nil(t, err)
req := &milvuspb.ShowPartitionRequest{
Base: &commonpb.MsgBase{
MsgType: commonpb.MsgType_kShowPartitions,
@ -290,7 +284,6 @@ func TestGrpcService(t *testing.T) {
},
DbName: "testDb",
CollectionName: "testColl",
CollectionID: coll.ID,
}
rsp, err := cli.ShowPartitions(req)
assert.Nil(t, err)
@ -319,7 +312,7 @@ func TestGrpcService(t *testing.T) {
req := &milvuspb.ShowSegmentRequest{
Base: &commonpb.MsgBase{
MsgType: commonpb.MsgType_kShowSegment,
MsgType: 111, //TODO show segment request msg type
MsgID: 111,
Timestamp: 111,
SourceID: 111,
@ -365,7 +358,7 @@ func TestGrpcService(t *testing.T) {
req := &milvuspb.DescribeSegmentRequest{
Base: &commonpb.MsgBase{
MsgType: commonpb.MsgType_kDescribeSegment,
MsgType: 113, //TODO, describe segment request msg type
MsgID: 113,
Timestamp: 113,
SourceID: 113,
@ -399,47 +392,6 @@ func TestGrpcService(t *testing.T) {
assert.Equal(t, rsp.IndexDescriptions[0].IndexName, cms.Params.DefaultIndexName)
})
t.Run("flush segment", func(t *testing.T) {
coll, err := core.MetaTable.GetCollectionByName("testColl")
assert.Nil(t, err)
partID := coll.PartitionIDs[1]
part, err := core.MetaTable.GetPartitionByID(partID)
assert.Nil(t, err)
assert.Equal(t, len(part.SegmentIDs), 1)
seg := &datapb.SegmentInfo{
SegmentID: 1001,
CollectionID: coll.ID,
PartitionID: part.PartitionID,
}
core.DataServiceSegmentChan <- seg
time.Sleep(time.Millisecond * 100)
part, err = core.MetaTable.GetPartitionByID(partID)
assert.Nil(t, err)
assert.Equal(t, len(part.SegmentIDs), 2)
core.DataNodeSegmentFlushCompletedChan <- 1001
time.Sleep(time.Millisecond * 100)
req := &milvuspb.DescribeIndexRequest{
Base: &commonpb.MsgBase{
MsgType: commonpb.MsgType_kDescribeIndex,
MsgID: 115,
Timestamp: 115,
SourceID: 115,
},
DbName: "",
CollectionName: "testColl",
FieldName: "vector",
IndexName: "",
}
rsp, err := cli.DescribeIndex(req)
assert.Nil(t, err)
assert.Equal(t, rsp.Status.ErrorCode, commonpb.ErrorCode_SUCCESS)
assert.Equal(t, len(rsp.IndexDescriptions), 2)
assert.Equal(t, rsp.IndexDescriptions[0].IndexName, cms.Params.DefaultIndexName)
assert.Equal(t, rsp.IndexDescriptions[1].IndexName, "index_100")
})
t.Run("drop partition", func(t *testing.T) {
req := &milvuspb.DropPartitionRequest{
Base: &commonpb.MsgBase{

26
internal/distributed/querynode/client.go → internal/distributed/querynode/client/client.go
View File

@ -1,7 +1,11 @@
package querynode
package grpcquerynodeclient
import (
"context"
"log"
"time"
"google.golang.org/grpc"
"github.com/zilliztech/milvus-distributed/internal/proto/commonpb"
"github.com/zilliztech/milvus-distributed/internal/proto/internalpb2"
@ -18,7 +22,7 @@ func (c *Client) GetComponentStates() (*internalpb2.ComponentStates, error) {
if err != nil {
return nil, err
}
return states.ServerStates, nil
return states.States, nil
}
func (c *Client) GetTimeTickChannel() (string, error) {
@ -26,7 +30,7 @@ func (c *Client) GetTimeTickChannel() (string, error) {
if err != nil {
return "", err
}
return response.TimeTickChannelID, nil
return response.Value, nil
}
func (c *Client) GetStatisticsChannel() (string, error) {
@ -34,7 +38,7 @@ func (c *Client) GetStatisticsChannel() (string, error) {
if err != nil {
return "", err
}
return response.StatsChannelID, nil
return response.Value, nil
}
func (c *Client) AddQueryChannel(in *querypb.AddQueryChannelsRequest) (*commonpb.Status, error) {
@ -56,3 +60,17 @@ func (c *Client) LoadSegments(in *querypb.LoadSegmentRequest) (*commonpb.Status,
func (c *Client) ReleaseSegments(in *querypb.ReleaseSegmentRequest) (*commonpb.Status, error) {
return c.grpcClient.ReleaseSegments(context.TODO(), in)
}
func NewClient(address string) *Client {
ctx1, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
conn, err := grpc.DialContext(ctx1, address, grpc.WithInsecure(), grpc.WithBlock())
if err != nil {
log.Printf("connect to queryNode failed, error= %v", err)
}
log.Printf("connected to queryNode, queryNode=%s", address)
return &Client{
grpcClient: querypb.NewQueryNodeClient(conn),
}
}

21
internal/distributed/querynode/service.go
View File

@ -1,4 +1,4 @@
package querynode
package grpcquerynode
import (
"context"
@ -7,6 +7,7 @@ import (
"google.golang.org/grpc"
"github.com/zilliztech/milvus-distributed/internal/proto/commonpb"
"github.com/zilliztech/milvus-distributed/internal/proto/milvuspb"
"github.com/zilliztech/milvus-distributed/internal/proto/querypb"
"github.com/zilliztech/milvus-distributed/internal/querynode"
)
@ -49,45 +50,45 @@ func (s *Server) Stop() error {
return s.Stop()
}
func (s *Server) GetTimeTickChannel(ctx context.Context, in *commonpb.Empty) (*querypb.GetTimeTickChannelResponse, error) {
func (s *Server) GetTimeTickChannel(ctx context.Context, in *commonpb.Empty) (*milvuspb.StringResponse, error) {
// ignore ctx and in
channel, err := s.node.GetTimeTickChannel()
if err != nil {
return nil, err
}
return &querypb.GetTimeTickChannelResponse{
return &milvuspb.StringResponse{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_SUCCESS,
},
TimeTickChannelID: channel,
Value: channel,
}, nil
}
func (s *Server) GetStatsChannel(ctx context.Context, in *commonpb.Empty) (*querypb.GetStatsChannelResponse, error) {
func (s *Server) GetStatsChannel(ctx context.Context, in *commonpb.Empty) (*milvuspb.StringResponse, error) {
// ignore ctx and in
channel, err := s.node.GetStatisticsChannel()
if err != nil {
return nil, err
}
return &querypb.GetStatsChannelResponse{
return &milvuspb.StringResponse{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_SUCCESS,
},
StatsChannelID: channel,
Value: channel,
}, nil
}
func (s *Server) GetComponentStates(ctx context.Context, in *commonpb.Empty) (*querypb.ServiceStatesResponse, error) {
func (s *Server) GetComponentStates(ctx context.Context, in *commonpb.Empty) (*querypb.ComponentStatesResponse, error) {
// ignore ctx and in
componentStates, err := s.node.GetComponentStates()
if err != nil {
return nil, err
}
return &querypb.ServiceStatesResponse{
return &querypb.ComponentStatesResponse{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_SUCCESS,
},
ServerStates: componentStates,
States: componentStates,
}, nil
}

70
internal/distributed/queryservice/client.go
View File

@ -1,70 +0,0 @@
package queryservice
import (
"github.com/zilliztech/milvus-distributed/internal/proto/internalpb2"
"github.com/zilliztech/milvus-distributed/internal/proto/querypb"
)
type Client struct {
grpcClient querypb.QueryServiceClient
}
func (c *Client) Init() error {
panic("implement me")
}
func (c *Client) Start() error {
panic("implement me")
}
func (c *Client) Stop() error {
panic("implement me")
}
func (c *Client) GetComponentStates() (*internalpb2.ComponentStates, error) {
panic("implement me")
}
func (c *Client) GetTimeTickChannel() (string, error) {
panic("implement me")
}
func (c *Client) GetStatisticsChannel() (string, error) {
panic("implement me")
}
func (c *Client) RegisterNode(req querypb.RegisterNodeRequest) (querypb.RegisterNodeResponse, error) {
panic("implement me")
}
func (c *Client) ShowCollections(req querypb.ShowCollectionRequest) (querypb.ShowCollectionResponse, error) {
panic("implement me")
}
func (c *Client) LoadCollection(req querypb.LoadCollectionRequest) error {
panic("implement me")
}
func (c *Client) ReleaseCollection(req querypb.ReleaseCollectionRequest) error {
panic("implement me")
}
func (c *Client) ShowPartitions(req querypb.ShowPartitionRequest) (querypb.ShowPartitionResponse, error) {
panic("implement me")
}
func (c *Client) LoadPartitions(req querypb.LoadPartitionRequest) error {
panic("implement me")
}
func (c *Client) ReleasePartitions(req querypb.ReleasePartitionRequest) error {
panic("implement me")
}
func (c *Client) CreateQueryChannel() (querypb.CreateQueryChannelResponse, error) {
panic("implement me")
}
func (c *Client) GetPartitionStates(req querypb.PartitionStatesRequest) (querypb.PartitionStatesResponse, error) {
panic("implement me")
}

91
internal/distributed/queryservice/client/client.go Normal file
View File

@ -0,0 +1,91 @@
package grpcqueryserviceclient
import (
"context"
"log"
"time"
"google.golang.org/grpc"
"github.com/zilliztech/milvus-distributed/internal/proto/commonpb"
"github.com/zilliztech/milvus-distributed/internal/proto/internalpb2"
"github.com/zilliztech/milvus-distributed/internal/proto/querypb"
)
type Client struct {
grpcClient querypb.QueryServiceClient
}
func (c *Client) Init() error {
panic("implement me")
}
func (c *Client) Start() error {
panic("implement me")
}
func (c *Client) Stop() error {
panic("implement me")
}
func (c *Client) GetComponentStates() (*internalpb2.ComponentStates, error) {
panic("implement me")
}
func (c *Client) GetTimeTickChannel() (string, error) {
panic("implement me")
}
func (c *Client) GetStatisticsChannel() (string, error) {
panic("implement me")
}
func (c *Client) RegisterNode(req *querypb.RegisterNodeRequest) (*querypb.RegisterNodeResponse, error) {
return c.grpcClient.RegisterNode(context.TODO(), req)
}
func (c *Client) ShowCollections(req *querypb.ShowCollectionRequest) (*querypb.ShowCollectionResponse, error) {
return c.grpcClient.ShowCollections(context.TODO(), req)
}
func (c *Client) LoadCollection(req *querypb.LoadCollectionRequest) (*commonpb.Status, error) {
return c.grpcClient.LoadCollection(context.TODO(), req)
}
func (c *Client) ReleaseCollection(req *querypb.ReleaseCollectionRequest) (*commonpb.Status, error) {
return c.grpcClient.ReleaseCollection(context.TODO(), req)
}
func (c *Client) ShowPartitions(req *querypb.ShowPartitionRequest) (*querypb.ShowPartitionResponse, error) {
return c.grpcClient.ShowPartitions(context.TODO(), req)
}
func (c *Client) LoadPartitions(req *querypb.LoadPartitionRequest) (*commonpb.Status, error) {
return c.grpcClient.LoadPartitions(context.TODO(), req)
}
func (c *Client) ReleasePartitions(req *querypb.ReleasePartitionRequest) (*commonpb.Status, error) {
return c.grpcClient.ReleasePartitions(context.TODO(), req)
}
func (c *Client) CreateQueryChannel() (*querypb.CreateQueryChannelResponse, error) {
return c.grpcClient.CreateQueryChannel(context.TODO(), &commonpb.Empty{})
}
func (c *Client) GetPartitionStates(req *querypb.PartitionStatesRequest) (*querypb.PartitionStatesResponse, error) {
return c.grpcClient.GetPartitionStates(context.TODO(), req)
}
func NewClient(address string) *Client {
ctx1, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
conn, err := grpc.DialContext(ctx1, address, grpc.WithInsecure(), grpc.WithBlock())
if err != nil {
log.Printf("connect to queryService failed, error= %v", err)
}
log.Printf("connected to queryService, queryService=%s", address)
return &Client{
grpcClient: querypb.NewQueryServiceClient(conn),
}
}

178
internal/distributed/queryservice/service.go
View File

@ -1,74 +1,190 @@
package queryservice
package grpcqueryservice
import (
"context"
"log"
"net"
"strconv"
"sync"
"google.golang.org/grpc"
"github.com/zilliztech/milvus-distributed/internal/proto/internalpb2"
"github.com/zilliztech/milvus-distributed/internal/errors"
"github.com/zilliztech/milvus-distributed/internal/proto/commonpb"
"github.com/zilliztech/milvus-distributed/internal/proto/milvuspb"
"github.com/zilliztech/milvus-distributed/internal/proto/querypb"
queryServiceImpl "github.com/zilliztech/milvus-distributed/internal/queryservice"
"github.com/zilliztech/milvus-distributed/internal/queryservice"
)
type QueryService = queryservice.QueryService
type Server struct {
grpcServer *grpc.Server
queryService queryServiceImpl.Interface
queryService *QueryService
loopCtx context.Context
loopCancel func()
loopWg sync.WaitGroup
}
func (s *Server) Init() error {
panic("implement me")
log.Println()
initParams := queryservice.InitParams{
Distributed: true,
}
s.InitParams(&initParams)
s.queryService.Init()
return nil
}
func (s *Server) InitParams(params *queryservice.InitParams) {
s.queryService.InitParams(params)
}
func (s *Server) Start() error {
panic("implement me")
s.Init()
log.Println("start query service ...")
s.loopWg.Add(1)
go s.grpcLoop()
s.queryService.Start()
return nil
}
func (s *Server) Stop() error {
panic("implement me")
s.queryService.Stop()
s.loopCancel()
if s.grpcServer != nil {
s.grpcServer.GracefulStop()
}
s.loopWg.Wait()
return nil
}
func (s *Server) GetComponentStates() (*internalpb2.ComponentStates, error) {
panic("implement me")
func (s *Server) GetComponentStates(ctx context.Context, req *commonpb.Empty) (*querypb.ComponentStatesResponse, error) {
componentStates, err := s.queryService.GetComponentStates()
if err != nil {
return &querypb.ComponentStatesResponse{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UNEXPECTED_ERROR,
Reason: err.Error(),
},
}, err
}
return &querypb.ComponentStatesResponse{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_SUCCESS,
Reason: "",
},
States: componentStates,
}, nil
}
func (s *Server) GetTimeTickChannel() (string, error) {
panic("implement me")
func (s *Server) GetTimeTickChannel(ctx context.Context, req *commonpb.Empty) (*milvuspb.StringResponse, error) {
channel, err := s.queryService.GetTimeTickChannel()
if err != nil {
return &milvuspb.StringResponse{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UNEXPECTED_ERROR,
Reason: err.Error(),
},
}, err
}
return &milvuspb.StringResponse{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_SUCCESS,
Reason: "",
},
Value: channel,
}, nil
}
func (s *Server) GetStatisticsChannel() (string, error) {
panic("implement me")
func (s *Server) GetStatisticsChannel(ctx context.Context, req *commonpb.Empty) (*milvuspb.StringResponse, error) {
statisticsChannel, err := s.queryService.GetStatisticsChannel()
if err != nil {
return &milvuspb.StringResponse{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UNEXPECTED_ERROR,
Reason: err.Error(),
},
}, err
}
return &milvuspb.StringResponse{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_SUCCESS,
Reason: "",
},
Value: statisticsChannel,
}, nil
}
func (s *Server) RegisterNode(req querypb.RegisterNodeRequest) (querypb.RegisterNodeResponse, error) {
panic("implement me")
func (s *Server) RegisterNode(ctx context.Context, req *querypb.RegisterNodeRequest) (*querypb.RegisterNodeResponse, error) {
return s.queryService.RegisterNode(req)
}
func (s *Server) ShowCollections(req querypb.ShowCollectionRequest) (querypb.ShowCollectionResponse, error) {
panic("implement me")
func (s *Server) ShowCollections(ctx context.Context, req *querypb.ShowCollectionRequest) (*querypb.ShowCollectionResponse, error) {
return s.queryService.ShowCollections(req)
}
func (s *Server) LoadCollection(req querypb.LoadCollectionRequest) error {
panic("implement me")
func (s *Server) LoadCollection(ctx context.Context, req *querypb.LoadCollectionRequest) (*commonpb.Status, error) {
return s.queryService.LoadCollection(req)
}
func (s *Server) ReleaseCollection(req querypb.ReleaseCollectionRequest) error {
panic("implement me")
func (s *Server) ReleaseCollection(ctx context.Context, req *querypb.ReleaseCollectionRequest) (*commonpb.Status, error) {
return s.queryService.ReleaseCollection(req)
}
func (s *Server) ShowPartitions(req querypb.ShowPartitionRequest) (querypb.ShowPartitionResponse, error) {
panic("implement me")
func (s *Server) ShowPartitions(ctx context.Context, req *querypb.ShowPartitionRequest) (*querypb.ShowPartitionResponse, error) {
return s.queryService.ShowPartitions(req)
}
func (s *Server) GetPartitionStates(req querypb.PartitionStatesRequest) (querypb.PartitionStatesResponse, error) {
panic("implement me")
func (s *Server) GetPartitionStates(ctx context.Context, req *querypb.PartitionStatesRequest) (*querypb.PartitionStatesResponse, error) {
return s.queryService.GetPartitionStates(req)
}
func (s *Server) LoadPartitions(req querypb.LoadPartitionRequest) error {
panic("implement me")
func (s *Server) LoadPartitions(ctx context.Context, req *querypb.LoadPartitionRequest) (*commonpb.Status, error) {
return s.queryService.LoadPartitions(req)
}
func (s *Server) ReleasePartitions(req querypb.ReleasePartitionRequest) error {
panic("implement me")
func (s *Server) ReleasePartitions(ctx context.Context, req *querypb.ReleasePartitionRequest) (*commonpb.Status, error) {
return s.queryService.ReleasePartitions(req)
}
func (s *Server) CreateQueryChannel() (querypb.CreateQueryChannelResponse, error) {
panic("implement me")
func (s *Server) CreateQueryChannel(ctx context.Context, req *commonpb.Empty) (*querypb.CreateQueryChannelResponse, error) {
return s.queryService.CreateQueryChannel()
}
func (s *Server) NewServer(ctx context.Context) *Server {
ctx1, cancel := context.WithCancel(ctx)
serviceInterface, err := queryservice.NewQueryService(ctx)
if err != nil {
log.Fatal(errors.New("create QueryService failed"))
}
return &Server{
queryService: serviceInterface.(*QueryService),
loopCtx: ctx1,
loopCancel: cancel,
}
}
func (s *Server) grpcLoop() {
defer s.loopWg.Done()
log.Println("Starting start query service Server")
lis, err := net.Listen("tcp", ":"+strconv.Itoa(queryservice.Params.Port))
if err != nil {
log.Fatalf("query service grpc server fatal error=%v", err)
}
s.grpcServer = grpc.NewServer()
querypb.RegisterQueryServiceServer(s.grpcServer, s)
log.Println("queryService's server register finished")
if err = s.grpcServer.Serve(lis); err != nil {
log.Fatalf("queryService grpc server fatal error=%v", err)
}
log.Println("query service grpc server starting...")
}

38
internal/masterservice/master_service.go
View File

@ -4,7 +4,6 @@ import (
"context"
"log"
"math/rand"
"strconv"
"sync"
"sync/atomic"
"time"
@ -139,9 +138,6 @@ type Core struct {
//setMsgStreams segment channel, receive segment info from data service, if master create segment
DataServiceSegmentChan chan *datapb.SegmentInfo
//setMsgStreams ,if segment flush completed, data node would put segment id into msg stream
DataNodeSegmentFlushCompletedChan chan typeutil.UniqueID
//TODO,get binlog file path from data service,
GetBinlogFilePathsFromDataServiceReq func(segID typeutil.UniqueID, fieldID typeutil.UniqueID) ([]string, error)
@ -231,9 +227,6 @@ func (c *Core) checkInit() error {
if c.indexTaskQueue == nil {
return errors.Errorf("indexTaskQueue is nil")
}
if c.DataNodeSegmentFlushCompletedChan == nil {
return errors.Errorf("DataNodeSegmentFlushCompletedChan is nil")
}
log.Printf("master node id = %d\n", Params.NodeID)
return nil
}
@ -318,7 +311,7 @@ func (c *Core) startCreateIndexLoop() {
return
case t, ok := <-c.indexTaskQueue:
if !ok {
log.Printf("index task chan has closed, exit loop")
log.Printf("index task chan is close, exit loop")
return
}
if err := t.BuildIndex(); err != nil {
@ -328,34 +321,6 @@ func (c *Core) startCreateIndexLoop() {
}
}
func (c *Core) startSegmentFlushCompletedLoop() {
for {
select {
case <-c.ctx.Done():
log.Printf("close segment flush completed loop")
return
case seg, ok := <-c.DataNodeSegmentFlushCompletedChan:
if !ok {
log.Printf("data node segment flush completed chan has colsed, exit loop")
}
fields, err := c.MetaTable.GetSegmentVectorFields(seg)
if err != nil {
log.Printf("GetSegmentVectorFields, error = %s ", err.Error())
}
for _, f := range fields {
t := &CreateIndexTask{
core: c,
segmentID: seg,
indexName: "index_" + strconv.FormatInt(f.FieldID, 10),
fieldSchema: f,
indexParams: nil,
}
c.indexTaskQueue <- t
}
}
}
}
func (c *Core) setMsgStreams() error {
//proxy time tick stream,
proxyTimeTickStream := pulsarms.NewPulsarMsgStream(c.ctx, 1024)
@ -577,7 +542,6 @@ func (c *Core) Start() error {
go c.startTimeTickLoop()
go c.startDataServiceSegmentLoop()
go c.startCreateIndexLoop()
go c.startSegmentFlushCompletedLoop()
c.stateCode.Store(internalpb2.StateCode_HEALTHY)
})
return nil

27
internal/masterservice/meta_table.go
View File

@ -182,10 +182,6 @@ func (mt *metaTable) AddCollection(coll *pb.CollectionInfo, part *pb.PartitionIn
if len(coll.PartitionIDs) != 0 {
return errors.Errorf("partitions should be empty when creating collection")
}
if _, ok := mt.collName2ID[coll.Schema.Name]; ok {
return errors.Errorf("collection %s exist", coll.Schema.Name)
}
coll.PartitionIDs = append(coll.PartitionIDs, part.PartitionID)
mt.collID2Meta[coll.ID] = *coll
mt.collName2ID[coll.Schema.Name] = coll.ID
@ -409,7 +405,7 @@ func (mt *metaTable) DeletePartition(collID typeutil.UniqueID, partitionName str
for _, segID := range partMeta.SegmentIDs {
segIndexMeta, ok := mt.segID2IndexMeta[segID]
if !ok {
log.Printf("segment id = %d has no index meta", segID)
log.Printf("segment id = %d not exist", segID)
continue
}
delete(mt.segID2IndexMeta, segID)
@ -634,27 +630,6 @@ func (mt *metaTable) GetNotIndexedSegments(collName string, fieldName string, in
return rstID, fieldSchema, nil
}
func (mt *metaTable) GetSegmentVectorFields(segID typeutil.UniqueID) ([]*schemapb.FieldSchema, error) {
mt.ddLock.RLock()
defer mt.ddLock.RUnlock()
collID, ok := mt.segID2CollID[segID]
if !ok {
return nil, errors.Errorf("segment id %d not belong to any collection", segID)
}
collMeta, ok := mt.collID2Meta[collID]
if !ok {
return nil, errors.Errorf("segment id %d not belong to any collection which has dropped", segID)
}
rst := make([]*schemapb.FieldSchema, 0, 2)
for _, f := range collMeta.Schema.Fields {
if f.DataType == schemapb.DataType_VECTOR_BINARY || f.DataType == schemapb.DataType_VECTOR_FLOAT {
field := proto.Clone(f)
rst = append(rst, field.(*schemapb.FieldSchema))
}
}
return rst, nil
}
func (mt *metaTable) GetIndexByName(collName string, fieldName string, indexName string) ([]pb.IndexInfo, error) {
mt.ddLock.RLock()
mt.ddLock.RUnlock()

9
internal/masterservice/task.go
View File

@ -212,7 +212,6 @@ func (t *DescribeCollectionReqTask) Execute() error {
return err
}
t.Rsp.Schema = proto.Clone(coll.Schema).(*schemapb.CollectionSchema)
t.Rsp.CollectionID = coll.ID
var newField []*schemapb.FieldSchema
for _, field := range t.Rsp.Schema.Fields {
if field.FieldID >= StartOfUserFieldID {
@ -369,13 +368,10 @@ func (t *ShowPartitionReqTask) Ts() (typeutil.Timestamp, error) {
}
func (t *ShowPartitionReqTask) Execute() error {
coll, err := t.core.MetaTable.GetCollectionByID(t.Req.CollectionID)
coll, err := t.core.MetaTable.GetCollectionByName(t.Req.CollectionName)
if err != nil {
return err
}
if coll.Schema.Name != t.Req.CollectionName {
return errors.Errorf("collection %s not exist", t.Req.CollectionName)
}
for _, partID := range coll.PartitionIDs {
partMeta, err := t.core.MetaTable.GetPartitionByID(partID)
if err != nil {
@ -481,9 +477,6 @@ func (t *CreateIndexReqTask) Execute() error {
if err != nil {
return err
}
if field.DataType != schemapb.DataType_VECTOR_FLOAT && field.DataType != schemapb.DataType_VECTOR_BINARY {
return errors.Errorf("field name = %s, data type = %s", t.Req.FieldName, schemapb.DataType_name[int32(field.DataType)])
}
for _, seg := range segIDs {
task := CreateIndexTask{
core: t.core,

1
internal/proto/milvus.proto
View File

@ -46,7 +46,6 @@ message DescribeCollectionRequest {
message DescribeCollectionResponse {
common.Status status = 1;
schema.CollectionSchema schema = 2;
int64 collectionID = 3;
}
message LoadCollectionRequest {

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

@ -380,7 +380,6 @@ func (m *DescribeCollectionRequest) GetCollectionName() string {
type DescribeCollectionResponse struct {
Status *commonpb.Status `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
Schema *schemapb.CollectionSchema `protobuf:"bytes,2,opt,name=schema,proto3" json:"schema,omitempty"`
CollectionID int64 `protobuf:"varint,3,opt,name=collectionID,proto3" json:"collectionID,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
@ -425,13 +424,6 @@ func (m *DescribeCollectionResponse) GetSchema() *schemapb.CollectionSchema {
return nil
}
func (m *DescribeCollectionResponse) GetCollectionID() int64 {
if m != nil {
return m.CollectionID
}
return 0
}
type LoadCollectionRequest 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"`
@ -2400,112 +2392,111 @@ func init() {
func init() { proto.RegisterFile("milvus.proto", fileDescriptor_02345ba45cc0e303) }
var fileDescriptor_02345ba45cc0e303 = []byte{
// 1665 bytes of a gzipped FileDescriptorProto
// 1661 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x59, 0xdd, 0x6f, 0x1b, 0xc5,
0x16, 0xcf, 0xda, 0x8e, 0x93, 0x9c, 0xac, 0x1d, 0x67, 0xf2, 0xe5, 0xba, 0xed, 0x6d, 0x3a, 0xf7,
0xf6, 0x26, 0xfd, 0x4a, 0xae, 0xd2, 0xfb, 0xf9, 0x70, 0xa5, 0x36, 0x71, 0x9a, 0x5a, 0x6d, 0xd3,
0xdc, 0x75, 0x6e, 0x21, 0x54, 0x95, 0x59, 0x7b, 0x07, 0x7b, 0xe9, 0x7a, 0xd7, 0xec, 0x8c, 0xf3,
0xd1, 0x27, 0x04, 0x12, 0x48, 0x80, 0xe0, 0x99, 0x57, 0x24, 0x5e, 0x11, 0x14, 0xc4, 0x7f, 0x80,
0xc4, 0xff, 0x82, 0x10, 0x7f, 0x01, 0x12, 0xda, 0xd9, 0xf5, 0x7a, 0x77, 0x33, 0x1b, 0x9b, 0x1a,
0x88, 0xf3, 0xe6, 0x39, 0x3e, 0x73, 0xce, 0xef, 0x7c, 0xcd, 0x9c, 0x39, 0x0b, 0x72, 0x53, 0x37,
0xf6, 0xdb, 0x74, 0xa5, 0x65, 0x5b, 0xcc, 0x42, 0x33, 0xc1, 0xd5, 0x8a, 0xbb, 0x28, 0xc8, 0x35,
0xab, 0xd9, 0xb4, 0x4c, 0x97, 0x58, 0x90, 0x69, 0xad, 0x41, 0x9a, 0xaa, 0xbb, 0xc2, 0x9f, 0x4b,
0xb0, 0xb0, 0x61, 0x13, 0x95, 0x91, 0x0d, 0xcb, 0x30, 0x48, 0x8d, 0xe9, 0x96, 0xa9, 0x90, 0xb7,
0xda, 0x84, 0x32, 0xf4, 0x37, 0x48, 0x55, 0x55, 0x4a, 0xf2, 0xd2, 0xa2, 0xb4, 0x3c, 0xb9, 0x76,
0x61, 0x25, 0x24, 0xdb, 0x93, 0xf9, 0x90, 0xd6, 0xd7, 0x55, 0x4a, 0x14, 0xce, 0x89, 0x16, 0x60,
0x4c, 0xab, 0x56, 0x4c, 0xb5, 0x49, 0xf2, 0x89, 0x45, 0x69, 0x79, 0x42, 0x49, 0x6b, 0xd5, 0x6d,
0xb5, 0x49, 0xd0, 0x12, 0x4c, 0xd5, 0x7c, 0xf9, 0x2e, 0x43, 0x92, 0x33, 0x64, 0xbb, 0x64, 0xce,
0x38, 0x0f, 0x69, 0x17, 0x5f, 0x3e, 0xb5, 0x28, 0x2d, 0xcb, 0x8a, 0xb7, 0xc2, 0x1f, 0x4a, 0x30,
0x57, 0xb4, 0xad, 0xd6, 0x50, 0xa0, 0xc4, 0x1f, 0x48, 0x30, 0x7b, 0x4f, 0xa5, 0xc3, 0x01, 0x66,
0x0f, 0xe4, 0x75, 0xcb, 0x32, 0x14, 0x42, 0x5b, 0x96, 0x49, 0x09, 0xba, 0x05, 0x69, 0xca, 0x54,
0xd6, 0xa6, 0x1e, 0x8a, 0xf3, 0x42, 0x14, 0x65, 0xce, 0xa2, 0x78, 0xac, 0x68, 0x16, 0x46, 0xf7,
0x55, 0xa3, 0xed, 0x82, 0x18, 0x57, 0xdc, 0x05, 0x7e, 0x02, 0xd9, 0x32, 0xb3, 0x75, 0xb3, 0xfe,
0x1b, 0x0a, 0x9f, 0xe8, 0x08, 0xff, 0x44, 0x82, 0x73, 0x45, 0x42, 0x6b, 0xb6, 0x5e, 0x1d, 0x8e,
0xe4, 0xc3, 0xdf, 0x48, 0x50, 0x10, 0x21, 0x1a, 0xc4, 0xf6, 0xff, 0xfa, 0x09, 0x9d, 0xe0, 0x9b,
0xae, 0x84, 0x37, 0x79, 0xc5, 0xd8, 0xd5, 0x56, 0xe6, 0x84, 0x4e, 0xde, 0x23, 0x0c, 0x72, 0x17,
0x64, 0xa9, 0xc8, 0x81, 0x27, 0x95, 0x10, 0x8d, 0xd7, 0xc6, 0x03, 0x4b, 0xd5, 0x86, 0xc3, 0x89,
0x1f, 0x4b, 0x90, 0x57, 0x88, 0x41, 0x54, 0x3a, 0x24, 0x51, 0xfd, 0x48, 0x82, 0xf9, 0x80, 0x7f,
0x99, 0xca, 0xe8, 0x69, 0xc2, 0x79, 0xdf, 0x39, 0x71, 0xa3, 0x70, 0x06, 0xc9, 0xb0, 0x7f, 0xc1,
0xa8, 0xf3, 0x8b, 0xe6, 0x13, 0x8b, 0xc9, 0xe5, 0xc9, 0xb5, 0xcb, 0xc2, 0x3d, 0xf7, 0xc9, 0xd1,
0x63, 0xa7, 0xea, 0x76, 0x54, 0xdd, 0x56, 0x5c, 0x7e, 0x5c, 0x85, 0xb9, 0x72, 0xc3, 0x3a, 0xf8,
0x3d, 0xa3, 0x84, 0x0f, 0x61, 0x3e, 0xaa, 0x63, 0x10, 0x5b, 0xaf, 0x42, 0x2e, 0xe2, 0x65, 0xd7,
0xec, 0x09, 0x65, 0x2a, 0xec, 0x66, 0x8a, 0xbf, 0x76, 0xc2, 0xce, 0x6f, 0xb6, 0x1d, 0xd5, 0x66,
0xfa, 0x69, 0x5f, 0x6c, 0x57, 0x20, 0xdb, 0xea, 0xe0, 0x70, 0xf9, 0x52, 0x9c, 0x2f, 0xe3, 0x53,
0xb9, 0xbf, 0xbe, 0x92, 0x60, 0xd6, 0xb9, 0xe7, 0xce, 0x12, 0xe6, 0x2f, 0x25, 0x98, 0xb9, 0xa7,
0xd2, 0xb3, 0x04, 0xf9, 0x85, 0x04, 0x33, 0xce, 0x91, 0xe9, 0x62, 0x3e, 0x5d, 0xc8, 0x4b, 0x30,
0x15, 0x86, 0x4c, 0xf3, 0x29, 0x9e, 0xd2, 0xd9, 0x10, 0x66, 0x8a, 0xbf, 0x95, 0x60, 0xc1, 0x3b,
0x59, 0x87, 0xc2, 0xd7, 0x7d, 0x03, 0x7f, 0x21, 0xc1, 0x9c, 0x8f, 0xf8, 0xb4, 0x0f, 0xe0, 0x7e,
0x53, 0xe4, 0x3d, 0x09, 0xe6, 0xa3, 0xa0, 0x4f, 0xe5, 0x98, 0xfe, 0x42, 0x82, 0x59, 0xe7, 0x0c,
0x1d, 0x8a, 0x98, 0x47, 0xfb, 0x91, 0x94, 0xa0, 0x1f, 0xf9, 0x54, 0x72, 0x2f, 0x96, 0x00, 0xe0,
0x41, 0x1c, 0x27, 0x48, 0xb3, 0x84, 0x28, 0xcd, 0x1c, 0x6c, 0x3e, 0xa5, 0x54, 0xa4, 0xf9, 0xe4,
0x62, 0xd2, 0xc1, 0x16, 0xa4, 0xf1, 0x66, 0xa0, 0xd3, 0xe2, 0x95, 0x49, 0xbd, 0x49, 0x4c, 0xf6,
0xf2, 0xee, 0x8c, 0x3a, 0x23, 0x71, 0xdc, 0x19, 0xe8, 0x02, 0x4c, 0x50, 0x57, 0x8f, 0xdf, 0xbd,
0x75, 0x09, 0xb8, 0x01, 0x0b, 0xc7, 0xd0, 0x0c, 0xe2, 0xab, 0x3c, 0x8c, 0xe9, 0xa6, 0x46, 0x0e,
0x7d, 0x30, 0x9d, 0xa5, 0x63, 0x38, 0x72, 0x82, 0xf2, 0x87, 0x18, 0xbd, 0x08, 0x93, 0x01, 0xaf,
0x7b, 0x66, 0x07, 0x49, 0xf8, 0x4d, 0x98, 0x09, 0xa1, 0x19, 0xc4, 0xe8, 0x3f, 0x01, 0xf8, 0x1e,
0x75, 0x73, 0x23, 0xa9, 0x04, 0x28, 0xf8, 0x47, 0x09, 0x90, 0xdb, 0x09, 0x94, 0x1c, 0x67, 0x9c,
0x66, 0xf9, 0x5c, 0x04, 0x78, 0x43, 0x27, 0x86, 0x16, 0x3c, 0x77, 0x26, 0x38, 0x85, 0xff, 0x5d,
0x04, 0x99, 0x1c, 0x32, 0x5b, 0xad, 0xb4, 0x54, 0x5b, 0x6d, 0xd2, 0xfc, 0x68, 0xbf, 0x47, 0xc5,
0x24, 0xdf, 0xb6, 0xc3, 0x77, 0xe1, 0xef, 0x9d, 0x1e, 0xc2, 0xcb, 0xaa, 0x61, 0xb7, 0xf8, 0x22,
0x00, 0xcf, 0x50, 0xf7, 0xef, 0x51, 0xf7, 0x6f, 0x4e, 0xe1, 0x87, 0xb0, 0x01, 0x39, 0x6e, 0x81,
0x6b, 0x4e, 0xcb, 0x91, 0x1a, 0xd9, 0x22, 0x45, 0xb6, 0xa0, 0xff, 0x40, 0xda, 0xf3, 0x5e, 0xdf,
0x07, 0xad, 0xb7, 0x01, 0x7f, 0x26, 0xc1, 0x5c, 0xc4, 0x71, 0x83, 0xe4, 0xe5, 0x2e, 0x20, 0x17,
0xa8, 0xd6, 0x45, 0xdf, 0x41, 0x15, 0x79, 0x06, 0x7a, 0x8b, 0xa8, 0xad, 0xca, 0xb4, 0x1e, 0xa1,
0x50, 0xfc, 0x9d, 0x04, 0xd3, 0x9c, 0xcf, 0xd1, 0x46, 0xce, 0x6e, 0x68, 0xdf, 0x96, 0x00, 0x05,
0xed, 0x18, 0xc4, 0xd3, 0xff, 0x70, 0xef, 0x56, 0xd7, 0x92, 0xec, 0xda, 0x25, 0xe1, 0x9e, 0x80,
0x32, 0x97, 0x1b, 0xff, 0x2c, 0x41, 0xa6, 0x64, 0x52, 0x62, 0xb3, 0xe1, 0xef, 0x47, 0xd0, 0xdf,
0x61, 0xdc, 0xb6, 0x0e, 0x2a, 0x9a, 0xca, 0x54, 0xef, 0x5c, 0x38, 0x27, 0x84, 0xb7, 0x6e, 0x58,
0x55, 0x65, 0xcc, 0xb6, 0x0e, 0x8a, 0x2a, 0x53, 0xd1, 0x79, 0x98, 0x68, 0xa8, 0xb4, 0x51, 0x79,
0x46, 0x8e, 0x68, 0x3e, 0xbd, 0x98, 0x5c, 0xce, 0x28, 0xe3, 0x0e, 0xe1, 0x3e, 0x39, 0xa2, 0xf8,
0x5d, 0x09, 0xb2, 0x1d, 0xfb, 0x07, 0x71, 0xff, 0x25, 0x98, 0xb4, 0xad, 0x83, 0x52, 0xb1, 0x52,
0x25, 0x75, 0xdd, 0xf4, 0x6e, 0x04, 0xe0, 0xa4, 0x75, 0x87, 0xe2, 0xa0, 0x70, 0x19, 0x88, 0xa9,
0x79, 0xb7, 0xc1, 0x38, 0x27, 0x6c, 0x9a, 0x1a, 0xde, 0x87, 0xdc, 0x8e, 0xa1, 0xd6, 0x48, 0xc3,
0x32, 0x34, 0x62, 0xf3, 0xaa, 0x44, 0x39, 0x48, 0x32, 0xb5, 0xee, 0x15, 0xb7, 0xf3, 0x13, 0xfd,
0x1b, 0x52, 0xec, 0xa8, 0xd5, 0x89, 0xf0, 0x5f, 0x84, 0xe5, 0x13, 0x10, 0xb3, 0x7b, 0xd4, 0x22,
0x0a, 0xdf, 0x81, 0xe6, 0x21, 0xcd, 0x07, 0x4e, 0x6e, 0x43, 0x20, 0x2b, 0xde, 0x0a, 0x3f, 0x0d,
0xe9, 0xdd, 0xb2, 0xad, 0x76, 0x0b, 0x95, 0x40, 0x6e, 0x75, 0x69, 0x8e, 0x13, 0xe2, 0x8b, 0x35,
0x0a, 0x5a, 0x09, 0x6d, 0xc5, 0x3f, 0x48, 0x90, 0x29, 0x13, 0xd5, 0xae, 0x35, 0xce, 0x42, 0x8f,
0xee, 0x78, 0x5c, 0xa3, 0x86, 0x57, 0xa6, 0xce, 0x4f, 0x74, 0x1d, 0xa6, 0x03, 0x06, 0x55, 0xea,
0x8e, 0x83, 0xf2, 0x69, 0x3e, 0x95, 0xcd, 0xb5, 0x22, 0x8e, 0xc3, 0xf7, 0x21, 0x75, 0x4f, 0x67,
0x5c, 0x8c, 0x73, 0x09, 0x4b, 0xfc, 0x12, 0x76, 0x7e, 0xa2, 0x73, 0x81, 0xbc, 0x4d, 0xf0, 0x00,
0xf8, 0xc9, 0xc9, 0x87, 0xbd, 0x96, 0xed, 0x45, 0x26, 0xa1, 0x78, 0x2b, 0xfc, 0x6a, 0xd7, 0x73,
0xb4, 0x6d, 0x30, 0xfa, 0x72, 0x59, 0x89, 0x20, 0xd5, 0xd0, 0xbd, 0x7e, 0x5b, 0x56, 0xf8, 0x6f,
0xfc, 0x8e, 0x04, 0xf2, 0x5d, 0xa3, 0x4d, 0x4f, 0x33, 0x26, 0x4e, 0xd9, 0xcd, 0x2a, 0xa4, 0xae,
0x53, 0x46, 0xec, 0x07, 0xba, 0xf9, 0xcc, 0x2f, 0xbe, 0x7f, 0xc2, 0x98, 0xaa, 0x69, 0x36, 0xa1,
0xf4, 0x44, 0x3c, 0x77, 0x5c, 0x1e, 0xa5, 0xc3, 0x1c, 0x70, 0x4f, 0xa2, 0x6f, 0xf7, 0x5c, 0xbb,
0x0d, 0x53, 0x91, 0x7a, 0x41, 0xe3, 0x90, 0xda, 0x7e, 0xb4, 0xbd, 0x99, 0x1b, 0x41, 0xd3, 0x90,
0x79, 0xbc, 0xb9, 0xb1, 0xfb, 0x48, 0xa9, 0xac, 0x97, 0xb6, 0xef, 0x28, 0x7b, 0x39, 0x0d, 0xe5,
0x40, 0xf6, 0x48, 0x77, 0x1f, 0x3c, 0xba, 0xb3, 0x9b, 0x23, 0x6b, 0x3f, 0xe5, 0x20, 0xf3, 0x90,
0x2b, 0x2a, 0x13, 0x7b, 0x5f, 0xaf, 0x11, 0x54, 0x81, 0x5c, 0xf4, 0x63, 0x02, 0xba, 0x21, 0x2c,
0x9e, 0x98, 0x6f, 0x0e, 0x85, 0x93, 0xa0, 0xe3, 0x11, 0xf4, 0x04, 0xb2, 0xe1, 0xaf, 0x00, 0xe8,
0x9a, 0x50, 0xbc, 0xf0, 0x53, 0x41, 0x2f, 0xe1, 0x15, 0xc8, 0x84, 0x86, 0xfa, 0xe8, 0xaa, 0x50,
0xb6, 0x68, 0xf0, 0x5f, 0xb8, 0x2c, 0x64, 0x0d, 0xce, 0xe5, 0x5d, 0xf4, 0xe1, 0x39, 0x6d, 0x0c,
0x7a, 0xe1, 0x30, 0xb7, 0x17, 0x7a, 0x15, 0xa6, 0x8f, 0x8d, 0x5d, 0xd1, 0x4d, 0xa1, 0xfc, 0xb8,
0xf1, 0x6c, 0x2f, 0x15, 0x07, 0x80, 0x8e, 0x8f, 0xc7, 0xd1, 0x8a, 0x38, 0x02, 0x71, 0x93, 0xfd,
0xc2, 0x6a, 0xdf, 0xfc, 0xbe, 0xe3, 0xf6, 0x61, 0x61, 0x8b, 0xb0, 0xf0, 0xd4, 0x54, 0xa7, 0x4c,
0xaf, 0x51, 0x74, 0x5d, 0x9c, 0x5e, 0xc2, 0x79, 0x6f, 0xe1, 0x46, 0x7f, 0xcc, 0xbe, 0x5e, 0x03,
0xa6, 0xc2, 0xd3, 0x4b, 0x1a, 0x13, 0x31, 0xe1, 0x1c, 0xb5, 0x70, 0xbd, 0x2f, 0x5e, 0x5f, 0xdb,
0x53, 0x98, 0x8a, 0x0c, 0x2c, 0xe3, 0xac, 0x13, 0x8e, 0x35, 0x7b, 0x45, 0x6f, 0x0f, 0x32, 0xa1,
0xc9, 0x62, 0x4c, 0x7a, 0x8b, 0xa6, 0x8f, 0xbd, 0x44, 0x3f, 0x05, 0x39, 0x38, 0x00, 0x44, 0xcb,
0x71, 0x85, 0x73, 0x4c, 0x70, 0x5f, 0x75, 0xb3, 0xe7, 0xd6, 0x8d, 0xbf, 0x99, 0xc6, 0x28, 0x10,
0x4c, 0xf4, 0x7a, 0x21, 0x7f, 0xdd, 0xaf, 0x9a, 0x80, 0xf4, 0x1b, 0x27, 0x55, 0xcd, 0xaf, 0xf5,
0x0d, 0x85, 0xf9, 0x2d, 0xc2, 0x42, 0x93, 0x24, 0x2f, 0x75, 0xc5, 0xa9, 0x24, 0x1c, 0x94, 0xc5,
0xa4, 0x92, 0x78, 0x3e, 0x85, 0x47, 0x90, 0x0e, 0xd9, 0xd0, 0x04, 0x86, 0xc6, 0x04, 0x5b, 0x34,
0x57, 0x2a, 0x5c, 0xeb, 0x87, 0xd5, 0x57, 0xf5, 0x7f, 0x98, 0x0c, 0x3c, 0xae, 0xd1, 0xd2, 0x09,
0x19, 0x1b, 0x7c, 0x8c, 0xf6, 0x72, 0x5b, 0x03, 0x32, 0xa1, 0xa7, 0x58, 0x5c, 0xb6, 0x0a, 0xde,
0xb9, 0x31, 0x06, 0x08, 0x5f, 0x76, 0x78, 0x04, 0x55, 0x21, 0xb3, 0x45, 0x58, 0xf7, 0x75, 0x80,
0xfe, 0x1a, 0xff, 0x36, 0x0b, 0xbe, 0xb9, 0x0a, 0x4b, 0x3d, 0xf9, 0x7c, 0x1d, 0x65, 0x48, 0xbb,
0x8d, 0x36, 0xc2, 0x31, 0x9b, 0x02, 0xaf, 0x90, 0xc2, 0x9f, 0x4f, 0xe4, 0xf1, 0x85, 0x2a, 0x90,
0x76, 0xdb, 0xa4, 0x18, 0xa1, 0xa1, 0xee, 0xb3, 0x70, 0x32, 0x0f, 0xef, 0xb3, 0xf0, 0x08, 0x2a,
0xc1, 0x28, 0xef, 0x8f, 0x90, 0xb8, 0x30, 0x83, 0xbd, 0x53, 0xaf, 0x08, 0xfe, 0x0f, 0xe4, 0x2d,
0xc2, 0x8a, 0xda, 0x46, 0x43, 0x35, 0x4d, 0x62, 0xa0, 0x82, 0x90, 0x7d, 0xb3, 0xd9, 0x62, 0x47,
0x31, 0x16, 0x87, 0xbf, 0x3d, 0xe3, 0x91, 0xb5, 0x3a, 0xc8, 0x3b, 0xb6, 0x75, 0x78, 0xd4, 0xe9,
0x37, 0x5e, 0x01, 0x39, 0xd8, 0x48, 0x9d, 0xa8, 0xe2, 0x6a, 0x4c, 0x51, 0x1f, 0xef, 0xc3, 0xf0,
0xc8, 0xfa, 0xfa, 0x6b, 0xb7, 0xeb, 0x3a, 0x6b, 0xb4, 0xab, 0x8e, 0x8c, 0xd5, 0xe7, 0xba, 0x61,
0xe8, 0xcf, 0x19, 0xa9, 0x35, 0x56, 0xdd, 0x6d, 0x37, 0x35, 0x9d, 0x32, 0x5b, 0xaf, 0xb6, 0x19,
0xd1, 0x56, 0x75, 0x93, 0x11, 0xdb, 0x54, 0x8d, 0x55, 0x2e, 0xd8, 0xe3, 0x68, 0x55, 0xab, 0x69,
0xbe, 0xbe, 0xf5, 0x4b, 0x00, 0x00, 0x00, 0xff, 0xff, 0xb4, 0x3e, 0x9a, 0x14, 0xa2, 0x21, 0x00,
0x00,
0xd1, 0x27, 0x04, 0x12, 0x48, 0x80, 0x80, 0x57, 0x5e, 0x91, 0x78, 0x45, 0x50, 0x24, 0xfe, 0x03,
0x24, 0xfe, 0x17, 0x84, 0xf8, 0x0b, 0x90, 0xd0, 0xce, 0xae, 0xd7, 0xbb, 0x9b, 0xd9, 0xd8, 0xd4,
0x40, 0x9c, 0xb7, 0x9d, 0xe3, 0x33, 0x67, 0x7e, 0xe7, 0x37, 0xe7, 0xcc, 0x9c, 0x39, 0x06, 0xb9,
0xa9, 0x1b, 0xfb, 0x6d, 0xba, 0xd2, 0xb2, 0x2d, 0x66, 0xa1, 0x99, 0xe0, 0x68, 0xc5, 0x1d, 0x14,
0xe4, 0x9a, 0xd5, 0x6c, 0x5a, 0xa6, 0x2b, 0x2c, 0xc8, 0xb4, 0xd6, 0x20, 0x4d, 0xd5, 0x1d, 0xe1,
0x2f, 0x24, 0x58, 0xd8, 0xb0, 0x89, 0xca, 0xc8, 0x86, 0x65, 0x18, 0xa4, 0xc6, 0x74, 0xcb, 0x54,
0xc8, 0x5b, 0x6d, 0x42, 0x19, 0xfa, 0x1b, 0xa4, 0xaa, 0x2a, 0x25, 0x79, 0x69, 0x51, 0x5a, 0x9e,
0x5c, 0xbb, 0xb0, 0x12, 0xb2, 0xed, 0xd9, 0x7c, 0x48, 0xeb, 0xeb, 0x2a, 0x25, 0x0a, 0xd7, 0x44,
0x0b, 0x30, 0xa6, 0x55, 0x2b, 0xa6, 0xda, 0x24, 0xf9, 0xc4, 0xa2, 0xb4, 0x3c, 0xa1, 0xa4, 0xb5,
0xea, 0xb6, 0xda, 0x24, 0x68, 0x09, 0xa6, 0x6a, 0xbe, 0x7d, 0x57, 0x21, 0xc9, 0x15, 0xb2, 0x5d,
0x31, 0x57, 0x9c, 0x87, 0xb4, 0x8b, 0x2f, 0x9f, 0x5a, 0x94, 0x96, 0x65, 0xc5, 0x1b, 0xe1, 0x0f,
0x25, 0x98, 0x2b, 0xda, 0x56, 0x6b, 0x28, 0x50, 0xe2, 0x0f, 0x24, 0x98, 0xbd, 0xa7, 0xd2, 0xe1,
0x00, 0xb3, 0x07, 0xf2, 0xba, 0x65, 0x19, 0x0a, 0xa1, 0x2d, 0xcb, 0xa4, 0x04, 0xdd, 0x82, 0x34,
0x65, 0x2a, 0x6b, 0x53, 0x0f, 0xc5, 0x79, 0x21, 0x8a, 0x32, 0x57, 0x51, 0x3c, 0x55, 0x34, 0x0b,
0xa3, 0xfb, 0xaa, 0xd1, 0x76, 0x41, 0x8c, 0x2b, 0xee, 0x00, 0x3f, 0x81, 0x6c, 0x99, 0xd9, 0xba,
0x59, 0xff, 0x0d, 0x8d, 0x4f, 0x74, 0x8c, 0x7f, 0x22, 0xc1, 0xb9, 0x22, 0xa1, 0x35, 0x5b, 0xaf,
0x0e, 0x47, 0xf0, 0xe1, 0x4f, 0x25, 0x28, 0x88, 0x10, 0x0d, 0xe2, 0xfb, 0x7f, 0xfd, 0x80, 0x4e,
0xf0, 0x49, 0x57, 0xc2, 0x93, 0xbc, 0x64, 0xec, 0xae, 0x56, 0xe6, 0x82, 0x50, 0xdc, 0x3f, 0xb0,
0x54, 0x6d, 0x38, 0x08, 0xfa, 0x58, 0x82, 0xbc, 0x42, 0x0c, 0xa2, 0xd2, 0x21, 0xd9, 0xb1, 0x8f,
0x24, 0x98, 0x0f, 0x70, 0xc7, 0x54, 0x46, 0x4f, 0x13, 0xce, 0xfb, 0xce, 0x69, 0x1a, 0x85, 0x33,
0x48, 0xf4, 0xfc, 0x0b, 0x46, 0x9d, 0x2f, 0x9a, 0x4f, 0x2c, 0x26, 0x97, 0x27, 0xd7, 0x2e, 0x0b,
0xe7, 0xdc, 0x27, 0x47, 0x8f, 0x9d, 0x8c, 0xda, 0x51, 0x75, 0x5b, 0x71, 0xf5, 0x71, 0x15, 0xe6,
0xca, 0x0d, 0xeb, 0xe0, 0xf7, 0xdc, 0x25, 0x7c, 0x08, 0xf3, 0xd1, 0x35, 0x06, 0xf1, 0xf5, 0x2a,
0xe4, 0x22, 0x2c, 0xbb, 0x6e, 0x4f, 0x28, 0x53, 0x61, 0x9a, 0x29, 0xfe, 0xc6, 0xd9, 0x76, 0x7e,
0x6b, 0xed, 0xa8, 0x36, 0xd3, 0x4f, 0xfb, 0xd2, 0xba, 0x02, 0xd9, 0x56, 0x07, 0x87, 0xab, 0x97,
0xe2, 0x7a, 0x19, 0x5f, 0xca, 0xf9, 0xfa, 0x5a, 0x82, 0x59, 0xe7, 0x0e, 0x3b, 0x4b, 0x98, 0xbf,
0x92, 0x60, 0xe6, 0x9e, 0x4a, 0xcf, 0x12, 0xe4, 0x17, 0x12, 0xcc, 0x38, 0x47, 0xa6, 0x8b, 0xf9,
0x74, 0x21, 0x2f, 0xc1, 0x54, 0x18, 0x32, 0xcd, 0xa7, 0x78, 0x48, 0x67, 0x43, 0x98, 0x29, 0xfe,
0x56, 0x82, 0x05, 0xef, 0x64, 0x1d, 0x0a, 0xae, 0xfb, 0x06, 0xfe, 0x42, 0x82, 0x39, 0x1f, 0xf1,
0x69, 0x1f, 0xc0, 0xfd, 0x86, 0xc8, 0x7b, 0x12, 0xcc, 0x47, 0x41, 0x9f, 0xca, 0x31, 0xfd, 0xa5,
0x04, 0xb3, 0xce, 0x19, 0x3a, 0x14, 0x7b, 0x8e, 0x41, 0xee, 0x4a, 0x4a, 0x45, 0x4e, 0x5d, 0x52,
0x09, 0xc9, 0xf0, 0x67, 0x92, 0x7b, 0xb1, 0x04, 0x00, 0x0f, 0x42, 0x9c, 0x20, 0xcc, 0x12, 0xa2,
0x30, 0x73, 0xb0, 0xf9, 0x92, 0x52, 0x91, 0xe6, 0x93, 0x8b, 0x49, 0x07, 0x5b, 0x50, 0xc6, 0x8b,
0x81, 0x4e, 0xf9, 0x56, 0x26, 0xf5, 0x26, 0x31, 0xd9, 0xcb, 0xd3, 0x19, 0x25, 0x23, 0x71, 0x9c,
0x0c, 0x74, 0x01, 0x26, 0xa8, 0xbb, 0x4e, 0xa9, 0xc8, 0x39, 0x4d, 0x2a, 0x5d, 0x01, 0x6e, 0xc0,
0xc2, 0x31, 0x34, 0x83, 0x70, 0x95, 0x87, 0x31, 0xdd, 0xd4, 0xc8, 0xa1, 0x0f, 0xa6, 0x33, 0x74,
0x1c, 0x47, 0xce, 0xa6, 0xfc, 0x21, 0x4e, 0x2f, 0xc2, 0x64, 0x80, 0x75, 0xcf, 0xed, 0xa0, 0x08,
0xbf, 0x09, 0x33, 0x21, 0x34, 0x83, 0x38, 0xfd, 0x27, 0x00, 0x9f, 0x51, 0x37, 0x36, 0x92, 0x4a,
0x40, 0x82, 0x7f, 0x94, 0x00, 0xb9, 0x95, 0x40, 0xc9, 0x21, 0xe3, 0x34, 0xd3, 0xe7, 0x22, 0xc0,
0x1b, 0x3a, 0x31, 0xb4, 0xe0, 0xb9, 0x33, 0xc1, 0x25, 0xfc, 0xe7, 0x22, 0xc8, 0xe4, 0x90, 0xd9,
0x6a, 0xa5, 0xa5, 0xda, 0x6a, 0x93, 0xe6, 0x47, 0xfb, 0x3d, 0x2a, 0x26, 0xf9, 0xb4, 0x1d, 0x3e,
0x0b, 0x7f, 0xef, 0xd4, 0x10, 0x5e, 0x54, 0x0d, 0xbb, 0xc7, 0x17, 0x01, 0x78, 0x84, 0xba, 0x3f,
0x8f, 0xba, 0x3f, 0x73, 0x09, 0x3f, 0x84, 0x0d, 0xc8, 0x71, 0x0f, 0x5c, 0x77, 0x5a, 0x8e, 0xd5,
0xc8, 0x14, 0x29, 0x32, 0x05, 0xfd, 0x07, 0xd2, 0x1e, 0x7b, 0x7d, 0x1f, 0xb4, 0xde, 0x04, 0xfc,
0xb9, 0x04, 0x73, 0x11, 0xe2, 0x06, 0x89, 0xcb, 0x5d, 0x40, 0x2e, 0x50, 0xad, 0x8b, 0xbe, 0x83,
0x2a, 0xf2, 0xc4, 0xf3, 0x06, 0x51, 0x5f, 0x95, 0x69, 0x3d, 0x22, 0xa1, 0xf8, 0x3b, 0x09, 0xa6,
0xb9, 0x9e, 0xb3, 0x1a, 0x39, 0xbb, 0x5b, 0xfb, 0xb6, 0x04, 0x28, 0xe8, 0xc7, 0x20, 0x4c, 0xff,
0xc3, 0xbd, 0x5b, 0x5d, 0x4f, 0xb2, 0x6b, 0x97, 0x84, 0x73, 0x02, 0x8b, 0xb9, 0xda, 0xf8, 0x67,
0x09, 0x32, 0x25, 0x93, 0x12, 0x9b, 0x0d, 0x7f, 0x3d, 0x82, 0xfe, 0x0e, 0xe3, 0xb6, 0x75, 0x50,
0xd1, 0x54, 0xa6, 0x7a, 0xe7, 0xc2, 0x39, 0x21, 0xbc, 0x75, 0xc3, 0xaa, 0x2a, 0x63, 0xb6, 0x75,
0x50, 0x54, 0x99, 0x8a, 0xce, 0xc3, 0x44, 0x43, 0xa5, 0x8d, 0xca, 0x33, 0x72, 0x44, 0xf3, 0xe9,
0xc5, 0xe4, 0x72, 0x46, 0x19, 0x77, 0x04, 0xf7, 0xc9, 0x11, 0xc5, 0xef, 0x4a, 0x90, 0xed, 0xf8,
0x3f, 0x08, 0xfd, 0x97, 0x60, 0xd2, 0xb6, 0x0e, 0x4a, 0xc5, 0x4a, 0x95, 0xd4, 0x75, 0xd3, 0xbb,
0x11, 0x80, 0x8b, 0xd6, 0x1d, 0x89, 0x83, 0xc2, 0x55, 0x20, 0xa6, 0xe6, 0xdd, 0x06, 0xe3, 0x5c,
0xb0, 0x69, 0x6a, 0x78, 0x1f, 0x72, 0x3b, 0x86, 0x5a, 0x23, 0x0d, 0xcb, 0xd0, 0x88, 0xcd, 0xb3,
0x12, 0xe5, 0x20, 0xc9, 0xd4, 0xba, 0x97, 0xdc, 0xce, 0x27, 0xfa, 0x37, 0xa4, 0xd8, 0x51, 0xab,
0xb3, 0xc3, 0x7f, 0x11, 0xa6, 0x4f, 0xc0, 0xcc, 0xee, 0x51, 0x8b, 0x28, 0x7c, 0x06, 0x9a, 0x87,
0x34, 0x6f, 0x26, 0xb9, 0x05, 0x81, 0xac, 0x78, 0x23, 0xfc, 0x34, 0xb4, 0xee, 0x96, 0x6d, 0xb5,
0x5b, 0xa8, 0x04, 0x72, 0xab, 0x2b, 0x73, 0x48, 0x88, 0x4f, 0xd6, 0x28, 0x68, 0x25, 0x34, 0x15,
0xff, 0x20, 0x41, 0xa6, 0x4c, 0x54, 0xbb, 0xd6, 0x38, 0x0b, 0x35, 0xba, 0xc3, 0xb8, 0x46, 0x0d,
0x2f, 0x4d, 0x9d, 0x4f, 0x74, 0x1d, 0xa6, 0x03, 0x0e, 0x55, 0xea, 0x0e, 0x41, 0xf9, 0x34, 0xef,
0xb8, 0xe6, 0x5a, 0x11, 0xe2, 0xf0, 0x7d, 0x48, 0xdd, 0xd3, 0x19, 0x37, 0xe3, 0x5c, 0xc2, 0x12,
0xbf, 0x84, 0x9d, 0x4f, 0x74, 0x2e, 0x10, 0xb7, 0x09, 0xbe, 0x01, 0x7e, 0x70, 0xf2, 0x46, 0xae,
0x65, 0x7b, 0x3b, 0x93, 0x50, 0xbc, 0x11, 0x7e, 0xb5, 0xcb, 0x1c, 0x6d, 0x1b, 0x8c, 0xbe, 0x5c,
0x54, 0x22, 0x48, 0x35, 0x74, 0xaf, 0xde, 0x96, 0x15, 0xfe, 0x8d, 0xdf, 0x91, 0x40, 0xbe, 0x6b,
0xb4, 0xe9, 0x69, 0xee, 0x89, 0x93, 0x76, 0xb3, 0x0a, 0xa9, 0xeb, 0x94, 0x11, 0xfb, 0x81, 0x6e,
0x3e, 0xf3, 0x93, 0xef, 0x9f, 0x30, 0xa6, 0x6a, 0x9a, 0x4d, 0x28, 0x3d, 0x11, 0xcf, 0x1d, 0x57,
0x47, 0xe9, 0x28, 0x07, 0xe8, 0x49, 0xf4, 0x4d, 0xcf, 0xb5, 0xdb, 0x30, 0x15, 0xc9, 0x17, 0x34,
0x0e, 0xa9, 0xed, 0x47, 0xdb, 0x9b, 0xb9, 0x11, 0x34, 0x0d, 0x99, 0xc7, 0x9b, 0x1b, 0xbb, 0x8f,
0x94, 0xca, 0x7a, 0x69, 0xfb, 0x8e, 0xb2, 0x97, 0xd3, 0x50, 0x0e, 0x64, 0x4f, 0x74, 0xf7, 0xc1,
0xa3, 0x3b, 0xbb, 0x39, 0xb2, 0xf6, 0x53, 0x0e, 0x32, 0x0f, 0xf9, 0x42, 0x65, 0x62, 0xef, 0xeb,
0x35, 0x82, 0x2a, 0x90, 0x8b, 0xfe, 0x51, 0x80, 0x6e, 0x08, 0x93, 0x27, 0xe6, 0xff, 0x84, 0xc2,
0x49, 0xd0, 0xf1, 0x08, 0x7a, 0x02, 0xd9, 0x70, 0x87, 0x1f, 0x5d, 0x13, 0x9a, 0x17, 0xfe, 0x0d,
0xd0, 0xcb, 0x78, 0x05, 0x32, 0xa1, 0x86, 0x3d, 0xba, 0x2a, 0xb4, 0x2d, 0x6a, 0xea, 0x17, 0x2e,
0x0b, 0x55, 0x83, 0x3d, 0x77, 0x17, 0x7d, 0xb8, 0x4f, 0x1b, 0x83, 0x5e, 0xd8, 0xcc, 0xed, 0x85,
0x5e, 0x85, 0xe9, 0x63, 0x6d, 0x57, 0x74, 0x53, 0x68, 0x3f, 0xae, 0x3d, 0xdb, 0x6b, 0x89, 0x03,
0x40, 0xc7, 0x5b, 0xdf, 0x68, 0x45, 0xbc, 0x03, 0x71, 0x5d, 0xfb, 0xc2, 0x6a, 0xdf, 0xfa, 0x3e,
0x71, 0xfb, 0xb0, 0xb0, 0x45, 0x58, 0xb8, 0x6b, 0xaa, 0x53, 0xa6, 0xd7, 0x28, 0xba, 0x2e, 0x0e,
0x2f, 0x61, 0xbf, 0xb7, 0x70, 0xa3, 0x3f, 0x65, 0x7f, 0x5d, 0x03, 0xa6, 0xc2, 0xdd, 0x4b, 0x1a,
0xb3, 0x63, 0xc2, 0x3e, 0x6a, 0xe1, 0x7a, 0x5f, 0xba, 0xfe, 0x6a, 0x4f, 0x61, 0x2a, 0xd2, 0xb0,
0x8c, 0xf3, 0x4e, 0xd8, 0xd6, 0xec, 0xb5, 0x7b, 0x7b, 0x90, 0x09, 0x75, 0x16, 0x63, 0xc2, 0x5b,
0xd4, 0x7d, 0xec, 0x65, 0xfa, 0x29, 0xc8, 0xc1, 0x06, 0x20, 0x5a, 0x8e, 0x4b, 0x9c, 0x63, 0x86,
0xfb, 0xca, 0x9b, 0x3d, 0x37, 0x6f, 0xfc, 0xc9, 0x34, 0x66, 0x01, 0x41, 0x47, 0xaf, 0x17, 0xf2,
0xd7, 0xfd, 0xac, 0x09, 0x58, 0xbf, 0x71, 0x52, 0xd6, 0xfc, 0x5a, 0x6e, 0x28, 0xcc, 0x6f, 0x11,
0x16, 0xea, 0x24, 0x79, 0xa1, 0x2b, 0x0e, 0x25, 0x61, 0xa3, 0x2c, 0x26, 0x94, 0xc4, 0xfd, 0x29,
0x3c, 0x82, 0x74, 0xc8, 0x86, 0x3a, 0x30, 0x34, 0x66, 0xb3, 0x45, 0x7d, 0xa5, 0xc2, 0xb5, 0x7e,
0x54, 0xfd, 0xa5, 0xfe, 0x0f, 0x93, 0x81, 0xc7, 0x35, 0x5a, 0x3a, 0x21, 0x62, 0x83, 0x8f, 0xd1,
0x5e, 0xb4, 0x35, 0x20, 0x13, 0x7a, 0x8a, 0xc5, 0x45, 0xab, 0xe0, 0x9d, 0x1b, 0xe3, 0x80, 0xf0,
0x65, 0x87, 0x47, 0x50, 0x15, 0x32, 0x5b, 0x84, 0x75, 0x5f, 0x07, 0xe8, 0xaf, 0xf1, 0x6f, 0xb3,
0xe0, 0x9b, 0xab, 0xb0, 0xd4, 0x53, 0xcf, 0x5f, 0xa3, 0x0c, 0x69, 0xb7, 0xd0, 0x46, 0x38, 0x66,
0x52, 0xe0, 0x15, 0x52, 0xf8, 0xf3, 0x89, 0x3a, 0xbe, 0x51, 0x05, 0xd2, 0x6e, 0x99, 0x14, 0x63,
0x34, 0x54, 0x7d, 0x16, 0x4e, 0xd6, 0xe1, 0x75, 0x16, 0x1e, 0x41, 0x25, 0x18, 0xe5, 0xf5, 0x11,
0x12, 0x27, 0x66, 0xb0, 0x76, 0xea, 0xb5, 0x83, 0xff, 0x03, 0x79, 0x8b, 0xb0, 0xa2, 0xb6, 0xd1,
0x50, 0x4d, 0x93, 0x18, 0xa8, 0x20, 0x54, 0xdf, 0x6c, 0xb6, 0xd8, 0x51, 0x8c, 0xc7, 0xe1, 0xff,
0x95, 0xf1, 0xc8, 0x5a, 0x1d, 0xe4, 0x1d, 0xdb, 0x3a, 0x3c, 0xea, 0xd4, 0x1b, 0xaf, 0x80, 0x1c,
0x2c, 0xa4, 0x4e, 0x5c, 0xe2, 0x6a, 0x4c, 0x52, 0x1f, 0xaf, 0xc3, 0xf0, 0xc8, 0xfa, 0xfa, 0x6b,
0xb7, 0xeb, 0x3a, 0x6b, 0xb4, 0xab, 0x8e, 0x8d, 0xd5, 0xe7, 0xba, 0x61, 0xe8, 0xcf, 0x19, 0xa9,
0x35, 0x56, 0xdd, 0x69, 0x37, 0x35, 0x9d, 0x32, 0x5b, 0xaf, 0xb6, 0x19, 0xd1, 0x56, 0x75, 0x93,
0x11, 0xdb, 0x54, 0x8d, 0x55, 0x6e, 0xd8, 0xd3, 0x68, 0x55, 0xab, 0x69, 0x3e, 0xbe, 0xf5, 0x4b,
0x00, 0x00, 0x00, 0xff, 0xff, 0x74, 0x4c, 0x32, 0xc3, 0x7e, 0x21, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.

29
internal/proto/query_service.proto
View File

@ -5,6 +5,7 @@ package milvus.proto.query;
option go_package = "github.com/zilliztech/milvus-distributed/internal/proto/querypb";
import "common.proto";
import "milvus.proto";
import "internal.proto";
message RegisterNodeRequest {
@ -53,7 +54,7 @@ message ShowPartitionResponse {
enum PartitionState {
NotExist = 0;
NotPresent = 1;
OnDist = 2;
OnDisk = 2;
PartialInMemory = 3;
InMemory = 4;
PartialInGPU = 5;
@ -133,19 +134,9 @@ message ReleaseSegmentRequest {
repeated int64 fieldIDs = 6;
}
message GetTimeTickChannelResponse {
message ComponentStatesResponse {
common.Status status = 1;
string time_tick_channelID = 2;
}
message GetStatsChannelResponse {
common.Status status = 1;
string stats_channelID = 2;
}
message ServiceStatesResponse {
common.Status status = 1;
internal.ComponentStates server_states = 2;
internal.ComponentStates states = 2;
}
service QueryService {
@ -160,16 +151,16 @@ service QueryService {
rpc ReleaseCollection(ReleaseCollectionRequest) returns (common.Status) {}
rpc CreateQueryChannel(common.Empty ) returns (CreateQueryChannelResponse) {}
rpc GetTimeTickChannel(common.Empty) returns (GetTimeTickChannelResponse) {}
rpc GetStatsChannel(common.Empty) returns (GetStatsChannelResponse) {}
rpc GetTimeTickChannel(common.Empty) returns (milvus.StringResponse) {}
rpc GetStatisticsChannel(common.Empty) returns (milvus.StringResponse) {}
rpc GetPartitionStates(PartitionStatesRequest) returns (PartitionStatesResponse) {}
rpc GetComponentStates(common.Empty) returns (ServiceStatesResponse) {}
rpc GetComponentStates(common.Empty) returns (ComponentStatesResponse) {}
}
service QueryNode {
rpc GetTimeTickChannel(common.Empty) returns (GetTimeTickChannelResponse) {}
rpc GetStatsChannel(common.Empty) returns (GetStatsChannelResponse) {}
rpc GetComponentStates(common.Empty) returns (ServiceStatesResponse) {}
rpc GetTimeTickChannel(common.Empty) returns (milvus.StringResponse) {}
rpc GetStatsChannel(common.Empty) returns (milvus.StringResponse) {}
rpc GetComponentStates(common.Empty) returns (ComponentStatesResponse) {}
rpc AddQueryChannel(AddQueryChannelsRequest) returns (common.Status) {}
rpc RemoveQueryChannel(RemoveQueryChannelsRequest) returns (common.Status) {}

370
internal/proto/querypb/query_service.pb.go
View File

@ -9,6 +9,7 @@ import (
proto "github.com/golang/protobuf/proto"
commonpb "github.com/zilliztech/milvus-distributed/internal/proto/commonpb"
internalpb2 "github.com/zilliztech/milvus-distributed/internal/proto/internalpb2"
milvuspb "github.com/zilliztech/milvus-distributed/internal/proto/milvuspb"
grpc "google.golang.org/grpc"
codes "google.golang.org/grpc/codes"
status "google.golang.org/grpc/status"
@ -31,7 +32,7 @@ type PartitionState int32
const (
PartitionState_NotExist PartitionState = 0
PartitionState_NotPresent PartitionState = 1
PartitionState_OnDist PartitionState = 2
PartitionState_OnDisk PartitionState = 2
PartitionState_PartialInMemory PartitionState = 3
PartitionState_InMemory PartitionState = 4
PartitionState_PartialInGPU PartitionState = 5
@ -41,7 +42,7 @@ const (
var PartitionState_name = map[int32]string{
0: "NotExist",
1: "NotPresent",
2: "OnDist",
2: "OnDisk",
3: "PartialInMemory",
4: "InMemory",
5: "PartialInGPU",
@ -51,7 +52,7 @@ var PartitionState_name = map[int32]string{
var PartitionState_value = map[string]int32{
"NotExist": 0,
"NotPresent": 1,
"OnDist": 2,
"OnDisk": 2,
"PartialInMemory": 3,
"InMemory": 4,
"PartialInGPU": 5,
@ -1127,143 +1128,49 @@ func (m *ReleaseSegmentRequest) GetFieldIDs() []int64 {
return nil
}
type GetTimeTickChannelResponse struct {
Status *commonpb.Status `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
TimeTickChannelID string `protobuf:"bytes,2,opt,name=time_tick_channelID,json=timeTickChannelID,proto3" json:"time_tick_channelID,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *GetTimeTickChannelResponse) Reset() { *m = GetTimeTickChannelResponse{} }
func (m *GetTimeTickChannelResponse) String() string { return proto.CompactTextString(m) }
func (*GetTimeTickChannelResponse) ProtoMessage() {}
func (*GetTimeTickChannelResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_5fcb6756dc1afb8d, []int{19}
}
func (m *GetTimeTickChannelResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetTimeTickChannelResponse.Unmarshal(m, b)
}
func (m *GetTimeTickChannelResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_GetTimeTickChannelResponse.Marshal(b, m, deterministic)
}
func (m *GetTimeTickChannelResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_GetTimeTickChannelResponse.Merge(m, src)
}
func (m *GetTimeTickChannelResponse) XXX_Size() int {
return xxx_messageInfo_GetTimeTickChannelResponse.Size(m)
}
func (m *GetTimeTickChannelResponse) XXX_DiscardUnknown() {
xxx_messageInfo_GetTimeTickChannelResponse.DiscardUnknown(m)
}
var xxx_messageInfo_GetTimeTickChannelResponse proto.InternalMessageInfo
func (m *GetTimeTickChannelResponse) GetStatus() *commonpb.Status {
if m != nil {
return m.Status
}
return nil
}
func (m *GetTimeTickChannelResponse) GetTimeTickChannelID() string {
if m != nil {
return m.TimeTickChannelID
}
return ""
}
type GetStatsChannelResponse struct {
Status *commonpb.Status `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
StatsChannelID string `protobuf:"bytes,2,opt,name=stats_channelID,json=statsChannelID,proto3" json:"stats_channelID,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *GetStatsChannelResponse) Reset() { *m = GetStatsChannelResponse{} }
func (m *GetStatsChannelResponse) String() string { return proto.CompactTextString(m) }
func (*GetStatsChannelResponse) ProtoMessage() {}
func (*GetStatsChannelResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_5fcb6756dc1afb8d, []int{20}
}
func (m *GetStatsChannelResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetStatsChannelResponse.Unmarshal(m, b)
}
func (m *GetStatsChannelResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_GetStatsChannelResponse.Marshal(b, m, deterministic)
}
func (m *GetStatsChannelResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_GetStatsChannelResponse.Merge(m, src)
}
func (m *GetStatsChannelResponse) XXX_Size() int {
return xxx_messageInfo_GetStatsChannelResponse.Size(m)
}
func (m *GetStatsChannelResponse) XXX_DiscardUnknown() {
xxx_messageInfo_GetStatsChannelResponse.DiscardUnknown(m)
}
var xxx_messageInfo_GetStatsChannelResponse proto.InternalMessageInfo
func (m *GetStatsChannelResponse) GetStatus() *commonpb.Status {
if m != nil {
return m.Status
}
return nil
}
func (m *GetStatsChannelResponse) GetStatsChannelID() string {
if m != nil {
return m.StatsChannelID
}
return ""
}
type ServiceStatesResponse struct {
type ComponentStatesResponse struct {
Status *commonpb.Status `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
ServerStates *internalpb2.ComponentStates `protobuf:"bytes,2,opt,name=server_states,json=serverStates,proto3" json:"server_states,omitempty"`
States *internalpb2.ComponentStates `protobuf:"bytes,2,opt,name=states,proto3" json:"states,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ServiceStatesResponse) Reset() { *m = ServiceStatesResponse{} }
func (m *ServiceStatesResponse) String() string { return proto.CompactTextString(m) }
func (*ServiceStatesResponse) ProtoMessage() {}
func (*ServiceStatesResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_5fcb6756dc1afb8d, []int{21}
func (m *ComponentStatesResponse) Reset() { *m = ComponentStatesResponse{} }
func (m *ComponentStatesResponse) String() string { return proto.CompactTextString(m) }
func (*ComponentStatesResponse) ProtoMessage() {}
func (*ComponentStatesResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_5fcb6756dc1afb8d, []int{19}
}
func (m *ServiceStatesResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ServiceStatesResponse.Unmarshal(m, b)
func (m *ComponentStatesResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ComponentStatesResponse.Unmarshal(m, b)
}
func (m *ServiceStatesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ServiceStatesResponse.Marshal(b, m, deterministic)
func (m *ComponentStatesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ComponentStatesResponse.Marshal(b, m, deterministic)
}
func (m *ServiceStatesResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_ServiceStatesResponse.Merge(m, src)
func (m *ComponentStatesResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_ComponentStatesResponse.Merge(m, src)
}
func (m *ServiceStatesResponse) XXX_Size() int {
return xxx_messageInfo_ServiceStatesResponse.Size(m)
func (m *ComponentStatesResponse) XXX_Size() int {
return xxx_messageInfo_ComponentStatesResponse.Size(m)
}
func (m *ServiceStatesResponse) XXX_DiscardUnknown() {
xxx_messageInfo_ServiceStatesResponse.DiscardUnknown(m)
func (m *ComponentStatesResponse) XXX_DiscardUnknown() {
xxx_messageInfo_ComponentStatesResponse.DiscardUnknown(m)
}
var xxx_messageInfo_ServiceStatesResponse proto.InternalMessageInfo
var xxx_messageInfo_ComponentStatesResponse proto.InternalMessageInfo
func (m *ServiceStatesResponse) GetStatus() *commonpb.Status {
func (m *ComponentStatesResponse) GetStatus() *commonpb.Status {
if m != nil {
return m.Status
}
return nil
}
func (m *ServiceStatesResponse) GetServerStates() *internalpb2.ComponentStates {
func (m *ComponentStatesResponse) GetStates() *internalpb2.ComponentStates {
if m != nil {
return m.ServerStates
return m.States
}
return nil
}
@ -1289,89 +1196,84 @@ func init() {
proto.RegisterType((*WatchDmChannelsRequest)(nil), "milvus.proto.query.WatchDmChannelsRequest")
proto.RegisterType((*LoadSegmentRequest)(nil), "milvus.proto.query.LoadSegmentRequest")
proto.RegisterType((*ReleaseSegmentRequest)(nil), "milvus.proto.query.ReleaseSegmentRequest")
proto.RegisterType((*GetTimeTickChannelResponse)(nil), "milvus.proto.query.GetTimeTickChannelResponse")
proto.RegisterType((*GetStatsChannelResponse)(nil), "milvus.proto.query.GetStatsChannelResponse")
proto.RegisterType((*ServiceStatesResponse)(nil), "milvus.proto.query.ServiceStatesResponse")
proto.RegisterType((*ComponentStatesResponse)(nil), "milvus.proto.query.ComponentStatesResponse")
}
func init() { proto.RegisterFile("query_service.proto", fileDescriptor_5fcb6756dc1afb8d) }
var fileDescriptor_5fcb6756dc1afb8d = []byte{
// 1172 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x57, 0xdd, 0x6e, 0x1b, 0x45,
0x14, 0xf6, 0xc6, 0x8e, 0xa9, 0x4f, 0x1c, 0xdb, 0x99, 0xfc, 0x6a, 0x41, 0x55, 0x19, 0xa0, 0xcd,
0x0f, 0x38, 0x28, 0x95, 0x10, 0x77, 0x28, 0x89, 0xab, 0xc8, 0x82, 0x86, 0xb0, 0x69, 0x85, 0x08,
0x8d, 0xcc, 0x7a, 0x77, 0x48, 0xa6, 0xdd, 0x1f, 0x77, 0x67, 0x9c, 0x92, 0xdc, 0x40, 0x11, 0xf7,
0x5c, 0x73, 0x89, 0x40, 0x20, 0xf1, 0x04, 0xbc, 0x0b, 0xdc, 0xf0, 0x26, 0x68, 0x67, 0xd6, 0x9b,
0xdd, 0xf5, 0x38, 0x76, 0xea, 0xb4, 0x81, 0xbb, 0x9d, 0xd9, 0x33, 0xe7, 0xfb, 0xce, 0x99, 0x39,
0x67, 0xbe, 0x81, 0xd9, 0xa7, 0x5d, 0x12, 0x9c, 0xb6, 0x18, 0x09, 0x4e, 0xa8, 0x45, 0xea, 0x9d,
0xc0, 0xe7, 0x3e, 0x42, 0x2e, 0x75, 0x4e, 0xba, 0x4c, 0x8e, 0xea, 0xc2, 0x42, 0x2f, 0x5b, 0xbe,
0xeb, 0xfa, 0x9e, 0x9c, 0xd3, 0x2b, 0xd4, 0xe3, 0x24, 0xf0, 0x4c, 0x47, 0x8e, 0xf1, 0xb7, 0x30,
0x6b, 0x90, 0x23, 0xca, 0x38, 0x09, 0x76, 0x7d, 0x9b, 0x18, 0xe4, 0x69, 0x97, 0x30, 0x8e, 0xde,
0x87, 0x42, 0xdb, 0x64, 0x64, 0x49, 0xbb, 0xa5, 0x2d, 0x4f, 0x6d, 0xbc, 0x51, 0x4f, 0xf9, 0x8d,
0x1c, 0xde, 0x67, 0x47, 0x5b, 0x26, 0x23, 0x86, 0xb0, 0x44, 0x1f, 0xc0, 0x6b, 0xa6, 0x6d, 0x07,
0x84, 0xb1, 0xa5, 0x89, 0x0b, 0x16, 0x6d, 0x4a, 0x1b, 0xa3, 0x67, 0x8c, 0x7f, 0xd4, 0x60, 0x2e,
0xcd, 0x80, 0x75, 0x7c, 0x8f, 0x11, 0x74, 0x17, 0x8a, 0x8c, 0x9b, 0xbc, 0xcb, 0x22, 0x12, 0xaf,
0x2b, 0xfd, 0xed, 0x0b, 0x13, 0x23, 0x32, 0x45, 0x5b, 0x30, 0x45, 0x3d, 0xca, 0x5b, 0x1d, 0x33,
0x30, 0xdd, 0x1e, 0x93, 0x37, 0xd3, 0x2b, 0xe3, 0x0c, 0x34, 0x3d, 0xca, 0xf7, 0x84, 0xa1, 0x01,
0x34, 0xfe, 0xc6, 0x87, 0x30, 0xbf, 0x7f, 0xec, 0x3f, 0xdb, 0xf6, 0x1d, 0x87, 0x58, 0x9c, 0xfa,
0xde, 0x8b, 0x27, 0x05, 0x41, 0xc1, 0x6e, 0x37, 0x1b, 0x82, 0x47, 0xde, 0x10, 0xdf, 0x98, 0xc1,
0x42, 0xd6, 0xfd, 0x38, 0x11, 0xbf, 0x0d, 0xd3, 0x56, 0xec, 0xaa, 0xd9, 0x08, 0x63, 0xce, 0x2f,
0xe7, 0x8d, 0xf4, 0x24, 0x7e, 0xae, 0xc1, 0xfc, 0x27, 0xbe, 0x69, 0xbf, 0xa4, 0xa0, 0x10, 0x86,
0x72, 0x12, 0x70, 0x29, 0x2f, 0xfe, 0xa5, 0xe6, 0xf0, 0x0f, 0x1a, 0x2c, 0x19, 0xc4, 0x21, 0x26,
0x23, 0xd7, 0x49, 0xe3, 0x3b, 0x0d, 0xe6, 0xc2, 0x0d, 0xd8, 0x33, 0x03, 0x4e, 0xaf, 0x87, 0x42,
0x47, 0x9e, 0xb0, 0x04, 0x83, 0x71, 0x4e, 0x00, 0x86, 0x72, 0xa7, 0xe7, 0xe9, 0xfc, 0x00, 0xa4,
0xe6, 0xb0, 0x0b, 0xd5, 0x18, 0x2d, 0x5c, 0x4e, 0x18, 0xba, 0x05, 0x53, 0x09, 0x13, 0x01, 0x98,
0x37, 0x92, 0x53, 0xe8, 0x43, 0x98, 0x0c, 0x21, 0x88, 0x88, 0xaf, 0xb2, 0x81, 0xeb, 0xfd, 0xdd,
0xa5, 0x9e, 0xf6, 0x6a, 0xc8, 0x05, 0xf8, 0x37, 0x0d, 0x16, 0x32, 0x78, 0xaf, 0x3c, 0xcb, 0x7d,
0x79, 0x29, 0x28, 0xf2, 0xf2, 0x87, 0x06, 0x8b, 0x7d, 0x44, 0xc7, 0xd9, 0x8c, 0x03, 0x58, 0x88,
0x01, 0x5a, 0x36, 0x61, 0x56, 0x40, 0x3b, 0xe1, 0xb7, 0xdc, 0x96, 0xa9, 0x8d, 0xb7, 0x86, 0x27,
0x91, 0x19, 0xf3, 0xb1, 0x8b, 0x46, 0xc2, 0x03, 0xfe, 0x55, 0x83, 0xb9, 0xb0, 0x88, 0xaf, 0xef,
0xe4, 0x8e, 0x94, 0xd3, 0xdf, 0x35, 0x58, 0x8c, 0xea, 0xfc, 0x3f, 0xce, 0xf4, 0x67, 0x0d, 0xf4,
0xed, 0x80, 0x98, 0x9c, 0x7c, 0x16, 0xee, 0xc3, 0xf6, 0xb1, 0xe9, 0x79, 0xc4, 0x19, 0xef, 0x00,
0xdc, 0x81, 0x6a, 0x20, 0x83, 0x6d, 0x59, 0xd2, 0x9f, 0xa0, 0x5e, 0x32, 0x2a, 0xd1, 0x74, 0x84,
0x82, 0xde, 0x81, 0x4a, 0x40, 0x58, 0xd7, 0x39, 0xb7, 0xcb, 0x0b, 0xbb, 0x69, 0x39, 0x1b, 0x99,
0xe1, 0x5f, 0x34, 0x58, 0xdc, 0xb4, 0xed, 0x24, 0xc1, 0x31, 0x6a, 0x69, 0x0d, 0x66, 0x32, 0xec,
0xa2, 0xd4, 0x96, 0x8c, 0x5a, 0x9a, 0x5f, 0xb3, 0x81, 0x56, 0xa0, 0x96, 0x66, 0x18, 0xa5, 0xba,
0x64, 0x54, 0x53, 0x1c, 0x9b, 0x0d, 0xfc, 0x97, 0x06, 0xba, 0x41, 0x5c, 0xff, 0x84, 0x28, 0x89,
0xbe, 0x50, 0x26, 0x7b, 0xd1, 0x4d, 0x8c, 0x17, 0x5d, 0xfe, 0x12, 0xd1, 0x15, 0xd4, 0xd1, 0x3d,
0x86, 0x85, 0xcf, 0x4d, 0x6e, 0x1d, 0x37, 0xdc, 0xf1, 0x77, 0xe0, 0x26, 0x40, 0x8c, 0x27, 0x9b,
0x42, 0xc9, 0x48, 0xcc, 0xe0, 0xbf, 0x35, 0x40, 0x61, 0x91, 0xef, 0x93, 0x23, 0x97, 0x78, 0xfc,
0xd5, 0x17, 0x4e, 0xe6, 0x5e, 0x28, 0xf4, 0xdf, 0x0b, 0x37, 0x01, 0x98, 0x64, 0x17, 0x86, 0x30,
0x29, 0x0a, 0x2b, 0x31, 0x83, 0x74, 0xb8, 0xf1, 0x35, 0x25, 0x8e, 0x1d, 0xfe, 0x2d, 0x8a, 0xbf,
0xf1, 0x18, 0xff, 0xa3, 0xc1, 0x7c, 0xd4, 0x1c, 0xae, 0x2d, 0xc2, 0x11, 0x5a, 0xc3, 0x58, 0x31,
0x3e, 0xd7, 0x40, 0xdf, 0x21, 0xfc, 0x01, 0x75, 0xc9, 0x03, 0x6a, 0x3d, 0xb9, 0x92, 0xb6, 0x52,
0x87, 0x59, 0x4e, 0x5d, 0xd2, 0xe2, 0xd4, 0x7a, 0xd2, 0x57, 0xba, 0x33, 0x3c, 0x0d, 0xd5, 0x6c,
0xe0, 0x67, 0xb0, 0xb8, 0x43, 0x78, 0xe8, 0x84, 0x5d, 0x55, 0x5b, 0x0b, 0xbf, 0x58, 0x1f, 0x76,
0x85, 0x25, 0x30, 0x9a, 0x0d, 0xfc, 0x93, 0x06, 0xf3, 0xfb, 0xf2, 0x51, 0x72, 0x15, 0xf7, 0xe9,
0xc7, 0x30, 0x1d, 0x3e, 0x71, 0x48, 0xd0, 0x12, 0xca, 0xa2, 0x27, 0xe9, 0x6f, 0x0f, 0x90, 0xf4,
0xdb, 0xbe, 0xdb, 0xf1, 0x3d, 0xe2, 0xf1, 0x08, 0xbb, 0x2c, 0x17, 0xcb, 0xd1, 0xea, 0x19, 0x54,
0xd2, 0x57, 0x2d, 0x2a, 0xc3, 0x8d, 0x5d, 0x9f, 0xdf, 0xfb, 0x86, 0x32, 0x5e, 0xcb, 0xa1, 0x0a,
0xc0, 0xae, 0xcf, 0xf7, 0x02, 0xc2, 0x88, 0xc7, 0x6b, 0x1a, 0x02, 0x28, 0x7e, 0xea, 0x35, 0xc2,
0x7f, 0x13, 0x68, 0x36, 0x52, 0x50, 0xa6, 0xd3, 0xf4, 0xee, 0x13, 0xd7, 0x0f, 0x4e, 0x6b, 0xf9,
0x70, 0x79, 0x3c, 0x2a, 0xa0, 0x1a, 0x94, 0x63, 0x93, 0x9d, 0xbd, 0x87, 0xb5, 0x49, 0x54, 0x82,
0x49, 0xf9, 0x59, 0xdc, 0xf8, 0xb3, 0x04, 0x65, 0xd1, 0x1b, 0xa3, 0xe4, 0x20, 0x0b, 0xca, 0xc9,
0x77, 0x0f, 0xba, 0xa3, 0x52, 0x06, 0x8a, 0xb7, 0x99, 0xbe, 0x3c, 0xdc, 0x50, 0x66, 0x1c, 0xe7,
0xd0, 0x63, 0xa8, 0xa6, 0x1f, 0x1b, 0x0c, 0xad, 0xa8, 0x96, 0x2b, 0x1f, 0x3c, 0xfa, 0xea, 0x28,
0xa6, 0x31, 0xd6, 0x11, 0x54, 0x52, 0xaa, 0x96, 0xa1, 0xe5, 0x41, 0xeb, 0xb3, 0xba, 0x40, 0x5f,
0x19, 0xc1, 0x32, 0x06, 0xfa, 0x02, 0x2a, 0x29, 0x19, 0x34, 0x00, 0x48, 0x25, 0x95, 0xf4, 0x8b,
0x0e, 0x1d, 0xce, 0xa1, 0x16, 0xcc, 0x64, 0xa5, 0x0b, 0x43, 0x6b, 0xea, 0x84, 0x2b, 0x15, 0xce,
0x30, 0x80, 0x03, 0xc9, 0xfd, 0x3c, 0x81, 0xea, 0xfd, 0x50, 0xbe, 0xd5, 0x86, 0xf9, 0xfe, 0x2a,
0x26, 0x9f, 0x70, 0xff, 0xee, 0x05, 0xe4, 0x2f, 0x8d, 0xd0, 0x06, 0xd4, 0xaf, 0x97, 0x90, 0xae,
0x5c, 0x74, 0xcf, 0xed, 0xf0, 0x53, 0xbd, 0xae, 0x82, 0x1f, 0xac, 0xb9, 0x24, 0x46, 0x7f, 0xf3,
0xbc, 0x3c, 0xc6, 0xe0, 0x06, 0x8c, 0x73, 0xe8, 0x11, 0x54, 0x33, 0xdd, 0xf1, 0x42, 0x80, 0xb5,
0x01, 0x00, 0xaa, 0xf6, 0x8a, 0x73, 0xc8, 0x17, 0x11, 0x64, 0xdf, 0x5b, 0xab, 0xa3, 0x28, 0xff,
0x68, 0x1b, 0xd6, 0x46, 0xb2, 0x8d, 0x01, 0x0f, 0x05, 0x60, 0xa6, 0xf7, 0x5d, 0x18, 0x91, 0xba,
0xde, 0x54, 0x6d, 0x1b, 0xe7, 0x36, 0xbe, 0x2f, 0x42, 0x49, 0x6c, 0x96, 0xe8, 0x53, 0xff, 0xff,
0xfd, 0x79, 0xb9, 0xe9, 0x42, 0x87, 0x50, 0xcd, 0x08, 0x76, 0x75, 0x07, 0x19, 0xa0, 0xea, 0x87,
0xd5, 0xa0, 0x05, 0xa8, 0x5f, 0x69, 0xa3, 0xba, 0xba, 0xcc, 0x07, 0x29, 0xf2, 0x61, 0x20, 0x8f,
0xa0, 0x9a, 0x51, 0xbc, 0xea, 0xf3, 0xab, 0x96, 0xc5, 0xc3, 0xbc, 0x3f, 0x84, 0x72, 0x42, 0xe2,
0x32, 0x74, 0x7b, 0x50, 0x0b, 0x4c, 0x4b, 0xc4, 0x61, 0x6e, 0xbf, 0x84, 0x6a, 0x5a, 0x5a, 0x0e,
0xb8, 0xec, 0x94, 0xfa, 0x73, 0x88, 0xf3, 0xad, 0xcd, 0x83, 0x8f, 0x8e, 0x28, 0x3f, 0xee, 0xb6,
0xc3, 0x3f, 0xeb, 0x67, 0xd4, 0x71, 0xe8, 0x19, 0x27, 0xd6, 0xf1, 0xba, 0x5c, 0xf5, 0x9e, 0x4d,
0x19, 0x0f, 0x68, 0xbb, 0xcb, 0x89, 0xbd, 0xde, 0x93, 0x23, 0xeb, 0xc2, 0xd5, 0xba, 0x40, 0xed,
0xb4, 0xdb, 0x45, 0x31, 0xbc, 0xfb, 0x6f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x88, 0x5d, 0xc7, 0x98,
0xbb, 0x15, 0x00, 0x00,
// 1132 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x57, 0x5d, 0x6f, 0x1b, 0x45,
0x17, 0xf6, 0xc6, 0x1f, 0x6f, 0x7d, 0xe2, 0xda, 0xee, 0xe4, 0x53, 0xfb, 0xa2, 0xaa, 0x0c, 0xd0,
0xe6, 0x03, 0x6c, 0xe4, 0x4a, 0x88, 0x2b, 0x50, 0x12, 0x57, 0x91, 0x25, 0x1a, 0xc2, 0x3a, 0x55,
0x45, 0xa0, 0x32, 0xeb, 0xdd, 0xc1, 0x9e, 0x76, 0x3f, 0xdc, 0x9d, 0x71, 0x20, 0xb9, 0x01, 0x24,
0xae, 0xe1, 0x37, 0x20, 0x10, 0x48, 0x88, 0x7f, 0x04, 0x37, 0xfc, 0x04, 0xfe, 0x01, 0xda, 0xd9,
0xf5, 0x66, 0x77, 0x3d, 0x8e, 0xdd, 0x3a, 0x69, 0xb8, 0xdb, 0x9d, 0x3d, 0xe7, 0x3c, 0xcf, 0x39,
0x33, 0x73, 0xce, 0xb3, 0xb0, 0xf4, 0x7c, 0x48, 0xbc, 0xd3, 0x0e, 0x23, 0xde, 0x09, 0x35, 0x48,
0x6d, 0xe0, 0xb9, 0xdc, 0x45, 0xc8, 0xa6, 0xd6, 0xc9, 0x90, 0x05, 0x6f, 0x35, 0x61, 0xa1, 0x96,
0x0c, 0xd7, 0xb6, 0x5d, 0x27, 0x58, 0x53, 0x4b, 0x71, 0x0b, 0xb5, 0x4c, 0x1d, 0x4e, 0x3c, 0x47,
0xb7, 0x82, 0x77, 0xfc, 0x0d, 0x2c, 0x69, 0xa4, 0x47, 0x19, 0x27, 0xde, 0x81, 0x6b, 0x12, 0x8d,
0x3c, 0x1f, 0x12, 0xc6, 0xd1, 0xbb, 0x90, 0xeb, 0xea, 0x8c, 0xac, 0x2b, 0x77, 0x94, 0x8d, 0xc5,
0xc6, 0x6b, 0xb5, 0x04, 0x4a, 0x18, 0xfe, 0x21, 0xeb, 0xed, 0xea, 0x8c, 0x68, 0xc2, 0x12, 0xbd,
0x07, 0xff, 0xd3, 0x4d, 0xd3, 0x23, 0x8c, 0xad, 0x2f, 0x5c, 0xe0, 0xb4, 0x13, 0xd8, 0x68, 0x23,
0x63, 0xfc, 0xa3, 0x02, 0xcb, 0x49, 0x06, 0x6c, 0xe0, 0x3a, 0x8c, 0xa0, 0xfb, 0x50, 0x60, 0x5c,
0xe7, 0x43, 0x16, 0x92, 0xf8, 0xbf, 0x34, 0x5e, 0x5b, 0x98, 0x68, 0xa1, 0x29, 0xda, 0x85, 0x45,
0xea, 0x50, 0xde, 0x19, 0xe8, 0x9e, 0x6e, 0x8f, 0x98, 0xbc, 0x9e, 0xf4, 0x8c, 0x2a, 0xd0, 0x72,
0x28, 0x3f, 0x14, 0x86, 0x1a, 0xd0, 0xe8, 0x19, 0x3f, 0x81, 0x95, 0x76, 0xdf, 0xfd, 0x6a, 0xcf,
0xb5, 0x2c, 0x62, 0x70, 0xea, 0x3a, 0x2f, 0x5f, 0x14, 0x04, 0x39, 0xb3, 0xdb, 0x6a, 0x0a, 0x1e,
0x59, 0x4d, 0x3c, 0x63, 0x06, 0xab, 0xe9, 0xf0, 0xf3, 0x64, 0xfc, 0x26, 0xdc, 0x34, 0xa2, 0x50,
0xad, 0xa6, 0x9f, 0x73, 0x76, 0x23, 0xab, 0x25, 0x17, 0xf1, 0x77, 0x0a, 0xac, 0x7c, 0xe4, 0xea,
0xe6, 0x15, 0x25, 0x85, 0x30, 0x94, 0xe2, 0x80, 0xeb, 0x59, 0xf1, 0x2d, 0xb1, 0x86, 0xbf, 0x57,
0x60, 0x5d, 0x23, 0x16, 0xd1, 0x19, 0xb9, 0x4e, 0x1a, 0xdf, 0x2a, 0xb0, 0xec, 0x6f, 0xc0, 0xa1,
0xee, 0x71, 0x7a, 0x3d, 0x14, 0x06, 0xc1, 0x09, 0x8b, 0x31, 0x98, 0xe7, 0x04, 0x60, 0x28, 0x0d,
0x46, 0x91, 0xce, 0x0f, 0x40, 0x62, 0x0d, 0xdb, 0x50, 0x89, 0xd0, 0x7c, 0x77, 0xc2, 0xd0, 0x1d,
0x58, 0x8c, 0x99, 0x08, 0xc0, 0xac, 0x16, 0x5f, 0x42, 0xef, 0x43, 0xde, 0x87, 0x20, 0x22, 0xbf,
0x72, 0x03, 0xd7, 0xc6, 0x7b, 0x4d, 0x2d, 0x19, 0x55, 0x0b, 0x1c, 0xf0, 0xaf, 0x0a, 0xac, 0xa6,
0xf0, 0x5e, 0x79, 0x95, 0xc7, 0xea, 0x92, 0x93, 0xd4, 0xe5, 0x77, 0x05, 0xd6, 0xc6, 0x88, 0xce,
0xb3, 0x19, 0xc7, 0xb0, 0x1a, 0x01, 0x74, 0x4c, 0xc2, 0x0c, 0x8f, 0x0e, 0xfc, 0xe7, 0x60, 0x5b,
0x16, 0x1b, 0x6f, 0x4c, 0x2f, 0x22, 0xd3, 0x56, 0xa2, 0x10, 0xcd, 0x58, 0x04, 0xfc, 0x8b, 0x02,
0xcb, 0xfe, 0x25, 0xbe, 0xbe, 0x93, 0x3b, 0x53, 0x4d, 0x7f, 0x53, 0x60, 0x2d, 0xbc, 0xe7, 0xff,
0x71, 0xa6, 0x3f, 0x29, 0xa0, 0xee, 0x79, 0x44, 0xe7, 0xe4, 0x13, 0x7f, 0x1f, 0xf6, 0xfa, 0xba,
0xe3, 0x10, 0x6b, 0xbe, 0x03, 0x70, 0x0f, 0x2a, 0x5e, 0x90, 0x6c, 0xc7, 0x08, 0xe2, 0x09, 0xea,
0x45, 0xad, 0x1c, 0x2e, 0x87, 0x28, 0xe8, 0x2d, 0x28, 0x7b, 0x84, 0x0d, 0xad, 0x73, 0xbb, 0xac,
0xb0, 0xbb, 0x19, 0xac, 0x86, 0x66, 0xf8, 0x67, 0x05, 0xd6, 0x76, 0x4c, 0x33, 0x4e, 0x70, 0x8e,
0xbb, 0xb4, 0x0d, 0xb7, 0x52, 0xec, 0xc2, 0xd2, 0x16, 0xb5, 0x6a, 0x92, 0x5f, 0xab, 0x89, 0x36,
0xa1, 0x9a, 0x64, 0x18, 0x96, 0xba, 0xa8, 0x55, 0x12, 0x1c, 0x5b, 0x4d, 0xfc, 0xa7, 0x02, 0xaa,
0x46, 0x6c, 0xf7, 0x84, 0x48, 0x89, 0xbe, 0x54, 0x25, 0x47, 0xd9, 0x2d, 0xcc, 0x97, 0x5d, 0xf6,
0x05, 0xb2, 0xcb, 0xc9, 0xb3, 0x7b, 0x0a, 0xab, 0x8f, 0x75, 0x6e, 0xf4, 0x9b, 0xf6, 0xfc, 0x3b,
0x70, 0x1b, 0x20, 0xc2, 0x0b, 0x9a, 0x42, 0x51, 0x8b, 0xad, 0xe0, 0xbf, 0x14, 0x40, 0xfe, 0x25,
0x6f, 0x93, 0x9e, 0x4d, 0x1c, 0xfe, 0xea, 0x2f, 0x4e, 0x6a, 0x2e, 0xe4, 0xc6, 0xe7, 0xc2, 0x6d,
0x00, 0x16, 0xb0, 0xf3, 0x53, 0xc8, 0x8b, 0x8b, 0x15, 0x5b, 0x41, 0x2a, 0xdc, 0xf8, 0x92, 0x12,
0xcb, 0xf4, 0xbf, 0x16, 0xc4, 0xd7, 0xe8, 0x1d, 0xff, 0xad, 0xc0, 0x4a, 0xd8, 0x1c, 0xae, 0x2d,
0xc3, 0x19, 0x5a, 0xc3, 0x5c, 0x39, 0xfe, 0xa0, 0xc0, 0xda, 0x9e, 0x6b, 0x0f, 0x5c, 0x87, 0x38,
0xfc, 0x32, 0x86, 0xca, 0x07, 0x81, 0x13, 0x19, 0x09, 0xda, 0xbb, 0x13, 0x04, 0x6d, 0x1a, 0x34,
0xf4, 0xda, 0x3a, 0x83, 0x72, 0x72, 0xc4, 0xa0, 0x12, 0xdc, 0x38, 0x70, 0xf9, 0x83, 0xaf, 0x29,
0xe3, 0xd5, 0x0c, 0x2a, 0x03, 0x1c, 0xb8, 0xfc, 0xd0, 0x23, 0x8c, 0x38, 0xbc, 0xaa, 0x20, 0x80,
0xc2, 0xc7, 0x4e, 0x93, 0xb2, 0x67, 0xd5, 0x05, 0xb4, 0x14, 0x2a, 0x07, 0xdd, 0x6a, 0x39, 0x0f,
0x89, 0xed, 0x7a, 0xa7, 0xd5, 0xac, 0xef, 0x1e, 0xbd, 0xe5, 0x50, 0x15, 0x4a, 0x91, 0xc9, 0xfe,
0xe1, 0xa3, 0x6a, 0x1e, 0x15, 0x21, 0x1f, 0x3c, 0x16, 0x1a, 0x7f, 0x14, 0xa1, 0x24, 0x7a, 0x42,
0x3b, 0xf8, 0x6f, 0x41, 0x06, 0x94, 0xe2, 0x7a, 0x1f, 0xdd, 0x93, 0x4d, 0x44, 0xc9, 0x3f, 0x89,
0xba, 0x31, 0xdd, 0x30, 0x28, 0x32, 0xce, 0xa0, 0xa7, 0x50, 0x49, 0x8a, 0x6c, 0x86, 0x36, 0x65,
0xee, 0x52, 0xa1, 0xaf, 0x6e, 0xcd, 0x62, 0x1a, 0x61, 0xf5, 0xa0, 0x9c, 0x50, 0x73, 0x0c, 0x6d,
0x4c, 0xf2, 0x4f, 0xcf, 0x43, 0x75, 0x73, 0x06, 0xcb, 0x08, 0xe8, 0x53, 0x28, 0x27, 0xc6, 0xff,
0x04, 0x20, 0x99, 0x44, 0x50, 0x2f, 0x3a, 0x67, 0x38, 0x83, 0x3a, 0x70, 0x2b, 0x3d, 0xb2, 0x19,
0xda, 0x96, 0x17, 0x5c, 0x3a, 0xd9, 0xa7, 0x01, 0x1c, 0x07, 0xdc, 0xcf, 0x0b, 0x28, 0xdf, 0x0f,
0xe9, 0x3f, 0xca, 0xb4, 0xd8, 0x5f, 0x44, 0xe4, 0x63, 0xe1, 0xdf, 0xbe, 0x80, 0xfc, 0x0b, 0x23,
0x74, 0x01, 0x8d, 0xeb, 0x04, 0xa4, 0x4a, 0x9d, 0x1e, 0xd8, 0x03, 0x7e, 0xaa, 0xd6, 0x64, 0xf0,
0x93, 0xb5, 0x06, 0xce, 0xa0, 0xc7, 0x80, 0xf6, 0x09, 0x3f, 0xa2, 0x36, 0x39, 0xa2, 0xc6, 0xb3,
0x59, 0x30, 0x52, 0x5a, 0x32, 0x7c, 0x69, 0x73, 0x8f, 0x3a, 0xbd, 0xc4, 0xb1, 0x59, 0xde, 0x27,
0xa2, 0x25, 0x50, 0xc6, 0xa9, 0xc1, 0x2e, 0x31, 0xb4, 0x2b, 0x38, 0xa7, 0xff, 0x2c, 0xb6, 0x66,
0xd1, 0xb8, 0x61, 0xe1, 0xb7, 0x67, 0xb2, 0x8d, 0x00, 0x3b, 0x02, 0x30, 0xd5, 0xe7, 0x2e, 0xcc,
0x44, 0x0a, 0x30, 0xa1, 0x3b, 0xe3, 0x4c, 0xe3, 0x9f, 0x3c, 0x14, 0xc5, 0x06, 0x89, 0xde, 0x74,
0x65, 0x7b, 0x72, 0x04, 0x95, 0x70, 0x4f, 0x2e, 0x73, 0x3b, 0xae, 0xba, 0x3a, 0xe8, 0x09, 0x54,
0x52, 0x5a, 0x54, 0xde, 0x24, 0x26, 0x08, 0xd6, 0x69, 0xd7, 0xcc, 0x00, 0x34, 0x2e, 0x22, 0x51,
0x4d, 0x7e, 0x93, 0x27, 0x89, 0xcd, 0x69, 0x20, 0x9f, 0x43, 0x25, 0x25, 0xe6, 0xe4, 0x07, 0x56,
0xae, 0xf8, 0xa6, 0x45, 0x7f, 0x04, 0xa5, 0x98, 0x7a, 0x63, 0xe8, 0xee, 0xa4, 0x2e, 0x97, 0x54,
0x3f, 0xd3, 0xc2, 0x7e, 0x06, 0x95, 0xa4, 0x6a, 0x9a, 0x30, 0xcf, 0xa4, 0xd2, 0x6a, 0x4a, 0xf0,
0xdd, 0x9d, 0xe3, 0x0f, 0x7b, 0x94, 0xf7, 0x87, 0x5d, 0xff, 0x4b, 0xfd, 0x8c, 0x5a, 0x16, 0x3d,
0xe3, 0xc4, 0xe8, 0xd7, 0x03, 0xaf, 0x77, 0x4c, 0xca, 0xb8, 0x47, 0xbb, 0x43, 0x4e, 0xcc, 0xfa,
0x48, 0x6b, 0xd4, 0x45, 0xa8, 0xba, 0x40, 0x1d, 0x74, 0xbb, 0x05, 0xf1, 0x7a, 0xff, 0xdf, 0x00,
0x00, 0x00, 0xff, 0xff, 0xd0, 0xb8, 0x9f, 0xe3, 0xa4, 0x14, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
@ -1394,10 +1296,10 @@ type QueryServiceClient interface {
LoadCollection(ctx context.Context, in *LoadCollectionRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
ReleaseCollection(ctx context.Context, in *ReleaseCollectionRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
CreateQueryChannel(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*CreateQueryChannelResponse, error)
GetTimeTickChannel(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*GetTimeTickChannelResponse, error)
GetStatsChannel(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*GetStatsChannelResponse, 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)
GetPartitionStates(ctx context.Context, in *PartitionStatesRequest, opts ...grpc.CallOption) (*PartitionStatesResponse, error)
GetComponentStates(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*ServiceStatesResponse, error)
GetComponentStates(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*ComponentStatesResponse, error)
}
type queryServiceClient struct {
@ -1480,8 +1382,8 @@ func (c *queryServiceClient) CreateQueryChannel(ctx context.Context, in *commonp
return out, nil
}
func (c *queryServiceClient) GetTimeTickChannel(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*GetTimeTickChannelResponse, error) {
out := new(GetTimeTickChannelResponse)
func (c *queryServiceClient) GetTimeTickChannel(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*milvuspb.StringResponse, error) {
out := new(milvuspb.StringResponse)
err := c.cc.Invoke(ctx, "/milvus.proto.query.QueryService/GetTimeTickChannel", in, out, opts...)
if err != nil {
return nil, err
@ -1489,9 +1391,9 @@ func (c *queryServiceClient) GetTimeTickChannel(ctx context.Context, in *commonp
return out, nil
}
func (c *queryServiceClient) GetStatsChannel(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*GetStatsChannelResponse, error) {
out := new(GetStatsChannelResponse)
err := c.cc.Invoke(ctx, "/milvus.proto.query.QueryService/GetStatsChannel", in, out, opts...)
func (c *queryServiceClient) GetStatisticsChannel(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*milvuspb.StringResponse, error) {
out := new(milvuspb.StringResponse)
err := c.cc.Invoke(ctx, "/milvus.proto.query.QueryService/GetStatisticsChannel", in, out, opts...)
if err != nil {
return nil, err
}
@ -1507,8 +1409,8 @@ func (c *queryServiceClient) GetPartitionStates(ctx context.Context, in *Partiti
return out, nil
}
func (c *queryServiceClient) GetComponentStates(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*ServiceStatesResponse, error) {
out := new(ServiceStatesResponse)
func (c *queryServiceClient) GetComponentStates(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*ComponentStatesResponse, error) {
out := new(ComponentStatesResponse)
err := c.cc.Invoke(ctx, "/milvus.proto.query.QueryService/GetComponentStates", in, out, opts...)
if err != nil {
return nil, err
@ -1526,10 +1428,10 @@ type QueryServiceServer interface {
LoadCollection(context.Context, *LoadCollectionRequest) (*commonpb.Status, error)
ReleaseCollection(context.Context, *ReleaseCollectionRequest) (*commonpb.Status, error)
CreateQueryChannel(context.Context, *commonpb.Empty) (*CreateQueryChannelResponse, error)
GetTimeTickChannel(context.Context, *commonpb.Empty) (*GetTimeTickChannelResponse, error)
GetStatsChannel(context.Context, *commonpb.Empty) (*GetStatsChannelResponse, error)
GetTimeTickChannel(context.Context, *commonpb.Empty) (*milvuspb.StringResponse, error)
GetStatisticsChannel(context.Context, *commonpb.Empty) (*milvuspb.StringResponse, error)
GetPartitionStates(context.Context, *PartitionStatesRequest) (*PartitionStatesResponse, error)
GetComponentStates(context.Context, *commonpb.Empty) (*ServiceStatesResponse, error)
GetComponentStates(context.Context, *commonpb.Empty) (*ComponentStatesResponse, error)
}
// UnimplementedQueryServiceServer can be embedded to have forward compatible implementations.
@ -1560,16 +1462,16 @@ func (*UnimplementedQueryServiceServer) ReleaseCollection(ctx context.Context, r
func (*UnimplementedQueryServiceServer) CreateQueryChannel(ctx context.Context, req *commonpb.Empty) (*CreateQueryChannelResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method CreateQueryChannel not implemented")
}
func (*UnimplementedQueryServiceServer) GetTimeTickChannel(ctx context.Context, req *commonpb.Empty) (*GetTimeTickChannelResponse, error) {
func (*UnimplementedQueryServiceServer) GetTimeTickChannel(ctx context.Context, req *commonpb.Empty) (*milvuspb.StringResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetTimeTickChannel not implemented")
}
func (*UnimplementedQueryServiceServer) GetStatsChannel(ctx context.Context, req *commonpb.Empty) (*GetStatsChannelResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetStatsChannel not implemented")
func (*UnimplementedQueryServiceServer) GetStatisticsChannel(ctx context.Context, req *commonpb.Empty) (*milvuspb.StringResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetStatisticsChannel not implemented")
}
func (*UnimplementedQueryServiceServer) GetPartitionStates(ctx context.Context, req *PartitionStatesRequest) (*PartitionStatesResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetPartitionStates not implemented")
}
func (*UnimplementedQueryServiceServer) GetComponentStates(ctx context.Context, req *commonpb.Empty) (*ServiceStatesResponse, error) {
func (*UnimplementedQueryServiceServer) GetComponentStates(ctx context.Context, req *commonpb.Empty) (*ComponentStatesResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetComponentStates not implemented")
}
@ -1739,20 +1641,20 @@ func _QueryService_GetTimeTickChannel_Handler(srv interface{}, ctx context.Conte
return interceptor(ctx, in, info, handler)
}
func _QueryService_GetStatsChannel_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
func _QueryService_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.(QueryServiceServer).GetStatsChannel(ctx, in)
return srv.(QueryServiceServer).GetStatisticsChannel(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/milvus.proto.query.QueryService/GetStatsChannel",
FullMethod: "/milvus.proto.query.QueryService/GetStatisticsChannel",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(QueryServiceServer).GetStatsChannel(ctx, req.(*commonpb.Empty))
return srv.(QueryServiceServer).GetStatisticsChannel(ctx, req.(*commonpb.Empty))
}
return interceptor(ctx, in, info, handler)
}
@ -1834,8 +1736,8 @@ var _QueryService_serviceDesc = grpc.ServiceDesc{
Handler: _QueryService_GetTimeTickChannel_Handler,
},
{
MethodName: "GetStatsChannel",
Handler: _QueryService_GetStatsChannel_Handler,
MethodName: "GetStatisticsChannel",
Handler: _QueryService_GetStatisticsChannel_Handler,
},
{
MethodName: "GetPartitionStates",
@ -1854,9 +1756,9 @@ var _QueryService_serviceDesc = grpc.ServiceDesc{
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type QueryNodeClient interface {
GetTimeTickChannel(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*GetTimeTickChannelResponse, error)
GetStatsChannel(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*GetStatsChannelResponse, error)
GetComponentStates(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*ServiceStatesResponse, error)
GetTimeTickChannel(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*milvuspb.StringResponse, error)
GetStatsChannel(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*milvuspb.StringResponse, error)
GetComponentStates(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*ComponentStatesResponse, error)
AddQueryChannel(ctx context.Context, in *AddQueryChannelsRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
RemoveQueryChannel(ctx context.Context, in *RemoveQueryChannelsRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
WatchDmChannels(ctx context.Context, in *WatchDmChannelsRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
@ -1872,8 +1774,8 @@ func NewQueryNodeClient(cc *grpc.ClientConn) QueryNodeClient {
return &queryNodeClient{cc}
}
func (c *queryNodeClient) GetTimeTickChannel(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*GetTimeTickChannelResponse, error) {
out := new(GetTimeTickChannelResponse)
func (c *queryNodeClient) GetTimeTickChannel(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*milvuspb.StringResponse, error) {
out := new(milvuspb.StringResponse)
err := c.cc.Invoke(ctx, "/milvus.proto.query.QueryNode/GetTimeTickChannel", in, out, opts...)
if err != nil {
return nil, err
@ -1881,8 +1783,8 @@ func (c *queryNodeClient) GetTimeTickChannel(ctx context.Context, in *commonpb.E
return out, nil
}
func (c *queryNodeClient) GetStatsChannel(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*GetStatsChannelResponse, error) {
out := new(GetStatsChannelResponse)
func (c *queryNodeClient) GetStatsChannel(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*milvuspb.StringResponse, error) {
out := new(milvuspb.StringResponse)
err := c.cc.Invoke(ctx, "/milvus.proto.query.QueryNode/GetStatsChannel", in, out, opts...)
if err != nil {
return nil, err
@ -1890,8 +1792,8 @@ func (c *queryNodeClient) GetStatsChannel(ctx context.Context, in *commonpb.Empt
return out, nil
}
func (c *queryNodeClient) GetComponentStates(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*ServiceStatesResponse, error) {
out := new(ServiceStatesResponse)
func (c *queryNodeClient) GetComponentStates(ctx context.Context, in *commonpb.Empty, opts ...grpc.CallOption) (*ComponentStatesResponse, error) {
out := new(ComponentStatesResponse)
err := c.cc.Invoke(ctx, "/milvus.proto.query.QueryNode/GetComponentStates", in, out, opts...)
if err != nil {
return nil, err
@ -1946,9 +1848,9 @@ func (c *queryNodeClient) ReleaseSegments(ctx context.Context, in *ReleaseSegmen
// QueryNodeServer is the server API for QueryNode service.
type QueryNodeServer interface {
GetTimeTickChannel(context.Context, *commonpb.Empty) (*GetTimeTickChannelResponse, error)
GetStatsChannel(context.Context, *commonpb.Empty) (*GetStatsChannelResponse, error)
GetComponentStates(context.Context, *commonpb.Empty) (*ServiceStatesResponse, error)
GetTimeTickChannel(context.Context, *commonpb.Empty) (*milvuspb.StringResponse, error)
GetStatsChannel(context.Context, *commonpb.Empty) (*milvuspb.StringResponse, error)
GetComponentStates(context.Context, *commonpb.Empty) (*ComponentStatesResponse, error)
AddQueryChannel(context.Context, *AddQueryChannelsRequest) (*commonpb.Status, error)
RemoveQueryChannel(context.Context, *RemoveQueryChannelsRequest) (*commonpb.Status, error)
WatchDmChannels(context.Context, *WatchDmChannelsRequest) (*commonpb.Status, error)
@ -1960,13 +1862,13 @@ type QueryNodeServer interface {
type UnimplementedQueryNodeServer struct {
}
func (*UnimplementedQueryNodeServer) GetTimeTickChannel(ctx context.Context, req *commonpb.Empty) (*GetTimeTickChannelResponse, error) {
func (*UnimplementedQueryNodeServer) GetTimeTickChannel(ctx context.Context, req *commonpb.Empty) (*milvuspb.StringResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetTimeTickChannel not implemented")
}
func (*UnimplementedQueryNodeServer) GetStatsChannel(ctx context.Context, req *commonpb.Empty) (*GetStatsChannelResponse, error) {
func (*UnimplementedQueryNodeServer) GetStatsChannel(ctx context.Context, req *commonpb.Empty) (*milvuspb.StringResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetStatsChannel not implemented")
}
func (*UnimplementedQueryNodeServer) GetComponentStates(ctx context.Context, req *commonpb.Empty) (*ServiceStatesResponse, error) {
func (*UnimplementedQueryNodeServer) GetComponentStates(ctx context.Context, req *commonpb.Empty) (*ComponentStatesResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetComponentStates not implemented")
}
func (*UnimplementedQueryNodeServer) AddQueryChannel(ctx context.Context, req *AddQueryChannelsRequest) (*commonpb.Status, error) {

18
internal/querynode/query_node.go
View File

@ -27,21 +27,11 @@ import (
"github.com/zilliztech/milvus-distributed/internal/proto/commonpb"
"github.com/zilliztech/milvus-distributed/internal/proto/internalpb2"
queryPb "github.com/zilliztech/milvus-distributed/internal/proto/querypb"
queryserviceimpl "github.com/zilliztech/milvus-distributed/internal/queryservice"
"github.com/zilliztech/milvus-distributed/internal/util/typeutil"
)
type Node interface {
GetComponentStates() (*internalpb2.ComponentStates, error)
GetTimeTickChannel() (string, error)
GetStatisticsChannel() (string, error)
AddQueryChannel(in *queryPb.AddQueryChannelsRequest) (*commonpb.Status, error)
RemoveQueryChannel(in *queryPb.RemoveQueryChannelsRequest) (*commonpb.Status, error)
WatchDmChannels(in *queryPb.WatchDmChannelsRequest) (*commonpb.Status, error)
LoadSegments(in *queryPb.LoadSegmentRequest) (*commonpb.Status, error)
ReleaseSegments(in *queryPb.ReleaseSegmentRequest) (*commonpb.Status, error)
}
type Node = typeutil.QueryNodeInterface
type QueryService = typeutil.QueryServiceInterface
type QueryNode struct {
typeutil.Service
@ -117,13 +107,13 @@ func Init() {
}
func (node *QueryNode) Init() error {
registerReq := queryPb.RegisterNodeRequest{
registerReq := &queryPb.RegisterNodeRequest{
Address: &commonpb.Address{
Ip: Params.QueryNodeIP,
Port: Params.QueryNodePort,
},
}
var client queryserviceimpl.Interface // TODO: init interface
var client QueryService // TODO: init interface
response, err := client.RegisterNode(registerReq)
if err != nil {
panic(err)

6
internal/queryservice/collection.go Normal file
View File

@ -0,0 +1,6 @@
package queryservice
type collection struct {
id UniqueID
partitions []*partition
}

43
internal/queryservice/collection_replica.go Normal file
View File

@ -0,0 +1,43 @@
package queryservice
import "github.com/zilliztech/milvus-distributed/internal/errors"
type metaReplica interface {
getCollectionIDs(id UniqueID) ([]UniqueID, error)
getPartitionIDs(dbID UniqueID, collectionID UniqueID) ([]UniqueID, error)
}
type metaReplicaImpl struct {
dbID []UniqueID
db2collections map[UniqueID][]*collection
}
func (mp *metaReplicaImpl) getCollectionIDs(dbID UniqueID) ([]UniqueID, error) {
if collections, ok := mp.db2collections[dbID]; ok {
collectionIDs := make([]UniqueID, 0)
for _, collection := range collections {
collectionIDs = append(collectionIDs, collection.id)
}
return collectionIDs, nil
}
return nil, errors.New("can't find collection in queryService")
}
func (mp *metaReplicaImpl) getPartitionIDs(dbID UniqueID, collectionID UniqueID) ([]UniqueID, error) {
if collections, ok := mp.db2collections[dbID]; ok {
for _, collection := range collections {
if collectionID == collection.id {
partitions := collection.partitions
partitionIDs := make([]UniqueID, 0)
for _, partition := range partitions {
partitionIDs = append(partitionIDs, partition.id)
}
return partitionIDs, nil
}
}
}
return nil, errors.New("can't find partitions in queryService")
}

22
internal/queryservice/interface.go
View File

@ -1,22 +0,0 @@
package queryserviceimpl
import (
"github.com/zilliztech/milvus-distributed/internal/proto/querypb"
"github.com/zilliztech/milvus-distributed/internal/util/typeutil"
)
type ServiceBase = typeutil.Component
type Interface interface {
ServiceBase
RegisterNode(req querypb.RegisterNodeRequest) (querypb.RegisterNodeResponse, error)
ShowCollections(req querypb.ShowCollectionRequest) (querypb.ShowCollectionResponse, error)
LoadCollection(req querypb.LoadCollectionRequest) error
ReleaseCollection(req querypb.ReleaseCollectionRequest) error
ShowPartitions(req querypb.ShowPartitionRequest) (querypb.ShowPartitionResponse, error)
LoadPartitions(req querypb.LoadPartitionRequest) error
ReleasePartitions(req querypb.ReleasePartitionRequest) error
CreateQueryChannel() (querypb.CreateQueryChannelResponse, error)
GetPartitionStates(req querypb.PartitionStatesRequest) (querypb.PartitionStatesResponse, error)
}

507
internal/queryservice/param_table.go Normal file
View File

@ -0,0 +1,507 @@
package queryservice
import (
"log"
"os"
"strconv"
"github.com/zilliztech/milvus-distributed/internal/util/paramtable"
"github.com/zilliztech/milvus-distributed/internal/util/typeutil"
)
type UniqueID = typeutil.UniqueID
type ParamTable struct {
paramtable.BaseTable
Distributed bool
Address string
Port int
MasterServiceAddress string
PulsarAddress string
ETCDAddress string
MetaRootPath string
QueryServiceID UniqueID
QueryNodeID UniqueID
QueryNodeNum int
FlowGraphMaxQueueLength int32
FlowGraphMaxParallelism int32
// minio
MinioEndPoint string
MinioAccessKeyID string
MinioSecretAccessKey string
MinioUseSSLStr bool
MinioBucketName string
// dm
InsertChannelNames []string
InsertChannelRange []int
InsertReceiveBufSize int64
InsertPulsarBufSize int64
// dd
DDChannelNames []string
DDReceiveBufSize int64
DDPulsarBufSize int64
// search
SearchChannelNames []string
SearchResultChannelNames []string
SearchReceiveBufSize int64
SearchPulsarBufSize int64
SearchResultReceiveBufSize int64
// stats
StatsPublishInterval int
StatsChannelName string
StatsReceiveBufSize int64
// load index
LoadIndexChannelNames []string
LoadIndexReceiveBufSize int64
LoadIndexPulsarBufSize int64
// timetick
TimeTickChannelName string
TimeTickReceiveBufferSize int64
GracefulTime int64
MsgChannelSubName string
DefaultPartitionTag string
SliceIndex int
}
var Params ParamTable
func (p *ParamTable) Init() {
p.BaseTable.Init()
err := p.LoadYaml("advanced/query_node.yaml")
if err != nil {
panic(err)
}
err = p.LoadYaml("milvus.yaml")
if err != nil {
panic(err)
}
queryNodeIDStr := os.Getenv("QUERY_NODE_ID")
if queryNodeIDStr == "" {
queryNodeIDList := p.QueryNodeIDList()
if len(queryNodeIDList) <= 0 {
queryNodeIDStr = "0"
} else {
queryNodeIDStr = strconv.Itoa(int(queryNodeIDList[0]))
}
}
err = p.LoadYaml("advanced/common.yaml")
if err != nil {
panic(err)
}
err = p.Save("_queryNodeID", queryNodeIDStr)
if err != nil {
panic(err)
}
p.initMinioEndPoint()
p.initMinioAccessKeyID()
p.initMinioSecretAccessKey()
p.initMinioUseSSLStr()
p.initMinioBucketName()
p.initPulsarAddress()
p.initETCDAddress()
p.initMetaRootPath()
p.initQueryNodeID()
p.initQueryNodeNum()
p.initGracefulTime()
p.initMsgChannelSubName()
p.initDefaultPartitionTag()
p.initSliceIndex()
p.initFlowGraphMaxQueueLength()
p.initFlowGraphMaxParallelism()
p.initInsertChannelNames()
p.initInsertChannelRange()
p.initInsertReceiveBufSize()
p.initInsertPulsarBufSize()
p.initDDChannelNames()
p.initDDReceiveBufSize()
p.initDDPulsarBufSize()
p.initSearchChannelNames()
p.initSearchResultChannelNames()
p.initSearchReceiveBufSize()
p.initSearchPulsarBufSize()
p.initSearchResultReceiveBufSize()
p.initStatsPublishInterval()
p.initStatsChannelName()
p.initStatsReceiveBufSize()
p.initLoadIndexChannelNames()
p.initLoadIndexReceiveBufSize()
p.initLoadIndexPulsarBufSize()
p.initTimeTickChannelName()
p.initTimeTickReceiveBufSize()
p.initAddress()
p.initPort()
p.initMasterServiceAddress()
p.initIsDistributed()
}
func (p *ParamTable) initMinioEndPoint() {
url, err := p.Load("_MinioAddress")
if err != nil {
panic(err)
}
p.MinioEndPoint = url
}
func (p *ParamTable) initMinioAccessKeyID() {
id, err := p.Load("minio.accessKeyID")
if err != nil {
panic(err)
}
p.MinioAccessKeyID = id
}
func (p *ParamTable) initMinioSecretAccessKey() {
key, err := p.Load("minio.secretAccessKey")
if err != nil {
panic(err)
}
p.MinioSecretAccessKey = key
}
func (p *ParamTable) initMinioUseSSLStr() {
ssl, err := p.Load("minio.useSSL")
if err != nil {
panic(err)
}
sslBoolean, err := strconv.ParseBool(ssl)
if err != nil {
panic(err)
}
p.MinioUseSSLStr = sslBoolean
}
func (p *ParamTable) initMinioBucketName() {
bucketName, err := p.Load("minio.bucketName")
if err != nil {
panic(err)
}
p.MinioBucketName = bucketName
}
func (p *ParamTable) initPulsarAddress() {
url, err := p.Load("_PulsarAddress")
if err != nil {
panic(err)
}
p.PulsarAddress = url
}
func (p *ParamTable) initMasterServiceAddress() {
url, err := p.Load("_MasterAddress")
if err != nil {
panic(err)
}
p.MasterServiceAddress = url
}
func (p *ParamTable) initQueryNodeID() {
queryNodeID, err := p.Load("_queryNodeID")
if err != nil {
panic(err)
}
id, err := strconv.Atoi(queryNodeID)
if err != nil {
panic(err)
}
p.QueryNodeID = UniqueID(id)
}
func (p *ParamTable) initInsertChannelRange() {
insertChannelRange, err := p.Load("msgChannel.channelRange.insert")
if err != nil {
panic(err)
}
p.InsertChannelRange = paramtable.ConvertRangeToIntRange(insertChannelRange, ",")
}
// advanced params
// stats
func (p *ParamTable) initStatsPublishInterval() {
p.StatsPublishInterval = p.ParseInt("queryNode.stats.publishInterval")
}
// dataSync:
func (p *ParamTable) initFlowGraphMaxQueueLength() {
p.FlowGraphMaxQueueLength = p.ParseInt32("queryNode.dataSync.flowGraph.maxQueueLength")
}
func (p *ParamTable) initFlowGraphMaxParallelism() {
p.FlowGraphMaxParallelism = p.ParseInt32("queryNode.dataSync.flowGraph.maxParallelism")
}
// msgStream
func (p *ParamTable) initInsertReceiveBufSize() {
p.InsertReceiveBufSize = p.ParseInt64("queryNode.msgStream.insert.recvBufSize")
}
func (p *ParamTable) initInsertPulsarBufSize() {
p.InsertPulsarBufSize = p.ParseInt64("queryNode.msgStream.insert.pulsarBufSize")
}
func (p *ParamTable) initDDReceiveBufSize() {
revBufSize, err := p.Load("queryNode.msgStream.dataDefinition.recvBufSize")
if err != nil {
panic(err)
}
bufSize, err := strconv.Atoi(revBufSize)
if err != nil {
panic(err)
}
p.DDReceiveBufSize = int64(bufSize)
}
func (p *ParamTable) initDDPulsarBufSize() {
pulsarBufSize, err := p.Load("queryNode.msgStream.dataDefinition.pulsarBufSize")
if err != nil {
panic(err)
}
bufSize, err := strconv.Atoi(pulsarBufSize)
if err != nil {
panic(err)
}
p.DDPulsarBufSize = int64(bufSize)
}
func (p *ParamTable) initSearchReceiveBufSize() {
p.SearchReceiveBufSize = p.ParseInt64("queryNode.msgStream.search.recvBufSize")
}
func (p *ParamTable) initSearchPulsarBufSize() {
p.SearchPulsarBufSize = p.ParseInt64("queryNode.msgStream.search.pulsarBufSize")
}
func (p *ParamTable) initSearchResultReceiveBufSize() {
p.SearchResultReceiveBufSize = p.ParseInt64("queryNode.msgStream.searchResult.recvBufSize")
}
func (p *ParamTable) initStatsReceiveBufSize() {
p.StatsReceiveBufSize = p.ParseInt64("queryNode.msgStream.stats.recvBufSize")
}
func (p *ParamTable) initETCDAddress() {
ETCDAddress, err := p.Load("_EtcdAddress")
if err != nil {
panic(err)
}
p.ETCDAddress = ETCDAddress
}
func (p *ParamTable) initMetaRootPath() {
rootPath, err := p.Load("etcd.rootPath")
if err != nil {
panic(err)
}
subPath, err := p.Load("etcd.metaSubPath")
if err != nil {
panic(err)
}
p.MetaRootPath = rootPath + "/" + subPath
}
func (p *ParamTable) initGracefulTime() {
p.GracefulTime = p.ParseInt64("queryNode.gracefulTime")
}
func (p *ParamTable) initInsertChannelNames() {
prefix, err := p.Load("msgChannel.chanNamePrefix.insert")
if err != nil {
log.Fatal(err)
}
prefix += "-"
channelRange, err := p.Load("msgChannel.channelRange.insert")
if err != nil {
panic(err)
}
channelIDs := paramtable.ConvertRangeToIntSlice(channelRange, ",")
var ret []string
for _, ID := range channelIDs {
ret = append(ret, prefix+strconv.Itoa(ID))
}
sep := len(channelIDs) / p.QueryNodeNum
index := p.SliceIndex
if index == -1 {
panic("queryNodeID not Match with Config")
}
start := index * sep
p.InsertChannelNames = ret[start : start+sep]
}
func (p *ParamTable) initSearchChannelNames() {
prefix, err := p.Load("msgChannel.chanNamePrefix.search")
if err != nil {
log.Fatal(err)
}
prefix += "-"
channelRange, err := p.Load("msgChannel.channelRange.search")
if err != nil {
panic(err)
}
channelIDs := paramtable.ConvertRangeToIntSlice(channelRange, ",")
var ret []string
for _, ID := range channelIDs {
ret = append(ret, prefix+strconv.Itoa(ID))
}
p.SearchChannelNames = ret
}
func (p *ParamTable) initSearchResultChannelNames() {
prefix, err := p.Load("msgChannel.chanNamePrefix.searchResult")
if err != nil {
log.Fatal(err)
}
prefix += "-"
channelRange, err := p.Load("msgChannel.channelRange.searchResult")
if err != nil {
panic(err)
}
channelIDs := paramtable.ConvertRangeToIntSlice(channelRange, ",")
var ret []string
for _, ID := range channelIDs {
ret = append(ret, prefix+strconv.Itoa(ID))
}
p.SearchResultChannelNames = ret
}
func (p *ParamTable) initMsgChannelSubName() {
// TODO: subName = namePrefix + "-" + queryNodeID, queryNodeID is assigned by master
name, err := p.Load("msgChannel.subNamePrefix.queryNodeSubNamePrefix")
if err != nil {
log.Panic(err)
}
queryNodeIDStr, err := p.Load("_QueryNodeID")
if err != nil {
panic(err)
}
p.MsgChannelSubName = name + "-" + queryNodeIDStr
}
func (p *ParamTable) initStatsChannelName() {
channels, err := p.Load("msgChannel.chanNamePrefix.queryNodeStats")
if err != nil {
panic(err)
}
p.StatsChannelName = channels
}
func (p *ParamTable) initDDChannelNames() {
prefix, err := p.Load("msgChannel.chanNamePrefix.dataDefinition")
if err != nil {
panic(err)
}
prefix += "-"
iRangeStr, err := p.Load("msgChannel.channelRange.dataDefinition")
if err != nil {
panic(err)
}
channelIDs := paramtable.ConvertRangeToIntSlice(iRangeStr, ",")
var ret []string
for _, ID := range channelIDs {
ret = append(ret, prefix+strconv.Itoa(ID))
}
p.DDChannelNames = ret
}
func (p *ParamTable) initDefaultPartitionTag() {
defaultTag, err := p.Load("common.defaultPartitionTag")
if err != nil {
panic(err)
}
p.DefaultPartitionTag = defaultTag
}
func (p *ParamTable) initSliceIndex() {
queryNodeID := p.QueryNodeID
queryNodeIDList := p.QueryNodeIDList()
for i := 0; i < len(queryNodeIDList); i++ {
if queryNodeID == queryNodeIDList[i] {
p.SliceIndex = i
return
}
}
p.SliceIndex = -1
}
func (p *ParamTable) initQueryNodeNum() {
p.QueryNodeNum = len(p.QueryNodeIDList())
}
func (p *ParamTable) initLoadIndexChannelNames() {
loadIndexChannelName, err := p.Load("msgChannel.chanNamePrefix.cmd")
if err != nil {
panic(err)
}
p.LoadIndexChannelNames = []string{loadIndexChannelName}
}
func (p *ParamTable) initLoadIndexReceiveBufSize() {
p.LoadIndexReceiveBufSize = p.ParseInt64("queryNode.msgStream.loadIndex.recvBufSize")
}
func (p *ParamTable) initLoadIndexPulsarBufSize() {
p.LoadIndexPulsarBufSize = p.ParseInt64("queryNode.msgStream.loadIndex.pulsarBufSize")
}
func (p *ParamTable) initTimeTickChannelName() {
timeTickChannelName, err := p.Load("msgChannel.chanNamePrefix.queryTimeTick")
if err != nil {
panic(err)
}
p.TimeTickChannelName = timeTickChannelName
}
func (p *ParamTable) initTimeTickReceiveBufSize() {
p.TimeTickReceiveBufferSize = p.ParseInt64("queryNode.msgStream.timeTick.recvBufSize")
}
func (p *ParamTable) initIsDistributed() {
p.Distributed = false
}
func (p *ParamTable) initAddress() {
url, err := p.Load("_QueryServiceAddress")
if err != nil {
panic(err)
}
p.Address = url
}
func (p *ParamTable) initPort() {
p.Port = p.ParseInt("queryService.port")
}

6
internal/queryservice/partition.go Normal file
View File

@ -0,0 +1,6 @@
package queryservice
type partition struct {
id UniqueID
segments []*segment
}

202
internal/queryservice/queryservice.go
View File

@ -1,71 +1,215 @@
package queryserviceimpl
package queryservice
import (
"context"
"log"
"strconv"
"sync/atomic"
"time"
"github.com/zilliztech/milvus-distributed/internal/distributed/masterservice"
grpcquerynodeclient "github.com/zilliztech/milvus-distributed/internal/distributed/querynode/client"
"github.com/zilliztech/milvus-distributed/internal/errors"
"github.com/zilliztech/milvus-distributed/internal/proto/commonpb"
"github.com/zilliztech/milvus-distributed/internal/proto/internalpb2"
"github.com/zilliztech/milvus-distributed/internal/proto/querypb"
"github.com/zilliztech/milvus-distributed/internal/querynode"
"github.com/zilliztech/milvus-distributed/internal/util/typeutil"
)
type Interface = typeutil.QueryServiceInterface
type QueryService struct {
loopCtx context.Context
loopCancel context.CancelFunc
QueryServiceID uint64
replica metaReplica
// type(masterServiceClient) should be interface
// masterServiceClient masterService.Service
masterServiceClient *masterservice.GrpcClient
queryNodeClient map[int]querynode.Node
numQueryNode int
numQueryChannel int
stateCode atomic.Value
isInit atomic.Value
}
type InitParams struct {
Distributed bool
}
//serverBase interface
func (qs *QueryService) Init() error {
panic("implement me")
if Params.Distributed {
var err error
//TODO:: alter 2*second
qs.masterServiceClient, err = masterservice.NewGrpcClient(Params.MasterServiceAddress, 2*time.Second)
if err != nil {
return err
}
} else {
//TODO:: create masterService.Core{}
log.Fatal(errors.New("should not use grpc client"))
}
qs.isInit.Store(true)
return nil
}
func (qs *QueryService) InitParams(params *InitParams) {
Params.Distributed = params.Distributed
}
func (qs *QueryService) Start() error {
panic("implement me")
isInit := qs.isInit.Load().(bool)
if !isInit {
return errors.New("call start before init")
}
qs.stateCode.Store(internalpb2.StateCode_HEALTHY)
return nil
}
func (qs *QueryService) Stop() error {
panic("implement me")
qs.loopCancel()
qs.stateCode.Store(internalpb2.StateCode_ABNORMAL)
return nil
}
func (qs *QueryService) GetComponentStates() (*internalpb2.ComponentStates, error) {
panic("implement me")
serviceComponentInfo := &internalpb2.ComponentInfo{
NodeID: Params.QueryServiceID,
StateCode: qs.stateCode.Load().(internalpb2.StateCode),
}
subComponentInfos := make([]*internalpb2.ComponentInfo, 0)
for nodeID, nodeClient := range qs.queryNodeClient {
componentStates, err := nodeClient.GetComponentStates()
if err != nil {
subComponentInfos = append(subComponentInfos, &internalpb2.ComponentInfo{
NodeID: int64(nodeID),
StateCode: internalpb2.StateCode_ABNORMAL,
})
continue
}
subComponentInfos = append(subComponentInfos, componentStates.State)
}
return &internalpb2.ComponentStates{
State: serviceComponentInfo,
SubcomponentStates: subComponentInfos,
}, nil
}
func (qs *QueryService) GetTimeTickChannel() (string, error) {
panic("implement me")
return Params.TimeTickChannelName, nil
}
func (qs *QueryService) GetStatisticsChannel() (string, error) {
return Params.StatsChannelName, nil
}
func (qs *QueryService) RegisterNode(req *querypb.RegisterNodeRequest) (*querypb.RegisterNodeResponse, error) {
allocatedID := qs.numQueryNode
qs.numQueryNode++
registerNodeAddress := req.Address.Ip + ":" + strconv.FormatInt(req.Address.Port, 10)
var client querynode.Node
if Params.Distributed {
client = grpcquerynodeclient.NewClient(registerNodeAddress)
} else {
log.Fatal(errors.New("should be queryNodeImpl.QueryNode"))
}
qs.queryNodeClient[allocatedID] = client
return &querypb.RegisterNodeResponse{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_SUCCESS,
},
InitParams: &internalpb2.InitParams{
NodeID: int64(allocatedID),
},
}, nil
}
func (qs *QueryService) ShowCollections(req *querypb.ShowCollectionRequest) (*querypb.ShowCollectionResponse, error) {
dbID := req.DbID
collectionIDs, err := qs.replica.getCollectionIDs(dbID)
if err != nil {
return nil, err
}
return &querypb.ShowCollectionResponse{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_SUCCESS,
},
CollectionIDs: collectionIDs,
}, nil
}
func (qs *QueryService) LoadCollection(req *querypb.LoadCollectionRequest) (*commonpb.Status, error) {
panic("implement me")
}
//queryService interface
func (qs *QueryService) RegisterNode(req querypb.RegisterNodeRequest) (querypb.RegisterNodeResponse, error) {
func (qs *QueryService) ReleaseCollection(req *querypb.ReleaseCollectionRequest) (*commonpb.Status, error) {
panic("implement me")
}
func (qs *QueryService) ShowCollections(req querypb.ShowCollectionRequest) (querypb.ShowCollectionResponse, error) {
func (qs *QueryService) ShowPartitions(req *querypb.ShowPartitionRequest) (*querypb.ShowPartitionResponse, error) {
dbID := req.DbID
collectionID := req.CollectionID
partitionIDs, err := qs.replica.getPartitionIDs(dbID, collectionID)
if err != nil {
return nil, err
}
return &querypb.ShowPartitionResponse{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_SUCCESS,
},
PartitionIDs: partitionIDs,
}, nil
}
func (qs *QueryService) LoadPartitions(req *querypb.LoadPartitionRequest) (*commonpb.Status, error) {
panic("implement me")
}
func (qs *QueryService) LoadCollection(req querypb.LoadCollectionRequest) error {
func (qs *QueryService) ReleasePartitions(req *querypb.ReleasePartitionRequest) (*commonpb.Status, error) {
panic("implement me")
}
func (qs *QueryService) ReleaseCollection(req querypb.ReleaseCollectionRequest) error {
func (qs *QueryService) CreateQueryChannel() (*querypb.CreateQueryChannelResponse, error) {
channelID := qs.numQueryChannel
qs.numQueryChannel++
allocatedQueryChannel := "query-" + strconv.FormatInt(int64(channelID), 10)
allocatedQueryResultChannel := "queryResult-" + strconv.FormatInt(int64(channelID), 10)
return &querypb.CreateQueryChannelResponse{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_SUCCESS,
},
RequestChannel: allocatedQueryChannel,
ResultChannel: allocatedQueryResultChannel,
}, nil
}
func (qs *QueryService) GetPartitionStates(req *querypb.PartitionStatesRequest) (*querypb.PartitionStatesResponse, error) {
panic("implement me")
}
func (qs *QueryService) ShowPartitions(req querypb.ShowPartitionRequest) (querypb.ShowPartitionResponse, error) {
panic("implement me")
}
func (qs *QueryService) LoadPartitions(req querypb.LoadPartitionRequest) error {
panic("implement me")
}
func (qs *QueryService) ReleasePartitions(req querypb.ReleasePartitionRequest) error {
panic("implement me")
}
func (qs *QueryService) CreateQueryChannel() (querypb.CreateQueryChannelResponse, error) {
panic("implement me")
}
func (qs *QueryService) GetPartitionStates(req querypb.PartitionStatesRequest) (querypb.PartitionStatesResponse, error) {
panic("implement me")
func NewQueryService(ctx context.Context) (Interface, error) {
Params.Init()
nodeClients := make(map[int]querynode.Node)
ctx1, cancel := context.WithCancel(ctx)
service := &QueryService{
loopCtx: ctx1,
loopCancel: cancel,
numQueryNode: 0,
queryNodeClient: nodeClients,
numQueryChannel: 0,
}
service.stateCode.Store(internalpb2.StateCode_INITIALIZING)
service.isInit.Store(false)
return service, nil
}

5
internal/queryservice/segment.go Normal file
View File

@ -0,0 +1,5 @@
package queryservice
type segment struct {
id UniqueID
}

17
internal/util/paramtable/paramtable.go
View File

@ -161,6 +161,23 @@ func (gp *BaseTable) tryloadFromEnv() {
if err != nil {
panic(err)
}
queryServiceAddress := os.Getenv("QUERY_SERVICE_ADDRESS")
if queryServiceAddress == "" {
serviceHost, err := gp.Load("queryService.address")
if err != nil {
panic(err)
}
port, err := gp.Load("queryService.port")
if err != nil {
panic(err)
}
queryServiceAddress = serviceHost + ":" + port
}
err = gp.Save("_QueryServiceAddress", queryServiceAddress)
if err != nil {
panic(err)
}
}
func (gp *BaseTable) Load(key string) (string, error) {

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

@ -1,7 +1,9 @@
package typeutil
import (
"github.com/zilliztech/milvus-distributed/internal/proto/commonpb"
"github.com/zilliztech/milvus-distributed/internal/proto/internalpb2"
"github.com/zilliztech/milvus-distributed/internal/proto/querypb"
)
type Service interface {
@ -15,3 +17,28 @@ type Component interface {
GetTimeTickChannel() (string, error)
GetStatisticsChannel() (string, error)
}
type QueryServiceInterface interface {
Service
Component
RegisterNode(req *querypb.RegisterNodeRequest) (*querypb.RegisterNodeResponse, error)
ShowCollections(req *querypb.ShowCollectionRequest) (*querypb.ShowCollectionResponse, error)
LoadCollection(req *querypb.LoadCollectionRequest) (*commonpb.Status, error)
ReleaseCollection(req *querypb.ReleaseCollectionRequest) (*commonpb.Status, error)
ShowPartitions(req *querypb.ShowPartitionRequest) (*querypb.ShowPartitionResponse, error)
LoadPartitions(req *querypb.LoadPartitionRequest) (*commonpb.Status, error)
ReleasePartitions(req *querypb.ReleasePartitionRequest) (*commonpb.Status, error)
CreateQueryChannel() (*querypb.CreateQueryChannelResponse, error)
GetPartitionStates(req *querypb.PartitionStatesRequest) (*querypb.PartitionStatesResponse, error)
}
type QueryNodeInterface interface {
Component
AddQueryChannel(in *querypb.AddQueryChannelsRequest) (*commonpb.Status, error)
RemoveQueryChannel(in *querypb.RemoveQueryChannelsRequest) (*commonpb.Status, error)
WatchDmChannels(in *querypb.WatchDmChannelsRequest) (*commonpb.Status, error)
LoadSegments(in *querypb.LoadSegmentRequest) (*commonpb.Status, error)
ReleaseSegments(in *querypb.ReleaseSegmentRequest) (*commonpb.Status, error)
}