admin/milvus
1
0
Fork 0
mirror of https://gitee.com/milvus-io/milvus.git synced 2026-01-07 19:31:51 +08:00
Code Issues Packages Projects Releases Wiki Activity

Add query coord watch delta channel (#11218)

Browse Source 
Signed-off-by: godchen <qingxiang.chen@zilliz.com>
This commit is contained in:
godchen 2021-11-05 14:47:19 +08:00 committed by GitHub
parent 88c9067873
commit 09f8fa1040
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
23 changed files with 700 additions and 261 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -284,7 +284,7 @@ const char descriptor_table_protodef_common_2eproto[] PROTOBUF_SECTION_VARIABLE(
"ssued\020\001\022\016\n\nInProgress\020\002\022\014\n\010Finished\020\003\022\n\n"
"\006Failed\020\004*f\n\014SegmentState\022\024\n\020SegmentStat"
"eNone\020\000\022\014\n\010NotExist\020\001\022\013\n\007Growing\020\002\022\n\n\006Se"
"aled\020\003\022\013\n\007Flushed\020\004\022\014\n\010Flushing\020\005*\344\010\n\007Ms"
"aled\020\003\022\013\n\007Flushed\020\004\022\014\n\010Flushing\020\005*\375\010\n\007Ms"
"gType\022\r\n\tUndefined\020\000\022\024\n\020CreateCollection"
"\020d\022\022\n\016DropCollection\020e\022\021\n\rHasCollection\020"
"f\022\026\n\022DescribeCollection\020g\022\023\n\017ShowCollect"
@ -307,15 +307,16 @@ const char descriptor_table_protodef_common_2eproto[] PROTOBUF_SECTION_VARIABLE(
"eve\020\372\003\022\023\n\016RetrieveResult\020\373\003\022\024\n\017WatchDmCh"
"annels\020\374\003\022\025\n\020RemoveDmChannels\020\375\003\022\027\n\022Watc"
"hQueryChannels\020\376\003\022\030\n\023RemoveQueryChannels"
"\020\377\003\022\035\n\030SealedSegmentsChangeInfo\020\200\004\022\020\n\013Se"
"gmentInfo\020\330\004\022\017\n\nSystemInfo\020\331\004\022\r\n\010TimeTic"
"k\020\260\t\022\023\n\016QueryNodeStats\020\261\t\022\016\n\tLoadIndex\020\262"
"\t\022\016\n\tRequestID\020\263\t\022\017\n\nRequestTSO\020\264\t\022\024\n\017Al"
"locateSegment\020\265\t\022\026\n\021SegmentStatistics\020\266\t"
"\022\025\n\020SegmentFlushDone\020\267\t\022\017\n\nDataNodeTt\020\270\t"
"*\"\n\007DslType\022\007\n\003Dsl\020\000\022\016\n\nBoolExprV1\020\001B5Z3"
"github.com/milvus-io/milvus/internal/pro"
"to/commonpbb\006proto3"
"\020\377\003\022\035\n\030SealedSegmentsChangeInfo\020\200\004\022\027\n\022Wa"
"tchDeltaChannels\020\201\004\022\020\n\013SegmentInfo\020\330\004\022\017\n"
"\nSystemInfo\020\331\004\022\r\n\010TimeTick\020\260\t\022\023\n\016QueryNo"
"deStats\020\261\t\022\016\n\tLoadIndex\020\262\t\022\016\n\tRequestID\020"
"\263\t\022\017\n\nRequestTSO\020\264\t\022\024\n\017AllocateSegment\020\265"
"\t\022\026\n\021SegmentStatistics\020\266\t\022\025\n\020SegmentFlus"
"hDone\020\267\t\022\017\n\nDataNodeTt\020\270\t*\"\n\007DslType\022\007\n\003"
"Dsl\020\000\022\016\n\nBoolExprV1\020\001B5Z3github.com/milv"
"us-io/milvus/internal/proto/commonpbb\006pr"
"oto3"
;
static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_common_2eproto_deps[1] = {
};
@ -332,7 +333,7 @@ static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_com
static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_common_2eproto_once;
static bool descriptor_table_common_2eproto_initialized = false;
const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_common_2eproto = {
&descriptor_table_common_2eproto_initialized, descriptor_table_protodef_common_2eproto, "common.proto", 2499,
&descriptor_table_common_2eproto_initialized, descriptor_table_protodef_common_2eproto, "common.proto", 2524,
&descriptor_table_common_2eproto_once, descriptor_table_common_2eproto_sccs, descriptor_table_common_2eproto_deps, 8, 0,
schemas, file_default_instances, TableStruct_common_2eproto::offsets,
file_level_metadata_common_2eproto, 8, file_level_enum_descriptors_common_2eproto, file_level_service_descriptors_common_2eproto,
@ -467,6 +468,7 @@ bool MsgType_IsValid(int value) {
case 510:
case 511:
case 512:
case 513:
case 600:
case 601:
case 1200:

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

@ -251,6 +251,7 @@ enum MsgType : int {
WatchQueryChannels = 510,
RemoveQueryChannels = 511,
SealedSegmentsChangeInfo = 512,
WatchDeltaChannels = 513,
SegmentInfo = 600,
SystemInfo = 601,
TimeTick = 1200,

16
internal/distributed/querynode/client/client.go
View File

@ -289,6 +289,22 @@ func (c *Client) WatchDmChannels(ctx context.Context, req *querypb.WatchDmChanne
return ret.(*commonpb.Status), err
}
// WatchDeltaChannels watches the channels about data manipulation.
func (c *Client) WatchDeltaChannels(ctx context.Context, req *querypb.WatchDeltaChannelsRequest) (*commonpb.Status, error) {
ret, err := c.recall(func() (interface{}, error) {
client, err := c.getGrpcClient()
if err != nil {
return nil, err
}
return client.WatchDeltaChannels(ctx, req)
})
if err != nil || ret == nil {
return nil, err
}
return ret.(*commonpb.Status), err
}
// LoadSegments loads the segments to search.
func (c *Client) LoadSegments(ctx context.Context, req *querypb.LoadSegmentsRequest) (*commonpb.Status, error) {
ret, err := c.recall(func() (interface{}, error) {

7
internal/distributed/querynode/client/client_test.go
View File

@ -57,6 +57,10 @@ func (m *MockQueryNodeClient) WatchDmChannels(ctx context.Context, in *querypb.W
return &commonpb.Status{}, m.err
}
func (m *MockQueryNodeClient) WatchDeltaChannels(ctx context.Context, in *querypb.WatchDeltaChannelsRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
return &commonpb.Status{}, m.err
}
func (m *MockQueryNodeClient) LoadSegments(ctx context.Context, in *querypb.LoadSegmentsRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
return &commonpb.Status{}, m.err
}
@ -148,6 +152,9 @@ func Test_NewClient(t *testing.T) {
r12, err := client.GetMetrics(ctx, nil)
retCheck(retNotNil, r12, err)
r13, err := client.WatchDeltaChannels(ctx, nil)
retCheck(retNotNil, r13, err)
}
client.getGrpcClient = func() (querypb.QueryNodeClient, error) {

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

@ -308,6 +308,12 @@ func (s *Server) WatchDmChannels(ctx context.Context, req *querypb.WatchDmChanne
return s.querynode.WatchDmChannels(ctx, req)
}
// WatchDeltaChannels watches the channels about data manipulation.
func (s *Server) WatchDeltaChannels(ctx context.Context, req *querypb.WatchDeltaChannelsRequest) (*commonpb.Status, error) {
// ignore ctx
return s.querynode.WatchDeltaChannels(ctx, req)
}
// LoadSegments loads the segments to search.
func (s *Server) LoadSegments(ctx context.Context, req *querypb.LoadSegmentsRequest) (*commonpb.Status, error) {
// ignore ctx

4
internal/distributed/querynode/service_test.go
View File

@ -84,6 +84,10 @@ func (m *MockQueryNode) WatchDmChannels(ctx context.Context, req *querypb.WatchD
return m.status, m.err
}
func (m *MockQueryNode) WatchDeltaChannels(ctx context.Context, req *querypb.WatchDeltaChannelsRequest) (*commonpb.Status, error) {
return m.status, m.err
}
func (m *MockQueryNode) LoadSegments(ctx context.Context, req *querypb.LoadSegmentsRequest) (*commonpb.Status, error) {
return m.status, m.err
}

3
internal/proto/common.proto
View File

@ -134,6 +134,7 @@ enum MsgType {
WatchQueryChannels = 510;
RemoveQueryChannels = 511;
SealedSegmentsChangeInfo = 512;
WatchDeltaChannels = 513;
/* DATA SERVICE */
SegmentInfo = 600;
@ -173,4 +174,4 @@ message MsgHeader {
message DMLMsgHeader {
common.MsgBase base = 1;
string shardName = 2;
}
}

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

@ -245,6 +245,7 @@ const (
MsgType_WatchQueryChannels MsgType = 510
MsgType_RemoveQueryChannels MsgType = 511
MsgType_SealedSegmentsChangeInfo MsgType = 512
MsgType_WatchDeltaChannels MsgType = 513
// DATA SERVICE
MsgType_SegmentInfo MsgType = 600
MsgType_SystemInfo MsgType = 601
@ -305,6 +306,7 @@ var MsgType_name = map[int32]string{
510: "WatchQueryChannels",
511: "RemoveQueryChannels",
512: "SealedSegmentsChangeInfo",
513: "WatchDeltaChannels",
600: "SegmentInfo",
601: "SystemInfo",
1200: "TimeTick",
@ -363,6 +365,7 @@ var MsgType_value = map[string]int32{
"WatchQueryChannels": 510,
"RemoveQueryChannels": 511,
"SealedSegmentsChangeInfo": 512,
"WatchDeltaChannels": 513,
"SegmentInfo": 600,
"SystemInfo": 601,
"TimeTick": 1200,
@ -806,92 +809,92 @@ func init() {
func init() { proto.RegisterFile("common.proto", fileDescriptor_555bd8c177793206) }
var fileDescriptor_555bd8c177793206 = []byte{
// 1380 bytes of a gzipped FileDescriptorProto
// 1390 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x56, 0x4b, 0x73, 0x1b, 0x37,
0x12, 0xd6, 0x70, 0x28, 0x51, 0x84, 0x28, 0x09, 0x82, 0x1e, 0x96, 0xbd, 0xda, 0x2d, 0x17, 0x4f,
0x2e, 0x55, 0x59, 0xda, 0x5d, 0xd7, 0xee, 0x9e, 0x7c, 0x90, 0x38, 0x7a, 0xb0, 0x6c, 0x3d, 0x76,
0x28, 0x3b, 0xa9, 0x1c, 0xe2, 0x82, 0x66, 0x9a, 0x24, 0xe2, 0x19, 0x80, 0x01, 0x40, 0x59, 0xbc,
0xe5, 0x27, 0x24, 0xfe, 0x1d, 0x49, 0x2a, 0xef, 0xa4, 0xf2, 0x0b, 0xf2, 0x3e, 0x27, 0xf7, 0x1c,
0xf2, 0x03, 0xf2, 0xf4, 0x33, 0xd5, 0x98, 0x21, 0x39, 0xae, 0xb2, 0x4f, 0xb9, 0xa1, 0x3f, 0x34,
0xbe, 0xee, 0xfe, 0xba, 0x81, 0x19, 0x52, 0x8b, 0x54, 0x9a, 0x2a, 0xb9, 0xd1, 0xd3, 0xca, 0x2a,
0xb6, 0x98, 0x8a, 0xe4, 0xac, 0x6f, 0x32, 0x6b, 0x23, 0xdb, 0xaa, 0xdf, 0x21, 0x53, 0x2d, 0xcb,
0x6d, 0xdf, 0xb0, 0xeb, 0x84, 0x80, 0xd6, 0x4a, 0xdf, 0x89, 0x54, 0x0c, 0xab, 0xde, 0x65, 0xef,
0xca, 0xdc, 0xbf, 0xff, 0xb1, 0xf1, 0x9c, 0x33, 0x1b, 0x3b, 0xe8, 0xd6, 0x50, 0x31, 0x84, 0x55,
0x18, 0x2e, 0xd9, 0x0a, 0x99, 0xd2, 0xc0, 0x8d, 0x92, 0xab, 0xa5, 0xcb, 0xde, 0x95, 0x6a, 0x98,
0x5b, 0xf5, 0xff, 0x92, 0xda, 0x0d, 0x18, 0xdc, 0xe6, 0x49, 0x1f, 0x8e, 0xb9, 0xd0, 0x8c, 0x12,
0xff, 0x2e, 0x0c, 0x1c, 0x7f, 0x35, 0xc4, 0x25, 0x5b, 0x22, 0x93, 0x67, 0xb8, 0x9d, 0x1f, 0xcc,
0x8c, 0xfa, 0x35, 0x32, 0x73, 0x03, 0x06, 0x01, 0xb7, 0xfc, 0x05, 0xc7, 0x18, 0x29, 0xc7, 0xdc,
0x72, 0x77, 0xaa, 0x16, 0xba, 0x75, 0x7d, 0x8d, 0x94, 0xb7, 0x13, 0x75, 0x3a, 0xa6, 0xf4, 0xdc,
0x66, 0x4e, 0x79, 0x95, 0x54, 0xb6, 0xe2, 0x58, 0x83, 0x31, 0x6c, 0x8e, 0x94, 0x44, 0x2f, 0x67,
0x2b, 0x89, 0x1e, 0x92, 0xf5, 0x94, 0xb6, 0x8e, 0xcc, 0x0f, 0xdd, 0xba, 0x7e, 0xdf, 0x23, 0x95,
0x03, 0xd3, 0xd9, 0xe6, 0x06, 0xd8, 0xff, 0xc8, 0x74, 0x6a, 0x3a, 0x77, 0xec, 0xa0, 0x37, 0x94,
0x66, 0xed, 0xb9, 0xd2, 0x1c, 0x98, 0xce, 0xc9, 0xa0, 0x07, 0x61, 0x25, 0xcd, 0x16, 0x98, 0x49,
0x6a, 0x3a, 0xcd, 0x20, 0x67, 0xce, 0x0c, 0xb6, 0x46, 0xaa, 0x56, 0xa4, 0x60, 0x2c, 0x4f, 0x7b,
0xab, 0xfe, 0x65, 0xef, 0x4a, 0x39, 0x1c, 0x03, 0xec, 0x12, 0x99, 0x36, 0xaa, 0xaf, 0x23, 0x68,
0x06, 0xab, 0x65, 0x77, 0x6c, 0x64, 0xd7, 0xaf, 0x93, 0xea, 0x81, 0xe9, 0xec, 0x03, 0x8f, 0x41,
0xb3, 0x7f, 0x92, 0xf2, 0x29, 0x37, 0x59, 0x46, 0x33, 0x2f, 0xce, 0x08, 0x2b, 0x08, 0x9d, 0x67,
0xfd, 0x55, 0x52, 0x0b, 0x0e, 0x6e, 0xfe, 0x05, 0x06, 0x4c, 0xdd, 0x74, 0xb9, 0x8e, 0x0f, 0x79,
0x3a, 0xec, 0xd8, 0x18, 0x58, 0xff, 0xbc, 0x4c, 0xaa, 0xa3, 0xf1, 0x60, 0x33, 0xa4, 0xd2, 0xea,
0x47, 0x11, 0x18, 0x43, 0x27, 0xd8, 0x22, 0x99, 0xbf, 0x25, 0xe1, 0xbc, 0x07, 0x91, 0x85, 0xd8,
0xf9, 0x50, 0x8f, 0x2d, 0x90, 0xd9, 0x86, 0x92, 0x12, 0x22, 0xbb, 0xcb, 0x45, 0x02, 0x31, 0x2d,
0xb1, 0x25, 0x42, 0x8f, 0x41, 0xa7, 0xc2, 0x18, 0xa1, 0x64, 0x00, 0x52, 0x40, 0x4c, 0x7d, 0x76,
0x81, 0x2c, 0x36, 0x54, 0x92, 0x40, 0x64, 0x85, 0x92, 0x87, 0xca, 0xee, 0x9c, 0x0b, 0x63, 0x0d,
0x2d, 0x23, 0x6d, 0x33, 0x49, 0xa0, 0xc3, 0x93, 0x2d, 0xdd, 0xe9, 0xa7, 0x20, 0x2d, 0x9d, 0x44,
0x8e, 0x1c, 0x0c, 0x44, 0x0a, 0x12, 0x99, 0x68, 0xa5, 0x80, 0x36, 0x65, 0x0c, 0xe7, 0xd8, 0x1f,
0x3a, 0xcd, 0x2e, 0x92, 0xe5, 0x1c, 0x2d, 0x04, 0xe0, 0x29, 0xd0, 0x2a, 0x9b, 0x27, 0x33, 0xf9,
0xd6, 0xc9, 0xd1, 0xf1, 0x0d, 0x4a, 0x0a, 0x0c, 0xa1, 0xba, 0x17, 0x42, 0xa4, 0x74, 0x4c, 0x67,
0x0a, 0x29, 0xdc, 0x86, 0xc8, 0x2a, 0xdd, 0x0c, 0x68, 0x0d, 0x13, 0xce, 0xc1, 0x16, 0x70, 0x1d,
0x75, 0x43, 0x30, 0xfd, 0xc4, 0xd2, 0x59, 0x46, 0x49, 0x6d, 0x57, 0x24, 0x70, 0xa8, 0xec, 0xae,
0xea, 0xcb, 0x98, 0xce, 0xb1, 0x39, 0x42, 0x0e, 0xc0, 0xf2, 0x5c, 0x81, 0x79, 0x0c, 0xdb, 0xe0,
0x51, 0x17, 0x72, 0x80, 0xb2, 0x15, 0xc2, 0x1a, 0x5c, 0x4a, 0x65, 0x1b, 0x1a, 0xb8, 0x85, 0x5d,
0x95, 0xc4, 0xa0, 0xe9, 0x02, 0xa6, 0xf3, 0x0c, 0x2e, 0x12, 0xa0, 0x6c, 0xec, 0x1d, 0x40, 0x02,
0x23, 0xef, 0xc5, 0xb1, 0x77, 0x8e, 0xa3, 0xf7, 0x12, 0x26, 0xbf, 0xdd, 0x17, 0x49, 0xec, 0x24,
0xc9, 0xda, 0xb2, 0x8c, 0x39, 0xe6, 0xc9, 0x1f, 0xde, 0x6c, 0xb6, 0x4e, 0xe8, 0x0a, 0x5b, 0x26,
0x0b, 0x39, 0x72, 0x00, 0x56, 0x8b, 0xc8, 0x89, 0x77, 0x01, 0x53, 0x3d, 0xea, 0xdb, 0xa3, 0xf6,
0x01, 0xa4, 0x4a, 0x0f, 0xe8, 0x2a, 0x36, 0xd4, 0x31, 0x0d, 0x5b, 0x44, 0x2f, 0x62, 0x84, 0x9d,
0xb4, 0x67, 0x07, 0x63, 0x79, 0xe9, 0x25, 0xc6, 0xc8, 0x6c, 0x10, 0x84, 0xf0, 0x7a, 0x1f, 0x8c,
0x0d, 0x79, 0x04, 0xf4, 0xa7, 0xca, 0xfa, 0xcb, 0x84, 0xb8, 0xb3, 0xf8, 0x20, 0x01, 0x63, 0x64,
0x6e, 0x6c, 0x1d, 0x2a, 0x09, 0x74, 0x82, 0xd5, 0xc8, 0xf4, 0x2d, 0x29, 0x8c, 0xe9, 0x43, 0x4c,
0x3d, 0xd4, 0xad, 0x29, 0x8f, 0xb5, 0xea, 0xe0, 0x95, 0xa6, 0x25, 0xdc, 0xdd, 0x15, 0x52, 0x98,
0xae, 0x9b, 0x18, 0x42, 0xa6, 0x72, 0x01, 0xcb, 0xeb, 0x6d, 0x52, 0x6b, 0x41, 0x07, 0x87, 0x23,
0xe3, 0x5e, 0x22, 0xb4, 0x68, 0x8f, 0xd9, 0x47, 0x69, 0x7b, 0x38, 0xbc, 0x7b, 0x5a, 0xdd, 0x13,
0xb2, 0x43, 0x4b, 0x48, 0xd6, 0x02, 0x9e, 0x38, 0xe2, 0x19, 0x52, 0xd9, 0x4d, 0xfa, 0x2e, 0x4a,
0xd9, 0xc5, 0x44, 0x03, 0xdd, 0x26, 0xd7, 0x7f, 0x9c, 0x76, 0x4f, 0x86, 0xbb, 0xf9, 0xb3, 0xa4,
0x7a, 0x4b, 0xc6, 0xd0, 0x16, 0x12, 0x62, 0x3a, 0xe1, 0xd4, 0x77, 0x5d, 0x2a, 0xc8, 0x10, 0x63,
0x91, 0x81, 0x56, 0xbd, 0x02, 0x06, 0x28, 0xe1, 0x3e, 0x37, 0x05, 0xa8, 0x8d, 0x2d, 0x0d, 0xc0,
0x44, 0x5a, 0x9c, 0x16, 0x8f, 0x77, 0x50, 0xda, 0x56, 0x57, 0xdd, 0x1b, 0x63, 0x86, 0x76, 0x31,
0xd2, 0x1e, 0xd8, 0xd6, 0xc0, 0x58, 0x48, 0x1b, 0x4a, 0xb6, 0x45, 0xc7, 0x50, 0x81, 0x91, 0x6e,
0x2a, 0x1e, 0x17, 0x8e, 0xbf, 0x86, 0x4d, 0x0d, 0x21, 0x01, 0x6e, 0x8a, 0xac, 0x77, 0xdd, 0xfc,
0xb9, 0x54, 0xb7, 0x12, 0xc1, 0x0d, 0x4d, 0xb0, 0x14, 0xcc, 0x32, 0x33, 0x53, 0xd4, 0x7d, 0x2b,
0xb1, 0xa0, 0x33, 0x5b, 0xb2, 0x25, 0x32, 0x9f, 0xf9, 0x1f, 0x73, 0x6d, 0x85, 0x23, 0xf9, 0xc2,
0x73, 0x1d, 0xd6, 0xaa, 0x37, 0xc6, 0xbe, 0xc4, 0xeb, 0x5e, 0xdb, 0xe7, 0x66, 0x0c, 0x7d, 0xe5,
0xb1, 0x15, 0xb2, 0x30, 0x2c, 0x6d, 0x8c, 0x7f, 0xed, 0xb1, 0x45, 0x32, 0x87, 0xa5, 0x8d, 0x30,
0x43, 0xbf, 0x71, 0x20, 0x16, 0x51, 0x00, 0xbf, 0x75, 0x0c, 0x79, 0x15, 0x05, 0xfc, 0x3b, 0x17,
0x0c, 0x19, 0xf2, 0x46, 0x1b, 0xfa, 0xc0, 0xc3, 0x4c, 0x87, 0xc1, 0x72, 0x98, 0x3e, 0x74, 0x8e,
0xc8, 0x3a, 0x72, 0x7c, 0xe4, 0x1c, 0x73, 0xce, 0x11, 0xfa, 0xd8, 0xa1, 0xfb, 0x5c, 0xc6, 0xaa,
0xdd, 0x1e, 0xa1, 0x4f, 0x3c, 0xb6, 0x4a, 0x16, 0xf1, 0xf8, 0x36, 0x4f, 0xb8, 0x8c, 0xc6, 0xfe,
0x4f, 0x3d, 0x46, 0x87, 0x42, 0xba, 0x41, 0xa6, 0x6f, 0x97, 0x9c, 0x28, 0x79, 0x02, 0x19, 0xf6,
0x4e, 0x89, 0xcd, 0x65, 0xea, 0x66, 0xf6, 0xbb, 0x25, 0x36, 0x43, 0xa6, 0x9a, 0xd2, 0x80, 0xb6,
0xf4, 0x4d, 0x1c, 0xb6, 0xa9, 0xec, 0xba, 0xd2, 0xb7, 0x70, 0xa4, 0x27, 0xdd, 0xb0, 0xd1, 0xfb,
0x6e, 0x23, 0x7b, 0x58, 0xe8, 0xcf, 0xbe, 0x2b, 0xb5, 0xf8, 0xca, 0xfc, 0xe2, 0x63, 0xa4, 0x3d,
0xb0, 0xe3, 0x1b, 0x44, 0x7f, 0xf5, 0xd9, 0x25, 0xb2, 0x3c, 0xc4, 0xdc, 0x9d, 0x1f, 0xdd, 0x9d,
0xdf, 0x7c, 0xb6, 0x46, 0x2e, 0xec, 0x81, 0x1d, 0xcf, 0x01, 0x1e, 0x12, 0xc6, 0x8a, 0xc8, 0xd0,
0xdf, 0x7d, 0xf6, 0x37, 0xb2, 0xb2, 0x07, 0x76, 0xa4, 0x6f, 0x61, 0xf3, 0x0f, 0x9f, 0xcd, 0x92,
0xe9, 0x10, 0x1f, 0x05, 0x38, 0x03, 0xfa, 0xc0, 0xc7, 0x26, 0x0d, 0xcd, 0x3c, 0x9d, 0x87, 0x3e,
0x4a, 0xf7, 0x12, 0xb7, 0x51, 0x37, 0x48, 0x1b, 0x5d, 0x2e, 0x25, 0x24, 0x86, 0x3e, 0xf2, 0xd9,
0x32, 0xa1, 0x21, 0xa4, 0xea, 0x0c, 0x0a, 0xf0, 0x63, 0x7c, 0xec, 0x99, 0x73, 0xfe, 0x7f, 0x1f,
0xf4, 0x60, 0xb4, 0xf1, 0xc4, 0x47, 0xa9, 0x33, 0xff, 0x67, 0x77, 0x9e, 0xfa, 0xec, 0xef, 0x64,
0x35, 0xbb, 0xa0, 0x43, 0xfd, 0x71, 0xb3, 0x03, 0x4d, 0xd9, 0x56, 0xf4, 0x8d, 0x32, 0x76, 0x22,
0xdf, 0x70, 0xc8, 0xf7, 0x65, 0x36, 0x4f, 0x48, 0x76, 0x45, 0x1c, 0xf0, 0x43, 0x19, 0xab, 0x38,
0x11, 0x29, 0x9c, 0x88, 0xe8, 0x2e, 0x7d, 0xaf, 0x8a, 0x55, 0xb8, 0x20, 0x87, 0x2a, 0x06, 0x2c,
0xd7, 0xd0, 0xf7, 0xab, 0xd8, 0x2a, 0x6c, 0x75, 0xd6, 0xaa, 0x0f, 0x9c, 0x9d, 0xbf, 0x61, 0xcd,
0x80, 0x7e, 0x88, 0x1f, 0x0c, 0x92, 0xdb, 0x27, 0xad, 0x23, 0xfa, 0x51, 0x15, 0xcb, 0xde, 0x4a,
0x12, 0x15, 0x71, 0x3b, 0x1a, 0xb8, 0x8f, 0xab, 0x38, 0xb1, 0x85, 0xe7, 0x27, 0x17, 0xf2, 0x93,
0x2a, 0xca, 0x91, 0xe3, 0xae, 0xcd, 0x01, 0x3e, 0x4b, 0x9f, 0x3a, 0x56, 0xfc, 0x0f, 0xc2, 0x4c,
0x4e, 0x2c, 0xfd, 0xac, 0xba, 0x5e, 0x27, 0x95, 0xc0, 0x24, 0xee, 0x95, 0xa9, 0x10, 0x3f, 0x30,
0x09, 0x9d, 0xc0, 0x4b, 0xb9, 0xad, 0x54, 0xb2, 0x73, 0xde, 0xd3, 0xb7, 0xff, 0x45, 0xbd, 0xed,
0xff, 0xbc, 0x72, 0xad, 0x23, 0x6c, 0xb7, 0x7f, 0x8a, 0x9f, 0xf1, 0xcd, 0xec, 0xbb, 0x7e, 0x55,
0xa8, 0x7c, 0xb5, 0x29, 0xa4, 0x05, 0x2d, 0x79, 0xb2, 0xe9, 0x3e, 0xf5, 0x9b, 0xd9, 0xa7, 0xbe,
0x77, 0x7a, 0x3a, 0xe5, 0xec, 0x6b, 0x7f, 0x06, 0x00, 0x00, 0xff, 0xff, 0x8a, 0x69, 0x88, 0x56,
0x3b, 0x0a, 0x00, 0x00,
0x25, 0xff, 0x20, 0xf1, 0xef, 0x48, 0x52, 0x79, 0x27, 0x95, 0x5f, 0x90, 0xf7, 0x39, 0xf9, 0x07,
0xf9, 0x01, 0x79, 0xfa, 0x99, 0x6a, 0xcc, 0x90, 0x1c, 0x57, 0xd9, 0xa7, 0xdc, 0xd0, 0x1f, 0xba,
0xbf, 0x6e, 0x7c, 0xdd, 0xc0, 0x0c, 0xa9, 0x45, 0x2a, 0x4d, 0x95, 0xdc, 0xe8, 0x69, 0x65, 0x15,
0x5b, 0x4c, 0x45, 0x72, 0xd6, 0x37, 0x99, 0xb5, 0x91, 0x6d, 0xd5, 0xef, 0x90, 0xa9, 0x96, 0xe5,
0xb6, 0x6f, 0xd8, 0x75, 0x42, 0x40, 0x6b, 0xa5, 0xef, 0x44, 0x2a, 0x86, 0x55, 0xef, 0xb2, 0x77,
0x65, 0xee, 0xdf, 0xff, 0xd8, 0x78, 0x4e, 0xcc, 0xc6, 0x0e, 0xba, 0x35, 0x54, 0x0c, 0x61, 0x15,
0x86, 0x4b, 0xb6, 0x42, 0xa6, 0x34, 0x70, 0xa3, 0xe4, 0x6a, 0xe9, 0xb2, 0x77, 0xa5, 0x1a, 0xe6,
0x56, 0xfd, 0xbf, 0xa4, 0x76, 0x03, 0x06, 0xb7, 0x79, 0xd2, 0x87, 0x63, 0x2e, 0x34, 0xa3, 0xc4,
0xbf, 0x0b, 0x03, 0xc7, 0x5f, 0x0d, 0x71, 0xc9, 0x96, 0xc8, 0xe4, 0x19, 0x6e, 0xe7, 0x81, 0x99,
0x51, 0xbf, 0x46, 0x66, 0x6e, 0xc0, 0x20, 0xe0, 0x96, 0xbf, 0x20, 0x8c, 0x91, 0x72, 0xcc, 0x2d,
0x77, 0x51, 0xb5, 0xd0, 0xad, 0xeb, 0x6b, 0xa4, 0xbc, 0x9d, 0xa8, 0xd3, 0x31, 0xa5, 0xe7, 0x36,
0x73, 0xca, 0xab, 0xa4, 0xb2, 0x15, 0xc7, 0x1a, 0x8c, 0x61, 0x73, 0xa4, 0x24, 0x7a, 0x39, 0x5b,
0x49, 0xf4, 0x90, 0xac, 0xa7, 0xb4, 0x75, 0x64, 0x7e, 0xe8, 0xd6, 0xf5, 0xfb, 0x1e, 0xa9, 0x1c,
0x98, 0xce, 0x36, 0x37, 0xc0, 0xfe, 0x47, 0xa6, 0x53, 0xd3, 0xb9, 0x63, 0x07, 0xbd, 0xa1, 0x34,
0x6b, 0xcf, 0x95, 0xe6, 0xc0, 0x74, 0x4e, 0x06, 0x3d, 0x08, 0x2b, 0x69, 0xb6, 0xc0, 0x4a, 0x52,
0xd3, 0x69, 0x06, 0x39, 0x73, 0x66, 0xb0, 0x35, 0x52, 0xb5, 0x22, 0x05, 0x63, 0x79, 0xda, 0x5b,
0xf5, 0x2f, 0x7b, 0x57, 0xca, 0xe1, 0x18, 0x60, 0x97, 0xc8, 0xb4, 0x51, 0x7d, 0x1d, 0x41, 0x33,
0x58, 0x2d, 0xbb, 0xb0, 0x91, 0x5d, 0xbf, 0x4e, 0xaa, 0x07, 0xa6, 0xb3, 0x0f, 0x3c, 0x06, 0xcd,
0xfe, 0x49, 0xca, 0xa7, 0xdc, 0x64, 0x15, 0xcd, 0xbc, 0xb8, 0x22, 0x3c, 0x41, 0xe8, 0x3c, 0xeb,
0xaf, 0x92, 0x5a, 0x70, 0x70, 0xf3, 0x2f, 0x30, 0x60, 0xe9, 0xa6, 0xcb, 0x75, 0x7c, 0xc8, 0xd3,
0x61, 0xc7, 0xc6, 0xc0, 0xfa, 0x17, 0x65, 0x52, 0x1d, 0x8d, 0x07, 0x9b, 0x21, 0x95, 0x56, 0x3f,
0x8a, 0xc0, 0x18, 0x3a, 0xc1, 0x16, 0xc9, 0xfc, 0x2d, 0x09, 0xe7, 0x3d, 0x88, 0x2c, 0xc4, 0xce,
0x87, 0x7a, 0x6c, 0x81, 0xcc, 0x36, 0x94, 0x94, 0x10, 0xd9, 0x5d, 0x2e, 0x12, 0x88, 0x69, 0x89,
0x2d, 0x11, 0x7a, 0x0c, 0x3a, 0x15, 0xc6, 0x08, 0x25, 0x03, 0x90, 0x02, 0x62, 0xea, 0xb3, 0x0b,
0x64, 0xb1, 0xa1, 0x92, 0x04, 0x22, 0x2b, 0x94, 0x3c, 0x54, 0x76, 0xe7, 0x5c, 0x18, 0x6b, 0x68,
0x19, 0x69, 0x9b, 0x49, 0x02, 0x1d, 0x9e, 0x6c, 0xe9, 0x4e, 0x3f, 0x05, 0x69, 0xe9, 0x24, 0x72,
0xe4, 0x60, 0x20, 0x52, 0x90, 0xc8, 0x44, 0x2b, 0x05, 0xb4, 0x29, 0x63, 0x38, 0xc7, 0xfe, 0xd0,
0x69, 0x76, 0x91, 0x2c, 0xe7, 0x68, 0x21, 0x01, 0x4f, 0x81, 0x56, 0xd9, 0x3c, 0x99, 0xc9, 0xb7,
0x4e, 0x8e, 0x8e, 0x6f, 0x50, 0x52, 0x60, 0x08, 0xd5, 0xbd, 0x10, 0x22, 0xa5, 0x63, 0x3a, 0x53,
0x28, 0xe1, 0x36, 0x44, 0x56, 0xe9, 0x66, 0x40, 0x6b, 0x58, 0x70, 0x0e, 0xb6, 0x80, 0xeb, 0xa8,
0x1b, 0x82, 0xe9, 0x27, 0x96, 0xce, 0x32, 0x4a, 0x6a, 0xbb, 0x22, 0x81, 0x43, 0x65, 0x77, 0x55,
0x5f, 0xc6, 0x74, 0x8e, 0xcd, 0x11, 0x72, 0x00, 0x96, 0xe7, 0x0a, 0xcc, 0x63, 0xda, 0x06, 0x8f,
0xba, 0x90, 0x03, 0x94, 0xad, 0x10, 0xd6, 0xe0, 0x52, 0x2a, 0xdb, 0xd0, 0xc0, 0x2d, 0xec, 0xaa,
0x24, 0x06, 0x4d, 0x17, 0xb0, 0x9c, 0x67, 0x70, 0x91, 0x00, 0x65, 0x63, 0xef, 0x00, 0x12, 0x18,
0x79, 0x2f, 0x8e, 0xbd, 0x73, 0x1c, 0xbd, 0x97, 0xb0, 0xf8, 0xed, 0xbe, 0x48, 0x62, 0x27, 0x49,
0xd6, 0x96, 0x65, 0xac, 0x31, 0x2f, 0xfe, 0xf0, 0x66, 0xb3, 0x75, 0x42, 0x57, 0xd8, 0x32, 0x59,
0xc8, 0x91, 0x03, 0xb0, 0x5a, 0x44, 0x4e, 0xbc, 0x0b, 0x58, 0xea, 0x51, 0xdf, 0x1e, 0xb5, 0x0f,
0x20, 0x55, 0x7a, 0x40, 0x57, 0xb1, 0xa1, 0x8e, 0x69, 0xd8, 0x22, 0x7a, 0x11, 0x33, 0xec, 0xa4,
0x3d, 0x3b, 0x18, 0xcb, 0x4b, 0x2f, 0x31, 0x46, 0x66, 0x83, 0x20, 0x84, 0xd7, 0xfb, 0x60, 0x6c,
0xc8, 0x23, 0xa0, 0x3f, 0x55, 0xd6, 0x5f, 0x26, 0xc4, 0xc5, 0xe2, 0x83, 0x04, 0x8c, 0x91, 0xb9,
0xb1, 0x75, 0xa8, 0x24, 0xd0, 0x09, 0x56, 0x23, 0xd3, 0xb7, 0xa4, 0x30, 0xa6, 0x0f, 0x31, 0xf5,
0x50, 0xb7, 0xa6, 0x3c, 0xd6, 0xaa, 0x83, 0x57, 0x9a, 0x96, 0x70, 0x77, 0x57, 0x48, 0x61, 0xba,
0x6e, 0x62, 0x08, 0x99, 0xca, 0x05, 0x2c, 0xaf, 0xb7, 0x49, 0xad, 0x05, 0x1d, 0x1c, 0x8e, 0x8c,
0x7b, 0x89, 0xd0, 0xa2, 0x3d, 0x66, 0x1f, 0x95, 0xed, 0xe1, 0xf0, 0xee, 0x69, 0x75, 0x4f, 0xc8,
0x0e, 0x2d, 0x21, 0x59, 0x0b, 0x78, 0xe2, 0x88, 0x67, 0x48, 0x65, 0x37, 0xe9, 0xbb, 0x2c, 0x65,
0x97, 0x13, 0x0d, 0x74, 0x9b, 0x5c, 0x7f, 0x3c, 0xed, 0x9e, 0x0c, 0x77, 0xf3, 0x67, 0x49, 0xf5,
0x96, 0x8c, 0xa1, 0x2d, 0x24, 0xc4, 0x74, 0xc2, 0xa9, 0xef, 0xba, 0x54, 0x90, 0x21, 0xc6, 0x43,
0x06, 0x5a, 0xf5, 0x0a, 0x18, 0xa0, 0x84, 0xfb, 0xdc, 0x14, 0xa0, 0x36, 0xb6, 0x34, 0x00, 0x13,
0x69, 0x71, 0x5a, 0x0c, 0xef, 0xa0, 0xb4, 0xad, 0xae, 0xba, 0x37, 0xc6, 0x0c, 0xed, 0x62, 0xa6,
0x3d, 0xb0, 0xad, 0x81, 0xb1, 0x90, 0x36, 0x94, 0x6c, 0x8b, 0x8e, 0xa1, 0x02, 0x33, 0xdd, 0x54,
0x3c, 0x2e, 0x84, 0xbf, 0x86, 0x4d, 0x0d, 0x21, 0x01, 0x6e, 0x8a, 0xac, 0x77, 0xdd, 0xfc, 0xb9,
0x52, 0xb7, 0x12, 0xc1, 0x0d, 0x4d, 0xf0, 0x28, 0x58, 0x65, 0x66, 0xa6, 0xa8, 0xfb, 0x56, 0x62,
0x41, 0x67, 0xb6, 0x64, 0x4b, 0x64, 0x3e, 0xf3, 0x3f, 0xe6, 0xda, 0x0a, 0x47, 0xf2, 0xa5, 0xe7,
0x3a, 0xac, 0x55, 0x6f, 0x8c, 0x7d, 0x85, 0xd7, 0xbd, 0xb6, 0xcf, 0xcd, 0x18, 0xfa, 0xda, 0x63,
0x2b, 0x64, 0x61, 0x78, 0xb4, 0x31, 0xfe, 0x8d, 0xc7, 0x16, 0xc9, 0x1c, 0x1e, 0x6d, 0x84, 0x19,
0xfa, 0xad, 0x03, 0xf1, 0x10, 0x05, 0xf0, 0x3b, 0xc7, 0x90, 0x9f, 0xa2, 0x80, 0x7f, 0xef, 0x92,
0x21, 0x43, 0xde, 0x68, 0x43, 0x1f, 0x78, 0x58, 0xe9, 0x30, 0x59, 0x0e, 0xd3, 0x87, 0xce, 0x11,
0x59, 0x47, 0x8e, 0x8f, 0x9c, 0x63, 0xce, 0x39, 0x42, 0x1f, 0x3b, 0x74, 0x9f, 0xcb, 0x58, 0xb5,
0xdb, 0x23, 0xf4, 0x89, 0xc7, 0x56, 0xc9, 0x22, 0x86, 0x6f, 0xf3, 0x84, 0xcb, 0x68, 0xec, 0xff,
0xd4, 0x63, 0x74, 0x28, 0xa4, 0x1b, 0x64, 0xfa, 0x4e, 0xc9, 0x89, 0x92, 0x17, 0x90, 0x61, 0xef,
0x96, 0xd8, 0x5c, 0xa6, 0x6e, 0x66, 0xbf, 0x57, 0x62, 0x33, 0x64, 0xaa, 0x29, 0x0d, 0x68, 0x4b,
0xdf, 0xc2, 0x61, 0x9b, 0xca, 0xae, 0x2b, 0x7d, 0x1b, 0x47, 0x7a, 0xd2, 0x0d, 0x1b, 0xbd, 0xef,
0x36, 0xb2, 0x87, 0x85, 0xfe, 0xec, 0xbb, 0xa3, 0x16, 0x5f, 0x99, 0x5f, 0x7c, 0xcc, 0xb4, 0x07,
0x76, 0x7c, 0x83, 0xe8, 0xaf, 0x3e, 0xbb, 0x44, 0x96, 0x87, 0x98, 0xbb, 0xf3, 0xa3, 0xbb, 0xf3,
0x9b, 0xcf, 0xd6, 0xc8, 0x85, 0x3d, 0xb0, 0xe3, 0x39, 0xc0, 0x20, 0x61, 0xac, 0x88, 0x0c, 0xfd,
0xdd, 0x67, 0x7f, 0x23, 0x2b, 0x7b, 0x60, 0x47, 0xfa, 0x16, 0x36, 0xff, 0xf0, 0xd9, 0x2c, 0x99,
0x0e, 0xf1, 0x51, 0x80, 0x33, 0xa0, 0x0f, 0x7c, 0x6c, 0xd2, 0xd0, 0xcc, 0xcb, 0x79, 0xe8, 0xa3,
0x74, 0x2f, 0x71, 0x1b, 0x75, 0x83, 0xb4, 0xd1, 0xe5, 0x52, 0x42, 0x62, 0xe8, 0x23, 0x9f, 0x2d,
0x13, 0x1a, 0x42, 0xaa, 0xce, 0xa0, 0x00, 0x3f, 0xc6, 0xc7, 0x9e, 0x39, 0xe7, 0xff, 0xf7, 0x41,
0x0f, 0x46, 0x1b, 0x4f, 0x7c, 0x94, 0x3a, 0xf3, 0x7f, 0x76, 0xe7, 0xa9, 0xcf, 0xfe, 0x4e, 0x56,
0xb3, 0x0b, 0x3a, 0xd4, 0x1f, 0x37, 0x3b, 0xd0, 0x94, 0x6d, 0x45, 0xdf, 0x28, 0x8f, 0x18, 0x03,
0x48, 0x2c, 0x1f, 0xc5, 0xbd, 0x59, 0xc6, 0x16, 0xe5, 0x11, 0xce, 0xf5, 0x87, 0x32, 0x9b, 0x27,
0x24, 0xbb, 0x3b, 0x0e, 0xf8, 0xb1, 0x8c, 0xc7, 0x3b, 0x11, 0x29, 0x9c, 0x88, 0xe8, 0x2e, 0x7d,
0xbf, 0x8a, 0xc7, 0x73, 0xd9, 0x0f, 0x55, 0x0c, 0xa8, 0x83, 0xa1, 0x1f, 0x54, 0xb1, 0x87, 0x38,
0x03, 0x59, 0x0f, 0x3f, 0x74, 0x76, 0xfe, 0xb8, 0x35, 0x03, 0xfa, 0x11, 0x7e, 0x49, 0x48, 0x6e,
0x9f, 0xb4, 0x8e, 0xe8, 0xc7, 0x55, 0xd4, 0x63, 0x2b, 0x49, 0x54, 0xc4, 0xed, 0x68, 0x12, 0x3f,
0xa9, 0xe2, 0x28, 0x17, 0xde, 0xa5, 0x5c, 0xe1, 0x4f, 0xab, 0xa8, 0x53, 0x8e, 0xbb, 0xfe, 0x07,
0xf8, 0x5e, 0x7d, 0xe6, 0x58, 0xf1, 0x07, 0x09, 0x2b, 0x39, 0xb1, 0xf4, 0xf3, 0xea, 0x7a, 0x9d,
0x54, 0x02, 0x93, 0xb8, 0xe7, 0xa7, 0x42, 0xfc, 0xc0, 0x24, 0x74, 0x02, 0x6f, 0xeb, 0xb6, 0x52,
0xc9, 0xce, 0x79, 0x4f, 0xdf, 0xfe, 0x17, 0xf5, 0xb6, 0xff, 0xf3, 0xca, 0xb5, 0x8e, 0xb0, 0xdd,
0xfe, 0x29, 0x7e, 0xdf, 0x37, 0xb3, 0x0f, 0xfe, 0x55, 0xa1, 0xf2, 0xd5, 0xa6, 0x90, 0x16, 0xb4,
0xe4, 0xc9, 0xa6, 0xfb, 0x07, 0xd8, 0xcc, 0xfe, 0x01, 0x7a, 0xa7, 0xa7, 0x53, 0xce, 0xbe, 0xf6,
0x67, 0x00, 0x00, 0x00, 0xff, 0xff, 0x26, 0x52, 0x92, 0x64, 0x54, 0x0a, 0x00, 0x00,
}

8
internal/proto/query_coord.proto
View File

@ -39,6 +39,7 @@ service QueryNode {
rpc AddQueryChannel(AddQueryChannelRequest) returns (common.Status) {}
rpc RemoveQueryChannel(RemoveQueryChannelRequest) returns (common.Status) {}
rpc WatchDmChannels(WatchDmChannelsRequest) returns (common.Status) {}
rpc WatchDeltaChannels(WatchDeltaChannelsRequest) returns (common.Status) {}
rpc LoadSegments(LoadSegmentsRequest) returns (common.Status) {}
rpc ReleaseCollection(ReleaseCollectionRequest) returns (common.Status) {}
rpc ReleasePartitions(ReleasePartitionsRequest) returns (common.Status) {}
@ -212,6 +213,13 @@ message WatchDmChannelsRequest {
repeated data.SegmentInfo exclude_infos = 7;
}
message WatchDeltaChannelsRequest {
common.MsgBase base = 1;
int64 nodeID = 2;
int64 collectionID = 3;
repeated data.VchannelInfo infos = 4;
}
enum TriggerCondition {
handoff = 0;
loadBalance = 1;

411
internal/proto/querypb/query_coord.pb.go
View File

@ -1416,6 +1416,69 @@ func (m *WatchDmChannelsRequest) GetExcludeInfos() []*datapb.SegmentInfo {
return nil
}
type WatchDeltaChannelsRequest struct {
Base *commonpb.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
NodeID int64 `protobuf:"varint,2,opt,name=nodeID,proto3" json:"nodeID,omitempty"`
CollectionID int64 `protobuf:"varint,3,opt,name=collectionID,proto3" json:"collectionID,omitempty"`
Infos []*datapb.VchannelInfo `protobuf:"bytes,4,rep,name=infos,proto3" json:"infos,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *WatchDeltaChannelsRequest) Reset() { *m = WatchDeltaChannelsRequest{} }
func (m *WatchDeltaChannelsRequest) String() string { return proto.CompactTextString(m) }
func (*WatchDeltaChannelsRequest) ProtoMessage() {}
func (*WatchDeltaChannelsRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_aab7cc9a69ed26e8, []int{19}
}
func (m *WatchDeltaChannelsRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_WatchDeltaChannelsRequest.Unmarshal(m, b)
}
func (m *WatchDeltaChannelsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_WatchDeltaChannelsRequest.Marshal(b, m, deterministic)
}
func (m *WatchDeltaChannelsRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_WatchDeltaChannelsRequest.Merge(m, src)
}
func (m *WatchDeltaChannelsRequest) XXX_Size() int {
return xxx_messageInfo_WatchDeltaChannelsRequest.Size(m)
}
func (m *WatchDeltaChannelsRequest) XXX_DiscardUnknown() {
xxx_messageInfo_WatchDeltaChannelsRequest.DiscardUnknown(m)
}
var xxx_messageInfo_WatchDeltaChannelsRequest proto.InternalMessageInfo
func (m *WatchDeltaChannelsRequest) GetBase() *commonpb.MsgBase {
if m != nil {
return m.Base
}
return nil
}
func (m *WatchDeltaChannelsRequest) GetNodeID() int64 {
if m != nil {
return m.NodeID
}
return 0
}
func (m *WatchDeltaChannelsRequest) GetCollectionID() int64 {
if m != nil {
return m.CollectionID
}
return 0
}
func (m *WatchDeltaChannelsRequest) GetInfos() []*datapb.VchannelInfo {
if m != nil {
return m.Infos
}
return nil
}
//used for handoff task
type SegmentLoadInfo struct {
SegmentID int64 `protobuf:"varint,1,opt,name=segmentID,proto3" json:"segmentID,omitempty"`
@ -1436,7 +1499,7 @@ func (m *SegmentLoadInfo) Reset() { *m = SegmentLoadInfo{} }
func (m *SegmentLoadInfo) String() string { return proto.CompactTextString(m) }
func (*SegmentLoadInfo) ProtoMessage() {}
func (*SegmentLoadInfo) Descriptor() ([]byte, []int) {
return fileDescriptor_aab7cc9a69ed26e8, []int{19}
return fileDescriptor_aab7cc9a69ed26e8, []int{20}
}
func (m *SegmentLoadInfo) XXX_Unmarshal(b []byte) error {
@ -1537,7 +1600,7 @@ func (m *LoadSegmentsRequest) Reset() { *m = LoadSegmentsRequest{} }
func (m *LoadSegmentsRequest) String() string { return proto.CompactTextString(m) }
func (*LoadSegmentsRequest) ProtoMessage() {}
func (*LoadSegmentsRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_aab7cc9a69ed26e8, []int{20}
return fileDescriptor_aab7cc9a69ed26e8, []int{21}
}
func (m *LoadSegmentsRequest) XXX_Unmarshal(b []byte) error {
@ -1624,7 +1687,7 @@ func (m *ReleaseSegmentsRequest) Reset() { *m = ReleaseSegmentsRequest{}
func (m *ReleaseSegmentsRequest) String() string { return proto.CompactTextString(m) }
func (*ReleaseSegmentsRequest) ProtoMessage() {}
func (*ReleaseSegmentsRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_aab7cc9a69ed26e8, []int{21}
return fileDescriptor_aab7cc9a69ed26e8, []int{22}
}
func (m *ReleaseSegmentsRequest) XXX_Unmarshal(b []byte) error {
@ -1699,7 +1762,7 @@ func (m *DmChannelInfo) Reset() { *m = DmChannelInfo{} }
func (m *DmChannelInfo) String() string { return proto.CompactTextString(m) }
func (*DmChannelInfo) ProtoMessage() {}
func (*DmChannelInfo) Descriptor() ([]byte, []int) {
return fileDescriptor_aab7cc9a69ed26e8, []int{22}
return fileDescriptor_aab7cc9a69ed26e8, []int{23}
}
func (m *DmChannelInfo) XXX_Unmarshal(b []byte) error {
@ -1749,7 +1812,7 @@ func (m *QueryChannelInfo) Reset() { *m = QueryChannelInfo{} }
func (m *QueryChannelInfo) String() string { return proto.CompactTextString(m) }
func (*QueryChannelInfo) ProtoMessage() {}
func (*QueryChannelInfo) Descriptor() ([]byte, []int) {
return fileDescriptor_aab7cc9a69ed26e8, []int{23}
return fileDescriptor_aab7cc9a69ed26e8, []int{24}
}
func (m *QueryChannelInfo) XXX_Unmarshal(b []byte) error {
@ -1823,7 +1886,7 @@ func (m *CollectionInfo) Reset() { *m = CollectionInfo{} }
func (m *CollectionInfo) String() string { return proto.CompactTextString(m) }
func (*CollectionInfo) ProtoMessage() {}
func (*CollectionInfo) Descriptor() ([]byte, []int) {
return fileDescriptor_aab7cc9a69ed26e8, []int{24}
return fileDescriptor_aab7cc9a69ed26e8, []int{25}
}
func (m *CollectionInfo) XXX_Unmarshal(b []byte) error {
@ -1918,7 +1981,7 @@ func (m *LoadBalanceSegmentInfo) Reset() { *m = LoadBalanceSegmentInfo{}
func (m *LoadBalanceSegmentInfo) String() string { return proto.CompactTextString(m) }
func (*LoadBalanceSegmentInfo) ProtoMessage() {}
func (*LoadBalanceSegmentInfo) Descriptor() ([]byte, []int) {
return fileDescriptor_aab7cc9a69ed26e8, []int{25}
return fileDescriptor_aab7cc9a69ed26e8, []int{26}
}
func (m *LoadBalanceSegmentInfo) XXX_Unmarshal(b []byte) error {
@ -2007,7 +2070,7 @@ func (m *HandoffSegmentsRequest) Reset() { *m = HandoffSegmentsRequest{}
func (m *HandoffSegmentsRequest) String() string { return proto.CompactTextString(m) }
func (*HandoffSegmentsRequest) ProtoMessage() {}
func (*HandoffSegmentsRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_aab7cc9a69ed26e8, []int{26}
return fileDescriptor_aab7cc9a69ed26e8, []int{27}
}
func (m *HandoffSegmentsRequest) XXX_Unmarshal(b []byte) error {
@ -2055,7 +2118,7 @@ func (m *LoadBalanceRequest) Reset() { *m = LoadBalanceRequest{} }
func (m *LoadBalanceRequest) String() string { return proto.CompactTextString(m) }
func (*LoadBalanceRequest) ProtoMessage() {}
func (*LoadBalanceRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_aab7cc9a69ed26e8, []int{27}
return fileDescriptor_aab7cc9a69ed26e8, []int{28}
}
func (m *LoadBalanceRequest) XXX_Unmarshal(b []byte) error {
@ -2112,7 +2175,7 @@ func (m *SegmentChangeInfo) Reset() { *m = SegmentChangeInfo{} }
func (m *SegmentChangeInfo) String() string { return proto.CompactTextString(m) }
func (*SegmentChangeInfo) ProtoMessage() {}
func (*SegmentChangeInfo) Descriptor() ([]byte, []int) {
return fileDescriptor_aab7cc9a69ed26e8, []int{28}
return fileDescriptor_aab7cc9a69ed26e8, []int{29}
}
func (m *SegmentChangeInfo) XXX_Unmarshal(b []byte) error {
@ -2173,7 +2236,7 @@ func (m *SealedSegmentsChangeInfo) Reset() { *m = SealedSegmentsChangeIn
func (m *SealedSegmentsChangeInfo) String() string { return proto.CompactTextString(m) }
func (*SealedSegmentsChangeInfo) ProtoMessage() {}
func (*SealedSegmentsChangeInfo) Descriptor() ([]byte, []int) {
return fileDescriptor_aab7cc9a69ed26e8, []int{29}
return fileDescriptor_aab7cc9a69ed26e8, []int{30}
}
func (m *SealedSegmentsChangeInfo) XXX_Unmarshal(b []byte) error {
@ -2232,6 +2295,7 @@ func init() {
proto.RegisterType((*AddQueryChannelRequest)(nil), "milvus.proto.query.AddQueryChannelRequest")
proto.RegisterType((*RemoveQueryChannelRequest)(nil), "milvus.proto.query.RemoveQueryChannelRequest")
proto.RegisterType((*WatchDmChannelsRequest)(nil), "milvus.proto.query.WatchDmChannelsRequest")
proto.RegisterType((*WatchDeltaChannelsRequest)(nil), "milvus.proto.query.WatchDeltaChannelsRequest")
proto.RegisterType((*SegmentLoadInfo)(nil), "milvus.proto.query.SegmentLoadInfo")
proto.RegisterType((*LoadSegmentsRequest)(nil), "milvus.proto.query.LoadSegmentsRequest")
proto.RegisterType((*ReleaseSegmentsRequest)(nil), "milvus.proto.query.ReleaseSegmentsRequest")
@ -2248,150 +2312,151 @@ func init() {
func init() { proto.RegisterFile("query_coord.proto", fileDescriptor_aab7cc9a69ed26e8) }
var fileDescriptor_aab7cc9a69ed26e8 = []byte{
// 2274 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x19, 0x4d, 0x73, 0x1c, 0x47,
0x55, 0xb3, 0x1f, 0xda, 0xdd, 0xb7, 0x5f, 0xe3, 0xb6, 0xb5, 0x59, 0x2f, 0xb1, 0xa3, 0x8c, 0xe3,
0x8f, 0x28, 0x44, 0x76, 0xe4, 0xf0, 0x91, 0x82, 0x1c, 0x62, 0x6d, 0xac, 0x6c, 0xb0, 0x65, 0x31,
0x72, 0x42, 0xe1, 0x72, 0xd5, 0x30, 0xbb, 0xd3, 0x5a, 0x4d, 0x79, 0x66, 0x7a, 0x3d, 0x3d, 0x6b,
0x5b, 0x3e, 0x73, 0x80, 0x03, 0xc5, 0x0f, 0x80, 0xa2, 0x8a, 0x2a, 0x28, 0x8a, 0x03, 0x47, 0x38,
0x70, 0xca, 0x85, 0x3b, 0xbf, 0x80, 0x2a, 0x0a, 0xee, 0x70, 0x81, 0x33, 0x35, 0xdd, 0x3d, 0xb3,
0xf3, 0xd1, 0x2b, 0xad, 0x24, 0x8c, 0x5d, 0x29, 0x6e, 0x33, 0xef, 0xbd, 0x7e, 0xef, 0xf5, 0xfb,
0xec, 0xd7, 0x0d, 0x67, 0x1e, 0x4f, 0xb1, 0x7f, 0x60, 0x8c, 0x08, 0xf1, 0xad, 0xf5, 0x89, 0x4f,
0x02, 0x82, 0x90, 0x6b, 0x3b, 0x4f, 0xa6, 0x94, 0xff, 0xad, 0x33, 0x7c, 0xaf, 0x31, 0x22, 0xae,
0x4b, 0x3c, 0x0e, 0xeb, 0x35, 0x92, 0x14, 0xbd, 0x96, 0xed, 0x05, 0xd8, 0xf7, 0x4c, 0x27, 0xc2,
0xd2, 0xd1, 0x3e, 0x76, 0x4d, 0xf1, 0xa7, 0x5a, 0x66, 0x60, 0x26, 0xf9, 0x6b, 0x3f, 0x54, 0xa0,
0xb3, 0xbb, 0x4f, 0x9e, 0x6e, 0x12, 0xc7, 0xc1, 0xa3, 0xc0, 0x26, 0x1e, 0xd5, 0xf1, 0xe3, 0x29,
0xa6, 0x01, 0xba, 0x01, 0xa5, 0xa1, 0x49, 0x71, 0x57, 0x59, 0x55, 0xae, 0xd5, 0x37, 0x5e, 0x5f,
0x4f, 0x69, 0x22, 0x54, 0xb8, 0x4b, 0xc7, 0xb7, 0x4c, 0x8a, 0x75, 0x46, 0x89, 0x10, 0x94, 0xac,
0xe1, 0xa0, 0xdf, 0x2d, 0xac, 0x2a, 0xd7, 0x8a, 0x3a, 0xfb, 0x46, 0x6f, 0x41, 0x73, 0x14, 0xf3,
0x1e, 0xf4, 0x69, 0xb7, 0xb8, 0x5a, 0xbc, 0x56, 0xd4, 0xd3, 0x40, 0xed, 0x37, 0x0a, 0xbc, 0x96,
0x53, 0x83, 0x4e, 0x88, 0x47, 0x31, 0xba, 0x09, 0xcb, 0x34, 0x30, 0x83, 0x29, 0x15, 0x9a, 0x7c,
0x45, 0xaa, 0xc9, 0x2e, 0x23, 0xd1, 0x05, 0x69, 0x5e, 0x6c, 0x41, 0x22, 0x16, 0xbd, 0x07, 0xe7,
0x6c, 0xef, 0x2e, 0x76, 0x89, 0x7f, 0x60, 0x4c, 0xb0, 0x3f, 0xc2, 0x5e, 0x60, 0x8e, 0x71, 0xa4,
0xe3, 0xd9, 0x08, 0xb7, 0x33, 0x43, 0x69, 0xbf, 0x56, 0x60, 0x25, 0xd4, 0x74, 0xc7, 0xf4, 0x03,
0xfb, 0x05, 0xd8, 0x4b, 0x83, 0x46, 0x52, 0xc7, 0x6e, 0x91, 0xe1, 0x52, 0xb0, 0x90, 0x66, 0x12,
0x89, 0x0f, 0xf7, 0x56, 0x62, 0xea, 0xa6, 0x60, 0xda, 0xaf, 0x84, 0x63, 0x93, 0x7a, 0x9e, 0xc6,
0xa0, 0x59, 0x99, 0x85, 0xbc, 0xcc, 0x93, 0x98, 0xf3, 0x0b, 0x05, 0x56, 0xee, 0x10, 0xd3, 0x9a,
0x39, 0xfe, 0x7f, 0x6f, 0xce, 0x0f, 0x61, 0x99, 0x67, 0x49, 0xb7, 0xc4, 0x64, 0x5d, 0x4e, 0xcb,
0x12, 0x19, 0x34, 0xd3, 0x70, 0x97, 0x01, 0x74, 0xb1, 0x48, 0xfb, 0xb9, 0x02, 0x5d, 0x1d, 0x3b,
0xd8, 0xa4, 0xf8, 0x65, 0xee, 0xa2, 0x03, 0xcb, 0x1e, 0xb1, 0xf0, 0xa0, 0xcf, 0x76, 0x51, 0xd4,
0xc5, 0x9f, 0xf6, 0x77, 0x61, 0xe1, 0x57, 0x3c, 0x60, 0x13, 0x5e, 0x28, 0x9f, 0xc4, 0x0b, 0x5f,
0xcc, 0xbc, 0xf0, 0xaa, 0xef, 0x74, 0xe6, 0xa9, 0x72, 0xca, 0x53, 0xdf, 0x87, 0xf3, 0x9b, 0x3e,
0x36, 0x03, 0xfc, 0xdd, 0xb0, 0xcc, 0x6f, 0xee, 0x9b, 0x9e, 0x87, 0x9d, 0x68, 0x0b, 0x59, 0xe1,
0x8a, 0x44, 0x78, 0x17, 0x2a, 0x13, 0x9f, 0x3c, 0x3b, 0x88, 0xf5, 0x8e, 0x7e, 0xb5, 0x5f, 0x2a,
0xd0, 0x93, 0xf1, 0x3e, 0x4d, 0x45, 0xb8, 0x0a, 0x6d, 0x9f, 0x2b, 0x67, 0x8c, 0x38, 0x3f, 0x26,
0xb5, 0xa6, 0xb7, 0x04, 0x58, 0x48, 0x41, 0x97, 0xa1, 0xe5, 0x63, 0x3a, 0x75, 0x66, 0x74, 0x45,
0x46, 0xd7, 0xe4, 0x50, 0x41, 0xa6, 0xfd, 0x56, 0x81, 0xf3, 0x5b, 0x38, 0x88, 0xbd, 0x17, 0x8a,
0xc3, 0xaf, 0x68, 0x75, 0xfd, 0x85, 0x02, 0xed, 0x8c, 0xa2, 0x68, 0x15, 0xea, 0x09, 0x1a, 0xe1,
0xa0, 0x24, 0x08, 0x7d, 0x13, 0xca, 0xa1, 0xed, 0x30, 0x53, 0xa9, 0xb5, 0xa1, 0xad, 0xe7, 0x9b,
0xfb, 0x7a, 0x9a, 0xab, 0xce, 0x17, 0xa0, 0xeb, 0x70, 0x56, 0x52, 0x59, 0x85, 0xfa, 0x28, 0x5f,
0x58, 0xb5, 0xdf, 0x29, 0xd0, 0x93, 0x19, 0xf3, 0x34, 0x0e, 0x7f, 0x00, 0x9d, 0x78, 0x37, 0x86,
0x85, 0xe9, 0xc8, 0xb7, 0x27, 0x2c, 0xcd, 0x58, 0x33, 0xa8, 0x6f, 0x5c, 0x3a, 0x7a, 0x3f, 0x54,
0x5f, 0x89, 0x59, 0xf4, 0x13, 0x1c, 0xb4, 0x9f, 0x28, 0xb0, 0xb2, 0x85, 0x83, 0x5d, 0x3c, 0x76,
0xb1, 0x17, 0x0c, 0xbc, 0x3d, 0x72, 0x72, 0xc7, 0x5f, 0x04, 0xa0, 0x82, 0x4f, 0xdc, 0xa8, 0x12,
0x90, 0x45, 0x82, 0x40, 0xfb, 0x67, 0x11, 0xea, 0x09, 0x65, 0xd0, 0xeb, 0x50, 0x8b, 0x39, 0x08,
0xd7, 0xce, 0x00, 0x39, 0x8e, 0x05, 0x49, 0x58, 0x65, 0xc2, 0xa3, 0x98, 0x0f, 0x8f, 0x39, 0x15,
0x1c, 0x9d, 0x87, 0xaa, 0x8b, 0x5d, 0x83, 0xda, 0xcf, 0xb1, 0xa8, 0x18, 0x15, 0x17, 0xbb, 0xbb,
0xf6, 0x73, 0x1c, 0xa2, 0xbc, 0xa9, 0x6b, 0xf8, 0xe4, 0x29, 0xed, 0x2e, 0x73, 0x94, 0x37, 0x75,
0x75, 0xf2, 0x94, 0xa2, 0x0b, 0x00, 0xb6, 0x67, 0xe1, 0x67, 0x86, 0x67, 0xba, 0xb8, 0x5b, 0x61,
0x19, 0x57, 0x63, 0x90, 0x6d, 0xd3, 0xc5, 0x61, 0xad, 0x60, 0x3f, 0x83, 0x7e, 0xb7, 0xca, 0x17,
0x8a, 0xdf, 0x70, 0xab, 0x22, 0x4f, 0x07, 0xfd, 0x6e, 0x8d, 0xaf, 0x8b, 0x01, 0xe8, 0x63, 0x68,
0x8a, 0x7d, 0x1b, 0x3c, 0x96, 0x81, 0xc5, 0xf2, 0xaa, 0xcc, 0xf7, 0xc2, 0x80, 0x3c, 0x92, 0x1b,
0x34, 0xf1, 0x87, 0xae, 0x40, 0x6b, 0x44, 0xdc, 0x89, 0xc9, 0xac, 0x73, 0xdb, 0x27, 0x6e, 0xb7,
0xce, 0xfc, 0x94, 0x81, 0xa2, 0x1b, 0x70, 0x76, 0xc4, 0xea, 0x96, 0x75, 0xeb, 0x60, 0x33, 0x46,
0x75, 0x1b, 0xab, 0xca, 0xb5, 0xaa, 0x2e, 0x43, 0xa1, 0x6f, 0x44, 0x49, 0xd6, 0x64, 0x8a, 0xbd,
0x29, 0x8f, 0xec, 0xa4, 0x66, 0x9c, 0x9e, 0x1d, 0x85, 0xb3, 0x21, 0x78, 0x9a, 0x74, 0xf9, 0x1a,
0x94, 0x6d, 0x6f, 0x8f, 0x44, 0xd9, 0xf1, 0xc6, 0x21, 0x16, 0x62, 0xc2, 0x38, 0xb5, 0xf6, 0x87,
0x22, 0x74, 0x3e, 0xb2, 0x2c, 0x59, 0x0f, 0x38, 0x7e, 0x2a, 0xcc, 0x42, 0xaa, 0x90, 0x0a, 0xa9,
0x45, 0xea, 0xe0, 0x3b, 0x70, 0x26, 0x53, 0xdf, 0x45, 0x64, 0xd6, 0x74, 0x35, 0x5d, 0xe1, 0x07,
0x7d, 0xf4, 0x36, 0xa8, 0xe9, 0x1a, 0x2f, 0xba, 0x5b, 0x4d, 0x6f, 0xa7, 0xaa, 0xfc, 0xa0, 0x8f,
0xbe, 0x0e, 0xaf, 0x8d, 0x1d, 0x32, 0x34, 0x1d, 0x83, 0x62, 0xd3, 0xc1, 0x96, 0x31, 0x4b, 0xac,
0x65, 0x16, 0x03, 0x2b, 0x1c, 0xbd, 0xcb, 0xb0, 0xbb, 0x71, 0x92, 0x6d, 0x85, 0x91, 0x87, 0x1f,
0x19, 0x13, 0x42, 0x59, 0xc6, 0xb0, 0x98, 0xae, 0x67, 0xab, 0x68, 0x3c, 0xff, 0xdc, 0xa5, 0xe3,
0x1d, 0x41, 0x19, 0xc6, 0x1e, 0x7e, 0x14, 0xfd, 0xa1, 0xcf, 0xa0, 0x23, 0x55, 0x80, 0x76, 0xab,
0x8b, 0x79, 0xea, 0x9c, 0x44, 0x41, 0xaa, 0xfd, 0x55, 0x81, 0xf3, 0x3a, 0x76, 0xc9, 0x13, 0xfc,
0xa5, 0xf5, 0x9d, 0xf6, 0xb7, 0x02, 0x74, 0xbe, 0x67, 0x06, 0xa3, 0xfd, 0xbe, 0x2b, 0x80, 0xf4,
0xe5, 0x6c, 0x30, 0x53, 0x4d, 0x4b, 0xf9, 0x6a, 0x1a, 0xa7, 0x5f, 0x59, 0xe6, 0xd4, 0x70, 0x10,
0x5e, 0xff, 0x3c, 0xda, 0xef, 0x2c, 0xfd, 0x12, 0xc7, 0xd0, 0xe5, 0x13, 0x1c, 0x43, 0xd1, 0x26,
0x34, 0xf1, 0xb3, 0x91, 0x33, 0xb5, 0xb0, 0xc1, 0xa5, 0x57, 0x98, 0xf4, 0x8b, 0x12, 0xe9, 0xc9,
0x88, 0x6a, 0x88, 0x45, 0x03, 0x56, 0x02, 0x7e, 0x54, 0x84, 0xb6, 0xc0, 0x86, 0x27, 0xf7, 0x05,
0x1a, 0x50, 0xc6, 0x1c, 0x85, 0xbc, 0x39, 0x16, 0x31, 0x6a, 0x74, 0x62, 0x2a, 0x25, 0x4e, 0x4c,
0x17, 0x00, 0xf6, 0x9c, 0x29, 0xdd, 0x37, 0x02, 0xdb, 0x8d, 0xda, 0x4f, 0x8d, 0x41, 0xee, 0xdb,
0x2e, 0x46, 0x1f, 0x41, 0x63, 0x68, 0x7b, 0x0e, 0x19, 0x1b, 0x13, 0x33, 0xd8, 0xa7, 0x2c, 0x83,
0xe5, 0xdb, 0xbd, 0x6d, 0x63, 0xc7, 0xba, 0xc5, 0x68, 0xf5, 0x3a, 0x5f, 0xb3, 0x13, 0x2e, 0x41,
0x17, 0xa1, 0x1e, 0xf6, 0x30, 0xb2, 0xc7, 0xdb, 0x58, 0x85, 0x8b, 0xf0, 0xa6, 0xee, 0xbd, 0x3d,
0xd6, 0xc8, 0xbe, 0x0d, 0xb5, 0xb0, 0xa2, 0x52, 0x87, 0x8c, 0xa3, 0x0c, 0x3d, 0x8a, 0xff, 0x6c,
0x01, 0xfa, 0x10, 0x6a, 0x16, 0x76, 0x02, 0x93, 0xad, 0xae, 0xcd, 0x0d, 0x85, 0x7e, 0x48, 0x73,
0x87, 0x8c, 0x99, 0x37, 0x66, 0x2b, 0xb4, 0x7f, 0x17, 0xe0, 0x6c, 0xe8, 0x83, 0x28, 0xcb, 0x4f,
0x1e, 0xed, 0x17, 0x00, 0x2c, 0x1a, 0x18, 0xa9, 0x88, 0xaf, 0x59, 0x34, 0xd8, 0xe6, 0x41, 0xff,
0x41, 0x14, 0xae, 0xc5, 0xf9, 0x67, 0xa9, 0x4c, 0x4c, 0xe4, 0x43, 0xf6, 0x24, 0xf3, 0x2b, 0xfa,
0x0e, 0xb4, 0x1c, 0x62, 0x5a, 0xc6, 0x88, 0x78, 0x16, 0x2f, 0xac, 0x65, 0xd6, 0x39, 0xdf, 0x92,
0xa9, 0x70, 0xdf, 0xb7, 0xc7, 0x63, 0xec, 0x6f, 0x46, 0xb4, 0x7a, 0xd3, 0x61, 0xd3, 0xbb, 0xf8,
0x45, 0x97, 0xa0, 0x49, 0xc9, 0xd4, 0x1f, 0xe1, 0x68, 0xa3, 0xfc, 0x54, 0xd2, 0xe0, 0xc0, 0x6d,
0x79, 0x82, 0x57, 0x24, 0x07, 0xb0, 0xbf, 0x28, 0xd0, 0x11, 0xf3, 0xdc, 0xe9, 0x6d, 0x3f, 0xaf,
0xd2, 0x44, 0x01, 0x5f, 0x3c, 0x64, 0x44, 0x28, 0x2d, 0x30, 0x22, 0x94, 0x25, 0x53, 0x5e, 0xfa,
0x14, 0xba, 0x9c, 0x3d, 0x85, 0x6a, 0xf7, 0xa1, 0x19, 0x17, 0x51, 0x96, 0xe1, 0x97, 0xa0, 0xc9,
0xd5, 0x32, 0x42, 0x93, 0x62, 0x2b, 0x1a, 0xf1, 0x38, 0xf0, 0x0e, 0x83, 0x85, 0x5c, 0xe3, 0x22,
0xcd, 0x4f, 0x16, 0x35, 0x3d, 0x01, 0xd1, 0x7e, 0x5f, 0x00, 0x35, 0xd9, 0x7e, 0x18, 0xe7, 0x45,
0x66, 0xc7, 0xab, 0xd0, 0x16, 0xb7, 0x8f, 0x71, 0x0f, 0x10, 0xd3, 0xdc, 0xe3, 0x24, 0xbb, 0x3e,
0x7a, 0x1f, 0x3a, 0x9c, 0x30, 0xd7, 0x33, 0xf8, 0x54, 0x77, 0x8e, 0x61, 0xf5, 0x4c, 0xd3, 0x9f,
0xdf, 0x73, 0x4b, 0xa7, 0xe8, 0xb9, 0xf9, 0x33, 0x41, 0xf9, 0x64, 0x67, 0x02, 0xed, 0xcf, 0x45,
0x68, 0xcd, 0x32, 0x64, 0x61, 0xab, 0x2d, 0x72, 0x2b, 0xb6, 0x0d, 0xea, 0x6c, 0x6c, 0x62, 0x47,
0xcd, 0x43, 0x93, 0x3c, 0x3b, 0x30, 0xb5, 0x27, 0x99, 0x39, 0xf3, 0x36, 0x34, 0x85, 0xcd, 0x45,
0x8b, 0xe1, 0x16, 0x7c, 0x53, 0xc6, 0x2c, 0x15, 0x61, 0x7a, 0x23, 0xd1, 0xef, 0x28, 0xfa, 0x00,
0x6a, 0x2c, 0xef, 0x83, 0x83, 0x09, 0x16, 0x29, 0xff, 0xba, 0x8c, 0x47, 0x18, 0x79, 0xf7, 0x0f,
0x26, 0x58, 0xaf, 0x3a, 0xe2, 0xeb, 0xb4, 0x4d, 0xf2, 0x26, 0xac, 0xf8, 0x3c, 0xb5, 0x2d, 0x23,
0x65, 0xbe, 0x0a, 0x33, 0xdf, 0xb9, 0x08, 0xb9, 0x93, 0x34, 0xe3, 0x9c, 0x11, 0xb8, 0x3a, 0x77,
0x04, 0xfe, 0x59, 0x01, 0x3a, 0xa1, 0xee, 0xb7, 0x4c, 0xc7, 0xf4, 0x46, 0x78, 0xf1, 0x69, 0xee,
0xbf, 0xd3, 0x4c, 0x73, 0x95, 0xb0, 0x24, 0xa9, 0x84, 0xe9, 0xa6, 0x50, 0xce, 0x36, 0x85, 0x37,
0xa0, 0x2e, 0x78, 0x58, 0xc4, 0xc3, 0xcc, 0xd8, 0x55, 0x1d, 0x38, 0xa8, 0x4f, 0x3c, 0x36, 0xff,
0x85, 0xeb, 0x19, 0xb6, 0xc2, 0xb0, 0x15, 0x8b, 0x06, 0x0c, 0x75, 0x01, 0xe0, 0x89, 0xe9, 0xd8,
0x16, 0x0b, 0x12, 0x66, 0xa6, 0xaa, 0x5e, 0x63, 0x90, 0xd0, 0x04, 0xda, 0x4f, 0x15, 0xe8, 0x7c,
0x62, 0x7a, 0x16, 0xd9, 0xdb, 0x3b, 0x7d, 0x7d, 0xdd, 0x84, 0x68, 0xba, 0x1b, 0x1c, 0x67, 0xe2,
0x49, 0x2d, 0xd2, 0xfe, 0xa8, 0x00, 0x4a, 0xf8, 0xeb, 0xe4, 0xda, 0x5c, 0x86, 0x56, 0xca, 0xf2,
0xf1, 0xe5, 0x7f, 0xd2, 0xf4, 0x34, 0xec, 0x7b, 0x43, 0x2e, 0xca, 0xf0, 0xb1, 0x49, 0x89, 0xc7,
0xdc, 0xb8, 0x70, 0xdf, 0x1b, 0x46, 0x6a, 0x86, 0x4b, 0xb5, 0x7f, 0x29, 0x70, 0x46, 0x6c, 0x2d,
0xcc, 0xb8, 0x31, 0x8e, 0x4a, 0x3a, 0xf1, 0x1c, 0xdb, 0x8b, 0x63, 0x40, 0xd4, 0x10, 0x0e, 0x14,
0x4e, 0xfe, 0x04, 0xda, 0x82, 0x28, 0xae, 0x89, 0x0b, 0xda, 0xaf, 0xc5, 0xd7, 0xc5, 0xd5, 0xf0,
0x32, 0xb4, 0xc8, 0xde, 0x5e, 0x52, 0x1e, 0x0f, 0xcc, 0xa6, 0x80, 0x0a, 0x81, 0x9f, 0x82, 0x1a,
0x91, 0x1d, 0xb7, 0x0a, 0xb7, 0xc5, 0xc2, 0x78, 0xe8, 0xf9, 0xb1, 0x02, 0xdd, 0x74, 0x4d, 0x4e,
0x6c, 0xff, 0xf8, 0xae, 0xfb, 0x56, 0x7a, 0x66, 0xbe, 0x7c, 0x88, 0x3e, 0x33, 0x39, 0xe2, 0x1c,
0xb4, 0xf6, 0x1c, 0x5a, 0xe9, 0xe2, 0x89, 0x1a, 0x50, 0xdd, 0x26, 0xc1, 0xc7, 0xcf, 0x6c, 0x1a,
0xa8, 0x4b, 0xa8, 0x05, 0xb0, 0x4d, 0x82, 0x1d, 0x1f, 0x53, 0xec, 0x05, 0xaa, 0x82, 0x00, 0x96,
0xef, 0x79, 0x7d, 0x9b, 0x3e, 0x52, 0x0b, 0xe8, 0xac, 0xb8, 0xcf, 0x33, 0x9d, 0x81, 0xa8, 0x24,
0x6a, 0x31, 0x5c, 0x1e, 0xff, 0x95, 0x90, 0x0a, 0x8d, 0x98, 0x64, 0x6b, 0xe7, 0x33, 0xb5, 0x8c,
0x6a, 0x50, 0xe6, 0x9f, 0xcb, 0x6b, 0xf7, 0x40, 0xcd, 0x86, 0x08, 0xaa, 0x43, 0x65, 0x9f, 0x67,
0x98, 0xba, 0x84, 0xda, 0x50, 0x77, 0x66, 0xc1, 0xad, 0x2a, 0x21, 0x60, 0xec, 0x4f, 0x46, 0x22,
0xcc, 0xd5, 0x42, 0x28, 0x2d, 0xf4, 0x5a, 0x9f, 0x3c, 0xf5, 0xd4, 0xe2, 0xda, 0xa7, 0xd0, 0x48,
0x5e, 0x52, 0xa0, 0x2a, 0x94, 0xb6, 0x89, 0x87, 0xd5, 0xa5, 0x90, 0xed, 0x96, 0x4f, 0x9e, 0xda,
0xde, 0x98, 0xef, 0xe1, 0xb6, 0x4f, 0x9e, 0x63, 0x4f, 0x2d, 0x84, 0x88, 0xb0, 0xb9, 0x86, 0x88,
0x62, 0x88, 0xe0, 0x9d, 0x56, 0x2d, 0xad, 0xbd, 0x07, 0xd5, 0xa8, 0x88, 0xa3, 0x33, 0xd0, 0x4c,
0xbd, 0x06, 0xa8, 0x4b, 0x08, 0xf1, 0x03, 0xe0, 0xac, 0x5c, 0xab, 0xca, 0xc6, 0x3f, 0x00, 0x80,
0x9f, 0x23, 0x08, 0xf1, 0x2d, 0x34, 0x01, 0xb4, 0x85, 0x83, 0x4d, 0xe2, 0x4e, 0x88, 0x17, 0xa9,
0x44, 0xd1, 0x8d, 0x39, 0x6d, 0x36, 0x4f, 0x2a, 0x76, 0xd9, 0xbb, 0x32, 0x67, 0x45, 0x86, 0x5c,
0x5b, 0x42, 0x2e, 0x93, 0x18, 0xce, 0x18, 0xf7, 0xed, 0xd1, 0xa3, 0xe8, 0x2a, 0xf9, 0x10, 0x89,
0x19, 0xd2, 0x48, 0x62, 0xa6, 0xc7, 0x8a, 0x9f, 0xdd, 0xc0, 0xb7, 0xbd, 0x71, 0x74, 0xbf, 0xa3,
0x2d, 0xa1, 0xc7, 0x70, 0x6e, 0x0b, 0x33, 0xe9, 0x36, 0x0d, 0xec, 0x11, 0x8d, 0x04, 0x6e, 0xcc,
0x17, 0x98, 0x23, 0x3e, 0xa6, 0x48, 0x07, 0xda, 0x99, 0x27, 0x4f, 0xb4, 0x26, 0x8d, 0x77, 0xe9,
0xf3, 0x6c, 0xef, 0x9d, 0x85, 0x68, 0x63, 0x69, 0x36, 0xb4, 0xd2, 0xcf, 0x81, 0xe8, 0xed, 0x79,
0x0c, 0x72, 0xef, 0x27, 0xbd, 0xb5, 0x45, 0x48, 0x63, 0x51, 0x0f, 0xa0, 0x95, 0x7e, 0x70, 0x92,
0x8b, 0x92, 0x3e, 0x4a, 0xf5, 0x0e, 0xbb, 0x5a, 0xd3, 0x96, 0xd0, 0x0f, 0xe0, 0x4c, 0xee, 0x95,
0x07, 0x7d, 0x55, 0xc6, 0x7e, 0xde, 0x63, 0xd0, 0x51, 0x12, 0x84, 0xf6, 0x33, 0x2b, 0xce, 0xd7,
0x3e, 0xf7, 0xdc, 0xb7, 0xb8, 0xf6, 0x09, 0xf6, 0x87, 0x69, 0x7f, 0x6c, 0x09, 0x53, 0x40, 0xf9,
0x77, 0x1e, 0xf4, 0xae, 0x4c, 0xc4, 0xdc, 0xb7, 0xa6, 0xde, 0xfa, 0xa2, 0xe4, 0xb1, 0xcb, 0xa7,
0x2c, 0x5b, 0xb3, 0x2f, 0x22, 0x52, 0xb1, 0x73, 0x9f, 0x78, 0xe4, 0x62, 0xe7, 0x3f, 0x62, 0xf0,
0xa0, 0x4e, 0xdf, 0xd8, 0xca, 0x7d, 0x25, 0x7d, 0x58, 0x90, 0x07, 0xb5, 0xfc, 0x02, 0x58, 0x5b,
0x42, 0x06, 0xc0, 0x16, 0x0e, 0xee, 0xe2, 0xc0, 0xb7, 0x47, 0x14, 0x5d, 0x91, 0xa6, 0xf8, 0x8c,
0x20, 0x92, 0x71, 0xf5, 0x48, 0xba, 0x48, 0xc0, 0xc6, 0x9f, 0x6a, 0x50, 0x63, 0xd6, 0x0d, 0xbb,
0xf4, 0xff, 0x0b, 0xee, 0x0b, 0x28, 0xb8, 0x0f, 0xa1, 0x9d, 0xb9, 0x58, 0x97, 0x17, 0x5c, 0xf9,
0xed, 0xfb, 0x51, 0x99, 0x37, 0x04, 0x94, 0xbf, 0xfd, 0x95, 0xa7, 0xc0, 0xdc, 0x5b, 0xe2, 0xa3,
0x64, 0x3c, 0x84, 0x76, 0xe6, 0xf6, 0x55, 0xbe, 0x03, 0xf9, 0x15, 0xed, 0x51, 0xdc, 0x3f, 0x87,
0x46, 0xf2, 0xaa, 0x0b, 0x5d, 0x9d, 0x57, 0xf7, 0x32, 0x03, 0xc3, 0xcb, 0xaf, 0x7a, 0x2f, 0xbe,
0x2b, 0x3c, 0x84, 0x76, 0xe6, 0x36, 0x4a, 0x6e, 0x79, 0xf9, 0x95, 0xd5, 0x51, 0xdc, 0xbf, 0x44,
0x75, 0xec, 0xd6, 0xfb, 0x0f, 0x36, 0xc6, 0x76, 0xb0, 0x3f, 0x1d, 0x86, 0xbb, 0xbc, 0xce, 0x29,
0xdf, 0xb5, 0x89, 0xf8, 0xba, 0x1e, 0x25, 0xf4, 0x75, 0xc6, 0xe9, 0x3a, 0xd3, 0x76, 0x32, 0x1c,
0x2e, 0xb3, 0xdf, 0x9b, 0xff, 0x09, 0x00, 0x00, 0xff, 0xff, 0xa4, 0xa4, 0xde, 0x9c, 0x03, 0x27,
0x00, 0x00,
// 2299 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x19, 0x4b, 0x6f, 0x1c, 0x49,
0xd9, 0x3d, 0x0f, 0x7b, 0xe6, 0x9b, 0x57, 0xa7, 0x12, 0xcf, 0x4e, 0x86, 0x24, 0xeb, 0xed, 0x6c,
0x1e, 0xeb, 0x65, 0x9d, 0xac, 0xb3, 0x3c, 0x56, 0xb0, 0x87, 0x8d, 0x67, 0xe3, 0x9d, 0x25, 0x71,
0x4c, 0x3b, 0xbb, 0x88, 0x28, 0x52, 0xd3, 0x33, 0x5d, 0x1e, 0xb7, 0xd2, 0xdd, 0x35, 0xe9, 0xea,
0x89, 0xe3, 0x9c, 0x39, 0xc0, 0x01, 0xf1, 0x03, 0x40, 0x48, 0x48, 0x20, 0xb4, 0x07, 0x8e, 0x70,
0xe0, 0x94, 0x9f, 0xc0, 0x2f, 0x40, 0x42, 0x70, 0x87, 0x0b, 0x9c, 0x51, 0x57, 0x55, 0xf7, 0xf4,
0xa3, 0xc6, 0x1e, 0xdb, 0x84, 0x44, 0x2b, 0x6e, 0xdd, 0x5f, 0x7d, 0xf5, 0xbd, 0x1f, 0xf5, 0x55,
0xc1, 0x99, 0x27, 0x13, 0xec, 0x1f, 0x18, 0x43, 0x42, 0x7c, 0x6b, 0x6d, 0xec, 0x93, 0x80, 0x20,
0xe4, 0xda, 0xce, 0xd3, 0x09, 0xe5, 0x7f, 0x6b, 0x6c, 0xbd, 0x5b, 0x1f, 0x12, 0xd7, 0x25, 0x1e,
0x87, 0x75, 0xeb, 0x49, 0x8c, 0x6e, 0xd3, 0xf6, 0x02, 0xec, 0x7b, 0xa6, 0x13, 0xad, 0xd2, 0xe1,
0x1e, 0x76, 0x4d, 0xf1, 0xa7, 0x5a, 0x66, 0x60, 0x26, 0xe9, 0x6b, 0x3f, 0x56, 0xa0, 0xbd, 0xb3,
0x47, 0xf6, 0x37, 0x88, 0xe3, 0xe0, 0x61, 0x60, 0x13, 0x8f, 0xea, 0xf8, 0xc9, 0x04, 0xd3, 0x00,
0xdd, 0x84, 0xd2, 0xc0, 0xa4, 0xb8, 0xa3, 0xac, 0x28, 0xd7, 0x6b, 0xeb, 0x17, 0xd6, 0x52, 0x92,
0x08, 0x11, 0xee, 0xd1, 0xd1, 0x6d, 0x93, 0x62, 0x9d, 0x61, 0x22, 0x04, 0x25, 0x6b, 0xd0, 0xef,
0x75, 0x0a, 0x2b, 0xca, 0xf5, 0xa2, 0xce, 0xbe, 0xd1, 0xdb, 0xd0, 0x18, 0xc6, 0xb4, 0xfb, 0x3d,
0xda, 0x29, 0xae, 0x14, 0xaf, 0x17, 0xf5, 0x34, 0x50, 0xfb, 0x9d, 0x02, 0x6f, 0xe4, 0xc4, 0xa0,
0x63, 0xe2, 0x51, 0x8c, 0x6e, 0xc1, 0x22, 0x0d, 0xcc, 0x60, 0x42, 0x85, 0x24, 0x5f, 0x93, 0x4a,
0xb2, 0xc3, 0x50, 0x74, 0x81, 0x9a, 0x67, 0x5b, 0x90, 0xb0, 0x45, 0xef, 0xc3, 0x39, 0xdb, 0xbb,
0x87, 0x5d, 0xe2, 0x1f, 0x18, 0x63, 0xec, 0x0f, 0xb1, 0x17, 0x98, 0x23, 0x1c, 0xc9, 0x78, 0x36,
0x5a, 0xdb, 0x9e, 0x2e, 0x69, 0xbf, 0x55, 0x60, 0x39, 0x94, 0x74, 0xdb, 0xf4, 0x03, 0xfb, 0x25,
0xd8, 0x4b, 0x83, 0x7a, 0x52, 0xc6, 0x4e, 0x91, 0xad, 0xa5, 0x60, 0x21, 0xce, 0x38, 0x62, 0x1f,
0xea, 0x56, 0x62, 0xe2, 0xa6, 0x60, 0xda, 0x6f, 0x84, 0x63, 0x93, 0x72, 0x9e, 0xc6, 0xa0, 0x59,
0x9e, 0x85, 0x3c, 0xcf, 0x93, 0x98, 0xf3, 0x85, 0x02, 0xcb, 0x77, 0x89, 0x69, 0x4d, 0x1d, 0xff,
0xbf, 0x37, 0xe7, 0x47, 0xb0, 0xc8, 0xb3, 0xa4, 0x53, 0x62, 0xbc, 0xae, 0xa4, 0x79, 0x89, 0x0c,
0x9a, 0x4a, 0xb8, 0xc3, 0x00, 0xba, 0xd8, 0xa4, 0xfd, 0x52, 0x81, 0x8e, 0x8e, 0x1d, 0x6c, 0x52,
0xfc, 0x2a, 0xb5, 0x68, 0xc3, 0xa2, 0x47, 0x2c, 0xdc, 0xef, 0x31, 0x2d, 0x8a, 0xba, 0xf8, 0xd3,
0xfe, 0x2e, 0x2c, 0xfc, 0x9a, 0x07, 0x6c, 0xc2, 0x0b, 0xe5, 0x93, 0x78, 0xe1, 0xc5, 0xd4, 0x0b,
0xaf, 0xbb, 0xa6, 0x53, 0x4f, 0x95, 0x53, 0x9e, 0xfa, 0x21, 0x9c, 0xdf, 0xf0, 0xb1, 0x19, 0xe0,
0xef, 0x87, 0x65, 0x7e, 0x63, 0xcf, 0xf4, 0x3c, 0xec, 0x44, 0x2a, 0x64, 0x99, 0x2b, 0x12, 0xe6,
0x1d, 0x58, 0x1a, 0xfb, 0xe4, 0xd9, 0x41, 0x2c, 0x77, 0xf4, 0xab, 0xfd, 0x5a, 0x81, 0xae, 0x8c,
0xf6, 0x69, 0x2a, 0xc2, 0x35, 0x68, 0xf9, 0x5c, 0x38, 0x63, 0xc8, 0xe9, 0x31, 0xae, 0x55, 0xbd,
0x29, 0xc0, 0x82, 0x0b, 0xba, 0x02, 0x4d, 0x1f, 0xd3, 0x89, 0x33, 0xc5, 0x2b, 0x32, 0xbc, 0x06,
0x87, 0x0a, 0x34, 0xed, 0x4b, 0x05, 0xce, 0x6f, 0xe2, 0x20, 0xf6, 0x5e, 0xc8, 0x0e, 0xbf, 0xa6,
0xd5, 0xf5, 0x57, 0x0a, 0xb4, 0x32, 0x82, 0xa2, 0x15, 0xa8, 0x25, 0x70, 0x84, 0x83, 0x92, 0x20,
0xf4, 0x6d, 0x28, 0x87, 0xb6, 0xc3, 0x4c, 0xa4, 0xe6, 0xba, 0xb6, 0x96, 0x6f, 0xee, 0x6b, 0x69,
0xaa, 0x3a, 0xdf, 0x80, 0x6e, 0xc0, 0x59, 0x49, 0x65, 0x15, 0xe2, 0xa3, 0x7c, 0x61, 0xd5, 0x7e,
0xaf, 0x40, 0x57, 0x66, 0xcc, 0xd3, 0x38, 0xfc, 0x21, 0xb4, 0x63, 0x6d, 0x0c, 0x0b, 0xd3, 0xa1,
0x6f, 0x8f, 0x59, 0x9a, 0xb1, 0x66, 0x50, 0x5b, 0xbf, 0x7c, 0xb4, 0x3e, 0x54, 0x5f, 0x8e, 0x49,
0xf4, 0x12, 0x14, 0xb4, 0x9f, 0x29, 0xb0, 0xbc, 0x89, 0x83, 0x1d, 0x3c, 0x72, 0xb1, 0x17, 0xf4,
0xbd, 0x5d, 0x72, 0x72, 0xc7, 0x5f, 0x02, 0xa0, 0x82, 0x4e, 0xdc, 0xa8, 0x12, 0x90, 0x79, 0x82,
0x40, 0xfb, 0x67, 0x11, 0x6a, 0x09, 0x61, 0xd0, 0x05, 0xa8, 0xc6, 0x14, 0x84, 0x6b, 0xa7, 0x80,
0x1c, 0xc5, 0x82, 0x24, 0xac, 0x32, 0xe1, 0x51, 0xcc, 0x87, 0xc7, 0x8c, 0x0a, 0x8e, 0xce, 0x43,
0xc5, 0xc5, 0xae, 0x41, 0xed, 0xe7, 0x58, 0x54, 0x8c, 0x25, 0x17, 0xbb, 0x3b, 0xf6, 0x73, 0x1c,
0x2e, 0x79, 0x13, 0xd7, 0xf0, 0xc9, 0x3e, 0xed, 0x2c, 0xf2, 0x25, 0x6f, 0xe2, 0xea, 0x64, 0x9f,
0xa2, 0x8b, 0x00, 0xb6, 0x67, 0xe1, 0x67, 0x86, 0x67, 0xba, 0xb8, 0xb3, 0xc4, 0x32, 0xae, 0xca,
0x20, 0x5b, 0xa6, 0x8b, 0xc3, 0x5a, 0xc1, 0x7e, 0xfa, 0xbd, 0x4e, 0x85, 0x6f, 0x14, 0xbf, 0xa1,
0xaa, 0x22, 0x4f, 0xfb, 0xbd, 0x4e, 0x95, 0xef, 0x8b, 0x01, 0xe8, 0x13, 0x68, 0x08, 0xbd, 0x0d,
0x1e, 0xcb, 0xc0, 0x62, 0x79, 0x45, 0xe6, 0x7b, 0x61, 0x40, 0x1e, 0xc9, 0x75, 0x9a, 0xf8, 0x43,
0x57, 0xa1, 0x39, 0x24, 0xee, 0xd8, 0x64, 0xd6, 0xb9, 0xe3, 0x13, 0xb7, 0x53, 0x63, 0x7e, 0xca,
0x40, 0xd1, 0x4d, 0x38, 0x3b, 0x64, 0x75, 0xcb, 0xba, 0x7d, 0xb0, 0x11, 0x2f, 0x75, 0xea, 0x2b,
0xca, 0xf5, 0x8a, 0x2e, 0x5b, 0x42, 0xdf, 0x8a, 0x92, 0xac, 0xc1, 0x04, 0x7b, 0x4b, 0x1e, 0xd9,
0x49, 0xc9, 0x38, 0x3e, 0x3b, 0x0a, 0x67, 0x43, 0xf0, 0x34, 0xe9, 0xf2, 0x0d, 0x28, 0xdb, 0xde,
0x2e, 0x89, 0xb2, 0xe3, 0xcd, 0x43, 0x2c, 0xc4, 0x98, 0x71, 0x6c, 0xed, 0x8f, 0x45, 0x68, 0x7f,
0x6c, 0x59, 0xb2, 0x1e, 0x70, 0xfc, 0x54, 0x98, 0x86, 0x54, 0x21, 0x15, 0x52, 0xf3, 0xd4, 0xc1,
0x77, 0xe1, 0x4c, 0xa6, 0xbe, 0x8b, 0xc8, 0xac, 0xea, 0x6a, 0xba, 0xc2, 0xf7, 0x7b, 0xe8, 0x1d,
0x50, 0xd3, 0x35, 0x5e, 0x74, 0xb7, 0xaa, 0xde, 0x4a, 0x55, 0xf9, 0x7e, 0x0f, 0x7d, 0x13, 0xde,
0x18, 0x39, 0x64, 0x60, 0x3a, 0x06, 0xc5, 0xa6, 0x83, 0x2d, 0x63, 0x9a, 0x58, 0x8b, 0x2c, 0x06,
0x96, 0xf9, 0xf2, 0x0e, 0x5b, 0xdd, 0x89, 0x93, 0x6c, 0x33, 0x8c, 0x3c, 0xfc, 0xd8, 0x18, 0x13,
0xca, 0x32, 0x86, 0xc5, 0x74, 0x2d, 0x5b, 0x45, 0xe3, 0xf9, 0xe7, 0x1e, 0x1d, 0x6d, 0x0b, 0xcc,
0x30, 0xf6, 0xf0, 0xe3, 0xe8, 0x0f, 0x7d, 0x0e, 0x6d, 0xa9, 0x00, 0xb4, 0x53, 0x99, 0xcf, 0x53,
0xe7, 0x24, 0x02, 0x52, 0xed, 0xaf, 0x0a, 0x9c, 0xd7, 0xb1, 0x4b, 0x9e, 0xe2, 0xaf, 0xac, 0xef,
0xb4, 0xbf, 0x15, 0xa0, 0xfd, 0x03, 0x33, 0x18, 0xee, 0xf5, 0x5c, 0x01, 0xa4, 0xaf, 0x46, 0xc1,
0x4c, 0x35, 0x2d, 0xe5, 0xab, 0x69, 0x9c, 0x7e, 0x65, 0x99, 0x53, 0xc3, 0x41, 0x78, 0xed, 0x8b,
0x48, 0xdf, 0x69, 0xfa, 0x25, 0x8e, 0xa1, 0x8b, 0x27, 0x38, 0x86, 0xa2, 0x0d, 0x68, 0xe0, 0x67,
0x43, 0x67, 0x62, 0x61, 0x83, 0x73, 0x5f, 0x62, 0xdc, 0x2f, 0x49, 0xb8, 0x27, 0x23, 0xaa, 0x2e,
0x36, 0xf5, 0x59, 0x09, 0x78, 0xa1, 0xc0, 0x79, 0x6e, 0x65, 0xec, 0x04, 0xe6, 0xab, 0x35, 0x74,
0x6c, 0xc6, 0xd2, 0x71, 0xcc, 0xa8, 0xfd, 0xa4, 0x08, 0x2d, 0xa1, 0x60, 0x38, 0x7c, 0xcc, 0xd1,
0x43, 0x33, 0x1e, 0x2d, 0xe4, 0x3d, 0x3a, 0x8f, 0xb8, 0xd1, 0xa1, 0xaf, 0x94, 0x38, 0xf4, 0x5d,
0x04, 0xd8, 0x75, 0x26, 0x74, 0xcf, 0x08, 0x6c, 0x37, 0xea, 0xa0, 0x55, 0x06, 0x79, 0x60, 0xbb,
0x18, 0x7d, 0x0c, 0xf5, 0x81, 0xed, 0x39, 0x64, 0x64, 0x8c, 0xcd, 0x60, 0x8f, 0xb2, 0x22, 0x24,
0xf7, 0xd8, 0x1d, 0x1b, 0x3b, 0xd6, 0x6d, 0x86, 0xab, 0xd7, 0xf8, 0x9e, 0xed, 0x70, 0x0b, 0xba,
0x04, 0xb5, 0xb0, 0x0d, 0x93, 0x5d, 0xde, 0x89, 0x97, 0x38, 0x0b, 0x6f, 0xe2, 0xde, 0xdf, 0x65,
0xbd, 0xf8, 0xbb, 0x50, 0x0d, 0x9b, 0x02, 0x75, 0xc8, 0x28, 0x2a, 0x32, 0x47, 0xd1, 0x9f, 0x6e,
0x40, 0x1f, 0x41, 0xd5, 0x0a, 0x03, 0x81, 0xed, 0xae, 0xce, 0x74, 0x03, 0x0b, 0x96, 0xbb, 0x64,
0xc4, 0xdc, 0x30, 0xdd, 0xa1, 0xfd, 0xbb, 0x00, 0x67, 0x43, 0x1f, 0x44, 0x85, 0xea, 0xe4, 0x71,
0x74, 0x11, 0xc0, 0xa2, 0x81, 0x91, 0x8a, 0xa5, 0xaa, 0x45, 0x83, 0x2d, 0x1e, 0x4e, 0x1f, 0x46,
0xa1, 0x52, 0x9c, 0x7d, 0x1c, 0xcc, 0xc4, 0x44, 0x3e, 0xeb, 0x4e, 0x32, 0x82, 0xa3, 0xef, 0x41,
0xd3, 0x21, 0xa6, 0x65, 0x0c, 0x89, 0x67, 0xf1, 0xde, 0x50, 0x66, 0xcd, 0xff, 0x6d, 0x99, 0x08,
0x0f, 0x7c, 0x7b, 0x34, 0xc2, 0xfe, 0x46, 0x84, 0xab, 0x37, 0x1c, 0x76, 0x01, 0x21, 0x7e, 0xd1,
0x65, 0x68, 0x50, 0x32, 0xf1, 0x87, 0x38, 0x52, 0x94, 0x1f, 0xac, 0xea, 0x1c, 0xb8, 0x25, 0x4f,
0x9d, 0x25, 0xc9, 0x19, 0xf2, 0x2f, 0x0a, 0xb4, 0xc5, 0x48, 0x7a, 0x7a, 0xdb, 0xcf, 0xca, 0xe1,
0x28, 0xe0, 0x8b, 0x87, 0x4c, 0x39, 0xa5, 0x39, 0xa6, 0x9c, 0xb2, 0x64, 0x50, 0x4d, 0x1f, 0xa4,
0x17, 0xb3, 0x07, 0x69, 0xed, 0x01, 0x34, 0xe2, 0x3e, 0xc0, 0x32, 0xfc, 0x32, 0x34, 0xb8, 0x58,
0x46, 0x68, 0x52, 0x6c, 0x45, 0x53, 0x2a, 0x07, 0xde, 0x65, 0xb0, 0x90, 0x6a, 0xdc, 0x67, 0xf8,
0xe1, 0xa8, 0xaa, 0x27, 0x20, 0xda, 0x1f, 0x0a, 0xa0, 0x26, 0x3b, 0x28, 0xa3, 0x3c, 0xcf, 0xf8,
0x7b, 0x0d, 0x5a, 0xe2, 0x02, 0x35, 0x6e, 0x63, 0x62, 0x20, 0x7d, 0x92, 0x24, 0xd7, 0x43, 0x1f,
0x40, 0x9b, 0x23, 0xe6, 0xda, 0x1e, 0x1f, 0x4c, 0xcf, 0xb1, 0x55, 0x3d, 0x73, 0x6e, 0x99, 0x7d,
0x6c, 0x28, 0x9d, 0xe2, 0xd8, 0x90, 0x3f, 0xd6, 0x94, 0x4f, 0x76, 0xac, 0xd1, 0xfe, 0x5c, 0x84,
0xe6, 0x34, 0x43, 0xe6, 0xb6, 0xda, 0x3c, 0x17, 0x7b, 0x5b, 0xa0, 0x4e, 0x27, 0x3f, 0x76, 0x5a,
0x3e, 0x34, 0xc9, 0xb3, 0x33, 0x5f, 0x6b, 0x9c, 0x19, 0x95, 0xef, 0x40, 0x43, 0xd8, 0xdc, 0x48,
0x36, 0x97, 0xb7, 0x64, 0xc4, 0x52, 0x11, 0xa6, 0xd7, 0x13, 0xbd, 0x86, 0xa2, 0x0f, 0xa1, 0xca,
0xf2, 0x3e, 0x38, 0x18, 0x63, 0x91, 0xf2, 0x17, 0x64, 0x34, 0xc2, 0xc8, 0x7b, 0x70, 0x30, 0xc6,
0x7a, 0xc5, 0x11, 0x5f, 0xa7, 0xed, 0xf3, 0xb7, 0x60, 0xd9, 0xe7, 0xa9, 0x6d, 0x19, 0x29, 0xf3,
0x2d, 0x31, 0xf3, 0x9d, 0x8b, 0x16, 0xb7, 0x93, 0x66, 0x9c, 0x31, 0xc5, 0x57, 0x66, 0x4e, 0xf1,
0xbf, 0x28, 0x40, 0x3b, 0x94, 0xfd, 0xb6, 0xe9, 0x98, 0xde, 0x10, 0xcf, 0x3f, 0x90, 0xfe, 0x77,
0x9a, 0x69, 0xae, 0x12, 0x96, 0x24, 0x95, 0x30, 0xdd, 0x14, 0xca, 0xd9, 0xa6, 0xf0, 0x26, 0xd4,
0x04, 0x0d, 0x8b, 0x78, 0x98, 0x19, 0xbb, 0xa2, 0x03, 0x07, 0xf5, 0x88, 0xc7, 0x46, 0xd8, 0x70,
0x3f, 0x5b, 0x5d, 0x62, 0xab, 0x4b, 0x16, 0x0d, 0xd8, 0xd2, 0x45, 0x80, 0xa7, 0xa6, 0x63, 0x5b,
0x2c, 0x48, 0x98, 0x99, 0x2a, 0x7a, 0x95, 0x41, 0x42, 0x13, 0x68, 0x3f, 0x57, 0xa0, 0xfd, 0xa9,
0xe9, 0x59, 0x64, 0x77, 0xf7, 0xf4, 0xf5, 0x75, 0x03, 0xa2, 0x01, 0xb5, 0x7f, 0x9c, 0xa1, 0x2d,
0xb5, 0x49, 0xfb, 0x93, 0x02, 0x28, 0xe1, 0xaf, 0x93, 0x4b, 0x73, 0x05, 0x9a, 0x29, 0xcb, 0xc7,
0xef, 0x17, 0x49, 0xd3, 0xd3, 0xb0, 0xef, 0x0d, 0x38, 0x2b, 0xc3, 0xc7, 0x26, 0x25, 0x1e, 0x73,
0xe3, 0xdc, 0x7d, 0x6f, 0x10, 0x89, 0x19, 0x6e, 0xd5, 0xfe, 0xa5, 0xc0, 0x19, 0xa1, 0x5a, 0x98,
0x71, 0x23, 0x1c, 0x95, 0x74, 0xe2, 0x39, 0xb6, 0x17, 0xc7, 0x80, 0xa8, 0x21, 0x1c, 0x28, 0x9c,
0xfc, 0x29, 0xb4, 0x04, 0x52, 0x5c, 0x13, 0xe7, 0xb4, 0x5f, 0x93, 0xef, 0x8b, 0xab, 0xe1, 0x15,
0x68, 0x92, 0xdd, 0xdd, 0x24, 0x3f, 0x1e, 0x98, 0x0d, 0x01, 0x15, 0x0c, 0x3f, 0x03, 0x35, 0x42,
0x3b, 0x6e, 0x15, 0x6e, 0x89, 0x8d, 0xf1, 0xdc, 0xf6, 0x53, 0x05, 0x3a, 0xe9, 0x9a, 0x9c, 0x50,
0xff, 0xf8, 0xae, 0xfb, 0x4e, 0x7a, 0xec, 0xbf, 0x72, 0x88, 0x3c, 0x53, 0x3e, 0xe2, 0x1c, 0xb4,
0xfa, 0x1c, 0x9a, 0xe9, 0xe2, 0x89, 0xea, 0x50, 0xd9, 0x22, 0xc1, 0x27, 0xcf, 0x6c, 0x1a, 0xa8,
0x0b, 0xa8, 0x09, 0xb0, 0x45, 0x82, 0x6d, 0x1f, 0x53, 0xec, 0x05, 0xaa, 0x82, 0x00, 0x16, 0xef,
0x7b, 0x3d, 0x9b, 0x3e, 0x56, 0x0b, 0xe8, 0xac, 0xb8, 0x92, 0x34, 0x9d, 0xbe, 0xa8, 0x24, 0x6a,
0x31, 0xdc, 0x1e, 0xff, 0x95, 0x90, 0x0a, 0xf5, 0x18, 0x65, 0x73, 0xfb, 0x73, 0xb5, 0x8c, 0xaa,
0x50, 0xe6, 0x9f, 0x8b, 0xab, 0xf7, 0x41, 0xcd, 0x86, 0x08, 0xaa, 0xc1, 0xd2, 0x1e, 0xcf, 0x30,
0x75, 0x01, 0xb5, 0xa0, 0xe6, 0x4c, 0x83, 0x5b, 0x55, 0x42, 0xc0, 0xc8, 0x1f, 0x0f, 0x45, 0x98,
0xab, 0x85, 0x90, 0x5b, 0xe8, 0xb5, 0x1e, 0xd9, 0xf7, 0xd4, 0xe2, 0xea, 0x67, 0x50, 0x4f, 0xde,
0xb3, 0xa0, 0x0a, 0x94, 0xb6, 0x88, 0x87, 0xd5, 0x85, 0x90, 0xec, 0xa6, 0x4f, 0xf6, 0x6d, 0x6f,
0xc4, 0x75, 0xb8, 0xe3, 0x93, 0xe7, 0xd8, 0x53, 0x0b, 0xe1, 0x42, 0xd8, 0x5c, 0xc3, 0x85, 0x62,
0xb8, 0xc0, 0x3b, 0xad, 0x5a, 0x5a, 0x7d, 0x1f, 0x2a, 0x51, 0x11, 0x47, 0x67, 0xa0, 0x91, 0x7a,
0xd0, 0x50, 0x17, 0x10, 0xe2, 0x07, 0xc0, 0x69, 0xb9, 0x56, 0x95, 0xf5, 0x7f, 0x00, 0x00, 0x3f,
0x47, 0x10, 0xe2, 0x5b, 0x68, 0x0c, 0x68, 0x13, 0x07, 0x1b, 0xc4, 0x1d, 0x13, 0x2f, 0x12, 0x89,
0xa2, 0x9b, 0x33, 0xda, 0x6c, 0x1e, 0x55, 0x68, 0xd9, 0xbd, 0x3a, 0x63, 0x47, 0x06, 0x5d, 0x5b,
0x40, 0x2e, 0xe3, 0x18, 0xce, 0x18, 0x0f, 0xec, 0xe1, 0xe3, 0xe8, 0x36, 0xfc, 0x10, 0x8e, 0x19,
0xd4, 0x88, 0x63, 0xa6, 0xc7, 0x8a, 0x9f, 0x9d, 0xc0, 0xb7, 0xbd, 0x51, 0x74, 0x45, 0xa5, 0x2d,
0xa0, 0x27, 0x70, 0x6e, 0x13, 0x33, 0xee, 0x36, 0x0d, 0xec, 0x21, 0x8d, 0x18, 0xae, 0xcf, 0x66,
0x98, 0x43, 0x3e, 0x26, 0x4b, 0x07, 0x5a, 0x99, 0x57, 0x5b, 0xb4, 0x2a, 0x8d, 0x77, 0xe9, 0x0b,
0x73, 0xf7, 0xdd, 0xb9, 0x70, 0x63, 0x6e, 0x36, 0x34, 0xd3, 0x2f, 0x9a, 0xe8, 0x9d, 0x59, 0x04,
0x72, 0x4f, 0x40, 0xdd, 0xd5, 0x79, 0x50, 0x63, 0x56, 0x0f, 0xa1, 0x99, 0x7e, 0x33, 0x93, 0xb3,
0x92, 0xbe, 0xab, 0x75, 0x0f, 0xbb, 0x1d, 0xd4, 0x16, 0xd0, 0x8f, 0xe0, 0x4c, 0xee, 0xa1, 0x0a,
0x7d, 0x5d, 0x46, 0x7e, 0xd6, 0x7b, 0xd6, 0x51, 0x1c, 0x84, 0xf4, 0x53, 0x2b, 0xce, 0x96, 0x3e,
0xf7, 0x62, 0x39, 0xbf, 0xf4, 0x09, 0xf2, 0x87, 0x49, 0x7f, 0x6c, 0x0e, 0x13, 0x40, 0xf9, 0xa7,
0x2a, 0xf4, 0x9e, 0x8c, 0xc5, 0xcc, 0xe7, 0xb2, 0xee, 0xda, 0xbc, 0xe8, 0xb1, 0xcb, 0x27, 0x2c,
0x5b, 0xb3, 0x8f, 0x3a, 0x52, 0xb6, 0x33, 0x5f, 0xa9, 0xe4, 0x6c, 0x67, 0xbf, 0xc3, 0xf0, 0xa0,
0x4e, 0x5f, 0x3a, 0xcb, 0x7d, 0x25, 0x7d, 0x1b, 0x91, 0x07, 0xb5, 0xfc, 0x0e, 0x5b, 0x5b, 0x40,
0x06, 0xc0, 0x26, 0x0e, 0xee, 0xe1, 0xc0, 0xb7, 0x87, 0x14, 0x5d, 0x95, 0xa6, 0xf8, 0x14, 0x21,
0xe2, 0x71, 0xed, 0x48, 0xbc, 0x88, 0xc1, 0xfa, 0x97, 0x00, 0x55, 0x66, 0xdd, 0xb0, 0x4b, 0xff,
0xbf, 0xe0, 0xbe, 0x84, 0x82, 0xfb, 0x08, 0x5a, 0x99, 0xb7, 0x01, 0x79, 0xc1, 0x95, 0x3f, 0x20,
0x1c, 0x95, 0x79, 0x03, 0x40, 0xf9, 0x0b, 0x6c, 0x79, 0x0a, 0xcc, 0xbc, 0xe8, 0x3e, 0x8a, 0xc7,
0x23, 0x68, 0x65, 0x2e, 0x90, 0xe5, 0x1a, 0xc8, 0x6f, 0x99, 0xe7, 0xd0, 0x20, 0x7f, 0x71, 0x2a,
0xd7, 0x60, 0xe6, 0x05, 0xeb, 0x51, 0x3c, 0xbe, 0x80, 0x7a, 0xf2, 0x3a, 0x0d, 0x5d, 0x9b, 0x55,
0x5b, 0x33, 0x43, 0xc9, 0xab, 0xaf, 0xac, 0x2f, 0xbf, 0xf3, 0x3c, 0x82, 0x56, 0xe6, 0xc6, 0x4b,
0xee, 0x5d, 0xf9, 0xb5, 0xd8, 0x51, 0xd4, 0xbf, 0x42, 0xb5, 0xf2, 0xf6, 0x07, 0x0f, 0xd7, 0x47,
0x76, 0xb0, 0x37, 0x19, 0x84, 0x5a, 0xde, 0xe0, 0x98, 0xef, 0xd9, 0x44, 0x7c, 0xdd, 0x88, 0x8a,
0xc6, 0x0d, 0x46, 0xe9, 0x06, 0x93, 0x76, 0x3c, 0x18, 0x2c, 0xb2, 0xdf, 0x5b, 0xff, 0x09, 0x00,
0x00, 0xff, 0xff, 0x2e, 0xfd, 0xc9, 0x8e, 0x2a, 0x28, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
@ -2918,6 +2983,7 @@ type QueryNodeClient interface {
AddQueryChannel(ctx context.Context, in *AddQueryChannelRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
RemoveQueryChannel(ctx context.Context, in *RemoveQueryChannelRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
WatchDmChannels(ctx context.Context, in *WatchDmChannelsRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
WatchDeltaChannels(ctx context.Context, in *WatchDeltaChannelsRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
LoadSegments(ctx context.Context, in *LoadSegmentsRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
ReleaseCollection(ctx context.Context, in *ReleaseCollectionRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
ReleasePartitions(ctx context.Context, in *ReleasePartitionsRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
@ -2989,6 +3055,15 @@ func (c *queryNodeClient) WatchDmChannels(ctx context.Context, in *WatchDmChanne
return out, nil
}
func (c *queryNodeClient) WatchDeltaChannels(ctx context.Context, in *WatchDeltaChannelsRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
out := new(commonpb.Status)
err := c.cc.Invoke(ctx, "/milvus.proto.query.QueryNode/WatchDeltaChannels", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *queryNodeClient) LoadSegments(ctx context.Context, in *LoadSegmentsRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
out := new(commonpb.Status)
err := c.cc.Invoke(ctx, "/milvus.proto.query.QueryNode/LoadSegments", in, out, opts...)
@ -3051,6 +3126,7 @@ type QueryNodeServer interface {
AddQueryChannel(context.Context, *AddQueryChannelRequest) (*commonpb.Status, error)
RemoveQueryChannel(context.Context, *RemoveQueryChannelRequest) (*commonpb.Status, error)
WatchDmChannels(context.Context, *WatchDmChannelsRequest) (*commonpb.Status, error)
WatchDeltaChannels(context.Context, *WatchDeltaChannelsRequest) (*commonpb.Status, error)
LoadSegments(context.Context, *LoadSegmentsRequest) (*commonpb.Status, error)
ReleaseCollection(context.Context, *ReleaseCollectionRequest) (*commonpb.Status, error)
ReleasePartitions(context.Context, *ReleasePartitionsRequest) (*commonpb.Status, error)
@ -3082,6 +3158,9 @@ func (*UnimplementedQueryNodeServer) RemoveQueryChannel(ctx context.Context, req
func (*UnimplementedQueryNodeServer) WatchDmChannels(ctx context.Context, req *WatchDmChannelsRequest) (*commonpb.Status, error) {
return nil, status.Errorf(codes.Unimplemented, "method WatchDmChannels not implemented")
}
func (*UnimplementedQueryNodeServer) WatchDeltaChannels(ctx context.Context, req *WatchDeltaChannelsRequest) (*commonpb.Status, error) {
return nil, status.Errorf(codes.Unimplemented, "method WatchDeltaChannels not implemented")
}
func (*UnimplementedQueryNodeServer) LoadSegments(ctx context.Context, req *LoadSegmentsRequest) (*commonpb.Status, error) {
return nil, status.Errorf(codes.Unimplemented, "method LoadSegments not implemented")
}
@ -3213,6 +3292,24 @@ func _QueryNode_WatchDmChannels_Handler(srv interface{}, ctx context.Context, de
return interceptor(ctx, in, info, handler)
}
func _QueryNode_WatchDeltaChannels_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(WatchDeltaChannelsRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(QueryNodeServer).WatchDeltaChannels(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/milvus.proto.query.QueryNode/WatchDeltaChannels",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(QueryNodeServer).WatchDeltaChannels(ctx, req.(*WatchDeltaChannelsRequest))
}
return interceptor(ctx, in, info, handler)
}
func _QueryNode_LoadSegments_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(LoadSegmentsRequest)
if err := dec(in); err != nil {
@ -3349,6 +3446,10 @@ var _QueryNode_serviceDesc = grpc.ServiceDesc{
MethodName: "WatchDmChannels",
Handler: _QueryNode_WatchDmChannels_Handler,
},
{
MethodName: "WatchDeltaChannels",
Handler: _QueryNode_WatchDeltaChannels_Handler,
},
{
MethodName: "LoadSegments",
Handler: _QueryNode_LoadSegments_Handler,

17
internal/querycoord/cluster.go
View File

@ -47,6 +47,7 @@ type Cluster interface {
getNumSegments(nodeID int64) (int, error)
watchDmChannels(ctx context.Context, nodeID int64, in *querypb.WatchDmChannelsRequest) error
watchDeltaChannels(ctx context.Context, nodeID int64, in *querypb.WatchDeltaChannelsRequest) error
//TODO:: removeDmChannel
getNumDmChannels(nodeID int64) (int, error)
@ -262,7 +263,6 @@ func (c *queryNodeCluster) watchDmChannels(ctx context.Context, nodeID int64, in
}
collectionID := in.CollectionID
//c.clusterMeta.addCollection(collectionID, in.Schema)
err = c.clusterMeta.addDmChannel(collectionID, nodeID, channels)
if err != nil {
log.Debug("WatchDmChannels: queryNode watch dm channel error", zap.String("error", err.Error()))
@ -274,6 +274,21 @@ func (c *queryNodeCluster) watchDmChannels(ctx context.Context, nodeID int64, in
return errors.New("WatchDmChannels: Can't find query node by nodeID ")
}
func (c *queryNodeCluster) watchDeltaChannels(ctx context.Context, nodeID int64, in *querypb.WatchDeltaChannelsRequest) error {
c.Lock()
defer c.Unlock()
if node, ok := c.nodes[nodeID]; ok {
err := node.watchDeltaChannels(ctx, in)
if err != nil {
log.Debug("WatchDeltaChannels: queryNode watch dm channel error", zap.String("error", err.Error()))
return err
}
return nil
}
return errors.New("WatchDeltaChannels: Can't find query node by nodeID ")
}
func (c *queryNodeCluster) hasWatchedQueryChannel(ctx context.Context, nodeID int64, collectionID UniqueID) bool {
c.Lock()
defer c.Unlock()

2
internal/querycoord/mock_3rd_component_test.go
View File

@ -361,7 +361,7 @@ func (data *dataCoordMock) GetRecoveryInfo(ctx context.Context, req *datapb.GetR
data.collections = append(data.collections, collectionID)
collectionName := funcutil.RandomString(8)
for i := int32(0); i < common.DefaultShardsNum; i++ {
vChannel := fmt.Sprintf("%s_%d_%d_v", collectionName, collectionID, i)
vChannel := fmt.Sprintf("Dml_%s_%d_%d_v", collectionName, collectionID, i)
channelInfo := &datapb.VchannelInfo{
CollectionID: collectionID,
ChannelName: vChannel,

4
internal/querycoord/mock_querynode_client_test.go
View File

@ -123,6 +123,10 @@ func (client *queryNodeClientMock) WatchDmChannels(ctx context.Context, req *que
return client.grpcClient.WatchDmChannels(ctx, req)
}
func (client *queryNodeClientMock) WatchDeltaChannels(ctx context.Context, req *querypb.WatchDeltaChannelsRequest) (*commonpb.Status, error) {
return client.grpcClient.WatchDeltaChannels(ctx, req)
}
func (client *queryNodeClientMock) LoadSegments(ctx context.Context, req *querypb.LoadSegmentsRequest) (*commonpb.Status, error) {
return client.grpcClient.LoadSegments(ctx, req)
}

6
internal/querycoord/mock_querynode_server_test.go
View File

@ -45,6 +45,7 @@ type queryNodeServerMock struct {
addQueryChannels func() (*commonpb.Status, error)
removeQueryChannels func() (*commonpb.Status, error)
watchDmChannels func() (*commonpb.Status, error)
watchDeltaChannels func() (*commonpb.Status, error)
loadSegment func() (*commonpb.Status, error)
releaseCollection func() (*commonpb.Status, error)
releasePartition func() (*commonpb.Status, error)
@ -61,6 +62,7 @@ func newQueryNodeServerMock(ctx context.Context) *queryNodeServerMock {
addQueryChannels: returnSuccessResult,
removeQueryChannels: returnSuccessResult,
watchDmChannels: returnSuccessResult,
watchDeltaChannels: returnSuccessResult,
loadSegment: returnSuccessResult,
releaseCollection: returnSuccessResult,
releasePartition: returnSuccessResult,
@ -166,6 +168,10 @@ func (qs *queryNodeServerMock) WatchDmChannels(ctx context.Context, req *querypb
return qs.watchDmChannels()
}
func (qs *queryNodeServerMock) WatchDeltaChannels(ctx context.Context, req *querypb.WatchDeltaChannelsRequest) (*commonpb.Status, error) {
return qs.watchDeltaChannels()
}
func (qs *queryNodeServerMock) LoadSegments(ctx context.Context, req *querypb.LoadSegmentsRequest) (*commonpb.Status, error) {
return qs.loadSegment()
}

24
internal/querycoord/param_table.go
View File

@ -62,6 +62,9 @@ type ParamTable struct {
CreatedTime time.Time
UpdatedTime time.Time
DmlChannelPrefix string
DeltaChannelPrefix string
// --- Pulsar ---
PulsarAddress string
@ -120,6 +123,9 @@ func (p *ParamTable) Init() {
//---- Handoff ---
p.initAutoHandoff()
p.initDmlChannelName()
p.initDeltaChannelName()
}
func (p *ParamTable) initQueryCoordAddress() {
@ -273,3 +279,21 @@ func (p *ParamTable) initAutoHandoff() {
panic(err)
}
}
func (p *ParamTable) initDmlChannelName() {
config, err := p.Load("msgChannel.chanNamePrefix.rootCoordDml")
if err != nil {
config = "rootcoord-dml"
}
s := []string{p.ClusterChannelPrefix, config}
p.DmlChannelPrefix = strings.Join(s, "-")
}
func (p *ParamTable) initDeltaChannelName() {
config, err := p.Load("msgChannel.chanNamePrefix.rootCoordDelta")
if err != nil {
config = "rootcoord-delta"
}
s := []string{p.ClusterChannelPrefix, config}
p.DeltaChannelPrefix = strings.Join(s, "-")
}

2
internal/querycoord/query_coord_test.go
View File

@ -41,6 +41,8 @@ func refreshParams() {
Params.StatsChannelName = Params.StatsChannelName + suffix
Params.TimeTickChannelName = Params.TimeTickChannelName + suffix
Params.MetaRootPath = Params.MetaRootPath + suffix
Params.DmlChannelPrefix = "Dml"
Params.DeltaChannelPrefix = "delta"
}
func TestMain(m *testing.M) {

16
internal/querycoord/querynode.go
View File

@ -46,6 +46,7 @@ type Node interface {
releasePartitions(ctx context.Context, in *querypb.ReleasePartitionsRequest) error
watchDmChannels(ctx context.Context, in *querypb.WatchDmChannelsRequest) error
watchDeltaChannels(ctx context.Context, in *querypb.WatchDeltaChannelsRequest) error
//removeDmChannel(collectionID UniqueID, channels []string) error
hasWatchedQueryChannel(collectionID UniqueID) bool
@ -413,6 +414,21 @@ func (qn *queryNode) watchDmChannels(ctx context.Context, in *querypb.WatchDmCha
return err
}
func (qn *queryNode) watchDeltaChannels(ctx context.Context, in *querypb.WatchDeltaChannelsRequest) error {
if !qn.isOnline() {
return errors.New("WatchDmChannels: queryNode is offline")
}
status, err := qn.client.WatchDeltaChannels(ctx, in)
if err != nil {
return err
}
if status.ErrorCode != commonpb.ErrorCode_Success {
return errors.New(status.Reason)
}
return err
}
func (qn *queryNode) addQueryChannel(ctx context.Context, in *querypb.AddQueryChannelRequest) error {
if !qn.isOnline() {
return errors.New("AddQueryChannel: queryNode is offline")

183
internal/querycoord/task.go
View File

@ -28,6 +28,7 @@ import (
"github.com/milvus-io/milvus/internal/proto/milvuspb"
"github.com/milvus-io/milvus/internal/proto/proxypb"
"github.com/milvus-io/milvus/internal/proto/querypb"
"github.com/milvus-io/milvus/internal/rootcoord"
"github.com/milvus-io/milvus/internal/types"
"github.com/milvus-io/milvus/internal/util/trace"
"github.com/opentracing/opentracing-go"
@ -351,6 +352,7 @@ func (lct *loadCollectionTask) execute(ctx context.Context) error {
watchDmChannelReqs := make([]*querypb.WatchDmChannelsRequest, 0)
channelsToWatch := make([]string, 0)
segmentsToLoad := make([]UniqueID, 0)
watchDeltaChannelReqs := make([]*querypb.WatchDeltaChannelsRequest, 0)
for _, partitionID := range toLoadPartitionIDs {
getRecoveryInfoRequest := &datapb.GetRecoveryInfoRequest{
Base: lct.Base,
@ -388,6 +390,27 @@ func (lct *loadCollectionTask) execute(ctx context.Context) error {
loadSegmentReqs = append(loadSegmentReqs, loadSegmentReq)
}
// init delta channels for sealed segments.
if len(loadSegmentReqs) != 0 && len(watchDeltaChannelReqs) != len(recoveryInfo.Channels) {
for _, info := range recoveryInfo.Channels {
deltaChannel, err := rootcoord.ConvertChannelName(info.ChannelName, Params.DmlChannelPrefix, Params.DeltaChannelPrefix)
if err != nil {
return err
}
deltaInfo := proto.Clone(info).(*datapb.VchannelInfo)
deltaInfo.ChannelName = deltaChannel
msgBase := proto.Clone(lct.Base).(*commonpb.MsgBase)
msgBase.MsgType = commonpb.MsgType_WatchDeltaChannels
watchDeltaRequest := &querypb.WatchDeltaChannelsRequest{
Base: msgBase,
CollectionID: collectionID,
Infos: []*datapb.VchannelInfo{deltaInfo},
}
watchDeltaChannelReqs = append(watchDeltaChannelReqs, watchDeltaRequest)
}
}
for _, info := range recoveryInfo.Channels {
channel := info.ChannelName
if !watchPartition {
@ -427,9 +450,10 @@ func (lct *loadCollectionTask) execute(ctx context.Context) error {
watchDmChannelReqs = append(watchDmChannelReqs, watchRequest)
}
}
}
err = assignInternalTask(ctx, collectionID, lct, lct.meta, lct.cluster, loadSegmentReqs, watchDmChannelReqs, false)
err = assignInternalTask(ctx, collectionID, lct, lct.meta, lct.cluster, loadSegmentReqs, watchDmChannelReqs, watchDeltaChannelReqs, false)
if err != nil {
log.Warn("loadCollectionTask: assign child task failed", zap.Int64("collectionID", collectionID))
lct.setResultInfo(err)
@ -679,6 +703,7 @@ func (lpt *loadPartitionTask) execute(ctx context.Context) error {
loadSegmentReqs := make([]*querypb.LoadSegmentsRequest, 0)
channelsToWatch := make([]string, 0)
watchDmReqs := make([]*querypb.WatchDmChannelsRequest, 0)
watchDeltaReqs := make([]*querypb.WatchDeltaChannelsRequest, 0)
for _, partitionID := range partitionIDs {
getRecoveryInfoRequest := &datapb.GetRecoveryInfoRequest{
Base: lpt.Base,
@ -715,7 +740,28 @@ func (lpt *loadPartitionTask) execute(ctx context.Context) error {
loadSegmentReqs = append(loadSegmentReqs, loadSegmentReq)
}
// init delta channels for sealed segments.
if len(loadSegmentReqs) != 0 && len(watchDeltaReqs) != len(recoveryInfo.Channels) {
for _, info := range recoveryInfo.Channels {
deltaChannel, err := rootcoord.ConvertChannelName(info.ChannelName, Params.DmlChannelPrefix, Params.DeltaChannelPrefix)
if err != nil {
return err
}
deltaInfo := proto.Clone(info).(*datapb.VchannelInfo)
deltaInfo.ChannelName = deltaChannel
msgBase := proto.Clone(lpt.Base).(*commonpb.MsgBase)
msgBase.MsgType = commonpb.MsgType_WatchDeltaChannels
watchDeltaRequest := &querypb.WatchDeltaChannelsRequest{
Base: msgBase,
CollectionID: collectionID,
Infos: []*datapb.VchannelInfo{deltaInfo},
}
watchDeltaReqs = append(watchDeltaReqs, watchDeltaRequest)
}
}
for _, info := range recoveryInfo.Channels {
// watch dml channels
channel := info.ChannelName
msgBase := proto.Clone(lpt.Base).(*commonpb.MsgBase)
msgBase.MsgType = commonpb.MsgType_WatchDmChannels
@ -729,9 +775,10 @@ func (lpt *loadPartitionTask) execute(ctx context.Context) error {
channelsToWatch = append(channelsToWatch, channel)
watchDmReqs = append(watchDmReqs, watchDmRequest)
log.Debug("loadPartitionTask: set watchDmChannelsRequests", zap.Any("request", watchDmRequest), zap.Int64("collectionID", collectionID))
}
}
err := assignInternalTask(ctx, collectionID, lpt, lpt.meta, lpt.cluster, loadSegmentReqs, watchDmReqs, false)
err := assignInternalTask(ctx, collectionID, lpt, lpt.meta, lpt.cluster, loadSegmentReqs, watchDmReqs, watchDeltaReqs, false)
if err != nil {
log.Warn("loadPartitionTask: assign child task failed", zap.Int64("collectionID", collectionID), zap.Int64s("partitionIDs", partitionIDs))
lpt.setResultInfo(err)
@ -1074,6 +1121,7 @@ func (lst *loadSegmentTask) reschedule(ctx context.Context) ([]task, error) {
reScheduledTask = append(reScheduledTask, watchQueryChannelTask)
log.Debug("loadSegmentTask: add a watchQueryChannelTask to RescheduleTasks", zap.Any("task", watchQueryChannelTask))
}
}
return reScheduledTask, nil
@ -1300,6 +1348,76 @@ func (wdt *watchDmChannelTask) reschedule(ctx context.Context) ([]task, error) {
return reScheduledTask, nil
}
type watchDeltaChannelTask struct {
*baseTask
*querypb.WatchDeltaChannelsRequest
meta Meta
cluster Cluster
excludeNodeIDs []int64
}
func (wdt *watchDeltaChannelTask) msgBase() *commonpb.MsgBase {
return wdt.Base
}
func (wdt *watchDeltaChannelTask) marshal() ([]byte, error) {
return proto.Marshal(wdt.WatchDeltaChannelsRequest)
}
func (wdt *watchDeltaChannelTask) msgType() commonpb.MsgType {
return wdt.Base.MsgType
}
func (wdt *watchDeltaChannelTask) timestamp() Timestamp {
return wdt.Base.Timestamp
}
func (wdt *watchDeltaChannelTask) updateTaskProcess() {
parentTask := wdt.getParentTask()
if parentTask == nil {
log.Warn("watchDeltaChannel: parentTask should not be nil")
return
}
parentTask.updateTaskProcess()
}
func (wdt *watchDeltaChannelTask) preExecute(context.Context) error {
channelInfos := wdt.Infos
channels := make([]string, 0)
for _, info := range channelInfos {
channels = append(channels, info.ChannelName)
}
wdt.setResultInfo(nil)
log.Debug("start do watchDeltaChannelTask",
zap.Strings("deltaChannels", channels),
zap.Int64("loaded nodeID", wdt.NodeID),
zap.Int64("taskID", wdt.getTaskID()))
return nil
}
func (wdt *watchDeltaChannelTask) execute(ctx context.Context) error {
defer func() {
wdt.retryCount--
}()
err := wdt.cluster.watchDeltaChannels(wdt.ctx, wdt.NodeID, wdt.WatchDeltaChannelsRequest)
if err != nil {
log.Warn("watchDeltaChannelTask: watchDeltaChannel occur error", zap.Int64("taskID", wdt.getTaskID()), zap.Error(err))
wdt.setResultInfo(err)
return err
}
log.Debug("watchDeltaChannelsTask Execute done",
zap.Int64("taskID", wdt.getTaskID()))
return nil
}
func (wdt *watchDeltaChannelTask) postExecute(context.Context) error {
log.Debug("watchDeltaChannelTask postExecute done",
zap.Int64("taskID", wdt.getTaskID()))
return nil
}
type watchQueryChannelTask struct {
*baseTask
*querypb.AddQueryChannelRequest
@ -1462,6 +1580,7 @@ func (ht *handoffTask) execute(ctx context.Context) error {
findBinlog := false
var loadSegmentReq *querypb.LoadSegmentsRequest
var watchDeltaChannelReqs []*querypb.WatchDeltaChannelsRequest
for _, segmentBinlogs := range recoveryInfo.Binlogs {
if segmentBinlogs.SegmentID == segmentID {
findBinlog = true
@ -1483,13 +1602,32 @@ func (ht *handoffTask) execute(ctx context.Context) error {
}
}
}
// init delta channels for sealed segments.
if loadSegmentReq != nil && len(watchDeltaChannelReqs) != len(recoveryInfo.Channels) {
for _, info := range recoveryInfo.Channels {
deltaChannel, err := rootcoord.ConvertChannelName(info.ChannelName, Params.DmlChannelPrefix, Params.DeltaChannelPrefix)
if err != nil {
return err
}
deltaInfo := proto.Clone(info).(*datapb.VchannelInfo)
deltaInfo.ChannelName = deltaChannel
msgBase := proto.Clone(ht.Base).(*commonpb.MsgBase)
msgBase.MsgType = commonpb.MsgType_WatchDeltaChannels
watchDeltaChannelsRequest := &querypb.WatchDeltaChannelsRequest{
Base: msgBase,
CollectionID: collectionID,
Infos: []*datapb.VchannelInfo{deltaInfo},
}
watchDeltaChannelReqs = append(watchDeltaChannelReqs, watchDeltaChannelsRequest)
}
}
if !findBinlog {
err = fmt.Errorf("segmnet has not been flushed, segmentID is %d", segmentID)
ht.setResultInfo(err)
return err
}
err = assignInternalTask(ctx, collectionID, ht, ht.meta, ht.cluster, []*querypb.LoadSegmentsRequest{loadSegmentReq}, nil, true)
err = assignInternalTask(ctx, collectionID, ht, ht.meta, ht.cluster, []*querypb.LoadSegmentsRequest{loadSegmentReq}, nil, watchDeltaChannelReqs, true)
if err != nil {
log.Error("handoffTask: assign child task failed", zap.Any("segmentInfo", segmentInfo))
ht.setResultInfo(err)
@ -1591,6 +1729,7 @@ func (lbt *loadBalanceTask) execute(ctx context.Context) error {
loadSegmentReqs := make([]*querypb.LoadSegmentsRequest, 0)
channelsToWatch := make([]string, 0)
watchDmChannelReqs := make([]*querypb.WatchDmChannelsRequest, 0)
watchDeltaChannelReqs := make([]*querypb.WatchDeltaChannelsRequest, 0)
dmChannels, err := lbt.meta.getDmChannelsByNodeID(collectionID, nodeID)
if err != nil {
@ -1638,6 +1777,23 @@ func (lbt *loadBalanceTask) execute(ctx context.Context) error {
loadSegmentReqs = append(loadSegmentReqs, loadSegmentReq)
}
// init delta channels for sealed segments.
if len(loadSegmentReqs) != 0 && len(watchDeltaChannelReqs) != len(recoveryInfo.Channels) {
for _, info := range recoveryInfo.Channels {
deltaChannel := info.ChannelName
deltaInfo := proto.Clone(info).(*datapb.VchannelInfo)
deltaInfo.ChannelName = deltaChannel
msgBase := proto.Clone(lbt.Base).(*commonpb.MsgBase)
msgBase.MsgType = commonpb.MsgType_WatchDeltaChannels
watchDeltaChannelsRequest := &querypb.WatchDeltaChannelsRequest{
Base: msgBase,
CollectionID: collectionID,
Infos: []*datapb.VchannelInfo{info},
}
watchDeltaChannelReqs = append(watchDeltaChannelReqs, watchDeltaChannelsRequest)
}
}
for _, channelInfo := range recoveryInfo.Channels {
for _, channel := range dmChannels {
if channelInfo.ChannelName == channel {
@ -1682,7 +1838,7 @@ func (lbt *loadBalanceTask) execute(ctx context.Context) error {
}
}
}
err = assignInternalTask(ctx, collectionID, lbt, lbt.meta, lbt.cluster, loadSegmentReqs, watchDmChannelReqs, true)
err = assignInternalTask(ctx, collectionID, lbt, lbt.meta, lbt.cluster, loadSegmentReqs, watchDmChannelReqs, watchDeltaChannelReqs, true)
if err != nil {
log.Warn("loadBalanceTask: assign child task failed", zap.Int64("collectionID", collectionID), zap.Int64s("partitionIDs", partitionIDs))
lbt.setResultInfo(err)
@ -1900,6 +2056,7 @@ func assignInternalTask(ctx context.Context,
cluster Cluster,
loadSegmentRequests []*querypb.LoadSegmentsRequest,
watchDmChannelRequests []*querypb.WatchDmChannelsRequest,
watchDeltaChannelRequests []*querypb.WatchDeltaChannelsRequest,
wait bool) error {
sp, _ := trace.StartSpanFromContext(ctx)
defer sp.Finish()
@ -1974,6 +2131,24 @@ func assignInternalTask(ctx context.Context,
parentTask.addChildTask(loadSegmentTask)
log.Debug("assignInternalTask: add a loadSegmentTask childTask", zap.Any("task", loadSegmentTask))
}
for _, req := range watchDeltaChannelRequests {
ctx = opentracing.ContextWithSpan(context.Background(), sp)
watchDeltaRequest := proto.Clone(req).(*querypb.WatchDeltaChannelsRequest)
watchDeltaRequest.NodeID = nodeID
baseTask := newBaseTask(ctx, parentTask.getTriggerCondition())
baseTask.setParentTask(parentTask)
watchDeltaTask := &watchDeltaChannelTask{
baseTask: baseTask,
WatchDeltaChannelsRequest: watchDeltaRequest,
meta: meta,
cluster: cluster,
excludeNodeIDs: []int64{},
}
parentTask.addChildTask(watchDeltaTask)
log.Debug("assignInternalTask: add a watchDeltaChannelTask childTask", zap.Any("task", watchDeltaTask))
}
}
for index, nodeID := range watchRequest2Nodes {

19
internal/querycoord/task_scheduler.go
View File

@ -358,6 +358,21 @@ func (scheduler *TaskScheduler) unmarshalTask(taskID UniqueID, t string) (task,
excludeNodeIDs: []int64{},
}
newTask = watchDmChannelTask
case commonpb.MsgType_WatchDeltaChannels:
//TODO::trigger condition may be different
loadReq := querypb.WatchDeltaChannelsRequest{}
err = proto.Unmarshal([]byte(t), &loadReq)
if err != nil {
return nil, err
}
watchDeltaChannelTask := &watchDeltaChannelTask{
baseTask: baseTask,
WatchDeltaChannelsRequest: &loadReq,
cluster: scheduler.cluster,
meta: scheduler.meta,
excludeNodeIDs: []int64{},
}
newTask = watchDeltaChannelTask
case commonpb.MsgType_WatchQueryChannels:
//TODO::trigger condition may be different
loadReq := querypb.AddQueryChannelRequest{}
@ -463,6 +478,8 @@ func (scheduler *TaskScheduler) processTask(t task) error {
protoSize = proto.Size(childTask.(*loadSegmentTask).LoadSegmentsRequest)
case commonpb.MsgType_WatchDmChannels:
protoSize = proto.Size(childTask.(*watchDmChannelTask).WatchDmChannelsRequest)
case commonpb.MsgType_WatchDeltaChannels:
protoSize = proto.Size(childTask.(*watchDeltaChannelTask).WatchDeltaChannelsRequest)
case commonpb.MsgType_WatchQueryChannels:
protoSize = proto.Size(childTask.(*watchQueryChannelTask).AddQueryChannelRequest)
default:
@ -816,6 +833,8 @@ func (scheduler *TaskScheduler) waitActivateTaskDone(wg *sync.WaitGroup, t task,
redoFunc1()
case commonpb.MsgType_WatchDmChannels:
redoFunc1()
case commonpb.MsgType_WatchDeltaChannels:
redoFunc2(err)
case commonpb.MsgType_WatchQueryChannels:
redoFunc2(err)
case commonpb.MsgType_ReleaseSegments:

27
internal/querycoord/task_scheduler_test.go
View File

@ -355,6 +355,27 @@ func TestUnMarshalTask(t *testing.T) {
assert.Equal(t, task.msgType(), commonpb.MsgType_WatchDmChannels)
})
t.Run("Test watchDeltaChannelTask", func(t *testing.T) {
watchTask := &watchDeltaChannelTask{
WatchDeltaChannelsRequest: &querypb.WatchDeltaChannelsRequest{
Base: &commonpb.MsgBase{
MsgType: commonpb.MsgType_WatchDeltaChannels,
},
},
}
blobs, err := watchTask.marshal()
assert.Nil(t, err)
err = kv.Save("testMarshalWatchDeltaChannel", string(blobs))
assert.Nil(t, err)
defer kv.RemoveWithPrefix("testMarshalWatchDeltaChannel")
value, err := kv.Load("testMarshalWatchDeltaChannel")
assert.Nil(t, err)
task, err := taskScheduler.unmarshalTask(1007, value)
assert.Nil(t, err)
assert.Equal(t, task.msgType(), commonpb.MsgType_WatchDeltaChannels)
})
t.Run("Test watchQueryChannelTask", func(t *testing.T) {
watchTask := &watchQueryChannelTask{
AddQueryChannelRequest: &querypb.AddQueryChannelRequest{
@ -371,7 +392,7 @@ func TestUnMarshalTask(t *testing.T) {
value, err := kv.Load("testMarshalWatchQueryChannel")
assert.Nil(t, err)
task, err := taskScheduler.unmarshalTask(1007, value)
task, err := taskScheduler.unmarshalTask(1008, value)
assert.Nil(t, err)
assert.Equal(t, task.msgType(), commonpb.MsgType_WatchQueryChannels)
})
@ -393,7 +414,7 @@ func TestUnMarshalTask(t *testing.T) {
value, err := kv.Load("testMarshalLoadBalanceTask")
assert.Nil(t, err)
task, err := taskScheduler.unmarshalTask(1008, value)
task, err := taskScheduler.unmarshalTask(1009, value)
assert.Nil(t, err)
assert.Equal(t, task.msgType(), commonpb.MsgType_LoadBalanceSegments)
})
@ -415,7 +436,7 @@ func TestUnMarshalTask(t *testing.T) {
value, err := kv.Load("testMarshalHandoffTask")
assert.Nil(t, err)
task, err := taskScheduler.unmarshalTask(1008, value)
task, err := taskScheduler.unmarshalTask(1010, value)
assert.Nil(t, err)
assert.Equal(t, task.msgType(), commonpb.MsgType_HandoffSegments)
})

2
internal/querycoord/task_test.go
View File

@ -694,7 +694,7 @@ func Test_AssignInternalTask(t *testing.T) {
loadSegmentRequests = append(loadSegmentRequests, req)
}
err = assignInternalTask(queryCoord.loopCtx, defaultCollectionID, loadCollectionTask, queryCoord.meta, queryCoord.cluster, loadSegmentRequests, nil, false)
err = assignInternalTask(queryCoord.loopCtx, defaultCollectionID, loadCollectionTask, queryCoord.meta, queryCoord.cluster, loadSegmentRequests, nil, nil, false)
assert.Nil(t, err)
assert.NotEqual(t, 1, len(loadCollectionTask.getChildTask()))

7
internal/querynode/impl.go
View File

@ -278,6 +278,13 @@ func (node *QueryNode) WatchDmChannels(ctx context.Context, in *queryPb.WatchDmC
return waitFunc()
}
// WatchDeltaChannels create consumers on dmChannels to reveive Incremental data，which is the important part of real-time query
func (node *QueryNode) WatchDeltaChannels(ctx context.Context, in *queryPb.WatchDeltaChannelsRequest) (*commonpb.Status, error) {
return &commonpb.Status{
ErrorCode: commonpb.ErrorCode_Success,
}, nil
}
// LoadSegments load historical data into query node, historical data can be vector data or index
func (node *QueryNode) LoadSegments(ctx context.Context, in *queryPb.LoadSegmentsRequest) (*commonpb.Status, error) {
code := node.stateCode.Load().(internalpb.StateCode)

1
internal/types/types.go
View File

@ -953,6 +953,7 @@ type QueryNode interface {
AddQueryChannel(ctx context.Context, req *querypb.AddQueryChannelRequest) (*commonpb.Status, error)
RemoveQueryChannel(ctx context.Context, req *querypb.RemoveQueryChannelRequest) (*commonpb.Status, error)
WatchDmChannels(ctx context.Context, req *querypb.WatchDmChannelsRequest) (*commonpb.Status, error)
WatchDeltaChannels(ctx context.Context, req *querypb.WatchDeltaChannelsRequest) (*commonpb.Status, error)
// LoadSegments notifies QueryNode to load the sealed segments from storage. The load tasks are sync to this
// rpc, QueryNode will return after all the sealed segments are loaded.
//