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

Remove useless statsService in QueryNode (#17395)

Browse Source 
Signed-off-by: bigsheeper <yihao.dai@zilliz.com>
This commit is contained in:
bigsheeper 2022-07-11 15:12:25 +08:00 committed by GitHub
parent a9aff3a678
commit 1da970af18
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
16 changed files with 137 additions and 527 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
internal/mq/msgstream/mq_msgstream_test.go
View File

@ -648,7 +648,6 @@ func TestStream_PulsarMsgStream_DefaultRepackFunc(t *testing.T) {
msgPack.Msgs = append(msgPack.Msgs, getTsMsg(commonpb.MsgType_TimeTick, 1))
msgPack.Msgs = append(msgPack.Msgs, getTsMsg(commonpb.MsgType_Search, 2))
msgPack.Msgs = append(msgPack.Msgs, getTsMsg(commonpb.MsgType_SearchResult, 3))
msgPack.Msgs = append(msgPack.Msgs, getTsMsg(commonpb.MsgType_QueryNodeStats, 4))
factory := ProtoUDFactory{}
@ -1973,18 +1972,6 @@ func getTsMsg(msgType MsgType, reqID UniqueID) TsMsg {
TimeTickMsg: timeTickResult,
}
return timeTickMsg
case commonpb.MsgType_QueryNodeStats:
queryNodeSegStats := internalpb.QueryNodeStats{
Base: &commonpb.MsgBase{
MsgType: commonpb.MsgType_QueryNodeStats,
SourceID: reqID,
},
}
queryNodeSegStatsMsg := &QueryNodeStatsMsg{
BaseMsg: baseMsg,
QueryNodeStats: queryNodeSegStats,
}
return queryNodeSegStatsMsg
}
return nil
}

64
internal/mq/msgstream/msg.go
View File

@ -723,70 +723,6 @@ func (tst *TimeTickMsg) Unmarshal(input MarshalType) (TsMsg, error) {
return timeTick, nil
}
/////////////////////////////////////////QueryNodeStats//////////////////////////////////////////
// QueryNodeStatsMsg is a message pack that contains statistic from querynode
// GOOSE TODO: remove QueryNodeStats
type QueryNodeStatsMsg struct {
BaseMsg
internalpb.QueryNodeStats
}
// interface implementation validation
var _ TsMsg = &QueryNodeStatsMsg{}
// TraceCtx returns the context of opentracing
func (qs *QueryNodeStatsMsg) TraceCtx() context.Context {
return qs.BaseMsg.Ctx
}
// SetTraceCtx is used to set context for opentracing
func (qs *QueryNodeStatsMsg) SetTraceCtx(ctx context.Context) {
qs.BaseMsg.Ctx = ctx
}
// ID returns the ID of this message pack
func (qs *QueryNodeStatsMsg) ID() UniqueID {
return qs.Base.MsgID
}
// Type returns the type of this message pack
func (qs *QueryNodeStatsMsg) Type() MsgType {
return qs.Base.MsgType
}
// SourceID indicates which component generated this message
func (qs *QueryNodeStatsMsg) SourceID() int64 {
return qs.Base.SourceID
}
// Marshal is used to serializing a message pack to byte array
func (qs *QueryNodeStatsMsg) Marshal(input TsMsg) (MarshalType, error) {
queryNodeSegStatsTask := input.(*QueryNodeStatsMsg)
queryNodeSegStats := &queryNodeSegStatsTask.QueryNodeStats
mb, err := proto.Marshal(queryNodeSegStats)
if err != nil {
return nil, err
}
return mb, nil
}
// Unmarshal is used to deserializing a message pack from byte array
func (qs *QueryNodeStatsMsg) Unmarshal(input MarshalType) (TsMsg, error) {
queryNodeSegStats := internalpb.QueryNodeStats{}
in, err := convertToByteArray(input)
if err != nil {
return nil, err
}
err = proto.Unmarshal(in, &queryNodeSegStats)
if err != nil {
return nil, err
}
queryNodeSegStatsMsg := &QueryNodeStatsMsg{QueryNodeStats: queryNodeSegStats}
return queryNodeSegStatsMsg, nil
}
/////////////////////////////////////////CreateCollection//////////////////////////////////////////
// CreateCollectionMsg is a message pack that contains create collection request

45
internal/mq/msgstream/msg_test.go
View File

@ -597,51 +597,6 @@ func TestTimeTickMsg_Unmarshal_IllegalParameter(t *testing.T) {
assert.Nil(t, tsMsg)
}
func TestQueryNodeStatsMsg(t *testing.T) {
queryNodeStatsMsg := &QueryNodeStatsMsg{
BaseMsg: generateBaseMsg(),
QueryNodeStats: internalpb.QueryNodeStats{
Base: &commonpb.MsgBase{
MsgType: commonpb.MsgType_TimeTick,
MsgID: 1,
Timestamp: 2,
SourceID: 3,
},
SegStats: []*internalpb.SegmentStats{},
FieldStats: []*internalpb.FieldStats{},
},
}
assert.NotNil(t, queryNodeStatsMsg.TraceCtx())
ctx := context.Background()
queryNodeStatsMsg.SetTraceCtx(ctx)
assert.Equal(t, ctx, queryNodeStatsMsg.TraceCtx())
assert.Equal(t, int64(1), queryNodeStatsMsg.ID())
assert.Equal(t, commonpb.MsgType_TimeTick, queryNodeStatsMsg.Type())
assert.Equal(t, int64(3), queryNodeStatsMsg.SourceID())
bytes, err := queryNodeStatsMsg.Marshal(queryNodeStatsMsg)
assert.Nil(t, err)
tsMsg, err := queryNodeStatsMsg.Unmarshal(bytes)
assert.Nil(t, err)
queryNodeStatsMsg2, ok := tsMsg.(*QueryNodeStatsMsg)
assert.True(t, ok)
assert.Equal(t, int64(1), queryNodeStatsMsg2.ID())
assert.Equal(t, commonpb.MsgType_TimeTick, queryNodeStatsMsg2.Type())
assert.Equal(t, int64(3), queryNodeStatsMsg2.SourceID())
}
func TestQueryNodeStatsMsg_Unmarshal_IllegalParameter(t *testing.T) {
queryNodeStatsMsg := &QueryNodeStatsMsg{}
tsMsg, err := queryNodeStatsMsg.Unmarshal(10)
assert.NotNil(t, err)
assert.Nil(t, tsMsg)
}
func TestCreateCollectionMsg(t *testing.T) {
createCollectionMsg := &CreateCollectionMsg{
BaseMsg: generateBaseMsg(),

1
internal/mq/msgstream/trace.go
View File

@ -93,7 +93,6 @@ func allowTrace(in interface{}) bool {
switch res := in.(type) {
case TsMsg:
return !(res.Type() == commonpb.MsgType_TimeTick ||
res.Type() == commonpb.MsgType_QueryNodeStats ||
res.Type() == commonpb.MsgType_LoadIndex)
default:
return false

2
internal/mq/msgstream/unmarshal.go
View File

@ -65,7 +65,6 @@ func (pudf *ProtoUDFactory) NewUnmarshalDispatcher() *ProtoUnmarshalDispatcher {
dropCollectionMsg := DropCollectionMsg{}
createPartitionMsg := CreatePartitionMsg{}
dropPartitionMsg := DropPartitionMsg{}
queryNodeSegStatsMsg := QueryNodeStatsMsg{}
dataNodeTtMsg := DataNodeTtMsg{}
sealedSegmentsChangeInfoMsg := SealedSegmentsChangeInfoMsg{}
@ -78,7 +77,6 @@ func (pudf *ProtoUDFactory) NewUnmarshalDispatcher() *ProtoUnmarshalDispatcher {
p.TempMap[commonpb.MsgType_Retrieve] = retrieveMsg.Unmarshal
p.TempMap[commonpb.MsgType_RetrieveResult] = retrieveResultMsg.Unmarshal
p.TempMap[commonpb.MsgType_TimeTick] = timeTickMsg.Unmarshal
p.TempMap[commonpb.MsgType_QueryNodeStats] = queryNodeSegStatsMsg.Unmarshal
p.TempMap[commonpb.MsgType_CreateCollection] = createCollectionMsg.Unmarshal
p.TempMap[commonpb.MsgType_DropCollection] = dropCollectionMsg.Unmarshal
p.TempMap[commonpb.MsgType_CreatePartition] = createPartitionMsg.Unmarshal

6
internal/proto/internal.proto
View File

@ -255,12 +255,6 @@ message SegmentStats {
bool recently_modified = 4;
}
message QueryNodeStats {
common.MsgBase base = 1;
repeated SegmentStats seg_stats = 2;
repeated FieldStats field_stats = 3;
}
message MsgPosition {
string channel_name = 1;
bytes msgID = 2;

333
internal/proto/internalpb/internal.pb.go
View File

@ -2148,61 +2148,6 @@ func (m *SegmentStats) GetRecentlyModified() bool {
return false
}
type QueryNodeStats struct {
Base *commonpb.MsgBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
SegStats []*SegmentStats `protobuf:"bytes,2,rep,name=seg_stats,json=segStats,proto3" json:"seg_stats,omitempty"`
FieldStats []*FieldStats `protobuf:"bytes,3,rep,name=field_stats,json=fieldStats,proto3" json:"field_stats,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *QueryNodeStats) Reset() { *m = QueryNodeStats{} }
func (m *QueryNodeStats) String() string { return proto.CompactTextString(m) }
func (*QueryNodeStats) ProtoMessage() {}
func (*QueryNodeStats) Descriptor() ([]byte, []int) {
return fileDescriptor_41f4a519b878ee3b, []int{28}
}
func (m *QueryNodeStats) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_QueryNodeStats.Unmarshal(m, b)
}
func (m *QueryNodeStats) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_QueryNodeStats.Marshal(b, m, deterministic)
}
func (m *QueryNodeStats) XXX_Merge(src proto.Message) {
xxx_messageInfo_QueryNodeStats.Merge(m, src)
}
func (m *QueryNodeStats) XXX_Size() int {
return xxx_messageInfo_QueryNodeStats.Size(m)
}
func (m *QueryNodeStats) XXX_DiscardUnknown() {
xxx_messageInfo_QueryNodeStats.DiscardUnknown(m)
}
var xxx_messageInfo_QueryNodeStats proto.InternalMessageInfo
func (m *QueryNodeStats) GetBase() *commonpb.MsgBase {
if m != nil {
return m.Base
}
return nil
}
func (m *QueryNodeStats) GetSegStats() []*SegmentStats {
if m != nil {
return m.SegStats
}
return nil
}
func (m *QueryNodeStats) GetFieldStats() []*FieldStats {
if m != nil {
return m.FieldStats
}
return nil
}
type MsgPosition struct {
ChannelName string `protobuf:"bytes,1,opt,name=channel_name,json=channelName,proto3" json:"channel_name,omitempty"`
MsgID []byte `protobuf:"bytes,2,opt,name=msgID,proto3" json:"msgID,omitempty"`
@ -2217,7 +2162,7 @@ func (m *MsgPosition) Reset() { *m = MsgPosition{} }
func (m *MsgPosition) String() string { return proto.CompactTextString(m) }
func (*MsgPosition) ProtoMessage() {}
func (*MsgPosition) Descriptor() ([]byte, []int) {
return fileDescriptor_41f4a519b878ee3b, []int{29}
return fileDescriptor_41f4a519b878ee3b, []int{28}
}
func (m *MsgPosition) XXX_Unmarshal(b []byte) error {
@ -2280,7 +2225,7 @@ func (m *ChannelTimeTickMsg) Reset() { *m = ChannelTimeTickMsg{} }
func (m *ChannelTimeTickMsg) String() string { return proto.CompactTextString(m) }
func (*ChannelTimeTickMsg) ProtoMessage() {}
func (*ChannelTimeTickMsg) Descriptor() ([]byte, []int) {
return fileDescriptor_41f4a519b878ee3b, []int{30}
return fileDescriptor_41f4a519b878ee3b, []int{29}
}
func (m *ChannelTimeTickMsg) XXX_Unmarshal(b []byte) error {
@ -2346,7 +2291,7 @@ func (m *CredentialInfo) Reset() { *m = CredentialInfo{} }
func (m *CredentialInfo) String() string { return proto.CompactTextString(m) }
func (*CredentialInfo) ProtoMessage() {}
func (*CredentialInfo) Descriptor() ([]byte, []int) {
return fileDescriptor_41f4a519b878ee3b, []int{31}
return fileDescriptor_41f4a519b878ee3b, []int{30}
}
func (m *CredentialInfo) XXX_Unmarshal(b []byte) error {
@ -2414,7 +2359,7 @@ func (m *ListPolicyRequest) Reset() { *m = ListPolicyRequest{} }
func (m *ListPolicyRequest) String() string { return proto.CompactTextString(m) }
func (*ListPolicyRequest) ProtoMessage() {}
func (*ListPolicyRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_41f4a519b878ee3b, []int{32}
return fileDescriptor_41f4a519b878ee3b, []int{31}
}
func (m *ListPolicyRequest) XXX_Unmarshal(b []byte) error {
@ -2455,7 +2400,7 @@ func (m *ListPolicyResponse) Reset() { *m = ListPolicyResponse{} }
func (m *ListPolicyResponse) String() string { return proto.CompactTextString(m) }
func (*ListPolicyResponse) ProtoMessage() {}
func (*ListPolicyResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_41f4a519b878ee3b, []int{33}
return fileDescriptor_41f4a519b878ee3b, []int{32}
}
func (m *ListPolicyResponse) XXX_Unmarshal(b []byte) error {
@ -2521,7 +2466,6 @@ func init() {
proto.RegisterType((*IndexStats)(nil), "milvus.proto.internal.IndexStats")
proto.RegisterType((*FieldStats)(nil), "milvus.proto.internal.FieldStats")
proto.RegisterType((*SegmentStats)(nil), "milvus.proto.internal.SegmentStats")
proto.RegisterType((*QueryNodeStats)(nil), "milvus.proto.internal.QueryNodeStats")
proto.RegisterType((*MsgPosition)(nil), "milvus.proto.internal.MsgPosition")
proto.RegisterType((*ChannelTimeTickMsg)(nil), "milvus.proto.internal.ChannelTimeTickMsg")
proto.RegisterType((*CredentialInfo)(nil), "milvus.proto.internal.CredentialInfo")
@ -2532,139 +2476,136 @@ func init() {
func init() { proto.RegisterFile("internal.proto", fileDescriptor_41f4a519b878ee3b) }
var fileDescriptor_41f4a519b878ee3b = []byte{
// 2136 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x59, 0xcf, 0x73, 0x1b, 0x49,
0xf5, 0xdf, 0xd1, 0xc8, 0x96, 0xf4, 0x24, 0xcb, 0x72, 0xc7, 0xc9, 0x4e, 0x7e, 0xec, 0xae, 0x33,
0xbb, 0xdf, 0x2f, 0x26, 0x61, 0x93, 0xe0, 0xdd, 0xcd, 0x6e, 0x01, 0x45, 0x36, 0xb6, 0x96, 0xa0,
0xca, 0x0f, 0xcc, 0x38, 0xa4, 0x0a, 0x2e, 0x53, 0x2d, 0x4d, 0x5b, 0x6e, 0x32, 0x33, 0x3d, 0xee,
0xee, 0xb1, 0xa3, 0x9c, 0x38, 0x70, 0x82, 0x82, 0x1b, 0x17, 0xaa, 0xe0, 0xcc, 0x7f, 0xc0, 0x0d,
0xaa, 0x38, 0xed, 0x89, 0x13, 0x17, 0xfe, 0x15, 0x8a, 0x03, 0xd5, 0x3f, 0x46, 0x1a, 0xc9, 0xb2,
0x63, 0x7b, 0x6b, 0xd9, 0x50, 0xb5, 0xb7, 0xe9, 0xf7, 0x5e, 0x77, 0xbf, 0x1f, 0x9f, 0xf7, 0xfa,
0x3d, 0x09, 0xda, 0x34, 0x95, 0x84, 0xa7, 0x38, 0xbe, 0x95, 0x71, 0x26, 0x19, 0xba, 0x98, 0xd0,
0xf8, 0x20, 0x17, 0x66, 0x75, 0xab, 0x60, 0x5e, 0x69, 0x0d, 0x58, 0x92, 0xb0, 0xd4, 0x90, 0xaf,
0xb4, 0xc4, 0x60, 0x8f, 0x24, 0xd8, 0xac, 0xfc, 0xbf, 0x38, 0xb0, 0xb4, 0xc5, 0x92, 0x8c, 0xa5,
0x24, 0x95, 0xbd, 0x74, 0x97, 0xa1, 0x4b, 0xb0, 0x98, 0xb2, 0x88, 0xf4, 0xba, 0x9e, 0xb3, 0xe6,
0xac, 0xbb, 0x81, 0x5d, 0x21, 0x04, 0x55, 0xce, 0x62, 0xe2, 0x55, 0xd6, 0x9c, 0xf5, 0x46, 0xa0,
0xbf, 0xd1, 0x3d, 0x00, 0x21, 0xb1, 0x24, 0xe1, 0x80, 0x45, 0xc4, 0x73, 0xd7, 0x9c, 0xf5, 0xf6,
0xc6, 0xda, 0xad, 0xb9, 0x5a, 0xdc, 0xda, 0x51, 0x82, 0x5b, 0x2c, 0x22, 0x41, 0x43, 0x14, 0x9f,
0xe8, 0x53, 0x00, 0xf2, 0x42, 0x72, 0x1c, 0xd2, 0x74, 0x97, 0x79, 0xd5, 0x35, 0x77, 0xbd, 0xb9,
0x71, 0x7d, 0xfa, 0x00, 0xab, 0xfc, 0x43, 0x32, 0x7a, 0x86, 0xe3, 0x9c, 0x6c, 0x63, 0xca, 0x83,
0x86, 0xde, 0xa4, 0xd4, 0xf5, 0xff, 0xe9, 0xc0, 0xf2, 0xd8, 0x00, 0x7d, 0x87, 0x40, 0xdf, 0x81,
0x05, 0x7d, 0x85, 0xb6, 0xa0, 0xb9, 0xf1, 0xde, 0x31, 0x1a, 0x4d, 0xd9, 0x1d, 0x98, 0x2d, 0xe8,
0x27, 0x70, 0x41, 0xe4, 0xfd, 0x41, 0xc1, 0x0a, 0x35, 0x55, 0x78, 0x15, 0xad, 0xda, 0xe9, 0x4e,
0x42, 0xe5, 0x03, 0xac, 0x4a, 0x1f, 0xc0, 0xa2, 0x3a, 0x29, 0x17, 0xda, 0x4b, 0xcd, 0x8d, 0xab,
0x73, 0x8d, 0xdc, 0xd1, 0x22, 0x81, 0x15, 0xf5, 0xaf, 0xc2, 0xe5, 0x07, 0x44, 0xce, 0x58, 0x17,
0x90, 0xfd, 0x9c, 0x08, 0x69, 0x99, 0x4f, 0x69, 0x42, 0x9e, 0xd2, 0xc1, 0xf3, 0xad, 0x3d, 0x9c,
0xa6, 0x24, 0x2e, 0x98, 0x6f, 0xc1, 0xd5, 0x07, 0x44, 0x6f, 0xa0, 0x42, 0xd2, 0x81, 0x98, 0x61,
0x5f, 0x84, 0x0b, 0x0f, 0x88, 0xec, 0x46, 0x33, 0xe4, 0x67, 0x50, 0x7f, 0xa2, 0x82, 0xad, 0x60,
0x70, 0x17, 0x6a, 0x38, 0x8a, 0x38, 0x11, 0xc2, 0x7a, 0xf1, 0xda, 0x5c, 0x8d, 0xef, 0x1b, 0x99,
0xa0, 0x10, 0x9e, 0x07, 0x13, 0xff, 0xe7, 0x00, 0xbd, 0x94, 0xca, 0x6d, 0xcc, 0x71, 0x22, 0x8e,
0x05, 0x58, 0x17, 0x5a, 0x42, 0x62, 0x2e, 0xc3, 0x4c, 0xcb, 0x59, 0x97, 0x9f, 0x02, 0x0d, 0x4d,
0xbd, 0xcd, 0x9c, 0xee, 0xff, 0x14, 0x60, 0x47, 0x72, 0x9a, 0x0e, 0x1f, 0x51, 0x21, 0xd5, 0x5d,
0x07, 0x4a, 0x4e, 0x19, 0xe1, 0xae, 0x37, 0x02, 0xbb, 0x2a, 0x85, 0xa3, 0x72, 0xfa, 0x70, 0xdc,
0x83, 0x66, 0xe1, 0xee, 0xc7, 0x62, 0x88, 0xee, 0x40, 0xb5, 0x8f, 0x05, 0x39, 0xd1, 0x3d, 0x8f,
0xc5, 0x70, 0x13, 0x0b, 0x12, 0x68, 0x49, 0xff, 0x57, 0x2e, 0xbc, 0xb9, 0xc5, 0x89, 0x06, 0x7f,
0x1c, 0x93, 0x81, 0xa4, 0x2c, 0xb5, 0xbe, 0x3f, 0xfb, 0x69, 0xe8, 0x4d, 0xa8, 0x45, 0xfd, 0x30,
0xc5, 0x49, 0xe1, 0xec, 0xc5, 0xa8, 0xff, 0x04, 0x27, 0x04, 0xfd, 0x3f, 0xb4, 0x07, 0xe3, 0xf3,
0x15, 0x45, 0x63, 0xae, 0x11, 0xcc, 0x50, 0xd1, 0x7b, 0xb0, 0x94, 0x61, 0x2e, 0xe9, 0x58, 0xac,
0xaa, 0xc5, 0xa6, 0x89, 0x2a, 0xa0, 0x51, 0xbf, 0xd7, 0xf5, 0x16, 0x74, 0xb0, 0xf4, 0x37, 0xf2,
0xa1, 0x35, 0x39, 0xab, 0xd7, 0xf5, 0x16, 0x35, 0x6f, 0x8a, 0x86, 0xd6, 0xa0, 0x39, 0x3e, 0xa8,
0xd7, 0xf5, 0x6a, 0x5a, 0xa4, 0x4c, 0x52, 0xc1, 0x31, 0xb5, 0xc8, 0xab, 0xaf, 0x39, 0xeb, 0xad,
0xc0, 0xae, 0xd0, 0x1d, 0xb8, 0x70, 0x40, 0xb9, 0xcc, 0x71, 0x6c, 0xf1, 0xa9, 0xf4, 0x10, 0x5e,
0x43, 0x47, 0x70, 0x1e, 0x0b, 0x6d, 0xc0, 0x6a, 0xb6, 0x37, 0x12, 0x74, 0x30, 0xb3, 0x05, 0xf4,
0x96, 0xb9, 0x3c, 0xff, 0x6f, 0x0e, 0x5c, 0xec, 0x72, 0x96, 0xbd, 0x16, 0xa1, 0x28, 0x9c, 0x5c,
0x3d, 0xc1, 0xc9, 0x0b, 0x47, 0x9d, 0xec, 0xff, 0xa6, 0x02, 0x97, 0x0c, 0xa2, 0xb6, 0x0b, 0xc7,
0x7e, 0x09, 0x56, 0x7c, 0x03, 0x96, 0x27, 0xb7, 0x1a, 0x81, 0xf9, 0x66, 0xfc, 0x1f, 0xb4, 0xc7,
0x01, 0x36, 0x72, 0xff, 0x5d, 0x48, 0xf9, 0xbf, 0xae, 0xc0, 0xaa, 0x0a, 0xea, 0xd7, 0xde, 0x50,
0xde, 0xf8, 0xa3, 0x03, 0xc8, 0xa0, 0xe3, 0x7e, 0x4c, 0xb1, 0xf8, 0x2a, 0x7d, 0xb1, 0x0a, 0x0b,
0x58, 0xe9, 0x60, 0x5d, 0x60, 0x16, 0xbe, 0x80, 0x8e, 0x8a, 0xd6, 0x97, 0xa5, 0xdd, 0xf8, 0x52,
0xb7, 0x7c, 0xe9, 0x1f, 0x1c, 0x58, 0xb9, 0x1f, 0x4b, 0xc2, 0x5f, 0x53, 0xa7, 0xfc, 0xb5, 0x52,
0x44, 0xad, 0x97, 0x46, 0xe4, 0xc5, 0x57, 0xa9, 0xe0, 0x5b, 0x00, 0xbb, 0x94, 0xc4, 0x51, 0x19,
0xbd, 0x0d, 0x4d, 0xf9, 0x42, 0xc8, 0xf5, 0xa0, 0xa6, 0x0f, 0x19, 0xa3, 0xb6, 0x58, 0xaa, 0x1e,
0xc0, 0xf4, 0x83, 0xb6, 0x07, 0xa8, 0x9f, 0xba, 0x07, 0xd0, 0xdb, 0x6c, 0x0f, 0xf0, 0xf7, 0x2a,
0x2c, 0xf5, 0x52, 0x41, 0xb8, 0x3c, 0xbf, 0xf3, 0xae, 0x41, 0x43, 0xec, 0x61, 0xae, 0x0d, 0xb5,
0xee, 0x9b, 0x10, 0xca, 0xae, 0x75, 0x5f, 0xe5, 0xda, 0xea, 0x29, 0x8b, 0xc3, 0xc2, 0x49, 0xc5,
0x61, 0xf1, 0x04, 0x17, 0xd7, 0x5e, 0x5d, 0x1c, 0xea, 0x47, 0x5f, 0x5f, 0x65, 0x20, 0x19, 0x26,
0xaa, 0x69, 0xed, 0x7a, 0x0d, 0xcd, 0x9f, 0x10, 0xd0, 0xdb, 0x00, 0x92, 0x26, 0x44, 0x48, 0x9c,
0x64, 0xe6, 0x1d, 0xad, 0x06, 0x25, 0x8a, 0x7a, 0xbb, 0x39, 0x3b, 0xec, 0x75, 0x85, 0xd7, 0x5c,
0x73, 0x55, 0x13, 0x67, 0x56, 0xe8, 0x43, 0xa8, 0x73, 0x76, 0x18, 0x46, 0x58, 0x62, 0xaf, 0xa5,
0x83, 0x77, 0x79, 0xae, 0xb3, 0x37, 0x63, 0xd6, 0x0f, 0x6a, 0x9c, 0x1d, 0x76, 0xb1, 0xc4, 0xe8,
0x1e, 0x34, 0x35, 0x02, 0x84, 0xd9, 0xb8, 0xa4, 0x37, 0xbe, 0x3d, 0xbd, 0xd1, 0x8e, 0x2d, 0x3f,
0x50, 0x72, 0x6a, 0x53, 0x60, 0xa0, 0x29, 0xf4, 0x01, 0x97, 0xa1, 0x9e, 0xe6, 0x49, 0xc8, 0xd9,
0xa1, 0xf0, 0xda, 0x6b, 0xce, 0x7a, 0x35, 0xa8, 0xa5, 0x79, 0x12, 0xb0, 0x43, 0x81, 0x36, 0xa1,
0x76, 0x40, 0xb8, 0xa0, 0x2c, 0xf5, 0x96, 0xf5, 0x80, 0xb2, 0x7e, 0x4c, 0x13, 0x6f, 0x10, 0xa3,
0x8e, 0x7b, 0x66, 0xe4, 0x83, 0x62, 0xa3, 0xff, 0x8f, 0x2a, 0x2c, 0xed, 0x10, 0xcc, 0x07, 0x7b,
0xe7, 0x07, 0xd4, 0x2a, 0x2c, 0x70, 0xb2, 0xdf, 0xeb, 0x6a, 0x30, 0xb9, 0x81, 0x59, 0x8c, 0xe3,
0xeb, 0x9e, 0x10, 0xdf, 0xea, 0x9c, 0xf8, 0xfa, 0xd0, 0x2a, 0x05, 0x53, 0x78, 0x0b, 0x3a, 0x0a,
0x53, 0x34, 0xd4, 0x01, 0x37, 0x12, 0xb1, 0x86, 0x4e, 0x23, 0x50, 0x9f, 0xe8, 0x26, 0xac, 0x64,
0x31, 0x1e, 0x90, 0x3d, 0x16, 0x47, 0x84, 0x87, 0x43, 0xce, 0xf2, 0x4c, 0xc3, 0xa7, 0x15, 0x74,
0x4a, 0x8c, 0x07, 0x8a, 0x8e, 0x3e, 0x86, 0x7a, 0x24, 0xe2, 0x50, 0x8e, 0x32, 0xa2, 0xf1, 0xd3,
0x3e, 0xc6, 0xcc, 0xae, 0x88, 0x9f, 0x8e, 0x32, 0x12, 0xd4, 0x22, 0xf3, 0x81, 0xee, 0xc0, 0xaa,
0x20, 0x9c, 0xe2, 0x98, 0xbe, 0x24, 0x51, 0x48, 0x5e, 0x64, 0x3c, 0xcc, 0x62, 0x9c, 0x6a, 0x90,
0xb5, 0x02, 0x34, 0xe1, 0x7d, 0xf6, 0x22, 0xe3, 0xdb, 0x31, 0x4e, 0xd1, 0x3a, 0x74, 0x58, 0x2e,
0xb3, 0x5c, 0x86, 0x16, 0x06, 0x34, 0xd2, 0x98, 0x73, 0x83, 0xb6, 0xa1, 0xeb, 0xa8, 0x8b, 0x5e,
0x84, 0xbe, 0x09, 0x1d, 0xc9, 0xf1, 0x01, 0x89, 0xc3, 0x31, 0x18, 0xbd, 0xa6, 0x0e, 0xf8, 0xb2,
0xa1, 0x3f, 0x2d, 0xc8, 0xe8, 0x36, 0x5c, 0x18, 0xe6, 0x98, 0xe3, 0x54, 0x12, 0x52, 0x92, 0x6e,
0x69, 0x69, 0x34, 0x66, 0x4d, 0x36, 0xdc, 0x84, 0x15, 0x25, 0xc6, 0x72, 0x59, 0x12, 0x5f, 0xd2,
0xe2, 0x1d, 0xcb, 0x98, 0x08, 0xb7, 0xa1, 0x92, 0xee, 0x6b, 0xac, 0xb9, 0x41, 0x25, 0xdd, 0x57,
0x81, 0x94, 0x2c, 0x7b, 0xae, 0x31, 0xe6, 0x06, 0xfa, 0x5b, 0x25, 0x51, 0x42, 0x24, 0xa7, 0x03,
0xe5, 0x16, 0xaf, 0xa3, 0xe3, 0x50, 0xa2, 0xf8, 0xff, 0x76, 0x27, 0xb0, 0x12, 0x79, 0x2c, 0xc5,
0x39, 0x60, 0x75, 0x9e, 0x49, 0x66, 0x82, 0x45, 0xb7, 0x8c, 0xc5, 0x77, 0xa0, 0x69, 0x94, 0x33,
0x31, 0xaf, 0xce, 0xea, 0xab, 0x04, 0x54, 0x96, 0xed, 0xe7, 0x84, 0x53, 0x22, 0x6c, 0xd9, 0x87,
0x34, 0x4f, 0x7e, 0x6c, 0x28, 0xe8, 0x02, 0x2c, 0x48, 0x96, 0x85, 0xcf, 0x8b, 0x72, 0x25, 0x59,
0xf6, 0x10, 0x7d, 0x0f, 0xae, 0x08, 0x82, 0x63, 0x12, 0x85, 0xe3, 0xf2, 0x22, 0x42, 0xa1, 0xcd,
0x26, 0x91, 0x57, 0xd3, 0x61, 0xf6, 0x8c, 0xc4, 0xce, 0x58, 0x60, 0xc7, 0xf2, 0x55, 0x14, 0x07,
0xa6, 0x6d, 0x9f, 0xda, 0x56, 0xd7, 0x9d, 0x3d, 0x9a, 0xb0, 0xc6, 0x1b, 0x3e, 0x01, 0x6f, 0x18,
0xb3, 0x3e, 0x8e, 0xc3, 0x23, 0xb7, 0xea, 0x11, 0xc2, 0x0d, 0x2e, 0x19, 0xfe, 0xce, 0xcc, 0x95,
0xca, 0x3c, 0x11, 0xd3, 0x01, 0x89, 0xc2, 0x7e, 0xcc, 0xfa, 0x1e, 0x68, 0xb8, 0x82, 0x21, 0xa9,
0x7a, 0xa5, 0x60, 0x6a, 0x05, 0x94, 0x1b, 0x06, 0x2c, 0x4f, 0xa5, 0x06, 0x9f, 0x1b, 0xb4, 0x0d,
0xfd, 0x49, 0x9e, 0x6c, 0x29, 0x2a, 0x7a, 0x17, 0x96, 0xac, 0x24, 0xdb, 0xdd, 0x15, 0x44, 0x6a,
0xd4, 0xb9, 0x41, 0xcb, 0x10, 0x7f, 0xa4, 0x69, 0xfe, 0xef, 0x5d, 0x58, 0x0e, 0x94, 0x77, 0xc9,
0x01, 0xf9, 0x5f, 0xaa, 0x2b, 0xc7, 0xe5, 0xf7, 0xe2, 0x99, 0xf2, 0xbb, 0x76, 0xea, 0xfc, 0xae,
0x9f, 0x29, 0xbf, 0x1b, 0x67, 0xcb, 0x6f, 0x98, 0x9f, 0xdf, 0xfe, 0x9f, 0xa6, 0x82, 0xf3, 0x1a,
0x64, 0xe7, 0x0d, 0x70, 0x69, 0x64, 0x5a, 0xc5, 0xe6, 0x86, 0x37, 0xf7, 0x6d, 0xec, 0x75, 0x45,
0xa0, 0x84, 0x66, 0xdf, 0xd3, 0x85, 0x33, 0xbf, 0xa7, 0xdf, 0x87, 0xab, 0x47, 0x73, 0x96, 0x5b,
0x77, 0x44, 0xde, 0xa2, 0x8e, 0xdd, 0xe5, 0xd9, 0xa4, 0x2d, 0xfc, 0x15, 0xa1, 0x6f, 0xc3, 0x6a,
0x29, 0x6b, 0x27, 0x1b, 0x6b, 0x66, 0x86, 0x9f, 0xf0, 0x26, 0x5b, 0x4e, 0xca, 0xdb, 0xfa, 0x49,
0x79, 0xeb, 0x7f, 0xee, 0xc2, 0x52, 0x97, 0xc4, 0x44, 0x92, 0xaf, 0xdb, 0xbd, 0x63, 0xdb, 0xbd,
0x6f, 0x01, 0xa2, 0xa9, 0xbc, 0xfb, 0x61, 0x98, 0x71, 0x9a, 0x60, 0x3e, 0x0a, 0x9f, 0x93, 0x51,
0x51, 0x10, 0x3b, 0x9a, 0xb3, 0x6d, 0x18, 0x0f, 0xc9, 0x48, 0xbc, 0xb2, 0xfd, 0x2b, 0xf7, 0x5b,
0xa6, 0x02, 0x8e, 0xfb, 0xad, 0xef, 0x42, 0x6b, 0xea, 0x8a, 0xd6, 0x2b, 0x00, 0xdb, 0xcc, 0x26,
0xf7, 0xfa, 0xff, 0x72, 0xa0, 0xf1, 0x88, 0xe1, 0x48, 0x4f, 0x3e, 0xe7, 0x0c, 0xe3, 0xb8, 0xa9,
0xad, 0xcc, 0x36, 0xb5, 0xd7, 0x60, 0x32, 0xbc, 0xd8, 0x40, 0x96, 0xa6, 0x99, 0xd2, 0x54, 0x52,
0x9d, 0x9e, 0x4a, 0xde, 0x81, 0x26, 0x55, 0x0a, 0x85, 0x19, 0x96, 0x7b, 0xa6, 0x26, 0x36, 0x02,
0xd0, 0xa4, 0x6d, 0x45, 0x51, 0x63, 0x4b, 0x21, 0xa0, 0xc7, 0x96, 0xc5, 0x53, 0x8f, 0x2d, 0xf6,
0x10, 0x3d, 0xb6, 0xfc, 0xd2, 0x01, 0xd0, 0x86, 0xab, 0x7a, 0x70, 0xf4, 0x50, 0xe7, 0x3c, 0x87,
0xaa, 0x62, 0xad, 0x23, 0x45, 0x62, 0x2c, 0x27, 0x49, 0x25, 0xac, 0x73, 0x90, 0x8a, 0x9a, 0x61,
0xd9, 0x84, 0x12, 0xfe, 0x6f, 0x1d, 0x00, 0x5d, 0x15, 0x8c, 0x1a, 0xb3, 0xf0, 0x73, 0x4e, 0x1e,
0xe8, 0x2a, 0xd3, 0xae, 0xdb, 0x2c, 0x5c, 0xa7, 0x6a, 0x9b, 0x1a, 0xc4, 0xe7, 0xd8, 0x50, 0xea,
0xc0, 0x0b, 0xe3, 0xad, 0x77, 0xf5, 0xb7, 0xff, 0x3b, 0x07, 0x5a, 0x56, 0x3b, 0xa3, 0xd2, 0x54,
0x94, 0x9d, 0xd9, 0x28, 0xeb, 0x36, 0x26, 0x61, 0x7c, 0x14, 0x0a, 0xfa, 0x92, 0x58, 0x85, 0xc0,
0x90, 0x76, 0xe8, 0x4b, 0x32, 0x05, 0x5e, 0x77, 0x1a, 0xbc, 0x37, 0x61, 0x85, 0x93, 0x01, 0x49,
0x65, 0x3c, 0x0a, 0x13, 0x16, 0xd1, 0x5d, 0x4a, 0x22, 0x8d, 0x86, 0x7a, 0xd0, 0x29, 0x18, 0x8f,
0x2d, 0xdd, 0xff, 0xdc, 0x81, 0xb6, 0xea, 0x7c, 0x46, 0x4f, 0x58, 0x44, 0x8c, 0x66, 0x67, 0x47,
0xec, 0xa7, 0xda, 0x16, 0xeb, 0x1e, 0xf3, 0x93, 0xf7, 0xbb, 0xc7, 0xfd, 0x83, 0x52, 0xf2, 0x41,
0x50, 0x17, 0x64, 0x68, 0xee, 0xdc, 0xb4, 0xc5, 0xfe, 0x54, 0x2e, 0x9e, 0x04, 0xd6, 0xd6, 0x7b,
0xe3, 0xe2, 0x5f, 0x38, 0xd0, 0x7c, 0x2c, 0x86, 0xdb, 0x4c, 0xe8, 0x7a, 0x81, 0xae, 0x43, 0xcb,
0xd6, 0x68, 0x53, 0xac, 0x1c, 0x9d, 0x2c, 0xcd, 0xc1, 0xe4, 0x07, 0x54, 0xf5, 0x4a, 0x25, 0x62,
0x68, 0x23, 0xde, 0x0a, 0xcc, 0x02, 0x5d, 0x81, 0x7a, 0x22, 0x86, 0x7a, 0x80, 0xb0, 0x19, 0x36,
0x5e, 0xab, 0xb0, 0x4d, 0xde, 0xdd, 0xaa, 0x7e, 0x77, 0x27, 0x04, 0xff, 0xcf, 0x0e, 0x20, 0xfb,
0x03, 0xed, 0x17, 0xfa, 0x95, 0x5d, 0x03, 0xb6, 0xfc, 0x23, 0x70, 0x45, 0xa7, 0xeb, 0x14, 0x6d,
0xa6, 0xbe, 0xb9, 0x47, 0xea, 0xdb, 0x4d, 0x58, 0x89, 0xc8, 0x2e, 0xce, 0xe3, 0x72, 0xab, 0x60,
0x54, 0xee, 0x58, 0xc6, 0xd3, 0xb2, 0xe6, 0xed, 0x2d, 0x4e, 0x22, 0x92, 0x4a, 0x8a, 0x63, 0xfd,
0xef, 0xc9, 0x15, 0xa8, 0xe7, 0x42, 0x79, 0x7c, 0xec, 0xbb, 0xf1, 0x1a, 0xbd, 0x0f, 0x88, 0xa4,
0x03, 0x3e, 0xca, 0x54, 0x3e, 0x66, 0x58, 0x88, 0x43, 0xc6, 0x23, 0xfb, 0xe6, 0xac, 0x8c, 0x39,
0xdb, 0x96, 0xa1, 0x26, 0x6d, 0x49, 0x52, 0x9c, 0xca, 0xe2, 0xe9, 0x31, 0x2b, 0x85, 0x62, 0x2a,
0x42, 0x91, 0x67, 0x84, 0x5b, 0x84, 0xd6, 0xa8, 0xd8, 0x51, 0x4b, 0xf5, 0x2a, 0x89, 0x3d, 0xbc,
0xf1, 0xd1, 0xdd, 0xc9, 0xf1, 0xe6, 0xb5, 0x69, 0x1b, 0x72, 0x71, 0xb6, 0xff, 0x19, 0xac, 0x3c,
0xa2, 0x42, 0x6e, 0xb3, 0x98, 0x0e, 0x46, 0xe7, 0x7e, 0x3c, 0xfd, 0x18, 0x50, 0xf9, 0x18, 0x91,
0xb1, 0x74, 0xaa, 0xf7, 0x71, 0x4e, 0xdf, 0xfb, 0x5c, 0x87, 0x56, 0xa6, 0x8f, 0xd1, 0xff, 0x08,
0x16, 0xc1, 0x6b, 0x1a, 0x9a, 0x72, 0xad, 0xb8, 0xf1, 0x09, 0x34, 0xc6, 0xff, 0x25, 0xa2, 0x0e,
0xb4, 0x7a, 0x29, 0x95, 0xba, 0xe1, 0xa4, 0xe9, 0xb0, 0xf3, 0x06, 0x6a, 0x42, 0xed, 0x87, 0x04,
0xc7, 0x72, 0x6f, 0xd4, 0x71, 0x50, 0x0b, 0xea, 0xf7, 0xfb, 0x29, 0xe3, 0x09, 0x8e, 0x3b, 0x95,
0x1b, 0x1b, 0xb0, 0x72, 0x64, 0xc8, 0x57, 0x22, 0x01, 0x3b, 0x54, 0xd6, 0x44, 0x9d, 0x37, 0xd0,
0x32, 0x34, 0xb7, 0x58, 0x9c, 0x27, 0xa9, 0x21, 0x38, 0x9b, 0x1f, 0xff, 0xec, 0xa3, 0x21, 0x95,
0x7b, 0x79, 0x5f, 0x29, 0x7c, 0xdb, 0x58, 0xf0, 0x3e, 0x65, 0xf6, 0xeb, 0x76, 0x91, 0x58, 0xb7,
0xb5, 0x51, 0xe3, 0x65, 0xd6, 0xef, 0x2f, 0x6a, 0xca, 0x07, 0xff, 0x09, 0x00, 0x00, 0xff, 0xff,
0xc0, 0xd0, 0xef, 0xbc, 0xa5, 0x1d, 0x00, 0x00,
// 2085 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x59, 0xcd, 0x73, 0x1b, 0x49,
0x15, 0xdf, 0xd1, 0xc8, 0x96, 0xf4, 0x24, 0xcb, 0x72, 0xc7, 0x9b, 0x9d, 0x7c, 0xec, 0xae, 0x33,
0x2c, 0x60, 0x12, 0x36, 0x09, 0xde, 0xdd, 0xec, 0x16, 0x50, 0x84, 0xc4, 0x5a, 0x82, 0x2a, 0x1f,
0x98, 0x71, 0x48, 0x15, 0x5c, 0xa6, 0x5a, 0x9a, 0xb6, 0xdc, 0x64, 0x66, 0x7a, 0xd2, 0xdd, 0x63,
0x47, 0x39, 0x71, 0xe0, 0x04, 0x05, 0x37, 0x2e, 0x54, 0xc1, 0x99, 0xff, 0x80, 0x1b, 0x54, 0x71,
0xe2, 0xc4, 0x89, 0x0b, 0xff, 0x0a, 0xc5, 0x81, 0xea, 0x8f, 0x19, 0x8d, 0x64, 0xd9, 0x71, 0xbc,
0xb5, 0x6c, 0xa8, 0xda, 0xdb, 0xf4, 0x7b, 0xaf, 0x5f, 0xbf, 0x8f, 0xdf, 0x7b, 0xfd, 0x5a, 0x82,
0x2e, 0x4d, 0x25, 0xe1, 0x29, 0x8e, 0xaf, 0x67, 0x9c, 0x49, 0x86, 0xde, 0x4c, 0x68, 0x7c, 0x90,
0x0b, 0xb3, 0xba, 0x5e, 0x30, 0x2f, 0x76, 0x46, 0x2c, 0x49, 0x58, 0x6a, 0xc8, 0x17, 0x3b, 0x62,
0xb4, 0x4f, 0x12, 0x6c, 0x56, 0xfe, 0x5f, 0x1c, 0x58, 0xd9, 0x66, 0x49, 0xc6, 0x52, 0x92, 0xca,
0x41, 0xba, 0xc7, 0xd0, 0x79, 0x58, 0x4e, 0x59, 0x44, 0x06, 0x7d, 0xcf, 0xd9, 0x70, 0x36, 0xdd,
0xc0, 0xae, 0x10, 0x82, 0x3a, 0x67, 0x31, 0xf1, 0x6a, 0x1b, 0xce, 0x66, 0x2b, 0xd0, 0xdf, 0xe8,
0x36, 0x80, 0x90, 0x58, 0x92, 0x70, 0xc4, 0x22, 0xe2, 0xb9, 0x1b, 0xce, 0x66, 0x77, 0x6b, 0xe3,
0xfa, 0x42, 0x2b, 0xae, 0xef, 0x2a, 0xc1, 0x6d, 0x16, 0x91, 0xa0, 0x25, 0x8a, 0x4f, 0xf4, 0x7d,
0x00, 0xf2, 0x5c, 0x72, 0x1c, 0xd2, 0x74, 0x8f, 0x79, 0xf5, 0x0d, 0x77, 0xb3, 0xbd, 0x75, 0x65,
0x56, 0x81, 0x35, 0xfe, 0x3e, 0x99, 0x3c, 0xc1, 0x71, 0x4e, 0x76, 0x30, 0xe5, 0x41, 0x4b, 0x6f,
0x52, 0xe6, 0xfa, 0xff, 0x72, 0x60, 0xb5, 0x74, 0x40, 0x9f, 0x21, 0xd0, 0xb7, 0x61, 0x49, 0x1f,
0xa1, 0x3d, 0x68, 0x6f, 0xbd, 0x77, 0x8c, 0x45, 0x33, 0x7e, 0x07, 0x66, 0x0b, 0xfa, 0x09, 0x9c,
0x13, 0xf9, 0x70, 0x54, 0xb0, 0x42, 0x4d, 0x15, 0x5e, 0x4d, 0x9b, 0x76, 0x3a, 0x4d, 0xa8, 0xaa,
0xc0, 0x9a, 0xf4, 0x01, 0x2c, 0x2b, 0x4d, 0xb9, 0xd0, 0x51, 0x6a, 0x6f, 0x5d, 0x5a, 0xe8, 0xe4,
0xae, 0x16, 0x09, 0xac, 0xa8, 0x7f, 0x09, 0x2e, 0xdc, 0x23, 0x72, 0xce, 0xbb, 0x80, 0x3c, 0xcb,
0x89, 0x90, 0x96, 0xf9, 0x98, 0x26, 0xe4, 0x31, 0x1d, 0x3d, 0xdd, 0xde, 0xc7, 0x69, 0x4a, 0xe2,
0x82, 0xf9, 0x36, 0x5c, 0xba, 0x47, 0xf4, 0x06, 0x2a, 0x24, 0x1d, 0x89, 0x39, 0xf6, 0x9b, 0x70,
0xee, 0x1e, 0x91, 0xfd, 0x68, 0x8e, 0xfc, 0x04, 0x9a, 0x8f, 0x54, 0xb2, 0x15, 0x0c, 0x6e, 0x41,
0x03, 0x47, 0x11, 0x27, 0x42, 0xd8, 0x28, 0x5e, 0x5e, 0x68, 0xf1, 0x1d, 0x23, 0x13, 0x14, 0xc2,
0x8b, 0x60, 0xe2, 0xff, 0x1c, 0x60, 0x90, 0x52, 0xb9, 0x83, 0x39, 0x4e, 0xc4, 0xb1, 0x00, 0xeb,
0x43, 0x47, 0x48, 0xcc, 0x65, 0x98, 0x69, 0x39, 0x1b, 0xf2, 0x53, 0xa0, 0xa1, 0xad, 0xb7, 0x19,
0xed, 0xfe, 0x4f, 0x01, 0x76, 0x25, 0xa7, 0xe9, 0xf8, 0x01, 0x15, 0x52, 0x9d, 0x75, 0xa0, 0xe4,
0x94, 0x13, 0xee, 0x66, 0x2b, 0xb0, 0xab, 0x4a, 0x3a, 0x6a, 0xa7, 0x4f, 0xc7, 0x6d, 0x68, 0x17,
0xe1, 0x7e, 0x28, 0xc6, 0xe8, 0x26, 0xd4, 0x87, 0x58, 0x90, 0x13, 0xc3, 0xf3, 0x50, 0x8c, 0xef,
0x62, 0x41, 0x02, 0x2d, 0xe9, 0xff, 0xca, 0x85, 0xb7, 0xb6, 0x39, 0xd1, 0xe0, 0x8f, 0x63, 0x32,
0x92, 0x94, 0xa5, 0x36, 0xf6, 0xaf, 0xae, 0x0d, 0xbd, 0x05, 0x8d, 0x68, 0x18, 0xa6, 0x38, 0x29,
0x82, 0xbd, 0x1c, 0x0d, 0x1f, 0xe1, 0x84, 0xa0, 0xaf, 0x41, 0x77, 0x54, 0xea, 0x57, 0x14, 0x8d,
0xb9, 0x56, 0x30, 0x47, 0x45, 0xef, 0xc1, 0x4a, 0x86, 0xb9, 0xa4, 0xa5, 0x58, 0x5d, 0x8b, 0xcd,
0x12, 0x55, 0x42, 0xa3, 0xe1, 0xa0, 0xef, 0x2d, 0xe9, 0x64, 0xe9, 0x6f, 0xe4, 0x43, 0x67, 0xaa,
0x6b, 0xd0, 0xf7, 0x96, 0x35, 0x6f, 0x86, 0x86, 0x36, 0xa0, 0x5d, 0x2a, 0x1a, 0xf4, 0xbd, 0x86,
0x16, 0xa9, 0x92, 0x54, 0x72, 0x4c, 0x2f, 0xf2, 0x9a, 0x1b, 0xce, 0x66, 0x27, 0xb0, 0x2b, 0x74,
0x13, 0xce, 0x1d, 0x50, 0x2e, 0x73, 0x1c, 0x5b, 0x7c, 0x2a, 0x3b, 0x84, 0xd7, 0xd2, 0x19, 0x5c,
0xc4, 0x42, 0x5b, 0xb0, 0x9e, 0xed, 0x4f, 0x04, 0x1d, 0xcd, 0x6d, 0x01, 0xbd, 0x65, 0x21, 0xcf,
0xff, 0x9b, 0x03, 0x6f, 0xf6, 0x39, 0xcb, 0x5e, 0x8b, 0x54, 0x14, 0x41, 0xae, 0x9f, 0x10, 0xe4,
0xa5, 0xa3, 0x41, 0xf6, 0x7f, 0x53, 0x83, 0xf3, 0x06, 0x51, 0x3b, 0x45, 0x60, 0x3f, 0x07, 0x2f,
0xbe, 0x0e, 0xab, 0xd3, 0x53, 0x8d, 0xc0, 0x62, 0x37, 0xbe, 0x0a, 0xdd, 0x32, 0xc1, 0x46, 0xee,
0x7f, 0x0b, 0x29, 0xff, 0xd7, 0x35, 0x58, 0x57, 0x49, 0xfd, 0x32, 0x1a, 0x2a, 0x1a, 0x7f, 0x74,
0x00, 0x19, 0x74, 0xdc, 0x89, 0x29, 0x16, 0x5f, 0x64, 0x2c, 0xd6, 0x61, 0x09, 0x2b, 0x1b, 0x6c,
0x08, 0xcc, 0xc2, 0x17, 0xd0, 0x53, 0xd9, 0xfa, 0xbc, 0xac, 0x2b, 0x0f, 0x75, 0xab, 0x87, 0xfe,
0xc1, 0x81, 0xb5, 0x3b, 0xb1, 0x24, 0xfc, 0x35, 0x0d, 0xca, 0x5f, 0x6b, 0x45, 0xd6, 0x06, 0x69,
0x44, 0x9e, 0x7f, 0x91, 0x06, 0xbe, 0x0d, 0xb0, 0x47, 0x49, 0x1c, 0x55, 0xd1, 0xdb, 0xd2, 0x94,
0xcf, 0x84, 0x5c, 0x0f, 0x1a, 0x5a, 0x49, 0x89, 0xda, 0x62, 0xa9, 0x66, 0x00, 0x33, 0x0f, 0xda,
0x19, 0xa0, 0x79, 0xea, 0x19, 0x40, 0x6f, 0xb3, 0x33, 0xc0, 0x3f, 0xea, 0xb0, 0x32, 0x48, 0x05,
0xe1, 0xf2, 0xec, 0xc1, 0xbb, 0x0c, 0x2d, 0xb1, 0x8f, 0xb9, 0x76, 0xd4, 0x86, 0x6f, 0x4a, 0xa8,
0x86, 0xd6, 0x7d, 0x59, 0x68, 0xeb, 0xa7, 0x6c, 0x0e, 0x4b, 0x27, 0x35, 0x87, 0xe5, 0x13, 0x42,
0xdc, 0x78, 0x79, 0x73, 0x68, 0x1e, 0xbd, 0x7d, 0x95, 0x83, 0x64, 0x9c, 0xa8, 0xa1, 0xb5, 0xef,
0xb5, 0x34, 0x7f, 0x4a, 0x40, 0xef, 0x00, 0x48, 0x9a, 0x10, 0x21, 0x71, 0x92, 0x99, 0x7b, 0xb4,
0x1e, 0x54, 0x28, 0xea, 0xee, 0xe6, 0xec, 0x70, 0xd0, 0x17, 0x5e, 0x7b, 0xc3, 0x55, 0x43, 0x9c,
0x59, 0xa1, 0x0f, 0xa1, 0xc9, 0xd9, 0x61, 0x18, 0x61, 0x89, 0xbd, 0x8e, 0x4e, 0xde, 0x85, 0x85,
0xc1, 0xbe, 0x1b, 0xb3, 0x61, 0xd0, 0xe0, 0xec, 0xb0, 0x8f, 0x25, 0x46, 0xb7, 0xa1, 0xad, 0x11,
0x20, 0xcc, 0xc6, 0x15, 0xbd, 0xf1, 0x9d, 0xd9, 0x8d, 0xf6, 0xd9, 0xf2, 0x03, 0x25, 0xa7, 0x36,
0x05, 0x06, 0x9a, 0x42, 0x2b, 0xb8, 0x00, 0xcd, 0x34, 0x4f, 0x42, 0xce, 0x0e, 0x85, 0xd7, 0xdd,
0x70, 0x36, 0xeb, 0x41, 0x23, 0xcd, 0x93, 0x80, 0x1d, 0x0a, 0x74, 0x17, 0x1a, 0x07, 0x84, 0x0b,
0xca, 0x52, 0x6f, 0x55, 0x3f, 0x50, 0x36, 0x8f, 0x19, 0xe2, 0x0d, 0x62, 0x94, 0xba, 0x27, 0x46,
0x3e, 0x28, 0x36, 0xfa, 0xff, 0xac, 0xc3, 0xca, 0x2e, 0xc1, 0x7c, 0xb4, 0x7f, 0x76, 0x40, 0xad,
0xc3, 0x12, 0x27, 0xcf, 0x06, 0x7d, 0x0d, 0x26, 0x37, 0x30, 0x8b, 0x32, 0xbf, 0xee, 0x09, 0xf9,
0xad, 0x2f, 0xc8, 0xaf, 0x0f, 0x9d, 0x4a, 0x32, 0x85, 0xb7, 0xa4, 0xb3, 0x30, 0x43, 0x43, 0x3d,
0x70, 0x23, 0x11, 0x6b, 0xe8, 0xb4, 0x02, 0xf5, 0x89, 0xae, 0xc1, 0x5a, 0x16, 0xe3, 0x11, 0xd9,
0x67, 0x71, 0x44, 0x78, 0x38, 0xe6, 0x2c, 0xcf, 0x34, 0x7c, 0x3a, 0x41, 0xaf, 0xc2, 0xb8, 0xa7,
0xe8, 0xe8, 0x63, 0x68, 0x46, 0x22, 0x0e, 0xe5, 0x24, 0x23, 0x1a, 0x3f, 0xdd, 0x63, 0xdc, 0xec,
0x8b, 0xf8, 0xf1, 0x24, 0x23, 0x41, 0x23, 0x32, 0x1f, 0xe8, 0x26, 0xac, 0x0b, 0xc2, 0x29, 0x8e,
0xe9, 0x0b, 0x12, 0x85, 0xe4, 0x79, 0xc6, 0xc3, 0x2c, 0xc6, 0xa9, 0x06, 0x59, 0x27, 0x40, 0x53,
0xde, 0xa7, 0xcf, 0x33, 0xbe, 0x13, 0xe3, 0x14, 0x6d, 0x42, 0x8f, 0xe5, 0x32, 0xcb, 0x65, 0x68,
0x61, 0x40, 0x23, 0x8d, 0x39, 0x37, 0xe8, 0x1a, 0xba, 0xce, 0xba, 0x18, 0x44, 0xe8, 0x1b, 0xd0,
0x93, 0x1c, 0x1f, 0x90, 0x38, 0x2c, 0xc1, 0xe8, 0xb5, 0x75, 0xc2, 0x57, 0x0d, 0xfd, 0x71, 0x41,
0x46, 0x37, 0xe0, 0xdc, 0x38, 0xc7, 0x1c, 0xa7, 0x92, 0x90, 0x8a, 0x74, 0x47, 0x4b, 0xa3, 0x92,
0x35, 0xdd, 0x70, 0x0d, 0xd6, 0x94, 0x18, 0xcb, 0x65, 0x45, 0x7c, 0x45, 0x8b, 0xf7, 0x2c, 0x63,
0x2a, 0xdc, 0x85, 0x5a, 0xfa, 0x4c, 0x63, 0xcd, 0x0d, 0x6a, 0xe9, 0x33, 0x95, 0x48, 0xc9, 0xb2,
0xa7, 0x1a, 0x63, 0x6e, 0xa0, 0xbf, 0x55, 0x11, 0x25, 0x44, 0x72, 0x3a, 0x52, 0x61, 0xf1, 0x7a,
0x3a, 0x0f, 0x15, 0x8a, 0xff, 0x1f, 0x77, 0x0a, 0x2b, 0x91, 0xc7, 0x52, 0x9c, 0x01, 0x56, 0x67,
0x79, 0xc9, 0x4c, 0xb1, 0xe8, 0x56, 0xb1, 0xf8, 0x2e, 0xb4, 0x8d, 0x71, 0x26, 0xe7, 0xf5, 0x79,
0x7b, 0x95, 0x80, 0xaa, 0xb2, 0x67, 0x39, 0xe1, 0x94, 0x08, 0xdb, 0xf6, 0x21, 0xcd, 0x93, 0x1f,
0x1b, 0x0a, 0x3a, 0x07, 0x4b, 0x92, 0x65, 0xe1, 0xd3, 0xa2, 0x5d, 0x49, 0x96, 0xdd, 0x47, 0xdf,
0x85, 0x8b, 0x82, 0xe0, 0x98, 0x44, 0x61, 0xd9, 0x5e, 0x44, 0x28, 0xb4, 0xdb, 0x24, 0xf2, 0x1a,
0x3a, 0xcd, 0x9e, 0x91, 0xd8, 0x2d, 0x05, 0x76, 0x2d, 0x5f, 0x65, 0x71, 0x64, 0xc6, 0xf6, 0x99,
0x6d, 0x4d, 0x3d, 0xd9, 0xa3, 0x29, 0xab, 0xdc, 0xf0, 0x09, 0x78, 0xe3, 0x98, 0x0d, 0x71, 0x1c,
0x1e, 0x39, 0x55, 0x3f, 0x21, 0xdc, 0xe0, 0xbc, 0xe1, 0xef, 0xce, 0x1d, 0xa9, 0xdc, 0x13, 0x31,
0x1d, 0x91, 0x28, 0x1c, 0xc6, 0x6c, 0xe8, 0x81, 0x86, 0x2b, 0x18, 0x92, 0xea, 0x57, 0x0a, 0xa6,
0x56, 0x40, 0x85, 0x61, 0xc4, 0xf2, 0x54, 0x6a, 0xf0, 0xb9, 0x41, 0xd7, 0xd0, 0x1f, 0xe5, 0xc9,
0xb6, 0xa2, 0xa2, 0xaf, 0xc0, 0x8a, 0x95, 0x64, 0x7b, 0x7b, 0x82, 0x48, 0x8d, 0x3a, 0x37, 0xe8,
0x18, 0xe2, 0x8f, 0x34, 0xcd, 0xff, 0xbd, 0x0b, 0xab, 0x81, 0x8a, 0x2e, 0x39, 0x20, 0xff, 0x4f,
0x7d, 0xe5, 0xb8, 0xfa, 0x5e, 0x7e, 0xa5, 0xfa, 0x6e, 0x9c, 0xba, 0xbe, 0x9b, 0xaf, 0x54, 0xdf,
0xad, 0x57, 0xab, 0x6f, 0x58, 0x5c, 0xdf, 0xfe, 0x9f, 0x66, 0x92, 0xf3, 0x1a, 0x54, 0xe7, 0x55,
0x70, 0x69, 0x64, 0x46, 0xc5, 0xf6, 0x96, 0xb7, 0xf0, 0x6e, 0x1c, 0xf4, 0x45, 0xa0, 0x84, 0xe6,
0xef, 0xd3, 0xa5, 0x57, 0xbe, 0x4f, 0xbf, 0x07, 0x97, 0x8e, 0xd6, 0x2c, 0xb7, 0xe1, 0x88, 0xbc,
0x65, 0x9d, 0xbb, 0x0b, 0xf3, 0x45, 0x5b, 0xc4, 0x2b, 0x42, 0xdf, 0x82, 0xf5, 0x4a, 0xd5, 0x4e,
0x37, 0x36, 0xcc, 0x1b, 0x7e, 0xca, 0x9b, 0x6e, 0x39, 0xa9, 0x6e, 0x9b, 0x27, 0xd5, 0xad, 0xff,
0x77, 0x17, 0x56, 0xfa, 0x24, 0x26, 0x92, 0x7c, 0x39, 0xee, 0x1d, 0x3b, 0xee, 0x7d, 0x13, 0x10,
0x4d, 0xe5, 0xad, 0x0f, 0xc3, 0x8c, 0xd3, 0x04, 0xf3, 0x49, 0xf8, 0x94, 0x4c, 0x8a, 0x86, 0xd8,
0xd3, 0x9c, 0x1d, 0xc3, 0xb8, 0x4f, 0x26, 0xe2, 0xa5, 0xe3, 0x5f, 0x75, 0xde, 0x32, 0x1d, 0xb0,
0x9c, 0xb7, 0xbe, 0x03, 0x9d, 0x99, 0x23, 0x3a, 0x2f, 0x01, 0x6c, 0x3b, 0x9b, 0x9e, 0xeb, 0xff,
0xdb, 0x81, 0xd6, 0x03, 0x86, 0x23, 0xfd, 0xf2, 0x39, 0x63, 0x1a, 0xcb, 0xa1, 0xb6, 0x36, 0x3f,
0xd4, 0x5e, 0x86, 0xe9, 0xe3, 0xc5, 0x26, 0xb2, 0xf2, 0x9a, 0xa9, 0xbc, 0x4a, 0xea, 0xb3, 0xaf,
0x92, 0x77, 0xa1, 0x4d, 0x95, 0x41, 0x61, 0x86, 0xe5, 0xbe, 0xe9, 0x89, 0xad, 0x00, 0x34, 0x69,
0x47, 0x51, 0xd4, 0xb3, 0xa5, 0x10, 0xd0, 0xcf, 0x96, 0xe5, 0x53, 0x3f, 0x5b, 0xac, 0x12, 0xfd,
0x6c, 0xf9, 0xa5, 0x03, 0xa0, 0x1d, 0x57, 0xfd, 0xe0, 0xa8, 0x52, 0xe7, 0x2c, 0x4a, 0x55, 0xb3,
0xd6, 0x99, 0x22, 0x31, 0x96, 0xd3, 0xa2, 0x12, 0x36, 0x38, 0x48, 0x65, 0xcd, 0xb0, 0x6c, 0x41,
0x09, 0xff, 0xb7, 0x0e, 0x80, 0xee, 0x0a, 0xc6, 0x8c, 0x79, 0xf8, 0x39, 0x27, 0x3f, 0xe8, 0x6a,
0xb3, 0xa1, 0xbb, 0x5b, 0x84, 0x4e, 0xf5, 0x36, 0xf5, 0x10, 0x5f, 0xe0, 0x43, 0x65, 0x02, 0x2f,
0x9c, 0xb7, 0xd1, 0xd5, 0xdf, 0xfe, 0xef, 0x1c, 0xe8, 0x58, 0xeb, 0x8c, 0x49, 0x33, 0x59, 0x76,
0xe6, 0xb3, 0xac, 0xc7, 0x98, 0x84, 0xf1, 0x49, 0x28, 0xe8, 0x0b, 0x62, 0x0d, 0x02, 0x43, 0xda,
0xa5, 0x2f, 0xc8, 0x0c, 0x78, 0xdd, 0x59, 0xf0, 0x5e, 0x83, 0x35, 0x4e, 0x46, 0x24, 0x95, 0xf1,
0x24, 0x4c, 0x58, 0x44, 0xf7, 0x28, 0x89, 0x34, 0x1a, 0x9a, 0x41, 0xaf, 0x60, 0x3c, 0xb4, 0x74,
0xff, 0x17, 0x0e, 0xb4, 0x1f, 0x8a, 0xf1, 0x0e, 0x13, 0xba, 0xc8, 0xd0, 0x15, 0xe8, 0xd8, 0xc6,
0x66, 0x2a, 0xdc, 0xd1, 0x08, 0x6b, 0x8f, 0xa6, 0xbf, 0x3a, 0xaa, 0xd6, 0x9e, 0x88, 0xb1, 0x0d,
0x53, 0x27, 0x30, 0x0b, 0x74, 0x11, 0x9a, 0x89, 0x18, 0xeb, 0xa9, 0xdb, 0xc2, 0xb2, 0x5c, 0x2b,
0x5f, 0xa7, 0x97, 0x55, 0x5d, 0x5f, 0x56, 0x53, 0x82, 0xff, 0x67, 0x07, 0x90, 0xfd, 0x55, 0xf3,
0x33, 0xfd, 0x34, 0xad, 0xb3, 0x5c, 0xfd, 0xe5, 0xb4, 0xa6, 0x31, 0x3e, 0x43, 0x9b, 0x6b, 0x0a,
0xee, 0x91, 0xa6, 0x70, 0x0d, 0xd6, 0x22, 0xb2, 0x87, 0xf3, 0xb8, 0x7a, 0xbf, 0x1a, 0x93, 0x7b,
0x96, 0xf1, 0xb8, 0x6a, 0x79, 0x77, 0x9b, 0x93, 0x88, 0xa4, 0x92, 0xe2, 0x58, 0xff, 0xe5, 0x70,
0x11, 0x9a, 0xb9, 0x50, 0x48, 0x28, 0x63, 0x57, 0xae, 0xd1, 0xfb, 0x80, 0x48, 0x3a, 0xe2, 0x93,
0x4c, 0x81, 0x38, 0xc3, 0x42, 0x1c, 0x32, 0x1e, 0xd9, 0x46, 0xbd, 0x56, 0x72, 0x76, 0x2c, 0x43,
0x3d, 0x4f, 0x25, 0x49, 0x71, 0x2a, 0x8b, 0x7e, 0x6d, 0x56, 0x2a, 0xf5, 0x54, 0x84, 0x22, 0xcf,
0x08, 0xb7, 0x69, 0x6d, 0x50, 0xb1, 0xab, 0x96, 0xaa, 0x95, 0x8b, 0x7d, 0xbc, 0xf5, 0xd1, 0xad,
0xa9, 0x7a, 0xd3, 0xa2, 0xbb, 0x86, 0x5c, 0xe8, 0xf6, 0x3f, 0x85, 0xb5, 0x07, 0x54, 0xc8, 0x1d,
0x16, 0xd3, 0xd1, 0xe4, 0xcc, 0x37, 0x8e, 0x1f, 0x03, 0xaa, 0xaa, 0x11, 0x19, 0x4b, 0x67, 0x06,
0x06, 0xe7, 0xf4, 0x03, 0xc3, 0x15, 0xe8, 0x64, 0x5a, 0x8d, 0xfe, 0x1b, 0xad, 0x48, 0x5e, 0xdb,
0xd0, 0x54, 0x68, 0xc5, 0xd5, 0x4f, 0xa0, 0x55, 0xfe, 0x01, 0x87, 0x7a, 0xd0, 0x19, 0xa4, 0x54,
0xea, 0x29, 0x8d, 0xa6, 0xe3, 0xde, 0x1b, 0xa8, 0x0d, 0x8d, 0x1f, 0x12, 0x1c, 0xcb, 0xfd, 0x49,
0xcf, 0x41, 0x1d, 0x68, 0xde, 0x19, 0xa6, 0x8c, 0x27, 0x38, 0xee, 0xd5, 0xae, 0x6e, 0xc1, 0xda,
0x91, 0x97, 0xb1, 0x12, 0x09, 0xd8, 0xa1, 0xf2, 0x26, 0xea, 0xbd, 0x81, 0x56, 0xa1, 0xbd, 0xcd,
0xe2, 0x3c, 0x49, 0x0d, 0xc1, 0xb9, 0xfb, 0xf1, 0xcf, 0x3e, 0x1a, 0x53, 0xb9, 0x9f, 0x0f, 0x95,
0xc1, 0x37, 0x8c, 0x07, 0xef, 0x53, 0x66, 0xbf, 0x6e, 0x14, 0x05, 0x7f, 0x43, 0x3b, 0x55, 0x2e,
0xb3, 0xe1, 0x70, 0x59, 0x53, 0x3e, 0xf8, 0x6f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xfd, 0x7b, 0xa3,
0xc9, 0xda, 0x1c, 0x00, 0x00,
}

1
internal/querycoord/impl.go
View File

@ -84,7 +84,6 @@ func (qc *QueryCoord) GetStatisticsChannel(ctx context.Context) (*milvuspb.Strin
ErrorCode: commonpb.ErrorCode_Success,
Reason: "",
},
Value: Params.CommonCfg.QueryNodeStats,
}, nil
}

1
internal/querycoord/query_coord_test.go
View File

@ -56,7 +56,6 @@ func setup() {
func refreshParams() {
rand.Seed(time.Now().UnixNano())
suffix := "-test-query-Coord" + strconv.FormatInt(rand.Int63(), 10)
Params.CommonCfg.QueryNodeStats = Params.CommonCfg.QueryNodeStats + suffix
Params.CommonCfg.QueryCoordTimeTick = Params.CommonCfg.QueryCoordTimeTick + suffix
Params.EtcdCfg.MetaRootPath = Params.EtcdCfg.MetaRootPath + suffix
GlobalSegmentInfos = make(map[UniqueID]*querypb.SegmentInfo)

1
internal/querynode/impl.go
View File

@ -87,7 +87,6 @@ func (node *QueryNode) GetStatisticsChannel(ctx context.Context) (*milvuspb.Stri
ErrorCode: commonpb.ErrorCode_Success,
Reason: "",
},
Value: Params.CommonCfg.QueryNodeStats,
}, nil
}

5
internal/querynode/query_node.go
View File

@ -94,10 +94,6 @@ type QueryNode struct {
// dataSyncService
dataSyncService *dataSyncService
// internal services
//queryService *queryService
statsService *statsService
// segment loader
loader *segmentLoader
@ -259,7 +255,6 @@ func (node *QueryNode) Start() error {
// start services
go node.watchChangeInfo()
//go node.statsService.start()
// create shardClusterService for shardLeader functions.
node.ShardClusterService = newShardClusterService(node.etcdCli, node.session, node)

4
internal/querynode/query_node_test.go
View File

@ -19,10 +19,8 @@ package querynode
import (
"context"
"io/ioutil"
"math/rand"
"net/url"
"os"
"strconv"
"sync"
"testing"
"time"
@ -97,7 +95,6 @@ func newQueryNodeMock() *QueryNode {
replica := newCollectionReplica()
svr.metaReplica = replica
svr.dataSyncService = newDataSyncService(ctx, svr.metaReplica, tsReplica, factory)
svr.statsService = newStatsService(ctx, svr.metaReplica, factory)
svr.vectorStorage, err = factory.NewVectorStorageChunkManager(ctx)
if err != nil {
panic(err)
@ -143,7 +140,6 @@ func startEmbedEtcdServer() (*embed.Etcd, error) {
func TestMain(m *testing.M) {
setup()
Params.CommonCfg.QueryNodeStats = Params.CommonCfg.QueryNodeStats + strconv.Itoa(rand.Int())
// init embed etcd
var err error
embedetcdServer, err = startEmbedEtcdServer()

108
internal/querynode/stats_service.go
View File

@ -1,108 +0,0 @@
// Licensed to the LF AI & Data foundation under one
// or more contributor license agreements. See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership. The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License. You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package querynode
import (
"context"
"time"
"github.com/milvus-io/milvus/internal/log"
"github.com/milvus-io/milvus/internal/mq/msgstream"
"github.com/milvus-io/milvus/internal/proto/commonpb"
"github.com/milvus-io/milvus/internal/proto/internalpb"
"go.uber.org/zap"
)
type statsService struct {
ctx context.Context
replica ReplicaInterface
statsStream msgstream.MsgStream
msFactory msgstream.Factory
}
func newStatsService(ctx context.Context, replica ReplicaInterface, factory msgstream.Factory) *statsService {
return &statsService{
ctx: ctx,
replica: replica,
statsStream: nil,
msFactory: factory,
}
}
func (sService *statsService) start() {
sleepTimeInterval := Params.QueryNodeCfg.StatsPublishInterval
// start pulsar
producerChannels := []string{Params.CommonCfg.QueryNodeStats}
statsStream, _ := sService.msFactory.NewMsgStream(sService.ctx)
statsStream.AsProducer(producerChannels)
log.Info("QueryNode statsService AsProducer succeed", zap.Strings("channels", producerChannels))
var statsMsgStream msgstream.MsgStream = statsStream
sService.statsStream = statsMsgStream
sService.statsStream.Start()
// start service
for {
select {
case <-sService.ctx.Done():
log.Info("stats service closed")
return
case <-time.After(time.Duration(sleepTimeInterval) * time.Millisecond):
sService.publicStatistic(nil)
}
}
}
func (sService *statsService) close() {
if sService.statsStream != nil {
sService.statsStream.Close()
}
}
func (sService *statsService) publicStatistic(fieldStats []*internalpb.FieldStats) {
segStats := sService.replica.getSegmentStatistics()
queryNodeStats := internalpb.QueryNodeStats{
Base: &commonpb.MsgBase{
MsgType: commonpb.MsgType_QueryNodeStats,
SourceID: Params.QueryNodeCfg.GetNodeID(),
},
SegStats: segStats,
FieldStats: fieldStats,
}
var msg msgstream.TsMsg = &msgstream.QueryNodeStatsMsg{
BaseMsg: msgstream.BaseMsg{
HashValues: []uint32{0},
},
QueryNodeStats: queryNodeStats,
}
var msgPack = msgstream.MsgPack{
Msgs: []msgstream.TsMsg{msg},
}
err := sService.statsStream.Produce(&msgPack)
if err != nil {
log.Warn("failed to publish stats", zap.Error(err))
}
}

67
internal/querynode/stats_service_test.go
View File

@ -1,67 +0,0 @@
// Licensed to the LF AI & Data foundation under one
// or more contributor license agreements. See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership. The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License. You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package querynode
import (
"context"
"testing"
"github.com/milvus-io/milvus/internal/mq/msgstream"
"github.com/milvus-io/milvus/internal/util/dependency"
"github.com/stretchr/testify/assert"
)
// NOTE: start pulsar before test
func TestStatsService_start(t *testing.T) {
node := newQueryNodeMock()
initTestMeta(t, node, 0, 0)
factory := dependency.NewDefaultFactory(true)
node.statsService = newStatsService(node.queryNodeLoopCtx, node.metaReplica, factory)
node.statsService.start()
node.Stop()
}
//NOTE: start pulsar before test
func TestSegmentManagement_sendSegmentStatistic(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
node, err := genSimpleQueryNode(ctx)
assert.NoError(t, err)
const receiveBufSize = 1024
// start pulsar
producerChannels := []string{Params.CommonCfg.QueryNodeStats}
factory := dependency.NewDefaultFactory(true)
statsStream, err := factory.NewMsgStream(node.queryNodeLoopCtx)
assert.Nil(t, err)
statsStream.AsProducer(producerChannels)
var statsMsgStream msgstream.MsgStream = statsStream
node.statsService = newStatsService(node.queryNodeLoopCtx, node.metaReplica, factory)
node.statsService.statsStream = statsMsgStream
node.statsService.statsStream.Start()
// send stats
node.statsService.publicStatistic(nil)
node.Stop()
}

10
internal/util/paramtable/component_param.go
View File

@ -111,7 +111,6 @@ type commonConfig struct {
QueryCoordSearch string
QueryCoordSearchResult string
QueryCoordTimeTick string
QueryNodeStats string
QueryNodeSubName string
DataCoordStatistic string
@ -151,7 +150,6 @@ func (p *commonConfig) init(base *BaseTable) {
p.initQueryCoordSearch()
p.initQueryCoordSearchResult()
p.initQueryCoordTimeTick()
p.initQueryNodeStats()
p.initQueryNodeSubName()
p.initDataCoordStatistic()
@ -274,14 +272,6 @@ func (p *commonConfig) initQueryCoordTimeTick() {
}
// --- querynode ---
func (p *commonConfig) initQueryNodeStats() {
keys := []string{
"msgChannel.chanNamePrefix.queryNodeStats",
"common.chanNamePrefix.queryNodeStats",
}
p.QueryNodeStats = p.initChanNamePrefix(keys)
}
func (p *commonConfig) initQueryNodeSubName() {
keys := []string{
"msgChannel.subNamePrefix.queryNodeSubNamePrefix",

3
internal/util/paramtable/component_param_test.go
View File

@ -91,9 +91,6 @@ func TestComponentParam(t *testing.T) {
t.Logf("querycoord timetick channel = %s", Params.QueryCoordTimeTick)
// -- querynode --
assert.Equal(t, Params.QueryNodeStats, "by-dev-query-node-stats")
t.Logf("querynode stats channel = %s", Params.QueryNodeStats)
assert.Equal(t, Params.QueryNodeSubName, "by-dev-queryNode")
t.Logf("querynode subname = %s", Params.QueryNodeSubName)