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

Add SyncReplicaSegments interface for QueryNode (#16672) 

Add SyncReplicaSegments for LoadCollection/LoadPartition child task
This API notifies related ShardCluster to record segment Loaded
Preventing the Etcd events is delayed, which will cause some segment not search

Signed-off-by: Congqi Xia <congqi.xia@zilliz.com>
pull/16677/head
congqixia 2022-04-27 10:41:46 +08:00 committed by GitHub
parent b657b10eb5
commit 0bf176a7e1
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
16 changed files with 684 additions and 185 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -284,6 +284,20 @@ func (c *Client) GetSegmentInfo(ctx context.Context, req *querypb.GetSegmentInfo
return ret.(*querypb.GetSegmentInfoResponse), err
}
// SyncReplicaSegments syncs replica node segments information to shard leaders.
func (c *Client) SyncReplicaSegments(ctx context.Context, req *querypb.SyncReplicaSegmentsRequest) (*commonpb.Status, error) {
ret, err := c.grpcClient.ReCall(ctx, func(client interface{}) (interface{}, error) {
if !funcutil.CheckCtxValid(ctx) {
return nil, ctx.Err()
}
return client.(querypb.QueryNodeClient).SyncReplicaSegments(ctx, req)
})
if err != nil || ret == nil {
return nil, err
}
return ret.(*commonpb.Status), err
}
// GetMetrics gets the metrics information of QueryNode.
func (c *Client) GetMetrics(ctx context.Context, req *milvuspb.GetMetricsRequest) (*milvuspb.GetMetricsResponse, error) {
ret, err := c.grpcClient.ReCall(ctx, func(client interface{}) (interface{}, error) {

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

@ -104,6 +104,9 @@ func Test_NewClient(t *testing.T) {
r15, err := client.Query(ctx, nil)
retCheck(retNotNil, r15, err)
r16, err := client.SyncReplicaSegments(ctx, nil)
retCheck(retNotNil, r16, err)
}
client.grpcClient = &mock.ClientBase{

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

@ -315,6 +315,11 @@ func (s *Server) Query(ctx context.Context, req *querypb.QueryRequest) (*interna
return s.querynode.Query(ctx, req)
}
// SyncReplicaSegments syncs replica segment information to shard leader
func (s *Server) SyncReplicaSegments(ctx context.Context, req *querypb.SyncReplicaSegmentsRequest) (*commonpb.Status, error) {
return s.querynode.SyncReplicaSegments(ctx, req)
}
// GetMetrics gets the metrics information of QueryNode.
func (s *Server) GetMetrics(ctx context.Context, req *milvuspb.GetMetricsRequest) (*milvuspb.GetMetricsResponse, error) {
return s.querynode.GetMetrics(ctx, req)

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

@ -124,6 +124,10 @@ func (m *MockQueryNode) Query(ctx context.Context, req *querypb.QueryRequest) (*
return m.queryResp, m.err
}
func (m *MockQueryNode) SyncReplicaSegments(ctx context.Context, req *querypb.SyncReplicaSegmentsRequest) (*commonpb.Status, error) {
return m.status, m.err
}
func (m *MockQueryNode) SetEtcdClient(client *clientv3.Client) {
}
@ -332,6 +336,13 @@ func Test_NewServer(t *testing.T) {
assert.Equal(t, commonpb.ErrorCode_Success, resp.GetStatus().GetErrorCode())
})
t.Run("SyncReplicaSegments", func(t *testing.T) {
req := &querypb.SyncReplicaSegmentsRequest{}
resp, err := server.SyncReplicaSegments(ctx, req)
assert.NoError(t, err)
assert.Equal(t, commonpb.ErrorCode_Success, resp.GetErrorCode())
})
err = server.Stop()
assert.Nil(t, err)
}

13
internal/proto/query_coord.proto
View File

@ -50,6 +50,7 @@ service QueryNode {
rpc ReleasePartitions(ReleasePartitionsRequest) returns (common.Status) {}
rpc ReleaseSegments(ReleaseSegmentsRequest) returns (common.Status) {}
rpc GetSegmentInfo(GetSegmentInfoRequest) returns (GetSegmentInfoResponse) {}
rpc SyncReplicaSegments(SyncReplicaSegmentsRequest) returns (common.Status) {}
rpc Search(SearchRequest) returns (internal.SearchResults) {}
rpc Query(QueryRequest) returns (internal.RetrieveResults) {}
@ -272,6 +273,18 @@ message QueryRequest {
repeated int64 segmentIDs = 3;
}
message SyncReplicaSegmentsRequest {
common.MsgBase base = 1;
string vchannel_name = 2;
repeated ReplicaSegmentsInfo replica_segments = 3;
}
message ReplicaSegmentsInfo {
int64 node_id = 1;
int64 partition_id = 2;
repeated int64 segment_ids = 3;
}
//----------------request auto triggered by QueryCoord-----------------
message HandoffSegmentsRequest {
common.MsgBase base = 1;

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

@ -2012,6 +2012,116 @@ func (m *QueryRequest) GetSegmentIDs() []int64 {
return nil
}
type SyncReplicaSegmentsRequest struct {
Base *commonpb.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
VchannelName string `protobuf:"bytes,2,opt,name=vchannel_name,json=vchannelName,proto3" json:"vchannel_name,omitempty"`
ReplicaSegments []*ReplicaSegmentsInfo `protobuf:"bytes,3,rep,name=replica_segments,json=replicaSegments,proto3" json:"replica_segments,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *SyncReplicaSegmentsRequest) Reset() { *m = SyncReplicaSegmentsRequest{} }
func (m *SyncReplicaSegmentsRequest) String() string { return proto.CompactTextString(m) }
func (*SyncReplicaSegmentsRequest) ProtoMessage() {}
func (*SyncReplicaSegmentsRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_aab7cc9a69ed26e8, []int{28}
}
func (m *SyncReplicaSegmentsRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_SyncReplicaSegmentsRequest.Unmarshal(m, b)
}
func (m *SyncReplicaSegmentsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_SyncReplicaSegmentsRequest.Marshal(b, m, deterministic)
}
func (m *SyncReplicaSegmentsRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_SyncReplicaSegmentsRequest.Merge(m, src)
}
func (m *SyncReplicaSegmentsRequest) XXX_Size() int {
return xxx_messageInfo_SyncReplicaSegmentsRequest.Size(m)
}
func (m *SyncReplicaSegmentsRequest) XXX_DiscardUnknown() {
xxx_messageInfo_SyncReplicaSegmentsRequest.DiscardUnknown(m)
}
var xxx_messageInfo_SyncReplicaSegmentsRequest proto.InternalMessageInfo
func (m *SyncReplicaSegmentsRequest) GetBase() *commonpb.MsgBase {
if m != nil {
return m.Base
}
return nil
}
func (m *SyncReplicaSegmentsRequest) GetVchannelName() string {
if m != nil {
return m.VchannelName
}
return ""
}
func (m *SyncReplicaSegmentsRequest) GetReplicaSegments() []*ReplicaSegmentsInfo {
if m != nil {
return m.ReplicaSegments
}
return nil
}
type ReplicaSegmentsInfo struct {
NodeId int64 `protobuf:"varint,1,opt,name=node_id,json=nodeId,proto3" json:"node_id,omitempty"`
PartitionId int64 `protobuf:"varint,2,opt,name=partition_id,json=partitionId,proto3" json:"partition_id,omitempty"`
SegmentIds []int64 `protobuf:"varint,3,rep,packed,name=segment_ids,json=segmentIds,proto3" json:"segment_ids,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ReplicaSegmentsInfo) Reset() { *m = ReplicaSegmentsInfo{} }
func (m *ReplicaSegmentsInfo) String() string { return proto.CompactTextString(m) }
func (*ReplicaSegmentsInfo) ProtoMessage() {}
func (*ReplicaSegmentsInfo) Descriptor() ([]byte, []int) {
return fileDescriptor_aab7cc9a69ed26e8, []int{29}
}
func (m *ReplicaSegmentsInfo) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ReplicaSegmentsInfo.Unmarshal(m, b)
}
func (m *ReplicaSegmentsInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ReplicaSegmentsInfo.Marshal(b, m, deterministic)
}
func (m *ReplicaSegmentsInfo) XXX_Merge(src proto.Message) {
xxx_messageInfo_ReplicaSegmentsInfo.Merge(m, src)
}
func (m *ReplicaSegmentsInfo) XXX_Size() int {
return xxx_messageInfo_ReplicaSegmentsInfo.Size(m)
}
func (m *ReplicaSegmentsInfo) XXX_DiscardUnknown() {
xxx_messageInfo_ReplicaSegmentsInfo.DiscardUnknown(m)
}
var xxx_messageInfo_ReplicaSegmentsInfo proto.InternalMessageInfo
func (m *ReplicaSegmentsInfo) GetNodeId() int64 {
if m != nil {
return m.NodeId
}
return 0
}
func (m *ReplicaSegmentsInfo) GetPartitionId() int64 {
if m != nil {
return m.PartitionId
}
return 0
}
func (m *ReplicaSegmentsInfo) GetSegmentIds() []int64 {
if m != nil {
return m.SegmentIds
}
return nil
}
//----------------request auto triggered by QueryCoord-----------------
type HandoffSegmentsRequest struct {
Base *commonpb.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
@ -2025,7 +2135,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{28}
return fileDescriptor_aab7cc9a69ed26e8, []int{30}
}
func (m *HandoffSegmentsRequest) XXX_Unmarshal(b []byte) error {
@ -2076,7 +2186,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{29}
return fileDescriptor_aab7cc9a69ed26e8, []int{31}
}
func (m *LoadBalanceRequest) XXX_Unmarshal(b []byte) error {
@ -2153,7 +2263,7 @@ func (m *DmChannelWatchInfo) Reset() { *m = DmChannelWatchInfo{} }
func (m *DmChannelWatchInfo) String() string { return proto.CompactTextString(m) }
func (*DmChannelWatchInfo) ProtoMessage() {}
func (*DmChannelWatchInfo) Descriptor() ([]byte, []int) {
return fileDescriptor_aab7cc9a69ed26e8, []int{30}
return fileDescriptor_aab7cc9a69ed26e8, []int{32}
}
func (m *DmChannelWatchInfo) XXX_Unmarshal(b []byte) error {
@ -2217,7 +2327,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{31}
return fileDescriptor_aab7cc9a69ed26e8, []int{33}
}
func (m *QueryChannelInfo) XXX_Unmarshal(b []byte) error {
@ -2286,7 +2396,7 @@ func (m *PartitionStates) Reset() { *m = PartitionStates{} }
func (m *PartitionStates) String() string { return proto.CompactTextString(m) }
func (*PartitionStates) ProtoMessage() {}
func (*PartitionStates) Descriptor() ([]byte, []int) {
return fileDescriptor_aab7cc9a69ed26e8, []int{32}
return fileDescriptor_aab7cc9a69ed26e8, []int{34}
}
func (m *PartitionStates) XXX_Unmarshal(b []byte) error {
@ -2353,7 +2463,7 @@ func (m *SegmentInfo) Reset() { *m = SegmentInfo{} }
func (m *SegmentInfo) String() string { return proto.CompactTextString(m) }
func (*SegmentInfo) ProtoMessage() {}
func (*SegmentInfo) Descriptor() ([]byte, []int) {
return fileDescriptor_aab7cc9a69ed26e8, []int{33}
return fileDescriptor_aab7cc9a69ed26e8, []int{35}
}
func (m *SegmentInfo) XXX_Unmarshal(b []byte) error {
@ -2498,7 +2608,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{34}
return fileDescriptor_aab7cc9a69ed26e8, []int{36}
}
func (m *CollectionInfo) XXX_Unmarshal(b []byte) error {
@ -2594,7 +2704,7 @@ func (m *UnsubscribeChannels) Reset() { *m = UnsubscribeChannels{} }
func (m *UnsubscribeChannels) String() string { return proto.CompactTextString(m) }
func (*UnsubscribeChannels) ProtoMessage() {}
func (*UnsubscribeChannels) Descriptor() ([]byte, []int) {
return fileDescriptor_aab7cc9a69ed26e8, []int{35}
return fileDescriptor_aab7cc9a69ed26e8, []int{37}
}
func (m *UnsubscribeChannels) XXX_Unmarshal(b []byte) error {
@ -2641,7 +2751,7 @@ func (m *UnsubscribeChannelInfo) Reset() { *m = UnsubscribeChannelInfo{}
func (m *UnsubscribeChannelInfo) String() string { return proto.CompactTextString(m) }
func (*UnsubscribeChannelInfo) ProtoMessage() {}
func (*UnsubscribeChannelInfo) Descriptor() ([]byte, []int) {
return fileDescriptor_aab7cc9a69ed26e8, []int{36}
return fileDescriptor_aab7cc9a69ed26e8, []int{38}
}
func (m *UnsubscribeChannelInfo) XXX_Unmarshal(b []byte) error {
@ -2691,7 +2801,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{37}
return fileDescriptor_aab7cc9a69ed26e8, []int{39}
}
func (m *SegmentChangeInfo) XXX_Unmarshal(b []byte) error {
@ -2752,7 +2862,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{38}
return fileDescriptor_aab7cc9a69ed26e8, []int{40}
}
func (m *SealedSegmentsChangeInfo) XXX_Unmarshal(b []byte) error {
@ -2819,6 +2929,8 @@ func init() {
proto.RegisterType((*ReleaseSegmentsRequest)(nil), "milvus.proto.query.ReleaseSegmentsRequest")
proto.RegisterType((*SearchRequest)(nil), "milvus.proto.query.SearchRequest")
proto.RegisterType((*QueryRequest)(nil), "milvus.proto.query.QueryRequest")
proto.RegisterType((*SyncReplicaSegmentsRequest)(nil), "milvus.proto.query.SyncReplicaSegmentsRequest")
proto.RegisterType((*ReplicaSegmentsInfo)(nil), "milvus.proto.query.ReplicaSegmentsInfo")
proto.RegisterType((*HandoffSegmentsRequest)(nil), "milvus.proto.query.HandoffSegmentsRequest")
proto.RegisterType((*LoadBalanceRequest)(nil), "milvus.proto.query.LoadBalanceRequest")
proto.RegisterType((*DmChannelWatchInfo)(nil), "milvus.proto.query.DmChannelWatchInfo")
@ -2835,180 +2947,185 @@ func init() {
func init() { proto.RegisterFile("query_coord.proto", fileDescriptor_aab7cc9a69ed26e8) }
var fileDescriptor_aab7cc9a69ed26e8 = []byte{
// 2755 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x5a, 0x5b, 0x6f, 0x1c, 0x49,
0x15, 0x76, 0xcf, 0xcd, 0x33, 0x67, 0x2e, 0x9e, 0x94, 0x13, 0xef, 0x78, 0xc8, 0xc5, 0xe9, 0xdc,
0x4c, 0x96, 0x75, 0x82, 0x03, 0x68, 0x57, 0xc0, 0x43, 0x6c, 0x13, 0xaf, 0x49, 0xe2, 0xf5, 0xb6,
0x9d, 0x00, 0x51, 0xa4, 0xa1, 0x67, 0xba, 0x3c, 0x6e, 0xa5, 0x2f, 0x93, 0xae, 0x9e, 0x24, 0xce,
0x33, 0x42, 0x2c, 0x17, 0x21, 0x9e, 0x10, 0x12, 0xe2, 0x09, 0x04, 0x48, 0xac, 0x78, 0xe6, 0x05,
0x21, 0x7e, 0x01, 0x12, 0xef, 0x88, 0x37, 0x7e, 0x01, 0x8f, 0x08, 0x54, 0x97, 0xee, 0xe9, 0x4b,
0xb5, 0x67, 0xec, 0xd9, 0x6c, 0x22, 0xb4, 0x6f, 0x5d, 0xa7, 0x4f, 0xd5, 0x39, 0xa7, 0xce, 0xa9,
0x53, 0x5f, 0xd5, 0x29, 0x38, 0xf5, 0x74, 0x88, 0xbd, 0xc3, 0x4e, 0xcf, 0x75, 0x3d, 0x63, 0x65,
0xe0, 0xb9, 0xbe, 0x8b, 0x90, 0x6d, 0x5a, 0xcf, 0x86, 0x84, 0xb7, 0x56, 0xd8, 0xff, 0x76, 0xad,
0xe7, 0xda, 0xb6, 0xeb, 0x70, 0x5a, 0xbb, 0x16, 0xe5, 0x68, 0x37, 0x4c, 0xc7, 0xc7, 0x9e, 0xa3,
0x5b, 0xc1, 0x5f, 0xd2, 0x3b, 0xc0, 0xb6, 0x2e, 0x5a, 0x4d, 0x43, 0xf7, 0xf5, 0xe8, 0xf8, 0xea,
0xf7, 0x14, 0x58, 0xd8, 0x3d, 0x70, 0x9f, 0xaf, 0xbb, 0x96, 0x85, 0x7b, 0xbe, 0xe9, 0x3a, 0x44,
0xc3, 0x4f, 0x87, 0x98, 0xf8, 0xe8, 0x26, 0x14, 0xba, 0x3a, 0xc1, 0x2d, 0x65, 0x49, 0x59, 0xae,
0xae, 0x9e, 0x5d, 0x89, 0x69, 0x22, 0x54, 0xb8, 0x4f, 0xfa, 0x6b, 0x3a, 0xc1, 0x1a, 0xe3, 0x44,
0x08, 0x0a, 0x46, 0x77, 0x6b, 0xa3, 0x95, 0x5b, 0x52, 0x96, 0xf3, 0x1a, 0xfb, 0x46, 0x97, 0xa1,
0xde, 0x0b, 0xc7, 0xde, 0xda, 0x20, 0xad, 0xfc, 0x52, 0x7e, 0x39, 0xaf, 0xc5, 0x89, 0xea, 0x6f,
0x15, 0x78, 0x2b, 0xa5, 0x06, 0x19, 0xb8, 0x0e, 0xc1, 0xe8, 0x16, 0x94, 0x88, 0xaf, 0xfb, 0x43,
0x22, 0x34, 0xf9, 0x9c, 0x54, 0x93, 0x5d, 0xc6, 0xa2, 0x09, 0xd6, 0xb4, 0xd8, 0x9c, 0x44, 0x2c,
0xfa, 0x22, 0x9c, 0x36, 0x9d, 0xfb, 0xd8, 0x76, 0xbd, 0xc3, 0xce, 0x00, 0x7b, 0x3d, 0xec, 0xf8,
0x7a, 0x1f, 0x07, 0x3a, 0xce, 0x07, 0xff, 0x76, 0x46, 0xbf, 0xd4, 0xdf, 0x28, 0x70, 0x86, 0x6a,
0xba, 0xa3, 0x7b, 0xbe, 0xf9, 0x0a, 0xe6, 0x4b, 0x85, 0x5a, 0x54, 0xc7, 0x56, 0x9e, 0xfd, 0x8b,
0xd1, 0x28, 0xcf, 0x20, 0x10, 0x4f, 0x6d, 0x2b, 0x30, 0x75, 0x63, 0x34, 0xf5, 0xd7, 0xc2, 0xb1,
0x51, 0x3d, 0xa7, 0x99, 0xd0, 0xa4, 0xcc, 0x5c, 0x5a, 0xe6, 0x49, 0xa6, 0xf3, 0x5f, 0x0a, 0x9c,
0xb9, 0xe7, 0xea, 0xc6, 0xc8, 0xf1, 0x9f, 0xfe, 0x74, 0x7e, 0x1d, 0x4a, 0x7c, 0x95, 0xb4, 0x0a,
0x4c, 0xd6, 0x95, 0xb8, 0x2c, 0xb1, 0x82, 0x46, 0x1a, 0xee, 0x32, 0x82, 0x26, 0x3a, 0xa1, 0x2b,
0xd0, 0xf0, 0xf0, 0xc0, 0x32, 0x7b, 0x7a, 0xc7, 0x19, 0xda, 0x5d, 0xec, 0xb5, 0x8a, 0x4b, 0xca,
0x72, 0x51, 0xab, 0x0b, 0xea, 0x36, 0x23, 0xaa, 0xbf, 0x54, 0xa0, 0xa5, 0x61, 0x0b, 0xeb, 0x04,
0xbf, 0x4e, 0x63, 0x17, 0xa0, 0xe4, 0xb8, 0x06, 0xde, 0xda, 0x60, 0xc6, 0xe6, 0x35, 0xd1, 0x52,
0x7f, 0x94, 0xe3, 0x8e, 0x78, 0xc3, 0xe3, 0x3a, 0xe2, 0xac, 0xe2, 0x27, 0xe3, 0xac, 0x92, 0xcc,
0x59, 0x7f, 0x19, 0x39, 0xeb, 0x4d, 0x9f, 0x90, 0x91, 0x43, 0x8b, 0x31, 0x87, 0x7e, 0x07, 0x16,
0xd7, 0x3d, 0xac, 0xfb, 0xf8, 0x43, 0xba, 0x69, 0xac, 0x1f, 0xe8, 0x8e, 0x83, 0xad, 0xc0, 0x84,
0xa4, 0x70, 0x45, 0x22, 0xbc, 0x05, 0xb3, 0x03, 0xcf, 0x7d, 0x71, 0x18, 0xea, 0x1d, 0x34, 0xd5,
0xdf, 0x29, 0xd0, 0x96, 0x8d, 0x3d, 0x4d, 0x7e, 0xb9, 0x04, 0x75, 0xb1, 0xfb, 0xf1, 0xd1, 0x98,
0xcc, 0x8a, 0x56, 0x7b, 0x1a, 0x91, 0x80, 0x6e, 0xc2, 0x69, 0xce, 0xe4, 0x61, 0x32, 0xb4, 0xfc,
0x90, 0x37, 0xcf, 0x78, 0x11, 0xfb, 0xa7, 0xb1, 0x5f, 0xa2, 0x87, 0xfa, 0x7b, 0x05, 0x16, 0x37,
0xb1, 0x1f, 0x3a, 0x91, 0x4a, 0xc5, 0x6f, 0x68, 0xca, 0xfe, 0x58, 0x81, 0xb6, 0x4c, 0xd7, 0x69,
0xa6, 0xf5, 0x11, 0x2c, 0x84, 0x32, 0x3a, 0x06, 0x26, 0x3d, 0xcf, 0x1c, 0xb0, 0x60, 0x66, 0x09,
0xbc, 0xba, 0x7a, 0x69, 0x25, 0x0d, 0x30, 0x56, 0x92, 0x1a, 0x9c, 0x09, 0x87, 0xd8, 0x88, 0x8c,
0xa0, 0xfe, 0x44, 0x81, 0x33, 0x9b, 0xd8, 0xdf, 0xc5, 0x7d, 0x1b, 0x3b, 0xfe, 0x96, 0xb3, 0xef,
0x9e, 0x7c, 0x5e, 0xcf, 0x03, 0x10, 0x31, 0x4e, 0xb8, 0xb9, 0x44, 0x28, 0x93, 0xcc, 0x31, 0xc3,
0x32, 0x49, 0x7d, 0xa6, 0x99, 0xbb, 0x2f, 0x43, 0xd1, 0x74, 0xf6, 0xdd, 0x60, 0xaa, 0x2e, 0xc8,
0xa6, 0x2a, 0x2a, 0x8c, 0x73, 0xab, 0x0e, 0xd7, 0xe2, 0x40, 0xf7, 0x8c, 0x7b, 0x58, 0x37, 0xb0,
0x37, 0x45, 0xb8, 0x25, 0xcd, 0xce, 0x49, 0xcc, 0xfe, 0xb1, 0x02, 0x6f, 0xa5, 0x04, 0x4e, 0x63,
0xf7, 0xd7, 0xa0, 0x44, 0xe8, 0x60, 0x81, 0xe1, 0x97, 0xa5, 0x86, 0x47, 0xc4, 0xdd, 0x33, 0x89,
0xaf, 0x89, 0x3e, 0xaa, 0x0b, 0xcd, 0xe4, 0x3f, 0x74, 0x11, 0x6a, 0x62, 0xa9, 0x76, 0x1c, 0xdd,
0xe6, 0x13, 0x50, 0xd1, 0xaa, 0x82, 0xb6, 0xad, 0xdb, 0x18, 0x2d, 0x42, 0x99, 0x26, 0xae, 0x8e,
0x69, 0x04, 0xee, 0x9f, 0x65, 0x89, 0xcc, 0x20, 0xe8, 0x1c, 0x00, 0xfb, 0xa5, 0x1b, 0x86, 0xc7,
0xc1, 0x44, 0x45, 0xab, 0x50, 0xca, 0x6d, 0x4a, 0x50, 0xff, 0x93, 0x83, 0x85, 0xdb, 0x86, 0x21,
0x4b, 0x73, 0xc7, 0x9f, 0xf0, 0x51, 0x36, 0xcd, 0x45, 0xb3, 0xe9, 0x44, 0x6b, 0x3c, 0x95, 0xc2,
0x0a, 0xc7, 0x48, 0x61, 0xc5, 0xac, 0x14, 0x86, 0x36, 0xa1, 0x4e, 0x30, 0x7e, 0xd2, 0x19, 0xb8,
0x84, 0xad, 0x41, 0xb6, 0x63, 0x55, 0x57, 0xd5, 0xb8, 0x35, 0x21, 0xee, 0xbf, 0x4f, 0xfa, 0x3b,
0x82, 0x53, 0xab, 0xd1, 0x8e, 0x41, 0x0b, 0x3d, 0x80, 0x85, 0xbe, 0xe5, 0x76, 0x75, 0xab, 0x43,
0xb0, 0x6e, 0x61, 0xa3, 0x23, 0xd6, 0x17, 0x69, 0xcd, 0x4e, 0x16, 0xe0, 0xa7, 0x79, 0xf7, 0x5d,
0xd6, 0x5b, 0xfc, 0x20, 0xea, 0x3f, 0x15, 0x58, 0xd4, 0xb0, 0xed, 0x3e, 0xc3, 0xff, 0xaf, 0x2e,
0x50, 0x7f, 0xa6, 0x40, 0x8d, 0x82, 0xa3, 0xfb, 0xd8, 0xd7, 0xe9, 0x4c, 0xa0, 0xf7, 0xa0, 0x62,
0xb9, 0xba, 0xd1, 0xf1, 0x0f, 0x07, 0xdc, 0xb4, 0x46, 0xd2, 0x34, 0x3e, 0x7b, 0xb4, 0xd3, 0xde,
0xe1, 0x00, 0x6b, 0x65, 0x4b, 0x7c, 0x4d, 0xb2, 0xa4, 0x53, 0xbb, 0x45, 0x5e, 0xb2, 0x5b, 0xfc,
0x35, 0x0f, 0x0b, 0xdf, 0xd2, 0xfd, 0xde, 0xc1, 0x86, 0x2d, 0xd4, 0x24, 0xaf, 0x67, 0xce, 0x27,
0x01, 0x29, 0x61, 0x2a, 0x2d, 0xca, 0x22, 0x8d, 0x9e, 0x4a, 0x57, 0x1e, 0x0a, 0x37, 0x44, 0x52,
0x69, 0x04, 0xec, 0x95, 0x4e, 0x02, 0xf6, 0xd6, 0xa1, 0x8e, 0x5f, 0xf4, 0xac, 0x21, 0x4d, 0x2b,
0x4c, 0x3a, 0x8f, 0xf3, 0xf3, 0x12, 0xe9, 0xd1, 0x30, 0xaf, 0x89, 0x4e, 0x5b, 0x42, 0x07, 0xee,
0x6a, 0x1b, 0xfb, 0x7a, 0xab, 0xcc, 0xd4, 0x58, 0xca, 0x72, 0x75, 0x10, 0x1f, 0xdc, 0xdd, 0xb4,
0x85, 0xce, 0x42, 0x45, 0x40, 0xcb, 0xad, 0x8d, 0x56, 0x85, 0x4d, 0xdf, 0x88, 0xa0, 0xfe, 0x57,
0x81, 0x45, 0xee, 0x44, 0x6c, 0xf9, 0xfa, 0xeb, 0xf5, 0x63, 0xe8, 0xa3, 0xc2, 0x31, 0x7d, 0x14,
0x99, 0x9f, 0xca, 0x71, 0xe7, 0x47, 0xfd, 0x73, 0x01, 0xe6, 0xc4, 0xe4, 0x53, 0x0e, 0xb6, 0xba,
0xce, 0x42, 0x25, 0xdc, 0xfa, 0x05, 0x34, 0x1d, 0x11, 0xd0, 0x12, 0x54, 0x23, 0xb1, 0x25, 0x0c,
0x8d, 0x92, 0x26, 0xb2, 0x36, 0x00, 0x72, 0x85, 0x08, 0x90, 0x3b, 0x07, 0xb0, 0x6f, 0x0d, 0xc9,
0x41, 0xc7, 0x37, 0x6d, 0x2c, 0xe0, 0x74, 0x85, 0x51, 0xf6, 0x4c, 0x1b, 0xa3, 0xdb, 0x50, 0xeb,
0x9a, 0x8e, 0xe5, 0xf6, 0x3b, 0x03, 0xdd, 0x3f, 0x20, 0xad, 0x52, 0x66, 0x34, 0xdd, 0x31, 0xb1,
0x65, 0xac, 0x31, 0x5e, 0xad, 0xca, 0xfb, 0xec, 0xd0, 0x2e, 0xe8, 0x3c, 0x54, 0x9d, 0xa1, 0xdd,
0x71, 0xf7, 0x3b, 0x9e, 0xfb, 0x9c, 0xc6, 0x23, 0x13, 0xe1, 0x0c, 0xed, 0x0f, 0xf6, 0x35, 0xf7,
0x39, 0xdd, 0x7a, 0x2b, 0x74, 0x13, 0x26, 0x96, 0xdb, 0x27, 0xad, 0xf2, 0x44, 0xe3, 0x8f, 0x3a,
0xd0, 0xde, 0x06, 0x8d, 0x23, 0xd6, 0xbb, 0x32, 0x59, 0xef, 0xb0, 0x03, 0xba, 0x0a, 0x8d, 0x9e,
0x6b, 0x0f, 0x74, 0x36, 0x43, 0x77, 0x3c, 0xd7, 0x6e, 0x01, 0x5b, 0xc9, 0x09, 0x2a, 0x5a, 0x87,
0xaa, 0xe9, 0x18, 0xf8, 0x85, 0x58, 0x53, 0x55, 0x26, 0x47, 0x95, 0xb9, 0x9c, 0x09, 0xda, 0xa2,
0xbc, 0xcc, 0xe9, 0x60, 0x06, 0x9f, 0x84, 0x22, 0x02, 0xe1, 0xd1, 0x0e, 0x31, 0x5f, 0xe2, 0x56,
0x8d, 0x7b, 0x51, 0xd0, 0x76, 0xcd, 0x97, 0x98, 0x1e, 0xd5, 0x4c, 0x87, 0x60, 0x6f, 0x94, 0xa0,
0xeb, 0x2c, 0x41, 0xd7, 0x39, 0x35, 0xc8, 0xcd, 0x7f, 0xcc, 0x41, 0x23, 0x2e, 0x88, 0x9e, 0x5c,
0xf6, 0x19, 0x25, 0x88, 0x9e, 0xa0, 0x49, 0xc5, 0x62, 0x47, 0xef, 0x5a, 0x34, 0x21, 0x18, 0xf8,
0x05, 0x0b, 0x9e, 0xb2, 0x56, 0xe5, 0x34, 0x36, 0x00, 0x0d, 0x02, 0x6e, 0x1e, 0x43, 0x2a, 0xfc,
0x64, 0x51, 0x61, 0x14, 0x86, 0x53, 0x5a, 0x30, 0xcb, 0xcd, 0x08, 0x42, 0x27, 0x68, 0xd2, 0x3f,
0xdd, 0xa1, 0xc9, 0xa4, 0xf2, 0xd0, 0x09, 0x9a, 0x68, 0x03, 0x6a, 0x7c, 0xc8, 0x81, 0xee, 0xe9,
0x76, 0x10, 0x38, 0x17, 0xa5, 0xeb, 0xf9, 0x2e, 0x3e, 0x7c, 0xa8, 0x5b, 0x43, 0xbc, 0xa3, 0x9b,
0x9e, 0xc6, 0x27, 0x7a, 0x87, 0xf5, 0x42, 0xcb, 0xd0, 0xe4, 0xa3, 0xec, 0x9b, 0x16, 0x16, 0x21,
0x38, 0xcb, 0xc0, 0x50, 0x83, 0xd1, 0xef, 0x98, 0x16, 0xe6, 0x51, 0x16, 0x9a, 0xc0, 0xa6, 0xb6,
0xcc, 0x83, 0x8c, 0x51, 0xe8, 0xc4, 0xaa, 0xdf, 0xcf, 0xc3, 0x3c, 0x5d, 0x6b, 0xc1, 0x0e, 0x7e,
0xf2, 0x74, 0x73, 0x0e, 0xc0, 0x20, 0x7e, 0x27, 0x96, 0x72, 0x2a, 0x06, 0xf1, 0xb7, 0x79, 0xd6,
0x79, 0x2f, 0xc8, 0x28, 0xf9, 0xec, 0xb3, 0x46, 0x62, 0xed, 0xa7, 0x33, 0xff, 0x89, 0xee, 0x64,
0x2e, 0x41, 0x9d, 0xb8, 0x43, 0xaf, 0x87, 0x3b, 0xb1, 0xb3, 0x71, 0x8d, 0x13, 0xb7, 0xe5, 0x49,
0xb1, 0x24, 0xbd, 0x1b, 0x8a, 0x64, 0xb7, 0xd9, 0xe9, 0xb2, 0x7f, 0x39, 0x99, 0xfd, 0xff, 0xa1,
0xc0, 0x82, 0xb8, 0x65, 0x98, 0xde, 0x17, 0x59, 0xa9, 0x3f, 0x48, 0x74, 0xf9, 0x23, 0x4e, 0xac,
0x85, 0x09, 0xb6, 0xf5, 0xa2, 0x64, 0x5b, 0x8f, 0x9f, 0xda, 0x4a, 0xc9, 0x53, 0x9b, 0xfa, 0x03,
0x05, 0xea, 0xbb, 0x58, 0xf7, 0x7a, 0x07, 0x81, 0x5d, 0x5f, 0x81, 0xbc, 0x87, 0x9f, 0x0a, 0xb3,
0x2e, 0x67, 0x40, 0xd8, 0x58, 0x17, 0x8d, 0x76, 0x40, 0x17, 0xa0, 0x6a, 0xd8, 0x56, 0xe2, 0x72,
0x00, 0x0c, 0xdb, 0x0a, 0x40, 0x5d, 0x5c, 0x95, 0x7c, 0x4a, 0x95, 0x8f, 0x14, 0xa8, 0x7d, 0xc8,
0x91, 0x1d, 0xd7, 0xe4, 0xdd, 0xa8, 0x26, 0x57, 0x33, 0x34, 0xd1, 0xb0, 0xef, 0x99, 0xf8, 0x19,
0xfe, 0x64, 0x75, 0xf9, 0xa9, 0x02, 0x0b, 0xef, 0xeb, 0x8e, 0xe1, 0xee, 0xef, 0x4f, 0xef, 0xf7,
0xf5, 0x30, 0x93, 0x6e, 0x1d, 0xe7, 0xb0, 0x1a, 0xeb, 0xa4, 0xfe, 0x21, 0x07, 0x88, 0x86, 0xf0,
0x9a, 0x6e, 0xe9, 0x4e, 0x0f, 0x9f, 0x5c, 0x9b, 0x2b, 0xd0, 0x88, 0x2d, 0xbc, 0xf0, 0xe2, 0x3d,
0xba, 0xf2, 0x08, 0xba, 0x0b, 0x8d, 0x2e, 0x17, 0xd5, 0xf1, 0xb0, 0x4e, 0x5c, 0x87, 0x85, 0x67,
0x43, 0x7e, 0xd4, 0xdc, 0xf3, 0xcc, 0x7e, 0x1f, 0x7b, 0xeb, 0xae, 0x63, 0xf0, 0x63, 0x4d, 0xbd,
0x1b, 0xa8, 0x49, 0xbb, 0x32, 0x7f, 0x84, 0x59, 0x28, 0xc0, 0x9f, 0x10, 0xa6, 0x21, 0x82, 0xde,
0x86, 0x53, 0xf1, 0x13, 0xcf, 0x28, 0x9e, 0x9b, 0x24, 0x7a, 0x98, 0x91, 0xdd, 0x34, 0x48, 0xb2,
0x82, 0xfa, 0x0b, 0x05, 0x50, 0x08, 0xbb, 0x19, 0x7e, 0x63, 0xfb, 0xce, 0x24, 0xb7, 0x6a, 0x67,
0xa1, 0x62, 0x04, 0x3d, 0x45, 0xe8, 0x8c, 0x08, 0x34, 0x6f, 0x71, 0x33, 0x3a, 0x34, 0x85, 0x60,
0x23, 0x80, 0x2e, 0x9c, 0x78, 0x8f, 0xd1, 0xe2, 0x49, 0xa5, 0x90, 0x4c, 0x2a, 0x1f, 0xe7, 0xa0,
0x19, 0x3d, 0x88, 0x4d, 0xac, 0xd9, 0xab, 0xb9, 0x81, 0x3b, 0xe2, 0xd4, 0x59, 0x98, 0xe2, 0xd4,
0x99, 0x3e, 0x15, 0x17, 0x4f, 0x76, 0x2a, 0x56, 0x7f, 0xa5, 0xc0, 0x5c, 0xe2, 0xc2, 0x2b, 0x09,
0x31, 0x95, 0x34, 0xc4, 0x7c, 0x17, 0x8a, 0x14, 0x77, 0x61, 0x36, 0x49, 0x0d, 0x39, 0xfc, 0x89,
0x8f, 0xaa, 0xf1, 0x0e, 0xe8, 0x06, 0xcc, 0x4b, 0x8a, 0x24, 0xc2, 0xd1, 0x28, 0x5d, 0x23, 0x51,
0xff, 0x54, 0x80, 0x6a, 0x64, 0x3e, 0xc6, 0xa0, 0xe3, 0x49, 0x8e, 0x97, 0x09, 0xf3, 0xf2, 0x69,
0xf3, 0x32, 0xaa, 0x04, 0x68, 0x11, 0xca, 0x36, 0xb6, 0x39, 0xae, 0x10, 0x20, 0xc7, 0xc6, 0x36,
0x83, 0x6b, 0x8b, 0x50, 0xa6, 0xd0, 0x96, 0xe1, 0x5a, 0xbe, 0x66, 0x66, 0x9d, 0xa1, 0xcd, 0x50,
0x6d, 0x1c, 0x52, 0xcd, 0x1e, 0x01, 0xa9, 0xca, 0x71, 0x48, 0x15, 0x5b, 0x2c, 0x95, 0xe4, 0x62,
0x99, 0x14, 0xb0, 0xde, 0x84, 0xf9, 0x1e, 0xbb, 0xad, 0x36, 0xd6, 0x0e, 0xd7, 0xc3, 0x5f, 0xad,
0x2a, 0xc3, 0x7e, 0xb2, 0x5f, 0xe8, 0x0e, 0x0d, 0x2e, 0x81, 0x4e, 0x99, 0x97, 0x6b, 0xcc, 0xcb,
0x72, 0xc4, 0x26, 0x7c, 0xc3, 0x9d, 0x1c, 0xa4, 0x55, 0xd6, 0x4a, 0x42, 0xe5, 0xfa, 0x89, 0xa0,
0xf2, 0x05, 0xa8, 0x06, 0x25, 0x0b, 0xd3, 0x20, 0xad, 0x06, 0x4f, 0x6f, 0xc1, 0x82, 0x37, 0x48,
0xec, 0xea, 0x6c, 0x2e, 0x76, 0x75, 0xa6, 0xfe, 0x2d, 0x0f, 0x8d, 0x11, 0x48, 0x9a, 0x38, 0x15,
0x4c, 0x52, 0xec, 0xdb, 0x86, 0xe6, 0xe8, 0x66, 0x99, 0xcd, 0xd2, 0x91, 0x38, 0x2f, 0x79, 0xa7,
0x3c, 0x37, 0x48, 0xac, 0xb9, 0xd8, 0x95, 0x4a, 0xe1, 0x58, 0x57, 0x2a, 0x53, 0xd6, 0x84, 0x6e,
0xc1, 0x19, 0x8f, 0xa3, 0x30, 0xa3, 0x13, 0x33, 0x9b, 0x03, 0x9a, 0xd3, 0xc1, 0xcf, 0x9d, 0xa8,
0xf9, 0x19, 0xcb, 0x78, 0x36, 0x6b, 0x19, 0x27, 0xdd, 0x58, 0x4e, 0xb9, 0x31, 0x5d, 0x9a, 0xaa,
0xc8, 0x4a, 0x53, 0x0f, 0x60, 0xfe, 0x81, 0x43, 0x86, 0x5d, 0xd2, 0xf3, 0xcc, 0x2e, 0x0e, 0xae,
0x0c, 0x26, 0x72, 0x6b, 0x1b, 0xca, 0x22, 0x5f, 0x73, 0x97, 0x56, 0xb4, 0xb0, 0xad, 0xfe, 0x50,
0x81, 0x85, 0xf4, 0xb8, 0x2c, 0x62, 0x46, 0xc9, 0x40, 0x89, 0x25, 0x83, 0x6f, 0xc3, 0xfc, 0x68,
0xf8, 0x4e, 0x6c, 0xe4, 0xea, 0xea, 0x35, 0x99, 0xef, 0x24, 0x8a, 0x6b, 0x68, 0x34, 0x46, 0x40,
0x53, 0xff, 0xad, 0xc0, 0x29, 0xb1, 0xac, 0x28, 0xad, 0xcf, 0xae, 0x62, 0xe8, 0x06, 0xe5, 0x3a,
0x96, 0xe9, 0x84, 0xa0, 0x5e, 0xd8, 0xc8, 0x89, 0x02, 0xd4, 0xbf, 0x0f, 0x73, 0x82, 0x29, 0xdc,
0x67, 0x26, 0x44, 0x44, 0x0d, 0xde, 0x2f, 0xdc, 0x61, 0xae, 0x40, 0xc3, 0xdd, 0xdf, 0x8f, 0xca,
0xe3, 0x89, 0xb2, 0x2e, 0xa8, 0x42, 0xe0, 0x37, 0xa1, 0x19, 0xb0, 0x1d, 0x77, 0x67, 0x9b, 0x13,
0x1d, 0xc3, 0xab, 0xd4, 0x8f, 0x14, 0x68, 0xc5, 0xf7, 0xb9, 0x88, 0xf9, 0xc7, 0x07, 0x63, 0x5f,
0x8d, 0x17, 0x30, 0xae, 0x1c, 0xa1, 0xcf, 0x48, 0x8e, 0x38, 0x81, 0x5d, 0x7f, 0x09, 0x8d, 0xf8,
0x9a, 0x45, 0x35, 0x28, 0x6f, 0xbb, 0xfe, 0x37, 0x5e, 0x98, 0xc4, 0x6f, 0xce, 0xa0, 0x06, 0xc0,
0xb6, 0xeb, 0xef, 0x78, 0x98, 0x60, 0xc7, 0x6f, 0x2a, 0x08, 0xa0, 0xf4, 0x81, 0xb3, 0x61, 0x92,
0x27, 0xcd, 0x1c, 0x9a, 0x17, 0x5b, 0xaa, 0x6e, 0x6d, 0x89, 0x85, 0xd0, 0xcc, 0xd3, 0xee, 0x61,
0xab, 0x80, 0x9a, 0x50, 0x0b, 0x59, 0x36, 0x77, 0x1e, 0x34, 0x8b, 0xa8, 0x02, 0x45, 0xfe, 0x59,
0xba, 0x6e, 0x40, 0x33, 0x09, 0xfa, 0xe8, 0x98, 0x0f, 0x9c, 0xbb, 0x8e, 0xfb, 0x3c, 0x24, 0x35,
0x67, 0x50, 0x15, 0x66, 0x05, 0x90, 0x6e, 0x2a, 0x68, 0x0e, 0xaa, 0x11, 0x0c, 0xdb, 0xcc, 0x51,
0xc2, 0xa6, 0x37, 0xe8, 0x09, 0x34, 0xcb, 0x55, 0xa0, 0x5e, 0xdb, 0x70, 0x9f, 0x3b, 0xcd, 0xc2,
0xf5, 0x35, 0x28, 0x07, 0xc9, 0x84, 0xb2, 0xf2, 0xd1, 0x1d, 0xda, 0x6c, 0xce, 0xa0, 0x53, 0x50,
0x8f, 0x95, 0xc3, 0x9b, 0x0a, 0x42, 0xd0, 0x88, 0x3f, 0x55, 0x68, 0xe6, 0x56, 0x7f, 0x5e, 0x07,
0xe0, 0x68, 0xcb, 0x75, 0x3d, 0x03, 0x0d, 0x00, 0x6d, 0x62, 0x9f, 0xee, 0x24, 0xae, 0x13, 0xec,
0x02, 0x04, 0xdd, 0xcc, 0x00, 0x25, 0x69, 0x56, 0xa1, 0x6a, 0x3b, 0xeb, 0x3c, 0x92, 0x60, 0x57,
0x67, 0x90, 0xcd, 0x24, 0xee, 0x99, 0x36, 0xde, 0x33, 0x7b, 0x4f, 0x42, 0x98, 0x96, 0x2d, 0x31,
0xc1, 0x1a, 0x48, 0x4c, 0x24, 0x6d, 0xd1, 0xd8, 0xf5, 0x3d, 0xd3, 0xe9, 0x07, 0xe5, 0x24, 0x75,
0x06, 0x3d, 0x85, 0xd3, 0x9b, 0x98, 0x49, 0x37, 0x89, 0x6f, 0xf6, 0x48, 0x20, 0x70, 0x35, 0x5b,
0x60, 0x8a, 0xf9, 0x98, 0x22, 0x2d, 0x98, 0x4b, 0x3c, 0x0d, 0x42, 0xd7, 0xe5, 0x15, 0x29, 0xd9,
0x33, 0xa6, 0xf6, 0xdb, 0x13, 0xf1, 0x86, 0xd2, 0x4c, 0x68, 0xc4, 0x9f, 0xcd, 0xa0, 0xcf, 0x67,
0x0d, 0x90, 0x7a, 0x19, 0xd0, 0xbe, 0x3e, 0x09, 0x6b, 0x28, 0xea, 0x11, 0x8f, 0xa7, 0x71, 0xa2,
0xa4, 0xaf, 0x32, 0xda, 0x47, 0x55, 0xf2, 0xd4, 0x19, 0xf4, 0x5d, 0x38, 0x95, 0x7a, 0xbf, 0x80,
0xbe, 0x20, 0x1b, 0x3e, 0xeb, 0x99, 0xc3, 0x38, 0x09, 0x8f, 0x92, 0xab, 0x21, 0x5b, 0xfb, 0xd4,
0x7b, 0x97, 0xc9, 0xb5, 0x8f, 0x0c, 0x7f, 0x94, 0xf6, 0xc7, 0x96, 0x30, 0x04, 0x94, 0x7e, 0xc1,
0x80, 0xde, 0x91, 0x89, 0xc8, 0x7c, 0x45, 0xd1, 0x5e, 0x99, 0x94, 0x3d, 0x74, 0xf9, 0x90, 0xad,
0xd6, 0xe4, 0x71, 0x43, 0x2a, 0x36, 0xf3, 0xd5, 0x82, 0x5c, 0x6c, 0xf6, 0xc3, 0x01, 0x1e, 0xd4,
0xf1, 0xc2, 0xb8, 0xdc, 0x57, 0xd2, 0x62, 0xbe, 0x3c, 0xa8, 0xe5, 0x75, 0x76, 0x75, 0x06, 0xed,
0xc5, 0x92, 0x30, 0xba, 0x9a, 0x15, 0x13, 0xf1, 0x9b, 0x86, 0x71, 0xee, 0xea, 0x00, 0x6c, 0x62,
0xff, 0x3e, 0xf6, 0x3d, 0xb3, 0x47, 0x92, 0x83, 0x8a, 0xc6, 0x88, 0x21, 0x18, 0xf4, 0xda, 0x58,
0xbe, 0x50, 0xed, 0x2e, 0x54, 0x37, 0xb1, 0xaf, 0x71, 0xa4, 0x45, 0x50, 0x66, 0xcf, 0x80, 0x23,
0x10, 0xb1, 0x3c, 0x9e, 0x31, 0x9a, 0xc8, 0x12, 0x75, 0x7a, 0x94, 0x39, 0xb7, 0xe9, 0xd7, 0x03,
0xf2, 0x44, 0x96, 0x51, 0xf8, 0x57, 0x67, 0x56, 0xff, 0x5e, 0x85, 0x0a, 0x8b, 0x42, 0xba, 0xe3,
0x7d, 0xb6, 0x31, 0xbd, 0x82, 0x8d, 0xe9, 0x31, 0xcc, 0x25, 0xde, 0x1d, 0xc8, 0xfd, 0x29, 0x7f,
0x9c, 0x30, 0x2e, 0xe4, 0xbb, 0x80, 0xd2, 0x55, 0x75, 0x79, 0xaa, 0xc8, 0xac, 0xbe, 0x8f, 0x93,
0xf1, 0x18, 0xe6, 0x12, 0x25, 0x64, 0xb9, 0x05, 0xf2, 0x3a, 0xf3, 0x04, 0x16, 0xa4, 0x6b, 0x9b,
0x72, 0x0b, 0x32, 0x6b, 0xa0, 0xe3, 0x64, 0x3c, 0xe4, 0x85, 0xf9, 0x10, 0xb4, 0x5f, 0xcb, 0xca,
0x37, 0x89, 0x8b, 0xd6, 0xd7, 0xbf, 0x03, 0xbd, 0xfa, 0x1d, 0xfa, 0x31, 0xcc, 0x25, 0xaa, 0x0b,
0x72, 0xef, 0xca, 0x4b, 0x10, 0xe3, 0x46, 0xff, 0x14, 0xf7, 0x94, 0x5d, 0x28, 0xf1, 0x92, 0x00,
0xba, 0x28, 0x3f, 0xc2, 0x44, 0xca, 0x05, 0xed, 0x71, 0x45, 0x05, 0x32, 0xb4, 0x7c, 0xc2, 0x06,
0x2d, 0xb2, 0x15, 0x83, 0xa4, 0xf5, 0x9c, 0x68, 0xa9, 0xa0, 0x3d, 0xbe, 0x3a, 0x10, 0x0c, 0xfa,
0xaa, 0xf7, 0xa9, 0xb5, 0x2f, 0x3d, 0x5a, 0xed, 0x9b, 0xfe, 0xc1, 0xb0, 0x4b, 0xfd, 0x71, 0x83,
0x73, 0xbe, 0x63, 0xba, 0xe2, 0xeb, 0x46, 0xa0, 0xda, 0x0d, 0x36, 0xd2, 0x0d, 0x66, 0xcb, 0xa0,
0xdb, 0x2d, 0xb1, 0xe6, 0xad, 0xff, 0x05, 0x00, 0x00, 0xff, 0xff, 0xaa, 0xf8, 0xae, 0x2f, 0x61,
0x30, 0x00, 0x00,
// 2846 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x1a, 0x4b, 0x8f, 0x1c, 0x47,
0x79, 0x7b, 0x5e, 0x3b, 0xf3, 0xcd, 0xd3, 0xb5, 0xf6, 0x66, 0x76, 0x70, 0x12, 0xa7, 0x1d, 0x27,
0xc6, 0x21, 0x6b, 0xb3, 0x01, 0x94, 0x08, 0x38, 0xc4, 0xbb, 0x78, 0xb3, 0xc4, 0xde, 0x6c, 0x7a,
0xd7, 0x01, 0xac, 0x48, 0x43, 0xcf, 0x74, 0xed, 0x6c, 0x2b, 0xfd, 0x18, 0x77, 0xf5, 0xd8, 0xde,
0x9c, 0x11, 0x22, 0x3c, 0x84, 0x38, 0x21, 0x24, 0xc4, 0x09, 0x04, 0x48, 0x44, 0x9c, 0x73, 0x41,
0x88, 0x0b, 0x57, 0x7e, 0x01, 0xe2, 0xc6, 0x2f, 0xe0, 0x88, 0x40, 0xf5, 0xea, 0xe9, 0x47, 0xf5,
0xce, 0xec, 0x4e, 0x1c, 0x5b, 0x88, 0x5b, 0xd7, 0xd7, 0x5f, 0xd5, 0xf7, 0xac, 0xef, 0x51, 0x55,
0x70, 0xee, 0xfe, 0x04, 0x07, 0xc7, 0xfd, 0xa1, 0xef, 0x07, 0xd6, 0xfa, 0x38, 0xf0, 0x43, 0x1f,
0x21, 0xd7, 0x76, 0x1e, 0x4c, 0x08, 0x1f, 0xad, 0xb3, 0xff, 0xbd, 0xc6, 0xd0, 0x77, 0x5d, 0xdf,
0xe3, 0xb0, 0x5e, 0x23, 0x8e, 0xd1, 0x6b, 0xd9, 0x5e, 0x88, 0x03, 0xcf, 0x74, 0xe4, 0x5f, 0x32,
0x3c, 0xc2, 0xae, 0x29, 0x46, 0x1d, 0xcb, 0x0c, 0xcd, 0xf8, 0xfa, 0xfa, 0xf7, 0x34, 0x58, 0xdd,
0x3f, 0xf2, 0x1f, 0x6e, 0xfa, 0x8e, 0x83, 0x87, 0xa1, 0xed, 0x7b, 0xc4, 0xc0, 0xf7, 0x27, 0x98,
0x84, 0xe8, 0x06, 0x94, 0x06, 0x26, 0xc1, 0x5d, 0xed, 0x92, 0x76, 0xb5, 0xbe, 0x71, 0x71, 0x3d,
0xc1, 0x89, 0x60, 0xe1, 0x0e, 0x19, 0xdd, 0x34, 0x09, 0x36, 0x18, 0x26, 0x42, 0x50, 0xb2, 0x06,
0x3b, 0x5b, 0xdd, 0xc2, 0x25, 0xed, 0x6a, 0xd1, 0x60, 0xdf, 0xe8, 0x45, 0x68, 0x0e, 0xa3, 0xb5,
0x77, 0xb6, 0x48, 0xb7, 0x78, 0xa9, 0x78, 0xb5, 0x68, 0x24, 0x81, 0xfa, 0x6f, 0x35, 0x78, 0x26,
0xc3, 0x06, 0x19, 0xfb, 0x1e, 0xc1, 0xe8, 0x35, 0xa8, 0x90, 0xd0, 0x0c, 0x27, 0x44, 0x70, 0xf2,
0x39, 0x25, 0x27, 0xfb, 0x0c, 0xc5, 0x10, 0xa8, 0x59, 0xb2, 0x05, 0x05, 0x59, 0xf4, 0x45, 0x38,
0x6f, 0x7b, 0x77, 0xb0, 0xeb, 0x07, 0xc7, 0xfd, 0x31, 0x0e, 0x86, 0xd8, 0x0b, 0xcd, 0x11, 0x96,
0x3c, 0xae, 0xc8, 0x7f, 0x7b, 0xd3, 0x5f, 0xfa, 0x6f, 0x34, 0xb8, 0x40, 0x39, 0xdd, 0x33, 0x83,
0xd0, 0x7e, 0x0c, 0xfa, 0xd2, 0xa1, 0x11, 0xe7, 0xb1, 0x5b, 0x64, 0xff, 0x12, 0x30, 0x8a, 0x33,
0x96, 0xe4, 0xa9, 0x6c, 0x25, 0xc6, 0x6e, 0x02, 0xa6, 0xff, 0x5a, 0x18, 0x36, 0xce, 0xe7, 0x22,
0x0a, 0x4d, 0xd3, 0x2c, 0x64, 0x69, 0x9e, 0x45, 0x9d, 0xff, 0xd4, 0xe0, 0xc2, 0x6d, 0xdf, 0xb4,
0xa6, 0x86, 0xff, 0xec, 0xd5, 0xf9, 0x75, 0xa8, 0xf0, 0x5d, 0xd2, 0x2d, 0x31, 0x5a, 0x57, 0x92,
0xb4, 0xc4, 0x0e, 0x9a, 0x72, 0xb8, 0xcf, 0x00, 0x86, 0x98, 0x84, 0xae, 0x40, 0x2b, 0xc0, 0x63,
0xc7, 0x1e, 0x9a, 0x7d, 0x6f, 0xe2, 0x0e, 0x70, 0xd0, 0x2d, 0x5f, 0xd2, 0xae, 0x96, 0x8d, 0xa6,
0x80, 0xee, 0x32, 0xa0, 0xfe, 0x4b, 0x0d, 0xba, 0x06, 0x76, 0xb0, 0x49, 0xf0, 0x93, 0x14, 0x76,
0x15, 0x2a, 0x9e, 0x6f, 0xe1, 0x9d, 0x2d, 0x26, 0x6c, 0xd1, 0x10, 0x23, 0xfd, 0x47, 0x05, 0x6e,
0x88, 0xa7, 0xdc, 0xaf, 0x63, 0xc6, 0x2a, 0x7f, 0x3a, 0xc6, 0xaa, 0xa8, 0x8c, 0xf5, 0xe7, 0xa9,
0xb1, 0x9e, 0x76, 0x85, 0x4c, 0x0d, 0x5a, 0x4e, 0x18, 0xf4, 0x3b, 0xb0, 0xb6, 0x19, 0x60, 0x33,
0xc4, 0xef, 0xd2, 0xa4, 0xb1, 0x79, 0x64, 0x7a, 0x1e, 0x76, 0xa4, 0x08, 0x69, 0xe2, 0x9a, 0x82,
0x78, 0x17, 0x96, 0xc7, 0x81, 0xff, 0xe8, 0x38, 0xe2, 0x5b, 0x0e, 0xf5, 0xdf, 0x69, 0xd0, 0x53,
0xad, 0xbd, 0x48, 0x7c, 0xb9, 0x0c, 0x4d, 0x91, 0xfd, 0xf8, 0x6a, 0x8c, 0x66, 0xcd, 0x68, 0xdc,
0x8f, 0x51, 0x40, 0x37, 0xe0, 0x3c, 0x47, 0x0a, 0x30, 0x99, 0x38, 0x61, 0x84, 0x5b, 0x64, 0xb8,
0x88, 0xfd, 0x33, 0xd8, 0x2f, 0x31, 0x43, 0xff, 0xbd, 0x06, 0x6b, 0xdb, 0x38, 0x8c, 0x8c, 0x48,
0xa9, 0xe2, 0xa7, 0x34, 0x64, 0x7f, 0xac, 0x41, 0x4f, 0xc5, 0xeb, 0x22, 0x6a, 0xbd, 0x07, 0xab,
0x11, 0x8d, 0xbe, 0x85, 0xc9, 0x30, 0xb0, 0xc7, 0xcc, 0x99, 0x59, 0x00, 0xaf, 0x6f, 0x5c, 0x5e,
0xcf, 0x16, 0x18, 0xeb, 0x69, 0x0e, 0x2e, 0x44, 0x4b, 0x6c, 0xc5, 0x56, 0xd0, 0x7f, 0xa2, 0xc1,
0x85, 0x6d, 0x1c, 0xee, 0xe3, 0x91, 0x8b, 0xbd, 0x70, 0xc7, 0x3b, 0xf4, 0xcf, 0xae, 0xd7, 0xe7,
0x00, 0x88, 0x58, 0x27, 0x4a, 0x2e, 0x31, 0xc8, 0x3c, 0x3a, 0x66, 0xb5, 0x4c, 0x9a, 0x9f, 0x45,
0x74, 0xf7, 0x65, 0x28, 0xdb, 0xde, 0xa1, 0x2f, 0x55, 0xf5, 0xbc, 0x4a, 0x55, 0x71, 0x62, 0x1c,
0x5b, 0xf7, 0x38, 0x17, 0x47, 0x66, 0x60, 0xdd, 0xc6, 0xa6, 0x85, 0x83, 0x05, 0xdc, 0x2d, 0x2d,
0x76, 0x41, 0x21, 0xf6, 0x8f, 0x35, 0x78, 0x26, 0x43, 0x70, 0x11, 0xb9, 0xbf, 0x06, 0x15, 0x42,
0x17, 0x93, 0x82, 0xbf, 0xa8, 0x14, 0x3c, 0x46, 0xee, 0xb6, 0x4d, 0x42, 0x43, 0xcc, 0xd1, 0x7d,
0xe8, 0xa4, 0xff, 0xa1, 0x17, 0xa0, 0x21, 0xb6, 0x6a, 0xdf, 0x33, 0x5d, 0xae, 0x80, 0x9a, 0x51,
0x17, 0xb0, 0x5d, 0xd3, 0xc5, 0x68, 0x0d, 0xaa, 0x34, 0x70, 0xf5, 0x6d, 0x4b, 0x9a, 0x7f, 0x99,
0x05, 0x32, 0x8b, 0xa0, 0x67, 0x01, 0xd8, 0x2f, 0xd3, 0xb2, 0x02, 0x5e, 0x4c, 0xd4, 0x8c, 0x1a,
0x85, 0xbc, 0x49, 0x01, 0xfa, 0xbf, 0x0b, 0xb0, 0xfa, 0xa6, 0x65, 0xa9, 0xc2, 0xdc, 0xe9, 0x15,
0x3e, 0x8d, 0xa6, 0x85, 0x78, 0x34, 0x9d, 0x6b, 0x8f, 0x67, 0x42, 0x58, 0xe9, 0x14, 0x21, 0xac,
0x9c, 0x17, 0xc2, 0xd0, 0x36, 0x34, 0x09, 0xc6, 0x1f, 0xf4, 0xc7, 0x3e, 0x61, 0x7b, 0x90, 0x65,
0xac, 0xfa, 0x86, 0x9e, 0x94, 0x26, 0xaa, 0xfb, 0xef, 0x90, 0xd1, 0x9e, 0xc0, 0x34, 0x1a, 0x74,
0xa2, 0x1c, 0xa1, 0xbb, 0xb0, 0x3a, 0x72, 0xfc, 0x81, 0xe9, 0xf4, 0x09, 0x36, 0x1d, 0x6c, 0xf5,
0xc5, 0xfe, 0x22, 0xdd, 0xe5, 0xf9, 0x1c, 0xfc, 0x3c, 0x9f, 0xbe, 0xcf, 0x66, 0x8b, 0x1f, 0x44,
0xff, 0x87, 0x06, 0x6b, 0x06, 0x76, 0xfd, 0x07, 0xf8, 0x7f, 0xd5, 0x04, 0xfa, 0xcf, 0x34, 0x68,
0xd0, 0xe2, 0xe8, 0x0e, 0x0e, 0x4d, 0xaa, 0x09, 0xf4, 0x06, 0xd4, 0x1c, 0xdf, 0xb4, 0xfa, 0xe1,
0xf1, 0x98, 0x8b, 0xd6, 0x4a, 0x8b, 0xc6, 0xb5, 0x47, 0x27, 0x1d, 0x1c, 0x8f, 0xb1, 0x51, 0x75,
0xc4, 0xd7, 0x3c, 0x5b, 0x3a, 0x93, 0x2d, 0x8a, 0x8a, 0x6c, 0xf1, 0x97, 0x22, 0xac, 0x7e, 0xcb,
0x0c, 0x87, 0x47, 0x5b, 0xae, 0x60, 0x93, 0x3c, 0x19, 0x9d, 0xcf, 0x53, 0xa4, 0x44, 0xa1, 0xb4,
0xac, 0xf2, 0x34, 0xda, 0x95, 0xae, 0xbf, 0x27, 0xcc, 0x10, 0x0b, 0xa5, 0xb1, 0x62, 0xaf, 0x72,
0x96, 0x62, 0x6f, 0x13, 0x9a, 0xf8, 0xd1, 0xd0, 0x99, 0xd0, 0xb0, 0xc2, 0xa8, 0x73, 0x3f, 0x7f,
0x4e, 0x41, 0x3d, 0xee, 0xe6, 0x0d, 0x31, 0x69, 0x47, 0xf0, 0xc0, 0x4d, 0xed, 0xe2, 0xd0, 0xec,
0x56, 0x19, 0x1b, 0x97, 0xf2, 0x4c, 0x2d, 0xfd, 0x83, 0x9b, 0x9b, 0x8e, 0xd0, 0x45, 0xa8, 0x89,
0xd2, 0x72, 0x67, 0xab, 0x5b, 0x63, 0xea, 0x9b, 0x02, 0xf4, 0xff, 0x68, 0xb0, 0xc6, 0x8d, 0x88,
0x9d, 0xd0, 0x7c, 0xb2, 0x76, 0x8c, 0x6c, 0x54, 0x3a, 0xa5, 0x8d, 0x62, 0xfa, 0xa9, 0x9d, 0x56,
0x3f, 0xfa, 0x9f, 0x4a, 0xd0, 0x16, 0xca, 0xa7, 0x18, 0x6c, 0x77, 0x5d, 0x84, 0x5a, 0x94, 0xfa,
0x45, 0x69, 0x3a, 0x05, 0xa0, 0x4b, 0x50, 0x8f, 0xf9, 0x96, 0x10, 0x34, 0x0e, 0x9a, 0x4b, 0x5a,
0x59, 0xc8, 0x95, 0x62, 0x85, 0xdc, 0xb3, 0x00, 0x87, 0xce, 0x84, 0x1c, 0xf5, 0x43, 0xdb, 0xc5,
0xa2, 0x9c, 0xae, 0x31, 0xc8, 0x81, 0xed, 0x62, 0xf4, 0x26, 0x34, 0x06, 0xb6, 0xe7, 0xf8, 0xa3,
0xfe, 0xd8, 0x0c, 0x8f, 0x48, 0xb7, 0x92, 0xeb, 0x4d, 0xb7, 0x6c, 0xec, 0x58, 0x37, 0x19, 0xae,
0x51, 0xe7, 0x73, 0xf6, 0xe8, 0x14, 0xf4, 0x1c, 0xd4, 0xbd, 0x89, 0xdb, 0xf7, 0x0f, 0xfb, 0x81,
0xff, 0x90, 0xfa, 0x23, 0x23, 0xe1, 0x4d, 0xdc, 0x77, 0x0e, 0x0d, 0xff, 0x21, 0x4d, 0xbd, 0x35,
0x9a, 0x84, 0x89, 0xe3, 0x8f, 0x48, 0xb7, 0x3a, 0xd7, 0xfa, 0xd3, 0x09, 0x74, 0xb6, 0x45, 0xfd,
0x88, 0xcd, 0xae, 0xcd, 0x37, 0x3b, 0x9a, 0x80, 0x5e, 0x82, 0xd6, 0xd0, 0x77, 0xc7, 0x26, 0xd3,
0xd0, 0xad, 0xc0, 0x77, 0xbb, 0xc0, 0x76, 0x72, 0x0a, 0x8a, 0x36, 0xa1, 0x6e, 0x7b, 0x16, 0x7e,
0x24, 0xf6, 0x54, 0x9d, 0xd1, 0xd1, 0x55, 0x26, 0x67, 0x84, 0x76, 0x28, 0x2e, 0x33, 0x3a, 0xd8,
0xf2, 0x93, 0xd0, 0x8a, 0x40, 0x58, 0xb4, 0x4f, 0xec, 0x0f, 0x71, 0xb7, 0xc1, 0xad, 0x28, 0x60,
0xfb, 0xf6, 0x87, 0x98, 0xb6, 0x6a, 0xb6, 0x47, 0x70, 0x30, 0x0d, 0xd0, 0x4d, 0x16, 0xa0, 0x9b,
0x1c, 0x2a, 0x63, 0xf3, 0x1f, 0x0b, 0xd0, 0x4a, 0x12, 0xa2, 0x9d, 0xcb, 0x21, 0x83, 0x48, 0xef,
0x91, 0x43, 0x4a, 0x16, 0x7b, 0xe6, 0xc0, 0xa1, 0x01, 0xc1, 0xc2, 0x8f, 0x98, 0xf3, 0x54, 0x8d,
0x3a, 0x87, 0xb1, 0x05, 0xa8, 0x13, 0x70, 0xf1, 0x58, 0xa5, 0xc2, 0x3b, 0x8b, 0x1a, 0x83, 0xb0,
0x3a, 0xa5, 0x0b, 0xcb, 0x5c, 0x0c, 0xe9, 0x3a, 0x72, 0x48, 0xff, 0x0c, 0x26, 0x36, 0xa3, 0xca,
0x5d, 0x47, 0x0e, 0xd1, 0x16, 0x34, 0xf8, 0x92, 0x63, 0x33, 0x30, 0x5d, 0xe9, 0x38, 0x2f, 0x28,
0xf7, 0xf3, 0xdb, 0xf8, 0xf8, 0x3d, 0xd3, 0x99, 0xe0, 0x3d, 0xd3, 0x0e, 0x0c, 0xae, 0xe8, 0x3d,
0x36, 0x0b, 0x5d, 0x85, 0x0e, 0x5f, 0xe5, 0xd0, 0x76, 0xb0, 0x70, 0xc1, 0x65, 0x56, 0x0c, 0xb5,
0x18, 0xfc, 0x96, 0xed, 0x60, 0xee, 0x65, 0x91, 0x08, 0x4c, 0xb5, 0x55, 0xee, 0x64, 0x0c, 0x42,
0x15, 0xab, 0x7f, 0xbf, 0x08, 0x2b, 0x74, 0xaf, 0xc9, 0x0c, 0x7e, 0xf6, 0x70, 0xf3, 0x2c, 0x80,
0x45, 0xc2, 0x7e, 0x22, 0xe4, 0xd4, 0x2c, 0x12, 0xee, 0xf2, 0xa8, 0xf3, 0x86, 0x8c, 0x28, 0xc5,
0xfc, 0x5e, 0x23, 0xb5, 0xf7, 0xb3, 0x91, 0xff, 0x4c, 0x67, 0x32, 0x97, 0xa1, 0x49, 0xfc, 0x49,
0x30, 0xc4, 0xfd, 0x44, 0x6f, 0xdc, 0xe0, 0xc0, 0x5d, 0x75, 0x50, 0xac, 0x28, 0xcf, 0x86, 0x62,
0xd1, 0x6d, 0x79, 0xb1, 0xe8, 0x5f, 0x4d, 0x47, 0xff, 0xbf, 0x6b, 0xb0, 0x2a, 0x4e, 0x19, 0x16,
0xb7, 0x45, 0x5e, 0xe8, 0x97, 0x81, 0xae, 0x78, 0x42, 0xc7, 0x5a, 0x9a, 0x23, 0xad, 0x97, 0x15,
0x69, 0x3d, 0xd9, 0xb5, 0x55, 0xd2, 0x5d, 0x9b, 0xfe, 0x03, 0x0d, 0x9a, 0xfb, 0xd8, 0x0c, 0x86,
0x47, 0x52, 0xae, 0xaf, 0x40, 0x31, 0xc0, 0xf7, 0x85, 0x58, 0x2f, 0xe6, 0x94, 0xb0, 0x89, 0x29,
0x06, 0x9d, 0x80, 0x9e, 0x87, 0xba, 0xe5, 0x3a, 0xa9, 0xc3, 0x01, 0xb0, 0x5c, 0x47, 0x16, 0x75,
0x49, 0x56, 0x8a, 0x19, 0x56, 0x3e, 0xd2, 0xa0, 0xf1, 0x2e, 0xaf, 0xec, 0x38, 0x27, 0xaf, 0xc7,
0x39, 0x79, 0x29, 0x87, 0x13, 0x03, 0x87, 0x81, 0x8d, 0x1f, 0xe0, 0x4f, 0x97, 0x97, 0xbf, 0x6a,
0xd0, 0xdb, 0x3f, 0xf6, 0x86, 0x06, 0xf7, 0x84, 0xc5, 0x6d, 0x7f, 0x19, 0x9a, 0x0f, 0x12, 0x0d,
0x96, 0x38, 0x3c, 0x79, 0x10, 0xef, 0xb0, 0x0c, 0xe8, 0xc8, 0xa3, 0xaf, 0xa8, 0xf0, 0xe7, 0x1b,
0xf3, 0x65, 0x95, 0x47, 0xa7, 0x98, 0x63, 0x8e, 0xdd, 0x0e, 0x92, 0x40, 0x3d, 0x80, 0x15, 0x05,
0x1e, 0x7a, 0x06, 0x96, 0x45, 0x33, 0x27, 0x02, 0x30, 0x77, 0x46, 0x8b, 0xc6, 0xdf, 0xe9, 0x71,
0x84, 0x6d, 0x65, 0x93, 0xb7, 0x45, 0xb5, 0x2b, 0x33, 0x03, 0xed, 0x05, 0x53, 0xda, 0xb3, 0x88,
0xfe, 0x53, 0x0d, 0x56, 0xdf, 0x32, 0x3d, 0xcb, 0x3f, 0x3c, 0x5c, 0x5c, 0x73, 0x9b, 0x51, 0x1e,
0xda, 0x39, 0x4d, 0xab, 0x9f, 0x98, 0xa4, 0xff, 0xa1, 0x00, 0x88, 0x06, 0x80, 0x9b, 0xa6, 0x63,
0x7a, 0x43, 0x7c, 0x76, 0x6e, 0xae, 0x40, 0x2b, 0x11, 0xb6, 0xa2, 0x6b, 0x8b, 0x78, 0xdc, 0x22,
0xe8, 0x6d, 0x68, 0x0d, 0x38, 0xa9, 0x7e, 0x80, 0x4d, 0xe2, 0x7b, 0x6c, 0x73, 0xb7, 0xd4, 0x8d,
0xfa, 0x41, 0x60, 0x8f, 0x46, 0x38, 0xd8, 0xf4, 0x3d, 0x8b, 0x37, 0x85, 0xcd, 0x81, 0x64, 0x93,
0x4e, 0x65, 0xde, 0x1c, 0xc5, 0x70, 0x59, 0xbd, 0x43, 0x14, 0xc4, 0x09, 0x7a, 0x05, 0xce, 0x25,
0xfb, 0xc5, 0x69, 0x34, 0xe8, 0x90, 0x78, 0x2b, 0xa8, 0x3a, 0xa7, 0x51, 0xc4, 0x54, 0xfd, 0x17,
0x1a, 0xa0, 0xa8, 0x69, 0x61, 0xd5, 0x2f, 0x73, 0x9a, 0x79, 0xce, 0x24, 0x2f, 0x42, 0xcd, 0x92,
0x33, 0x85, 0x93, 0x4f, 0x01, 0x74, 0x1b, 0x70, 0x31, 0xfa, 0x34, 0x00, 0x63, 0x4b, 0x16, 0x7e,
0x1c, 0x78, 0x9b, 0xc1, 0x92, 0x21, 0xb9, 0x94, 0x0e, 0xc9, 0x1f, 0x17, 0xa0, 0x13, 0x6f, 0x63,
0xe7, 0xe6, 0xec, 0xf1, 0x9c, 0x5f, 0x9e, 0xd0, 0xb3, 0x97, 0x16, 0xe8, 0xd9, 0xb3, 0x67, 0x0a,
0xe5, 0xb3, 0x9d, 0x29, 0xe8, 0xbf, 0xd2, 0xa0, 0x9d, 0x3a, 0x2e, 0x4c, 0x17, 0xe8, 0x5a, 0xb6,
0x40, 0x7f, 0x1d, 0xca, 0xb4, 0x6a, 0xe5, 0x71, 0xaa, 0xa5, 0x2e, 0x1e, 0x93, 0xab, 0x1a, 0x7c,
0x02, 0xba, 0x0e, 0x2b, 0x8a, 0x2b, 0x26, 0x61, 0x68, 0x94, 0xbd, 0x61, 0xd2, 0x3f, 0x29, 0x41,
0x3d, 0xa6, 0x8f, 0x19, 0xbd, 0xc5, 0x3c, 0xcd, 0x79, 0x4a, 0xbc, 0x62, 0x56, 0xbc, 0x9c, 0x3b,
0x16, 0xb4, 0x06, 0x55, 0x17, 0xbb, 0xbc, 0x2a, 0x13, 0x25, 0xa2, 0x8b, 0x5d, 0x56, 0xec, 0xae,
0x41, 0x95, 0x36, 0x06, 0xac, 0x2b, 0xe0, 0x7b, 0x66, 0xd9, 0x9b, 0xb8, 0xac, 0x27, 0x48, 0x16,
0xa4, 0xcb, 0x27, 0x14, 0xa4, 0xd5, 0x64, 0x41, 0x9a, 0xd8, 0x2c, 0xb5, 0xf4, 0x66, 0x99, 0xb7,
0xdc, 0xbf, 0x01, 0x2b, 0x43, 0x76, 0xd6, 0x6f, 0xdd, 0x3c, 0xde, 0x8c, 0x7e, 0x75, 0xeb, 0xac,
0x72, 0x56, 0xfd, 0x42, 0xb7, 0xa8, 0x73, 0x89, 0xda, 0x9e, 0x59, 0xb9, 0xc1, 0xac, 0xac, 0xae,
0x77, 0x85, 0x6d, 0xb8, 0x91, 0x65, 0x58, 0x65, 0xa3, 0x74, 0xa3, 0xd1, 0x3c, 0x53, 0xa3, 0xf1,
0x3c, 0xd4, 0x65, 0xd6, 0xa3, 0xe9, 0xa4, 0xc5, 0xc3, 0x9b, 0xdc, 0xf0, 0x16, 0x49, 0x1c, 0x3c,
0xb6, 0x13, 0x07, 0x8f, 0xfa, 0xdf, 0x8a, 0xd0, 0x9a, 0x96, 0x98, 0x73, 0x87, 0x82, 0x79, 0xae,
0x4a, 0x77, 0xa1, 0x33, 0x4d, 0x84, 0x4c, 0x4b, 0x27, 0x56, 0xc9, 0xe9, 0x13, 0xf9, 0xf6, 0x38,
0xb5, 0xe7, 0x12, 0x07, 0x52, 0xa5, 0x53, 0x1d, 0x48, 0x2d, 0x78, 0xa3, 0xf6, 0x1a, 0x5c, 0x08,
0x78, 0x0d, 0x6b, 0xf5, 0x13, 0x62, 0xf3, 0x72, 0xf0, 0xbc, 0xfc, 0xb9, 0x17, 0x17, 0x3f, 0x67,
0x1b, 0x2f, 0xe7, 0x6d, 0xe3, 0xb4, 0x19, 0xab, 0x19, 0x33, 0x66, 0x2f, 0xf6, 0x6a, 0xaa, 0x8b,
0xbd, 0xbb, 0xb0, 0x72, 0xd7, 0x23, 0x93, 0x01, 0x19, 0x06, 0xf6, 0x00, 0xcb, 0x03, 0x97, 0xb9,
0xcc, 0xda, 0x83, 0xaa, 0x88, 0xd7, 0xdc, 0xa4, 0x35, 0x23, 0x1a, 0xeb, 0x3f, 0xd4, 0x60, 0x35,
0xbb, 0x2e, 0xf3, 0x98, 0x69, 0x30, 0xd0, 0x12, 0xc1, 0xe0, 0xdb, 0xb0, 0x32, 0x5d, 0xbe, 0x9f,
0x58, 0x39, 0xa7, 0x22, 0x53, 0x30, 0x6e, 0xa0, 0xe9, 0x1a, 0x12, 0xa6, 0xff, 0x4b, 0x83, 0x73,
0x62, 0x5b, 0x51, 0xd8, 0x88, 0x1d, 0x64, 0xd1, 0x04, 0xe5, 0x7b, 0x8e, 0xed, 0x45, 0x2d, 0x91,
0x90, 0x91, 0x03, 0x45, 0x4b, 0xf4, 0x16, 0xb4, 0x05, 0x52, 0x94, 0x67, 0xe6, 0xac, 0x88, 0x5a,
0x7c, 0x5e, 0x94, 0x61, 0xae, 0x40, 0xcb, 0x3f, 0x3c, 0x8c, 0xd3, 0xe3, 0x81, 0xb2, 0x29, 0xa0,
0x82, 0xe0, 0x37, 0xa1, 0x23, 0xd1, 0x4e, 0x9b, 0xd9, 0xda, 0x62, 0x62, 0x54, 0x8c, 0x7e, 0xa4,
0x41, 0x37, 0x99, 0xe7, 0x62, 0xe2, 0x9f, 0xbe, 0x18, 0xfb, 0x6a, 0xf2, 0xfa, 0xe7, 0xca, 0x09,
0xfc, 0x4c, 0xe9, 0x88, 0xfe, 0xf5, 0xda, 0x87, 0xd0, 0x4a, 0xee, 0x59, 0xd4, 0x80, 0xea, 0xae,
0x1f, 0x7e, 0xe3, 0x91, 0x4d, 0xc2, 0xce, 0x12, 0x6a, 0x01, 0xec, 0xfa, 0xe1, 0x5e, 0x80, 0x09,
0xf6, 0xc2, 0x8e, 0x86, 0x00, 0x2a, 0xef, 0x78, 0x5b, 0x36, 0xf9, 0xa0, 0x53, 0x40, 0x2b, 0x22,
0xa5, 0x9a, 0xce, 0x8e, 0xd8, 0x08, 0x9d, 0x22, 0x9d, 0x1e, 0x8d, 0x4a, 0xa8, 0x03, 0x8d, 0x08,
0x65, 0x7b, 0xef, 0x6e, 0xa7, 0x8c, 0x6a, 0x50, 0xe6, 0x9f, 0x95, 0x6b, 0x16, 0x74, 0xd2, 0x45,
0x1f, 0x5d, 0xf3, 0xae, 0xf7, 0xb6, 0xe7, 0x3f, 0x8c, 0x40, 0x9d, 0x25, 0x54, 0x87, 0x65, 0x51,
0x48, 0x77, 0x34, 0xd4, 0x86, 0x7a, 0xac, 0x86, 0xed, 0x14, 0x28, 0x60, 0x3b, 0x18, 0x0f, 0x45,
0x35, 0xcb, 0x59, 0xa0, 0x56, 0xdb, 0xf2, 0x1f, 0x7a, 0x9d, 0xd2, 0xb5, 0x9b, 0x50, 0x95, 0xc1,
0x84, 0xa2, 0xf2, 0xd5, 0x3d, 0x3a, 0xec, 0x2c, 0xa1, 0x73, 0xd0, 0x4c, 0x3c, 0x26, 0xe8, 0x68,
0x08, 0x41, 0x2b, 0xf9, 0xd0, 0xa3, 0x53, 0xd8, 0xf8, 0x79, 0x13, 0x80, 0x57, 0x5b, 0xbe, 0x1f,
0x58, 0x68, 0x0c, 0x68, 0x1b, 0x87, 0x34, 0x93, 0xf8, 0x9e, 0xcc, 0x02, 0x04, 0xdd, 0xc8, 0x29,
0x4a, 0xb2, 0xa8, 0x82, 0xd5, 0x5e, 0x5e, 0x37, 0x97, 0x42, 0xd7, 0x97, 0x90, 0xcb, 0x28, 0x1e,
0xd8, 0x2e, 0x3e, 0xb0, 0x87, 0x1f, 0x44, 0x65, 0x5a, 0x3e, 0xc5, 0x14, 0xaa, 0xa4, 0x98, 0x0a,
0xda, 0x62, 0xb0, 0x1f, 0x06, 0xb6, 0x37, 0x92, 0x97, 0x71, 0xfa, 0x12, 0xba, 0x0f, 0xe7, 0xb7,
0x31, 0xa3, 0x6e, 0x93, 0xd0, 0x1e, 0x12, 0x49, 0x70, 0x23, 0x9f, 0x60, 0x06, 0xf9, 0x94, 0x24,
0x1d, 0x68, 0xa7, 0x1e, 0x56, 0xa1, 0x6b, 0xea, 0xfb, 0x3c, 0xd5, 0x23, 0xb0, 0xde, 0x2b, 0x73,
0xe1, 0x46, 0xd4, 0x6c, 0x68, 0x25, 0x1f, 0x1d, 0xa1, 0xcf, 0xe7, 0x2d, 0x90, 0x79, 0x57, 0xd1,
0xbb, 0x36, 0x0f, 0x6a, 0x44, 0xea, 0x1e, 0xf7, 0xa7, 0x59, 0xa4, 0x94, 0x6f, 0x5a, 0x7a, 0x27,
0xdd, 0x83, 0xea, 0x4b, 0xe8, 0xbb, 0x70, 0x2e, 0xf3, 0xfa, 0x03, 0x7d, 0x41, 0xdd, 0x25, 0xab,
0x1f, 0x89, 0xcc, 0xa2, 0x70, 0x2f, 0xbd, 0x1b, 0xf2, 0xb9, 0xcf, 0xbc, 0x16, 0x9a, 0x9f, 0xfb,
0xd8, 0xf2, 0x27, 0x71, 0x7f, 0x6a, 0x0a, 0x13, 0x40, 0xd9, 0xf7, 0x1f, 0xe8, 0x55, 0x15, 0x89,
0xdc, 0x37, 0x28, 0xbd, 0xf5, 0x79, 0xd1, 0x23, 0x93, 0x4f, 0xd8, 0x6e, 0x4d, 0xb7, 0x1b, 0x4a,
0xb2, 0xb9, 0x6f, 0x3e, 0xd4, 0x64, 0xf3, 0x9f, 0x5d, 0x70, 0xa7, 0x4e, 0x3e, 0x2b, 0x50, 0xdb,
0x4a, 0xf9, 0x14, 0x42, 0xed, 0xd4, 0xea, 0x57, 0x0a, 0xfa, 0x12, 0x3a, 0x48, 0x04, 0x61, 0xf4,
0x52, 0x9e, 0x4f, 0x24, 0x4f, 0x1a, 0x66, 0x99, 0xab, 0x0f, 0xb0, 0x8d, 0xc3, 0x3b, 0x38, 0x0c,
0xec, 0x21, 0x49, 0x2f, 0x2a, 0x06, 0x53, 0x04, 0xb9, 0xe8, 0xcb, 0x33, 0xf1, 0x22, 0xb6, 0x07,
0x50, 0xdf, 0xc6, 0xa1, 0x38, 0x09, 0x22, 0x28, 0x77, 0xa6, 0xc4, 0x90, 0x24, 0xae, 0xce, 0x46,
0x8c, 0x07, 0xb2, 0xd4, 0x2b, 0x07, 0x94, 0xab, 0xdb, 0xec, 0xdb, 0x0b, 0x75, 0x20, 0xcb, 0x79,
0x36, 0xa1, 0x2f, 0x6d, 0x7c, 0xd2, 0x80, 0x1a, 0xf3, 0x42, 0x9a, 0xf1, 0xfe, 0x9f, 0x98, 0x1e,
0x43, 0x62, 0x7a, 0x1f, 0xda, 0xa9, 0x57, 0x1b, 0x6a, 0x7b, 0xaa, 0x9f, 0x76, 0xcc, 0x72, 0xf9,
0x01, 0xa0, 0xec, 0x9b, 0x04, 0x75, 0xa8, 0xc8, 0x7d, 0xbb, 0x30, 0x8b, 0xc6, 0xfb, 0xd0, 0x4e,
0x5d, 0xc0, 0xab, 0x25, 0x50, 0xdf, 0xd2, 0xcf, 0x21, 0x41, 0xf6, 0x66, 0x58, 0x2d, 0x41, 0xee,
0x0d, 0xf2, 0x2c, 0x1a, 0xef, 0xf1, 0x67, 0x0d, 0x51, 0xd1, 0xfe, 0x72, 0x5e, 0xbc, 0x49, 0x1d,
0xb4, 0x3e, 0xf9, 0x0c, 0xf4, 0xf8, 0x33, 0xf4, 0xfb, 0xd0, 0x4e, 0xdd, 0xcd, 0xa8, 0xad, 0xab,
0xbe, 0xc0, 0x99, 0xb5, 0xfa, 0x67, 0x98, 0x53, 0x2c, 0x58, 0x51, 0x5c, 0x36, 0x20, 0x65, 0x1e,
0xcc, 0xbf, 0x95, 0x98, 0x25, 0xd0, 0x3e, 0x54, 0xf8, 0xb5, 0x0d, 0x7a, 0x41, 0xdd, 0x28, 0xc5,
0xae, 0x74, 0x7a, 0xb3, 0x2e, 0x7e, 0xc8, 0xc4, 0x09, 0xf9, 0xa2, 0x65, 0xb6, 0x2f, 0x91, 0xf2,
0xce, 0x2d, 0x7e, 0x9d, 0xd3, 0x9b, 0x7d, 0x83, 0x23, 0x17, 0x7d, 0xdc, 0xd9, 0xf0, 0xe6, 0x97,
0xee, 0x6d, 0x8c, 0xec, 0xf0, 0x68, 0x32, 0xa0, 0x4a, 0xba, 0xce, 0x31, 0x5f, 0xb5, 0x7d, 0xf1,
0x75, 0x5d, 0xb2, 0x76, 0x9d, 0xad, 0x74, 0x9d, 0xc9, 0x32, 0x1e, 0x0c, 0x2a, 0x6c, 0xf8, 0xda,
0x7f, 0x03, 0x00, 0x00, 0xff, 0xff, 0x29, 0x09, 0x3e, 0x05, 0x05, 0x32, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
@ -3651,6 +3768,7 @@ type QueryNodeClient interface {
ReleasePartitions(ctx context.Context, in *ReleasePartitionsRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
ReleaseSegments(ctx context.Context, in *ReleaseSegmentsRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
GetSegmentInfo(ctx context.Context, in *GetSegmentInfoRequest, opts ...grpc.CallOption) (*GetSegmentInfoResponse, error)
SyncReplicaSegments(ctx context.Context, in *SyncReplicaSegmentsRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
Search(ctx context.Context, in *SearchRequest, opts ...grpc.CallOption) (*internalpb.SearchResults, error)
Query(ctx context.Context, in *QueryRequest, opts ...grpc.CallOption) (*internalpb.RetrieveResults, error)
// https://wiki.lfaidata.foundation/display/MIL/MEP+8+--+Add+metrics+for+proxy
@ -3773,6 +3891,15 @@ func (c *queryNodeClient) GetSegmentInfo(ctx context.Context, in *GetSegmentInfo
return out, nil
}
func (c *queryNodeClient) SyncReplicaSegments(ctx context.Context, in *SyncReplicaSegmentsRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
out := new(commonpb.Status)
err := c.cc.Invoke(ctx, "/milvus.proto.query.QueryNode/SyncReplicaSegments", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *queryNodeClient) Search(ctx context.Context, in *SearchRequest, opts ...grpc.CallOption) (*internalpb.SearchResults, error) {
out := new(internalpb.SearchResults)
err := c.cc.Invoke(ctx, "/milvus.proto.query.QueryNode/Search", in, out, opts...)
@ -3814,6 +3941,7 @@ type QueryNodeServer interface {
ReleasePartitions(context.Context, *ReleasePartitionsRequest) (*commonpb.Status, error)
ReleaseSegments(context.Context, *ReleaseSegmentsRequest) (*commonpb.Status, error)
GetSegmentInfo(context.Context, *GetSegmentInfoRequest) (*GetSegmentInfoResponse, error)
SyncReplicaSegments(context.Context, *SyncReplicaSegmentsRequest) (*commonpb.Status, error)
Search(context.Context, *SearchRequest) (*internalpb.SearchResults, error)
Query(context.Context, *QueryRequest) (*internalpb.RetrieveResults, error)
// https://wiki.lfaidata.foundation/display/MIL/MEP+8+--+Add+metrics+for+proxy
@ -3860,6 +3988,9 @@ func (*UnimplementedQueryNodeServer) ReleaseSegments(ctx context.Context, req *R
func (*UnimplementedQueryNodeServer) GetSegmentInfo(ctx context.Context, req *GetSegmentInfoRequest) (*GetSegmentInfoResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetSegmentInfo not implemented")
}
func (*UnimplementedQueryNodeServer) SyncReplicaSegments(ctx context.Context, req *SyncReplicaSegmentsRequest) (*commonpb.Status, error) {
return nil, status.Errorf(codes.Unimplemented, "method SyncReplicaSegments not implemented")
}
func (*UnimplementedQueryNodeServer) Search(ctx context.Context, req *SearchRequest) (*internalpb.SearchResults, error) {
return nil, status.Errorf(codes.Unimplemented, "method Search not implemented")
}
@ -4090,6 +4221,24 @@ func _QueryNode_GetSegmentInfo_Handler(srv interface{}, ctx context.Context, dec
return interceptor(ctx, in, info, handler)
}
func _QueryNode_SyncReplicaSegments_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(SyncReplicaSegmentsRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(QueryNodeServer).SyncReplicaSegments(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/milvus.proto.query.QueryNode/SyncReplicaSegments",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(QueryNodeServer).SyncReplicaSegments(ctx, req.(*SyncReplicaSegmentsRequest))
}
return interceptor(ctx, in, info, handler)
}
func _QueryNode_Search_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(SearchRequest)
if err := dec(in); err != nil {
@ -4196,6 +4345,10 @@ var _QueryNode_serviceDesc = grpc.ServiceDesc{
MethodName: "GetSegmentInfo",
Handler: _QueryNode_GetSegmentInfo_Handler,
},
{
MethodName: "SyncReplicaSegments",
Handler: _QueryNode_SyncReplicaSegments_Handler,
},
{
MethodName: "Search",
Handler: _QueryNode_Search_Handler,

4
internal/proxy/query_node_mock_test.go
View File

@ -49,6 +49,10 @@ func (m *QueryNodeMock) Query(ctx context.Context, req *querypb.QueryRequest) (*
return m.withQueryResult, nil
}
func (m *QueryNodeMock) SyncReplicaSegments(ctx context.Context, req *querypb.SyncReplicaSegmentsRequest) (*commonpb.Status, error) {
return &commonpb.Status{}, nil
}
// TODO
func (m *QueryNodeMock) AddQueryChannel(ctx context.Context, req *querypb.AddQueryChannelRequest) (*commonpb.Status, error) {
return nil, nil

4
internal/querycoord/mock_querynode_client_test.go
View File

@ -165,3 +165,7 @@ func (client *queryNodeClientMock) Search(ctx context.Context, req *querypb.Sear
func (client *queryNodeClientMock) Query(ctx context.Context, req *querypb.QueryRequest) (*internalpb.RetrieveResults, error) {
return client.grpcClient.Query(ctx, req)
}
func (client *queryNodeClientMock) SyncReplicaSegments(ctx context.Context, req *querypb.SyncReplicaSegmentsRequest) (*commonpb.Status, error) {
return client.grpcClient.SyncReplicaSegments(ctx, req)
}

26
internal/querynode/impl.go
View File

@ -27,6 +27,7 @@ import (
"github.com/milvus-io/milvus/internal/proto/commonpb"
"github.com/milvus-io/milvus/internal/proto/internalpb"
"github.com/milvus-io/milvus/internal/proto/milvuspb"
"github.com/milvus-io/milvus/internal/proto/querypb"
queryPb "github.com/milvus-io/milvus/internal/proto/querypb"
"github.com/milvus-io/milvus/internal/util/metricsinfo"
"github.com/milvus-io/milvus/internal/util/typeutil"
@ -671,6 +672,31 @@ func (node *QueryNode) Query(ctx context.Context, req *queryPb.QueryRequest) (*i
return results, nil
}
// SyncReplicaSegments syncs replica node & segments states
func (node *QueryNode) SyncReplicaSegments(ctx context.Context, req *querypb.SyncReplicaSegmentsRequest) (*commonpb.Status, error) {
if !node.isHealthy() {
return &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: msgQueryNodeIsUnhealthy(Params.QueryNodeCfg.GetNodeID()),
}, nil
}
log.Debug("Received SyncReplicaSegments request", zap.String("vchannelName", req.GetVchannelName()))
err := node.ShardClusterService.SyncReplicaSegments(req.GetVchannelName(), req.GetReplicaSegments())
if err != nil {
log.Warn("failed to sync replica semgents,", zap.String("vchannel", req.GetVchannelName()), zap.Error(err))
return &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: err.Error(),
}, nil
}
log.Debug("SyncReplicaSegments Done", zap.String("vchannel", req.GetVchannelName()))
return &commonpb.Status{ErrorCode: commonpb.ErrorCode_Success}, nil
}
// GetMetrics return system infos of the query node, such as total memory, memory usage, cpu usage ...
// TODO(dragondriver): cache the Metrics and set a retention to the cache
func (node *QueryNode) GetMetrics(ctx context.Context, req *milvuspb.GetMetricsRequest) (*milvuspb.GetMetricsResponse, error) {

74
internal/querynode/impl_test.go
View File

@ -30,6 +30,7 @@ import (
"github.com/milvus-io/milvus/internal/proto/commonpb"
"github.com/milvus-io/milvus/internal/proto/internalpb"
"github.com/milvus-io/milvus/internal/proto/milvuspb"
"github.com/milvus-io/milvus/internal/proto/querypb"
queryPb "github.com/milvus-io/milvus/internal/proto/querypb"
"github.com/milvus-io/milvus/internal/util/etcd"
"github.com/milvus-io/milvus/internal/util/metricsinfo"
@ -601,6 +602,7 @@ func TestImpl_Query(t *testing.T) {
defer cancel()
node, err := genSimpleQueryNode(ctx)
defer node.Stop()
require.NoError(t, err)
req, err := genSimpleRetrieveRequest()
@ -614,3 +616,75 @@ func TestImpl_Query(t *testing.T) {
})
assert.NoError(t, err)
}
func TestImpl_SyncReplicaSegments(t *testing.T) {
t.Run("QueryNode not healthy", func(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
node, err := genSimpleQueryNode(ctx)
defer node.Stop()
assert.NoError(t, err)
node.UpdateStateCode(internalpb.StateCode_Abnormal)
resp, err := node.SyncReplicaSegments(ctx, &querypb.SyncReplicaSegmentsRequest{})
assert.NoError(t, err)
assert.Equal(t, commonpb.ErrorCode_UnexpectedError, resp.GetErrorCode())
})
t.Run("Sync non-exist channel", func(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
node, err := genSimpleQueryNode(ctx)
defer node.Stop()
assert.NoError(t, err)
resp, err := node.SyncReplicaSegments(ctx, &querypb.SyncReplicaSegmentsRequest{
VchannelName: defaultDMLChannel,
ReplicaSegments: []*queryPb.ReplicaSegmentsInfo{
{
NodeId: 1,
PartitionId: defaultPartitionID,
SegmentIds: []int64{1},
},
},
})
assert.NoError(t, err)
assert.Equal(t, commonpb.ErrorCode_UnexpectedError, resp.GetErrorCode())
})
t.Run("Normal sync segments", func(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
node, err := genSimpleQueryNode(ctx)
defer node.Stop()
assert.NoError(t, err)
node.ShardClusterService.addShardCluster(defaultCollectionID, defaultReplicaID, defaultDMLChannel)
resp, err := node.SyncReplicaSegments(ctx, &querypb.SyncReplicaSegmentsRequest{
VchannelName: defaultDMLChannel,
ReplicaSegments: []*queryPb.ReplicaSegmentsInfo{
{
NodeId: 1,
PartitionId: defaultPartitionID,
SegmentIds: []int64{1},
},
},
})
assert.NoError(t, err)
assert.Equal(t, commonpb.ErrorCode_Success, resp.GetErrorCode())
t.Log(resp.GetReason())
cs, ok := node.ShardClusterService.getShardCluster(defaultDMLChannel)
require.True(t, ok)
segment, ok := cs.getSegment(1)
require.True(t, ok)
assert.Equal(t, int64(1), segment.nodeID)
assert.Equal(t, defaultPartitionID, segment.partitionID)
assert.Equal(t, segmentStateLoaded, segment.state)
})
}

35
internal/querynode/shard_cluster.go
View File

@ -243,6 +243,41 @@ func (sc *ShardCluster) updateSegment(evt segmentEvent) {
sc.transferSegment(old, evt)
}
// SyncSegments synchronize segment distribution in batch
func (sc *ShardCluster) SyncSegments(distribution []*querypb.ReplicaSegmentsInfo, state segmentState) {
// notify handoff wait online if any
defer func() {
sc.segmentCond.L.Lock()
sc.segmentCond.Broadcast()
sc.segmentCond.L.Unlock()
}()
sc.mut.Lock()
defer sc.mut.Unlock()
for _, line := range distribution {
for _, segmentID := range line.GetSegmentIds() {
old, ok := sc.segments[segmentID]
if !ok { // newly add
sc.segments[segmentID] = &shardSegmentInfo{
nodeID: line.GetNodeId(),
partitionID: line.GetPartitionId(),
segmentID: segmentID,
state: state,
}
continue
}
sc.transferSegment(old, segmentEvent{
eventType: segmentAdd,
nodeID: line.GetNodeId(),
partitionID: line.GetPartitionId(),
segmentID: segmentID,
state: state,
})
}
}
}
// transferSegment apply segment state transition.
func (sc *ShardCluster) transferSegment(old *shardSegmentInfo, evt segmentEvent) {
switch old.state {

12
internal/querynode/shard_cluster_service.go
View File

@ -125,3 +125,15 @@ func (s *ShardClusterService) HandoffSegments(collectionID int64, info *querypb.
})
wg.Wait()
}
// SyncReplicaSegments dispatches nodeID segments distribution to ShardCluster.
func (s *ShardClusterService) SyncReplicaSegments(vchannelName string, distribution []*querypb.ReplicaSegmentsInfo) error {
sc, ok := s.getShardCluster(vchannelName)
if !ok {
return fmt.Errorf("Leader of VChannel %s is not this QueryNode %d", vchannelName, s.session.ServerID)
}
sc.SyncSegments(distribution, segmentStateLoaded)
return nil
}

38
internal/querynode/shard_cluster_service_test.go
View File

@ -50,3 +50,41 @@ func TestShardClusterService_HandoffSegments(t *testing.T) {
clusterService.HandoffSegments(defaultCollectionID, &querypb.SegmentChangeInfo{})
})
}
func TestShardClusterService_SyncReplicaSegments(t *testing.T) {
qn, err := genSimpleQueryNode(context.Background())
require.NoError(t, err)
client := v3client.New(embedetcdServer.Server)
defer client.Close()
session := sessionutil.NewSession(context.Background(), "/by-dev/sessions/unittest/querynode/", client)
clusterService := newShardClusterService(client, session, qn)
t.Run("sync non-exist shard cluster", func(t *testing.T) {
err := clusterService.SyncReplicaSegments(defaultDMLChannel, nil)
assert.Error(t, err)
})
t.Run("sync shard cluster", func(t *testing.T) {
clusterService.addShardCluster(defaultCollectionID, defaultReplicaID, defaultDMLChannel)
err := clusterService.SyncReplicaSegments(defaultDMLChannel, []*querypb.ReplicaSegmentsInfo{
{
NodeId: 1,
PartitionId: defaultPartitionID,
SegmentIds: []int64{1},
},
})
assert.NoError(t, err)
cs, ok := clusterService.getShardCluster(defaultDMLChannel)
require.True(t, ok)
segment, ok := cs.getSegment(1)
assert.True(t, ok)
assert.Equal(t, int64(1), segment.nodeID)
assert.Equal(t, defaultPartitionID, segment.partitionID)
assert.Equal(t, segmentStateLoaded, segment.state)
})
}

102
internal/querynode/shard_cluster_test.go
View File

@ -626,6 +626,108 @@ func TestShardCluster_segmentEvent(t *testing.T) {
})
}
func TestShardCluster_SyncSegments(t *testing.T) {
collectionID := int64(1)
vchannelName := "dml_1_1_v0"
replicaID := int64(0)
t.Run("sync new segments", func(t *testing.T) {
segmentEvents := []segmentEvent{}
evtCh := make(chan segmentEvent, 10)
sc := NewShardCluster(collectionID, replicaID, vchannelName,
&mockNodeDetector{}, &mockSegmentDetector{
initSegments: segmentEvents,
evtCh: evtCh,
}, buildMockQueryNode)
defer sc.Close()
sc.SyncSegments([]*querypb.ReplicaSegmentsInfo{
{
NodeId: 1,
SegmentIds: []int64{1},
},
{
NodeId: 2,
SegmentIds: []int64{2},
},
{
NodeId: 3,
SegmentIds: []int64{3},
},
}, segmentStateLoaded)
assert.Eventually(t, func() bool {
seg, has := sc.getSegment(1)
return has && seg.nodeID == 1 && seg.state == segmentStateLoaded
}, time.Second, time.Millisecond)
assert.Eventually(t, func() bool {
seg, has := sc.getSegment(2)
return has && seg.nodeID == 2 && seg.state == segmentStateLoaded
}, time.Second, time.Millisecond)
assert.Eventually(t, func() bool {
seg, has := sc.getSegment(3)
return has && seg.nodeID == 3 && seg.state == segmentStateLoaded
}, time.Second, time.Millisecond)
})
t.Run("sync existing segments", func(t *testing.T) {
segmentEvents := []segmentEvent{
{
segmentID: 1,
nodeID: 1,
state: segmentStateOffline,
},
{
segmentID: 2,
nodeID: 2,
state: segmentStateOffline,
},
{
segmentID: 3,
nodeID: 3,
state: segmentStateOffline,
},
}
evtCh := make(chan segmentEvent, 10)
sc := NewShardCluster(collectionID, replicaID, vchannelName,
&mockNodeDetector{}, &mockSegmentDetector{
initSegments: segmentEvents,
evtCh: evtCh,
}, buildMockQueryNode)
defer sc.Close()
sc.SyncSegments([]*querypb.ReplicaSegmentsInfo{
{
NodeId: 1,
SegmentIds: []int64{1},
},
{
NodeId: 2,
SegmentIds: []int64{2},
},
{
NodeId: 3,
SegmentIds: []int64{3},
},
}, segmentStateLoaded)
assert.Eventually(t, func() bool {
seg, has := sc.getSegment(1)
return has && seg.nodeID == 1 && seg.state == segmentStateLoaded
}, time.Second, time.Millisecond)
assert.Eventually(t, func() bool {
seg, has := sc.getSegment(2)
return has && seg.nodeID == 2 && seg.state == segmentStateLoaded
}, time.Second, time.Millisecond)
assert.Eventually(t, func() bool {
seg, has := sc.getSegment(3)
return has && seg.nodeID == 3 && seg.state == segmentStateLoaded
}, time.Second, time.Millisecond)
})
}
func TestShardCluster_Search(t *testing.T) {
collectionID := int64(1)
vchannelName := "dml_1_1_v0"

1
internal/types/types.go
View File

@ -1193,6 +1193,7 @@ type QueryNode interface {
Search(ctx context.Context, req *querypb.SearchRequest) (*internalpb.SearchResults, error)
Query(ctx context.Context, req *querypb.QueryRequest) (*internalpb.RetrieveResults, error)
SyncReplicaSegments(ctx context.Context, req *querypb.SyncReplicaSegmentsRequest) (*commonpb.Status, error)
// GetMetrics gets the metrics about QueryNode.
GetMetrics(ctx context.Context, req *milvuspb.GetMetricsRequest) (*milvuspb.GetMetricsResponse, error)

4
internal/util/mock/querynode_client.go
View File

@ -86,6 +86,10 @@ func (m *QueryNodeClient) Query(ctx context.Context, in *querypb.QueryRequest, o
return &internalpb.RetrieveResults{}, m.Err
}
func (m *QueryNodeClient) SyncReplicaSegments(ctx context.Context, in *querypb.SyncReplicaSegmentsRequest, opts ...grpc.CallOption) (*commonpb.Status, error) {
return &commonpb.Status{}, m.Err
}
func (m *QueryNodeClient) GetMetrics(ctx context.Context, in *milvuspb.GetMetricsRequest, opts ...grpc.CallOption) (*milvuspb.GetMetricsResponse, error) {
return &milvuspb.GetMetricsResponse{}, m.Err
}