test/milvus
1
0
Fork 0
mirror of https://gitee.com/milvus-io/milvus.git synced 2024-11-30 02:48:45 +08:00
Code Issues Actions 11 Packages Projects Releases Wiki Activity

Explictly specify Load operation meta (#16027)

Browse Source 
Fix #15996

Signed-off-by: Congqi Xia <congqi.xia@zilliz.com>
This commit is contained in:
congqixia 2022-03-14 09:50:01 +08:00 committed by GitHub
parent b38591e527
commit 6a66faa2fb
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
10 changed files with 350 additions and 216 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
internal/proto/query_coord.proto
View File

@ -161,6 +161,12 @@ message RemoveQueryChannelRequest {
string query_result_channel = 5;
}
message LoadMetaInfo {
LoadType load_type = 1;
int64 collectionID = 2;
repeated int64 partitionIDs = 3;
}
message WatchDmChannelsRequest {
common.MsgBase base = 1;
int64 nodeID = 2;
@ -169,6 +175,7 @@ message WatchDmChannelsRequest {
repeated data.VchannelInfo infos = 5;
schema.CollectionSchema schema = 6;
repeated data.SegmentInfo exclude_infos = 7;
LoadMetaInfo load_meta = 8;
}
message WatchDeltaChannelsRequest {
@ -176,6 +183,7 @@ message WatchDeltaChannelsRequest {
int64 nodeID = 2;
int64 collectionID = 3;
repeated data.VchannelInfo infos = 4;
LoadMetaInfo load_meta = 9;
}
message SegmentLoadInfo {
@ -211,6 +219,7 @@ message LoadSegmentsRequest {
schema.CollectionSchema schema = 4;
int64 source_nodeID = 5;
int64 collectionID = 6;
LoadMetaInfo load_meta = 7;
}
message ReleaseSegmentsRequest {
@ -257,9 +266,9 @@ enum TriggerCondition {
}
enum LoadType {
UnKnowType = 0;
UnKnownType = 0;
LoadPartition = 1;
loadCollection = 2;
LoadCollection = 2;
}
message DmChannelWatchInfo {

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

@ -107,21 +107,21 @@ func (TriggerCondition) EnumDescriptor() ([]byte, []int) {
type LoadType int32
const (
LoadType_UnKnowType LoadType = 0
LoadType_UnKnownType LoadType = 0
LoadType_LoadPartition LoadType = 1
LoadType_loadCollection LoadType = 2
LoadType_LoadCollection LoadType = 2
)
var LoadType_name = map[int32]string{
0: "UnKnowType",
0: "UnKnownType",
1: "LoadPartition",
2: "loadCollection",
2: "LoadCollection",
}
var LoadType_value = map[string]int32{
"UnKnowType": 0,
"UnKnownType": 0,
"LoadPartition": 1,
"loadCollection": 2,
"LoadCollection": 2,
}
func (x LoadType) String() string {
@ -1103,6 +1103,61 @@ func (m *RemoveQueryChannelRequest) GetQueryResultChannel() string {
return ""
}
type LoadMetaInfo struct {
LoadType LoadType `protobuf:"varint,1,opt,name=load_type,json=loadType,proto3,enum=milvus.proto.query.LoadType" json:"load_type,omitempty"`
CollectionID int64 `protobuf:"varint,2,opt,name=collectionID,proto3" json:"collectionID,omitempty"`
PartitionIDs []int64 `protobuf:"varint,3,rep,packed,name=partitionIDs,proto3" json:"partitionIDs,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *LoadMetaInfo) Reset() { *m = LoadMetaInfo{} }
func (m *LoadMetaInfo) String() string { return proto.CompactTextString(m) }
func (*LoadMetaInfo) ProtoMessage() {}
func (*LoadMetaInfo) Descriptor() ([]byte, []int) {
return fileDescriptor_aab7cc9a69ed26e8, []int{16}
}
func (m *LoadMetaInfo) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_LoadMetaInfo.Unmarshal(m, b)
}
func (m *LoadMetaInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_LoadMetaInfo.Marshal(b, m, deterministic)
}
func (m *LoadMetaInfo) XXX_Merge(src proto.Message) {
xxx_messageInfo_LoadMetaInfo.Merge(m, src)
}
func (m *LoadMetaInfo) XXX_Size() int {
return xxx_messageInfo_LoadMetaInfo.Size(m)
}
func (m *LoadMetaInfo) XXX_DiscardUnknown() {
xxx_messageInfo_LoadMetaInfo.DiscardUnknown(m)
}
var xxx_messageInfo_LoadMetaInfo proto.InternalMessageInfo
func (m *LoadMetaInfo) GetLoadType() LoadType {
if m != nil {
return m.LoadType
}
return LoadType_UnKnownType
}
func (m *LoadMetaInfo) GetCollectionID() int64 {
if m != nil {
return m.CollectionID
}
return 0
}
func (m *LoadMetaInfo) GetPartitionIDs() []int64 {
if m != nil {
return m.PartitionIDs
}
return nil
}
type WatchDmChannelsRequest 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"`
@ -1111,6 +1166,7 @@ type WatchDmChannelsRequest struct {
Infos []*datapb.VchannelInfo `protobuf:"bytes,5,rep,name=infos,proto3" json:"infos,omitempty"`
Schema *schemapb.CollectionSchema `protobuf:"bytes,6,opt,name=schema,proto3" json:"schema,omitempty"`
ExcludeInfos []*datapb.SegmentInfo `protobuf:"bytes,7,rep,name=exclude_infos,json=excludeInfos,proto3" json:"exclude_infos,omitempty"`
LoadMeta *LoadMetaInfo `protobuf:"bytes,8,opt,name=load_meta,json=loadMeta,proto3" json:"load_meta,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
@ -1120,7 +1176,7 @@ func (m *WatchDmChannelsRequest) Reset() { *m = WatchDmChannelsRequest{}
func (m *WatchDmChannelsRequest) String() string { return proto.CompactTextString(m) }
func (*WatchDmChannelsRequest) ProtoMessage() {}
func (*WatchDmChannelsRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_aab7cc9a69ed26e8, []int{16}
return fileDescriptor_aab7cc9a69ed26e8, []int{17}
}
func (m *WatchDmChannelsRequest) XXX_Unmarshal(b []byte) error {
@ -1190,11 +1246,19 @@ func (m *WatchDmChannelsRequest) GetExcludeInfos() []*datapb.SegmentInfo {
return nil
}
func (m *WatchDmChannelsRequest) GetLoadMeta() *LoadMetaInfo {
if m != nil {
return m.LoadMeta
}
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"`
LoadMeta *LoadMetaInfo `protobuf:"bytes,9,opt,name=load_meta,json=loadMeta,proto3" json:"load_meta,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
@ -1204,7 +1268,7 @@ func (m *WatchDeltaChannelsRequest) Reset() { *m = WatchDeltaChannelsReq
func (m *WatchDeltaChannelsRequest) String() string { return proto.CompactTextString(m) }
func (*WatchDeltaChannelsRequest) ProtoMessage() {}
func (*WatchDeltaChannelsRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_aab7cc9a69ed26e8, []int{17}
return fileDescriptor_aab7cc9a69ed26e8, []int{18}
}
func (m *WatchDeltaChannelsRequest) XXX_Unmarshal(b []byte) error {
@ -1253,6 +1317,13 @@ func (m *WatchDeltaChannelsRequest) GetInfos() []*datapb.VchannelInfo {
return nil
}
func (m *WatchDeltaChannelsRequest) GetLoadMeta() *LoadMetaInfo {
if m != nil {
return m.LoadMeta
}
return nil
}
type SegmentLoadInfo struct {
SegmentID int64 `protobuf:"varint,1,opt,name=segmentID,proto3" json:"segmentID,omitempty"`
PartitionID int64 `protobuf:"varint,2,opt,name=partitionID,proto3" json:"partitionID,omitempty"`
@ -1275,7 +1346,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{18}
return fileDescriptor_aab7cc9a69ed26e8, []int{19}
}
func (m *SegmentLoadInfo) XXX_Unmarshal(b []byte) error {
@ -1398,7 +1469,7 @@ func (m *VecFieldIndexInfo) Reset() { *m = VecFieldIndexInfo{} }
func (m *VecFieldIndexInfo) String() string { return proto.CompactTextString(m) }
func (*VecFieldIndexInfo) ProtoMessage() {}
func (*VecFieldIndexInfo) Descriptor() ([]byte, []int) {
return fileDescriptor_aab7cc9a69ed26e8, []int{19}
return fileDescriptor_aab7cc9a69ed26e8, []int{20}
}
func (m *VecFieldIndexInfo) XXX_Unmarshal(b []byte) error {
@ -1482,6 +1553,7 @@ type LoadSegmentsRequest struct {
Schema *schemapb.CollectionSchema `protobuf:"bytes,4,opt,name=schema,proto3" json:"schema,omitempty"`
SourceNodeID int64 `protobuf:"varint,5,opt,name=source_nodeID,json=sourceNodeID,proto3" json:"source_nodeID,omitempty"`
CollectionID int64 `protobuf:"varint,6,opt,name=collectionID,proto3" json:"collectionID,omitempty"`
LoadMeta *LoadMetaInfo `protobuf:"bytes,7,opt,name=load_meta,json=loadMeta,proto3" json:"load_meta,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
@ -1491,7 +1563,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 {
@ -1554,6 +1626,13 @@ func (m *LoadSegmentsRequest) GetCollectionID() int64 {
return 0
}
func (m *LoadSegmentsRequest) GetLoadMeta() *LoadMetaInfo {
if m != nil {
return m.LoadMeta
}
return nil
}
type ReleaseSegmentsRequest 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"`
@ -1571,7 +1650,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 {
@ -1647,7 +1726,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{22}
return fileDescriptor_aab7cc9a69ed26e8, []int{23}
}
func (m *HandoffSegmentsRequest) XXX_Unmarshal(b []byte) error {
@ -1697,7 +1776,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{23}
return fileDescriptor_aab7cc9a69ed26e8, []int{24}
}
func (m *LoadBalanceRequest) XXX_Unmarshal(b []byte) error {
@ -1766,7 +1845,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{24}
return fileDescriptor_aab7cc9a69ed26e8, []int{25}
}
func (m *DmChannelWatchInfo) XXX_Unmarshal(b []byte) error {
@ -1823,7 +1902,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{25}
return fileDescriptor_aab7cc9a69ed26e8, []int{26}
}
func (m *QueryChannelInfo) XXX_Unmarshal(b []byte) error {
@ -1892,7 +1971,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{26}
return fileDescriptor_aab7cc9a69ed26e8, []int{27}
}
func (m *PartitionStates) XXX_Unmarshal(b []byte) error {
@ -1957,7 +2036,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{27}
return fileDescriptor_aab7cc9a69ed26e8, []int{28}
}
func (m *SegmentInfo) XXX_Unmarshal(b []byte) error {
@ -2086,7 +2165,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{28}
return fileDescriptor_aab7cc9a69ed26e8, []int{29}
}
func (m *CollectionInfo) XXX_Unmarshal(b []byte) error {
@ -2132,7 +2211,7 @@ func (m *CollectionInfo) GetLoadType() LoadType {
if m != nil {
return m.LoadType
}
return LoadType_UnKnowType
return LoadType_UnKnownType
}
func (m *CollectionInfo) GetSchema() *schemapb.CollectionSchema {
@ -2168,7 +2247,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{29}
return fileDescriptor_aab7cc9a69ed26e8, []int{30}
}
func (m *UnsubscribeChannels) XXX_Unmarshal(b []byte) error {
@ -2215,7 +2294,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{30}
return fileDescriptor_aab7cc9a69ed26e8, []int{31}
}
func (m *UnsubscribeChannelInfo) XXX_Unmarshal(b []byte) error {
@ -2265,7 +2344,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{31}
return fileDescriptor_aab7cc9a69ed26e8, []int{32}
}
func (m *SegmentChangeInfo) XXX_Unmarshal(b []byte) error {
@ -2326,7 +2405,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{32}
return fileDescriptor_aab7cc9a69ed26e8, []int{33}
}
func (m *SealedSegmentsChangeInfo) XXX_Unmarshal(b []byte) error {
@ -2381,6 +2460,7 @@ func init() {
proto.RegisterType((*GetSegmentInfoResponse)(nil), "milvus.proto.query.GetSegmentInfoResponse")
proto.RegisterType((*AddQueryChannelRequest)(nil), "milvus.proto.query.AddQueryChannelRequest")
proto.RegisterType((*RemoveQueryChannelRequest)(nil), "milvus.proto.query.RemoveQueryChannelRequest")
proto.RegisterType((*LoadMetaInfo)(nil), "milvus.proto.query.LoadMetaInfo")
proto.RegisterType((*WatchDmChannelsRequest)(nil), "milvus.proto.query.WatchDmChannelsRequest")
proto.RegisterType((*WatchDeltaChannelsRequest)(nil), "milvus.proto.query.WatchDeltaChannelsRequest")
proto.RegisterType((*SegmentLoadInfo)(nil), "milvus.proto.query.SegmentLoadInfo")
@ -2403,154 +2483,158 @@ func init() {
func init() { proto.RegisterFile("query_coord.proto", fileDescriptor_aab7cc9a69ed26e8) }
var fileDescriptor_aab7cc9a69ed26e8 = []byte{
// 2345 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x39, 0xcd, 0x6f, 0x1c, 0x49,
0xf5, 0xee, 0x99, 0xf1, 0xd8, 0xf3, 0x66, 0x3c, 0x1e, 0x97, 0x13, 0xff, 0x26, 0xf3, 0xcb, 0x66,
0xb3, 0xbd, 0x9b, 0x0f, 0xb2, 0xac, 0x13, 0x1c, 0x90, 0x58, 0x01, 0x87, 0xc4, 0x26, 0x5e, 0x93,
0x8d, 0xd7, 0xb4, 0x9d, 0x00, 0x51, 0xa4, 0xa6, 0x67, 0xba, 0x66, 0xdc, 0x4a, 0x77, 0xd7, 0xa4,
0xab, 0x67, 0x13, 0x87, 0x0b, 0x07, 0x0e, 0x0b, 0x12, 0xe2, 0x8e, 0x10, 0x27, 0x10, 0xe4, 0xb0,
0x17, 0xfe, 0x82, 0x5c, 0xf8, 0x37, 0x10, 0x07, 0xf8, 0x13, 0x38, 0x22, 0xa1, 0xfa, 0xe8, 0x9e,
0xfe, 0xa8, 0xb6, 0xdb, 0xb6, 0xbc, 0x89, 0x10, 0xb7, 0xae, 0xd7, 0xaf, 0xde, 0x7b, 0xf5, 0xbe,
0xab, 0x1e, 0x2c, 0x3d, 0x9b, 0xe0, 0xe0, 0xc0, 0x1c, 0x10, 0x12, 0xd8, 0xab, 0xe3, 0x80, 0x84,
0x04, 0x21, 0xcf, 0x71, 0x3f, 0x9f, 0x50, 0xb1, 0x5a, 0xe5, 0xff, 0x7b, 0xad, 0x01, 0xf1, 0x3c,
0xe2, 0x0b, 0x58, 0xaf, 0x95, 0xc4, 0xe8, 0xb5, 0x1d, 0x3f, 0xc4, 0x81, 0x6f, 0xb9, 0xd1, 0x5f,
0x3a, 0xd8, 0xc7, 0x9e, 0x25, 0x57, 0x1d, 0xdb, 0x0a, 0xad, 0x24, 0x7d, 0xfd, 0x17, 0x1a, 0xac,
0xec, 0xee, 0x93, 0xe7, 0xeb, 0xc4, 0x75, 0xf1, 0x20, 0x74, 0x88, 0x4f, 0x0d, 0xfc, 0x6c, 0x82,
0x69, 0x88, 0x6e, 0x41, 0xad, 0x6f, 0x51, 0xdc, 0xd5, 0x2e, 0x6b, 0xd7, 0x9b, 0x6b, 0x17, 0x57,
0x53, 0x92, 0x48, 0x11, 0x1e, 0xd0, 0xd1, 0x5d, 0x8b, 0x62, 0x83, 0x63, 0x22, 0x04, 0x35, 0xbb,
0xbf, 0xb5, 0xd1, 0xad, 0x5c, 0xd6, 0xae, 0x57, 0x0d, 0xfe, 0x8d, 0x3e, 0x80, 0x85, 0x41, 0x4c,
0x7b, 0x6b, 0x83, 0x76, 0xab, 0x97, 0xab, 0xd7, 0xab, 0x46, 0x1a, 0xa8, 0xff, 0x49, 0x83, 0xff,
0xcb, 0x89, 0x41, 0xc7, 0xc4, 0xa7, 0x18, 0xdd, 0x86, 0x3a, 0x0d, 0xad, 0x70, 0x42, 0xa5, 0x24,
0xff, 0xaf, 0x94, 0x64, 0x97, 0xa3, 0x18, 0x12, 0x35, 0xcf, 0xb6, 0xa2, 0x60, 0x8b, 0xbe, 0x01,
0xe7, 0x1c, 0xff, 0x01, 0xf6, 0x48, 0x70, 0x60, 0x8e, 0x71, 0x30, 0xc0, 0x7e, 0x68, 0x8d, 0x70,
0x24, 0xe3, 0x72, 0xf4, 0x6f, 0x67, 0xfa, 0x4b, 0xff, 0xa3, 0x06, 0xe7, 0x99, 0xa4, 0x3b, 0x56,
0x10, 0x3a, 0x67, 0xa0, 0x2f, 0x1d, 0x5a, 0x49, 0x19, 0xbb, 0x55, 0xfe, 0x2f, 0x05, 0x63, 0x38,
0xe3, 0x88, 0x3d, 0x3b, 0x5b, 0x8d, 0x8b, 0x9b, 0x82, 0xe9, 0x7f, 0x90, 0x86, 0x4d, 0xca, 0x79,
0x1a, 0x85, 0x66, 0x79, 0x56, 0xf2, 0x3c, 0x4f, 0xa2, 0xce, 0xd7, 0x1a, 0x9c, 0xff, 0x94, 0x58,
0xf6, 0xd4, 0xf0, 0x5f, 0xbd, 0x3a, 0xbf, 0x07, 0x75, 0x11, 0x25, 0xdd, 0x1a, 0xe7, 0x75, 0x25,
0xcd, 0x4b, 0x46, 0xd0, 0x54, 0xc2, 0x5d, 0x0e, 0x30, 0xe4, 0x26, 0xfd, 0x77, 0x1a, 0x74, 0x0d,
0xec, 0x62, 0x8b, 0xe2, 0x37, 0x79, 0x8a, 0x15, 0xa8, 0xfb, 0xc4, 0xc6, 0x5b, 0x1b, 0xfc, 0x14,
0x55, 0x43, 0xae, 0xf4, 0x7f, 0x48, 0x0d, 0xbf, 0xe5, 0x0e, 0x9b, 0xb0, 0xc2, 0xec, 0x49, 0xac,
0xf0, 0x7a, 0x6a, 0x85, 0xb7, 0xfd, 0xa4, 0x53, 0x4b, 0xcd, 0xa6, 0x2c, 0xf5, 0x13, 0xb8, 0xb0,
0x1e, 0x60, 0x2b, 0xc4, 0x3f, 0x64, 0x69, 0x7e, 0x7d, 0xdf, 0xf2, 0x7d, 0xec, 0x46, 0x47, 0xc8,
0x32, 0xd7, 0x14, 0xcc, 0xbb, 0x30, 0x37, 0x0e, 0xc8, 0x8b, 0x83, 0x58, 0xee, 0x68, 0xa9, 0xff,
0x59, 0x83, 0x9e, 0x8a, 0xf6, 0x69, 0x32, 0xc2, 0xfb, 0xb0, 0x20, 0xeb, 0x95, 0xa0, 0xc6, 0x79,
0x36, 0x8c, 0xd6, 0xb3, 0x04, 0x07, 0x74, 0x0b, 0xce, 0x09, 0xa4, 0x00, 0xd3, 0x89, 0x1b, 0xc6,
0xb8, 0x55, 0x8e, 0x8b, 0xf8, 0x3f, 0x83, 0xff, 0x92, 0x3b, 0xf4, 0x57, 0x1a, 0x5c, 0xd8, 0xc4,
0x61, 0x6c, 0x44, 0xc6, 0x15, 0xbf, 0xa5, 0x49, 0xf6, 0x4b, 0x0d, 0x7a, 0x2a, 0x59, 0x4f, 0xa3,
0xd6, 0xc7, 0xb0, 0x12, 0xf3, 0x30, 0x6d, 0x4c, 0x07, 0x81, 0x33, 0xe6, 0xce, 0xcc, 0x53, 0x6e,
0x73, 0xed, 0xfd, 0xd5, 0x7c, 0x4b, 0xb0, 0x9a, 0x95, 0xe0, 0x7c, 0x4c, 0x62, 0x23, 0x41, 0x41,
0xff, 0xb5, 0x06, 0xe7, 0x37, 0x71, 0xb8, 0x8b, 0x47, 0x1e, 0xf6, 0xc3, 0x2d, 0x7f, 0x48, 0x4e,
0xae, 0xd7, 0x4b, 0x00, 0x54, 0xd2, 0x89, 0xcb, 0x41, 0x02, 0x52, 0x46, 0xc7, 0xbc, 0xfb, 0xc8,
0xca, 0x73, 0x1a, 0xdd, 0x7d, 0x0b, 0x66, 0x1d, 0x7f, 0x48, 0x22, 0x55, 0xbd, 0xab, 0x52, 0x55,
0x92, 0x99, 0xc0, 0xd6, 0xff, 0x5d, 0x81, 0x95, 0x3b, 0xb6, 0xad, 0x0a, 0xbb, 0xe3, 0xeb, 0x65,
0x1a, 0xdd, 0x95, 0x64, 0x74, 0x97, 0xf2, 0xb9, 0x5c, 0x48, 0xd5, 0x8e, 0x11, 0x52, 0xb3, 0x45,
0x21, 0x85, 0x36, 0x61, 0x81, 0x62, 0xfc, 0xd4, 0x1c, 0x13, 0xca, 0x7d, 0xa2, 0x5b, 0xe7, 0xa7,
0xd1, 0xd3, 0xa7, 0x89, 0x3b, 0xc7, 0x07, 0x74, 0xb4, 0x23, 0x31, 0x8d, 0x16, 0xdb, 0x18, 0xad,
0xd0, 0x43, 0x58, 0x19, 0xb9, 0xa4, 0x6f, 0xb9, 0x26, 0xc5, 0x96, 0x8b, 0x6d, 0x53, 0xda, 0x9b,
0x76, 0xe7, 0xca, 0x29, 0xfc, 0x9c, 0xd8, 0xbe, 0xcb, 0x77, 0xcb, 0x1f, 0x54, 0xff, 0xbb, 0x06,
0x17, 0x0c, 0xec, 0x91, 0xcf, 0xf1, 0x7f, 0xab, 0x09, 0xf4, 0x7f, 0x56, 0x60, 0xe5, 0x47, 0x56,
0x38, 0xd8, 0xdf, 0xf0, 0x24, 0x88, 0xbe, 0x99, 0xf3, 0x95, 0x29, 0x50, 0x71, 0x18, 0xcd, 0xaa,
0xac, 0xca, 0xee, 0x10, 0xab, 0x8f, 0xe4, 0x91, 0x13, 0x61, 0x94, 0xa8, 0xe0, 0xf5, 0x13, 0x54,
0x70, 0xb4, 0x0e, 0x0b, 0xf8, 0xc5, 0xc0, 0x9d, 0xd8, 0xd8, 0x14, 0xdc, 0x85, 0x4f, 0x5d, 0x52,
0x70, 0x4f, 0xba, 0x54, 0x4b, 0x6e, 0xda, 0xe2, 0xa1, 0xfc, 0x5a, 0x83, 0x0b, 0x42, 0xcf, 0xd8,
0x0d, 0xad, 0x37, 0xab, 0xea, 0x58, 0x8d, 0xb5, 0xe3, 0xa8, 0x51, 0xff, 0x6d, 0x0d, 0x16, 0xe5,
0x01, 0x59, 0xdf, 0xc6, 0x7e, 0xa1, 0x8b, 0xd0, 0x88, 0x53, 0xab, 0x2c, 0xfd, 0x53, 0x00, 0xba,
0x0c, 0xcd, 0x84, 0xfd, 0xa4, 0xa4, 0x49, 0x50, 0x29, 0x71, 0xa3, 0x42, 0x59, 0x4b, 0x14, 0xca,
0x77, 0x00, 0x86, 0xee, 0x84, 0xee, 0x9b, 0xa1, 0xe3, 0x61, 0xd9, 0xae, 0x34, 0x38, 0x64, 0xcf,
0xf1, 0x30, 0xba, 0x03, 0xad, 0xbe, 0xe3, 0xbb, 0x64, 0x64, 0x8e, 0xad, 0x70, 0x9f, 0x76, 0xeb,
0x85, 0x16, 0xbb, 0xe7, 0x60, 0xd7, 0xbe, 0xcb, 0x71, 0x8d, 0xa6, 0xd8, 0xb3, 0xc3, 0xb6, 0xa0,
0x4b, 0xd0, 0xf4, 0x27, 0x9e, 0x49, 0x86, 0x66, 0x40, 0x9e, 0x33, 0x9b, 0x73, 0x16, 0xfe, 0xc4,
0xfb, 0x6c, 0x68, 0x90, 0xe7, 0x14, 0x7d, 0x17, 0x1a, 0x2c, 0xb9, 0x53, 0x97, 0x8c, 0x68, 0x77,
0xbe, 0x14, 0xfd, 0xe9, 0x06, 0xb6, 0xdb, 0x66, 0x8e, 0xc0, 0x77, 0x37, 0xca, 0xed, 0x8e, 0x37,
0xa0, 0xab, 0xd0, 0x1e, 0x10, 0x6f, 0x6c, 0x71, 0x0d, 0xdd, 0x0b, 0x88, 0xd7, 0x05, 0x1e, 0x2d,
0x19, 0x28, 0xba, 0x07, 0x4d, 0xc7, 0xb7, 0xf1, 0x0b, 0xe9, 0xb7, 0x4d, 0xce, 0xe7, 0x8a, 0x2a,
0x17, 0x3e, 0xc2, 0x03, 0xce, 0x6b, 0x8b, 0xa1, 0x73, 0xa3, 0x83, 0x13, 0x7d, 0x52, 0xf4, 0x1e,
0xb4, 0xa4, 0x51, 0x4d, 0xea, 0xbc, 0xc4, 0xdd, 0x96, 0x30, 0xa4, 0x84, 0xed, 0x3a, 0x2f, 0xb1,
0xfe, 0x97, 0x0a, 0x2c, 0xe5, 0x88, 0xb0, 0xc6, 0x6f, 0xc8, 0x21, 0x91, 0x73, 0x44, 0x4b, 0x46,
0x12, 0xfb, 0x56, 0xdf, 0x65, 0x31, 0x65, 0xe3, 0x17, 0xdc, 0x37, 0xe6, 0x8d, 0xa6, 0x80, 0x71,
0x02, 0xcc, 0xc6, 0x42, 0x7a, 0xdf, 0xf2, 0xb0, 0x6c, 0xcc, 0x1a, 0x1c, 0xb2, 0x6d, 0x79, 0x98,
0xd1, 0x16, 0x22, 0x46, 0x9e, 0x11, 0x2d, 0xd9, 0x9f, 0xfe, 0xc4, 0xe1, 0x5c, 0x85, 0x67, 0x44,
0x4b, 0xb4, 0x01, 0x2d, 0x41, 0x72, 0x6c, 0x05, 0x96, 0x17, 0xf9, 0xc5, 0x7b, 0xca, 0x78, 0xbb,
0x8f, 0x0f, 0x1e, 0x59, 0xee, 0x04, 0xef, 0x58, 0x4e, 0x60, 0x08, 0x3d, 0xee, 0xf0, 0x5d, 0xe8,
0x3a, 0x74, 0x04, 0x95, 0xa1, 0xe3, 0x62, 0xe9, 0x61, 0x2c, 0x27, 0x34, 0x8c, 0x36, 0x87, 0xdf,
0x73, 0x5c, 0x2c, 0x9c, 0x28, 0x3e, 0x02, 0x57, 0xdb, 0xbc, 0xf0, 0x21, 0x0e, 0xe1, 0x4a, 0x7b,
0x55, 0x81, 0x65, 0x16, 0x4a, 0x51, 0xc1, 0x39, 0x79, 0x3a, 0x78, 0x07, 0xc0, 0xa6, 0xa1, 0x99,
0x4a, 0x09, 0x0d, 0x9b, 0x86, 0xdb, 0x22, 0x2b, 0x7c, 0x1c, 0x45, 0x7c, 0xb5, 0xb8, 0x55, 0xcb,
0x84, 0x76, 0x3e, 0x79, 0x9e, 0xe4, 0x12, 0xca, 0xca, 0x16, 0x25, 0x93, 0x60, 0x80, 0xcd, 0xd4,
0xd5, 0xa2, 0x25, 0x80, 0xdb, 0xea, 0xa4, 0x55, 0x57, 0xb4, 0x64, 0x7f, 0xd3, 0x60, 0x45, 0xde,
0xa3, 0x4e, 0xaf, 0xae, 0xa2, 0xec, 0x19, 0xa5, 0x9a, 0xea, 0x21, 0x3d, 0x79, 0xad, 0x44, 0xf1,
0x9a, 0x55, 0x14, 0xaf, 0x74, 0x5f, 0x5a, 0xcf, 0xf6, 0xa5, 0xfa, 0x6f, 0x34, 0x58, 0xf9, 0xc4,
0xf2, 0x6d, 0x32, 0x1c, 0x9e, 0xfe, 0x80, 0xeb, 0x71, 0xc4, 0x6e, 0x1d, 0xa7, 0xef, 0x4c, 0x6d,
0xd2, 0xbf, 0xa8, 0x00, 0x62, 0xee, 0x70, 0xd7, 0x72, 0x2d, 0x7f, 0x80, 0x4f, 0x2e, 0xcd, 0x15,
0x68, 0xa7, 0x9c, 0x20, 0x7e, 0xf5, 0x4a, 0x7a, 0x01, 0x45, 0xf7, 0xa1, 0xdd, 0x17, 0xac, 0xcc,
0x00, 0x5b, 0x94, 0xf8, 0xdc, 0x0e, 0xed, 0xb5, 0x0f, 0x54, 0x62, 0xef, 0x05, 0xce, 0x68, 0x84,
0x83, 0x75, 0xe2, 0xdb, 0xa2, 0x23, 0x5c, 0xe8, 0x47, 0x62, 0xb2, 0xad, 0xe8, 0x5d, 0x68, 0x4e,
0x23, 0x22, 0x6a, 0x27, 0x20, 0x0e, 0x09, 0x8a, 0x3e, 0x84, 0xa5, 0x74, 0xb3, 0x38, 0x35, 0x5c,
0x87, 0x26, 0xfb, 0x40, 0x66, 0x9c, 0x9f, 0x01, 0x8a, 0x1b, 0x24, 0x5e, 0xc6, 0x79, 0x7a, 0x2b,
0x73, 0xf7, 0xbd, 0x08, 0x0d, 0x3b, 0xda, 0x29, 0x6f, 0xa2, 0x53, 0x00, 0x0b, 0x0f, 0x21, 0xa1,
0xe9, 0x12, 0xcb, 0xc6, 0x76, 0x54, 0x00, 0x05, 0xf0, 0x53, 0x0e, 0xd3, 0xbf, 0xac, 0x40, 0x27,
0xd9, 0x80, 0x96, 0xe6, 0x7d, 0x36, 0x37, 0xe1, 0x43, 0xba, 0xed, 0xda, 0x29, 0xba, 0xed, 0xfc,
0x6d, 0x60, 0xf6, 0x64, 0xb7, 0x01, 0xfd, 0xf7, 0x1a, 0x2c, 0x66, 0x2e, 0x9e, 0xd9, 0x56, 0x44,
0xcb, 0xb7, 0x22, 0xdf, 0x86, 0x59, 0x56, 0x9f, 0x31, 0x57, 0x52, 0x3b, 0xcb, 0x56, 0x75, 0x9d,
0x35, 0xc4, 0x06, 0x74, 0x13, 0x96, 0x15, 0xcf, 0x8b, 0xd2, 0x94, 0x28, 0xff, 0xba, 0xa8, 0xff,
0xbc, 0x06, 0xcd, 0x84, 0x3e, 0x8e, 0xe8, 0xa2, 0xb2, 0x96, 0xae, 0x28, 0x2c, 0x9d, 0x39, 0x5e,
0x35, 0x7f, 0xbc, 0x82, 0x67, 0x38, 0x74, 0x01, 0xe6, 0x3d, 0xec, 0x89, 0x02, 0x25, 0xab, 0xa5,
0x87, 0x3d, 0x56, 0x9e, 0xd8, 0x2f, 0xd6, 0x02, 0xf1, 0xfe, 0x47, 0xa4, 0xe4, 0x39, 0x7f, 0xe2,
0xf1, 0xee, 0x27, 0x5d, 0x9b, 0xe7, 0x0e, 0xa9, 0xcd, 0xf3, 0xe9, 0xda, 0x9c, 0x0a, 0x87, 0x46,
0x36, 0x1c, 0xca, 0x36, 0x36, 0xb7, 0x60, 0x79, 0xc0, 0x5f, 0x8d, 0xec, 0xbb, 0x07, 0xeb, 0xf1,
0xaf, 0x6e, 0x93, 0x37, 0x11, 0xaa, 0x5f, 0xe8, 0x1e, 0x73, 0x2e, 0xd9, 0xc2, 0x70, 0x2b, 0xb7,
0xb8, 0x95, 0xd5, 0xa5, 0x5f, 0xda, 0x46, 0x18, 0x39, 0xca, 0x89, 0x7c, 0x95, 0x6d, 0xa9, 0x16,
0x4e, 0xd8, 0x52, 0xe9, 0x5f, 0x54, 0xa1, 0x3d, 0x2d, 0x9a, 0xa5, 0x23, 0xba, 0xcc, 0x6b, 0xf7,
0x36, 0x74, 0xa6, 0x0f, 0x35, 0xfc, 0xb0, 0x87, 0xd6, 0xfd, 0xec, 0x13, 0xcd, 0xe2, 0x38, 0x13,
0x3a, 0x1f, 0x43, 0x83, 0x25, 0x27, 0x33, 0x3c, 0x18, 0x63, 0xee, 0x3c, 0xed, 0x6c, 0xd2, 0x17,
0x84, 0x58, 0xb6, 0xda, 0x3b, 0x18, 0x63, 0x63, 0xde, 0x95, 0x5f, 0xa7, 0x7c, 0x3b, 0x45, 0xb7,
0xe1, 0x7c, 0x20, 0x4a, 0xbe, 0x6d, 0xa6, 0x8e, 0x2d, 0xaa, 0xe7, 0xb9, 0xe8, 0xe7, 0x4e, 0xf2,
0xf8, 0x05, 0xd1, 0x38, 0x57, 0x18, 0x8d, 0x0f, 0x61, 0xf9, 0xa1, 0x4f, 0x27, 0x7d, 0x3a, 0x08,
0x9c, 0x3e, 0x8e, 0xae, 0x66, 0xa5, 0xcc, 0xd1, 0x83, 0x79, 0x99, 0x2e, 0x85, 0x29, 0x1a, 0x46,
0xbc, 0xd6, 0x7f, 0xa5, 0xc1, 0x4a, 0x9e, 0x2e, 0xb7, 0xf4, 0x34, 0x16, 0xb5, 0x54, 0x2c, 0xfe,
0x18, 0x96, 0xa7, 0xe4, 0xcd, 0x14, 0xe5, 0xe6, 0xda, 0x35, 0x95, 0xce, 0x15, 0x82, 0x1b, 0x68,
0x4a, 0x23, 0x82, 0xe9, 0xff, 0xd2, 0x60, 0x49, 0x7a, 0x35, 0x83, 0x8d, 0xf8, 0xad, 0x94, 0xd5,
0x07, 0xe2, 0xbb, 0x8e, 0x1f, 0x37, 0x67, 0xf2, 0x8c, 0x02, 0x28, 0x9b, 0xb3, 0x4f, 0x60, 0x51,
0x22, 0xc5, 0x69, 0xbe, 0x64, 0x37, 0xd1, 0x16, 0xfb, 0xe2, 0x04, 0x7f, 0x05, 0xda, 0x64, 0x38,
0x4c, 0xf2, 0x13, 0x79, 0x6a, 0x41, 0x42, 0x25, 0xc3, 0x1f, 0x40, 0x27, 0x42, 0x3b, 0x6e, 0x61,
0x59, 0x94, 0x1b, 0xe3, 0x17, 0x9c, 0x5f, 0x6a, 0xd0, 0x4d, 0x97, 0x99, 0xc4, 0xf1, 0x8f, 0xdf,
0xc8, 0x7c, 0x27, 0xfd, 0x8e, 0x77, 0xe5, 0x10, 0x79, 0xa6, 0x7c, 0x64, 0x27, 0x7d, 0xe3, 0x25,
0xb4, 0xd3, 0xb1, 0x86, 0x5a, 0x30, 0xbf, 0x4d, 0xc2, 0xef, 0xbf, 0x70, 0x68, 0xd8, 0x99, 0x41,
0x6d, 0x80, 0x6d, 0x12, 0xee, 0x04, 0x98, 0x62, 0x3f, 0xec, 0x68, 0x08, 0xa0, 0xfe, 0x99, 0xbf,
0xe1, 0xd0, 0xa7, 0x9d, 0x0a, 0x5a, 0x96, 0x15, 0xcd, 0x72, 0xb7, 0xa4, 0x03, 0x77, 0xaa, 0x6c,
0x7b, 0xbc, 0xaa, 0xa1, 0x0e, 0xb4, 0x62, 0x94, 0xcd, 0x9d, 0x87, 0x9d, 0x59, 0xd4, 0x80, 0x59,
0xf1, 0x59, 0xbf, 0x61, 0x43, 0x27, 0xdb, 0x30, 0x31, 0x9a, 0x0f, 0xfd, 0xfb, 0x3e, 0x79, 0x1e,
0x83, 0x3a, 0x33, 0xa8, 0x09, 0x73, 0xb2, 0x09, 0xed, 0x68, 0x68, 0x11, 0x9a, 0x89, 0xfe, 0xaf,
0x53, 0x61, 0x80, 0xcd, 0x60, 0x3c, 0x90, 0x9d, 0xa0, 0x10, 0x81, 0x59, 0x6d, 0x83, 0x3c, 0xf7,
0x3b, 0xb5, 0x1b, 0x77, 0x60, 0x3e, 0x4a, 0x02, 0xec, 0x34, 0x82, 0x3a, 0x5b, 0x75, 0x66, 0xd0,
0x12, 0x2c, 0xa4, 0xa6, 0x3d, 0x1d, 0x0d, 0x21, 0x68, 0xbb, 0xa9, 0x11, 0x5b, 0xa7, 0xb2, 0xf6,
0xd7, 0x26, 0x80, 0xe8, 0x75, 0x08, 0x09, 0x6c, 0x34, 0x06, 0xb4, 0x89, 0x43, 0x96, 0xc7, 0x89,
0x1f, 0xe5, 0x60, 0x8a, 0x6e, 0x15, 0xb4, 0x04, 0x79, 0x54, 0x29, 0x69, 0xef, 0x6a, 0xc1, 0x8e,
0x0c, 0xba, 0x3e, 0x83, 0x3c, 0xce, 0x71, 0xcf, 0xf1, 0xf0, 0x9e, 0x33, 0x78, 0x1a, 0x37, 0x49,
0xc5, 0x1c, 0x33, 0xa8, 0x11, 0xc7, 0x4c, 0xae, 0x95, 0x8b, 0xdd, 0x30, 0x70, 0xfc, 0x51, 0xf4,
0x98, 0xac, 0xcf, 0xa0, 0x67, 0x70, 0x6e, 0x13, 0x73, 0xee, 0x0e, 0x0d, 0x9d, 0x01, 0x8d, 0x18,
0xae, 0x15, 0x33, 0xcc, 0x21, 0x1f, 0x93, 0xa5, 0x0b, 0x8b, 0x99, 0x91, 0x36, 0xba, 0xa1, 0x74,
0x64, 0xe5, 0xf8, 0xbd, 0xf7, 0x61, 0x29, 0xdc, 0x98, 0x9b, 0x03, 0xed, 0xf4, 0xb8, 0x17, 0x7d,
0xad, 0x88, 0x40, 0x6e, 0x3e, 0xd6, 0xbb, 0x51, 0x06, 0x35, 0x66, 0xf5, 0x18, 0xda, 0xe9, 0x81,
0xa2, 0x9a, 0x95, 0x72, 0xe8, 0xd8, 0x3b, 0xec, 0x1d, 0x5f, 0x9f, 0x41, 0x3f, 0x85, 0xa5, 0xdc,
0x14, 0x0f, 0x7d, 0x5d, 0x45, 0xbe, 0x68, 0xd8, 0x77, 0x14, 0x07, 0x29, 0xfd, 0x54, 0x8b, 0xc5,
0xd2, 0xe7, 0xc6, 0xb9, 0xe5, 0xa5, 0x4f, 0x90, 0x3f, 0x4c, 0xfa, 0x63, 0x73, 0x98, 0x00, 0xca,
0xcf, 0xf1, 0xd0, 0x47, 0x2a, 0x16, 0x85, 0xb3, 0xc4, 0xde, 0x6a, 0x59, 0xf4, 0xd8, 0xe4, 0x13,
0x1e, 0xad, 0xd9, 0x66, 0x5f, 0xc9, 0xb6, 0x70, 0x76, 0xa7, 0x66, 0x5b, 0x3c, 0x3e, 0x13, 0x4e,
0x9d, 0x1e, 0x0f, 0xa9, 0x6d, 0xa5, 0x1c, 0x69, 0xa9, 0x9d, 0x5a, 0x3d, 0x6d, 0xd2, 0x67, 0xd0,
0x5e, 0x2a, 0x07, 0xa3, 0xab, 0x45, 0x3e, 0x91, 0xbe, 0xa4, 0x1f, 0x65, 0x2e, 0x13, 0x60, 0x13,
0x87, 0x0f, 0x70, 0x18, 0x38, 0x03, 0x9a, 0x25, 0x2a, 0x17, 0x53, 0x84, 0x88, 0xe8, 0xb5, 0x23,
0xf1, 0x22, 0xb1, 0xd7, 0x5e, 0x01, 0x34, 0xb8, 0xcd, 0x58, 0x79, 0xf8, 0x5f, 0x1a, 0x3f, 0x83,
0x34, 0xfe, 0x04, 0x16, 0x33, 0xb3, 0x41, 0x75, 0x1a, 0x57, 0x0f, 0x10, 0x8f, 0x72, 0x90, 0x3e,
0xa0, 0xfc, 0xe4, 0x4b, 0x1d, 0x58, 0x85, 0x13, 0xb2, 0xa3, 0x78, 0x3c, 0x81, 0xc5, 0xcc, 0xe8,
0x49, 0x7d, 0x02, 0xf5, 0x7c, 0xaa, 0xc4, 0x09, 0xf2, 0x03, 0x17, 0xf5, 0x09, 0x0a, 0x07, 0x33,
0x47, 0xf1, 0x78, 0x04, 0xad, 0xe4, 0xfb, 0x2d, 0xba, 0x56, 0x14, 0x9d, 0x99, 0x17, 0xbd, 0x37,
0x9f, 0xaf, 0xcf, 0xbe, 0x9e, 0x3d, 0x81, 0xc5, 0xcc, 0x7b, 0xad, 0xda, 0xba, 0xea, 0x47, 0xdd,
0xa3, 0xa8, 0x7f, 0x85, 0x19, 0xf8, 0xac, 0x73, 0xe5, 0xdd, 0x6f, 0x3e, 0x5e, 0x1b, 0x39, 0xe1,
0xfe, 0xa4, 0xcf, 0x4e, 0x79, 0x53, 0x60, 0x7e, 0xe4, 0x10, 0xf9, 0x75, 0x33, 0x4a, 0x1a, 0x37,
0x39, 0xa5, 0x9b, 0x5c, 0xda, 0x71, 0xbf, 0x5f, 0xe7, 0xcb, 0xdb, 0xff, 0x09, 0x00, 0x00, 0xff,
0xff, 0x0a, 0x67, 0x23, 0x4a, 0x9d, 0x29, 0x00, 0x00,
// 2401 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x3a, 0xcd, 0x73, 0x1b, 0x49,
0xf5, 0x1e, 0x49, 0x96, 0xad, 0x27, 0x59, 0x92, 0xdb, 0x89, 0x7f, 0x8a, 0x7e, 0xd9, 0x6c, 0x76,
0x76, 0xf3, 0x41, 0x96, 0x75, 0x82, 0x03, 0x55, 0x6c, 0x01, 0x87, 0xb5, 0x4d, 0xbc, 0x26, 0x1b,
0xaf, 0x19, 0x3b, 0x01, 0x52, 0xa9, 0x12, 0x23, 0x4d, 0x4b, 0x9e, 0xca, 0xcc, 0xb4, 0x32, 0x3d,
0xda, 0xc4, 0xe1, 0xc2, 0x81, 0xc3, 0x42, 0x15, 0x45, 0x71, 0xa5, 0x28, 0x4e, 0x50, 0xb0, 0x87,
0xbd, 0xf0, 0x17, 0xec, 0x85, 0x7f, 0x83, 0xe2, 0xc0, 0x81, 0x7f, 0x80, 0x23, 0x05, 0xd5, 0x1f,
0x33, 0x9a, 0x8f, 0x1e, 0x7b, 0x64, 0x97, 0x37, 0x29, 0x8a, 0x9b, 0xfa, 0xcd, 0xeb, 0xf7, 0x5e,
0xbf, 0xef, 0xee, 0x27, 0x58, 0x7e, 0x36, 0xc1, 0xfe, 0x51, 0x6f, 0x40, 0x88, 0x6f, 0xad, 0x8d,
0x7d, 0x12, 0x10, 0x84, 0x5c, 0xdb, 0xf9, 0x64, 0x42, 0xc5, 0x6a, 0x8d, 0x7f, 0xef, 0x36, 0x06,
0xc4, 0x75, 0x89, 0x27, 0x60, 0xdd, 0x46, 0x1c, 0xa3, 0xdb, 0xb4, 0xbd, 0x00, 0xfb, 0x9e, 0xe9,
0x84, 0x5f, 0xe9, 0xe0, 0x10, 0xbb, 0xa6, 0x5c, 0xb5, 0x2d, 0x33, 0x30, 0xe3, 0xf4, 0xf5, 0x9f,
0x69, 0xb0, 0xba, 0x7f, 0x48, 0x9e, 0x6f, 0x12, 0xc7, 0xc1, 0x83, 0xc0, 0x26, 0x1e, 0x35, 0xf0,
0xb3, 0x09, 0xa6, 0x01, 0xba, 0x03, 0x95, 0xbe, 0x49, 0x71, 0x47, 0xbb, 0xaa, 0xdd, 0xac, 0xaf,
0x5f, 0x5e, 0x4b, 0x48, 0x22, 0x45, 0x78, 0x40, 0x47, 0x1b, 0x26, 0xc5, 0x06, 0xc7, 0x44, 0x08,
0x2a, 0x56, 0x7f, 0x67, 0xab, 0x53, 0xba, 0xaa, 0xdd, 0x2c, 0x1b, 0xfc, 0x37, 0x7a, 0x07, 0x96,
0x06, 0x11, 0xed, 0x9d, 0x2d, 0xda, 0x29, 0x5f, 0x2d, 0xdf, 0x2c, 0x1b, 0x49, 0xa0, 0xfe, 0x47,
0x0d, 0xfe, 0x2f, 0x23, 0x06, 0x1d, 0x13, 0x8f, 0x62, 0x74, 0x17, 0xaa, 0x34, 0x30, 0x83, 0x09,
0x95, 0x92, 0xfc, 0xbf, 0x52, 0x92, 0x7d, 0x8e, 0x62, 0x48, 0xd4, 0x2c, 0xdb, 0x92, 0x82, 0x2d,
0xfa, 0x1a, 0x5c, 0xb0, 0xbd, 0x07, 0xd8, 0x25, 0xfe, 0x51, 0x6f, 0x8c, 0xfd, 0x01, 0xf6, 0x02,
0x73, 0x84, 0x43, 0x19, 0x57, 0xc2, 0x6f, 0x7b, 0xd3, 0x4f, 0xfa, 0x1f, 0x34, 0xb8, 0xc8, 0x24,
0xdd, 0x33, 0xfd, 0xc0, 0x3e, 0x07, 0x7d, 0xe9, 0xd0, 0x88, 0xcb, 0xd8, 0x29, 0xf3, 0x6f, 0x09,
0x18, 0xc3, 0x19, 0x87, 0xec, 0xd9, 0xd9, 0x2a, 0x5c, 0xdc, 0x04, 0x4c, 0xff, 0xbd, 0x34, 0x6c,
0x5c, 0xce, 0xb3, 0x28, 0x34, 0xcd, 0xb3, 0x94, 0xe5, 0x79, 0x1a, 0x75, 0x7e, 0xa1, 0xc1, 0xc5,
0x8f, 0x88, 0x69, 0x4d, 0x0d, 0xff, 0xe5, 0xab, 0xf3, 0x3b, 0x50, 0x15, 0x51, 0xd2, 0xa9, 0x70,
0x5e, 0xd7, 0x92, 0xbc, 0x64, 0x04, 0x4d, 0x25, 0xdc, 0xe7, 0x00, 0x43, 0x6e, 0xd2, 0x7f, 0xab,
0x41, 0xc7, 0xc0, 0x0e, 0x36, 0x29, 0x7e, 0x95, 0xa7, 0x58, 0x85, 0xaa, 0x47, 0x2c, 0xbc, 0xb3,
0xc5, 0x4f, 0x51, 0x36, 0xe4, 0x4a, 0xff, 0xbb, 0xd4, 0xf0, 0x6b, 0xee, 0xb0, 0x31, 0x2b, 0xcc,
0x9f, 0xc6, 0x0a, 0x5f, 0x4c, 0xad, 0xf0, 0xba, 0x9f, 0x74, 0x6a, 0xa9, 0xf9, 0x84, 0xa5, 0x7e,
0x04, 0x97, 0x36, 0x7d, 0x6c, 0x06, 0xf8, 0xfb, 0x2c, 0xcd, 0x6f, 0x1e, 0x9a, 0x9e, 0x87, 0x9d,
0xf0, 0x08, 0x69, 0xe6, 0x9a, 0x82, 0x79, 0x07, 0x16, 0xc6, 0x3e, 0x79, 0x71, 0x14, 0xc9, 0x1d,
0x2e, 0xf5, 0x3f, 0x69, 0xd0, 0x55, 0xd1, 0x3e, 0x4b, 0x46, 0x78, 0x1b, 0x96, 0x64, 0xbd, 0x12,
0xd4, 0x38, 0xcf, 0x9a, 0xd1, 0x78, 0x16, 0xe3, 0x80, 0xee, 0xc0, 0x05, 0x81, 0xe4, 0x63, 0x3a,
0x71, 0x82, 0x08, 0xb7, 0xcc, 0x71, 0x11, 0xff, 0x66, 0xf0, 0x4f, 0x72, 0x87, 0xfe, 0x99, 0x06,
0x97, 0xb6, 0x71, 0x10, 0x19, 0x91, 0x71, 0xc5, 0xaf, 0x69, 0x92, 0xfd, 0x5c, 0x83, 0xae, 0x4a,
0xd6, 0xb3, 0xa8, 0xf5, 0x31, 0xac, 0x46, 0x3c, 0x7a, 0x16, 0xa6, 0x03, 0xdf, 0x1e, 0x73, 0x67,
0xe6, 0x29, 0xb7, 0xbe, 0xfe, 0xf6, 0x5a, 0xb6, 0x25, 0x58, 0x4b, 0x4b, 0x70, 0x31, 0x22, 0xb1,
0x15, 0xa3, 0xa0, 0xff, 0x52, 0x83, 0x8b, 0xdb, 0x38, 0xd8, 0xc7, 0x23, 0x17, 0x7b, 0xc1, 0x8e,
0x37, 0x24, 0xa7, 0xd7, 0xeb, 0x15, 0x00, 0x2a, 0xe9, 0x44, 0xe5, 0x20, 0x06, 0x29, 0xa2, 0x63,
0xde, 0x7d, 0xa4, 0xe5, 0x39, 0x8b, 0xee, 0xbe, 0x01, 0xf3, 0xb6, 0x37, 0x24, 0xa1, 0xaa, 0xde,
0x54, 0xa9, 0x2a, 0xce, 0x4c, 0x60, 0xeb, 0xff, 0x2a, 0xc1, 0xea, 0x07, 0x96, 0xa5, 0x0a, 0xbb,
0xd9, 0xf5, 0x32, 0x8d, 0xee, 0x52, 0x3c, 0xba, 0x0b, 0xf9, 0x5c, 0x26, 0xa4, 0x2a, 0x33, 0x84,
0xd4, 0x7c, 0x5e, 0x48, 0xa1, 0x6d, 0x58, 0xa2, 0x18, 0x3f, 0xed, 0x8d, 0x09, 0xe5, 0x3e, 0xd1,
0xa9, 0xf2, 0xd3, 0xe8, 0xc9, 0xd3, 0x44, 0x9d, 0xe3, 0x03, 0x3a, 0xda, 0x93, 0x98, 0x46, 0x83,
0x6d, 0x0c, 0x57, 0xe8, 0x21, 0xac, 0x8e, 0x1c, 0xd2, 0x37, 0x9d, 0x1e, 0xc5, 0xa6, 0x83, 0xad,
0x9e, 0xb4, 0x37, 0xed, 0x2c, 0x14, 0x53, 0xf8, 0x05, 0xb1, 0x7d, 0x9f, 0xef, 0x96, 0x1f, 0xa8,
0xfe, 0x37, 0x0d, 0x2e, 0x19, 0xd8, 0x25, 0x9f, 0xe0, 0xff, 0x56, 0x13, 0xe8, 0xbf, 0xd6, 0xa0,
0xc1, 0xaa, 0xf0, 0x03, 0x1c, 0x98, 0x4c, 0x13, 0xe8, 0x7d, 0xa8, 0x39, 0xc4, 0xb4, 0x7a, 0xc1,
0xd1, 0x58, 0x1c, 0xad, 0x99, 0x3e, 0x9a, 0xd0, 0x1e, 0xdb, 0x74, 0x70, 0x34, 0xc6, 0xc6, 0xa2,
0x23, 0x7f, 0x65, 0x8e, 0x51, 0x2a, 0x90, 0xbd, 0xca, 0xaa, 0x16, 0xb1, 0x0c, 0xab, 0x3f, 0x30,
0x83, 0xc1, 0xe1, 0x96, 0x2b, 0xc5, 0xa4, 0xaf, 0x46, 0xe7, 0x45, 0x8a, 0x66, 0x14, 0xda, 0xf3,
0x2a, 0x4f, 0x63, 0xf7, 0x9a, 0xb5, 0x47, 0xd2, 0x0c, 0xb1, 0xd0, 0x8e, 0x75, 0x15, 0xd5, 0x53,
0x74, 0x15, 0x68, 0x13, 0x96, 0xf0, 0x8b, 0x81, 0x33, 0xb1, 0x70, 0x4f, 0x70, 0x17, 0x7e, 0x7e,
0x45, 0xc1, 0x3d, 0xee, 0xe6, 0x0d, 0xb9, 0x69, 0x47, 0xca, 0x20, 0x4c, 0xed, 0xe2, 0xc0, 0xec,
0x2c, 0x72, 0x31, 0xae, 0xe6, 0x99, 0x3a, 0xf4, 0x0f, 0x61, 0x6e, 0xb6, 0xd2, 0xff, 0xad, 0xc1,
0x25, 0x61, 0x26, 0xec, 0x04, 0xe6, 0xab, 0xb5, 0x54, 0x64, 0x85, 0xca, 0x8c, 0x56, 0x88, 0x69,
0xa0, 0x36, 0xb3, 0x06, 0x7e, 0x53, 0x81, 0x96, 0x54, 0x2f, 0xc3, 0xe0, 0xf1, 0x73, 0x19, 0x6a,
0x51, 0xb1, 0x91, 0xcd, 0xd0, 0x14, 0x80, 0xae, 0x42, 0x3d, 0xe6, 0x3d, 0xf2, 0xa0, 0x71, 0x50,
0xa1, 0xd3, 0x86, 0xad, 0x43, 0x25, 0xd6, 0x3a, 0xbc, 0x01, 0x30, 0x74, 0x26, 0xf4, 0xb0, 0x17,
0xd8, 0x2e, 0x96, 0x0d, 0x5c, 0x8d, 0x43, 0x0e, 0x6c, 0x17, 0xa3, 0x0f, 0xa0, 0xd1, 0xb7, 0x3d,
0x87, 0x8c, 0x7a, 0x63, 0x33, 0x38, 0xa4, 0x9d, 0x6a, 0xae, 0xbf, 0xdc, 0xb3, 0xb1, 0x63, 0x6d,
0x70, 0x5c, 0xa3, 0x2e, 0xf6, 0xec, 0xb1, 0x2d, 0xe8, 0x0a, 0xd4, 0xbd, 0x89, 0xdb, 0x23, 0xc3,
0x9e, 0x4f, 0x9e, 0x33, 0x8f, 0xe3, 0x2c, 0xbc, 0x89, 0xfb, 0xf1, 0xd0, 0x20, 0xcf, 0x29, 0xfa,
0x36, 0xd4, 0x58, 0xb9, 0xa3, 0x0e, 0x19, 0xd1, 0xce, 0x62, 0x21, 0xfa, 0xd3, 0x0d, 0x6c, 0xb7,
0xc5, 0xfc, 0x88, 0xef, 0xae, 0x15, 0xdb, 0x1d, 0x6d, 0x40, 0xd7, 0xa1, 0x39, 0x20, 0xee, 0xd8,
0xe4, 0x1a, 0xba, 0xe7, 0x13, 0xb7, 0x03, 0x3c, 0x56, 0x53, 0x50, 0x74, 0x0f, 0xea, 0xb6, 0x67,
0xe1, 0x17, 0x32, 0x6a, 0xea, 0x9c, 0xcf, 0x35, 0x95, 0xc9, 0x1f, 0xe1, 0x01, 0xe7, 0xb5, 0xc3,
0xd0, 0xb9, 0xdd, 0xc1, 0x0e, 0x7f, 0x52, 0xf4, 0x16, 0x34, 0xa4, 0x51, 0x7b, 0xd4, 0x7e, 0x89,
0x3b, 0x0d, 0x61, 0x48, 0x09, 0xdb, 0xb7, 0x5f, 0x62, 0xfd, 0xcf, 0x25, 0x58, 0xce, 0x10, 0x61,
0xad, 0xf0, 0x90, 0x43, 0x42, 0xe7, 0x08, 0x97, 0x8c, 0x24, 0xf6, 0xcc, 0xbe, 0xc3, 0x22, 0xda,
0xc2, 0x2f, 0xb8, 0x6f, 0x2c, 0x1a, 0x75, 0x01, 0xe3, 0x04, 0x98, 0x8d, 0x85, 0xf4, 0x9e, 0xe9,
0x62, 0xd9, 0xaa, 0xd6, 0x38, 0x64, 0xd7, 0x74, 0x31, 0xa3, 0x2d, 0x44, 0x0c, 0x3d, 0x23, 0x5c,
0xb2, 0x2f, 0xfd, 0x89, 0xcd, 0xb9, 0x0a, 0xcf, 0x08, 0x97, 0x68, 0x0b, 0x1a, 0x82, 0xe4, 0xd8,
0xf4, 0x4d, 0x37, 0xf4, 0x8b, 0xb7, 0x94, 0xe1, 0x7a, 0x1f, 0x1f, 0x3d, 0x32, 0x9d, 0x09, 0xde,
0x33, 0x6d, 0xdf, 0x10, 0x7a, 0xdc, 0xe3, 0xbb, 0xd0, 0x4d, 0x68, 0x0b, 0x2a, 0x43, 0xdb, 0xc1,
0xd2, 0xc3, 0x58, 0x46, 0xaa, 0x19, 0x4d, 0x0e, 0xbf, 0x67, 0x3b, 0x58, 0x38, 0x51, 0x74, 0x04,
0xae, 0xb6, 0x45, 0xe1, 0x43, 0x1c, 0xc2, 0x95, 0xf6, 0x8f, 0x12, 0xac, 0xb0, 0x50, 0x0a, 0x4b,
0xf0, 0xe9, 0xb3, 0xc9, 0x1b, 0x00, 0x16, 0x0d, 0x7a, 0x89, 0x8c, 0x52, 0xb3, 0x68, 0xb0, 0x2b,
0x92, 0xca, 0xfb, 0x61, 0xc2, 0x28, 0xe7, 0x37, 0xaf, 0xa9, 0xd0, 0xce, 0xa6, 0xee, 0xd3, 0x5c,
0xcb, 0x59, 0x21, 0xa7, 0x64, 0xe2, 0x0f, 0x70, 0x2f, 0x71, 0xd9, 0x6a, 0x08, 0xe0, 0xae, 0x3a,
0xe7, 0x55, 0x95, 0xcf, 0x03, 0xb1, 0xe4, 0xb5, 0x30, 0x73, 0xf2, 0xfa, 0xab, 0x06, 0xab, 0xf2,
0x62, 0x7a, 0x76, 0x6d, 0xe7, 0xe5, 0xee, 0x30, 0x53, 0x95, 0x8f, 0xb9, 0xe4, 0x54, 0x0a, 0x54,
0xde, 0x79, 0x45, 0xe5, 0x4d, 0x36, 0xfa, 0xd5, 0x74, 0xa3, 0xaf, 0xff, 0x4a, 0x83, 0xd5, 0x0f,
0x4d, 0xcf, 0x22, 0xc3, 0xe1, 0xd9, 0x0f, 0xb8, 0x19, 0x05, 0xfc, 0xce, 0x2c, 0x8d, 0x7c, 0x62,
0x93, 0xfe, 0x69, 0x09, 0x10, 0xb3, 0xc6, 0x86, 0xe9, 0x98, 0xde, 0x00, 0x9f, 0x5e, 0x9a, 0x6b,
0xd0, 0x4c, 0xf8, 0x50, 0xf4, 0x8c, 0x18, 0x77, 0x22, 0x8a, 0xee, 0x43, 0xb3, 0x2f, 0x58, 0xf5,
0x7c, 0x6c, 0x52, 0xe2, 0x71, 0x3b, 0x34, 0xd7, 0xdf, 0x51, 0x89, 0x7d, 0xe0, 0xdb, 0xa3, 0x11,
0xf6, 0x37, 0x89, 0x67, 0x89, 0x16, 0x7b, 0xa9, 0x1f, 0x8a, 0xc9, 0xb6, 0xa2, 0x37, 0xa1, 0x3e,
0x0d, 0xa8, 0xb0, 0x17, 0x82, 0x28, 0xa2, 0x28, 0x7a, 0x17, 0x96, 0x93, 0xdd, 0xf7, 0xd4, 0x70,
0x6d, 0x1a, 0x6f, 0xac, 0x99, 0x71, 0x7e, 0x02, 0x28, 0xea, 0xee, 0x78, 0x13, 0xc1, 0xb3, 0x63,
0x91, 0xc7, 0x84, 0xcb, 0x50, 0xb3, 0xc2, 0x9d, 0xf2, 0x6a, 0x3f, 0x05, 0xb0, 0xe8, 0x12, 0x12,
0xf6, 0x98, 0xa3, 0x63, 0x2b, 0xac, 0x9f, 0x02, 0xf8, 0x11, 0x87, 0xe9, 0x9f, 0x97, 0xa0, 0x1d,
0xef, 0xe8, 0x0b, 0xf3, 0x3e, 0x9f, 0xa7, 0x85, 0x63, 0xae, 0x2f, 0x95, 0x33, 0x5c, 0x5f, 0xb2,
0xd7, 0xab, 0xf9, 0xd3, 0x5d, 0xaf, 0xf4, 0xdf, 0x69, 0xd0, 0x4a, 0xdd, 0xe4, 0xd3, 0x9d, 0x8c,
0x96, 0xed, 0x64, 0xbe, 0x09, 0xf3, 0xac, 0xbc, 0x63, 0xae, 0xa4, 0x66, 0x9a, 0xad, 0xea, 0x7d,
0xc0, 0x10, 0x1b, 0xd0, 0x6d, 0x58, 0x51, 0xbc, 0xd7, 0x4a, 0x53, 0xa2, 0xec, 0x73, 0xad, 0xfe,
0xd3, 0x0a, 0xd4, 0x63, 0xfa, 0x38, 0xa1, 0x09, 0x2b, 0x72, 0x4f, 0x49, 0x1d, 0xaf, 0x9c, 0x3d,
0x5e, 0xce, 0xbb, 0x26, 0xba, 0x04, 0x8b, 0x2e, 0x76, 0x45, 0x7d, 0x93, 0xc5, 0xd6, 0xc5, 0x2e,
0xab, 0x6e, 0xec, 0x13, 0xeb, 0xa0, 0x78, 0xfb, 0x24, 0x32, 0xfa, 0x82, 0x37, 0x71, 0x79, 0xf3,
0x94, 0x2c, 0xed, 0x0b, 0xc7, 0x94, 0xf6, 0xc5, 0x64, 0x69, 0x4f, 0x84, 0x43, 0x2d, 0x1d, 0x0e,
0x45, 0xfb, 0xa2, 0x3b, 0xb0, 0x32, 0xe0, 0xcf, 0x70, 0xd6, 0xc6, 0xd1, 0x66, 0xf4, 0xa9, 0x53,
0xe7, 0x3d, 0x88, 0xea, 0x13, 0xba, 0xc7, 0x9c, 0x4b, 0x76, 0x40, 0xdc, 0xca, 0x0d, 0x6e, 0x65,
0x75, 0xe7, 0x20, 0x6d, 0x23, 0x8c, 0x1c, 0xe6, 0x44, 0xbe, 0x4a, 0x77, 0x64, 0x4b, 0xa7, 0xec,
0xc8, 0xf4, 0x4f, 0xcb, 0xd0, 0x9c, 0xd6, 0xdc, 0xc2, 0x11, 0x5d, 0x64, 0x7c, 0xb0, 0x0b, 0xed,
0xe9, 0xcb, 0x17, 0x3f, 0xec, 0xb1, 0x6d, 0x43, 0xfa, 0xcd, 0xab, 0x35, 0x4e, 0x85, 0x4e, 0xe2,
0x8a, 0x5d, 0x99, 0xe9, 0x8a, 0x7d, 0xb6, 0xc7, 0x68, 0x74, 0x17, 0x2e, 0xfa, 0xa2, 0xe4, 0x5b,
0xbd, 0xc4, 0xb1, 0x45, 0xf5, 0xbc, 0x10, 0x7e, 0xdc, 0x8b, 0x1f, 0x3f, 0x27, 0x1a, 0x17, 0x72,
0xa3, 0xf1, 0x21, 0xac, 0x3c, 0xf4, 0xe8, 0xa4, 0x4f, 0x07, 0xbe, 0xdd, 0xc7, 0xe1, 0xc5, 0xb0,
0x90, 0x39, 0xba, 0xb0, 0x28, 0xd3, 0xa5, 0x30, 0x45, 0xcd, 0x88, 0xd6, 0xfa, 0x2f, 0x34, 0x58,
0xcd, 0xd2, 0xe5, 0x96, 0x9e, 0xc6, 0xa2, 0x96, 0x88, 0xc5, 0x1f, 0xc2, 0xca, 0x94, 0x7c, 0x2f,
0x41, 0xb9, 0xbe, 0x7e, 0x43, 0xa5, 0x73, 0x85, 0xe0, 0x06, 0x9a, 0xd2, 0x08, 0x61, 0xfa, 0x3f,
0x35, 0x58, 0x96, 0x5e, 0xcd, 0x60, 0x23, 0x7e, 0xa5, 0x66, 0xf5, 0x81, 0x78, 0x8e, 0xed, 0x45,
0xbd, 0x9d, 0x3c, 0xa3, 0x00, 0xca, 0xde, 0xee, 0x43, 0x68, 0x49, 0xa4, 0x28, 0xcd, 0x17, 0xec,
0x26, 0x9a, 0x62, 0x5f, 0x94, 0xe0, 0xaf, 0x41, 0x93, 0x0c, 0x87, 0x71, 0x7e, 0x22, 0x4f, 0x2d,
0x49, 0xa8, 0x64, 0xf8, 0x3d, 0x68, 0x87, 0x68, 0xb3, 0x16, 0x96, 0x96, 0xdc, 0x18, 0x3d, 0x89,
0xfd, 0x5c, 0x83, 0x4e, 0xb2, 0xcc, 0xc4, 0x8e, 0x3f, 0x7b, 0x23, 0xf3, 0xad, 0xe4, 0xc3, 0xe8,
0xb5, 0x63, 0xe4, 0x99, 0xf2, 0x91, 0x8d, 0xf8, 0xad, 0x97, 0xd0, 0x4c, 0xc6, 0x1a, 0x6a, 0xc0,
0xe2, 0x2e, 0x09, 0xbe, 0xfb, 0xc2, 0xa6, 0x41, 0x7b, 0x0e, 0x35, 0x01, 0x76, 0x49, 0xb0, 0xe7,
0x63, 0x8a, 0xbd, 0xa0, 0xad, 0x21, 0x80, 0xea, 0xc7, 0xde, 0x96, 0x4d, 0x9f, 0xb6, 0x4b, 0x68,
0x45, 0x56, 0x34, 0xd3, 0xd9, 0x91, 0x0e, 0xdc, 0x2e, 0xb3, 0xed, 0xd1, 0xaa, 0x82, 0xda, 0xd0,
0x88, 0x50, 0xb6, 0xf7, 0x1e, 0xb6, 0xe7, 0x51, 0x0d, 0xe6, 0xc5, 0xcf, 0xea, 0x2d, 0x0b, 0xda,
0xe9, 0x86, 0x89, 0xd1, 0x7c, 0xe8, 0xdd, 0xf7, 0xc8, 0xf3, 0x08, 0xd4, 0x9e, 0x43, 0x75, 0x58,
0x90, 0x4d, 0x68, 0x5b, 0x43, 0x2d, 0xa8, 0xc7, 0xfa, 0xbf, 0x76, 0x89, 0x01, 0xb6, 0xfd, 0xf1,
0x40, 0x76, 0x82, 0x42, 0x04, 0x66, 0xb5, 0x2d, 0xf2, 0xdc, 0x6b, 0x57, 0x6e, 0x6d, 0xc0, 0x62,
0x98, 0x04, 0x18, 0xaa, 0xa0, 0xee, 0xb1, 0x65, 0x7b, 0x0e, 0x2d, 0xc3, 0x52, 0x62, 0x7e, 0xd6,
0xd6, 0x10, 0x82, 0x66, 0x72, 0x68, 0xd9, 0x2e, 0xad, 0xff, 0xa5, 0x0e, 0x20, 0x9a, 0x1d, 0x42,
0x7c, 0x0b, 0x8d, 0x01, 0x6d, 0xe3, 0x80, 0x25, 0x72, 0xe2, 0x85, 0x49, 0x98, 0xa2, 0x3b, 0x39,
0x3d, 0x41, 0x16, 0x55, 0x8a, 0xda, 0xbd, 0x9e, 0xb3, 0x23, 0x85, 0xae, 0xcf, 0x21, 0x97, 0x73,
0x3c, 0xb0, 0x5d, 0x7c, 0x60, 0x0f, 0x9e, 0x46, 0x5d, 0x52, 0x3e, 0xc7, 0x14, 0x6a, 0xc8, 0x31,
0x95, 0x6c, 0xe5, 0x62, 0x3f, 0xf0, 0x6d, 0x6f, 0x14, 0x3e, 0xcf, 0xeb, 0x73, 0xe8, 0x19, 0x5c,
0xd8, 0xc6, 0x9c, 0xbb, 0x4d, 0x03, 0x7b, 0x40, 0x43, 0x86, 0xeb, 0xf9, 0x0c, 0x33, 0xc8, 0x33,
0xb2, 0x74, 0xa0, 0x95, 0xfa, 0x93, 0x00, 0xba, 0xa5, 0xf4, 0x64, 0xe5, 0x1f, 0x1a, 0xba, 0xef,
0x16, 0xc2, 0x8d, 0xb8, 0xd9, 0xd0, 0x4c, 0x0e, 0xd0, 0xd1, 0x57, 0xf2, 0x08, 0x64, 0x26, 0x8e,
0xdd, 0x5b, 0x45, 0x50, 0x23, 0x56, 0x8f, 0x85, 0x3f, 0x9d, 0xc4, 0x4a, 0x39, 0xc6, 0xed, 0x1e,
0x37, 0x19, 0xd1, 0xe7, 0xd0, 0x8f, 0x61, 0x39, 0x33, 0x17, 0x45, 0x5f, 0x55, 0x91, 0xcf, 0x1b,
0x9f, 0x9e, 0xc4, 0xe1, 0x71, 0x3a, 0x1a, 0xf2, 0xa5, 0xcf, 0x0c, 0xc8, 0x8b, 0x4b, 0x1f, 0x23,
0x7f, 0x9c, 0xf4, 0x33, 0x73, 0x98, 0x00, 0xca, 0x4e, 0x46, 0xd1, 0x7b, 0x2a, 0x16, 0xb9, 0xd3,
0xd9, 0xee, 0x5a, 0x51, 0xf4, 0xc8, 0xe4, 0x13, 0x1e, 0xad, 0xe9, 0x6e, 0x5f, 0xc9, 0x36, 0x77,
0x1a, 0xaa, 0x66, 0x9b, 0x3f, 0x90, 0x14, 0x4e, 0x9d, 0x1c, 0xb8, 0xa9, 0x6d, 0xa5, 0x1c, 0x12,
0xaa, 0x9d, 0x5a, 0x3d, 0xbf, 0xd3, 0xe7, 0xd0, 0x41, 0x22, 0x09, 0xa3, 0xeb, 0x79, 0x3e, 0x91,
0xbc, 0xa5, 0x9f, 0x64, 0xae, 0x1e, 0xc0, 0x36, 0x0e, 0x1e, 0xe0, 0xc0, 0xb7, 0x07, 0x34, 0x4d,
0x54, 0x2e, 0xa6, 0x08, 0x21, 0xd1, 0x1b, 0x27, 0xe2, 0x85, 0x62, 0xaf, 0x7f, 0x06, 0x50, 0xe3,
0x36, 0x63, 0xf5, 0xe1, 0x7f, 0x69, 0xfc, 0x1c, 0xd2, 0xf8, 0x13, 0x68, 0xa5, 0xa6, 0xad, 0xea,
0x34, 0xae, 0x1e, 0xc9, 0x9e, 0xe4, 0x20, 0x7d, 0x40, 0xd9, 0x59, 0xa2, 0x3a, 0xb0, 0x72, 0x67,
0x8e, 0x27, 0xf1, 0x78, 0x02, 0xad, 0xd4, 0xe0, 0x4c, 0x7d, 0x02, 0xf5, 0x74, 0xad, 0xc0, 0x09,
0xb2, 0xf3, 0x1e, 0xf5, 0x09, 0x72, 0xe7, 0x42, 0x27, 0xf1, 0x78, 0x24, 0xc6, 0x91, 0x51, 0x8b,
0x7b, 0x23, 0x2f, 0x3a, 0x53, 0x4f, 0x7a, 0xaf, 0x3e, 0x5f, 0x9f, 0x7f, 0x3d, 0x7b, 0x02, 0xad,
0xd4, 0x83, 0xad, 0xda, 0xba, 0xea, 0x57, 0xdd, 0x93, 0xa8, 0x7f, 0x89, 0x19, 0xf8, 0xbc, 0x73,
0xe5, 0xc6, 0xd7, 0x1f, 0xaf, 0x8f, 0xec, 0xe0, 0x70, 0xd2, 0x67, 0xa7, 0xbc, 0x2d, 0x30, 0xdf,
0xb3, 0x89, 0xfc, 0x75, 0x3b, 0x4c, 0x1a, 0xb7, 0x39, 0xa5, 0xdb, 0x5c, 0xda, 0x71, 0xbf, 0x5f,
0xe5, 0xcb, 0xbb, 0xff, 0x09, 0x00, 0x00, 0xff, 0xff, 0xee, 0xf5, 0x56, 0xa4, 0xef, 0x2a, 0x00,
0x00,
}
// Reference imports to suppress errors if they are not otherwise used.

6
internal/querycoord/impl.go
View File

@ -183,7 +183,7 @@ func (qc *QueryCoord) LoadCollection(ctx context.Context, req *querypb.LoadColle
if collectionInfo, err := qc.meta.getCollectionInfoByID(collectionID); err == nil {
// if collection has been loaded by load collection request, return success
if collectionInfo.LoadType == querypb.LoadType_loadCollection {
if collectionInfo.LoadType == querypb.LoadType_LoadCollection {
log.Debug("collection has already been loaded, return load success directly",
zap.String("role", typeutil.QueryCoordRole),
zap.Int64("collectionID", collectionID),
@ -471,7 +471,7 @@ func (qc *QueryCoord) LoadPartitions(ctx context.Context, req *querypb.LoadParti
if collectionInfo, err := qc.meta.getCollectionInfoByID(collectionID); err == nil {
// if the collection has been loaded into memory by load collection request, return error
// should release collection first, then load partitions again
if collectionInfo.LoadType == querypb.LoadType_loadCollection {
if collectionInfo.LoadType == querypb.LoadType_LoadCollection {
status.ErrorCode = commonpb.ErrorCode_UnexpectedError
err = fmt.Errorf("collection %d has been loaded into QueryNode, please release collection firstly", collectionID)
status.Reason = err.Error()
@ -611,7 +611,7 @@ func (qc *QueryCoord) ReleasePartitions(ctx context.Context, req *querypb.Releas
if collectionInfo, err := qc.meta.getCollectionInfoByID(collectionID); err == nil {
// if collection has been loaded into memory by load collection request, return error
// part of the partitions released after load collection is temporarily not supported, and will be supported soon
if collectionInfo.LoadType == querypb.LoadType_loadCollection {
if collectionInfo.LoadType == querypb.LoadType_LoadCollection {
status.ErrorCode = commonpb.ErrorCode_UnexpectedError
err := errors.New("releasing some partitions after load collection is not supported")
status.Reason = err.Error()

6
internal/querycoord/index_checker_test.go
View File

@ -73,7 +73,7 @@ func TestReloadFromKV(t *testing.T) {
err = kv.Save(key, string(value))
assert.Nil(t, err)
meta.setLoadType(defaultCollectionID, querypb.LoadType_loadCollection)
meta.setLoadType(defaultCollectionID, querypb.LoadType_LoadCollection)
t.Run("Test_CollectionExist", func(t *testing.T) {
indexChecker, err := newIndexChecker(baseCtx, kv, meta, nil, nil, nil)
@ -135,7 +135,7 @@ func TestCheckIndexLoop(t *testing.T) {
childCancel()
indexChecker.wg.Wait()
})
meta.addCollection(defaultCollectionID, querypb.LoadType_loadCollection, genDefaultCollectionSchema(false))
meta.addCollection(defaultCollectionID, querypb.LoadType_LoadCollection, genDefaultCollectionSchema(false))
t.Run("Test_GetIndexInfo", func(t *testing.T) {
childCtx, childCancel := context.WithCancel(context.Background())
indexChecker, err := newIndexChecker(childCtx, kv, meta, nil, nil, broker)
@ -176,7 +176,7 @@ func TestHandoffNotExistSegment(t *testing.T) {
broker, err := newGlobalMetaBroker(ctx, rootCoord, dataCoord, indexCoord)
assert.Nil(t, err)
meta.addCollection(defaultCollectionID, querypb.LoadType_loadCollection, genDefaultCollectionSchema(false))
meta.addCollection(defaultCollectionID, querypb.LoadType_LoadCollection, genDefaultCollectionSchema(false))
segmentInfo := &querypb.SegmentInfo{
SegmentID: defaultSegmentID,

2
internal/querycoord/meta.go
View File

@ -903,7 +903,7 @@ func (m *MetaReplica) setLoadPercentage(collectionID UniqueID, partitionID Uniqu
}
info := proto.Clone(m.collectionInfos[collectionID]).(*querypb.CollectionInfo)
if loadType == querypb.LoadType_loadCollection {
if loadType == querypb.LoadType_LoadCollection {
info.InMemoryPercentage = percentage
for _, partitionState := range info.PartitionStates {
if percentage >= 100 {

12
internal/querycoord/meta_test.go
View File

@ -70,7 +70,7 @@ func TestReplica_Release(t *testing.T) {
etcdKV := etcdkv.NewEtcdKV(etcdCli, Params.EtcdCfg.MetaRootPath)
meta, err := newMeta(context.Background(), etcdKV, nil, nil)
assert.Nil(t, err)
err = meta.addCollection(1, querypb.LoadType_loadCollection, nil)
err = meta.addCollection(1, querypb.LoadType_LoadCollection, nil)
require.NoError(t, err)
collections := meta.showCollections()
@ -164,18 +164,18 @@ func TestMetaFunc(t *testing.T) {
})
t.Run("Test SetLoadTypeFail", func(t *testing.T) {
err := meta.setLoadType(defaultCollectionID, querypb.LoadType_loadCollection)
err := meta.setLoadType(defaultCollectionID, querypb.LoadType_LoadCollection)
assert.NotNil(t, err)
})
t.Run("Test SetLoadPercentageFail", func(t *testing.T) {
err := meta.setLoadPercentage(defaultCollectionID, defaultPartitionID, 100, querypb.LoadType_loadCollection)
err := meta.setLoadPercentage(defaultCollectionID, defaultPartitionID, 100, querypb.LoadType_LoadCollection)
assert.NotNil(t, err)
})
t.Run("Test AddCollection", func(t *testing.T) {
schema := genDefaultCollectionSchema(false)
err := meta.addCollection(defaultCollectionID, querypb.LoadType_loadCollection, schema)
err := meta.addCollection(defaultCollectionID, querypb.LoadType_LoadCollection, schema)
assert.Nil(t, err)
})
@ -260,7 +260,7 @@ func TestMetaFunc(t *testing.T) {
})
t.Run("Test SetLoadType", func(t *testing.T) {
err := meta.setLoadType(defaultCollectionID, querypb.LoadType_loadCollection)
err := meta.setLoadType(defaultCollectionID, querypb.LoadType_LoadCollection)
assert.Nil(t, err)
})
@ -270,7 +270,7 @@ func TestMetaFunc(t *testing.T) {
state, err := meta.getPartitionStatesByID(defaultCollectionID, defaultPartitionID)
assert.Nil(t, err)
assert.Equal(t, int64(100), state.InMemoryPercentage)
err = meta.setLoadPercentage(defaultCollectionID, defaultPartitionID, 100, querypb.LoadType_loadCollection)
err = meta.setLoadPercentage(defaultCollectionID, defaultPartitionID, 100, querypb.LoadType_LoadCollection)
assert.Nil(t, err)
info, err := meta.getCollectionInfoByID(defaultCollectionID)
assert.Nil(t, err)

2
internal/querycoord/query_coord_test.go
View File

@ -353,7 +353,7 @@ func TestHandoffSegmentLoop(t *testing.T) {
err = queryCoord.scheduler.Enqueue(loadCollectionTask)
assert.Nil(t, err)
waitTaskFinalState(loadCollectionTask, taskExpired)
queryCoord.meta.setLoadType(defaultCollectionID, querypb.LoadType_loadCollection)
queryCoord.meta.setLoadType(defaultCollectionID, querypb.LoadType_LoadCollection)
t.Run("Test handoffGrowingSegment", func(t *testing.T) {
infos := queryCoord.meta.showSegmentInfos(defaultCollectionID, nil)

34
internal/querycoord/task.go
View File

@ -339,7 +339,7 @@ func (lct *loadCollectionTask) updateTaskProcess() {
}
if allDone {
err := lct.meta.setLoadPercentage(collectionID, 0, 100, querypb.LoadType_loadCollection)
err := lct.meta.setLoadPercentage(collectionID, 0, 100, querypb.LoadType_LoadCollection)
if err != nil {
log.Error("loadCollectionTask: set load percentage to meta's collectionInfo", zap.Int64("collectionID", collectionID))
lct.setResultInfo(err)
@ -387,8 +387,8 @@ func (lct *loadCollectionTask) execute(ctx context.Context) error {
return err
}
for _, segmentBingLog := range binlogs {
segmentLoadInfo := lct.broker.generateSegmentLoadInfo(ctx, collectionID, partitionID, segmentBingLog, true, lct.Schema)
for _, segmentBinlog := range binlogs {
segmentLoadInfo := lct.broker.generateSegmentLoadInfo(ctx, collectionID, partitionID, segmentBinlog, true, lct.Schema)
msgBase := proto.Clone(lct.Base).(*commonpb.MsgBase)
msgBase.MsgType = commonpb.MsgType_LoadSegments
loadSegmentReq := &querypb.LoadSegmentsRequest{
@ -396,6 +396,11 @@ func (lct *loadCollectionTask) execute(ctx context.Context) error {
Infos: []*querypb.SegmentLoadInfo{segmentLoadInfo},
Schema: lct.Schema,
CollectionID: collectionID,
LoadMeta: &querypb.LoadMetaInfo{
LoadType: querypb.LoadType_LoadCollection,
CollectionID: collectionID,
PartitionIDs: toLoadPartitionIDs,
},
}
loadSegmentReqs = append(loadSegmentReqs, loadSegmentReq)
@ -433,6 +438,11 @@ func (lct *loadCollectionTask) execute(ctx context.Context) error {
//PartitionIDs: toLoadPartitionIDs,
Infos: []*datapb.VchannelInfo{info},
Schema: lct.Schema,
LoadMeta: &querypb.LoadMetaInfo{
LoadType: querypb.LoadType_LoadCollection,
CollectionID: collectionID,
PartitionIDs: toLoadPartitionIDs,
},
}
watchDmChannelReqs = append(watchDmChannelReqs, watchRequest)
@ -451,7 +461,7 @@ func (lct *loadCollectionTask) execute(ctx context.Context) error {
metrics.QueryCoordNumChildTasks.WithLabelValues().Add(float64(len(internalTasks)))
log.Debug("loadCollectionTask: assign child task done", zap.Int64("collectionID", collectionID), zap.Int64("msgID", lct.Base.MsgID))
err = lct.meta.addCollection(collectionID, querypb.LoadType_loadCollection, lct.Schema)
err = lct.meta.addCollection(collectionID, querypb.LoadType_LoadCollection, lct.Schema)
if err != nil {
log.Error("loadCollectionTask: add collection to meta failed", zap.Int64("collectionID", collectionID), zap.Int64("msgID", lct.Base.MsgID), zap.Error(err))
lct.setResultInfo(err)
@ -741,6 +751,11 @@ func (lpt *loadPartitionTask) execute(ctx context.Context) error {
Infos: []*querypb.SegmentLoadInfo{segmentLoadInfo},
Schema: lpt.Schema,
CollectionID: collectionID,
LoadMeta: &querypb.LoadMetaInfo{
LoadType: querypb.LoadType_LoadPartition,
CollectionID: collectionID,
PartitionIDs: partitionIDs,
},
}
loadSegmentReqs = append(loadSegmentReqs, loadSegmentReq)
}
@ -775,6 +790,11 @@ func (lpt *loadPartitionTask) execute(ctx context.Context) error {
PartitionIDs: partitionIDs,
Infos: []*datapb.VchannelInfo{info},
Schema: lpt.Schema,
LoadMeta: &querypb.LoadMetaInfo{
LoadType: querypb.LoadType_LoadPartition,
CollectionID: collectionID,
PartitionIDs: partitionIDs,
},
}
watchDmChannelReqs = append(watchDmChannelReqs, watchRequest)
@ -1468,7 +1488,7 @@ func (ht *handoffTask) execute(ctx context.Context) error {
continue
}
if collectionInfo.LoadType == querypb.LoadType_loadCollection && ht.meta.hasReleasePartition(collectionID, partitionID) {
if collectionInfo.LoadType == querypb.LoadType_LoadCollection && ht.meta.hasReleasePartition(collectionID, partitionID) {
log.Debug("handoffTask: partition has not been released", zap.Int64("collectionID", collectionID), zap.Int64("partitionID", partitionID))
continue
}
@ -1480,7 +1500,7 @@ func (ht *handoffTask) execute(ctx context.Context) error {
}
}
if collectionInfo.LoadType != querypb.LoadType_loadCollection && !partitionLoaded {
if collectionInfo.LoadType != querypb.LoadType_LoadCollection && !partitionLoaded {
log.Debug("handoffTask: partition has not been loaded into memory", zap.Int64("collectionID", collectionID), zap.Int64("partitionID", partitionID), zap.Int64("segmentID", segmentID))
continue
}
@ -1661,7 +1681,7 @@ func (lbt *loadBalanceTask) execute(ctx context.Context) error {
var dmChannelInfos []*datapb.VchannelInfo
var toRecoverPartitionIDs []UniqueID
if collectionInfo.LoadType == querypb.LoadType_loadCollection {
if collectionInfo.LoadType == querypb.LoadType_LoadCollection {
toRecoverPartitionIDs, err = lbt.broker.showPartitionIDs(ctx, collectionID)
if err != nil {
log.Error("loadBalanceTask: show collection's partitionIDs failed", zap.Int64("collectionID", collectionID), zap.Error(err))

23
internal/querycoord/task_test.go
View File

@ -142,6 +142,11 @@ func genWatchDmChannelTask(ctx context.Context, queryCoord *QueryCoord, nodeID i
PartitionIDs: []UniqueID{defaultPartitionID},
Schema: schema,
Infos: []*datapb.VchannelInfo{vChannelInfo},
LoadMeta: &querypb.LoadMetaInfo{
LoadType: querypb.LoadType_LoadCollection,
CollectionID: defaultCollectionID,
PartitionIDs: []int64{defaultPartitionID},
},
}
baseTask := newBaseTask(ctx, querypb.TriggerCondition_GrpcRequest)
baseTask.taskID = 100
@ -175,7 +180,7 @@ func genWatchDmChannelTask(ctx context.Context, queryCoord *QueryCoord, nodeID i
parentTask.addChildTask(watchDmChannelTask)
watchDmChannelTask.setParentTask(parentTask)
queryCoord.meta.addCollection(defaultCollectionID, querypb.LoadType_loadCollection, schema)
queryCoord.meta.addCollection(defaultCollectionID, querypb.LoadType_LoadCollection, schema)
return watchDmChannelTask
}
func genLoadSegmentTask(ctx context.Context, queryCoord *QueryCoord, nodeID int64) *loadSegmentTask {
@ -194,6 +199,11 @@ func genLoadSegmentTask(ctx context.Context, queryCoord *QueryCoord, nodeID int6
Schema: schema,
Infos: []*querypb.SegmentLoadInfo{segmentInfo},
CollectionID: defaultCollectionID,
LoadMeta: &querypb.LoadMetaInfo{
LoadType: querypb.LoadType_LoadCollection,
CollectionID: defaultCollectionID,
PartitionIDs: []int64{defaultPartitionID},
},
}
baseTask := newBaseTask(ctx, querypb.TriggerCondition_GrpcRequest)
baseTask.taskID = 100
@ -227,7 +237,7 @@ func genLoadSegmentTask(ctx context.Context, queryCoord *QueryCoord, nodeID int6
parentTask.addChildTask(loadSegmentTask)
loadSegmentTask.setParentTask(parentTask)
queryCoord.meta.addCollection(defaultCollectionID, querypb.LoadType_loadCollection, schema)
queryCoord.meta.addCollection(defaultCollectionID, querypb.LoadType_LoadCollection, schema)
return loadSegmentTask
}
@ -258,6 +268,11 @@ func genWatchDeltaChannelTask(ctx context.Context, queryCoord *QueryCoord, nodeI
},
NodeID: nodeID,
CollectionID: defaultCollectionID,
LoadMeta: &querypb.LoadMetaInfo{
LoadType: querypb.LoadType_LoadCollection,
CollectionID: defaultCollectionID,
PartitionIDs: []int64{defaultPartitionID},
},
}
baseTask := newBaseTask(ctx, querypb.TriggerCondition_GrpcRequest)
baseTask.taskID = 300
@ -1229,7 +1244,7 @@ func TestUpdateTaskProcessWhenLoadSegment(t *testing.T) {
node1, err := startQueryNodeServer(ctx)
assert.Nil(t, err)
waitQueryNodeOnline(queryCoord.cluster, node1.queryNodeID)
queryCoord.meta.addCollection(defaultCollectionID, querypb.LoadType_loadCollection, genDefaultCollectionSchema(false))
queryCoord.meta.addCollection(defaultCollectionID, querypb.LoadType_LoadCollection, genDefaultCollectionSchema(false))
loadSegmentTask := genLoadSegmentTask(ctx, queryCoord, node1.queryNodeID)
loadCollectionTask := loadSegmentTask.getParentTask()
@ -1262,7 +1277,7 @@ func TestUpdateTaskProcessWhenWatchDmChannel(t *testing.T) {
node1, err := startQueryNodeServer(ctx)
assert.Nil(t, err)
waitQueryNodeOnline(queryCoord.cluster, node1.queryNodeID)
queryCoord.meta.addCollection(defaultCollectionID, querypb.LoadType_loadCollection, genDefaultCollectionSchema(false))
queryCoord.meta.addCollection(defaultCollectionID, querypb.LoadType_LoadCollection, genDefaultCollectionSchema(false))
watchDmChannel := genWatchDmChannelTask(ctx, queryCoord, node1.queryNodeID)
loadCollectionTask := watchDmChannel.getParentTask()

40
internal/querynode/task.go
View File

@ -227,11 +227,19 @@ func (w *watchDmChannelsTask) Execute(ctx context.Context) error {
partitionIDs := w.req.GetPartitionIDs()
var lType loadType
// if no partitionID is specified, load type is load collection
if len(partitionIDs) != 0 {
lType = loadTypePartition
} else {
switch w.req.GetLoadMeta().GetLoadType() {
case queryPb.LoadType_LoadCollection:
lType = loadTypeCollection
case queryPb.LoadType_LoadPartition:
lType = loadTypePartition
default:
// if no partitionID is specified, load type is load collection
if len(partitionIDs) != 0 {
lType = loadTypePartition
} else {
lType = loadTypeCollection
}
}
// get all vChannels
@ -288,7 +296,8 @@ func (w *watchDmChannelsTask) Execute(ctx context.Context) error {
},
Infos: unFlushedSegments,
CollectionID: collectionID,
Schema: w.req.Schema,
Schema: w.req.GetSchema(),
LoadMeta: w.req.GetLoadMeta(),
}
log.Debug("loading growing segments in WatchDmChannels...",
zap.Int64("collectionID", collectionID),
@ -432,13 +441,11 @@ func (w *watchDmChannelsTask) Execute(ctx context.Context) error {
hCol.addVChannels(vChannels)
hCol.addPChannels(pChannels)
hCol.setLoadType(lType)
if lType == loadTypePartition {
for _, partitionID := range partitionIDs {
sCol.deleteReleasedPartition(partitionID)
hCol.deleteReleasedPartition(partitionID)
w.node.streaming.replica.addPartition(collectionID, partitionID)
w.node.historical.replica.addPartition(collectionID, partitionID)
}
for _, partitionID := range w.req.GetLoadMeta().GetPartitionIDs() {
sCol.deleteReleasedPartition(partitionID)
hCol.deleteReleasedPartition(partitionID)
w.node.streaming.replica.addPartition(collectionID, partitionID)
w.node.historical.replica.addPartition(collectionID, partitionID)
}
log.Debug("watchDMChannel, init replica done", zap.Int64("collectionID", collectionID), zap.Strings("vChannels", vChannels))
@ -638,15 +645,14 @@ func (l *loadSegmentsTask) Execute(ctx context.Context) error {
var err error
// init meta
for _, info := range l.req.Infos {
collectionID := info.CollectionID
partitionID := info.PartitionID
l.node.historical.replica.addCollection(collectionID, l.req.Schema)
collectionID := l.req.GetLoadMeta().GetCollectionID()
l.node.historical.replica.addCollection(collectionID, l.req.GetSchema())
l.node.streaming.replica.addCollection(collectionID, l.req.GetSchema())
for _, partitionID := range l.req.GetLoadMeta().GetPartitionIDs() {
err = l.node.historical.replica.addPartition(collectionID, partitionID)
if err != nil {
return err
}
l.node.streaming.replica.addCollection(collectionID, l.req.Schema)
err = l.node.streaming.replica.addPartition(collectionID, partitionID)
if err != nil {
return err