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

Move GetComponentStates to milvus.proto, make it an external interface (#19594) 

Signed-off-by: wayblink <anyang.wang@zilliz.com>

Signed-off-by: wayblink <anyang.wang@zilliz.com>
pull/19383/head
wayblink 2022-10-10 15:55:22 +08:00 committed by GitHub
parent 2c92ce0c0e
commit 85e04d845c
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
118 changed files with 2668 additions and 2607 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

357
api/commonpb/common.pb.go
View File

@ -822,6 +822,37 @@ func (ObjectPrivilege) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_555bd8c177793206, []int{10}
}
type StateCode int32
const (
StateCode_Initializing StateCode = 0
StateCode_Healthy StateCode = 1
StateCode_Abnormal StateCode = 2
StateCode_StandBy StateCode = 3
)
var StateCode_name = map[int32]string{
0: "Initializing",
1: "Healthy",
2: "Abnormal",
3: "StandBy",
}
var StateCode_value = map[string]int32{
"Initializing": 0,
"Healthy": 1,
"Abnormal": 2,
"StandBy": 3,
}
func (x StateCode) String() string {
return proto.EnumName(StateCode_name, int32(x))
}
func (StateCode) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_555bd8c177793206, []int{11}
}
type Status struct {
ErrorCode ErrorCode `protobuf:"varint,1,opt,name=error_code,json=errorCode,proto3,enum=milvus.proto.common.ErrorCode" json:"error_code,omitempty"`
Reason string `protobuf:"bytes,2,opt,name=reason,proto3" json:"reason,omitempty"`
@ -1387,6 +1418,7 @@ func init() {
proto.RegisterEnum("milvus.proto.common.ImportState", ImportState_name, ImportState_value)
proto.RegisterEnum("milvus.proto.common.ObjectType", ObjectType_name, ObjectType_value)
proto.RegisterEnum("milvus.proto.common.ObjectPrivilege", ObjectPrivilege_name, ObjectPrivilege_value)
proto.RegisterEnum("milvus.proto.common.StateCode", StateCode_name, StateCode_value)
proto.RegisterType((*Status)(nil), "milvus.proto.common.Status")
proto.RegisterType((*KeyValuePair)(nil), "milvus.proto.common.KeyValuePair")
proto.RegisterType((*KeyDataPair)(nil), "milvus.proto.common.KeyDataPair")
@ -1404,165 +1436,168 @@ func init() {
func init() { proto.RegisterFile("common.proto", fileDescriptor_555bd8c177793206) }
var fileDescriptor_555bd8c177793206 = []byte{
// 2552 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x58, 0xc9, 0x73, 0x63, 0x47,
0x19, 0x9f, 0x67, 0xc9, 0x96, 0xd5, 0x92, 0xe5, 0x76, 0xdb, 0xe3, 0x51, 0x66, 0xc9, 0x38, 0x26,
0x01, 0x23, 0x12, 0x4f, 0x32, 0xa9, 0x02, 0x8a, 0xaa, 0x50, 0xd8, 0x92, 0xed, 0x51, 0xc5, 0x1b,
0xcf, 0x9e, 0x40, 0x51, 0x05, 0x53, 0xad, 0xf7, 0x3e, 0xcb, 0x3d, 0xf3, 0xf4, 0xfa, 0xf1, 0xba,
0xe5, 0xb1, 0x38, 0x85, 0x00, 0xb9, 0x70, 0x61, 0xa9, 0xe2, 0xcc, 0x1f, 0x00, 0x29, 0x76, 0x38,
0xb2, 0x93, 0xb0, 0x9d, 0xd9, 0xe1, 0x08, 0x77, 0x96, 0x90, 0x95, 0xfa, 0xba, 0xdf, 0x26, 0xcf,
0x04, 0x0e, 0xdc, 0xd4, 0xbf, 0xef, 0xeb, 0x6f, 0xeb, 0x6f, 0x7b, 0x22, 0x75, 0x4f, 0x0e, 0x06,
0x32, 0x5c, 0x8d, 0x62, 0xa9, 0x25, 0x9b, 0x1f, 0x88, 0xe0, 0x64, 0xa8, 0xec, 0x69, 0xd5, 0x92,
0x2e, 0x2e, 0xf5, 0xa5, 0xec, 0x07, 0x70, 0xcd, 0x80, 0xbd, 0xe1, 0xd1, 0x35, 0x1f, 0x94, 0x17,
0x8b, 0x48, 0xcb, 0xd8, 0x32, 0x2e, 0xdf, 0x22, 0x53, 0x07, 0x9a, 0xeb, 0xa1, 0x62, 0x4f, 0x11,
0x02, 0x71, 0x2c, 0xe3, 0x5b, 0x9e, 0xf4, 0xa1, 0xe9, 0x2c, 0x39, 0x2b, 0x8d, 0xeb, 0x0f, 0xae,
0xde, 0x47, 0xea, 0xea, 0x06, 0xb2, 0xb5, 0xa5, 0x0f, 0x6e, 0x15, 0xd2, 0x9f, 0x6c, 0x91, 0x4c,
0xc5, 0xc0, 0x95, 0x0c, 0x9b, 0x13, 0x4b, 0xce, 0x4a, 0xd5, 0x4d, 0x4e, 0xcb, 0xef, 0x26, 0xf5,
0xa7, 0x61, 0xf4, 0x0c, 0x0f, 0x86, 0xb0, 0xcf, 0x45, 0xcc, 0x28, 0x29, 0xdd, 0x81, 0x91, 0x91,
0x5f, 0x75, 0xf1, 0x27, 0x5b, 0x20, 0x93, 0x27, 0x48, 0x4e, 0x2e, 0xda, 0xc3, 0xf2, 0x93, 0xa4,
0xf6, 0x34, 0x8c, 0x3a, 0x5c, 0xf3, 0xb7, 0xb8, 0xc6, 0x48, 0xd9, 0xe7, 0x9a, 0x9b, 0x5b, 0x75,
0xd7, 0xfc, 0x5e, 0xbe, 0x4c, 0xca, 0xeb, 0x81, 0xec, 0xe5, 0x22, 0x1d, 0x43, 0x4c, 0x44, 0x9e,
0x10, 0xba, 0x1f, 0x70, 0x0f, 0x8e, 0x65, 0xe0, 0x43, 0x6c, 0x4c, 0x42, 0xb9, 0x9a, 0xf7, 0x53,
0xb9, 0x9a, 0xf7, 0xd9, 0x7b, 0x49, 0x59, 0x8f, 0x22, 0x6b, 0x4d, 0xe3, 0xfa, 0xc3, 0xf7, 0x8d,
0x40, 0x41, 0xcc, 0xe1, 0x28, 0x02, 0xd7, 0xdc, 0xc0, 0x10, 0x18, 0x45, 0xaa, 0x59, 0x5a, 0x2a,
0xad, 0xd4, 0xdd, 0xe4, 0xb4, 0xfc, 0xd1, 0x31, 0xbd, 0x5b, 0xb1, 0x1c, 0x46, 0xac, 0x4b, 0xea,
0x51, 0x8e, 0xa9, 0xa6, 0xb3, 0x54, 0x5a, 0xa9, 0x5d, 0x7f, 0xe4, 0x7f, 0x69, 0x33, 0x46, 0xbb,
0x63, 0x57, 0x97, 0x1f, 0x23, 0x95, 0x35, 0xdf, 0x8f, 0x41, 0x29, 0xd6, 0x20, 0x13, 0x22, 0x4a,
0x9c, 0x99, 0x10, 0x11, 0xc6, 0x28, 0x92, 0xb1, 0x36, 0xbe, 0x94, 0x5c, 0xf3, 0x7b, 0xf9, 0x05,
0x87, 0x54, 0x76, 0x54, 0x7f, 0x9d, 0x2b, 0x60, 0xef, 0x21, 0xd3, 0x03, 0xd5, 0xbf, 0x65, 0xfc,
0xb5, 0x2f, 0x7e, 0xf9, 0xbe, 0x16, 0xec, 0xa8, 0xbe, 0xf1, 0xb3, 0x32, 0xb0, 0x3f, 0x30, 0xc0,
0x03, 0xd5, 0xef, 0x76, 0x12, 0xc9, 0xf6, 0xc0, 0x2e, 0x93, 0xaa, 0x16, 0x03, 0x50, 0x9a, 0x0f,
0xa2, 0x66, 0x69, 0xc9, 0x59, 0x29, 0xbb, 0x39, 0xc0, 0x2e, 0x92, 0x69, 0x25, 0x87, 0xb1, 0x07,
0xdd, 0x4e, 0xb3, 0x6c, 0xae, 0x65, 0x67, 0xa4, 0x69, 0x1e, 0xf7, 0x41, 0x77, 0x3b, 0xcd, 0x49,
0x4b, 0x4b, 0xcf, 0xcb, 0x4f, 0x91, 0xea, 0x8e, 0xea, 0xdf, 0x00, 0xee, 0x43, 0xcc, 0x1e, 0x27,
0xe5, 0x1e, 0x57, 0xd6, 0xda, 0xda, 0x5b, 0x5b, 0x8b, 0xde, 0xb9, 0x86, 0x73, 0xf9, 0x63, 0xa4,
0xde, 0xd9, 0xd9, 0xfe, 0x3f, 0x24, 0xa0, 0x5b, 0xea, 0x98, 0xc7, 0xfe, 0x2e, 0x1f, 0xa4, 0x49,
0x9a, 0x03, 0xcb, 0xaf, 0x3a, 0xa4, 0xbe, 0x1f, 0x8b, 0x13, 0x11, 0x40, 0x1f, 0x36, 0x4e, 0x35,
0xfb, 0x00, 0xa9, 0xc9, 0xde, 0x6d, 0xf0, 0x74, 0x31, 0xae, 0x57, 0xef, 0xab, 0x67, 0xcf, 0xf0,
0x99, 0xd0, 0x12, 0x99, 0xfd, 0x66, 0x7b, 0x84, 0x26, 0x12, 0xa2, 0x54, 0xf0, 0x7f, 0x4d, 0x47,
0x2b, 0x26, 0x33, 0xc2, 0x9d, 0x95, 0xe3, 0x00, 0x6b, 0x91, 0xb9, 0x44, 0x60, 0xc8, 0x07, 0x70,
0x4b, 0x84, 0x3e, 0x9c, 0x9a, 0x07, 0x9a, 0x4c, 0x79, 0xd1, 0x95, 0x2e, 0xc2, 0xec, 0x51, 0xc2,
0xee, 0xe1, 0x55, 0xe6, 0xc1, 0x26, 0x5d, 0x7a, 0x86, 0x59, 0xb5, 0xbe, 0x54, 0x25, 0xd5, 0xac,
0x1f, 0xb0, 0x1a, 0xa9, 0x1c, 0x0c, 0x3d, 0x0f, 0x94, 0xa2, 0xe7, 0xd8, 0x3c, 0x99, 0xbd, 0x19,
0xc2, 0x69, 0x04, 0x9e, 0x06, 0xdf, 0xf0, 0x50, 0x87, 0xcd, 0x91, 0x99, 0xb6, 0x0c, 0x43, 0xf0,
0xf4, 0x26, 0x17, 0x01, 0xf8, 0x74, 0x82, 0x2d, 0x10, 0xba, 0x0f, 0xf1, 0x40, 0x28, 0x25, 0x64,
0xd8, 0x81, 0x50, 0x80, 0x4f, 0x4b, 0xec, 0x02, 0x99, 0x6f, 0xcb, 0x20, 0x00, 0x4f, 0x0b, 0x19,
0xee, 0x4a, 0xbd, 0x71, 0x2a, 0x94, 0x56, 0xb4, 0x8c, 0x62, 0xbb, 0x41, 0x00, 0x7d, 0x1e, 0xac,
0xc5, 0xfd, 0xe1, 0x00, 0x42, 0x4d, 0x27, 0x51, 0x46, 0x02, 0x76, 0xc4, 0x00, 0x42, 0x94, 0x44,
0x2b, 0x05, 0xd4, 0x58, 0x8b, 0xb1, 0xa5, 0xd3, 0xec, 0x01, 0x72, 0x3e, 0x41, 0x0b, 0x0a, 0xf8,
0x00, 0x68, 0x95, 0xcd, 0x92, 0x5a, 0x42, 0x3a, 0xdc, 0xdb, 0x7f, 0x9a, 0x92, 0x82, 0x04, 0x57,
0xde, 0x75, 0xc1, 0x93, 0xb1, 0x4f, 0x6b, 0x05, 0x13, 0x9e, 0x01, 0x4f, 0xcb, 0xb8, 0xdb, 0xa1,
0x75, 0x34, 0x38, 0x01, 0x0f, 0x80, 0xc7, 0xde, 0xb1, 0x0b, 0x6a, 0x18, 0x68, 0x3a, 0xc3, 0x28,
0xa9, 0x6f, 0x8a, 0x00, 0x76, 0xa5, 0xde, 0x94, 0xc3, 0xd0, 0xa7, 0x0d, 0xd6, 0x20, 0x64, 0x07,
0x34, 0x4f, 0x22, 0x30, 0x8b, 0x6a, 0xdb, 0xdc, 0x3b, 0x86, 0x04, 0xa0, 0x6c, 0x91, 0xb0, 0x36,
0x0f, 0x43, 0xa9, 0xdb, 0x31, 0x70, 0x0d, 0x9b, 0xa6, 0xd2, 0xe9, 0x1c, 0x9a, 0x33, 0x86, 0x8b,
0x00, 0x28, 0xcb, 0xb9, 0x3b, 0x10, 0x40, 0xc6, 0x3d, 0x9f, 0x73, 0x27, 0x38, 0x72, 0x2f, 0xa0,
0xf1, 0xeb, 0x43, 0x11, 0xf8, 0x26, 0x24, 0xf6, 0x59, 0xce, 0xa3, 0x8d, 0x89, 0xf1, 0xbb, 0xdb,
0xdd, 0x83, 0x43, 0xba, 0xc8, 0xce, 0x93, 0xb9, 0x04, 0xd9, 0x01, 0x1d, 0x0b, 0xcf, 0x04, 0xef,
0x02, 0x9a, 0xba, 0x37, 0xd4, 0x7b, 0x47, 0x3b, 0x30, 0x90, 0xf1, 0x88, 0x36, 0xf1, 0x41, 0x8d,
0xa4, 0xf4, 0x89, 0xe8, 0x03, 0xa8, 0x61, 0x63, 0x10, 0xe9, 0x51, 0x1e, 0x5e, 0x7a, 0x91, 0x5d,
0x22, 0x17, 0x6e, 0x46, 0x3e, 0xd7, 0xd0, 0x1d, 0x60, 0x1b, 0x3a, 0xe4, 0xea, 0x0e, 0xba, 0x3b,
0x8c, 0x81, 0x5e, 0x62, 0x17, 0xc9, 0xe2, 0xf8, 0x5b, 0x64, 0xc1, 0xba, 0x8c, 0x17, 0xad, 0xb7,
0xed, 0x18, 0x7c, 0x08, 0xb5, 0xe0, 0x41, 0x7a, 0xf1, 0x4a, 0x2e, 0xf5, 0x5e, 0xe2, 0x83, 0x48,
0xb4, 0x9e, 0xdf, 0x4b, 0xbc, 0xca, 0x9a, 0x64, 0x61, 0x0b, 0xf4, 0xbd, 0x94, 0x25, 0xa4, 0x6c,
0x0b, 0x65, 0x48, 0x37, 0x15, 0xc4, 0x2a, 0xa5, 0x3c, 0xc4, 0x18, 0x69, 0x6c, 0x81, 0x46, 0x30,
0xc5, 0x96, 0x31, 0x4e, 0xd6, 0x3c, 0x57, 0x06, 0x90, 0xc2, 0x6f, 0xc3, 0x18, 0x74, 0x62, 0x19,
0x15, 0xc1, 0x87, 0xd1, 0xcd, 0xbd, 0x08, 0x62, 0xae, 0x01, 0x65, 0x14, 0x69, 0x8f, 0xa0, 0x9c,
0x03, 0xc0, 0x08, 0x14, 0xe1, 0xb7, 0xe7, 0x70, 0x51, 0xeb, 0x3b, 0x30, 0x87, 0x13, 0x6e, 0xb0,
0x3d, 0x34, 0x25, 0xad, 0xa0, 0xd7, 0x89, 0x92, 0xac, 0xfe, 0x53, 0xe2, 0x3b, 0x31, 0x55, 0xec,
0xbd, 0xad, 0x98, 0x87, 0x3a, 0xc5, 0x5b, 0xec, 0x21, 0x72, 0xc5, 0x85, 0xa3, 0x18, 0xd4, 0xf1,
0xbe, 0x0c, 0x84, 0x37, 0xea, 0x86, 0x47, 0x32, 0x4b, 0x49, 0x64, 0x79, 0x17, 0x5a, 0x82, 0x61,
0xb1, 0xf4, 0x14, 0x7e, 0x14, 0x63, 0xb2, 0x2b, 0xf5, 0x01, 0xb6, 0xc3, 0x6d, 0xd3, 0x60, 0xe9,
0x63, 0xa8, 0x65, 0x57, 0xba, 0x10, 0x05, 0xc2, 0xe3, 0x6b, 0x27, 0x5c, 0x04, 0xbc, 0x17, 0x00,
0x5d, 0xc5, 0xa0, 0x1c, 0x40, 0x1f, 0x4b, 0x36, 0x7b, 0xdf, 0x6b, 0x6c, 0x86, 0x54, 0x37, 0x65,
0xec, 0x41, 0x07, 0xc2, 0x11, 0x7d, 0x1c, 0x8f, 0x2e, 0xd7, 0xb0, 0x2d, 0x06, 0x42, 0xd3, 0x27,
0xac, 0x78, 0x1f, 0xba, 0x9d, 0x5d, 0xa9, 0x77, 0xb8, 0xf6, 0x8e, 0xe9, 0x75, 0xcc, 0x41, 0xdc,
0x0b, 0xda, 0x52, 0xc6, 0xfe, 0xee, 0x1a, 0xf5, 0x19, 0x23, 0x33, 0x9d, 0x8e, 0x0b, 0x1f, 0x1f,
0x82, 0xd2, 0x2e, 0xf7, 0x80, 0xfe, 0xb5, 0xd2, 0xf2, 0x08, 0x31, 0x79, 0x89, 0xdb, 0x0d, 0xa0,
0x98, 0xfc, 0xb4, 0x2b, 0x43, 0xa0, 0xe7, 0x58, 0x9d, 0x4c, 0xdf, 0x0c, 0x85, 0x52, 0x43, 0xf0,
0xa9, 0x83, 0x35, 0xd9, 0x0d, 0xf7, 0x63, 0xd9, 0xc7, 0x41, 0x4a, 0x27, 0x90, 0xba, 0x29, 0x42,
0xa1, 0x8e, 0x4d, 0x37, 0x22, 0x64, 0x2a, 0x29, 0xce, 0x32, 0xab, 0x92, 0x49, 0x17, 0x74, 0x3c,
0xa2, 0x93, 0xad, 0xe7, 0x1c, 0x52, 0x4f, 0x3c, 0xb2, 0x7a, 0x16, 0x08, 0x2d, 0x9e, 0x73, 0x4d,
0x59, 0x79, 0x38, 0xd8, 0x24, 0xb7, 0x62, 0x79, 0x57, 0x84, 0x7d, 0x3a, 0x81, 0x82, 0x0f, 0x80,
0x07, 0x46, 0x49, 0x8d, 0x54, 0x36, 0x83, 0xa1, 0xd1, 0x58, 0x36, 0xfa, 0xf1, 0x80, 0x6c, 0x93,
0x48, 0xc2, 0x74, 0x8a, 0xc0, 0xa7, 0x53, 0x18, 0x22, 0x5b, 0x44, 0x48, 0xab, 0xb4, 0xde, 0x4f,
0x66, 0xcf, 0xec, 0x23, 0x6c, 0x9a, 0x94, 0x13, 0xd5, 0x94, 0xd4, 0xd7, 0x45, 0xc8, 0xe3, 0x91,
0xed, 0x54, 0xd4, 0xc7, 0xe8, 0x6d, 0x06, 0x92, 0xeb, 0x04, 0x80, 0xd6, 0xcb, 0x75, 0xb3, 0x10,
0x98, 0x8b, 0x33, 0xa4, 0x7a, 0x33, 0xf4, 0xe1, 0x48, 0x84, 0xe0, 0xd3, 0x73, 0xa6, 0x83, 0xd8,
0xda, 0xcb, 0x4b, 0x19, 0xc3, 0xdd, 0x40, 0x63, 0x0a, 0x18, 0x60, 0x1b, 0xb8, 0xc1, 0x55, 0x01,
0x3a, 0xc2, 0x2c, 0xe8, 0x98, 0x75, 0xb3, 0x57, 0xbc, 0xde, 0x37, 0x59, 0x70, 0x2c, 0xef, 0xe6,
0x98, 0xa2, 0xc7, 0xa8, 0x69, 0x0b, 0xf4, 0xc1, 0x48, 0x69, 0x18, 0xb4, 0x65, 0x78, 0x24, 0xfa,
0x8a, 0x0a, 0xd4, 0xb4, 0x2d, 0xb9, 0x5f, 0xb8, 0x7e, 0x1b, 0xf3, 0xd0, 0x85, 0x00, 0xb8, 0x2a,
0x4a, 0xbd, 0x63, 0x7a, 0xa8, 0x31, 0x75, 0x2d, 0x10, 0x5c, 0xd1, 0x00, 0x5d, 0x41, 0x2b, 0xed,
0x71, 0x80, 0xef, 0xbb, 0x16, 0x68, 0x88, 0xed, 0x39, 0x64, 0x0b, 0x64, 0xd6, 0xf2, 0xef, 0xf3,
0x58, 0x0b, 0x23, 0xe4, 0x45, 0xc7, 0x64, 0x52, 0x2c, 0xa3, 0x1c, 0x7b, 0x09, 0x47, 0x56, 0xfd,
0x06, 0x57, 0x39, 0xf4, 0x73, 0x87, 0x2d, 0x92, 0xb9, 0xd4, 0xb5, 0x1c, 0xff, 0x85, 0xc3, 0xe6,
0x49, 0x03, 0x5d, 0xcb, 0x30, 0x45, 0x7f, 0x69, 0x40, 0x74, 0xa2, 0x00, 0xfe, 0xca, 0x48, 0x48,
0xbc, 0x28, 0xe0, 0xbf, 0x36, 0xca, 0x50, 0x42, 0x92, 0x44, 0x8a, 0xbe, 0xe2, 0xa0, 0xa5, 0xa9,
0xb2, 0x04, 0xa6, 0xaf, 0x1a, 0x46, 0x94, 0x9a, 0x31, 0xbe, 0x66, 0x18, 0x13, 0x99, 0x19, 0xfa,
0xba, 0x41, 0x6f, 0xf0, 0xd0, 0x97, 0x47, 0x47, 0x19, 0xfa, 0x86, 0xc3, 0x9a, 0x64, 0x1e, 0xaf,
0xaf, 0xf3, 0x80, 0x87, 0x5e, 0xce, 0xff, 0xa6, 0xc3, 0xce, 0x13, 0x7a, 0x46, 0x9d, 0xa2, 0xcf,
0x4e, 0x30, 0x9a, 0xc6, 0xd7, 0xd4, 0x11, 0xfd, 0xca, 0x84, 0x89, 0x55, 0xc2, 0x68, 0xb1, 0xaf,
0x4e, 0xb0, 0x86, 0x0d, 0xba, 0x3d, 0xbf, 0x30, 0xc1, 0x6a, 0x64, 0xaa, 0x1b, 0x2a, 0x88, 0x35,
0xfd, 0x1c, 0xe6, 0xf7, 0x94, 0xed, 0xc7, 0xf4, 0xf3, 0x58, 0x51, 0x93, 0x26, 0xbf, 0xe9, 0x17,
0x70, 0xd6, 0x33, 0x17, 0x14, 0x84, 0x7e, 0xa1, 0x76, 0x14, 0xfd, 0xa2, 0xb9, 0x61, 0x87, 0x29,
0xfd, 0x7b, 0xc9, 0x84, 0xa6, 0x38, 0x59, 0xff, 0x51, 0x42, 0x13, 0xb6, 0x40, 0xe7, 0x95, 0x4d,
0xff, 0x59, 0x62, 0x17, 0xc9, 0xf9, 0x14, 0x33, 0x73, 0x2e, 0xab, 0xe9, 0x7f, 0x95, 0xd8, 0x65,
0x72, 0x01, 0x9b, 0x7e, 0x96, 0x37, 0x78, 0x49, 0x28, 0x2d, 0x3c, 0x45, 0x5f, 0x2e, 0xb1, 0x4b,
0x64, 0x71, 0x0b, 0x74, 0xf6, 0x1e, 0x05, 0xe2, 0xbf, 0x4b, 0x6c, 0x86, 0x4c, 0x63, 0xd5, 0x0b,
0x38, 0x01, 0xfa, 0x4a, 0x09, 0x1f, 0x35, 0x3d, 0x26, 0xe6, 0xbc, 0x5a, 0xc2, 0x50, 0x7f, 0x08,
0x7b, 0x54, 0x67, 0xd0, 0x3e, 0xe6, 0x61, 0x08, 0x81, 0xa2, 0xaf, 0x95, 0x30, 0xa0, 0x2e, 0x0c,
0xe4, 0x09, 0x14, 0xe0, 0xd7, 0x8d, 0xd3, 0x86, 0xf9, 0x83, 0x43, 0x88, 0x47, 0x19, 0xe1, 0x8d,
0x12, 0x3e, 0x8d, 0xe5, 0x1f, 0xa7, 0xbc, 0x59, 0x62, 0x57, 0x48, 0xd3, 0x36, 0x8b, 0xf4, 0x61,
0x90, 0xd8, 0x07, 0x6c, 0xd6, 0xf4, 0xd9, 0x72, 0x26, 0xb1, 0x03, 0x81, 0xe6, 0xd9, 0xbd, 0x4f,
0x96, 0xd1, 0x2e, 0x2c, 0xae, 0xbc, 0x47, 0x2b, 0xfa, 0x5c, 0x19, 0x5f, 0x74, 0x0b, 0x74, 0xd2,
0xa6, 0x15, 0xfd, 0x14, 0xae, 0x56, 0x8d, 0x9b, 0xa1, 0x1a, 0xf6, 0x32, 0x43, 0xe9, 0xa7, 0xd3,
0xcb, 0x1d, 0xa1, 0x74, 0x2c, 0x7a, 0x43, 0x93, 0xe9, 0x9f, 0x29, 0xa3, 0x53, 0x07, 0xa3, 0xd0,
0x1b, 0x83, 0x9f, 0x37, 0x32, 0x13, 0xdb, 0x8c, 0x51, 0xbf, 0x29, 0xb3, 0x59, 0x42, 0x6c, 0x55,
0x1b, 0xe0, 0xb7, 0xa9, 0x3c, 0xdc, 0xa5, 0x4e, 0x20, 0x36, 0x83, 0x86, 0xfe, 0x2e, 0x33, 0xb1,
0xd0, 0x3b, 0xe9, 0xef, 0xcb, 0x18, 0xf4, 0x43, 0x31, 0x80, 0x43, 0xe1, 0xdd, 0xa1, 0x5f, 0xab,
0xa2, 0x7d, 0x26, 0x26, 0x38, 0x11, 0x6c, 0x8e, 0x7c, 0xbd, 0x8a, 0x29, 0x87, 0x99, 0x6c, 0x53,
0xee, 0x1b, 0xe6, 0x9c, 0x8c, 0x82, 0x6e, 0x87, 0x7e, 0x13, 0x77, 0x3a, 0x92, 0x9c, 0x0f, 0x0f,
0xf6, 0xe8, 0xb7, 0xaa, 0xa8, 0x6a, 0x2d, 0x08, 0xa4, 0xc7, 0x75, 0x56, 0x4f, 0xdf, 0xae, 0x62,
0x41, 0x16, 0xb4, 0x27, 0xef, 0xfe, 0x9d, 0xaa, 0x71, 0xd4, 0xe2, 0x26, 0x5d, 0x3b, 0xd8, 0x56,
0xbf, 0x6b, 0xa4, 0xe2, 0x0c, 0x42, 0x4b, 0x0e, 0x35, 0xfd, 0x9e, 0xe1, 0x3b, 0xbb, 0xa6, 0xd0,
0x3f, 0xd4, 0x92, 0x0c, 0x2d, 0x60, 0x7f, 0xac, 0xd9, 0x0a, 0x1b, 0xdf, 0x4b, 0xe8, 0x9f, 0x0c,
0x7c, 0x76, 0x97, 0xa1, 0x7f, 0xae, 0xa1, 0x61, 0xc5, 0x75, 0x04, 0x97, 0x72, 0x45, 0xff, 0x52,
0x43, 0x0b, 0xf2, 0xc5, 0x83, 0x7e, 0xbf, 0x8e, 0xc1, 0x4a, 0x57, 0x0e, 0xfa, 0x83, 0x3a, 0xba,
0x79, 0x66, 0xd9, 0xa0, 0x3f, 0xac, 0x9b, 0xe7, 0xc8, 0xd6, 0x0c, 0xfa, 0xa3, 0x02, 0x80, 0x5c,
0xf4, 0xc7, 0x75, 0xd3, 0xc3, 0xc6, 0x56, 0x0b, 0xfa, 0x93, 0x3a, 0xda, 0x76, 0x76, 0xa9, 0xa0,
0x3f, 0xad, 0xdb, 0xe7, 0xce, 0xd6, 0x09, 0xfa, 0xb3, 0x3a, 0xd6, 0xd0, 0xfd, 0x17, 0x09, 0xfa,
0xa2, 0xd1, 0x95, 0xaf, 0x10, 0xf4, 0xa5, 0x7a, 0x6b, 0x99, 0x54, 0x3a, 0x2a, 0x30, 0x93, 0xa7,
0x42, 0x4a, 0x1d, 0x15, 0xd0, 0x73, 0xd8, 0xa8, 0xd7, 0xa5, 0x0c, 0x36, 0x4e, 0xa3, 0xf8, 0x99,
0x27, 0xa8, 0xd3, 0x5a, 0x27, 0xb3, 0x6d, 0x39, 0x88, 0x78, 0x56, 0xb0, 0x66, 0xd8, 0xd8, 0x29,
0x05, 0xbe, 0x4d, 0x95, 0x73, 0xd8, 0xed, 0x37, 0x4e, 0xc1, 0x1b, 0x9a, 0x99, 0xe8, 0xe0, 0x11,
0x2f, 0x61, 0x90, 0x7d, 0x3a, 0xd1, 0xfa, 0x30, 0xa1, 0x6d, 0x19, 0x2a, 0xa1, 0x34, 0x84, 0xde,
0x68, 0x1b, 0x4e, 0x20, 0x30, 0x93, 0x57, 0xc7, 0x32, 0xec, 0xd3, 0x73, 0xe6, 0xbb, 0x05, 0xcc,
0xf7, 0x87, 0x9d, 0xcf, 0xeb, 0xb8, 0x9b, 0x98, 0x8f, 0x93, 0x06, 0x21, 0x1b, 0x27, 0x10, 0xea,
0x21, 0x0f, 0x82, 0x11, 0x2d, 0xe1, 0xb9, 0x3d, 0x54, 0x5a, 0x0e, 0xc4, 0x27, 0x70, 0x4c, 0xb7,
0x3e, 0xeb, 0x90, 0x9a, 0x1d, 0xc6, 0x99, 0x69, 0xf6, 0xb8, 0x0f, 0xa1, 0x2f, 0x8c, 0x70, 0xdc,
0xad, 0x0d, 0x94, 0x6c, 0x10, 0x4e, 0xce, 0x74, 0xa0, 0x79, 0x6c, 0x2c, 0x34, 0x9f, 0x14, 0xc9,
0xbd, 0xd8, 0xd8, 0xe9, 0xd3, 0xc9, 0x1c, 0xcc, 0x7d, 0x99, 0xc2, 0x25, 0xb2, 0x28, 0x6e, 0x2d,
0xf4, 0xdb, 0x01, 0x70, 0x9c, 0xd7, 0x95, 0xd6, 0x75, 0x42, 0xf2, 0x4f, 0x4a, 0x63, 0x6b, 0x3e,
0x22, 0xcf, 0xa1, 0xc7, 0x5b, 0x81, 0xec, 0xf1, 0x80, 0x3a, 0xb8, 0x21, 0x98, 0x07, 0x9f, 0x68,
0x3d, 0x3f, 0x49, 0x66, 0xcf, 0x7c, 0x40, 0xa2, 0xc9, 0xd9, 0x61, 0x2d, 0xc0, 0x57, 0xb9, 0x42,
0x1e, 0xc8, 0x90, 0x7b, 0x56, 0x02, 0x07, 0x97, 0xce, 0x8c, 0x7c, 0x66, 0x37, 0x98, 0x60, 0x57,
0xc9, 0xa5, 0x9c, 0x78, 0xef, 0x46, 0x80, 0x6d, 0xb9, 0x99, 0x31, 0x9c, 0x5d, 0x0d, 0xca, 0x18,
0xad, 0x8c, 0x8a, 0x95, 0x6e, 0x3f, 0xf7, 0xf2, 0xaf, 0x5d, 0x3b, 0xf2, 0xe8, 0x14, 0x7e, 0x81,
0xe5, 0x36, 0x66, 0x29, 0x43, 0x2b, 0x18, 0xc7, 0x8c, 0x90, 0x8c, 0xa3, 0xe9, 0x31, 0x30, 0x19,
0x4b, 0x55, 0x0c, 0x6e, 0x06, 0x62, 0x3f, 0xca, 0x5b, 0x01, 0xc1, 0xef, 0x82, 0x33, 0x21, 0xb0,
0x3d, 0xa7, 0x36, 0x46, 0x31, 0x58, 0x07, 0x34, 0x17, 0x01, 0xad, 0xe3, 0x0e, 0x34, 0x16, 0x17,
0x7b, 0x63, 0x66, 0x4c, 0x79, 0x32, 0xe1, 0x1a, 0xb8, 0xed, 0xe4, 0x2b, 0xbb, 0x99, 0x8d, 0xb3,
0x63, 0x98, 0xe9, 0x7d, 0x94, 0x8e, 0xa9, 0x2b, 0x0c, 0x71, 0x3a, 0x37, 0xee, 0xa8, 0x49, 0x12,
0xca, 0xc6, 0xa2, 0x6b, 0xed, 0xde, 0xbb, 0x1b, 0x42, 0xac, 0x8e, 0x45, 0x44, 0xe7, 0xc7, 0x82,
0x66, 0xdb, 0x8f, 0xc9, 0x8b, 0x85, 0xb1, 0x50, 0xa0, 0xe9, 0xf9, 0xa5, 0xf3, 0xe3, 0x0f, 0x66,
0x1a, 0x40, 0x4e, 0x5d, 0x1c, 0xa3, 0xee, 0xf0, 0x90, 0xf7, 0x0b, 0x0a, 0x2f, 0x8c, 0x29, 0x2c,
0x74, 0x9e, 0xe6, 0xfb, 0x24, 0x99, 0xcb, 0xfe, 0xee, 0xb8, 0x05, 0xa7, 0xfa, 0x96, 0xec, 0xdd,
0x66, 0x57, 0x57, 0xed, 0x5f, 0x98, 0xab, 0xe9, 0x5f, 0x98, 0xab, 0x3b, 0xa0, 0x14, 0x8a, 0x8c,
0x4c, 0x7e, 0x34, 0xff, 0x56, 0x31, 0xff, 0xe3, 0x3c, 0x74, 0xff, 0x7f, 0xce, 0x0a, 0xff, 0xcb,
0xb8, 0xb3, 0x51, 0xe1, 0xb4, 0xd7, 0xbb, 0xbd, 0xbe, 0x4d, 0x1a, 0x42, 0xa6, 0xf7, 0xfa, 0x71,
0xe4, 0xad, 0xd7, 0xda, 0xe6, 0xde, 0x3e, 0xca, 0xd8, 0x77, 0x3e, 0xb2, 0xd2, 0x17, 0xfa, 0x78,
0xd8, 0x43, 0x69, 0xd7, 0x2c, 0xdb, 0x63, 0x42, 0x26, 0xbf, 0xae, 0xf1, 0x48, 0x5c, 0xb3, 0x6a,
0xa2, 0xde, 0x97, 0x1d, 0xa7, 0x37, 0x65, 0x34, 0x3f, 0xf9, 0x9f, 0x00, 0x00, 0x00, 0xff, 0xff,
0x87, 0x4b, 0xf7, 0xea, 0x97, 0x15, 0x00, 0x00,
// 2597 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x58, 0xd9, 0x73, 0x63, 0x47,
0xd5, 0x9f, 0x2b, 0xc9, 0xf6, 0xa8, 0xa5, 0xb1, 0x8f, 0xdb, 0x1e, 0x8f, 0x32, 0x4b, 0xc6, 0xf1,
0x97, 0x7c, 0x18, 0x91, 0x78, 0x92, 0x49, 0x15, 0x50, 0x54, 0x85, 0xc2, 0x96, 0x6c, 0x8f, 0x2a,
0xde, 0x90, 0x3d, 0x81, 0xa2, 0x0a, 0xa6, 0x5a, 0xf7, 0x1e, 0xcb, 0x3d, 0x73, 0x75, 0xfb, 0x72,
0xbb, 0xe5, 0xb1, 0xf2, 0x14, 0x02, 0xe4, 0x85, 0x17, 0x96, 0x2a, 0x9e, 0xf9, 0x03, 0x20, 0xc5,
0x0e, 0x8f, 0xec, 0x24, 0x6c, 0xcf, 0xec, 0xf0, 0x08, 0xef, 0x2c, 0x21, 0x2b, 0x75, 0xfa, 0xae,
0xf2, 0x4c, 0xe0, 0x81, 0x37, 0xf5, 0xef, 0x9c, 0x3e, 0x5b, 0x9f, 0xed, 0x8a, 0xd5, 0x5d, 0x35,
0x18, 0xa8, 0x60, 0x25, 0x8c, 0x94, 0x51, 0x7c, 0x6e, 0x20, 0xfd, 0xe3, 0xa1, 0x8e, 0x4f, 0x2b,
0x31, 0xe9, 0xe2, 0x62, 0x5f, 0xa9, 0xbe, 0x8f, 0xd7, 0x2c, 0xd8, 0x1b, 0x1e, 0x5e, 0xf3, 0x50,
0xbb, 0x91, 0x0c, 0x8d, 0x8a, 0x62, 0xc6, 0xa5, 0x5b, 0x6c, 0x72, 0xdf, 0x08, 0x33, 0xd4, 0xfc,
0x29, 0xc6, 0x30, 0x8a, 0x54, 0x74, 0xcb, 0x55, 0x1e, 0x36, 0x9c, 0x45, 0x67, 0x79, 0xfa, 0xfa,
0x83, 0x2b, 0xf7, 0x91, 0xba, 0xb2, 0x4e, 0x6c, 0x2d, 0xe5, 0x61, 0xb7, 0x8a, 0xe9, 0x4f, 0xbe,
0xc0, 0x26, 0x23, 0x14, 0x5a, 0x05, 0x8d, 0xd2, 0xa2, 0xb3, 0x5c, 0xed, 0x26, 0xa7, 0xa5, 0x77,
0xb3, 0xfa, 0xd3, 0x38, 0x7a, 0x46, 0xf8, 0x43, 0xdc, 0x13, 0x32, 0xe2, 0xc0, 0xca, 0x77, 0x70,
0x64, 0xe5, 0x57, 0xbb, 0xf4, 0x93, 0xcf, 0xb3, 0x89, 0x63, 0x22, 0x27, 0x17, 0xe3, 0xc3, 0xd2,
0x93, 0xac, 0xf6, 0x34, 0x8e, 0xda, 0xc2, 0x88, 0xb7, 0xb9, 0xc6, 0x59, 0xc5, 0x13, 0x46, 0xd8,
0x5b, 0xf5, 0xae, 0xfd, 0xbd, 0x74, 0x99, 0x55, 0xd6, 0x7c, 0xd5, 0xcb, 0x45, 0x3a, 0x96, 0x98,
0x88, 0x3c, 0x66, 0xb0, 0xe7, 0x0b, 0x17, 0x8f, 0x94, 0xef, 0x61, 0x64, 0x4d, 0x22, 0xb9, 0x46,
0xf4, 0x53, 0xb9, 0x46, 0xf4, 0xf9, 0x7b, 0x59, 0xc5, 0x8c, 0xc2, 0xd8, 0x9a, 0xe9, 0xeb, 0x0f,
0xdf, 0x37, 0x02, 0x05, 0x31, 0x07, 0xa3, 0x10, 0xbb, 0xf6, 0x06, 0x85, 0xc0, 0x2a, 0xd2, 0x8d,
0xf2, 0x62, 0x79, 0xb9, 0xde, 0x4d, 0x4e, 0x4b, 0x1f, 0x1d, 0xd3, 0xbb, 0x19, 0xa9, 0x61, 0xc8,
0x3b, 0xac, 0x1e, 0xe6, 0x98, 0x6e, 0x38, 0x8b, 0xe5, 0xe5, 0xda, 0xf5, 0x47, 0xfe, 0x9b, 0x36,
0x6b, 0x74, 0x77, 0xec, 0xea, 0xd2, 0x63, 0x6c, 0x6a, 0xd5, 0xf3, 0x22, 0xd4, 0x9a, 0x4f, 0xb3,
0x92, 0x0c, 0x13, 0x67, 0x4a, 0x32, 0xa4, 0x18, 0x85, 0x2a, 0x32, 0xd6, 0x97, 0x72, 0xd7, 0xfe,
0x5e, 0x7a, 0xd1, 0x61, 0x53, 0xdb, 0xba, 0xbf, 0x26, 0x34, 0xf2, 0xf7, 0xb0, 0xb3, 0x03, 0xdd,
0xbf, 0x65, 0xfd, 0x8d, 0x5f, 0xfc, 0xf2, 0x7d, 0x2d, 0xd8, 0xd6, 0x7d, 0xeb, 0xe7, 0xd4, 0x20,
0xfe, 0x41, 0x01, 0x1e, 0xe8, 0x7e, 0xa7, 0x9d, 0x48, 0x8e, 0x0f, 0xfc, 0x32, 0xab, 0x1a, 0x39,
0x40, 0x6d, 0xc4, 0x20, 0x6c, 0x94, 0x17, 0x9d, 0xe5, 0x4a, 0x37, 0x07, 0xf8, 0x45, 0x76, 0x56,
0xab, 0x61, 0xe4, 0x62, 0xa7, 0xdd, 0xa8, 0xd8, 0x6b, 0xd9, 0x99, 0x68, 0x46, 0x44, 0x7d, 0x34,
0x9d, 0x76, 0x63, 0x22, 0xa6, 0xa5, 0xe7, 0xa5, 0xa7, 0x58, 0x75, 0x5b, 0xf7, 0x6f, 0xa0, 0xf0,
0x30, 0xe2, 0x8f, 0xb3, 0x4a, 0x4f, 0xe8, 0xd8, 0xda, 0xda, 0xdb, 0x5b, 0x4b, 0xde, 0x75, 0x2d,
0xe7, 0xd2, 0xc7, 0x58, 0xbd, 0xbd, 0xbd, 0xf5, 0x3f, 0x48, 0x20, 0xb7, 0xf4, 0x91, 0x88, 0xbc,
0x1d, 0x31, 0x48, 0x93, 0x34, 0x07, 0x96, 0x5e, 0x73, 0x58, 0x7d, 0x2f, 0x92, 0xc7, 0xd2, 0xc7,
0x3e, 0xae, 0x9f, 0x18, 0xfe, 0x01, 0x56, 0x53, 0xbd, 0xdb, 0xe8, 0x9a, 0x62, 0x5c, 0xaf, 0xde,
0x57, 0xcf, 0xae, 0xe5, 0xb3, 0xa1, 0x65, 0x2a, 0xfb, 0xcd, 0x77, 0x19, 0x24, 0x12, 0xc2, 0x54,
0xf0, 0x7f, 0x4c, 0xc7, 0x58, 0x4c, 0x66, 0x44, 0x77, 0x46, 0x8d, 0x03, 0xbc, 0xc9, 0x66, 0x13,
0x81, 0x81, 0x18, 0xe0, 0x2d, 0x19, 0x78, 0x78, 0x62, 0x1f, 0x68, 0x22, 0xe5, 0x25, 0x57, 0x3a,
0x04, 0xf3, 0x47, 0x19, 0xbf, 0x87, 0x57, 0xdb, 0x07, 0x9b, 0xe8, 0xc2, 0x29, 0x66, 0xdd, 0xfc,
0x62, 0x95, 0x55, 0xb3, 0x7e, 0xc0, 0x6b, 0x6c, 0x6a, 0x7f, 0xe8, 0xba, 0xa8, 0x35, 0x9c, 0xe1,
0x73, 0x6c, 0xe6, 0x66, 0x80, 0x27, 0x21, 0xba, 0x06, 0x3d, 0xcb, 0x03, 0x0e, 0x9f, 0x65, 0xe7,
0x5a, 0x2a, 0x08, 0xd0, 0x35, 0x1b, 0x42, 0xfa, 0xe8, 0x41, 0x89, 0xcf, 0x33, 0xd8, 0xc3, 0x68,
0x20, 0xb5, 0x96, 0x2a, 0x68, 0x63, 0x20, 0xd1, 0x83, 0x32, 0xbf, 0xc0, 0xe6, 0x5a, 0xca, 0xf7,
0xd1, 0x35, 0x52, 0x05, 0x3b, 0xca, 0xac, 0x9f, 0x48, 0x6d, 0x34, 0x54, 0x48, 0x6c, 0xc7, 0xf7,
0xb1, 0x2f, 0xfc, 0xd5, 0xa8, 0x3f, 0x1c, 0x60, 0x60, 0x60, 0x82, 0x64, 0x24, 0x60, 0x5b, 0x0e,
0x30, 0x20, 0x49, 0x30, 0x55, 0x40, 0xad, 0xb5, 0x14, 0x5b, 0x38, 0xcb, 0x1f, 0x60, 0xe7, 0x13,
0xb4, 0xa0, 0x40, 0x0c, 0x10, 0xaa, 0x7c, 0x86, 0xd5, 0x12, 0xd2, 0xc1, 0xee, 0xde, 0xd3, 0xc0,
0x0a, 0x12, 0xba, 0xea, 0x6e, 0x17, 0x5d, 0x15, 0x79, 0x50, 0x2b, 0x98, 0xf0, 0x0c, 0xba, 0x46,
0x45, 0x9d, 0x36, 0xd4, 0xc9, 0xe0, 0x04, 0xdc, 0x47, 0x11, 0xb9, 0x47, 0x5d, 0xd4, 0x43, 0xdf,
0xc0, 0x39, 0x0e, 0xac, 0xbe, 0x21, 0x7d, 0xdc, 0x51, 0x66, 0x43, 0x0d, 0x03, 0x0f, 0xa6, 0xf9,
0x34, 0x63, 0xdb, 0x68, 0x44, 0x12, 0x81, 0x19, 0x52, 0xdb, 0x12, 0xee, 0x11, 0x26, 0x00, 0xf0,
0x05, 0xc6, 0x5b, 0x22, 0x08, 0x94, 0x69, 0x45, 0x28, 0x0c, 0x6e, 0xd8, 0x4a, 0x87, 0x59, 0x32,
0x67, 0x0c, 0x97, 0x3e, 0x02, 0xcf, 0xb9, 0xdb, 0xe8, 0x63, 0xc6, 0x3d, 0x97, 0x73, 0x27, 0x38,
0x71, 0xcf, 0x93, 0xf1, 0x6b, 0x43, 0xe9, 0x7b, 0x36, 0x24, 0xf1, 0xb3, 0x9c, 0x27, 0x1b, 0x13,
0xe3, 0x77, 0xb6, 0x3a, 0xfb, 0x07, 0xb0, 0xc0, 0xcf, 0xb3, 0xd9, 0x04, 0xd9, 0x46, 0x13, 0x49,
0xd7, 0x06, 0xef, 0x02, 0x99, 0xba, 0x3b, 0x34, 0xbb, 0x87, 0xdb, 0x38, 0x50, 0xd1, 0x08, 0x1a,
0xf4, 0xa0, 0x56, 0x52, 0xfa, 0x44, 0xf0, 0x00, 0x69, 0x58, 0x1f, 0x84, 0x66, 0x94, 0x87, 0x17,
0x2e, 0xf2, 0x4b, 0xec, 0xc2, 0xcd, 0xd0, 0x13, 0x06, 0x3b, 0x03, 0x6a, 0x43, 0x07, 0x42, 0xdf,
0x21, 0x77, 0x87, 0x11, 0xc2, 0x25, 0x7e, 0x91, 0x2d, 0x8c, 0xbf, 0x45, 0x16, 0xac, 0xcb, 0x74,
0x31, 0xf6, 0xb6, 0x15, 0xa1, 0x87, 0x81, 0x91, 0xc2, 0x4f, 0x2f, 0x5e, 0xc9, 0xa5, 0xde, 0x4b,
0x7c, 0x90, 0x88, 0xb1, 0xe7, 0xf7, 0x12, 0xaf, 0xf2, 0x06, 0x9b, 0xdf, 0x44, 0x73, 0x2f, 0x65,
0x91, 0x28, 0x5b, 0x52, 0x5b, 0xd2, 0x4d, 0x8d, 0x91, 0x4e, 0x29, 0x0f, 0x71, 0xce, 0xa6, 0x37,
0xd1, 0x10, 0x98, 0x62, 0x4b, 0x14, 0xa7, 0xd8, 0xbc, 0xae, 0xf2, 0x31, 0x85, 0xff, 0x8f, 0x62,
0xd0, 0x8e, 0x54, 0x58, 0x04, 0x1f, 0x26, 0x37, 0x77, 0x43, 0x8c, 0x84, 0x41, 0x92, 0x51, 0xa4,
0x3d, 0x42, 0x72, 0xf6, 0x91, 0x22, 0x50, 0x84, 0xff, 0x3f, 0x87, 0x8b, 0x5a, 0xdf, 0x41, 0x39,
0x9c, 0x70, 0x63, 0xdc, 0x43, 0x53, 0xd2, 0x32, 0x79, 0x9d, 0x28, 0xc9, 0xea, 0x3f, 0x25, 0xbe,
0x93, 0x52, 0x25, 0xbe, 0xb7, 0x19, 0x89, 0xc0, 0xa4, 0x78, 0x93, 0x3f, 0xc4, 0xae, 0x74, 0xf1,
0x30, 0x42, 0x7d, 0xb4, 0xa7, 0x7c, 0xe9, 0x8e, 0x3a, 0xc1, 0xa1, 0xca, 0x52, 0x92, 0x58, 0xde,
0x45, 0x96, 0x50, 0x58, 0x62, 0x7a, 0x0a, 0x3f, 0x4a, 0x31, 0xd9, 0x51, 0x66, 0x9f, 0xda, 0xe1,
0x96, 0x6d, 0xb0, 0xf0, 0x18, 0x69, 0xd9, 0x51, 0x5d, 0x0c, 0x7d, 0xe9, 0x8a, 0xd5, 0x63, 0x21,
0x7d, 0xd1, 0xf3, 0x11, 0x56, 0x28, 0x28, 0xfb, 0xd8, 0xa7, 0x92, 0xcd, 0xde, 0xf7, 0x1a, 0x3f,
0xc7, 0xaa, 0x1b, 0x2a, 0x72, 0xb1, 0x8d, 0xc1, 0x08, 0x1e, 0xa7, 0x63, 0x57, 0x18, 0xdc, 0x92,
0x03, 0x69, 0xe0, 0x89, 0x58, 0xbc, 0x87, 0x9d, 0xf6, 0x8e, 0x32, 0xdb, 0xc2, 0xb8, 0x47, 0x70,
0x9d, 0x72, 0x90, 0xf6, 0x82, 0x96, 0x52, 0x91, 0xb7, 0xb3, 0x0a, 0x1e, 0xe7, 0xec, 0x5c, 0xbb,
0xdd, 0xc5, 0x8f, 0x0f, 0x51, 0x9b, 0xae, 0x70, 0x11, 0xfe, 0x32, 0xd5, 0x74, 0x19, 0xb3, 0x79,
0x49, 0xdb, 0x0d, 0x92, 0x98, 0xfc, 0xb4, 0xa3, 0x02, 0x84, 0x33, 0xbc, 0xce, 0xce, 0xde, 0x0c,
0xa4, 0xd6, 0x43, 0xf4, 0xc0, 0xa1, 0x9a, 0xec, 0x04, 0x7b, 0x91, 0xea, 0xd3, 0x20, 0x85, 0x12,
0x51, 0x37, 0x64, 0x20, 0xf5, 0x91, 0xed, 0x46, 0x8c, 0x4d, 0x26, 0xc5, 0x59, 0xe1, 0x55, 0x36,
0xd1, 0x45, 0x13, 0x8d, 0x60, 0xa2, 0xf9, 0xbc, 0xc3, 0xea, 0x89, 0x47, 0xb1, 0x9e, 0x79, 0x06,
0xc5, 0x73, 0xae, 0x29, 0x2b, 0x0f, 0x87, 0x9a, 0xe4, 0x66, 0xa4, 0xee, 0xca, 0xa0, 0x0f, 0x25,
0x12, 0xbc, 0x8f, 0xc2, 0xb7, 0x4a, 0x6a, 0x6c, 0x6a, 0xc3, 0x1f, 0x5a, 0x8d, 0x15, 0xab, 0x9f,
0x0e, 0xc4, 0x36, 0x41, 0x24, 0x4a, 0xa7, 0x10, 0x3d, 0x98, 0xa4, 0x10, 0xc5, 0x45, 0x44, 0xb4,
0xa9, 0xe6, 0xfb, 0xd9, 0xcc, 0xa9, 0x7d, 0x84, 0x9f, 0x65, 0x95, 0x44, 0x35, 0xb0, 0xfa, 0x9a,
0x0c, 0x44, 0x34, 0x8a, 0x3b, 0x15, 0x78, 0x14, 0xbd, 0x0d, 0x5f, 0x09, 0x93, 0x00, 0xd8, 0x7c,
0xa5, 0x6e, 0x17, 0x02, 0x7b, 0xf1, 0x1c, 0xab, 0xde, 0x0c, 0x3c, 0x3c, 0x94, 0x01, 0x7a, 0x70,
0xc6, 0x76, 0x90, 0xb8, 0xf6, 0xf2, 0x52, 0xa6, 0x70, 0x4f, 0x93, 0x31, 0x05, 0x0c, 0xa9, 0x0d,
0xdc, 0x10, 0xba, 0x00, 0x1d, 0x52, 0x16, 0xb4, 0xed, 0xba, 0xd9, 0x2b, 0x5e, 0xef, 0xdb, 0x2c,
0x38, 0x52, 0x77, 0x73, 0x4c, 0xc3, 0x11, 0x69, 0xda, 0x44, 0xb3, 0x3f, 0xd2, 0x06, 0x07, 0x2d,
0x15, 0x1c, 0xca, 0xbe, 0x06, 0x49, 0x9a, 0xb6, 0x94, 0xf0, 0x0a, 0xd7, 0x6f, 0x53, 0x1e, 0x76,
0xd1, 0x47, 0xa1, 0x8b, 0x52, 0xef, 0xd8, 0x1e, 0x6a, 0x4d, 0x5d, 0xf5, 0xa5, 0xd0, 0xe0, 0x93,
0x2b, 0x64, 0x65, 0x7c, 0x1c, 0xd0, 0xfb, 0xae, 0xfa, 0x06, 0xa3, 0xf8, 0x1c, 0xf0, 0x79, 0x36,
0x13, 0xf3, 0xef, 0x89, 0xc8, 0x48, 0x2b, 0xe4, 0x25, 0xc7, 0x66, 0x52, 0xa4, 0xc2, 0x1c, 0x7b,
0x99, 0x46, 0x56, 0xfd, 0x86, 0xd0, 0x39, 0xf4, 0x33, 0x87, 0x2f, 0xb0, 0xd9, 0xd4, 0xb5, 0x1c,
0xff, 0xb9, 0xc3, 0xe7, 0xd8, 0x34, 0xb9, 0x96, 0x61, 0x1a, 0x7e, 0x61, 0x41, 0x72, 0xa2, 0x00,
0xfe, 0xd2, 0x4a, 0x48, 0xbc, 0x28, 0xe0, 0xbf, 0xb2, 0xca, 0x48, 0x42, 0x92, 0x44, 0x1a, 0x5e,
0x75, 0xc8, 0xd2, 0x54, 0x59, 0x02, 0xc3, 0x6b, 0x96, 0x91, 0xa4, 0x66, 0x8c, 0xaf, 0x5b, 0xc6,
0x44, 0x66, 0x86, 0xbe, 0x61, 0xd1, 0x1b, 0x22, 0xf0, 0xd4, 0xe1, 0x61, 0x86, 0xbe, 0xe9, 0xf0,
0x06, 0x9b, 0xa3, 0xeb, 0x6b, 0xc2, 0x17, 0x81, 0x9b, 0xf3, 0xbf, 0xe5, 0xf0, 0xf3, 0x0c, 0x4e,
0xa9, 0xd3, 0xf0, 0x5c, 0x89, 0x43, 0x1a, 0x5f, 0x5b, 0x47, 0xf0, 0xe5, 0x92, 0x8d, 0x55, 0xc2,
0x18, 0x63, 0x5f, 0x29, 0xf1, 0xe9, 0x38, 0xe8, 0xf1, 0xf9, 0xc5, 0x12, 0xaf, 0xb1, 0xc9, 0x4e,
0xa0, 0x31, 0x32, 0xf0, 0x59, 0xca, 0xef, 0xc9, 0xb8, 0x1f, 0xc3, 0xe7, 0xa8, 0xa2, 0x26, 0x6c,
0x7e, 0xc3, 0xe7, 0x69, 0xd6, 0xf3, 0x2e, 0x6a, 0x0c, 0xbc, 0x42, 0xed, 0x68, 0xf8, 0x82, 0xbd,
0x11, 0x0f, 0x53, 0xf8, 0x5b, 0xd9, 0x86, 0xa6, 0x38, 0x59, 0xff, 0x5e, 0x26, 0x13, 0x36, 0xd1,
0xe4, 0x95, 0x0d, 0xff, 0x28, 0xf3, 0x8b, 0xec, 0x7c, 0x8a, 0xd9, 0x39, 0x97, 0xd5, 0xf4, 0x3f,
0xcb, 0xfc, 0x32, 0xbb, 0x40, 0x4d, 0x3f, 0xcb, 0x1b, 0xba, 0x24, 0xb5, 0x91, 0xae, 0x86, 0x57,
0xca, 0xfc, 0x12, 0x5b, 0xd8, 0x44, 0x93, 0xbd, 0x47, 0x81, 0xf8, 0xaf, 0x32, 0x3f, 0xc7, 0xce,
0x52, 0xd5, 0x4b, 0x3c, 0x46, 0x78, 0xb5, 0x4c, 0x8f, 0x9a, 0x1e, 0x13, 0x73, 0x5e, 0x2b, 0x53,
0xa8, 0x3f, 0x44, 0x3d, 0xaa, 0x3d, 0x68, 0x1d, 0x89, 0x20, 0x40, 0x5f, 0xc3, 0xeb, 0x65, 0x0a,
0x68, 0x17, 0x07, 0xea, 0x18, 0x0b, 0xf0, 0x1b, 0xd6, 0x69, 0xcb, 0xfc, 0xc1, 0x21, 0x46, 0xa3,
0x8c, 0xf0, 0x66, 0x99, 0x9e, 0x26, 0xe6, 0x1f, 0xa7, 0xbc, 0x55, 0xe6, 0x57, 0x58, 0x23, 0x6e,
0x16, 0xe9, 0xc3, 0x10, 0xb1, 0x8f, 0xd4, 0xac, 0xe1, 0xb9, 0x4a, 0x26, 0xb1, 0x8d, 0xbe, 0x11,
0xd9, 0xbd, 0x4f, 0x54, 0xc8, 0x2e, 0x2a, 0xae, 0xbc, 0x47, 0x6b, 0x78, 0xbe, 0x42, 0x2f, 0xba,
0x89, 0x26, 0x69, 0xd3, 0x1a, 0x3e, 0x49, 0xab, 0xd5, 0xf4, 0xcd, 0x40, 0x0f, 0x7b, 0x99, 0xa1,
0xf0, 0xa9, 0xf4, 0x72, 0x5b, 0x6a, 0x13, 0xc9, 0xde, 0xd0, 0x66, 0xfa, 0xa7, 0x2b, 0xe4, 0xd4,
0xfe, 0x28, 0x70, 0xc7, 0xe0, 0x17, 0xac, 0xcc, 0xc4, 0x36, 0x6b, 0xd4, 0xaf, 0x2b, 0x7c, 0x86,
0xb1, 0xb8, 0xaa, 0x2d, 0xf0, 0x9b, 0x54, 0x1e, 0xed, 0x52, 0xc7, 0x18, 0xd9, 0x41, 0x03, 0xbf,
0xcd, 0x4c, 0x2c, 0xf4, 0x4e, 0xf8, 0x5d, 0x85, 0x82, 0x7e, 0x20, 0x07, 0x78, 0x20, 0xdd, 0x3b,
0xf0, 0xd5, 0x2a, 0xd9, 0x67, 0x63, 0x42, 0x13, 0x21, 0xce, 0x91, 0xaf, 0x55, 0x29, 0xe5, 0x28,
0x93, 0xe3, 0x94, 0xfb, 0xba, 0x3d, 0x27, 0xa3, 0xa0, 0xd3, 0x86, 0x6f, 0xd0, 0x4e, 0xc7, 0x92,
0xf3, 0xc1, 0xfe, 0x2e, 0x7c, 0xb3, 0x4a, 0xaa, 0x56, 0x7d, 0x5f, 0xb9, 0xc2, 0x64, 0xf5, 0xf4,
0xad, 0x2a, 0x15, 0x64, 0x41, 0x7b, 0xf2, 0xee, 0xdf, 0xae, 0x5a, 0x47, 0x63, 0xdc, 0xa6, 0x6b,
0x9b, 0xda, 0xea, 0x77, 0xac, 0x54, 0x9a, 0x41, 0x64, 0xc9, 0x81, 0x81, 0xef, 0x5a, 0xbe, 0xd3,
0x6b, 0x0a, 0xfc, 0xbe, 0x96, 0x64, 0x68, 0x01, 0xfb, 0x43, 0x2d, 0xae, 0xb0, 0xf1, 0xbd, 0x04,
0xfe, 0x68, 0xe1, 0xd3, 0xbb, 0x0c, 0xfc, 0xa9, 0x46, 0x86, 0x15, 0xd7, 0x11, 0x5a, 0xca, 0x35,
0xfc, 0xb9, 0x46, 0x16, 0xe4, 0x8b, 0x07, 0x7c, 0xaf, 0x4e, 0xc1, 0x4a, 0x57, 0x0e, 0xf8, 0x7e,
0x9d, 0xdc, 0x3c, 0xb5, 0x6c, 0xc0, 0x0f, 0xea, 0xf6, 0x39, 0xb2, 0x35, 0x03, 0x7e, 0x58, 0x00,
0x88, 0x0b, 0x7e, 0x54, 0xb7, 0x3d, 0x6c, 0x6c, 0xb5, 0x80, 0x1f, 0xd7, 0xc9, 0xb6, 0xd3, 0x4b,
0x05, 0xfc, 0xa4, 0x1e, 0x3f, 0x77, 0xb6, 0x4e, 0xc0, 0x4f, 0xeb, 0x54, 0x43, 0xf7, 0x5f, 0x24,
0xe0, 0x25, 0xab, 0x2b, 0x5f, 0x21, 0xe0, 0xe5, 0x7a, 0x73, 0x89, 0x4d, 0xb5, 0xb5, 0x6f, 0x27,
0xcf, 0x14, 0x2b, 0xb7, 0xb5, 0x0f, 0x67, 0xa8, 0x51, 0xaf, 0x29, 0xe5, 0xaf, 0x9f, 0x84, 0xd1,
0x33, 0x4f, 0x80, 0xd3, 0x5c, 0x63, 0x33, 0x2d, 0x35, 0x08, 0x45, 0x56, 0xb0, 0x76, 0xd8, 0xc4,
0x53, 0x0a, 0xbd, 0x38, 0x55, 0xce, 0x50, 0xb7, 0x5f, 0x3f, 0x41, 0x77, 0x68, 0x67, 0xa2, 0x43,
0x47, 0xba, 0x44, 0x41, 0xf6, 0xa0, 0xd4, 0xfc, 0x30, 0x83, 0x96, 0x0a, 0xb4, 0xd4, 0x06, 0x03,
0x77, 0xb4, 0x85, 0xc7, 0xe8, 0xdb, 0xc9, 0x6b, 0x22, 0x15, 0xf4, 0xe1, 0x8c, 0xfd, 0x6e, 0x41,
0xfb, 0xfd, 0x11, 0xcf, 0xe7, 0x35, 0xda, 0x4d, 0xec, 0xc7, 0xc9, 0x34, 0x63, 0xeb, 0xc7, 0x18,
0x98, 0xa1, 0xf0, 0xfd, 0x11, 0x94, 0xe9, 0xdc, 0x1a, 0x6a, 0xa3, 0x06, 0xf2, 0x59, 0x1a, 0xd3,
0xcd, 0xcf, 0x38, 0xac, 0x16, 0x0f, 0xe3, 0xcc, 0xb4, 0xf8, 0xb8, 0x87, 0x81, 0x27, 0xad, 0x70,
0xda, 0xad, 0x2d, 0x94, 0x6c, 0x10, 0x4e, 0xce, 0xb4, 0x6f, 0x44, 0x64, 0x2d, 0xb4, 0x9f, 0x14,
0xc9, 0xbd, 0xc8, 0xda, 0xe9, 0xc1, 0x44, 0x0e, 0xe6, 0xbe, 0x4c, 0xd2, 0x12, 0x59, 0x14, 0xb7,
0x1a, 0x78, 0x2d, 0x1f, 0x05, 0xcd, 0xeb, 0xa9, 0xe6, 0x75, 0xc6, 0xf2, 0x4f, 0x4a, 0x6b, 0x6b,
0x3e, 0x22, 0xcf, 0x90, 0xc7, 0x9b, 0xbe, 0xea, 0x09, 0x1f, 0x1c, 0xda, 0x10, 0xec, 0x83, 0x97,
0x9a, 0x2f, 0x4c, 0xb0, 0x99, 0x53, 0x1f, 0x90, 0x64, 0x72, 0x76, 0x58, 0xf5, 0xe9, 0x55, 0xae,
0xb0, 0x07, 0x32, 0xe4, 0x9e, 0x95, 0xc0, 0xa1, 0xa5, 0x33, 0x23, 0x9f, 0xda, 0x0d, 0x4a, 0xfc,
0x2a, 0xbb, 0x94, 0x13, 0xef, 0xdd, 0x08, 0xa8, 0x2d, 0x37, 0x32, 0x86, 0xd3, 0xab, 0x41, 0x85,
0xa2, 0x95, 0x51, 0xa9, 0xd2, 0xe3, 0xcf, 0xbd, 0xfc, 0x6b, 0x37, 0x1e, 0x79, 0x30, 0x49, 0x5f,
0x60, 0xb9, 0x8d, 0x59, 0xca, 0xc0, 0x14, 0xc5, 0x31, 0x23, 0x24, 0xe3, 0xe8, 0xec, 0x18, 0x98,
0x8c, 0xa5, 0x2a, 0x05, 0x37, 0x03, 0xa9, 0x1f, 0xe5, 0xad, 0x80, 0xd1, 0x77, 0xc1, 0xa9, 0x10,
0xc4, 0x3d, 0xa7, 0x36, 0x46, 0xb1, 0x58, 0x1b, 0x8d, 0x90, 0x3e, 0xd4, 0x69, 0x07, 0x1a, 0x8b,
0x4b, 0x7c, 0xe3, 0xdc, 0x98, 0xf2, 0x64, 0xc2, 0x4d, 0xd3, 0xb6, 0x93, 0xaf, 0xec, 0x76, 0x36,
0xce, 0x8c, 0x61, 0xb6, 0xf7, 0x01, 0x8c, 0xa9, 0x2b, 0x0c, 0x71, 0x98, 0x1d, 0x77, 0xd4, 0x26,
0x09, 0xf0, 0xb1, 0xe8, 0xc6, 0x76, 0xef, 0xde, 0x0d, 0x30, 0xd2, 0x47, 0x32, 0x84, 0xb9, 0xb1,
0xa0, 0xc5, 0xed, 0xc7, 0xe6, 0xc5, 0xfc, 0x58, 0x28, 0xc8, 0xf4, 0xfc, 0xd2, 0xf9, 0xf1, 0x07,
0xb3, 0x0d, 0x20, 0xa7, 0x2e, 0x8c, 0x51, 0xb7, 0x45, 0x20, 0xfa, 0x05, 0x85, 0x17, 0xc6, 0x14,
0x16, 0x3a, 0x4f, 0xa3, 0xb9, 0xce, 0xaa, 0xb6, 0x86, 0xec, 0x3f, 0x09, 0x54, 0x34, 0x81, 0xa4,
0x1e, 0x28, 0x9f, 0x95, 0x69, 0x8d, 0xde, 0x40, 0xe1, 0x9b, 0xa3, 0x11, 0x38, 0xb4, 0x1d, 0xaf,
0xf6, 0x02, 0x15, 0x0d, 0x84, 0x0f, 0x25, 0x5b, 0xbe, 0x46, 0x04, 0xde, 0xda, 0x08, 0xca, 0xef,
0x53, 0x6c, 0x36, 0xfb, 0xd7, 0xe4, 0x16, 0x9e, 0x98, 0x5b, 0xaa, 0x77, 0x9b, 0x5f, 0x5d, 0x89,
0xff, 0x09, 0x5d, 0x49, 0xff, 0x09, 0x5d, 0xd9, 0x46, 0xad, 0xc9, 0xb2, 0xd0, 0xa6, 0x59, 0xe3,
0xaf, 0x53, 0xf6, 0xef, 0xa0, 0x87, 0xee, 0xff, 0x07, 0x5c, 0xe1, 0xef, 0x9d, 0xee, 0x4c, 0x58,
0x38, 0xed, 0xf6, 0x6e, 0xaf, 0x6d, 0xb1, 0x69, 0xa9, 0xd2, 0x7b, 0xfd, 0x28, 0x74, 0xd7, 0x6a,
0x2d, 0x7b, 0x6f, 0x8f, 0x64, 0xec, 0x39, 0x1f, 0x59, 0xee, 0x4b, 0x73, 0x34, 0xec, 0x91, 0xb4,
0x6b, 0x31, 0xdb, 0x63, 0x52, 0x25, 0xbf, 0xae, 0x89, 0x50, 0x5e, 0x8b, 0xd5, 0x84, 0xbd, 0x2f,
0x39, 0x4e, 0x6f, 0xd2, 0x6a, 0x7e, 0xf2, 0xdf, 0x01, 0x00, 0x00, 0xff, 0xff, 0x54, 0x8b, 0x8e,
0x9b, 0xde, 0x15, 0x00, 0x00,
}

968
api/milvuspb/milvus.pb.go
View File

File diff suppressed because it is too large Load Diff

4
cmd/components/data_coord.go
View File

@ -19,8 +19,8 @@ package components
import (
"context"
"github.com/milvus-io/milvus/api/milvuspb"
"github.com/milvus-io/milvus/internal/log"
"github.com/milvus-io/milvus/internal/proto/internalpb"
"github.com/milvus-io/milvus/internal/util/dependency"
grpcdatacoordclient "github.com/milvus-io/milvus/internal/distributed/datacoord"
@ -60,6 +60,6 @@ func (s *DataCoord) Stop() error {
}
// GetComponentStates returns DataCoord's states
func (s *DataCoord) GetComponentStates(ctx context.Context, request *internalpb.GetComponentStatesRequest) (*internalpb.ComponentStates, error) {
func (s *DataCoord) GetComponentStates(ctx context.Context, request *milvuspb.GetComponentStatesRequest) (*milvuspb.ComponentStates, error) {
return s.svr.GetComponentStates(ctx, request)
}

7
cmd/components/data_node.go
View File

@ -19,11 +19,10 @@ package components
import (
"context"
"github.com/milvus-io/milvus/internal/proto/internalpb"
"github.com/milvus-io/milvus/internal/util/dependency"
"github.com/milvus-io/milvus/api/milvuspb"
grpcdatanode "github.com/milvus-io/milvus/internal/distributed/datanode"
"github.com/milvus-io/milvus/internal/log"
"github.com/milvus-io/milvus/internal/util/dependency"
)
// DataNode implements DataNode grpc server
@ -63,6 +62,6 @@ func (d *DataNode) Stop() error {
}
// GetComponentStates returns DataNode's states
func (d *DataNode) GetComponentStates(ctx context.Context, request *internalpb.GetComponentStatesRequest) (*internalpb.ComponentStates, error) {
func (d *DataNode) GetComponentStates(ctx context.Context, request *milvuspb.GetComponentStatesRequest) (*milvuspb.ComponentStates, error) {
return d.svr.GetComponentStates(ctx, request)
}

5
cmd/components/index_coord.go
View File

@ -19,9 +19,10 @@ package components
import (
"context"
"github.com/milvus-io/milvus/api/milvuspb"
grpcindexcoord "github.com/milvus-io/milvus/internal/distributed/indexcoord"
"github.com/milvus-io/milvus/internal/log"
"github.com/milvus-io/milvus/internal/proto/internalpb"
"github.com/milvus-io/milvus/internal/util/dependency"
)
@ -61,6 +62,6 @@ func (s *IndexCoord) Stop() error {
}
// GetComponentStates returns indexnode's states
func (s *IndexCoord) GetComponentStates(ctx context.Context, request *internalpb.GetComponentStatesRequest) (*internalpb.ComponentStates, error) {
func (s *IndexCoord) GetComponentStates(ctx context.Context, request *milvuspb.GetComponentStatesRequest) (*milvuspb.ComponentStates, error) {
return s.svr.GetComponentStates(ctx, request)
}

5
cmd/components/index_node.go
View File

@ -19,8 +19,9 @@ package components
import (
"context"
"github.com/milvus-io/milvus/api/milvuspb"
"github.com/milvus-io/milvus/internal/log"
"github.com/milvus-io/milvus/internal/proto/internalpb"
"github.com/milvus-io/milvus/internal/util/dependency"
grpcindexnode "github.com/milvus-io/milvus/internal/distributed/indexnode"
@ -62,6 +63,6 @@ func (n *IndexNode) Stop() error {
}
// GetComponentStates returns IndexNode's states
func (n *IndexNode) GetComponentStates(ctx context.Context, request *internalpb.GetComponentStatesRequest) (*internalpb.ComponentStates, error) {
func (n *IndexNode) GetComponentStates(ctx context.Context, request *milvuspb.GetComponentStatesRequest) (*milvuspb.ComponentStates, error) {
return n.svr.GetComponentStates(ctx, request)
}

11
cmd/components/proxy.go
View File

@ -19,12 +19,13 @@ package components
import (
"context"
"github.com/milvus-io/milvus/internal/log"
"github.com/milvus-io/milvus/internal/proto/internalpb"
"github.com/milvus-io/milvus/internal/util/dependency"
"go.uber.org/zap"
"github.com/milvus-io/milvus/api/milvuspb"
grpcproxy "github.com/milvus-io/milvus/internal/distributed/proxy"
"github.com/milvus-io/milvus/internal/log"
"github.com/milvus-io/milvus/internal/util/dependency"
"go.uber.org/zap"
)
// Proxy implements Proxy grpc server
@ -64,6 +65,6 @@ func (n *Proxy) Stop() error {
}
// GetComponentStates returns Proxy's states
func (n *Proxy) GetComponentStates(ctx context.Context, request *internalpb.GetComponentStatesRequest) (*internalpb.ComponentStates, error) {
func (n *Proxy) GetComponentStates(ctx context.Context, request *milvuspb.GetComponentStatesRequest) (*milvuspb.ComponentStates, error) {
return n.svr.GetComponentStates(ctx, request)
}

5
cmd/components/query_coord.go
View File

@ -19,8 +19,9 @@ package components
import (
"context"
"github.com/milvus-io/milvus/api/milvuspb"
"github.com/milvus-io/milvus/internal/log"
"github.com/milvus-io/milvus/internal/proto/internalpb"
"github.com/milvus-io/milvus/internal/util/dependency"
grpcquerycoord "github.com/milvus-io/milvus/internal/distributed/querycoord"
@ -63,6 +64,6 @@ func (qs *QueryCoord) Stop() error {
}
// GetComponentStates returns QueryCoord's states
func (qs *QueryCoord) GetComponentStates(ctx context.Context, request *internalpb.GetComponentStatesRequest) (*internalpb.ComponentStates, error) {
func (qs *QueryCoord) GetComponentStates(ctx context.Context, request *milvuspb.GetComponentStatesRequest) (*milvuspb.ComponentStates, error) {
return qs.svr.GetComponentStates(ctx, request)
}

5
cmd/components/query_node.go
View File

@ -19,8 +19,9 @@ package components
import (
"context"
"github.com/milvus-io/milvus/api/milvuspb"
"github.com/milvus-io/milvus/internal/log"
"github.com/milvus-io/milvus/internal/proto/internalpb"
"github.com/milvus-io/milvus/internal/util/dependency"
grpcquerynode "github.com/milvus-io/milvus/internal/distributed/querynode"
@ -64,6 +65,6 @@ func (q *QueryNode) Stop() error {
}
// GetComponentStates returns QueryNode's states
func (q *QueryNode) GetComponentStates(ctx context.Context, request *internalpb.GetComponentStatesRequest) (*internalpb.ComponentStates, error) {
func (q *QueryNode) GetComponentStates(ctx context.Context, request *milvuspb.GetComponentStatesRequest) (*milvuspb.ComponentStates, error) {
return q.svr.GetComponentStates(ctx, request)
}

5
cmd/components/root_coord.go
View File

@ -20,10 +20,11 @@ import (
"context"
"io"
"github.com/milvus-io/milvus/api/milvuspb"
rc "github.com/milvus-io/milvus/internal/distributed/rootcoord"
"github.com/milvus-io/milvus/internal/log"
"github.com/milvus-io/milvus/internal/proto/internalpb"
"github.com/milvus-io/milvus/internal/util/dependency"
"github.com/opentracing/opentracing-go"
"go.uber.org/zap"
)
@ -68,6 +69,6 @@ func (rc *RootCoord) Stop() error {
}
// GetComponentStates returns RootCoord's states
func (rc *RootCoord) GetComponentStates(ctx context.Context, request *internalpb.GetComponentStatesRequest) (*internalpb.ComponentStates, error) {
func (rc *RootCoord) GetComponentStates(ctx context.Context, request *milvuspb.GetComponentStatesRequest) (*milvuspb.ComponentStates, error) {
return rc.svr.GetComponentStates(ctx, request)
}

10
cmd/roles/healthz_handler.go
View File

@ -22,11 +22,11 @@ import (
"net/http"
"github.com/milvus-io/milvus/api/commonpb"
"github.com/milvus-io/milvus/api/milvuspb"
"github.com/milvus-io/milvus/internal/log"
"github.com/milvus-io/milvus/internal/util/healthz"
"go.uber.org/zap"
"github.com/milvus-io/milvus/internal/proto/internalpb"
"go.uber.org/zap"
)
func unhealthyHandler(w http.ResponseWriter, r *http.Request, reason string) {
@ -54,7 +54,7 @@ func healthyHandler(w http.ResponseWriter, r *http.Request) {
// GetComponentStatesInterface defines the interface that get states from component.
type GetComponentStatesInterface interface {
// GetComponentStates returns the states of component.
GetComponentStates(ctx context.Context, request *internalpb.GetComponentStatesRequest) (*internalpb.ComponentStates, error)
GetComponentStates(ctx context.Context, request *milvuspb.GetComponentStatesRequest) (*milvuspb.ComponentStates, error)
}
type componentsHealthzHandler struct {
@ -62,7 +62,7 @@ type componentsHealthzHandler struct {
}
func (handler *componentsHealthzHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
states, err := handler.component.GetComponentStates(context.Background(), &internalpb.GetComponentStatesRequest{})
states, err := handler.component.GetComponentStates(context.Background(), &milvuspb.GetComponentStatesRequest{})
if err != nil {
log.Warn("failed to get component states", zap.Error(err))
@ -96,7 +96,7 @@ func (handler *componentsHealthzHandler) ServeHTTP(w http.ResponseWriter, r *htt
return
}
if states.State.StateCode != internalpb.StateCode_Healthy {
if states.State.StateCode != commonpb.StateCode_Healthy {
log.Warn("component is unhealthy", zap.String("state", states.State.StateCode.String()))
unhealthyHandler(w, r, fmt.Sprintf("state: %s", states.State.StateCode.String()))
return

21
cmd/roles/roles.go
View File

@ -27,13 +27,8 @@ import (
"syscall"
"time"
rocksmqimpl "github.com/milvus-io/milvus/internal/mq/mqimpl/rocksmq/server"
"github.com/milvus-io/milvus/internal/util/dependency"
"go.uber.org/zap"
"github.com/prometheus/client_golang/prometheus"
"github.com/milvus-io/milvus/api/commonpb"
"github.com/milvus-io/milvus/api/milvuspb"
"github.com/milvus-io/milvus/cmd/components"
"github.com/milvus-io/milvus/internal/datacoord"
"github.com/milvus-io/milvus/internal/datanode"
@ -41,17 +36,21 @@ import (
"github.com/milvus-io/milvus/internal/indexnode"
"github.com/milvus-io/milvus/internal/log"
"github.com/milvus-io/milvus/internal/metrics"
"github.com/milvus-io/milvus/internal/proto/internalpb"
rocksmqimpl "github.com/milvus-io/milvus/internal/mq/mqimpl/rocksmq/server"
"github.com/milvus-io/milvus/internal/proxy"
"github.com/milvus-io/milvus/internal/querycoord"
"github.com/milvus-io/milvus/internal/querynode"
"github.com/milvus-io/milvus/internal/rootcoord"
"github.com/milvus-io/milvus/internal/util/dependency"
"github.com/milvus-io/milvus/internal/util/etcd"
"github.com/milvus-io/milvus/internal/util/healthz"
"github.com/milvus-io/milvus/internal/util/metricsinfo"
"github.com/milvus-io/milvus/internal/util/paramtable"
"github.com/milvus-io/milvus/internal/util/trace"
"github.com/milvus-io/milvus/internal/util/typeutil"
"github.com/prometheus/client_golang/prometheus"
"go.uber.org/zap"
)
var Params paramtable.ComponentParam
@ -465,9 +464,9 @@ func (mr *MilvusRoles) Run(local bool, alias string) {
multiRoleHealthzHandler := func(w http.ResponseWriter, r *http.Request) {
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
defer cancel()
req := &internalpb.GetComponentStatesRequest{}
validateResp := func(resp *internalpb.ComponentStates, err error) bool {
return err == nil && resp != nil && resp.GetState().GetStateCode() == internalpb.StateCode_Healthy
req := &milvuspb.GetComponentStatesRequest{}
validateResp := func(resp *milvuspb.ComponentStates, err error) bool {
return err == nil && resp != nil && resp.GetState().GetStateCode() == commonpb.StateCode_Healthy
}
if mr.EnableRootCoord {
if rc == nil || !validateResp(rc.GetComponentStates(ctx, req)) {

2
docs/developer_guides/appendix_a_basic_components.md
View File

@ -9,7 +9,7 @@ type Component interface {
Init() error
Start() error
Stop() error
GetComponentStates(ctx context.Context) (*internalpb.ComponentStates, error)
GetComponentStates(ctx context.Context) (*milvuspb.ComponentStates, error)
GetStatisticsChannel(ctx context.Context) (*milvuspb.StringResponse, error)
Register() error
}

2
docs/developer_guides/chap05_proxy.md
View File

@ -361,7 +361,7 @@ type Proxy struct {
ip string
port int
stateCode internalpb.StateCode
stateCode commonpb.StateCode
rootCoordClient RootCoordClient
indexCoordClient IndexCoordClient

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

@ -226,7 +226,7 @@ static void InitDefaultsscc_info_Status_common_2eproto() {
{{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_Status_common_2eproto}, {}};
static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_common_2eproto[11];
static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_common_2eproto[11];
static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_common_2eproto[12];
static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_common_2eproto = nullptr;
const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_common_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
@ -467,12 +467,13 @@ const char descriptor_table_protodef_common_2eproto[] PROTOBUF_SECTION_VARIABLE(
"p\020\023\022\027\n\023PrivilegeUpdateUser\020\024\022\032\n\026Privileg"
"eDropOwnership\020\025\022\034\n\030PrivilegeSelectOwner"
"ship\020\026\022\034\n\030PrivilegeManageOwnership\020\027\022\027\n\023"
"PrivilegeSelectUser\020\030:^\n\021privilege_ext_o"
"bj\022\037.google.protobuf.MessageOptions\030\351\007 \001"
"(\0132!.milvus.proto.common.PrivilegeExtBL\n"
"\016io.milvus.grpcB\013CommonProtoP\001Z(github.c"
"om/milvus-io/milvus/api/commonpb\240\001\001b\006pro"
"to3"
"PrivilegeSelectUser\020\030*E\n\tStateCode\022\020\n\014In"
"itializing\020\000\022\013\n\007Healthy\020\001\022\014\n\010Abnormal\020\002\022"
"\013\n\007StandBy\020\003:^\n\021privilege_ext_obj\022\037.goog"
"le.protobuf.MessageOptions\030\351\007 \001(\0132!.milv"
"us.proto.common.PrivilegeExtBL\n\016io.milvu"
"s.grpcB\013CommonProtoP\001Z(github.com/milvus"
"-io/milvus/api/commonpb\240\001\001b\006proto3"
;
static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_common_2eproto_deps[1] = {
&::descriptor_table_google_2fprotobuf_2fdescriptor_2eproto,
@ -493,7 +494,7 @@ static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_com
static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_common_2eproto_once;
static bool descriptor_table_common_2eproto_initialized = false;
const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_common_2eproto = {
&descriptor_table_common_2eproto_initialized, descriptor_table_protodef_common_2eproto, "common.proto", 5283,
&descriptor_table_common_2eproto_initialized, descriptor_table_protodef_common_2eproto, "common.proto", 5354,
&descriptor_table_common_2eproto_once, descriptor_table_common_2eproto_sccs, descriptor_table_common_2eproto_deps, 11, 1,
schemas, file_default_instances, TableStruct_common_2eproto::offsets,
file_level_metadata_common_2eproto, 11, file_level_enum_descriptors_common_2eproto, file_level_service_descriptors_common_2eproto,
@ -829,6 +830,22 @@ bool ObjectPrivilege_IsValid(int value) {
}
}
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* StateCode_descriptor() {
::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_common_2eproto);
return file_level_enum_descriptors_common_2eproto[11];
}
bool StateCode_IsValid(int value) {
switch (value) {
case 0:
case 1:
case 2:
case 3:
return true;
default:
return false;
}
}
// ===================================================================

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

@ -558,6 +558,33 @@ inline bool ObjectPrivilege_Parse(
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ObjectPrivilege>(
ObjectPrivilege_descriptor(), name, value);
}
enum StateCode : int {
Initializing = 0,
Healthy = 1,
Abnormal = 2,
StandBy = 3,
StateCode_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
StateCode_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool StateCode_IsValid(int value);
constexpr StateCode StateCode_MIN = Initializing;
constexpr StateCode StateCode_MAX = StandBy;
constexpr int StateCode_ARRAYSIZE = StateCode_MAX + 1;
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* StateCode_descriptor();
template<typename T>
inline const std::string& StateCode_Name(T enum_t_value) {
static_assert(::std::is_same<T, StateCode>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function StateCode_Name.");
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
StateCode_descriptor(), enum_t_value);
}
inline bool StateCode_Parse(
const std::string& name, StateCode* value) {
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<StateCode>(
StateCode_descriptor(), name, value);
}
// ===================================================================
class Status :
@ -3141,6 +3168,11 @@ template <>
inline const EnumDescriptor* GetEnumDescriptor< ::milvus::proto::common::ObjectPrivilege>() {
return ::milvus::proto::common::ObjectPrivilege_descriptor();
}
template <> struct is_proto_enum< ::milvus::proto::common::StateCode> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::milvus::proto::common::StateCode>() {
return ::milvus::proto::common::StateCode_descriptor();
}
PROTOBUF_NAMESPACE_CLOSE

32
internal/datacoord/mock_test.go
View File

@ -119,7 +119,7 @@ func newTestSchema() *schemapb.CollectionSchema {
type mockDataNodeClient struct {
id int64
state internalpb.StateCode
state commonpb.StateCode
ch chan interface{}
compactionStateResp *datapb.CompactionStateResponse
addImportSegmentResp *datapb.AddImportSegmentResponse
@ -129,7 +129,7 @@ type mockDataNodeClient struct {
func newMockDataNodeClient(id int64, ch chan interface{}) (*mockDataNodeClient, error) {
return &mockDataNodeClient{
id: id,
state: internalpb.StateCode_Initializing,
state: commonpb.StateCode_Initializing,
ch: ch,
addImportSegmentResp: &datapb.AddImportSegmentResponse{
Status: &commonpb.Status{
@ -144,7 +144,7 @@ func (c *mockDataNodeClient) Init() error {
}
func (c *mockDataNodeClient) Start() error {
c.state = internalpb.StateCode_Healthy
c.state = commonpb.StateCode_Healthy
return nil
}
@ -152,9 +152,9 @@ func (c *mockDataNodeClient) Register() error {
return nil
}
func (c *mockDataNodeClient) GetComponentStates(ctx context.Context) (*internalpb.ComponentStates, error) {
return &internalpb.ComponentStates{
State: &internalpb.ComponentInfo{
func (c *mockDataNodeClient) GetComponentStates(ctx context.Context) (*milvuspb.ComponentStates, error) {
return &milvuspb.ComponentStates{
State: &milvuspb.ComponentInfo{
NodeID: c.id,
StateCode: c.state,
},
@ -257,12 +257,12 @@ func (c *mockDataNodeClient) SyncSegments(ctx context.Context, req *datapb.SyncS
}
func (c *mockDataNodeClient) Stop() error {
c.state = internalpb.StateCode_Abnormal
c.state = commonpb.StateCode_Abnormal
return nil
}
type mockRootCoordService struct {
state internalpb.StateCode
state commonpb.StateCode
cnt int64
}
@ -279,7 +279,7 @@ func (m *mockRootCoordService) AlterAlias(ctx context.Context, req *milvuspb.Alt
}
func newMockRootCoordService() *mockRootCoordService {
return &mockRootCoordService{state: internalpb.StateCode_Healthy}
return &mockRootCoordService{state: commonpb.StateCode_Healthy}
}
func (m *mockRootCoordService) GetTimeTickChannel(ctx context.Context) (*milvuspb.StringResponse, error) {
@ -295,7 +295,7 @@ func (m *mockRootCoordService) Start() error {
}
func (m *mockRootCoordService) Stop() error {
m.state = internalpb.StateCode_Abnormal
m.state = commonpb.StateCode_Abnormal
return nil
}
@ -303,15 +303,15 @@ func (m *mockRootCoordService) Register() error {
return nil
}
func (m *mockRootCoordService) GetComponentStates(ctx context.Context) (*internalpb.ComponentStates, error) {
return &internalpb.ComponentStates{
State: &internalpb.ComponentInfo{
func (m *mockRootCoordService) GetComponentStates(ctx context.Context) (*milvuspb.ComponentStates, error) {
return &milvuspb.ComponentStates{
State: &milvuspb.ComponentInfo{
NodeID: 0,
Role: "",
StateCode: m.state,
ExtraInfo: []*commonpb.KeyValuePair{},
},
SubcomponentStates: []*internalpb.ComponentInfo{},
SubcomponentStates: []*milvuspb.ComponentInfo{},
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_Success,
Reason: "",
@ -385,7 +385,7 @@ func (m *mockRootCoordService) ShowPartitions(ctx context.Context, req *milvuspb
//global timestamp allocator
func (m *mockRootCoordService) AllocTimestamp(ctx context.Context, req *rootcoordpb.AllocTimestampRequest) (*rootcoordpb.AllocTimestampResponse, error) {
if m.state != internalpb.StateCode_Healthy {
if m.state != commonpb.StateCode_Healthy {
return &rootcoordpb.AllocTimestampResponse{Status: &commonpb.Status{ErrorCode: commonpb.ErrorCode_UnexpectedError}}, nil
}
@ -403,7 +403,7 @@ func (m *mockRootCoordService) AllocTimestamp(ctx context.Context, req *rootcoor
}
func (m *mockRootCoordService) AllocID(ctx context.Context, req *rootcoordpb.AllocIDRequest) (*rootcoordpb.AllocIDResponse, error) {
if m.state != internalpb.StateCode_Healthy {
if m.state != commonpb.StateCode_Healthy {
return &rootcoordpb.AllocIDResponse{Status: &commonpb.Status{ErrorCode: commonpb.ErrorCode_UnexpectedError}}, nil
}
val := atomic.AddInt64(&m.cnt, int64(req.Count))

26
internal/datacoord/server.go
View File

@ -77,20 +77,6 @@ type (
Timestamp = typeutil.Timestamp
)
// ServerState type alias, presents datacoord Server State
type ServerState = int64
const (
// ServerStateStopped state stands for just created or stopped `Server` instance
ServerStateStopped ServerState = 0
// ServerStateInitializing state stands initializing `Server` instance
ServerStateInitializing ServerState = 1
// ServerStateHealthy state stands for healthy `Server` instance
ServerStateHealthy ServerState = 2
// ServerStateStandby state stands for standby `Server` instance
ServerStateStandby ServerState = 3
)
type dataNodeCreatorFunc func(ctx context.Context, addr string) (types.DataNode, error)
type rootCoordCreatorFunc func(ctx context.Context, metaRootPath string, etcdClient *clientv3.Client) (types.RootCoord, error)
@ -107,7 +93,7 @@ type Server struct {
serverLoopCancel context.CancelFunc
serverLoopWg sync.WaitGroup
quitCh chan struct{}
isServing ServerState
stateCode atomic.Value
helper ServerHelper
etcdCli *clientv3.Client
@ -265,7 +251,7 @@ func (s *Server) initSession() error {
// Init change server state to Initializing
func (s *Server) Init() error {
var err error
atomic.StoreInt64(&s.isServing, ServerStateInitializing)
s.stateCode.Store(commonpb.StateCode_Initializing)
s.factory.Init(&Params)
if err = s.initRootCoordClient(); err != nil {
@ -324,14 +310,14 @@ func (s *Server) Start() error {
// todo complete the activateFunc
log.Info("datacoord switch from standby to active, activating")
s.startServerLoop()
atomic.StoreInt64(&s.isServing, ServerStateHealthy)
s.stateCode.Store(commonpb.StateCode_Healthy)
logutil.Logger(s.ctx).Debug("startup success")
}
atomic.StoreInt64(&s.isServing, ServerStateStandby)
s.stateCode.Store(commonpb.StateCode_StandBy)
logutil.Logger(s.ctx).Debug("DataCoord enter standby mode successfully")
} else {
s.startServerLoop()
atomic.StoreInt64(&s.isServing, ServerStateHealthy)
s.stateCode.Store(commonpb.StateCode_Healthy)
logutil.Logger(s.ctx).Debug("DataCoord startup successfully")
}
@ -867,7 +853,7 @@ func (s *Server) initRootCoordClient() error {
// if Server is healthy, set server state to stopped, release etcd session,
// stop message stream client and stop server loops
func (s *Server) Stop() error {
if !atomic.CompareAndSwapInt64(&s.isServing, ServerStateHealthy, ServerStateStopped) {
if !s.stateCode.CompareAndSwap(commonpb.StateCode_Healthy, commonpb.StateCode_Abnormal) {
return nil
}
logutil.Logger(s.ctx).Debug("server shutdown")

55
internal/datacoord/server_test.go
View File

@ -25,7 +25,6 @@ import (
"os/signal"
"path"
"strconv"
"sync/atomic"
"syscall"
"testing"
"time"
@ -286,9 +285,9 @@ func TestFlush(t *testing.T) {
//resp, err := svr.GetComponentStates(context.TODO())
//assert.Nil(t, err)
//assert.EqualValues(t, commonpb.ErrorCode_Success, resp.Status.ErrorCode)
//assert.EqualValues(t, internalpb.StateCode_Healthy, resp.State.StateCode)
//assert.EqualValues(t, commonpb.StateCode_Healthy, resp.State.StateCode)
//assert.EqualValues(t, 1, len(resp.SubcomponentStates))
//assert.EqualValues(t, internalpb.StateCode_Healthy, resp.SubcomponentStates[0].StateCode)
//assert.EqualValues(t, commonpb.StateCode_Healthy, resp.SubcomponentStates[0].StateCode)
//}
func TestGetTimeTickChannel(t *testing.T) {
@ -580,16 +579,16 @@ func TestGetComponentStates(t *testing.T) {
svr.session = &sessionutil.Session{}
svr.session.UpdateRegistered(true)
type testCase struct {
state ServerState
code internalpb.StateCode
state commonpb.StateCode
code commonpb.StateCode
}
cases := []testCase{
{state: ServerStateStopped, code: internalpb.StateCode_Abnormal},
{state: ServerStateInitializing, code: internalpb.StateCode_Initializing},
{state: ServerStateHealthy, code: internalpb.StateCode_Healthy},
{state: commonpb.StateCode_Abnormal, code: commonpb.StateCode_Abnormal},
{state: commonpb.StateCode_Initializing, code: commonpb.StateCode_Initializing},
{state: commonpb.StateCode_Healthy, code: commonpb.StateCode_Healthy},
}
for _, tc := range cases {
atomic.StoreInt64(&svr.isServing, tc.state)
svr.stateCode.Store(tc.state)
resp, err := svr.GetComponentStates(context.Background())
assert.Nil(t, err)
assert.Equal(t, commonpb.ErrorCode_Success, resp.GetStatus().GetErrorCode())
@ -985,14 +984,14 @@ func TestServer_ShowConfigurations(t *testing.T) {
}
// server is closed
stateSave := atomic.LoadInt64(&svr.isServing)
atomic.StoreInt64(&svr.isServing, ServerStateInitializing)
stateSave := svr.stateCode.Load()
svr.stateCode.Store(commonpb.StateCode_Initializing)
resp, err := svr.ShowConfigurations(svr.ctx, req)
assert.Nil(t, err)
assert.Equal(t, commonpb.ErrorCode_UnexpectedError, resp.Status.ErrorCode)
// normal case
atomic.StoreInt64(&svr.isServing, stateSave)
svr.stateCode.Store(stateSave)
resp, err = svr.ShowConfigurations(svr.ctx, req)
assert.NoError(t, err)
@ -1008,12 +1007,12 @@ func TestServer_GetMetrics(t *testing.T) {
var err error
// server is closed
stateSave := atomic.LoadInt64(&svr.isServing)
atomic.StoreInt64(&svr.isServing, ServerStateInitializing)
stateSave := svr.stateCode.Load()
svr.stateCode.Store(commonpb.StateCode_Initializing)
resp, err := svr.GetMetrics(svr.ctx, &milvuspb.GetMetricsRequest{})
assert.Nil(t, err)
assert.NotEqual(t, commonpb.ErrorCode_Success, resp.Status.ErrorCode)
atomic.StoreInt64(&svr.isServing, stateSave)
svr.stateCode.Store(stateSave)
// failed to parse metric type
invalidRequest := "invalid request"
@ -2215,7 +2214,7 @@ func TestGetCompactionState(t *testing.T) {
Params.DataCoordCfg.EnableCompaction = true
t.Run("test get compaction state with new compactionhandler", func(t *testing.T) {
svr := &Server{}
svr.isServing = ServerStateHealthy
svr.stateCode.Store(commonpb.StateCode_Healthy)
svr.compactionHandler = &mockCompactionHandler{
methods: map[string]interface{}{
@ -2234,7 +2233,7 @@ func TestGetCompactionState(t *testing.T) {
})
t.Run("test get compaction state in running", func(t *testing.T) {
svr := &Server{}
svr.isServing = ServerStateHealthy
svr.stateCode.Store(commonpb.StateCode_Healthy)
svr.compactionHandler = &mockCompactionHandler{
methods: map[string]interface{}{
@ -2267,7 +2266,7 @@ func TestGetCompactionState(t *testing.T) {
t.Run("with closed server", func(t *testing.T) {
svr := &Server{}
svr.isServing = ServerStateStopped
svr.stateCode.Store(commonpb.StateCode_Abnormal)
resp, err := svr.GetCompactionState(context.Background(), &milvuspb.GetCompactionStateRequest{})
assert.Nil(t, err)
@ -2280,7 +2279,7 @@ func TestManualCompaction(t *testing.T) {
Params.DataCoordCfg.EnableCompaction = true
t.Run("test manual compaction successfully", func(t *testing.T) {
svr := &Server{allocator: &MockAllocator{}}
svr.isServing = ServerStateHealthy
svr.stateCode.Store(commonpb.StateCode_Healthy)
svr.compactionTrigger = &mockCompactionTrigger{
methods: map[string]interface{}{
"forceTriggerCompaction": func(collectionID int64, ct *compactTime) (UniqueID, error) {
@ -2299,7 +2298,7 @@ func TestManualCompaction(t *testing.T) {
t.Run("test manual compaction failure", func(t *testing.T) {
svr := &Server{allocator: &MockAllocator{}}
svr.isServing = ServerStateHealthy
svr.stateCode.Store(commonpb.StateCode_Healthy)
svr.compactionTrigger = &mockCompactionTrigger{
methods: map[string]interface{}{
"forceTriggerCompaction": func(collectionID int64, ct *compactTime) (UniqueID, error) {
@ -2318,7 +2317,7 @@ func TestManualCompaction(t *testing.T) {
t.Run("test manual compaction with closed server", func(t *testing.T) {
svr := &Server{}
svr.isServing = ServerStateStopped
svr.stateCode.Store(commonpb.StateCode_Abnormal)
svr.compactionTrigger = &mockCompactionTrigger{
methods: map[string]interface{}{
"forceTriggerCompaction": func(collectionID int64, ct *compactTime) (UniqueID, error) {
@ -2340,7 +2339,8 @@ func TestManualCompaction(t *testing.T) {
func TestGetCompactionStateWithPlans(t *testing.T) {
t.Run("test get compaction state successfully", func(t *testing.T) {
svr := &Server{}
svr.isServing = ServerStateHealthy
svr.stateCode.Store(commonpb.StateCode_Healthy)
svr.compactionHandler = &mockCompactionHandler{
methods: map[string]interface{}{
"getCompactionTasksBySignalID": func(signalID int64) []*compactionTask {
@ -2364,7 +2364,7 @@ func TestGetCompactionStateWithPlans(t *testing.T) {
t.Run("test get compaction state with closed server", func(t *testing.T) {
svr := &Server{}
svr.isServing = ServerStateStopped
svr.stateCode.Store(commonpb.StateCode_Abnormal)
svr.compactionHandler = &mockCompactionHandler{
methods: map[string]interface{}{
"getCompactionTasksBySignalID": func(signalID int64) []*compactionTask {
@ -2575,7 +2575,6 @@ func TestPostFlush(t *testing.T) {
func TestGetFlushState(t *testing.T) {
t.Run("get flush state with all flushed segments", func(t *testing.T) {
svr := &Server{
isServing: ServerStateHealthy,
meta: &meta{
segments: &SegmentsInfo{
segments: map[int64]*SegmentInfo{
@ -2595,7 +2594,7 @@ func TestGetFlushState(t *testing.T) {
},
},
}
svr.stateCode.Store(commonpb.StateCode_Healthy)
resp, err := svr.GetFlushState(context.TODO(), &milvuspb.GetFlushStateRequest{SegmentIDs: []int64{1, 2}})
assert.Nil(t, err)
assert.EqualValues(t, &milvuspb.GetFlushStateResponse{
@ -2606,7 +2605,6 @@ func TestGetFlushState(t *testing.T) {
t.Run("get flush state with unflushed segments", func(t *testing.T) {
svr := &Server{
isServing: ServerStateHealthy,
meta: &meta{
segments: &SegmentsInfo{
segments: map[int64]*SegmentInfo{
@ -2626,6 +2624,7 @@ func TestGetFlushState(t *testing.T) {
},
},
}
svr.stateCode.Store(commonpb.StateCode_Healthy)
resp, err := svr.GetFlushState(context.TODO(), &milvuspb.GetFlushStateRequest{SegmentIDs: []int64{1, 2}})
assert.Nil(t, err)
@ -2637,7 +2636,6 @@ func TestGetFlushState(t *testing.T) {
t.Run("get flush state with compacted segments", func(t *testing.T) {
svr := &Server{
isServing: ServerStateHealthy,
meta: &meta{
segments: &SegmentsInfo{
segments: map[int64]*SegmentInfo{
@ -2657,6 +2655,7 @@ func TestGetFlushState(t *testing.T) {
},
},
}
svr.stateCode.Store(commonpb.StateCode_Healthy)
resp, err := svr.GetFlushState(context.TODO(), &milvuspb.GetFlushStateRequest{SegmentIDs: []int64{1, 2}})
assert.Nil(t, err)
@ -3345,7 +3344,7 @@ func testDataCoordBase(t *testing.T, opts ...Option) *Server {
resp, err := svr.GetComponentStates(context.Background())
assert.Nil(t, err)
assert.Equal(t, commonpb.ErrorCode_Success, resp.GetStatus().GetErrorCode())
assert.Equal(t, internalpb.StateCode_Healthy, resp.GetState().GetStateCode())
assert.Equal(t, commonpb.StateCode_Healthy, resp.GetState().GetStateCode())
// stop channal watch state watcher in tests
if svr.channelManager != nil && svr.channelManager.stopChecker != nil {

30
internal/datacoord/services.go
View File

@ -21,7 +21,6 @@ import (
"fmt"
"math/rand"
"strconv"
"sync/atomic"
"time"
"github.com/milvus-io/milvus/api/commonpb"
@ -42,7 +41,7 @@ import (
// checks whether server in Healthy State
func (s *Server) isClosed() bool {
return atomic.LoadInt64(&s.isServing) != ServerStateHealthy
return s.stateCode.Load() != commonpb.StateCode_Healthy
}
// GetTimeTickChannel legacy API, returns time tick channel name
@ -552,34 +551,33 @@ func (s *Server) SetSegmentState(ctx context.Context, req *datapb.SetSegmentStat
}, nil
}
func (s *Server) GetStateCode() commonpb.StateCode {
code := s.stateCode.Load()
if code == nil {
return commonpb.StateCode_Abnormal
}
return code.(commonpb.StateCode)
}
// GetComponentStates returns DataCoord's current state
func (s *Server) GetComponentStates(ctx context.Context) (*internalpb.ComponentStates, error) {
func (s *Server) GetComponentStates(ctx context.Context) (*milvuspb.ComponentStates, error) {
nodeID := common.NotRegisteredID
if s.session != nil && s.session.Registered() {
nodeID = s.session.ServerID // or Params.NodeID
}
resp := &internalpb.ComponentStates{
State: &internalpb.ComponentInfo{
code := s.GetStateCode()
resp := &milvuspb.ComponentStates{
State: &milvuspb.ComponentInfo{
// NodeID: Params.NodeID, // will race with Server.Register()
NodeID: nodeID,
Role: "datacoord",
StateCode: 0,
StateCode: code,
},
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_Success,
Reason: "",
},
}
state := atomic.LoadInt64(&s.isServing)
switch state {
case ServerStateInitializing:
resp.State.StateCode = internalpb.StateCode_Initializing
case ServerStateHealthy:
resp.State.StateCode = internalpb.StateCode_Healthy
default:
resp.State.StateCode = internalpb.StateCode_Abnormal
}
return resp, nil
}

38
internal/datanode/data_node.go
View File

@ -104,11 +104,11 @@ var rateCol *rateCollector
// `clearSignal` is a signal channel for releasing the flowgraph resources.
// `segmentCache` stores all flushing and flushed segments.
type DataNode struct {
ctx context.Context
cancel context.CancelFunc
Role string
State atomic.Value // internalpb.StateCode_Initializing
ctx context.Context
cancel context.CancelFunc
Role string
State atomic.Value // commonpb.StateCode_Initializing
stateCode atomic.Value // commonpb.StateCode_Initializing
flowgraphManager *flowgraphManager
eventManagerMap sync.Map // vchannel name -> channelEventManager
@ -148,7 +148,7 @@ func NewDataNode(ctx context.Context, factory dependency.Factory) *DataNode {
flowgraphManager: newFlowgraphManager(),
clearSignal: make(chan string, 100),
}
node.UpdateStateCode(internalpb.StateCode_Abnormal)
node.UpdateStateCode(commonpb.StateCode_Abnormal)
return node
}
@ -513,22 +513,22 @@ func (node *DataNode) Start() error {
Params.DataNodeCfg.CreatedTime = time.Now()
Params.DataNodeCfg.UpdatedTime = time.Now()
node.UpdateStateCode(internalpb.StateCode_Healthy)
node.UpdateStateCode(commonpb.StateCode_Healthy)
return nil
}
// UpdateStateCode updates datanode's state code
func (node *DataNode) UpdateStateCode(code internalpb.StateCode) {
node.State.Store(code)
func (node *DataNode) UpdateStateCode(code commonpb.StateCode) {
node.stateCode.Store(code)
}
// GetStateCode return datanode's state code
func (node *DataNode) GetStateCode() internalpb.StateCode {
return node.State.Load().(internalpb.StateCode)
func (node *DataNode) GetStateCode() commonpb.StateCode {
return node.stateCode.Load().(commonpb.StateCode)
}
func (node *DataNode) isHealthy() bool {
return node.GetStateCode() == internalpb.StateCode_Healthy
return node.GetStateCode() == commonpb.StateCode_Healthy
}
// WatchDmChannels is not in use
@ -542,20 +542,20 @@ func (node *DataNode) WatchDmChannels(ctx context.Context, in *datapb.WatchDmCha
}
// GetComponentStates will return current state of DataNode
func (node *DataNode) GetComponentStates(ctx context.Context) (*internalpb.ComponentStates, error) {
log.Debug("DataNode current state", zap.Any("State", node.State.Load()))
func (node *DataNode) GetComponentStates(ctx context.Context) (*milvuspb.ComponentStates, error) {
log.Debug("DataNode current state", zap.Any("State", node.stateCode.Load()))
nodeID := common.NotRegisteredID
if node.session != nil && node.session.Registered() {
nodeID = node.session.ServerID
}
states := &internalpb.ComponentStates{
State: &internalpb.ComponentInfo{
states := &milvuspb.ComponentStates{
State: &milvuspb.ComponentInfo{
// NodeID: Params.NodeID, // will race with DataNode.Register()
NodeID: nodeID,
Role: node.Role,
StateCode: node.State.Load().(internalpb.StateCode),
StateCode: node.stateCode.Load().(commonpb.StateCode),
},
SubcomponentStates: make([]*internalpb.ComponentInfo, 0),
SubcomponentStates: make([]*milvuspb.ComponentInfo, 0),
Status: &commonpb.Status{ErrorCode: commonpb.ErrorCode_Success},
}
return states, nil
@ -679,7 +679,7 @@ func (node *DataNode) ResendSegmentStats(ctx context.Context, req *datapb.Resend
// Stop will release DataNode resources and shutdown datanode
func (node *DataNode) Stop() error {
// https://github.com/milvus-io/milvus/issues/12282
node.UpdateStateCode(internalpb.StateCode_Abnormal)
node.UpdateStateCode(commonpb.StateCode_Abnormal)
node.cancel()
node.flowgraphManager.dropAll()

16
internal/datanode/data_node_test.go
View File

@ -181,10 +181,10 @@ func TestDataNode(t *testing.T) {
})
t.Run("Test GetCompactionState unhealthy", func(t *testing.T) {
node.UpdateStateCode(internalpb.StateCode_Abnormal)
node.UpdateStateCode(commonpb.StateCode_Abnormal)
resp, _ := node.GetCompactionState(ctx, nil)
assert.Equal(t, "DataNode is unhealthy", resp.GetStatus().GetReason())
node.UpdateStateCode(internalpb.StateCode_Healthy)
node.UpdateStateCode(commonpb.StateCode_Healthy)
})
t.Run("Test FlushSegments", func(t *testing.T) {
@ -362,12 +362,12 @@ func TestDataNode(t *testing.T) {
//test closed server
node := &DataNode{}
node.session = &sessionutil.Session{ServerID: 1}
node.State.Store(internalpb.StateCode_Abnormal)
node.stateCode.Store(commonpb.StateCode_Abnormal)
resp, err := node.ShowConfigurations(ctx, req)
assert.NoError(t, err)
assert.Equal(t, commonpb.ErrorCode_UnexpectedError, resp.Status.ErrorCode)
node.State.Store(internalpb.StateCode_Healthy)
node.stateCode.Store(commonpb.StateCode_Healthy)
resp, err = node.ShowConfigurations(ctx, req)
assert.NoError(t, err)
@ -382,11 +382,11 @@ func TestDataNode(t *testing.T) {
node.session = &sessionutil.Session{ServerID: 1}
node.flowgraphManager = newFlowgraphManager()
// server is closed
node.State.Store(internalpb.StateCode_Abnormal)
node.stateCode.Store(commonpb.StateCode_Abnormal)
resp, err := node.GetMetrics(ctx, &milvuspb.GetMetricsRequest{})
assert.NoError(t, err)
assert.NotEqual(t, commonpb.ErrorCode_Success, resp.Status.ErrorCode)
node.State.Store(internalpb.StateCode_Healthy)
node.stateCode.Store(commonpb.StateCode_Healthy)
// failed to parse metric type
invalidRequest := "invalid request"
@ -594,7 +594,7 @@ func TestDataNode(t *testing.T) {
assert.NoError(t, err)
assert.Equal(t, commonpb.ErrorCode_UnexpectedError, stat.GetErrorCode())
node.State.Store(internalpb.StateCode_Abnormal)
node.stateCode.Store(commonpb.StateCode_Abnormal)
stat, err = node.Import(context.WithValue(ctx, ctxKey{}, ""), req)
assert.NoError(t, err)
assert.Equal(t, commonpb.ErrorCode_UnexpectedError, stat.GetErrorCode())
@ -1068,7 +1068,7 @@ func TestWatchChannel(t *testing.T) {
func TestDataNode_GetComponentStates(t *testing.T) {
n := &DataNode{}
n.State.Store(internalpb.StateCode_Healthy)
n.stateCode.Store(commonpb.StateCode_Healthy)
resp, err := n.GetComponentStates(context.Background())
assert.NoError(t, err)
assert.Equal(t, commonpb.ErrorCode_Success, resp.Status.ErrorCode)

8
internal/datanode/mock_test.go
View File

@ -1002,10 +1002,10 @@ func (m *RootCoordFactory) DescribeCollection(ctx context.Context, in *milvuspb.
return resp, nil
}
func (m *RootCoordFactory) GetComponentStates(ctx context.Context) (*internalpb.ComponentStates, error) {
return &internalpb.ComponentStates{
State: &internalpb.ComponentInfo{},
SubcomponentStates: make([]*internalpb.ComponentInfo, 0),
func (m *RootCoordFactory) GetComponentStates(ctx context.Context) (*milvuspb.ComponentStates, error) {
return &milvuspb.ComponentStates{
State: &milvuspb.ComponentInfo{},
SubcomponentStates: make([]*milvuspb.ComponentInfo, 0),
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_Success,
},

6
internal/distributed/datacoord/client/client.go
View File

@ -118,17 +118,17 @@ func (c *Client) Register() error {
}
// GetComponentStates calls DataCoord GetComponentStates services
func (c *Client) GetComponentStates(ctx context.Context) (*internalpb.ComponentStates, error) {
func (c *Client) GetComponentStates(ctx context.Context) (*milvuspb.ComponentStates, error) {
ret, err := c.grpcClient.ReCall(ctx, func(client interface{}) (interface{}, error) {
if !funcutil.CheckCtxValid(ctx) {
return nil, ctx.Err()
}
return client.(datapb.DataCoordClient).GetComponentStates(ctx, &internalpb.GetComponentStatesRequest{})
return client.(datapb.DataCoordClient).GetComponentStates(ctx, &milvuspb.GetComponentStatesRequest{})
})
if err != nil || ret == nil {
return nil, err
}
return ret.(*internalpb.ComponentStates), err
return ret.(*milvuspb.ComponentStates), err
}
// GetTimeTickChannel return the name of time tick channel.

2
internal/distributed/datacoord/service.go
View File

@ -243,7 +243,7 @@ func (s *Server) Run() error {
}
// GetComponentStates gets states of datacoord and datanodes
func (s *Server) GetComponentStates(ctx context.Context, req *internalpb.GetComponentStatesRequest) (*internalpb.ComponentStates, error) {
func (s *Server) GetComponentStates(ctx context.Context, req *milvuspb.GetComponentStatesRequest) (*milvuspb.ComponentStates, error) {
return s.dataCoord.GetComponentStates(ctx)
}

6
internal/distributed/datacoord/service_test.go
View File

@ -33,7 +33,7 @@ import (
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
type MockDataCoord struct {
states *internalpb.ComponentStates
states *milvuspb.ComponentStates
status *commonpb.Status
err error
initErr error
@ -91,7 +91,7 @@ func (m *MockDataCoord) SetEtcdClient(etcdClient *clientv3.Client) {
func (m *MockDataCoord) SetIndexCoord(indexCoord types.IndexCoord) {
}
func (m *MockDataCoord) GetComponentStates(ctx context.Context) (*internalpb.ComponentStates, error) {
func (m *MockDataCoord) GetComponentStates(ctx context.Context) (*milvuspb.ComponentStates, error) {
return m.states, m.err
}
@ -237,7 +237,7 @@ func Test_NewServer(t *testing.T) {
t.Run("GetComponentStates", func(t *testing.T) {
server.dataCoord = &MockDataCoord{
states: &internalpb.ComponentStates{},
states: &milvuspb.ComponentStates{},
}
states, err := server.GetComponentStates(ctx, nil)
assert.Nil(t, err)

6
internal/distributed/datanode/client/client.go
View File

@ -98,17 +98,17 @@ func (c *Client) getAddr() (string, error) {
}
// GetComponentStates returns ComponentStates
func (c *Client) GetComponentStates(ctx context.Context) (*internalpb.ComponentStates, error) {
func (c *Client) GetComponentStates(ctx context.Context) (*milvuspb.ComponentStates, error) {
ret, err := c.grpcClient.ReCall(ctx, func(client interface{}) (interface{}, error) {
if !funcutil.CheckCtxValid(ctx) {
return nil, ctx.Err()
}
return client.(datapb.DataNodeClient).GetComponentStates(ctx, &internalpb.GetComponentStatesRequest{})
return client.(datapb.DataNodeClient).GetComponentStates(ctx, &milvuspb.GetComponentStatesRequest{})
})
if err != nil || ret == nil {
return nil, err
}
return ret.(*internalpb.ComponentStates), err
return ret.(*milvuspb.ComponentStates), err
}
// GetStatisticsChannel return the statistics channel in string

7
internal/distributed/datanode/service.go
View File

@ -301,7 +301,8 @@ func (s *Server) init() error {
}
}
s.datanode.UpdateStateCode(internalpb.StateCode_Initializing)
s.datanode.UpdateStateCode(commonpb.StateCode_Initializing)
if err := s.datanode.Init(); err != nil {
log.Error("failed to init DataNode server", zap.Error(err))
return err
@ -324,7 +325,7 @@ func (s *Server) start() error {
}
// GetComponentStates gets the component states of Datanode
func (s *Server) GetComponentStates(ctx context.Context, req *internalpb.GetComponentStatesRequest) (*internalpb.ComponentStates, error) {
func (s *Server) GetComponentStates(ctx context.Context, req *milvuspb.GetComponentStatesRequest) (*milvuspb.ComponentStates, error) {
return s.datanode.GetComponentStates(ctx)
}
@ -339,7 +340,7 @@ func (s *Server) WatchDmChannels(ctx context.Context, req *datapb.WatchDmChannel
}
func (s *Server) FlushSegments(ctx context.Context, req *datapb.FlushSegmentsRequest) (*commonpb.Status, error) {
if s.datanode.GetStateCode() != internalpb.StateCode_Healthy {
if s.datanode.GetStateCode() != commonpb.StateCode_Healthy {
return &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: "DataNode isn't healthy.",

36
internal/distributed/datanode/service_test.go
View File

@ -36,8 +36,8 @@ import (
type MockDataNode struct {
nodeID typeutil.UniqueID
stateCode internalpb.StateCode
states *internalpb.ComponentStates
stateCode commonpb.StateCode
states *milvuspb.ComponentStates
status *commonpb.Status
err error
initErr error
@ -72,11 +72,11 @@ func (m *MockDataNode) SetNodeID(id typeutil.UniqueID) {
m.nodeID = id
}
func (m *MockDataNode) UpdateStateCode(code internalpb.StateCode) {
func (m *MockDataNode) UpdateStateCode(code commonpb.StateCode) {
m.stateCode = code
}
func (m *MockDataNode) GetStateCode() internalpb.StateCode {
func (m *MockDataNode) GetStateCode() commonpb.StateCode {
return m.stateCode
}
@ -88,7 +88,7 @@ func (m *MockDataNode) SetDataCoord(dc types.DataCoord) error {
return m.err
}
func (m *MockDataNode) GetComponentStates(ctx context.Context) (*internalpb.ComponentStates, error) {
func (m *MockDataNode) GetComponentStates(ctx context.Context) (*milvuspb.ComponentStates, error) {
return m.states, m.err
}
@ -150,17 +150,17 @@ func (m *mockDataCoord) Init() error {
func (m *mockDataCoord) Start() error {
return nil
}
func (m *mockDataCoord) GetComponentStates(ctx context.Context) (*internalpb.ComponentStates, error) {
return &internalpb.ComponentStates{
State: &internalpb.ComponentInfo{
StateCode: internalpb.StateCode_Healthy,
func (m *mockDataCoord) GetComponentStates(ctx context.Context) (*milvuspb.ComponentStates, error) {
return &milvuspb.ComponentStates{
State: &milvuspb.ComponentInfo{
StateCode: commonpb.StateCode_Healthy,
},
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_Success,
},
SubcomponentStates: []*internalpb.ComponentInfo{
SubcomponentStates: []*milvuspb.ComponentInfo{
{
StateCode: internalpb.StateCode_Healthy,
StateCode: commonpb.StateCode_Healthy,
},
},
}, nil
@ -180,17 +180,17 @@ func (m *mockRootCoord) Init() error {
func (m *mockRootCoord) Start() error {
return nil
}
func (m *mockRootCoord) GetComponentStates(ctx context.Context) (*internalpb.ComponentStates, error) {
return &internalpb.ComponentStates{
State: &internalpb.ComponentInfo{
StateCode: internalpb.StateCode_Healthy,
func (m *mockRootCoord) GetComponentStates(ctx context.Context) (*milvuspb.ComponentStates, error) {
return &milvuspb.ComponentStates{
State: &milvuspb.ComponentInfo{
StateCode: commonpb.StateCode_Healthy,
},
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_Success,
},
SubcomponentStates: []*internalpb.ComponentInfo{
SubcomponentStates: []*milvuspb.ComponentInfo{
{
StateCode: internalpb.StateCode_Healthy,
StateCode: commonpb.StateCode_Healthy,
},
},
}, nil
@ -222,7 +222,7 @@ func Test_NewServer(t *testing.T) {
t.Run("GetComponentStates", func(t *testing.T) {
server.datanode = &MockDataNode{
states: &internalpb.ComponentStates{},
states: &milvuspb.ComponentStates{},
}
states, err := server.GetComponentStates(ctx, nil)
assert.Nil(t, err)

6
internal/distributed/indexcoord/client/client.go
View File

@ -117,17 +117,17 @@ func (c *Client) newGrpcClient(cc *grpc.ClientConn) interface{} {
}
// GetComponentStates gets the component states of IndexCoord.
func (c *Client) GetComponentStates(ctx context.Context) (*internalpb.ComponentStates, error) {
func (c *Client) GetComponentStates(ctx context.Context) (*milvuspb.ComponentStates, error) {
ret, err := c.grpcClient.ReCall(ctx, func(client interface{}) (interface{}, error) {
if !funcutil.CheckCtxValid(ctx) {
return nil, ctx.Err()
}
return client.(indexpb.IndexCoordClient).GetComponentStates(ctx, &internalpb.GetComponentStatesRequest{})
return client.(indexpb.IndexCoordClient).GetComponentStates(ctx, &milvuspb.GetComponentStatesRequest{})
})
if err != nil || ret == nil {
return nil, err
}
return ret.(*internalpb.ComponentStates), err
return ret.(*milvuspb.ComponentStates), err
}
// GetStatisticsChannel gets the statistics channel of IndexCoord.

2
internal/distributed/indexcoord/client/client_test.go
View File

@ -85,7 +85,7 @@ func TestIndexCoordClient(t *testing.T) {
t.Run("GetComponentStates", func(t *testing.T) {
states, err := icc.GetComponentStates(ctx)
assert.NoError(t, err)
assert.Equal(t, internalpb.StateCode_Healthy, states.State.StateCode)
assert.Equal(t, commonpb.StateCode_Healthy, states.State.StateCode)
assert.Equal(t, commonpb.ErrorCode_Success, states.Status.ErrorCode)
})

2
internal/distributed/indexcoord/service.go
View File

@ -236,7 +236,7 @@ func (s *Server) SetRootCoord(d types.RootCoord) error {
}
// GetComponentStates gets the component states of IndexCoord.
func (s *Server) GetComponentStates(ctx context.Context, req *internalpb.GetComponentStatesRequest) (*internalpb.ComponentStates, error) {
func (s *Server) GetComponentStates(ctx context.Context, req *milvuspb.GetComponentStatesRequest) (*milvuspb.ComponentStates, error) {
return s.indexcoord.GetComponentStates(ctx)
}

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

@ -51,10 +51,10 @@ func TestIndexCoordinateServer(t *testing.T) {
assert.NoError(t, err)
t.Run("GetComponentStates", func(t *testing.T) {
req := &internalpb.GetComponentStatesRequest{}
req := &milvuspb.GetComponentStatesRequest{}
states, err := server.GetComponentStates(ctx, req)
assert.NoError(t, err)
assert.Equal(t, internalpb.StateCode_Healthy, states.State.StateCode)
assert.Equal(t, commonpb.StateCode_Healthy, states.State.StateCode)
})
t.Run("GetStatisticsChannel", func(t *testing.T) {

6
internal/distributed/indexnode/client/client.go
View File

@ -99,17 +99,17 @@ func (c *Client) getAddr() (string, error) {
}
// GetComponentStates gets the component states of IndexNode.
func (c *Client) GetComponentStates(ctx context.Context) (*internalpb.ComponentStates, error) {
func (c *Client) GetComponentStates(ctx context.Context) (*milvuspb.ComponentStates, error) {
ret, err := c.grpcClient.ReCall(ctx, func(client interface{}) (interface{}, error) {
if !funcutil.CheckCtxValid(ctx) {
return nil, ctx.Err()
}
return client.(indexpb.IndexNodeClient).GetComponentStates(ctx, &internalpb.GetComponentStatesRequest{})
return client.(indexpb.IndexNodeClient).GetComponentStates(ctx, &milvuspb.GetComponentStatesRequest{})
})
if err != nil || ret == nil {
return nil, err
}
return ret.(*internalpb.ComponentStates), err
return ret.(*milvuspb.ComponentStates), err
}
func (c *Client) GetStatisticsChannel(ctx context.Context) (*milvuspb.StringResponse, error) {

2
internal/distributed/indexnode/client/client_test.go
View File

@ -156,7 +156,7 @@ func TestIndexNodeClient(t *testing.T) {
t.Run("GetComponentStates", func(t *testing.T) {
states, err := inc.GetComponentStates(ctx)
assert.Nil(t, err)
assert.Equal(t, internalpb.StateCode_Healthy, states.State.StateCode)
assert.Equal(t, commonpb.StateCode_Healthy, states.State.StateCode)
assert.Equal(t, commonpb.ErrorCode_Success, states.Status.ErrorCode)
})

2
internal/distributed/indexnode/service.go
View File

@ -223,7 +223,7 @@ func (s *Server) SetEtcdClient(etcdCli *clientv3.Client) {
}
// GetComponentStates gets the component states of IndexNode.
func (s *Server) GetComponentStates(ctx context.Context, req *internalpb.GetComponentStatesRequest) (*internalpb.ComponentStates, error) {
func (s *Server) GetComponentStates(ctx context.Context, req *milvuspb.GetComponentStatesRequest) (*milvuspb.ComponentStates, error) {
return s.indexnode.GetComponentStates(ctx)
}

5
internal/distributed/indexnode/service_test.go
View File

@ -23,6 +23,7 @@ import (
"github.com/stretchr/testify/assert"
"github.com/milvus-io/milvus/api/commonpb"
"github.com/milvus-io/milvus/api/milvuspb"
"github.com/milvus-io/milvus/internal/indexnode"
"github.com/milvus-io/milvus/internal/proto/indexpb"
"github.com/milvus-io/milvus/internal/proto/internalpb"
@ -53,10 +54,10 @@ func TestIndexNodeServer(t *testing.T) {
assert.Nil(t, err)
t.Run("GetComponentStates", func(t *testing.T) {
req := &internalpb.GetComponentStatesRequest{}
req := &milvuspb.GetComponentStatesRequest{}
states, err := server.GetComponentStates(ctx, req)
assert.Nil(t, err)
assert.Equal(t, internalpb.StateCode_Healthy, states.State.StateCode)
assert.Equal(t, commonpb.StateCode_Healthy, states.State.StateCode)
})
t.Run("GetStatisticsChannel", func(t *testing.T) {

6
internal/distributed/proxy/client/client.go
View File

@ -95,17 +95,17 @@ func (c *Client) Register() error {
}
// GetComponentStates get the component state.
func (c *Client) GetComponentStates(ctx context.Context) (*internalpb.ComponentStates, error) {
func (c *Client) GetComponentStates(ctx context.Context) (*milvuspb.ComponentStates, error) {
ret, err := c.grpcClient.ReCall(ctx, func(client interface{}) (interface{}, error) {
if !funcutil.CheckCtxValid(ctx) {
return nil, ctx.Err()
}
return client.(proxypb.ProxyClient).GetComponentStates(ctx, &internalpb.GetComponentStatesRequest{})
return client.(proxypb.ProxyClient).GetComponentStates(ctx, &milvuspb.GetComponentStatesRequest{})
})
if err != nil || ret == nil {
return nil, err
}
return ret.(*internalpb.ComponentStates), err
return ret.(*milvuspb.ComponentStates), err
}
//GetStatisticsChannel return the statistics channel in string

10
internal/distributed/proxy/service.go
View File

@ -469,8 +469,8 @@ func (s *Server) init() error {
s.proxy.SetQueryCoordClient(s.queryCoordClient)
log.Debug("set QueryCoord client for Proxy done")
log.Debug(fmt.Sprintf("update Proxy's state to %s", internalpb.StateCode_Initializing.String()))
s.proxy.UpdateStateCode(internalpb.StateCode_Initializing)
log.Debug(fmt.Sprintf("update Proxy's state to %s", commonpb.StateCode_Initializing.String()))
s.proxy.UpdateStateCode(commonpb.StateCode_Initializing)
log.Debug("init Proxy")
if err := s.proxy.Init(); err != nil {
@ -539,7 +539,7 @@ func (s *Server) Stop() error {
}
// GetComponentStates get the component states
func (s *Server) GetComponentStates(ctx context.Context, request *internalpb.GetComponentStatesRequest) (*internalpb.ComponentStates, error) {
func (s *Server) GetComponentStates(ctx context.Context, request *milvuspb.GetComponentStatesRequest) (*milvuspb.ComponentStates, error) {
return s.proxy.GetComponentStates(ctx)
}
@ -777,7 +777,7 @@ func (s *Server) Check(ctx context.Context, req *grpc_health_v1.HealthCheckReque
if state.Status.ErrorCode != commonpb.ErrorCode_Success {
return ret, nil
}
if state.State.StateCode != internalpb.StateCode_Healthy {
if state.State.StateCode != commonpb.StateCode_Healthy {
return ret, nil
}
ret.Status = grpc_health_v1.HealthCheckResponse_SERVING
@ -796,7 +796,7 @@ func (s *Server) Watch(req *grpc_health_v1.HealthCheckRequest, server grpc_healt
if state.Status.ErrorCode != commonpb.ErrorCode_Success {
return server.Send(ret)
}
if state.State.StateCode != internalpb.StateCode_Healthy {
if state.State.StateCode != commonpb.StateCode_Healthy {
return server.Send(ret)
}
ret.Status = grpc_health_v1.HealthCheckResponse_SERVING

42
internal/distributed/proxy/service_test.go
View File

@ -64,23 +64,23 @@ func (m *MockBase) On(methodName string, arguments ...interface{}) *mock.Call {
return m.Mock.On(methodName, arguments...)
}
func (m *MockBase) GetComponentStates(ctx context.Context) (*internalpb.ComponentStates, error) {
func (m *MockBase) GetComponentStates(ctx context.Context) (*milvuspb.ComponentStates, error) {
if m.isMockGetComponentStatesOn {
ret1 := &internalpb.ComponentStates{}
ret1 := &milvuspb.ComponentStates{}
var ret2 error
args := m.Called(ctx)
arg1 := args.Get(0)
arg2 := args.Get(1)
if arg1 != nil {
ret1 = arg1.(*internalpb.ComponentStates)
ret1 = arg1.(*milvuspb.ComponentStates)
}
if arg2 != nil {
ret2 = arg2.(error)
}
return ret1, ret2
}
return &internalpb.ComponentStates{
State: &internalpb.ComponentInfo{StateCode: internalpb.StateCode_Healthy},
return &milvuspb.ComponentStates{
State: &milvuspb.ComponentInfo{StateCode: commonpb.StateCode_Healthy},
Status: &commonpb.Status{ErrorCode: commonpb.ErrorCode_Success},
}, nil
}
@ -348,7 +348,7 @@ func (m *MockQueryCoord) Register() error {
return m.regErr
}
func (m *MockQueryCoord) UpdateStateCode(code internalpb.StateCode) {
func (m *MockQueryCoord) UpdateStateCode(code commonpb.StateCode) {
}
func (m *MockQueryCoord) SetRootCoord(types.RootCoord) error {
@ -359,12 +359,12 @@ func (m *MockQueryCoord) SetDataCoord(types.DataCoord) error {
return nil
}
func (m *MockQueryCoord) GetComponentStates(ctx context.Context) (*internalpb.ComponentStates, error) {
return &internalpb.ComponentStates{
State: &internalpb.ComponentInfo{
func (m *MockQueryCoord) GetComponentStates(ctx context.Context) (*milvuspb.ComponentStates, error) {
return &milvuspb.ComponentStates{
State: &milvuspb.ComponentInfo{
NodeID: int64(uniquegenerator.GetUniqueIntGeneratorIns().GetInt()),
Role: "MockQueryCoord",
StateCode: internalpb.StateCode_Healthy,
StateCode: commonpb.StateCode_Healthy,
ExtraInfo: nil,
},
SubcomponentStates: nil,
@ -781,7 +781,7 @@ func (m *MockProxy) GetRateLimiter() (types.Limiter, error) {
return nil, nil
}
func (m *MockProxy) UpdateStateCode(stateCode internalpb.StateCode) {
func (m *MockProxy) UpdateStateCode(stateCode commonpb.StateCode) {
}
@ -1332,13 +1332,13 @@ func TestServer_Check(t *testing.T) {
assert.NotNil(t, err)
assert.Equal(t, grpc_health_v1.HealthCheckResponse_NOT_SERVING, ret.Status)
componentInfo := &internalpb.ComponentInfo{
componentInfo := &milvuspb.ComponentInfo{
NodeID: 0,
Role: "proxy",
StateCode: internalpb.StateCode_Abnormal,
StateCode: commonpb.StateCode_Abnormal,
}
status := &commonpb.Status{ErrorCode: commonpb.ErrorCode_UnexpectedError}
componentState := &internalpb.ComponentStates{
componentState := &milvuspb.ComponentStates{
State: componentInfo,
Status: status,
}
@ -1353,12 +1353,12 @@ func TestServer_Check(t *testing.T) {
assert.Nil(t, err)
assert.Equal(t, grpc_health_v1.HealthCheckResponse_NOT_SERVING, ret.Status)
componentInfo.StateCode = internalpb.StateCode_Initializing
componentInfo.StateCode = commonpb.StateCode_Initializing
ret, err = server.Check(ctx, req)
assert.Nil(t, err)
assert.Equal(t, grpc_health_v1.HealthCheckResponse_NOT_SERVING, ret.Status)
componentInfo.StateCode = internalpb.StateCode_Healthy
componentInfo.StateCode = commonpb.StateCode_Healthy
ret, err = server.Check(ctx, req)
assert.Nil(t, err)
assert.Equal(t, grpc_health_v1.HealthCheckResponse_SERVING, ret.Status)
@ -1394,13 +1394,13 @@ func TestServer_Watch(t *testing.T) {
assert.Nil(t, err)
assert.Equal(t, grpc_health_v1.HealthCheckResponse_NOT_SERVING, ret.Status)
componentInfo := &internalpb.ComponentInfo{
componentInfo := &milvuspb.ComponentInfo{
NodeID: 0,
Role: "proxy",
StateCode: internalpb.StateCode_Abnormal,
StateCode: commonpb.StateCode_Abnormal,
}
status := &commonpb.Status{ErrorCode: commonpb.ErrorCode_UnexpectedError}
componentState := &internalpb.ComponentStates{
componentState := &milvuspb.ComponentStates{
State: componentInfo,
Status: status,
}
@ -1417,13 +1417,13 @@ func TestServer_Watch(t *testing.T) {
assert.Nil(t, err)
assert.Equal(t, grpc_health_v1.HealthCheckResponse_NOT_SERVING, ret.Status)
componentInfo.StateCode = internalpb.StateCode_Initializing
componentInfo.StateCode = commonpb.StateCode_Initializing
err = server.Watch(req, watchServer)
ret = <-resultChan
assert.Nil(t, err)
assert.Equal(t, grpc_health_v1.HealthCheckResponse_NOT_SERVING, ret.Status)
componentInfo.StateCode = internalpb.StateCode_Healthy
componentInfo.StateCode = commonpb.StateCode_Healthy
err = server.Watch(req, watchServer)
ret = <-resultChan
assert.Nil(t, err)

6
internal/distributed/querycoord/client/client.go
View File

@ -114,17 +114,17 @@ func (c *Client) Register() error {
}
// GetComponentStates gets the component states of QueryCoord.
func (c *Client) GetComponentStates(ctx context.Context) (*internalpb.ComponentStates, error) {
func (c *Client) GetComponentStates(ctx context.Context) (*milvuspb.ComponentStates, error) {
ret, err := c.grpcClient.ReCall(ctx, func(client interface{}) (interface{}, error) {
if !funcutil.CheckCtxValid(ctx) {
return nil, ctx.Err()
}
return client.(querypb.QueryCoordClient).GetComponentStates(ctx, &internalpb.GetComponentStatesRequest{})
return client.(querypb.QueryCoordClient).GetComponentStates(ctx, &milvuspb.GetComponentStatesRequest{})
})
if err != nil || ret == nil {
return nil, err
}
return ret.(*internalpb.ComponentStates), err
return ret.(*milvuspb.ComponentStates), err
}
// GetTimeTickChannel gets the time tick channel of QueryCoord.

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

@ -224,8 +224,8 @@ func (s *Server) init() error {
panic(err)
}
s.queryCoord.UpdateStateCode(internalpb.StateCode_Initializing)
log.Debug("QueryCoord", zap.Any("State", internalpb.StateCode_Initializing))
s.queryCoord.UpdateStateCode(commonpb.StateCode_Initializing)
log.Debug("QueryCoord", zap.Any("State", commonpb.StateCode_Initializing))
if err := s.queryCoord.Init(); err != nil {
return err
}
@ -328,7 +328,7 @@ func (s *Server) SetIndexCoord(d types.IndexCoord) error {
}
// GetComponentStates gets the component states of QueryCoord.
func (s *Server) GetComponentStates(ctx context.Context, req *internalpb.GetComponentStatesRequest) (*internalpb.ComponentStates, error) {
func (s *Server) GetComponentStates(ctx context.Context, req *milvuspb.GetComponentStatesRequest) (*milvuspb.ComponentStates, error) {
return s.queryCoord.GetComponentStates(ctx)
}

32
internal/distributed/querycoord/service_test.go
View File

@ -34,7 +34,7 @@ import (
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
type MockQueryCoord struct {
states *internalpb.ComponentStates
states *milvuspb.ComponentStates
status *commonpb.Status
err error
initErr error
@ -69,7 +69,7 @@ func (m *MockQueryCoord) Register() error {
return m.regErr
}
func (m *MockQueryCoord) UpdateStateCode(code internalpb.StateCode) {
func (m *MockQueryCoord) UpdateStateCode(code commonpb.StateCode) {
}
func (m *MockQueryCoord) SetEtcdClient(client *clientv3.Client) {
@ -87,7 +87,7 @@ func (m *MockQueryCoord) SetIndexCoord(coord types.IndexCoord) error {
return nil
}
func (m *MockQueryCoord) GetComponentStates(ctx context.Context) (*internalpb.ComponentStates, error) {
func (m *MockQueryCoord) GetComponentStates(ctx context.Context) (*milvuspb.ComponentStates, error) {
log.Debug("MockQueryCoord::WaitForComponentStates")
return m.states, m.err
}
@ -178,9 +178,9 @@ func (m *MockRootCoord) Register() error {
return m.regErr
}
func (m *MockRootCoord) GetComponentStates(ctx context.Context) (*internalpb.ComponentStates, error) {
return &internalpb.ComponentStates{
State: &internalpb.ComponentInfo{StateCode: internalpb.StateCode_Healthy},
func (m *MockRootCoord) GetComponentStates(ctx context.Context) (*milvuspb.ComponentStates, error) {
return &milvuspb.ComponentStates{
State: &milvuspb.ComponentInfo{StateCode: commonpb.StateCode_Healthy},
Status: &commonpb.Status{ErrorCode: m.stateErr},
}, nil
}
@ -211,9 +211,9 @@ func (m *MockDataCoord) Register() error {
return m.regErr
}
func (m *MockDataCoord) GetComponentStates(ctx context.Context) (*internalpb.ComponentStates, error) {
return &internalpb.ComponentStates{
State: &internalpb.ComponentInfo{StateCode: internalpb.StateCode_Healthy},
func (m *MockDataCoord) GetComponentStates(ctx context.Context) (*milvuspb.ComponentStates, error) {
return &milvuspb.ComponentStates{
State: &milvuspb.ComponentInfo{StateCode: commonpb.StateCode_Healthy},
Status: &commonpb.Status{ErrorCode: m.stateErr},
}, nil
}
@ -244,9 +244,9 @@ func (m *MockIndexCoord) Register() error {
return m.regErr
}
func (m *MockIndexCoord) GetComponentStates(ctx context.Context) (*internalpb.ComponentStates, error) {
return &internalpb.ComponentStates{
State: &internalpb.ComponentInfo{StateCode: internalpb.StateCode_Healthy},
func (m *MockIndexCoord) GetComponentStates(ctx context.Context) (*milvuspb.ComponentStates, error) {
return &milvuspb.ComponentStates{
State: &milvuspb.ComponentInfo{StateCode: commonpb.StateCode_Healthy},
Status: &commonpb.Status{ErrorCode: m.stateErr},
}, nil
}
@ -259,8 +259,8 @@ func Test_NewServer(t *testing.T) {
assert.NotNil(t, server)
mqc := &MockQueryCoord{
states: &internalpb.ComponentStates{
State: &internalpb.ComponentInfo{StateCode: internalpb.StateCode_Healthy},
states: &milvuspb.ComponentStates{
State: &milvuspb.ComponentInfo{StateCode: commonpb.StateCode_Healthy},
Status: &commonpb.Status{ErrorCode: commonpb.ErrorCode_Success},
},
status: &commonpb.Status{ErrorCode: commonpb.ErrorCode_Success},
@ -297,10 +297,10 @@ func Test_NewServer(t *testing.T) {
})
t.Run("GetComponentStates", func(t *testing.T) {
req := &internalpb.GetComponentStatesRequest{}
req := &milvuspb.GetComponentStatesRequest{}
states, err := server.GetComponentStates(ctx, req)
assert.Nil(t, err)
assert.Equal(t, internalpb.StateCode_Healthy, states.State.StateCode)
assert.Equal(t, commonpb.StateCode_Healthy, states.State.StateCode)
})
t.Run("GetStatisticsChannel", func(t *testing.T) {

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

@ -97,17 +97,17 @@ func (c *Client) getAddr() (string, error) {
}
// GetComponentStates gets the component states of QueryNode.
func (c *Client) GetComponentStates(ctx context.Context) (*internalpb.ComponentStates, error) {
func (c *Client) GetComponentStates(ctx context.Context) (*milvuspb.ComponentStates, error) {
ret, err := c.grpcClient.ReCall(ctx, func(client interface{}) (interface{}, error) {
if !funcutil.CheckCtxValid(ctx) {
return nil, ctx.Err()
}
return client.(querypb.QueryNodeClient).GetComponentStates(ctx, &internalpb.GetComponentStatesRequest{})
return client.(querypb.QueryNodeClient).GetComponentStates(ctx, &milvuspb.GetComponentStatesRequest{})
})
if err != nil || ret == nil {
return nil, err
}
return ret.(*internalpb.ComponentStates), err
return ret.(*milvuspb.ComponentStates), err
}
// GetTimeTickChannel gets the time tick channel of QueryNode.

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

@ -121,8 +121,8 @@ func (s *Server) init() error {
return err
}
s.querynode.UpdateStateCode(internalpb.StateCode_Initializing)
log.Debug("QueryNode", zap.Any("State", internalpb.StateCode_Initializing))
s.querynode.UpdateStateCode(commonpb.StateCode_Initializing)
log.Debug("QueryNode", zap.Any("State", commonpb.StateCode_Initializing))
if err := s.querynode.Init(); err != nil {
log.Error("QueryNode init error: ", zap.Error(err))
return err
@ -257,7 +257,7 @@ func (s *Server) GetStatisticsChannel(ctx context.Context, req *internalpb.GetSt
}
// GetComponentStates gets the component states of QueryNode.
func (s *Server) GetComponentStates(ctx context.Context, req *internalpb.GetComponentStatesRequest) (*internalpb.ComponentStates, error) {
func (s *Server) GetComponentStates(ctx context.Context, req *milvuspb.GetComponentStatesRequest) (*milvuspb.ComponentStates, error) {
// ignore ctx and in
return s.querynode.GetComponentStates(ctx)
}

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

@ -34,7 +34,7 @@ import (
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
type MockQueryNode struct {
states *internalpb.ComponentStates
states *milvuspb.ComponentStates
status *commonpb.Status
err error
initErr error
@ -67,7 +67,7 @@ func (m *MockQueryNode) Register() error {
return m.regErr
}
func (m *MockQueryNode) GetComponentStates(ctx context.Context) (*internalpb.ComponentStates, error) {
func (m *MockQueryNode) GetComponentStates(ctx context.Context) (*milvuspb.ComponentStates, error) {
return m.states, m.err
}
@ -126,7 +126,7 @@ func (m *MockQueryNode) SyncReplicaSegments(ctx context.Context, req *querypb.Sy
func (m *MockQueryNode) SetEtcdClient(client *clientv3.Client) {
}
func (m *MockQueryNode) UpdateStateCode(code internalpb.StateCode) {
func (m *MockQueryNode) UpdateStateCode(code commonpb.StateCode) {
}
func (m *MockQueryNode) SetRootCoord(rc types.RootCoord) error {
@ -179,9 +179,9 @@ func (m *MockRootCoord) Register() error {
func (m *MockRootCoord) SetEtcdClient(client *clientv3.Client) {
}
func (m *MockRootCoord) GetComponentStates(ctx context.Context) (*internalpb.ComponentStates, error) {
return &internalpb.ComponentStates{
State: &internalpb.ComponentInfo{StateCode: internalpb.StateCode_Healthy},
func (m *MockRootCoord) GetComponentStates(ctx context.Context) (*milvuspb.ComponentStates, error) {
return &milvuspb.ComponentStates{
State: &milvuspb.ComponentInfo{StateCode: commonpb.StateCode_Healthy},
Status: &commonpb.Status{ErrorCode: m.stateErr},
}, nil
}
@ -215,9 +215,9 @@ func (m *MockIndexCoord) Register() error {
func (m *MockIndexCoord) SetEtcdClient(client *clientv3.Client) {
}
func (m *MockIndexCoord) GetComponentStates(ctx context.Context) (*internalpb.ComponentStates, error) {
return &internalpb.ComponentStates{
State: &internalpb.ComponentInfo{StateCode: internalpb.StateCode_Healthy},
func (m *MockIndexCoord) GetComponentStates(ctx context.Context) (*milvuspb.ComponentStates, error) {
return &milvuspb.ComponentStates{
State: &milvuspb.ComponentInfo{StateCode: commonpb.StateCode_Healthy},
Status: &commonpb.Status{ErrorCode: m.stateErr},
}, nil
}
@ -230,7 +230,7 @@ func Test_NewServer(t *testing.T) {
assert.NotNil(t, server)
mqn := &MockQueryNode{
states: &internalpb.ComponentStates{State: &internalpb.ComponentInfo{StateCode: internalpb.StateCode_Healthy}},
states: &milvuspb.ComponentStates{State: &milvuspb.ComponentInfo{StateCode: commonpb.StateCode_Healthy}},
status: &commonpb.Status{ErrorCode: commonpb.ErrorCode_Success},
err: nil,
strResp: &milvuspb.StringResponse{Status: &commonpb.Status{ErrorCode: commonpb.ErrorCode_Success}},
@ -246,10 +246,10 @@ func Test_NewServer(t *testing.T) {
})
t.Run("GetComponentStates", func(t *testing.T) {
req := &internalpb.GetComponentStatesRequest{}
req := &milvuspb.GetComponentStatesRequest{}
states, err := server.GetComponentStates(ctx, req)
assert.Nil(t, err)
assert.Equal(t, internalpb.StateCode_Healthy, states.State.StateCode)
assert.Equal(t, commonpb.StateCode_Healthy, states.State.StateCode)
})
t.Run("GetStatisticsChannel", func(t *testing.T) {

6
internal/distributed/rootcoord/client/client.go
View File

@ -120,17 +120,17 @@ func (c *Client) Register() error {
}
// GetComponentStates TODO: timeout need to be propagated through ctx
func (c *Client) GetComponentStates(ctx context.Context) (*internalpb.ComponentStates, error) {
func (c *Client) GetComponentStates(ctx context.Context) (*milvuspb.ComponentStates, error) {
ret, err := c.grpcClient.ReCall(ctx, func(client interface{}) (interface{}, error) {
if !funcutil.CheckCtxValid(ctx) {
return nil, ctx.Err()
}
return client.(rootcoordpb.RootCoordClient).GetComponentStates(ctx, &internalpb.GetComponentStatesRequest{})
return client.(rootcoordpb.RootCoordClient).GetComponentStates(ctx, &milvuspb.GetComponentStatesRequest{})
})
if err != nil || ret == nil {
return nil, err
}
return ret.(*internalpb.ComponentStates), err
return ret.(*milvuspb.ComponentStates), err
}
// GetTimeTickChannel get timetick channel name

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

@ -173,8 +173,8 @@ func (s *Server) init() error {
}
log.Debug("grpc init done ...")
s.rootCoord.UpdateStateCode(internalpb.StateCode_Initializing)
log.Debug("RootCoord", zap.Any("State", internalpb.StateCode_Initializing))
s.rootCoord.UpdateStateCode(commonpb.StateCode_Initializing)
log.Debug("RootCoord", zap.Any("State", commonpb.StateCode_Initializing))
if s.newDataCoordClient != nil {
log.Debug("RootCoord start to create DataCoord client")
@ -309,7 +309,7 @@ func (s *Server) Stop() error {
}
// GetComponentStates gets the component states of RootCoord.
func (s *Server) GetComponentStates(ctx context.Context, req *internalpb.GetComponentStatesRequest) (*internalpb.ComponentStates, error) {
func (s *Server) GetComponentStates(ctx context.Context, req *milvuspb.GetComponentStatesRequest) (*milvuspb.ComponentStates, error) {
return s.rootCoord.GetComponentStates(ctx)
}

16
internal/distributed/rootcoord/service_test.go
View File

@ -29,7 +29,7 @@ import (
"github.com/stretchr/testify/assert"
"github.com/milvus-io/milvus/api/commonpb"
"github.com/milvus-io/milvus/internal/proto/internalpb"
"github.com/milvus-io/milvus/api/milvuspb"
"github.com/milvus-io/milvus/internal/proto/proxypb"
"github.com/milvus-io/milvus/internal/rootcoord"
"github.com/milvus-io/milvus/internal/types"
@ -52,7 +52,7 @@ type mockCore struct {
types.RootCoordComponent
}
func (m *mockCore) UpdateStateCode(internalpb.StateCode) {
func (m *mockCore) UpdateStateCode(commonpb.StateCode) {
}
func (m *mockCore) SetEtcdClient(etcdClient *clientv3.Client) {
@ -95,17 +95,17 @@ func (m *mockDataCoord) Init() error {
func (m *mockDataCoord) Start() error {
return nil
}
func (m *mockDataCoord) GetComponentStates(ctx context.Context) (*internalpb.ComponentStates, error) {
return &internalpb.ComponentStates{
State: &internalpb.ComponentInfo{
StateCode: internalpb.StateCode_Healthy,
func (m *mockDataCoord) GetComponentStates(ctx context.Context) (*milvuspb.ComponentStates, error) {
return &milvuspb.ComponentStates{
State: &milvuspb.ComponentInfo{
StateCode: commonpb.StateCode_Healthy,
},
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_Success,
},
SubcomponentStates: []*internalpb.ComponentInfo{
SubcomponentStates: []*milvuspb.ComponentInfo{
{
StateCode: internalpb.StateCode_Healthy,
StateCode: commonpb.StateCode_Healthy,
},
},
}, nil

30
internal/indexcoord/index_coord.go
View File

@ -123,7 +123,7 @@ func NewIndexCoord(ctx context.Context, factory dependency.Factory) (*IndexCoord
factory: factory,
enableActiveStandBy: Params.IndexCoordCfg.EnableActiveStandby,
}
i.UpdateStateCode(internalpb.StateCode_Abnormal)
i.UpdateStateCode(commonpb.StateCode_Abnormal)
return i, nil
}
@ -165,8 +165,8 @@ func (i *IndexCoord) Init() error {
var initErr error
Params.InitOnce()
i.initOnce.Do(func() {
i.UpdateStateCode(internalpb.StateCode_Initializing)
log.Debug("IndexCoord init", zap.Any("stateCode", i.stateCode.Load().(internalpb.StateCode)))
i.UpdateStateCode(commonpb.StateCode_Initializing)
log.Debug("IndexCoord init", zap.Any("stateCode", i.stateCode.Load().(commonpb.StateCode)))
i.factory.Init(&Params)
@ -279,7 +279,7 @@ func (i *IndexCoord) Start() error {
i.handoff.Start()
i.flushedSegmentWatcher.Start()
i.UpdateStateCode(internalpb.StateCode_Healthy)
i.UpdateStateCode(commonpb.StateCode_Healthy)
})
// Start callbacks
for _, cb := range i.startCallbacks {
@ -293,12 +293,12 @@ func (i *IndexCoord) Start() error {
i.activateFunc = func() {
log.Info("IndexCoord switch from standby to active, reload the KV")
i.metaTable.reloadFromKV()
i.UpdateStateCode(internalpb.StateCode_Healthy)
i.UpdateStateCode(commonpb.StateCode_Healthy)
}
i.UpdateStateCode(internalpb.StateCode_StandBy)
i.UpdateStateCode(commonpb.StateCode_StandBy)
log.Info("IndexCoord start successfully", zap.Any("state", i.stateCode.Load()))
} else {
i.UpdateStateCode(internalpb.StateCode_Healthy)
i.UpdateStateCode(commonpb.StateCode_Healthy)
log.Info("IndexCoord start successfully", zap.Any("state", i.stateCode.Load()))
}
@ -308,7 +308,7 @@ func (i *IndexCoord) Start() error {
// Stop stops the IndexCoord component.
func (i *IndexCoord) Stop() error {
// https://github.com/milvus-io/milvus/issues/12282
i.UpdateStateCode(internalpb.StateCode_Abnormal)
i.UpdateStateCode(commonpb.StateCode_Abnormal)
if i.loopCancel != nil {
i.loopCancel()
@ -367,17 +367,17 @@ func (i *IndexCoord) SetRootCoord(rootCoord types.RootCoord) error {
}
// UpdateStateCode updates the component state of IndexCoord.
func (i *IndexCoord) UpdateStateCode(code internalpb.StateCode) {
func (i *IndexCoord) UpdateStateCode(code commonpb.StateCode) {
i.stateCode.Store(code)
}
func (i *IndexCoord) isHealthy() bool {
code := i.stateCode.Load().(internalpb.StateCode)
return code == internalpb.StateCode_Healthy
code := i.stateCode.Load().(commonpb.StateCode)
return code == commonpb.StateCode_Healthy
}
// GetComponentStates gets the component states of IndexCoord.
func (i *IndexCoord) GetComponentStates(ctx context.Context) (*internalpb.ComponentStates, error) {
func (i *IndexCoord) GetComponentStates(ctx context.Context) (*milvuspb.ComponentStates, error) {
log.Debug("get IndexCoord component states ...")
nodeID := common.NotRegisteredID
@ -385,13 +385,13 @@ func (i *IndexCoord) GetComponentStates(ctx context.Context) (*internalpb.Compon
nodeID = i.session.ServerID
}
stateInfo := &internalpb.ComponentInfo{
stateInfo := &milvuspb.ComponentInfo{
NodeID: nodeID,
Role: "IndexCoord",
StateCode: i.stateCode.Load().(internalpb.StateCode),
StateCode: i.stateCode.Load().(commonpb.StateCode),
}
ret := &internalpb.ComponentStates{
ret := &milvuspb.ComponentStates{
State: stateInfo,
SubcomponentStates: nil, // todo add subcomponents states
Status: &commonpb.Status{

40
internal/indexcoord/index_coord_mock.go
View File

@ -43,14 +43,14 @@ type Mock struct {
CallInit func() error
CallStart func() error
CallStop func() error
CallGetComponentStates func(ctx context.Context) (*internalpb.ComponentStates, error)
CallGetComponentStates func(ctx context.Context) (*milvuspb.ComponentStates, error)
CallGetStatisticsChannel func(ctx context.Context) (*milvuspb.StringResponse, error)
CallRegister func() error
CallSetEtcdClient func(etcdClient *clientv3.Client)
CallSetDataCoord func(dataCoord types.DataCoord) error
CallSetRootCoord func(rootCoord types.RootCoord) error
CallUpdateStateCode func(stateCode internalpb.StateCode)
CallUpdateStateCode func(stateCode commonpb.StateCode)
CallCreateIndex func(ctx context.Context, req *indexpb.CreateIndexRequest) (*commonpb.Status, error)
CallGetIndexState func(ctx context.Context, req *indexpb.GetIndexStateRequest) (*indexpb.GetIndexStateResponse, error)
@ -95,12 +95,12 @@ func (m *Mock) SetRootCoord(rootCoord types.RootCoord) error {
return m.CallSetRootCoord(rootCoord)
}
func (m *Mock) UpdateStateCode(stateCode internalpb.StateCode) {
func (m *Mock) UpdateStateCode(stateCode commonpb.StateCode) {
m.CallUpdateStateCode(stateCode)
}
// GetComponentStates gets the component states of the mocked IndexCoord.
func (m *Mock) GetComponentStates(ctx context.Context) (*internalpb.ComponentStates, error) {
func (m *Mock) GetComponentStates(ctx context.Context) (*milvuspb.ComponentStates, error) {
return m.CallGetComponentStates(ctx)
}
@ -167,12 +167,12 @@ func NewIndexCoordMock() *Mock {
CallSetRootCoord: func(rootCoord types.RootCoord) error {
return nil
},
CallGetComponentStates: func(ctx context.Context) (*internalpb.ComponentStates, error) {
return &internalpb.ComponentStates{
State: &internalpb.ComponentInfo{
CallGetComponentStates: func(ctx context.Context) (*milvuspb.ComponentStates, error) {
return &milvuspb.ComponentStates{
State: &milvuspb.ComponentInfo{
NodeID: 1,
Role: typeutil.IndexCoordRole,
StateCode: internalpb.StateCode_Healthy,
StateCode: commonpb.StateCode_Healthy,
},
SubcomponentStates: nil,
Status: &commonpb.Status{
@ -292,7 +292,7 @@ type RootCoordMock struct {
CallInit func() error
CallStart func() error
CallGetComponentStates func(ctx context.Context) (*internalpb.ComponentStates, error)
CallGetComponentStates func(ctx context.Context) (*milvuspb.ComponentStates, error)
CallAllocID func(ctx context.Context, req *rootcoordpb.AllocIDRequest) (*rootcoordpb.AllocIDResponse, error)
}
@ -305,7 +305,7 @@ func (rcm *RootCoordMock) Start() error {
return rcm.CallStart()
}
func (rcm *RootCoordMock) GetComponentStates(ctx context.Context) (*internalpb.ComponentStates, error) {
func (rcm *RootCoordMock) GetComponentStates(ctx context.Context) (*milvuspb.ComponentStates, error) {
return rcm.CallGetComponentStates(ctx)
}
@ -321,12 +321,12 @@ func NewRootCoordMock() *RootCoordMock {
CallStart: func() error {
return nil
},
CallGetComponentStates: func(ctx context.Context) (*internalpb.ComponentStates, error) {
return &internalpb.ComponentStates{
State: &internalpb.ComponentInfo{
CallGetComponentStates: func(ctx context.Context) (*milvuspb.ComponentStates, error) {
return &milvuspb.ComponentStates{
State: &milvuspb.ComponentInfo{
NodeID: 1,
Role: typeutil.IndexCoordRole,
StateCode: internalpb.StateCode_Healthy,
StateCode: commonpb.StateCode_Healthy,
},
SubcomponentStates: nil,
Status: &commonpb.Status{
@ -353,7 +353,7 @@ type DataCoordMock struct {
CallInit func() error
CallStart func() error
CallGetComponentStates func(ctx context.Context) (*internalpb.ComponentStates, error)
CallGetComponentStates func(ctx context.Context) (*milvuspb.ComponentStates, error)
CallGetSegmentInfo func(ctx context.Context, req *datapb.GetSegmentInfoRequest) (*datapb.GetSegmentInfoResponse, error)
CallGetFlushedSegment func(ctx context.Context, req *datapb.GetFlushedSegmentsRequest) (*datapb.GetFlushedSegmentsResponse, error)
@ -369,7 +369,7 @@ func (dcm *DataCoordMock) Start() error {
return dcm.CallStart()
}
func (dcm *DataCoordMock) GetComponentStates(ctx context.Context) (*internalpb.ComponentStates, error) {
func (dcm *DataCoordMock) GetComponentStates(ctx context.Context) (*milvuspb.ComponentStates, error) {
return dcm.CallGetComponentStates(ctx)
}
@ -406,12 +406,12 @@ func NewDataCoordMock() *DataCoordMock {
CallStart: func() error {
return nil
},
CallGetComponentStates: func(ctx context.Context) (*internalpb.ComponentStates, error) {
return &internalpb.ComponentStates{
State: &internalpb.ComponentInfo{
CallGetComponentStates: func(ctx context.Context) (*milvuspb.ComponentStates, error) {
return &milvuspb.ComponentStates{
State: &milvuspb.ComponentInfo{
NodeID: 1,
Role: typeutil.IndexCoordRole,
StateCode: internalpb.StateCode_Healthy,
StateCode: commonpb.StateCode_Healthy,
},
SubcomponentStates: nil,
Status: &commonpb.Status{

20
internal/indexcoord/index_coord_test.go
View File

@ -180,7 +180,7 @@ func testIndexCoord(t *testing.T) {
err = ic.Start()
assert.NoError(t, err)
ic.UpdateStateCode(internalpb.StateCode_Healthy)
ic.UpdateStateCode(commonpb.StateCode_Healthy)
ic.nodeManager.setClient(1, inm0)
@ -188,7 +188,7 @@ func testIndexCoord(t *testing.T) {
t.Run("GetComponentStates", func(t *testing.T) {
states, err := ic.GetComponentStates(ctx)
assert.NoError(t, err)
assert.Equal(t, internalpb.StateCode_Healthy, states.State.StateCode)
assert.Equal(t, commonpb.StateCode_Healthy, states.State.StateCode)
})
t.Run("GetStatisticsChannel", func(t *testing.T) {
@ -457,7 +457,7 @@ func TestIndexCoord_EnableActiveStandby(t *testing.T) {
func TestIndexCoord_GetComponentStates(t *testing.T) {
ic := &IndexCoord{}
ic.stateCode.Store(internalpb.StateCode_Healthy)
ic.stateCode.Store(commonpb.StateCode_Healthy)
resp, err := ic.GetComponentStates(context.Background())
assert.NoError(t, err)
assert.Equal(t, commonpb.ErrorCode_Success, resp.Status.ErrorCode)
@ -475,7 +475,7 @@ func TestIndexCoord_UnHealthy(t *testing.T) {
ic := &IndexCoord{
serverID: 1,
}
ic.stateCode.Store(internalpb.StateCode_Abnormal)
ic.stateCode.Store(commonpb.StateCode_Abnormal)
// Test IndexCoord function
t.Run("CreateIndex", func(t *testing.T) {
@ -587,7 +587,7 @@ func TestIndexCoord_DropIndex(t *testing.T) {
},
}),
}
ic.UpdateStateCode(internalpb.StateCode_Healthy)
ic.UpdateStateCode(commonpb.StateCode_Healthy)
resp, err := ic.DropIndex(context.Background(), &indexpb.DropIndexRequest{
CollectionID: collID,
PartitionIDs: []int64{partID},
@ -631,7 +631,7 @@ func TestIndexCoord_DropIndex(t *testing.T) {
},
}),
}
ic.UpdateStateCode(internalpb.StateCode_Healthy)
ic.UpdateStateCode(commonpb.StateCode_Healthy)
resp, err := ic.DropIndex(context.Background(), &indexpb.DropIndexRequest{
CollectionID: collID,
@ -775,7 +775,7 @@ func TestIndexCoord_DropIndex(t *testing.T) {
//
//func TestIndexCoord_GetComponentStates(t *testing.T) {
// n := &IndexCoord{}
// n.stateCode.Store(internalpb.StateCode_Healthy)
// n.stateCode.Store(commonpb.StateCode_Healthy)
// resp, err := n.GetComponentStates(context.Background())
// assert.NoError(t, err)
// assert.Equal(t, commonpb.ErrorCode_Success, resp.Status.ErrorCode)
@ -789,7 +789,7 @@ func TestIndexCoord_DropIndex(t *testing.T) {
//
//func TestIndexCoord_NotHealthy(t *testing.T) {
// ic := &IndexCoord{}
// ic.stateCode.Store(internalpb.StateCode_Abnormal)
// ic.stateCode.Store(commonpb.StateCode_Abnormal)
// req := &indexpb.BuildIndexRequest{}
// resp, err := ic.BuildIndex(context.Background(), req)
// assert.Error(t, err)
@ -839,7 +839,7 @@ func TestIndexCoord_DropIndex(t *testing.T) {
// },
// }
//
// ic.stateCode.Store(internalpb.StateCode_Healthy)
// ic.stateCode.Store(commonpb.StateCode_Healthy)
//
// t.Run("GetIndexFilePaths success", func(t *testing.T) {
// resp, err := ic.GetIndexFilePaths(context.Background(), &indexpb.GetIndexFilePathsRequest{IndexBuildIDs: []UniqueID{1}})
@ -932,7 +932,7 @@ func TestIndexCoord_DropIndex(t *testing.T) {
// notify: make(chan struct{}, 10),
// },
// }
// ic.stateCode.Store(internalpb.StateCode_Healthy)
// ic.stateCode.Store(commonpb.StateCode_Healthy)
// status, err := ic.RemoveIndex(context.Background(), &indexpb.RemoveIndexRequest{BuildIDs: []UniqueID{0}})
// assert.Nil(t, err)
// assert.Equal(t, commonpb.ErrorCode_Success, status.GetErrorCode())

28
internal/indexnode/indexnode.go
View File

@ -109,7 +109,7 @@ func NewIndexNode(ctx context.Context, factory dependency.Factory) (*IndexNode,
storageFactory: &chunkMgr{},
tasks: map[taskKey]*taskInfo{},
}
b.UpdateStateCode(internalpb.StateCode_Abnormal)
b.UpdateStateCode(commonpb.StateCode_Abnormal)
sc, err := NewTaskScheduler(b.loopCtx)
if err != nil {
return nil, err
@ -176,8 +176,8 @@ func (i *IndexNode) Init() error {
i.initOnce.Do(func() {
Params.Init()
i.UpdateStateCode(internalpb.StateCode_Initializing)
log.Debug("IndexNode init", zap.Any("State", i.stateCode.Load().(internalpb.StateCode)))
i.UpdateStateCode(commonpb.StateCode_Initializing)
log.Debug("IndexNode init", zap.Any("State", i.stateCode.Load().(commonpb.StateCode)))
err := i.initSession()
if err != nil {
log.Error(err.Error())
@ -212,7 +212,7 @@ func (i *IndexNode) Start() error {
Params.IndexNodeCfg.CreatedTime = time.Now()
Params.IndexNodeCfg.UpdatedTime = time.Now()
i.UpdateStateCode(internalpb.StateCode_Healthy)
i.UpdateStateCode(commonpb.StateCode_Healthy)
log.Debug("IndexNode", zap.Any("State", i.stateCode.Load()))
})
@ -223,7 +223,7 @@ func (i *IndexNode) Start() error {
// Stop closes the server.
func (i *IndexNode) Stop() error {
// https://github.com/milvus-io/milvus/issues/12282
i.UpdateStateCode(internalpb.StateCode_Abnormal)
i.UpdateStateCode(commonpb.StateCode_Abnormal)
// cleanup all running tasks
deletedTasks := i.deleteAllTasks()
for _, task := range deletedTasks {
@ -242,7 +242,7 @@ func (i *IndexNode) Stop() error {
}
// UpdateStateCode updates the component state of IndexNode.
func (i *IndexNode) UpdateStateCode(code internalpb.StateCode) {
func (i *IndexNode) UpdateStateCode(code commonpb.StateCode) {
i.stateCode.Store(code)
}
@ -252,14 +252,14 @@ func (i *IndexNode) SetEtcdClient(client *clientv3.Client) {
}
func (i *IndexNode) isHealthy() bool {
code := i.stateCode.Load().(internalpb.StateCode)
return code == internalpb.StateCode_Healthy
code := i.stateCode.Load().(commonpb.StateCode)
return code == commonpb.StateCode_Healthy
}
//// BuildIndex receives request from IndexCoordinator to build an index.
//// Index building is asynchronous, so when an index building request comes, IndexNode records the task and returns.
//func (i *IndexNode) BuildIndex(ctx context.Context, request *indexpb.BuildIndexRequest) (*commonpb.Status, error) {
// if i.stateCode.Load().(internalpb.StateCode) != internalpb.StateCode_Healthy {
// if i.stateCode.Load().(commonpb.StateCode) != commonpb.StateCode_Healthy {
// return &commonpb.Status{
// ErrorCode: commonpb.ErrorCode_UnexpectedError,
// Reason: "state code is not healthy",
@ -310,7 +310,7 @@ func (i *IndexNode) isHealthy() bool {
//
//// GetTaskSlots gets how many task the IndexNode can still perform.
//func (i *IndexNode) GetTaskSlots(ctx context.Context, req *indexpb.GetTaskSlotsRequest) (*indexpb.GetTaskSlotsResponse, error) {
// if i.stateCode.Load().(internalpb.StateCode) != internalpb.StateCode_Healthy {
// if i.stateCode.Load().(commonpb.StateCode) != commonpb.StateCode_Healthy {
// return &indexpb.GetTaskSlotsResponse{
// Status: &commonpb.Status{
// ErrorCode: commonpb.ErrorCode_UnexpectedError,
@ -332,20 +332,20 @@ func (i *IndexNode) isHealthy() bool {
//}
// GetComponentStates gets the component states of IndexNode.
func (i *IndexNode) GetComponentStates(ctx context.Context) (*internalpb.ComponentStates, error) {
func (i *IndexNode) GetComponentStates(ctx context.Context) (*milvuspb.ComponentStates, error) {
log.Debug("get IndexNode components states ...")
nodeID := common.NotRegisteredID
if i.session != nil && i.session.Registered() {
nodeID = i.session.ServerID
}
stateInfo := &internalpb.ComponentInfo{
stateInfo := &milvuspb.ComponentInfo{
// NodeID: Params.NodeID, // will race with i.Register()
NodeID: nodeID,
Role: typeutil.IndexNodeRole,
StateCode: i.stateCode.Load().(internalpb.StateCode),
StateCode: i.stateCode.Load().(commonpb.StateCode),
}
ret := &internalpb.ComponentStates{
ret := &milvuspb.ComponentStates{
State: stateInfo,
SubcomponentStates: nil, // todo add subcomponents states
Status: &commonpb.Status{

18
internal/indexnode/indexnode_mock.go
View File

@ -37,12 +37,12 @@ type Mock struct {
CallInit func() error
CallStart func() error
CallStop func() error
CallGetComponentStates func(ctx context.Context) (*internalpb.ComponentStates, error)
CallGetComponentStates func(ctx context.Context) (*milvuspb.ComponentStates, error)
CallGetStatisticsChannel func(ctx context.Context) (*milvuspb.StringResponse, error)
CallRegister func() error
CallSetEtcdClient func(etcdClient *clientv3.Client)
CallUpdateStateCode func(stateCode internalpb.StateCode)
CallUpdateStateCode func(stateCode commonpb.StateCode)
CallCreateJob func(ctx context.Context, req *indexpb.CreateJobRequest) (*commonpb.Status, error)
CallQueryJobs func(ctx context.Context, in *indexpb.QueryJobsRequest) (*indexpb.QueryJobsResponse, error)
@ -69,14 +69,14 @@ func NewIndexNodeMock() *Mock {
},
CallSetEtcdClient: func(etcdClient *clientv3.Client) {
},
CallUpdateStateCode: func(stateCode internalpb.StateCode) {
CallUpdateStateCode: func(stateCode commonpb.StateCode) {
},
CallGetComponentStates: func(ctx context.Context) (*internalpb.ComponentStates, error) {
return &internalpb.ComponentStates{
State: &internalpb.ComponentInfo{
CallGetComponentStates: func(ctx context.Context) (*milvuspb.ComponentStates, error) {
return &milvuspb.ComponentStates{
State: &milvuspb.ComponentInfo{
NodeID: 1,
Role: typeutil.IndexCoordRole,
StateCode: internalpb.StateCode_Healthy,
StateCode: commonpb.StateCode_Healthy,
},
SubcomponentStates: nil,
Status: &commonpb.Status{
@ -163,7 +163,7 @@ func (m *Mock) Stop() error {
return m.CallStop()
}
func (m *Mock) GetComponentStates(ctx context.Context) (*internalpb.ComponentStates, error) {
func (m *Mock) GetComponentStates(ctx context.Context) (*milvuspb.ComponentStates, error) {
return m.CallGetComponentStates(ctx)
}
@ -178,7 +178,7 @@ func (m *Mock) Register() error {
func (m *Mock) SetEtcdClient(etcdClient *clientv3.Client) {
}
func (m *Mock) UpdateStateCode(stateCode internalpb.StateCode) {
func (m *Mock) UpdateStateCode(stateCode commonpb.StateCode) {
}
func (m *Mock) CreateJob(ctx context.Context, req *indexpb.CreateJobRequest) (*commonpb.Status, error) {

17
internal/indexnode/indexnode_service.go
View File

@ -13,15 +13,14 @@ import (
"github.com/milvus-io/milvus/internal/log"
"github.com/milvus-io/milvus/internal/metrics"
"github.com/milvus-io/milvus/internal/proto/indexpb"
"github.com/milvus-io/milvus/internal/proto/internalpb"
"github.com/milvus-io/milvus/internal/util/metricsinfo"
"github.com/milvus-io/milvus/internal/util/timerecord"
"github.com/milvus-io/milvus/internal/util/trace"
)
func (i *IndexNode) CreateJob(ctx context.Context, req *indexpb.CreateJobRequest) (*commonpb.Status, error) {
stateCode := i.stateCode.Load().(internalpb.StateCode)
if stateCode != internalpb.StateCode_Healthy {
stateCode := i.stateCode.Load().(commonpb.StateCode)
if stateCode != commonpb.StateCode_Healthy {
log.Ctx(ctx).Warn("index node not ready", zap.Int32("state", int32(stateCode)), zap.String("ClusterID", req.ClusterID), zap.Int64("IndexBuildID", req.BuildID))
return &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
@ -93,8 +92,8 @@ func (i *IndexNode) CreateJob(ctx context.Context, req *indexpb.CreateJobRequest
}
func (i *IndexNode) QueryJobs(ctx context.Context, req *indexpb.QueryJobsRequest) (*indexpb.QueryJobsResponse, error) {
stateCode := i.stateCode.Load().(internalpb.StateCode)
if stateCode != internalpb.StateCode_Healthy {
stateCode := i.stateCode.Load().(commonpb.StateCode)
if stateCode != commonpb.StateCode_Healthy {
log.Ctx(ctx).Warn("index node not ready", zap.Int32("state", int32(stateCode)), zap.String("ClusterID", req.ClusterID))
return &indexpb.QueryJobsResponse{
Status: &commonpb.Status{
@ -144,8 +143,8 @@ func (i *IndexNode) QueryJobs(ctx context.Context, req *indexpb.QueryJobsRequest
func (i *IndexNode) DropJobs(ctx context.Context, req *indexpb.DropJobsRequest) (*commonpb.Status, error) {
log.Ctx(ctx).Debug("drop index build jobs", zap.String("ClusterID", req.ClusterID), zap.Int64s("IndexBuildIDs", req.BuildIDs))
stateCode := i.stateCode.Load().(internalpb.StateCode)
if stateCode != internalpb.StateCode_Healthy {
stateCode := i.stateCode.Load().(commonpb.StateCode)
if stateCode != commonpb.StateCode_Healthy {
log.Ctx(ctx).Warn("index node not ready", zap.Int32("state", int32(stateCode)), zap.String("ClusterID", req.ClusterID))
return &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
@ -171,8 +170,8 @@ func (i *IndexNode) DropJobs(ctx context.Context, req *indexpb.DropJobsRequest)
}
func (i *IndexNode) GetJobStats(ctx context.Context, req *indexpb.GetJobStatsRequest) (*indexpb.GetJobStatsResponse, error) {
stateCode := i.stateCode.Load().(internalpb.StateCode)
if stateCode != internalpb.StateCode_Healthy {
stateCode := i.stateCode.Load().(commonpb.StateCode)
if stateCode != commonpb.StateCode_Healthy {
log.Ctx(ctx).Warn("index node not ready", zap.Int32("state", int32(stateCode)))
return &indexpb.GetJobStatsResponse{
Status: &commonpb.Status{

7
internal/indexnode/indexnode_service_test.go
View File

@ -13,7 +13,6 @@ import (
"github.com/milvus-io/milvus/api/commonpb"
"github.com/milvus-io/milvus/api/milvuspb"
"github.com/milvus-io/milvus/internal/proto/indexpb"
"github.com/milvus-io/milvus/internal/proto/internalpb"
"github.com/milvus-io/milvus/internal/util/metricsinfo"
)
@ -24,7 +23,7 @@ func TestIndexNodeSimple(t *testing.T) {
state, err := in.GetComponentStates(ctx)
assert.Nil(t, err)
assert.Equal(t, state.Status.ErrorCode, commonpb.ErrorCode_Success)
assert.Equal(t, state.State.StateCode, internalpb.StateCode_Healthy)
assert.Equal(t, state.State.StateCode, commonpb.StateCode_Healthy)
assert.Nil(t, err, err)
var (
@ -199,7 +198,7 @@ func TestIndexNodeComplex(t *testing.T) {
state, err := in.GetComponentStates(ctx)
assert.Nil(t, err)
assert.Equal(t, state.Status.ErrorCode, commonpb.ErrorCode_Success)
assert.Equal(t, state.State.StateCode, internalpb.StateCode_Healthy)
assert.Equal(t, state.State.StateCode, commonpb.StateCode_Healthy)
mockChunkMgr := mockChunkMgrIns
@ -311,7 +310,7 @@ Loop:
assert.Nil(t, in.Stop())
node := in.(*mockIndexNodeComponent).IndexNode
assert.Equal(t, 0, len(node.tasks))
assert.Equal(t, internalpb.StateCode_Abnormal, node.stateCode.Load().(internalpb.StateCode))
assert.Equal(t, commonpb.StateCode_Abnormal, node.stateCode.Load().(commonpb.StateCode))
}
func TestAbnormalIndexNode(t *testing.T) {

11
internal/indexnode/indexnode_test.go
View File

@ -22,7 +22,6 @@ import (
"testing"
"github.com/milvus-io/milvus/api/commonpb"
"github.com/milvus-io/milvus/internal/proto/internalpb"
"github.com/stretchr/testify/assert"
)
@ -404,7 +403,7 @@ import (
// resp, err := in.GetComponentStates(ctx)
// assert.Nil(t, err)
// assert.Equal(t, commonpb.ErrorCode_Success, resp.Status.ErrorCode)
// assert.Equal(t, internalpb.StateCode_Healthy, resp.State.StateCode)
// assert.Equal(t, commonpb.StateCode_Healthy, resp.State.StateCode)
// })
//
// t.Run("GetTimeTickChannel", func(t *testing.T) {
@ -467,25 +466,25 @@ func TestComponentState(t *testing.T) {
state, err := in.GetComponentStates(ctx)
assert.Nil(t, err)
assert.Equal(t, state.Status.ErrorCode, commonpb.ErrorCode_Success)
assert.Equal(t, state.State.StateCode, internalpb.StateCode_Abnormal)
assert.Equal(t, state.State.StateCode, commonpb.StateCode_Abnormal)
assert.Nil(t, in.Init())
state, err = in.GetComponentStates(ctx)
assert.Nil(t, err)
assert.Equal(t, state.Status.ErrorCode, commonpb.ErrorCode_Success)
assert.Equal(t, state.State.StateCode, internalpb.StateCode_Initializing)
assert.Equal(t, state.State.StateCode, commonpb.StateCode_Initializing)
assert.Nil(t, in.Start())
state, err = in.GetComponentStates(ctx)
assert.Nil(t, err)
assert.Equal(t, state.Status.ErrorCode, commonpb.ErrorCode_Success)
assert.Equal(t, state.State.StateCode, internalpb.StateCode_Healthy)
assert.Equal(t, state.State.StateCode, commonpb.StateCode_Healthy)
assert.Nil(t, in.Stop())
state, err = in.GetComponentStates(ctx)
assert.Nil(t, err)
assert.Equal(t, state.Status.ErrorCode, commonpb.ErrorCode_Success)
assert.Equal(t, state.State.StateCode, internalpb.StateCode_Abnormal)
assert.Equal(t, state.State.StateCode, commonpb.StateCode_Abnormal)
}
func TestGetTimeTickChannel(t *testing.T) {

10
internal/mocks/mock_datacoord.go
View File

@ -359,15 +359,15 @@ func (_c *DataCoord_GetCompactionStateWithPlans_Call) Return(_a0 *milvuspb.GetCo
}
// GetComponentStates provides a mock function with given fields: ctx
func (_m *DataCoord) GetComponentStates(ctx context.Context) (*internalpb.ComponentStates, error) {
func (_m *DataCoord) GetComponentStates(ctx context.Context) (*milvuspb.ComponentStates, error) {
ret := _m.Called(ctx)
var r0 *internalpb.ComponentStates
if rf, ok := ret.Get(0).(func(context.Context) *internalpb.ComponentStates); ok {
var r0 *milvuspb.ComponentStates
if rf, ok := ret.Get(0).(func(context.Context) *milvuspb.ComponentStates); ok {
r0 = rf(ctx)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*internalpb.ComponentStates)
r0 = ret.Get(0).(*milvuspb.ComponentStates)
}
}
@ -399,7 +399,7 @@ func (_c *DataCoord_GetComponentStates_Call) Run(run func(ctx context.Context))
return _c
}
func (_c *DataCoord_GetComponentStates_Call) Return(_a0 *internalpb.ComponentStates, _a1 error) *DataCoord_GetComponentStates_Call {
func (_c *DataCoord_GetComponentStates_Call) Return(_a0 *milvuspb.ComponentStates, _a1 error) *DataCoord_GetComponentStates_Call {
_c.Call.Return(_a0, _a1)
return _c
}

10
internal/mocks/mock_datanode.go
View File

@ -218,15 +218,15 @@ func (_c *DataNode_GetCompactionState_Call) Return(_a0 *datapb.CompactionStateRe
}
// GetComponentStates provides a mock function with given fields: ctx
func (_m *DataNode) GetComponentStates(ctx context.Context) (*internalpb.ComponentStates, error) {
func (_m *DataNode) GetComponentStates(ctx context.Context) (*milvuspb.ComponentStates, error) {
ret := _m.Called(ctx)
var r0 *internalpb.ComponentStates
if rf, ok := ret.Get(0).(func(context.Context) *internalpb.ComponentStates); ok {
var r0 *milvuspb.ComponentStates
if rf, ok := ret.Get(0).(func(context.Context) *milvuspb.ComponentStates); ok {
r0 = rf(ctx)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*internalpb.ComponentStates)
r0 = ret.Get(0).(*milvuspb.ComponentStates)
}
}
@ -258,7 +258,7 @@ func (_c *DataNode_GetComponentStates_Call) Run(run func(ctx context.Context)) *
return _c
}
func (_c *DataNode_GetComponentStates_Call) Return(_a0 *internalpb.ComponentStates, _a1 error) *DataNode_GetComponentStates_Call {
func (_c *DataNode_GetComponentStates_Call) Return(_a0 *milvuspb.ComponentStates, _a1 error) *DataNode_GetComponentStates_Call {
_c.Call.Return(_a0, _a1)
return _c
}

10
internal/mocks/mock_indexcoord.go
View File

@ -171,15 +171,15 @@ func (_c *MockIndexCoord_DropIndex_Call) Return(_a0 *commonpb.Status, _a1 error)
}
// GetComponentStates provides a mock function with given fields: ctx
func (_m *MockIndexCoord) GetComponentStates(ctx context.Context) (*internalpb.ComponentStates, error) {
func (_m *MockIndexCoord) GetComponentStates(ctx context.Context) (*milvuspb.ComponentStates, error) {
ret := _m.Called(ctx)
var r0 *internalpb.ComponentStates
if rf, ok := ret.Get(0).(func(context.Context) *internalpb.ComponentStates); ok {
var r0 *milvuspb.ComponentStates
if rf, ok := ret.Get(0).(func(context.Context) *milvuspb.ComponentStates); ok {
r0 = rf(ctx)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*internalpb.ComponentStates)
r0 = ret.Get(0).(*milvuspb.ComponentStates)
}
}
@ -211,7 +211,7 @@ func (_c *MockIndexCoord_GetComponentStates_Call) Run(run func(ctx context.Conte
return _c
}
func (_c *MockIndexCoord_GetComponentStates_Call) Return(_a0 *internalpb.ComponentStates, _a1 error) *MockIndexCoord_GetComponentStates_Call {
func (_c *MockIndexCoord_GetComponentStates_Call) Return(_a0 *milvuspb.ComponentStates, _a1 error) *MockIndexCoord_GetComponentStates_Call {
_c.Call.Return(_a0, _a1)
return _c
}

10
internal/mocks/mock_rootcoord.go
View File

@ -690,15 +690,15 @@ func (_c *RootCoord_DropRole_Call) Return(_a0 *commonpb.Status, _a1 error) *Root
}
// GetComponentStates provides a mock function with given fields: ctx
func (_m *RootCoord) GetComponentStates(ctx context.Context) (*internalpb.ComponentStates, error) {
func (_m *RootCoord) GetComponentStates(ctx context.Context) (*milvuspb.ComponentStates, error) {
ret := _m.Called(ctx)
var r0 *internalpb.ComponentStates
if rf, ok := ret.Get(0).(func(context.Context) *internalpb.ComponentStates); ok {
var r0 *milvuspb.ComponentStates
if rf, ok := ret.Get(0).(func(context.Context) *milvuspb.ComponentStates); ok {
r0 = rf(ctx)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*internalpb.ComponentStates)
r0 = ret.Get(0).(*milvuspb.ComponentStates)
}
}
@ -730,7 +730,7 @@ func (_c *RootCoord_GetComponentStates_Call) Run(run func(ctx context.Context))
return _c
}
func (_c *RootCoord_GetComponentStates_Call) Return(_a0 *internalpb.ComponentStates, _a1 error) *RootCoord_GetComponentStates_Call {
func (_c *RootCoord_GetComponentStates_Call) Return(_a0 *milvuspb.ComponentStates, _a1 error) *RootCoord_GetComponentStates_Call {
_c.Call.Return(_a0, _a1)
return _c
}

7
internal/proto/common.proto
View File

@ -328,3 +328,10 @@ message PrivilegeExt {
extend google.protobuf.MessageOptions {
PrivilegeExt privilege_ext_obj = 1001;
}
enum StateCode {
Initializing = 0;
Healthy = 1;
Abnormal = 2;
StandBy = 3;
}

4
internal/proto/data_coord.proto
View File

@ -19,7 +19,7 @@ enum SegmentType {
}
service DataCoord {
rpc GetComponentStates(internal.GetComponentStatesRequest) returns (internal.ComponentStates) {}
rpc GetComponentStates(milvus.GetComponentStatesRequest) returns (milvus.ComponentStates) {}
rpc GetTimeTickChannel(internal.GetTimeTickChannelRequest) returns(milvus.StringResponse) {}
rpc GetStatisticsChannel(internal.GetStatisticsChannelRequest) returns(milvus.StringResponse){}
@ -66,7 +66,7 @@ service DataCoord {
}
service DataNode {
rpc GetComponentStates(internal.GetComponentStatesRequest) returns (internal.ComponentStates) {}
rpc GetComponentStates(milvus.GetComponentStatesRequest) returns (milvus.ComponentStates) {}
rpc GetStatisticsChannel(internal.GetStatisticsChannelRequest) returns (milvus.StringResponse) {}
rpc WatchDmChannels(WatchDmChannelsRequest) returns (common.Status) {}

560
internal/proto/datapb/data_coord.pb.go
View File

@ -4852,272 +4852,272 @@ func init() {
func init() { proto.RegisterFile("data_coord.proto", fileDescriptor_82cd95f524594f49) }
var fileDescriptor_82cd95f524594f49 = []byte{
// 4240 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x3c, 0x5b, 0x6f, 0x1c, 0x59,
0x5a, 0xa9, 0xbe, 0xb9, 0xfb, 0xeb, 0x8b, 0xdb, 0x27, 0x19, 0xbb, 0xd3, 0x93, 0xdb, 0xd4, 0x4c,
0x32, 0x99, 0x4c, 0x26, 0x99, 0xf1, 0x30, 0xda, 0x81, 0xec, 0xcc, 0x6a, 0x1c, 0x4f, 0x3c, 0x0d,
0xb6, 0xd7, 0x5b, 0x76, 0x26, 0xd2, 0x2e, 0x52, 0xab, 0xd2, 0x75, 0xdc, 0xae, 0x75, 0x57, 0x55,
0xa7, 0xaa, 0xda, 0x8e, 0x97, 0x87, 0x1d, 0xb1, 0x12, 0xd2, 0x22, 0xc4, 0x72, 0x11, 0x12, 0x3c,
0x20, 0x21, 0x9e, 0x16, 0x10, 0x12, 0xd2, 0x8a, 0x07, 0xe0, 0x81, 0x07, 0x5e, 0x56, 0x80, 0xb4,
0x82, 0x07, 0x7e, 0x02, 0xf0, 0xce, 0x2b, 0x0f, 0xe8, 0x5c, 0xea, 0xd4, 0xed, 0x54, 0x77, 0xb9,
0x3b, 0xd9, 0x20, 0x78, 0xeb, 0xf3, 0xd5, 0x77, 0x6e, 0xdf, 0xfd, 0xfb, 0xce, 0x39, 0x0d, 0x6d,
0x43, 0xf7, 0xf5, 0xfe, 0xc0, 0x71, 0x5c, 0xe3, 0xde, 0xd8, 0x75, 0x7c, 0x07, 0xad, 0x58, 0xe6,
0xe8, 0x64, 0xe2, 0xb1, 0xd6, 0x3d, 0xf2, 0xb9, 0xdb, 0x18, 0x38, 0x96, 0xe5, 0xd8, 0x0c, 0xd4,
0x6d, 0x99, 0xb6, 0x8f, 0x5d, 0x5b, 0x1f, 0xf1, 0x76, 0x23, 0xda, 0xa1, 0xdb, 0xf0, 0x06, 0x47,
0xd8, 0xd2, 0x59, 0x4b, 0x5d, 0x82, 0xf2, 0xe7, 0xd6, 0xd8, 0x3f, 0x53, 0xff, 0x50, 0x81, 0xc6,
0xa3, 0xd1, 0xc4, 0x3b, 0xd2, 0xf0, 0xb3, 0x09, 0xf6, 0x7c, 0xf4, 0x3e, 0x94, 0x9e, 0xea, 0x1e,
0xee, 0x28, 0x37, 0x94, 0xdb, 0xf5, 0xf5, 0x2b, 0xf7, 0x62, 0xb3, 0xf2, 0xf9, 0x76, 0xbc, 0xe1,
0x86, 0xee, 0x61, 0x8d, 0x62, 0x22, 0x04, 0x25, 0xe3, 0x69, 0x6f, 0xb3, 0x53, 0xb8, 0xa1, 0xdc,
0x2e, 0x6a, 0xf4, 0x37, 0xba, 0x06, 0xe0, 0xe1, 0xa1, 0x85, 0x6d, 0xbf, 0xb7, 0xe9, 0x75, 0x8a,
0x37, 0x8a, 0xb7, 0x8b, 0x5a, 0x04, 0x82, 0x54, 0x68, 0x0c, 0x9c, 0xd1, 0x08, 0x0f, 0x7c, 0xd3,
0xb1, 0x7b, 0x9b, 0x9d, 0x12, 0xed, 0x1b, 0x83, 0xa9, 0xff, 0xae, 0x40, 0x93, 0x2f, 0xcd, 0x1b,
0x3b, 0xb6, 0x87, 0xd1, 0x87, 0x50, 0xf1, 0x7c, 0xdd, 0x9f, 0x78, 0x7c, 0x75, 0xaf, 0x4b, 0x57,
0xb7, 0x4f, 0x51, 0x34, 0x8e, 0x2a, 0x5d, 0x5e, 0x72, 0xfa, 0x62, 0x7a, 0xfa, 0xc4, 0x16, 0x4a,
0xa9, 0x2d, 0xdc, 0x86, 0xe5, 0x43, 0xb2, 0xba, 0xfd, 0x10, 0xa9, 0x4c, 0x91, 0x92, 0x60, 0x32,
0x92, 0x6f, 0x5a, 0xf8, 0x9b, 0x87, 0xfb, 0x58, 0x1f, 0x75, 0x2a, 0x74, 0xae, 0x08, 0x44, 0xfd,
0x17, 0x05, 0xda, 0x02, 0x3d, 0xe0, 0xc3, 0x25, 0x28, 0x0f, 0x9c, 0x89, 0xed, 0xd3, 0xad, 0x36,
0x35, 0xd6, 0x40, 0x6f, 0x40, 0x63, 0x70, 0xa4, 0xdb, 0x36, 0x1e, 0xf5, 0x6d, 0xdd, 0xc2, 0x74,
0x53, 0x35, 0xad, 0xce, 0x61, 0xbb, 0xba, 0x85, 0x73, 0xed, 0xed, 0x06, 0xd4, 0xc7, 0xba, 0xeb,
0x9b, 0x31, 0xea, 0x47, 0x41, 0xa8, 0x0b, 0x55, 0xd3, 0xeb, 0x59, 0x63, 0xc7, 0xf5, 0x3b, 0xe5,
0x1b, 0xca, 0xed, 0xaa, 0x26, 0xda, 0x64, 0x06, 0x93, 0xfe, 0x3a, 0xd0, 0xbd, 0xe3, 0xde, 0x26,
0xdf, 0x51, 0x0c, 0xa6, 0xfe, 0x89, 0x02, 0xab, 0x9f, 0x79, 0x9e, 0x39, 0xb4, 0x53, 0x3b, 0x5b,
0x85, 0x8a, 0xed, 0x18, 0xb8, 0xb7, 0x49, 0xb7, 0x56, 0xd4, 0x78, 0x0b, 0xbd, 0x0e, 0xb5, 0x31,
0xc6, 0x6e, 0xdf, 0x75, 0x46, 0xc1, 0xc6, 0xaa, 0x04, 0xa0, 0x39, 0x23, 0x8c, 0xbe, 0x05, 0x2b,
0x5e, 0x62, 0x20, 0x26, 0x57, 0xf5, 0xf5, 0x37, 0xef, 0xa5, 0x34, 0xe3, 0x5e, 0x72, 0x52, 0x2d,
0xdd, 0x5b, 0xfd, 0xaa, 0x00, 0x17, 0x05, 0x1e, 0x5b, 0x2b, 0xf9, 0x4d, 0x28, 0xef, 0xe1, 0xa1,
0x58, 0x1e, 0x6b, 0xe4, 0xa1, 0xbc, 0x60, 0x59, 0x31, 0xca, 0xb2, 0x1c, 0xa2, 0x9e, 0xe4, 0x47,
0x39, 0xcd, 0x8f, 0xeb, 0x50, 0xc7, 0xcf, 0xc7, 0xa6, 0x8b, 0xfb, 0x44, 0x70, 0x28, 0xc9, 0x4b,
0x1a, 0x30, 0xd0, 0x81, 0x69, 0x45, 0x75, 0x63, 0x29, 0xb7, 0x6e, 0xa8, 0x7f, 0xaa, 0xc0, 0x5a,
0x8a, 0x4b, 0x5c, 0xd9, 0x34, 0x68, 0xd3, 0x9d, 0x87, 0x94, 0x21, 0x6a, 0x47, 0x08, 0x7e, 0x6b,
0x1a, 0xc1, 0x43, 0x74, 0x2d, 0xd5, 0x3f, 0xb2, 0xc8, 0x42, 0xfe, 0x45, 0x1e, 0xc3, 0xda, 0x16,
0xf6, 0xf9, 0x04, 0xe4, 0x1b, 0xf6, 0xe6, 0x37, 0x56, 0x71, 0xad, 0x2e, 0x24, 0xb5, 0x5a, 0xfd,
0xab, 0x82, 0xd0, 0x45, 0x3a, 0x55, 0xcf, 0x3e, 0x74, 0xd0, 0x15, 0xa8, 0x09, 0x14, 0x2e, 0x15,
0x21, 0x00, 0x7d, 0x0d, 0xca, 0x64, 0xa5, 0x4c, 0x24, 0x5a, 0xeb, 0x6f, 0xc8, 0xf7, 0x14, 0x19,
0x53, 0x63, 0xf8, 0xa8, 0x07, 0x2d, 0xcf, 0xd7, 0x5d, 0xbf, 0x3f, 0x76, 0x3c, 0xca, 0x67, 0x2a,
0x38, 0xf5, 0x75, 0x35, 0x3e, 0x82, 0x30, 0xeb, 0x3b, 0xde, 0x70, 0x8f, 0x63, 0x6a, 0x4d, 0xda,
0x33, 0x68, 0xa2, 0xcf, 0xa1, 0x81, 0x6d, 0x23, 0x1c, 0xa8, 0x94, 0x7b, 0xa0, 0x3a, 0xb6, 0x0d,
0x31, 0x4c, 0xc8, 0x9f, 0x72, 0x7e, 0xfe, 0xfc, 0x96, 0x02, 0x9d, 0x34, 0x83, 0x16, 0x31, 0xd9,
0x0f, 0x58, 0x27, 0xcc, 0x18, 0x34, 0x55, 0xc3, 0x05, 0x93, 0x34, 0xde, 0x45, 0xfd, 0x03, 0x05,
0x5e, 0x0b, 0x97, 0x43, 0x3f, 0xbd, 0x2c, 0x69, 0x41, 0x77, 0xa0, 0x6d, 0xda, 0x83, 0xd1, 0xc4,
0xc0, 0x8f, 0xed, 0x2f, 0xb0, 0x3e, 0xf2, 0x8f, 0xce, 0x28, 0x0f, 0xab, 0x5a, 0x0a, 0xae, 0xfe,
0x40, 0x81, 0xd5, 0xe4, 0xba, 0x16, 0x21, 0xd2, 0x2f, 0x40, 0xd9, 0xb4, 0x0f, 0x9d, 0x80, 0x46,
0xd7, 0xa6, 0x28, 0x25, 0x99, 0x8b, 0x21, 0xab, 0x16, 0xbc, 0xbe, 0x85, 0xfd, 0x9e, 0xed, 0x61,
0xd7, 0xdf, 0x30, 0xed, 0x91, 0x33, 0xdc, 0xd3, 0xfd, 0xa3, 0x05, 0x14, 0x2a, 0xa6, 0x1b, 0x85,
0x84, 0x6e, 0xa8, 0x3f, 0x56, 0xe0, 0x8a, 0x7c, 0x3e, 0xbe, 0xf5, 0x2e, 0x54, 0x0f, 0x4d, 0x3c,
0x32, 0x08, 0x7d, 0x15, 0x4a, 0x5f, 0xd1, 0x26, 0x8a, 0x35, 0x26, 0xc8, 0x7c, 0x87, 0x6f, 0x64,
0x48, 0xf3, 0xbe, 0xef, 0x9a, 0xf6, 0x70, 0xdb, 0xf4, 0x7c, 0x8d, 0xe1, 0x47, 0xe8, 0x59, 0xcc,
0x2f, 0xc6, 0xbf, 0xa9, 0xc0, 0xb5, 0x2d, 0xec, 0x3f, 0x14, 0x76, 0x99, 0x7c, 0x37, 0x3d, 0xdf,
0x1c, 0x78, 0x2f, 0x36, 0x36, 0xca, 0xe1, 0xa0, 0xd5, 0x1f, 0x29, 0x70, 0x3d, 0x73, 0x31, 0x9c,
0x74, 0xdc, 0xee, 0x04, 0x56, 0x59, 0x6e, 0x77, 0x7e, 0x05, 0x9f, 0x7d, 0xa9, 0x8f, 0x26, 0x78,
0x4f, 0x37, 0x5d, 0x66, 0x77, 0xe6, 0xb4, 0xc2, 0x7f, 0xa9, 0xc0, 0xd5, 0x2d, 0xec, 0xef, 0x05,
0x3e, 0xe9, 0x15, 0x52, 0x87, 0xe0, 0x44, 0x7c, 0x63, 0x10, 0x9c, 0xc5, 0x60, 0xea, 0x6f, 0x33,
0x76, 0x4a, 0xd7, 0xfb, 0x4a, 0x08, 0x78, 0x8d, 0x6a, 0x42, 0x44, 0x25, 0x1f, 0xb2, 0xd0, 0x81,
0x93, 0x4f, 0xfd, 0x63, 0x05, 0x2e, 0x7f, 0x36, 0x78, 0x36, 0x31, 0x5d, 0xcc, 0x91, 0xb6, 0x9d,
0xc1, 0xf1, 0xfc, 0xc4, 0x0d, 0xc3, 0xac, 0x42, 0x2c, 0xcc, 0x9a, 0x15, 0x9a, 0xaf, 0x42, 0xc5,
0x67, 0x71, 0x1d, 0x8b, 0x54, 0x78, 0x8b, 0xae, 0x4f, 0xc3, 0x23, 0xac, 0x7b, 0xff, 0x3b, 0xd7,
0xf7, 0xa3, 0x12, 0x34, 0xbe, 0xe4, 0xe1, 0x18, 0xf5, 0xda, 0x49, 0x49, 0x52, 0xe4, 0x81, 0x57,
0x24, 0x82, 0x93, 0x05, 0x75, 0x5b, 0xd0, 0xf4, 0x30, 0x3e, 0x9e, 0xc7, 0x47, 0x37, 0x48, 0x47,
0xe1, 0x5b, 0xb7, 0x61, 0x65, 0x62, 0xd3, 0xd4, 0x00, 0x1b, 0x9c, 0x80, 0x4c, 0x72, 0x67, 0xdb,
0xee, 0x74, 0x47, 0xf4, 0x05, 0xcf, 0x3e, 0x22, 0x63, 0x95, 0x73, 0x8d, 0x95, 0xec, 0x86, 0x7a,
0xd0, 0x36, 0x5c, 0x67, 0x3c, 0xc6, 0x46, 0xdf, 0x0b, 0x86, 0xaa, 0xe4, 0x1b, 0x8a, 0xf7, 0x13,
0x43, 0xbd, 0x0f, 0x17, 0x93, 0x2b, 0xed, 0x19, 0x24, 0x20, 0x25, 0x3c, 0x94, 0x7d, 0x42, 0x77,
0x61, 0x25, 0x8d, 0x5f, 0xa5, 0xf8, 0xe9, 0x0f, 0xe8, 0x3d, 0x40, 0x89, 0xa5, 0x12, 0xf4, 0x1a,
0x43, 0x8f, 0x2f, 0xa6, 0x67, 0x78, 0xea, 0x0f, 0x15, 0x58, 0x7d, 0xa2, 0xfb, 0x83, 0xa3, 0x4d,
0x8b, 0xeb, 0xda, 0x02, 0xb6, 0xea, 0x13, 0xa8, 0x9d, 0x70, 0xb9, 0x08, 0x1c, 0xd2, 0x75, 0x09,
0x7d, 0xa2, 0x12, 0xa8, 0x85, 0x3d, 0xd4, 0x9f, 0x2a, 0x70, 0xe9, 0x51, 0x24, 0x2f, 0x7c, 0x05,
0x56, 0x73, 0x56, 0x42, 0x7b, 0x0b, 0x5a, 0x96, 0xee, 0x1e, 0xa7, 0xf2, 0xd9, 0x04, 0x54, 0x7d,
0x0e, 0xc0, 0x5b, 0x3b, 0xde, 0x70, 0x8e, 0xf5, 0x7f, 0x0c, 0x4b, 0x7c, 0x56, 0x6e, 0x3e, 0x67,
0xc9, 0x59, 0x80, 0xae, 0xfe, 0xa3, 0x02, 0xad, 0xd0, 0x25, 0x52, 0x25, 0x6f, 0x41, 0x41, 0xa8,
0x76, 0xa1, 0xb7, 0x89, 0x3e, 0x81, 0x0a, 0x2b, 0x74, 0xf0, 0xb1, 0x6f, 0xc6, 0xc7, 0xe6, 0x45,
0x90, 0x88, 0x5f, 0xa5, 0x00, 0x8d, 0x77, 0x22, 0x34, 0x12, 0x5e, 0x44, 0x18, 0x9f, 0x10, 0x82,
0x7a, 0xb0, 0x1c, 0x0f, 0xd9, 0x03, 0x15, 0xbe, 0x91, 0xe5, 0x3c, 0x36, 0x75, 0x5f, 0xa7, 0xbe,
0xa3, 0x15, 0x8b, 0xd8, 0x3d, 0xf5, 0x77, 0x2b, 0x50, 0x8f, 0xec, 0x32, 0xb5, 0x93, 0x24, 0x4b,
0x0b, 0xb3, 0xf3, 0xc6, 0x62, 0x3a, 0x6f, 0xbc, 0x09, 0x2d, 0x93, 0x06, 0x5f, 0x7d, 0x2e, 0x8a,
0xd4, 0x6a, 0xd6, 0xb4, 0x26, 0x83, 0x72, 0xbd, 0x40, 0xd7, 0xa0, 0x6e, 0x4f, 0xac, 0xbe, 0x73,
0xd8, 0x77, 0x9d, 0x53, 0x8f, 0x27, 0xa0, 0x35, 0x7b, 0x62, 0x7d, 0xf3, 0x50, 0x73, 0x4e, 0xbd,
0x30, 0xc7, 0xa9, 0x9c, 0x33, 0xc7, 0xb9, 0x06, 0x75, 0x4b, 0x7f, 0x4e, 0x46, 0xed, 0xdb, 0x13,
0x8b, 0xe6, 0xa6, 0x45, 0xad, 0x66, 0xe9, 0xcf, 0x35, 0xe7, 0x74, 0x77, 0x62, 0xa1, 0xdb, 0xd0,
0x1e, 0xe9, 0x9e, 0xdf, 0x8f, 0x26, 0xb7, 0x55, 0x9a, 0xdc, 0xb6, 0x08, 0xfc, 0xf3, 0x30, 0xc1,
0x4d, 0x67, 0x4b, 0xb5, 0x05, 0xb2, 0x25, 0xc3, 0x1a, 0x85, 0x03, 0x41, 0xfe, 0x6c, 0xc9, 0xb0,
0x46, 0x62, 0x98, 0x8f, 0x61, 0xe9, 0x29, 0x0d, 0x69, 0xbd, 0x4e, 0x3d, 0xd3, 0x60, 0x3e, 0x22,
0xd1, 0x2c, 0x8b, 0x7c, 0xb5, 0x00, 0x1d, 0x7d, 0x1d, 0x6a, 0x34, 0x92, 0xa0, 0x7d, 0x1b, 0xb9,
0xfa, 0x86, 0x1d, 0x48, 0x6f, 0x03, 0x8f, 0x7c, 0x9d, 0xf6, 0x6e, 0xe6, 0xeb, 0x2d, 0x3a, 0x10,
0x23, 0x3d, 0x70, 0xb1, 0xee, 0x63, 0x63, 0xe3, 0xec, 0xa1, 0x63, 0x8d, 0x75, 0x2a, 0x4c, 0x9d,
0x16, 0x4d, 0x5b, 0x64, 0x9f, 0x88, 0x61, 0x18, 0x88, 0xd6, 0x23, 0xd7, 0xb1, 0x3a, 0xcb, 0xcc,
0x30, 0xc4, 0xa1, 0xe8, 0x2a, 0x40, 0x60, 0x9e, 0x75, 0xbf, 0xd3, 0xa6, 0x5c, 0xac, 0x71, 0xc8,
0x67, 0xb4, 0x76, 0x65, 0x7a, 0x7d, 0x56, 0x25, 0x32, 0xed, 0x61, 0x67, 0x85, 0xce, 0x58, 0x0f,
0xca, 0x4a, 0xa6, 0x3d, 0x54, 0xbf, 0x0f, 0x97, 0x42, 0x21, 0x8a, 0x30, 0x2c, 0xcd, 0x7b, 0x65,
0x5e, 0xde, 0x4f, 0xcf, 0x57, 0x7e, 0x56, 0x82, 0xd5, 0x7d, 0xfd, 0x04, 0xbf, 0xfc, 0xd4, 0x28,
0x97, 0xc9, 0xde, 0x86, 0x15, 0x9a, 0x0d, 0xad, 0x47, 0xd6, 0x33, 0x25, 0x66, 0x88, 0x72, 0x3c,
0xdd, 0x11, 0x7d, 0x83, 0x04, 0x3b, 0x78, 0x70, 0xbc, 0xe7, 0x98, 0x61, 0xbc, 0x70, 0x55, 0x32,
0xce, 0x43, 0x81, 0xa5, 0x45, 0x7b, 0xa0, 0xbd, 0xb4, 0xf5, 0x63, 0x91, 0xc2, 0xdb, 0x53, 0x13,
0xf4, 0x90, 0xfa, 0x49, 0x23, 0x88, 0x3a, 0xb0, 0xc4, 0xdd, 0x3c, 0x35, 0x0d, 0x55, 0x2d, 0x68,
0xa2, 0x3d, 0xb8, 0xc8, 0x76, 0xb0, 0xcf, 0xe5, 0x9e, 0x6d, 0xbe, 0x9a, 0x6b, 0xf3, 0xb2, 0xae,
0x71, 0xb5, 0xa9, 0x9d, 0x57, 0x6d, 0x3a, 0xb0, 0xc4, 0x45, 0x99, 0x9a, 0x8b, 0xaa, 0x16, 0x34,
0x09, 0x9b, 0x43, 0xa1, 0xae, 0xd3, 0x6f, 0x21, 0x80, 0xa4, 0x95, 0x10, 0xd2, 0x73, 0x46, 0x29,
0xe9, 0x53, 0xa8, 0x0a, 0x09, 0x2f, 0xe4, 0x96, 0x70, 0xd1, 0x27, 0x69, 0xc6, 0x8b, 0x09, 0x33,
0xae, 0xfe, 0x93, 0x02, 0x8d, 0x4d, 0xb2, 0xa5, 0x6d, 0x67, 0x48, 0x9d, 0xce, 0x4d, 0x68, 0xb9,
0x78, 0xe0, 0xb8, 0x46, 0x1f, 0xdb, 0xbe, 0x6b, 0x62, 0x56, 0x81, 0x28, 0x69, 0x4d, 0x06, 0xfd,
0x9c, 0x01, 0x09, 0x1a, 0xb1, 0xcc, 0x9e, 0xaf, 0x5b, 0xe3, 0xfe, 0x21, 0xb1, 0x00, 0x05, 0x86,
0x26, 0xa0, 0xd4, 0x00, 0xbc, 0x01, 0x8d, 0x10, 0xcd, 0x77, 0xe8, 0xfc, 0x25, 0xad, 0x2e, 0x60,
0x07, 0x0e, 0x7a, 0x0b, 0x5a, 0x94, 0xa6, 0xfd, 0x91, 0x33, 0xec, 0x93, 0x6c, 0x9d, 0xfb, 0xa3,
0x86, 0xc1, 0x97, 0x45, 0x78, 0x15, 0xc7, 0xf2, 0xcc, 0xef, 0x61, 0xee, 0x91, 0x04, 0xd6, 0xbe,
0xf9, 0x3d, 0x4c, 0xc2, 0x81, 0x26, 0x71, 0xaf, 0xbb, 0x8e, 0x81, 0x0f, 0xe6, 0x0c, 0x46, 0x72,
0x94, 0x75, 0xaf, 0x40, 0x4d, 0xec, 0x80, 0x6f, 0x29, 0x04, 0xa0, 0x47, 0xd0, 0x0a, 0xc2, 0xe6,
0x3e, 0xcb, 0x26, 0x4b, 0x99, 0xc1, 0x61, 0xc4, 0x41, 0x7a, 0x5a, 0x33, 0xe8, 0x46, 0x9b, 0xea,
0x23, 0x68, 0x44, 0x3f, 0x93, 0x59, 0xf7, 0x93, 0x82, 0x22, 0x00, 0x44, 0x1a, 0x77, 0x27, 0x16,
0xe1, 0x29, 0x37, 0x2c, 0x41, 0x53, 0xfd, 0x81, 0x02, 0x4d, 0xee, 0xd5, 0xf7, 0xc5, 0x01, 0x08,
0xdd, 0x9a, 0x42, 0xb7, 0x46, 0x7f, 0xa3, 0x5f, 0x8a, 0xd7, 0x2c, 0xdf, 0x92, 0x1a, 0x01, 0x3a,
0x08, 0x0d, 0xa0, 0x63, 0x2e, 0x3d, 0x4f, 0xfd, 0xe2, 0x2b, 0x22, 0x68, 0x9c, 0x35, 0x54, 0xd0,
0x3a, 0xb0, 0xa4, 0x1b, 0x86, 0x8b, 0x3d, 0x8f, 0xaf, 0x23, 0x68, 0x92, 0x2f, 0x27, 0xd8, 0xf5,
0x02, 0x91, 0x2f, 0x6a, 0x41, 0x13, 0x7d, 0x1d, 0xaa, 0x22, 0xe2, 0x2e, 0xca, 0xa2, 0xac, 0xe8,
0x3a, 0x79, 0xb6, 0x2d, 0x7a, 0xa8, 0x7f, 0x5d, 0x80, 0x16, 0x27, 0xd8, 0x06, 0x77, 0xbb, 0xd3,
0x95, 0x6f, 0x03, 0x1a, 0x87, 0xa1, 0xee, 0x4f, 0xab, 0xab, 0x45, 0x4d, 0x44, 0xac, 0xcf, 0x2c,
0x05, 0x8c, 0x3b, 0xfe, 0xd2, 0x42, 0x8e, 0xbf, 0x7c, 0x5e, 0x0b, 0x96, 0x0e, 0x05, 0x2b, 0x92,
0x50, 0x50, 0xfd, 0x55, 0xa8, 0x47, 0x06, 0xa0, 0x16, 0x9a, 0x15, 0xe4, 0x38, 0xc5, 0x82, 0x26,
0xfa, 0x30, 0x0c, 0x7f, 0x18, 0xa9, 0x2e, 0x4b, 0xd6, 0x92, 0x88, 0x7c, 0xd4, 0xbf, 0x57, 0xa0,
0xc2, 0x47, 0xbe, 0x0e, 0x75, 0x6e, 0x74, 0x68, 0x68, 0xc8, 0x46, 0x07, 0x0e, 0x22, 0xb1, 0xe1,
0x8b, 0xb3, 0x3a, 0x97, 0xa1, 0x9a, 0xb0, 0x37, 0x4b, 0xdc, 0x2d, 0x04, 0x9f, 0x22, 0x46, 0x86,
0x7c, 0x22, 0xf6, 0x05, 0x5d, 0x82, 0xf2, 0xc8, 0x19, 0x8a, 0x03, 0x2e, 0xd6, 0x20, 0x99, 0xdc,
0xda, 0x16, 0xf6, 0x35, 0x3c, 0x70, 0x4e, 0xb0, 0x7b, 0xb6, 0x78, 0x21, 0xf7, 0x41, 0x44, 0xcc,
0x73, 0x26, 0x96, 0xa2, 0x03, 0x7a, 0x10, 0x32, 0xa1, 0x28, 0xab, 0x62, 0x45, 0xed, 0x0e, 0x17,
0xd2, 0x90, 0x19, 0xbf, 0xc3, 0x4a, 0xd2, 0xf1, 0xad, 0xcc, 0x1b, 0xed, 0xbc, 0x90, 0x7c, 0x45,
0xfd, 0x99, 0x02, 0xdd, 0xb0, 0x4c, 0xe6, 0x6d, 0x9c, 0x2d, 0x7a, 0xe0, 0xf3, 0x62, 0xd2, 0xa8,
0x5f, 0x14, 0x27, 0x12, 0x44, 0x69, 0x73, 0x25, 0x40, 0xc1, 0x79, 0x84, 0x4d, 0x2b, 0xee, 0xe9,
0x0d, 0x2d, 0x22, 0x32, 0x5d, 0xa8, 0x8a, 0x5a, 0x0d, 0x3b, 0x95, 0x10, 0x6d, 0xf5, 0xf7, 0x15,
0xb8, 0xbc, 0x85, 0xfd, 0x47, 0xf1, 0x32, 0xcf, 0xab, 0xe6, 0xab, 0x45, 0xd9, 0x9a, 0x5a, 0xd4,
0xcb, 0x22, 0xc2, 0x6f, 0x28, 0xd0, 0xe1, 0xb3, 0xd0, 0x39, 0x49, 0x36, 0x33, 0xc2, 0x3e, 0x36,
0x7e, 0xde, 0x25, 0x8b, 0xff, 0x56, 0xa0, 0x1d, 0xf5, 0xa4, 0xd4, 0x19, 0x7e, 0x04, 0x65, 0x5a,
0x19, 0xe2, 0x2b, 0x98, 0xa9, 0xee, 0x0c, 0x9b, 0x98, 0x62, 0x1a, 0x3e, 0x1f, 0x08, 0xa7, 0xcf,
0x9b, 0xa1, 0x3b, 0x2f, 0x9e, 0xdf, 0x9d, 0xf3, 0xf0, 0xc6, 0x99, 0x90, 0x71, 0x59, 0x49, 0x35,
0x04, 0x44, 0xea, 0x29, 0xe5, 0x39, 0xea, 0x29, 0xea, 0x2f, 0xc3, 0x6a, 0x98, 0x48, 0xb2, 0x69,
0xe7, 0x15, 0x44, 0xf5, 0xdf, 0x14, 0xb8, 0xb8, 0x7f, 0x66, 0x0f, 0x92, 0x22, 0xbd, 0x0a, 0x95,
0xf1, 0x48, 0x0f, 0x2b, 0xbc, 0xbc, 0x45, 0x43, 0x3b, 0x36, 0x37, 0x36, 0x88, 0x5f, 0x60, 0x34,
0xab, 0x0b, 0xd8, 0x81, 0x33, 0xd3, 0x5d, 0xdf, 0x14, 0x99, 0x2f, 0x36, 0x98, 0x07, 0x62, 0x65,
0xb3, 0xa6, 0x80, 0x52, 0x0f, 0xf4, 0x09, 0x00, 0x75, 0xd2, 0xfd, 0xf3, 0x38, 0x66, 0xda, 0x63,
0x9b, 0x98, 0xe1, 0x9f, 0x14, 0xa0, 0x13, 0xa1, 0xd2, 0xcf, 0x3b, 0x66, 0xc9, 0xc8, 0xb4, 0x8a,
0x2f, 0x28, 0xd3, 0x2a, 0x2d, 0x1e, 0xa7, 0x94, 0x65, 0x71, 0xca, 0xdf, 0x15, 0xa0, 0x15, 0x52,
0x6d, 0x6f, 0xa4, 0xdb, 0x99, 0x92, 0xb0, 0x2f, 0x62, 0xf4, 0x38, 0x9d, 0xde, 0x95, 0xe9, 0x49,
0x06, 0x23, 0xb4, 0xc4, 0x10, 0xe8, 0x2a, 0x65, 0xba, 0xeb, 0xb3, 0x9a, 0x15, 0xcf, 0x0b, 0x98,
0x42, 0x9a, 0x16, 0x46, 0x77, 0x01, 0x71, 0x2d, 0xea, 0x9b, 0x76, 0xdf, 0xc3, 0x03, 0xc7, 0x36,
0x98, 0x7e, 0x95, 0xb5, 0x36, 0xff, 0xd2, 0xb3, 0xf7, 0x19, 0x1c, 0x7d, 0x04, 0x25, 0xff, 0x6c,
0xcc, 0x22, 0x90, 0x96, 0xd4, 0x87, 0x87, 0xeb, 0x3a, 0x38, 0x1b, 0x63, 0x8d, 0xa2, 0x07, 0x37,
0x8b, 0x7c, 0x57, 0x3f, 0xe1, 0xe1, 0x5c, 0x49, 0x8b, 0x40, 0x88, 0xc5, 0x08, 0x68, 0xb8, 0xc4,
0xc2, 0x1e, 0xde, 0x54, 0xff, 0xa6, 0x00, 0xed, 0x70, 0x48, 0x0d, 0x7b, 0x93, 0x51, 0xb6, 0x26,
0x4d, 0x2f, 0x64, 0xcc, 0x52, 0xa2, 0x6f, 0x40, 0x9d, 0xf3, 0xf3, 0x1c, 0xf2, 0x00, 0xac, 0xcb,
0xf6, 0x14, 0x01, 0x2d, 0xbf, 0x20, 0x01, 0xad, 0x9c, 0x53, 0x40, 0xd5, 0x1f, 0x2b, 0xf0, 0x5a,
0xca, 0xaa, 0x4d, 0x25, 0xe0, 0xf4, 0x74, 0x8b, 0x5b, 0xbb, 0xe4, 0x90, 0xdc, 0x3e, 0x3f, 0x80,
0x8a, 0x4b, 0x47, 0xe7, 0x27, 0x4f, 0x6f, 0x4e, 0x15, 0x0e, 0xb6, 0x10, 0x8d, 0x77, 0x51, 0x7f,
0x4f, 0x81, 0xb5, 0xf4, 0x52, 0x17, 0x70, 0xba, 0x1b, 0xb0, 0xc4, 0x86, 0x0e, 0x74, 0xe8, 0xf6,
0x74, 0x1d, 0x0a, 0x89, 0xa3, 0x05, 0x1d, 0xd5, 0x7d, 0x58, 0x0d, 0x7c, 0x73, 0x48, 0xe0, 0x1d,
0xec, 0xeb, 0x53, 0x92, 0x8d, 0xeb, 0x50, 0x67, 0x51, 0x2b, 0x0b, 0xe2, 0x59, 0x9a, 0x0e, 0x4f,
0x45, 0x75, 0x4b, 0xfd, 0x4f, 0x05, 0x2e, 0x51, 0xe7, 0x96, 0x3c, 0xea, 0xc9, 0x73, 0x0c, 0xa8,
0x8a, 0x2a, 0x00, 0xc9, 0xf8, 0xd9, 0xd6, 0x6a, 0x5a, 0x0c, 0x26, 0x2b, 0xfd, 0x17, 0xe7, 0x2b,
0xfd, 0x47, 0x9c, 0x6a, 0x69, 0x1e, 0xa7, 0xba, 0x0d, 0xaf, 0x25, 0x76, 0xba, 0x00, 0x47, 0xd5,
0x3f, 0x53, 0x08, 0x3b, 0x62, 0xd7, 0x77, 0xe6, 0x0f, 0x16, 0xaf, 0x8a, 0x33, 0xa6, 0xbe, 0x69,
0x24, 0x4d, 0x85, 0x81, 0x3e, 0x85, 0x9a, 0x8d, 0x4f, 0xfb, 0xd1, 0x58, 0x25, 0x47, 0x24, 0x5d,
0xb5, 0xf1, 0x29, 0xfd, 0xa5, 0xee, 0xc2, 0x5a, 0x6a, 0xa9, 0x8b, 0xec, 0xfd, 0x6f, 0x15, 0xb8,
0xbc, 0xe9, 0x3a, 0xe3, 0x2f, 0x4d, 0xd7, 0x9f, 0xe8, 0xa3, 0xf8, 0x89, 0xfc, 0xcb, 0xa9, 0x26,
0x7d, 0x11, 0x89, 0x5a, 0x99, 0xfc, 0xdc, 0x95, 0x68, 0x50, 0x7a, 0x51, 0x7c, 0xd3, 0x91, 0x18,
0xf7, 0x3f, 0x8a, 0xb2, 0xc5, 0x73, 0xbc, 0x19, 0x71, 0x43, 0x9e, 0xa0, 0x5e, 0x5a, 0x7c, 0x2e,
0xce, 0x5b, 0x7c, 0xce, 0x30, 0xe2, 0xa5, 0x17, 0x64, 0xc4, 0xcf, 0x5d, 0x0d, 0xf9, 0x02, 0xe2,
0x07, 0x03, 0xd4, 0x7b, 0xce, 0x75, 0xa2, 0xb0, 0x01, 0x10, 0x16, 0xc9, 0xf9, 0xed, 0xcb, 0x3c,
0xc3, 0x44, 0x7a, 0x11, 0x6e, 0x09, 0x87, 0x49, 0xcf, 0xbf, 0x62, 0x65, 0xdb, 0x6f, 0x41, 0x57,
0x26, 0xa5, 0x8b, 0x48, 0xfe, 0x4f, 0x0a, 0x00, 0x3d, 0x71, 0x61, 0x77, 0x3e, 0x5f, 0xf0, 0x26,
0x34, 0x43, 0x81, 0x09, 0xf5, 0x3d, 0x2a, 0x45, 0x06, 0x51, 0x09, 0x91, 0x07, 0x12, 0x9c, 0x54,
0x6e, 0x68, 0xd0, 0x71, 0x22, 0x5a, 0xc3, 0x84, 0x22, 0x69, 0x7e, 0x5f, 0x87, 0x9a, 0xeb, 0x9c,
0xf6, 0x89, 0x9a, 0x19, 0xc1, 0x8d, 0x64, 0xd7, 0x39, 0x25, 0xca, 0x67, 0xa0, 0x35, 0x58, 0xf2,
0x75, 0xef, 0x98, 0x8c, 0x5f, 0x89, 0x5c, 0x0a, 0x31, 0xd0, 0x25, 0x28, 0x1f, 0x9a, 0x23, 0xcc,
0xee, 0x20, 0xd4, 0x34, 0xd6, 0x40, 0x5f, 0x0b, 0xae, 0xce, 0x55, 0x73, 0x5f, 0xfc, 0x61, 0xb7,
0xe7, 0x7e, 0xaa, 0xc0, 0x72, 0x48, 0x35, 0x6a, 0x80, 0x88, 0x4d, 0xa3, 0xf6, 0xec, 0xa1, 0x63,
0x30, 0x53, 0xd1, 0xca, 0xf0, 0x08, 0xac, 0x23, 0xb3, 0x5a, 0x61, 0x97, 0x69, 0x69, 0x2c, 0xd9,
0x17, 0xd9, 0xb4, 0x69, 0x04, 0x67, 0xd1, 0x15, 0xd7, 0x39, 0xed, 0x19, 0x82, 0x1a, 0xec, 0xba,
0x31, 0x4b, 0xda, 0x08, 0x35, 0x1e, 0xd2, 0x1b, 0xc7, 0x6f, 0x42, 0x13, 0xbb, 0xae, 0xe3, 0xf6,
0x2d, 0xec, 0x79, 0xfa, 0x10, 0xf3, 0xf8, 0xb9, 0x41, 0x81, 0x3b, 0x0c, 0xa6, 0xfe, 0x43, 0x11,
0x5a, 0xe1, 0x56, 0x82, 0x13, 0x68, 0xd3, 0x08, 0x4e, 0xa0, 0x4d, 0xc2, 0x3a, 0x70, 0x99, 0x29,
0x14, 0xcc, 0xdd, 0x28, 0x74, 0x14, 0xad, 0xc6, 0xa1, 0x3d, 0x83, 0xb8, 0x65, 0xa2, 0x64, 0xb6,
0x63, 0xe0, 0x90, 0xb9, 0x10, 0x80, 0x38, 0x6f, 0x63, 0x32, 0x52, 0xca, 0x21, 0x23, 0xe5, 0x1c,
0x32, 0x52, 0x91, 0xc8, 0xc8, 0x2a, 0x54, 0x9e, 0x4e, 0x06, 0xc7, 0xd8, 0xe7, 0xd1, 0x2e, 0x6f,
0xc5, 0x65, 0xa7, 0x9a, 0x90, 0x1d, 0x21, 0x22, 0xb5, 0xa8, 0x88, 0xbc, 0x0e, 0x35, 0x76, 0x14,
0xda, 0xf7, 0x3d, 0x7a, 0xe0, 0x53, 0xd4, 0xaa, 0x0c, 0x70, 0xe0, 0xa1, 0x8f, 0x83, 0x70, 0xae,
0x2e, 0x53, 0x76, 0x6a, 0x75, 0x12, 0x52, 0x12, 0x04, 0x73, 0x6f, 0xc3, 0x72, 0x84, 0x1c, 0xd4,
0x47, 0x34, 0xe8, 0x52, 0x5b, 0x21, 0x98, 0xba, 0x89, 0x9b, 0xd0, 0x0a, 0x49, 0x42, 0xf1, 0x9a,
0x2c, 0x09, 0x12, 0x50, 0x82, 0xa6, 0x7e, 0x17, 0x50, 0x38, 0xd3, 0x62, 0x91, 0x5d, 0x82, 0x95,
0x85, 0x24, 0x2b, 0xd5, 0x3f, 0x57, 0x60, 0x25, 0x3a, 0xd9, 0xbc, 0x4e, 0xf2, 0x53, 0xa8, 0xb3,
0xe3, 0xb1, 0x3e, 0x51, 0x52, 0x5e, 0x50, 0xb9, 0x3a, 0x95, 0x86, 0x1a, 0x84, 0x8f, 0x0b, 0x88,
0x28, 0x9c, 0x3a, 0xee, 0xb1, 0x69, 0x0f, 0xfb, 0x64, 0x65, 0x81, 0x6a, 0x34, 0x38, 0x70, 0x97,
0xc0, 0xd4, 0x1f, 0x2a, 0x70, 0xed, 0xf1, 0xd8, 0xd0, 0x7d, 0x1c, 0x89, 0x16, 0x16, 0xbd, 0xaf,
0xf8, 0x51, 0x70, 0x61, 0xb0, 0x90, 0xef, 0x88, 0x87, 0x61, 0xab, 0x3b, 0x70, 0x59, 0xc3, 0x1e,
0xb6, 0x8d, 0xd8, 0xc7, 0xb9, 0xeb, 0x20, 0x63, 0xe8, 0xca, 0x86, 0x5b, 0x84, 0xf7, 0x2c, 0x6c,
0xeb, 0xbb, 0x64, 0x58, 0x9f, 0x5b, 0x21, 0x12, 0x2d, 0xd0, 0x79, 0x7c, 0xf5, 0x2f, 0x0a, 0xb0,
0xf6, 0x99, 0x61, 0x70, 0x03, 0xc6, 0x03, 0x91, 0x97, 0x15, 0x23, 0x26, 0x63, 0xa8, 0x62, 0x3a,
0x86, 0x7a, 0x51, 0x46, 0x85, 0x9b, 0x57, 0x7b, 0x62, 0x05, 0x6e, 0xc3, 0x65, 0xb7, 0x52, 0x1e,
0xf0, 0x63, 0x1a, 0x92, 0xb1, 0x52, 0xd7, 0x31, 0x3b, 0xb4, 0xa8, 0x06, 0xf5, 0x1c, 0x75, 0x0c,
0x9d, 0x34, 0xb1, 0x16, 0xd4, 0xcc, 0x80, 0x22, 0x63, 0x87, 0xd5, 0xfe, 0x1a, 0x24, 0x7a, 0xa0,
0xa0, 0x3d, 0xc7, 0x53, 0xff, 0xab, 0x00, 0x9d, 0x7d, 0xfd, 0x04, 0xff, 0xff, 0x61, 0xd0, 0xb7,
0xe1, 0x92, 0xa7, 0x9f, 0xe0, 0x7e, 0x24, 0x27, 0xec, 0xbb, 0xf8, 0x19, 0x8f, 0xbe, 0xde, 0x91,
0x29, 0xa6, 0xf4, 0x56, 0x87, 0xb6, 0xe2, 0xc5, 0xe0, 0x1a, 0x7e, 0x86, 0x6e, 0xc1, 0x72, 0xf4,
0x76, 0x10, 0x59, 0x5a, 0x95, 0x92, 0xbc, 0x19, 0xb9, 0xfc, 0xd3, 0x33, 0xd4, 0x67, 0x70, 0xe5,
0xb1, 0xed, 0x61, 0xbf, 0x17, 0x5e, 0x60, 0x59, 0x30, 0x7b, 0xba, 0x0e, 0xf5, 0x90, 0xf0, 0xa9,
0xf7, 0x06, 0x86, 0xa7, 0x3a, 0xd0, 0xdd, 0x09, 0x2f, 0xe3, 0x79, 0x9b, 0xec, 0x06, 0xc2, 0x4b,
0x9c, 0xf0, 0x50, 0x5c, 0xc8, 0xd1, 0xf0, 0x21, 0x76, 0xb1, 0x3d, 0xc0, 0xdb, 0xce, 0xe0, 0x38,
0x72, 0x09, 0x57, 0x89, 0x5e, 0xc2, 0x9d, 0xf7, 0x52, 0xef, 0x9d, 0xfb, 0xe2, 0x2e, 0xdc, 0xc1,
0xd9, 0x18, 0xa3, 0x25, 0x28, 0xee, 0xe2, 0xd3, 0xf6, 0x05, 0x04, 0x50, 0xd9, 0x75, 0x5c, 0x4b,
0x1f, 0xb5, 0x15, 0x54, 0x87, 0x25, 0x7e, 0x7e, 0xd0, 0x2e, 0xdc, 0xf9, 0x23, 0x05, 0x56, 0x52,
0x25, 0x6d, 0xd4, 0x02, 0x78, 0x6c, 0x0f, 0x78, 0xad, 0xbf, 0x7d, 0x01, 0x35, 0xa0, 0x1a, 0x54,
0xfe, 0xd9, 0x00, 0x07, 0x0e, 0xc5, 0x6e, 0x17, 0x50, 0x1b, 0x1a, 0xac, 0xe3, 0x64, 0x30, 0xc0,
0x9e, 0xd7, 0x2e, 0x0a, 0xc8, 0x23, 0xdd, 0x1c, 0x4d, 0x5c, 0xdc, 0x2e, 0xa1, 0x26, 0xd4, 0x0e,
0x1c, 0x7e, 0xe7, 0xb9, 0x5d, 0x46, 0x08, 0x5a, 0xc1, 0x05, 0x68, 0xde, 0xa9, 0x12, 0x81, 0x05,
0xdd, 0x96, 0xee, 0x3c, 0x89, 0x16, 0x26, 0xe9, 0x7e, 0xd6, 0xe0, 0xe2, 0x63, 0xdb, 0xc0, 0x87,
0xa6, 0x8d, 0x8d, 0xf0, 0x53, 0xfb, 0x02, 0xba, 0x08, 0xcb, 0x3b, 0xd8, 0x1d, 0xe2, 0x08, 0xb0,
0x80, 0x56, 0xa0, 0xb9, 0x63, 0x3e, 0x8f, 0x80, 0x8a, 0x6a, 0xa9, 0xaa, 0xb4, 0x95, 0xf5, 0x7f,
0xed, 0x42, 0x6d, 0x53, 0xf7, 0xf5, 0x87, 0x8e, 0xe3, 0x1a, 0x68, 0x0c, 0x88, 0x3e, 0x11, 0xb0,
0xc6, 0x8e, 0x2d, 0x1e, 0xde, 0xa0, 0xf7, 0x33, 0x32, 0x8f, 0x34, 0x2a, 0x17, 0x9b, 0xee, 0xad,
0x8c, 0x1e, 0x09, 0x74, 0xf5, 0x02, 0xb2, 0xe8, 0x8c, 0x07, 0xa6, 0x85, 0x0f, 0xcc, 0xc1, 0x71,
0x70, 0x77, 0x70, 0xca, 0x8c, 0x09, 0xd4, 0x60, 0xc6, 0x44, 0x09, 0x8b, 0x37, 0xd8, 0x3b, 0x8e,
0xc0, 0x54, 0xaa, 0x17, 0xd0, 0x33, 0xb8, 0xb4, 0x85, 0x23, 0x8e, 0x3b, 0x98, 0x70, 0x3d, 0x7b,
0xc2, 0x14, 0xf2, 0x39, 0xa7, 0xdc, 0x86, 0x32, 0x95, 0x31, 0x24, 0xf3, 0xed, 0xd1, 0x77, 0xb2,
0xdd, 0x1b, 0xd9, 0x08, 0x62, 0xb4, 0xef, 0xc2, 0x72, 0xe2, 0x75, 0x1d, 0x92, 0x99, 0x26, 0xf9,
0x3b, 0xc9, 0xee, 0x9d, 0x3c, 0xa8, 0x62, 0xae, 0x21, 0xb4, 0xe2, 0xcf, 0x0b, 0x90, 0xac, 0x32,
0x27, 0x7d, 0x18, 0xd5, 0x7d, 0x27, 0x07, 0xa6, 0x98, 0xc8, 0x82, 0x76, 0xf2, 0xb5, 0x17, 0xba,
0x33, 0x75, 0x80, 0xb8, 0xb8, 0xbd, 0x9b, 0x0b, 0x57, 0x4c, 0x77, 0x46, 0x85, 0x20, 0xf5, 0x80,
0x08, 0xdd, 0x93, 0x0f, 0x93, 0xf5, 0xb2, 0xa9, 0x7b, 0x3f, 0x37, 0xbe, 0x98, 0xfa, 0xd7, 0xd9,
0x49, 0xbf, 0xec, 0x11, 0x0e, 0xfa, 0x40, 0x3e, 0xdc, 0x94, 0xd7, 0x43, 0xdd, 0xf5, 0xf3, 0x74,
0x11, 0x8b, 0xf8, 0x3e, 0x3d, 0xa2, 0x97, 0x3c, 0x63, 0x49, 0xea, 0x5d, 0x30, 0x5e, 0xf6, 0x0b,
0x9d, 0xee, 0x07, 0xe7, 0xe8, 0x21, 0x16, 0xe0, 0x24, 0x9f, 0xd3, 0x05, 0x6a, 0x78, 0x7f, 0xa6,
0xd4, 0xcc, 0xa7, 0x83, 0xdf, 0x81, 0xe5, 0x84, 0xb3, 0x46, 0xf9, 0x1d, 0x7a, 0x77, 0x5a, 0x44,
0xc5, 0x54, 0x32, 0x71, 0xe3, 0x01, 0x65, 0x48, 0xbf, 0xe4, 0x56, 0x44, 0xf7, 0x4e, 0x1e, 0x54,
0xb1, 0x11, 0x8f, 0x9a, 0xcb, 0xc4, 0x99, 0x37, 0xba, 0x2b, 0x1f, 0x43, 0x7e, 0x5e, 0xdf, 0x7d,
0x2f, 0x27, 0xb6, 0x98, 0xf4, 0x04, 0x2e, 0x4a, 0xae, 0x1b, 0xa0, 0xf7, 0xa6, 0x32, 0x2b, 0x79,
0xcf, 0xa2, 0x7b, 0x2f, 0x2f, 0xba, 0x98, 0xf7, 0xd7, 0x00, 0xed, 0x1f, 0x39, 0xa7, 0x0f, 0x1d,
0xfb, 0xd0, 0x1c, 0x4e, 0x5c, 0x9d, 0x55, 0xba, 0xb3, 0x7c, 0x43, 0x1a, 0x35, 0x43, 0x46, 0xa7,
0xf6, 0x10, 0x93, 0xf7, 0x01, 0xb6, 0xb0, 0xbf, 0x83, 0x7d, 0x97, 0x28, 0xc6, 0x2d, 0xa9, 0x9c,
0x85, 0x08, 0xc1, 0x54, 0x6f, 0xcf, 0xc4, 0x8b, 0xb8, 0xa2, 0xf6, 0x8e, 0x6e, 0x4f, 0xf4, 0x51,
0xe4, 0x5a, 0xf4, 0x5d, 0x69, 0xf7, 0x24, 0x5a, 0x06, 0x23, 0x33, 0xb1, 0xc5, 0x94, 0xa7, 0xc2,
0xbd, 0x47, 0x8e, 0x52, 0x92, 0x66, 0x2f, 0x5c, 0xb3, 0xfc, 0x98, 0x3d, 0x69, 0xf6, 0xa6, 0xe0,
0x8b, 0x89, 0xbf, 0x52, 0xe8, 0x8d, 0x95, 0x04, 0xc2, 0x13, 0xd3, 0x3f, 0xda, 0x1b, 0xe9, 0xb6,
0x97, 0x67, 0x09, 0x14, 0xf1, 0x1c, 0x4b, 0xe0, 0xf8, 0x62, 0x09, 0x06, 0x34, 0x63, 0x27, 0x1c,
0x48, 0x76, 0xc1, 0x58, 0x76, 0xda, 0xd3, 0xbd, 0x3d, 0x1b, 0x51, 0xcc, 0x72, 0x04, 0xcd, 0x40,
0x95, 0x18, 0x71, 0xdf, 0xc9, 0x5a, 0x69, 0x88, 0x93, 0x61, 0x09, 0xe4, 0xa8, 0x51, 0x4b, 0x90,
0x2e, 0xe0, 0xa2, 0x7c, 0x85, 0xff, 0x69, 0x96, 0x20, 0xbb, 0x2a, 0xcc, 0x4c, 0x5d, 0xe2, 0xb0,
0x44, 0x6e, 0x47, 0xa5, 0x67, 0x3f, 0x52, 0x53, 0x97, 0x71, 0xf6, 0xa2, 0x5e, 0x40, 0x4f, 0xa0,
0xc2, 0xff, 0x1c, 0xe2, 0xad, 0xe9, 0x85, 0x1c, 0x3e, 0xfa, 0xcd, 0x19, 0x58, 0x62, 0xe0, 0x63,
0x58, 0xcb, 0x28, 0xe3, 0x48, 0x5d, 0xf0, 0xf4, 0x92, 0xcf, 0x2c, 0xe7, 0xa0, 0x03, 0x4a, 0xbf,
0xc0, 0x94, 0xb2, 0x29, 0xf3, 0xa1, 0x66, 0x8e, 0x29, 0xd2, 0x8f, 0x28, 0xa5, 0x53, 0x64, 0xbe,
0xb5, 0x9c, 0x35, 0x45, 0x1f, 0x56, 0x52, 0xc5, 0x00, 0xf4, 0x6e, 0x86, 0x07, 0x95, 0x95, 0x0c,
0x66, 0x4d, 0x30, 0x84, 0xd7, 0xa4, 0x89, 0xaf, 0x34, 0x22, 0x98, 0x96, 0x22, 0xcf, 0x9a, 0x68,
0x00, 0x17, 0x25, 0xe9, 0xae, 0xd4, 0x97, 0x65, 0xa7, 0xc5, 0x33, 0x26, 0x59, 0xff, 0xe7, 0x1a,
0x54, 0x83, 0xab, 0xca, 0xaf, 0x20, 0xa7, 0x7a, 0x05, 0x49, 0xce, 0x77, 0x60, 0x39, 0xf1, 0x2c,
0x52, 0x6a, 0x18, 0xe4, 0x4f, 0x27, 0x67, 0xf1, 0xec, 0x09, 0xff, 0xd3, 0x1e, 0x11, 0xef, 0xbc,
0x9d, 0x95, 0x28, 0x25, 0x43, 0x9d, 0x19, 0x03, 0xff, 0xdf, 0x0e, 0x30, 0x76, 0x01, 0x22, 0xa1,
0xc5, 0xf4, 0x0b, 0x40, 0xc4, 0x5b, 0xce, 0xa2, 0x96, 0x25, 0x8d, 0x1e, 0xde, 0xc9, 0x73, 0x59,
0x23, 0xdb, 0xfe, 0x67, 0xc7, 0x0c, 0x8f, 0xa1, 0x11, 0xbd, 0x9a, 0x87, 0xa4, 0x7f, 0x11, 0x93,
0xbe, 0xbb, 0x37, 0x6b, 0x17, 0x3b, 0xe7, 0x74, 0x2b, 0x33, 0x86, 0xf3, 0x88, 0xf1, 0x4d, 0x56,
0xce, 0x33, 0x8c, 0x6f, 0x46, 0xbd, 0x5e, 0xea, 0x86, 0xb3, 0xcb, 0xf1, 0x2c, 0x5f, 0x4e, 0x96,
0x83, 0xa5, 0xf9, 0x72, 0x46, 0x81, 0x5d, 0x9a, 0x2f, 0x67, 0xd5, 0x97, 0xd5, 0x0b, 0x1b, 0x1f,
0x7e, 0xfb, 0x83, 0xa1, 0xe9, 0x1f, 0x4d, 0x9e, 0x92, 0xdd, 0xdf, 0x67, 0x5d, 0xdf, 0x33, 0x1d,
0xfe, 0xeb, 0x7e, 0x20, 0xee, 0xf7, 0xe9, 0x68, 0xf7, 0xc9, 0x68, 0xe3, 0xa7, 0x4f, 0x2b, 0xb4,
0xf5, 0xe1, 0xff, 0x04, 0x00, 0x00, 0xff, 0xff, 0x9b, 0x8d, 0x7b, 0x9b, 0x76, 0x4c, 0x00, 0x00,
// 4239 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x3c, 0x5b, 0x8f, 0x1c, 0x57,
0x5a, 0xae, 0xbe, 0x4d, 0xf7, 0xd7, 0x97, 0xe9, 0x39, 0x76, 0xc6, 0xed, 0xf6, 0x35, 0xe5, 0x38,
0x71, 0x1c, 0xc7, 0x4e, 0x26, 0x44, 0x1b, 0xf0, 0x26, 0xab, 0x8c, 0x27, 0x9e, 0x34, 0xcc, 0xcc,
0xce, 0xd6, 0x8c, 0x63, 0x69, 0x17, 0xa9, 0x55, 0xee, 0x3a, 0xd3, 0x53, 0x3b, 0x5d, 0x55, 0xed,
0xaa, 0xea, 0x19, 0xcf, 0xf2, 0xb0, 0x11, 0x2b, 0x21, 0x2d, 0x42, 0x2c, 0x17, 0x21, 0xc1, 0x03,
0x12, 0xe2, 0x69, 0x01, 0x21, 0x21, 0xad, 0x78, 0x00, 0x1e, 0x78, 0xe0, 0x25, 0x02, 0x89, 0x15,
0x2f, 0xfc, 0x04, 0xe0, 0x9d, 0x57, 0x1e, 0xd0, 0xb9, 0xd4, 0xa9, 0xdb, 0xa9, 0xee, 0x9a, 0x6e,
0x3b, 0x46, 0xec, 0x5b, 0x9f, 0xaf, 0xbe, 0x73, 0xfb, 0xee, 0xdf, 0x77, 0xce, 0x69, 0x68, 0x1b,
0xba, 0xaf, 0xf7, 0x07, 0x8e, 0xe3, 0x1a, 0xf7, 0xc6, 0xae, 0xe3, 0x3b, 0x68, 0xc5, 0x32, 0x47,
0xc7, 0x13, 0x8f, 0xb5, 0xee, 0x91, 0xcf, 0xdd, 0xc6, 0xc0, 0xb1, 0x2c, 0xc7, 0x66, 0xa0, 0x6e,
0xcb, 0xb4, 0x7d, 0xec, 0xda, 0xfa, 0x88, 0xb7, 0x1b, 0xd1, 0x0e, 0xdd, 0x86, 0x37, 0x38, 0xc4,
0x96, 0xce, 0x5a, 0xea, 0x12, 0x94, 0x3f, 0xb3, 0xc6, 0xfe, 0xa9, 0xfa, 0xc7, 0x0a, 0x34, 0x1e,
0x8d, 0x26, 0xde, 0xa1, 0x86, 0x9f, 0x4d, 0xb0, 0xe7, 0xa3, 0xf7, 0xa0, 0xf4, 0x54, 0xf7, 0x70,
0x47, 0xb9, 0xa1, 0xdc, 0xae, 0xaf, 0x5d, 0xb9, 0x17, 0x9b, 0x95, 0xcf, 0xb7, 0xed, 0x0d, 0xd7,
0x75, 0x0f, 0x6b, 0x14, 0x13, 0x21, 0x28, 0x19, 0x4f, 0x7b, 0x1b, 0x9d, 0xc2, 0x0d, 0xe5, 0x76,
0x51, 0xa3, 0xbf, 0xd1, 0x35, 0x00, 0x0f, 0x0f, 0x2d, 0x6c, 0xfb, 0xbd, 0x0d, 0xaf, 0x53, 0xbc,
0x51, 0xbc, 0x5d, 0xd4, 0x22, 0x10, 0xa4, 0x42, 0x63, 0xe0, 0x8c, 0x46, 0x78, 0xe0, 0x9b, 0x8e,
0xdd, 0xdb, 0xe8, 0x94, 0x68, 0xdf, 0x18, 0x4c, 0xfd, 0x0f, 0x05, 0x9a, 0x7c, 0x69, 0xde, 0xd8,
0xb1, 0x3d, 0x8c, 0x3e, 0x80, 0x8a, 0xe7, 0xeb, 0xfe, 0xc4, 0xe3, 0xab, 0xbb, 0x2c, 0x5d, 0xdd,
0x1e, 0x45, 0xd1, 0x38, 0xaa, 0x74, 0x79, 0xc9, 0xe9, 0x8b, 0xe9, 0xe9, 0x13, 0x5b, 0x28, 0xa5,
0xb6, 0x70, 0x1b, 0x96, 0x0f, 0xc8, 0xea, 0xf6, 0x42, 0xa4, 0x32, 0x45, 0x4a, 0x82, 0xc9, 0x48,
0xbe, 0x69, 0xe1, 0x6f, 0x1f, 0xec, 0x61, 0x7d, 0xd4, 0xa9, 0xd0, 0xb9, 0x22, 0x10, 0xf5, 0xdf,
0x14, 0x68, 0x0b, 0xf4, 0x80, 0x0f, 0x17, 0xa0, 0x3c, 0x70, 0x26, 0xb6, 0x4f, 0xb7, 0xda, 0xd4,
0x58, 0x03, 0xbd, 0x0e, 0x8d, 0xc1, 0xa1, 0x6e, 0xdb, 0x78, 0xd4, 0xb7, 0x75, 0x0b, 0xd3, 0x4d,
0xd5, 0xb4, 0x3a, 0x87, 0xed, 0xe8, 0x16, 0xce, 0xb5, 0xb7, 0x1b, 0x50, 0x1f, 0xeb, 0xae, 0x6f,
0xc6, 0xa8, 0x1f, 0x05, 0xa1, 0x2e, 0x54, 0x4d, 0xaf, 0x67, 0x8d, 0x1d, 0xd7, 0xef, 0x94, 0x6f,
0x28, 0xb7, 0xab, 0x9a, 0x68, 0x93, 0x19, 0x4c, 0xfa, 0x6b, 0x5f, 0xf7, 0x8e, 0x7a, 0x1b, 0x7c,
0x47, 0x31, 0x98, 0xfa, 0x67, 0x0a, 0xac, 0x7e, 0xea, 0x79, 0xe6, 0xd0, 0x4e, 0xed, 0x6c, 0x15,
0x2a, 0xb6, 0x63, 0xe0, 0xde, 0x06, 0xdd, 0x5a, 0x51, 0xe3, 0x2d, 0x74, 0x19, 0x6a, 0x63, 0x8c,
0xdd, 0xbe, 0xeb, 0x8c, 0x82, 0x8d, 0x55, 0x09, 0x40, 0x73, 0x46, 0x18, 0x7d, 0x07, 0x56, 0xbc,
0xc4, 0x40, 0x4c, 0xae, 0xea, 0x6b, 0x37, 0xef, 0xa5, 0x34, 0xe3, 0x5e, 0x72, 0x52, 0x2d, 0xdd,
0x5b, 0xfd, 0xb2, 0x00, 0xe7, 0x05, 0x1e, 0x5b, 0x2b, 0xf9, 0x4d, 0x28, 0xef, 0xe1, 0xa1, 0x58,
0x1e, 0x6b, 0xe4, 0xa1, 0xbc, 0x60, 0x59, 0x31, 0xca, 0xb2, 0x1c, 0xa2, 0x9e, 0xe4, 0x47, 0x39,
0xcd, 0x8f, 0xeb, 0x50, 0xc7, 0xcf, 0xc7, 0xa6, 0x8b, 0xfb, 0x44, 0x70, 0x28, 0xc9, 0x4b, 0x1a,
0x30, 0xd0, 0xbe, 0x69, 0x45, 0x75, 0x63, 0x29, 0xb7, 0x6e, 0xa8, 0x7f, 0xae, 0xc0, 0xc5, 0x14,
0x97, 0xb8, 0xb2, 0x69, 0xd0, 0xa6, 0x3b, 0x0f, 0x29, 0x43, 0xd4, 0x8e, 0x10, 0xfc, 0xcd, 0x69,
0x04, 0x0f, 0xd1, 0xb5, 0x54, 0xff, 0xc8, 0x22, 0x0b, 0xf9, 0x17, 0x79, 0x04, 0x17, 0x37, 0xb1,
0xcf, 0x27, 0x20, 0xdf, 0xb0, 0x37, 0xbf, 0xb1, 0x8a, 0x6b, 0x75, 0x21, 0xa9, 0xd5, 0xea, 0xdf,
0x14, 0x84, 0x2e, 0xd2, 0xa9, 0x7a, 0xf6, 0x81, 0x83, 0xae, 0x40, 0x4d, 0xa0, 0x70, 0xa9, 0x08,
0x01, 0xe8, 0x1b, 0x50, 0x26, 0x2b, 0x65, 0x22, 0xd1, 0x5a, 0x7b, 0x5d, 0xbe, 0xa7, 0xc8, 0x98,
0x1a, 0xc3, 0x47, 0x3d, 0x68, 0x79, 0xbe, 0xee, 0xfa, 0xfd, 0xb1, 0xe3, 0x51, 0x3e, 0x53, 0xc1,
0xa9, 0xaf, 0xa9, 0xf1, 0x11, 0x84, 0x59, 0xdf, 0xf6, 0x86, 0xbb, 0x1c, 0x53, 0x6b, 0xd2, 0x9e,
0x41, 0x13, 0x7d, 0x06, 0x0d, 0x6c, 0x1b, 0xe1, 0x40, 0xa5, 0xdc, 0x03, 0xd5, 0xb1, 0x6d, 0x88,
0x61, 0x42, 0xfe, 0x94, 0xf3, 0xf3, 0xe7, 0x77, 0x14, 0xe8, 0xa4, 0x19, 0xb4, 0x88, 0xc9, 0x7e,
0xc0, 0x3a, 0x61, 0xc6, 0xa0, 0xa9, 0x1a, 0x2e, 0x98, 0xa4, 0xf1, 0x2e, 0xea, 0x1f, 0x29, 0xf0,
0x5a, 0xb8, 0x1c, 0xfa, 0xe9, 0x65, 0x49, 0x0b, 0xba, 0x03, 0x6d, 0xd3, 0x1e, 0x8c, 0x26, 0x06,
0x7e, 0x6c, 0x7f, 0x8e, 0xf5, 0x91, 0x7f, 0x78, 0x4a, 0x79, 0x58, 0xd5, 0x52, 0x70, 0xf5, 0x47,
0x0a, 0xac, 0x26, 0xd7, 0xb5, 0x08, 0x91, 0x7e, 0x09, 0xca, 0xa6, 0x7d, 0xe0, 0x04, 0x34, 0xba,
0x36, 0x45, 0x29, 0xc9, 0x5c, 0x0c, 0x59, 0xb5, 0xe0, 0xf2, 0x26, 0xf6, 0x7b, 0xb6, 0x87, 0x5d,
0x7f, 0xdd, 0xb4, 0x47, 0xce, 0x70, 0x57, 0xf7, 0x0f, 0x17, 0x50, 0xa8, 0x98, 0x6e, 0x14, 0x12,
0xba, 0xa1, 0xfe, 0x54, 0x81, 0x2b, 0xf2, 0xf9, 0xf8, 0xd6, 0xbb, 0x50, 0x3d, 0x30, 0xf1, 0xc8,
0x20, 0xf4, 0x55, 0x28, 0x7d, 0x45, 0x9b, 0x28, 0xd6, 0x98, 0x20, 0xf3, 0x1d, 0xbe, 0x9e, 0x21,
0xcd, 0x7b, 0xbe, 0x6b, 0xda, 0xc3, 0x2d, 0xd3, 0xf3, 0x35, 0x86, 0x1f, 0xa1, 0x67, 0x31, 0xbf,
0x18, 0xff, 0xb6, 0x02, 0xd7, 0x36, 0xb1, 0xff, 0x50, 0xd8, 0x65, 0xf2, 0xdd, 0xf4, 0x7c, 0x73,
0xe0, 0xbd, 0xd8, 0xd8, 0x28, 0x87, 0x83, 0x56, 0x7f, 0xa2, 0xc0, 0xf5, 0xcc, 0xc5, 0x70, 0xd2,
0x71, 0xbb, 0x13, 0x58, 0x65, 0xb9, 0xdd, 0xf9, 0x35, 0x7c, 0xfa, 0x85, 0x3e, 0x9a, 0xe0, 0x5d,
0xdd, 0x74, 0x99, 0xdd, 0x99, 0xd3, 0x0a, 0xff, 0xb5, 0x02, 0x57, 0x37, 0xb1, 0xbf, 0x1b, 0xf8,
0xa4, 0x57, 0x48, 0x1d, 0x82, 0x13, 0xf1, 0x8d, 0x41, 0x70, 0x16, 0x83, 0xa9, 0xbf, 0xcb, 0xd8,
0x29, 0x5d, 0xef, 0x2b, 0x21, 0xe0, 0x35, 0xaa, 0x09, 0x11, 0x95, 0x7c, 0xc8, 0x42, 0x07, 0x4e,
0x3e, 0xf5, 0x4f, 0x15, 0xb8, 0xf4, 0xe9, 0xe0, 0xd9, 0xc4, 0x74, 0x31, 0x47, 0xda, 0x72, 0x06,
0x47, 0xf3, 0x13, 0x37, 0x0c, 0xb3, 0x0a, 0xb1, 0x30, 0x6b, 0x56, 0x68, 0xbe, 0x0a, 0x15, 0x9f,
0xc5, 0x75, 0x2c, 0x52, 0xe1, 0x2d, 0xba, 0x3e, 0x0d, 0x8f, 0xb0, 0xee, 0xfd, 0xdf, 0x5c, 0xdf,
0x4f, 0x4a, 0xd0, 0xf8, 0x82, 0x87, 0x63, 0xd4, 0x6b, 0x27, 0x25, 0x49, 0x91, 0x07, 0x5e, 0x91,
0x08, 0x4e, 0x16, 0xd4, 0x6d, 0x42, 0xd3, 0xc3, 0xf8, 0x68, 0x1e, 0x1f, 0xdd, 0x20, 0x1d, 0x85,
0x6f, 0xdd, 0x82, 0x95, 0x89, 0x4d, 0x53, 0x03, 0x6c, 0x70, 0x02, 0x32, 0xc9, 0x9d, 0x6d, 0xbb,
0xd3, 0x1d, 0xd1, 0xe7, 0x3c, 0xfb, 0x88, 0x8c, 0x55, 0xce, 0x35, 0x56, 0xb2, 0x1b, 0xea, 0x41,
0xdb, 0x70, 0x9d, 0xf1, 0x18, 0x1b, 0x7d, 0x2f, 0x18, 0xaa, 0x92, 0x6f, 0x28, 0xde, 0x4f, 0x0c,
0xf5, 0x1e, 0x9c, 0x4f, 0xae, 0xb4, 0x67, 0x90, 0x80, 0x94, 0xf0, 0x50, 0xf6, 0x09, 0xdd, 0x85,
0x95, 0x34, 0x7e, 0x95, 0xe2, 0xa7, 0x3f, 0xa0, 0x77, 0x01, 0x25, 0x96, 0x4a, 0xd0, 0x6b, 0x0c,
0x3d, 0xbe, 0x98, 0x9e, 0xe1, 0xa9, 0x3f, 0x56, 0x60, 0xf5, 0x89, 0xee, 0x0f, 0x0e, 0x37, 0x2c,
0xae, 0x6b, 0x0b, 0xd8, 0xaa, 0x8f, 0xa1, 0x76, 0xcc, 0xe5, 0x22, 0x70, 0x48, 0xd7, 0x25, 0xf4,
0x89, 0x4a, 0xa0, 0x16, 0xf6, 0x50, 0xbf, 0x52, 0xe0, 0xc2, 0xa3, 0x48, 0x5e, 0xf8, 0x0a, 0xac,
0xe6, 0xac, 0x84, 0xf6, 0x4d, 0x68, 0x59, 0xba, 0x7b, 0x94, 0xca, 0x67, 0x13, 0x50, 0xf5, 0x39,
0x00, 0x6f, 0x6d, 0x7b, 0xc3, 0x39, 0xd6, 0xff, 0x11, 0x2c, 0xf1, 0x59, 0xb9, 0xf9, 0x9c, 0x25,
0x67, 0x01, 0xba, 0xfa, 0xcf, 0x0a, 0xb4, 0x42, 0x97, 0x48, 0x95, 0xbc, 0x05, 0x05, 0xa1, 0xda,
0x85, 0xde, 0x06, 0xfa, 0x18, 0x2a, 0xac, 0xd0, 0xc1, 0xc7, 0xbe, 0x15, 0x1f, 0x9b, 0x17, 0x41,
0x22, 0x7e, 0x95, 0x02, 0x34, 0xde, 0x89, 0xd0, 0x48, 0x78, 0x11, 0x61, 0x7c, 0x42, 0x08, 0xea,
0xc1, 0x72, 0x3c, 0x64, 0x0f, 0x54, 0xf8, 0x46, 0x96, 0xf3, 0xd8, 0xd0, 0x7d, 0x9d, 0xfa, 0x8e,
0x56, 0x2c, 0x62, 0xf7, 0xd4, 0xdf, 0xaf, 0x40, 0x3d, 0xb2, 0xcb, 0xd4, 0x4e, 0x92, 0x2c, 0x2d,
0xcc, 0xce, 0x1b, 0x8b, 0xe9, 0xbc, 0xf1, 0x16, 0xb4, 0x4c, 0x1a, 0x7c, 0xf5, 0xb9, 0x28, 0x52,
0xab, 0x59, 0xd3, 0x9a, 0x0c, 0xca, 0xf5, 0x02, 0x5d, 0x83, 0xba, 0x3d, 0xb1, 0xfa, 0xce, 0x41,
0xdf, 0x75, 0x4e, 0x3c, 0x9e, 0x80, 0xd6, 0xec, 0x89, 0xf5, 0xed, 0x03, 0xcd, 0x39, 0xf1, 0xc2,
0x1c, 0xa7, 0x72, 0xc6, 0x1c, 0xe7, 0x1a, 0xd4, 0x2d, 0xfd, 0x39, 0x19, 0xb5, 0x6f, 0x4f, 0x2c,
0x9a, 0x9b, 0x16, 0xb5, 0x9a, 0xa5, 0x3f, 0xd7, 0x9c, 0x93, 0x9d, 0x89, 0x85, 0x6e, 0x43, 0x7b,
0xa4, 0x7b, 0x7e, 0x3f, 0x9a, 0xdc, 0x56, 0x69, 0x72, 0xdb, 0x22, 0xf0, 0xcf, 0xc2, 0x04, 0x37,
0x9d, 0x2d, 0xd5, 0x16, 0xc8, 0x96, 0x0c, 0x6b, 0x14, 0x0e, 0x04, 0xf9, 0xb3, 0x25, 0xc3, 0x1a,
0x89, 0x61, 0x3e, 0x82, 0xa5, 0xa7, 0x34, 0xa4, 0xf5, 0x3a, 0xf5, 0x4c, 0x83, 0xf9, 0x88, 0x44,
0xb3, 0x2c, 0xf2, 0xd5, 0x02, 0x74, 0xf4, 0x4d, 0xa8, 0xd1, 0x48, 0x82, 0xf6, 0x6d, 0xe4, 0xea,
0x1b, 0x76, 0x20, 0xbd, 0x0d, 0x3c, 0xf2, 0x75, 0xda, 0xbb, 0x99, 0xaf, 0xb7, 0xe8, 0x40, 0x8c,
0xf4, 0xc0, 0xc5, 0xba, 0x8f, 0x8d, 0xf5, 0xd3, 0x87, 0x8e, 0x35, 0xd6, 0xa9, 0x30, 0x75, 0x5a,
0x34, 0x6d, 0x91, 0x7d, 0x22, 0x86, 0x61, 0x20, 0x5a, 0x8f, 0x5c, 0xc7, 0xea, 0x2c, 0x33, 0xc3,
0x10, 0x87, 0xa2, 0xab, 0x00, 0x81, 0x79, 0xd6, 0xfd, 0x4e, 0x9b, 0x72, 0xb1, 0xc6, 0x21, 0x9f,
0xd2, 0xda, 0x95, 0xe9, 0xf5, 0x59, 0x95, 0xc8, 0xb4, 0x87, 0x9d, 0x15, 0x3a, 0x63, 0x3d, 0x28,
0x2b, 0x99, 0xf6, 0x50, 0xfd, 0x21, 0x5c, 0x08, 0x85, 0x28, 0xc2, 0xb0, 0x34, 0xef, 0x95, 0x79,
0x79, 0x3f, 0x3d, 0x5f, 0xf9, 0x79, 0x09, 0x56, 0xf7, 0xf4, 0x63, 0xfc, 0xf2, 0x53, 0xa3, 0x5c,
0x26, 0x7b, 0x0b, 0x56, 0x68, 0x36, 0xb4, 0x16, 0x59, 0xcf, 0x94, 0x98, 0x21, 0xca, 0xf1, 0x74,
0x47, 0xf4, 0x2d, 0x12, 0xec, 0xe0, 0xc1, 0xd1, 0xae, 0x63, 0x86, 0xf1, 0xc2, 0x55, 0xc9, 0x38,
0x0f, 0x05, 0x96, 0x16, 0xed, 0x81, 0x76, 0xd3, 0xd6, 0x8f, 0x45, 0x0a, 0x6f, 0x4d, 0x4d, 0xd0,
0x43, 0xea, 0x27, 0x8d, 0x20, 0xea, 0xc0, 0x12, 0x77, 0xf3, 0xd4, 0x34, 0x54, 0xb5, 0xa0, 0x89,
0x76, 0xe1, 0x3c, 0xdb, 0xc1, 0x1e, 0x97, 0x7b, 0xb6, 0xf9, 0x6a, 0xae, 0xcd, 0xcb, 0xba, 0xc6,
0xd5, 0xa6, 0x76, 0x56, 0xb5, 0xe9, 0xc0, 0x12, 0x17, 0x65, 0x6a, 0x2e, 0xaa, 0x5a, 0xd0, 0x24,
0x6c, 0x0e, 0x85, 0xba, 0x4e, 0xbf, 0x85, 0x00, 0x92, 0x56, 0x42, 0x48, 0xcf, 0x19, 0xa5, 0xa4,
0x4f, 0xa0, 0x2a, 0x24, 0xbc, 0x90, 0x5b, 0xc2, 0x45, 0x9f, 0xa4, 0x19, 0x2f, 0x26, 0xcc, 0xb8,
0xfa, 0x2f, 0x0a, 0x34, 0x36, 0xc8, 0x96, 0xb6, 0x9c, 0x21, 0x75, 0x3a, 0xb7, 0xa0, 0xe5, 0xe2,
0x81, 0xe3, 0x1a, 0x7d, 0x6c, 0xfb, 0xae, 0x89, 0x59, 0x05, 0xa2, 0xa4, 0x35, 0x19, 0xf4, 0x33,
0x06, 0x24, 0x68, 0xc4, 0x32, 0x7b, 0xbe, 0x6e, 0x8d, 0xfb, 0x07, 0xc4, 0x02, 0x14, 0x18, 0x9a,
0x80, 0x52, 0x03, 0xf0, 0x3a, 0x34, 0x42, 0x34, 0xdf, 0xa1, 0xf3, 0x97, 0xb4, 0xba, 0x80, 0xed,
0x3b, 0xe8, 0x0d, 0x68, 0x51, 0x9a, 0xf6, 0x47, 0xce, 0xb0, 0x4f, 0xb2, 0x75, 0xee, 0x8f, 0x1a,
0x06, 0x5f, 0x16, 0xe1, 0x55, 0x1c, 0xcb, 0x33, 0x7f, 0x80, 0xb9, 0x47, 0x12, 0x58, 0x7b, 0xe6,
0x0f, 0x30, 0x09, 0x07, 0x9a, 0xc4, 0xbd, 0xee, 0x38, 0x06, 0xde, 0x9f, 0x33, 0x18, 0xc9, 0x51,
0xd6, 0xbd, 0x02, 0x35, 0xb1, 0x03, 0xbe, 0xa5, 0x10, 0x80, 0x1e, 0x41, 0x2b, 0x08, 0x9b, 0xfb,
0x2c, 0x9b, 0x2c, 0x65, 0x06, 0x87, 0x11, 0x07, 0xe9, 0x69, 0xcd, 0xa0, 0x1b, 0x6d, 0xaa, 0x8f,
0xa0, 0x11, 0xfd, 0x4c, 0x66, 0xdd, 0x4b, 0x0a, 0x8a, 0x00, 0x10, 0x69, 0xdc, 0x99, 0x58, 0x84,
0xa7, 0xdc, 0xb0, 0x04, 0x4d, 0xf5, 0x47, 0x0a, 0x34, 0xb9, 0x57, 0xdf, 0x13, 0x07, 0x20, 0x74,
0x6b, 0x0a, 0xdd, 0x1a, 0xfd, 0x8d, 0x7e, 0x25, 0x5e, 0xb3, 0x7c, 0x43, 0x6a, 0x04, 0xe8, 0x20,
0x34, 0x80, 0x8e, 0xb9, 0xf4, 0x3c, 0xf5, 0x8b, 0x2f, 0x89, 0xa0, 0x71, 0xd6, 0x50, 0x41, 0xeb,
0xc0, 0x92, 0x6e, 0x18, 0x2e, 0xf6, 0x3c, 0xbe, 0x8e, 0xa0, 0x49, 0xbe, 0x1c, 0x63, 0xd7, 0x0b,
0x44, 0xbe, 0xa8, 0x05, 0x4d, 0xf4, 0x4d, 0xa8, 0x8a, 0x88, 0xbb, 0x28, 0x8b, 0xb2, 0xa2, 0xeb,
0xe4, 0xd9, 0xb6, 0xe8, 0xa1, 0xfe, 0x6d, 0x01, 0x5a, 0x9c, 0x60, 0xeb, 0xdc, 0xed, 0x4e, 0x57,
0xbe, 0x75, 0x68, 0x1c, 0x84, 0xba, 0x3f, 0xad, 0xae, 0x16, 0x35, 0x11, 0xb1, 0x3e, 0xb3, 0x14,
0x30, 0xee, 0xf8, 0x4b, 0x0b, 0x39, 0xfe, 0xf2, 0x59, 0x2d, 0x58, 0x3a, 0x14, 0xac, 0x48, 0x42,
0x41, 0xf5, 0xd7, 0xa1, 0x1e, 0x19, 0x80, 0x5a, 0x68, 0x56, 0x90, 0xe3, 0x14, 0x0b, 0x9a, 0xe8,
0x83, 0x30, 0xfc, 0x61, 0xa4, 0xba, 0x24, 0x59, 0x4b, 0x22, 0xf2, 0x51, 0xff, 0x51, 0x81, 0x0a,
0x1f, 0xf9, 0x3a, 0xd4, 0xb9, 0xd1, 0xa1, 0xa1, 0x21, 0x1b, 0x1d, 0x38, 0x88, 0xc4, 0x86, 0x2f,
0xce, 0xea, 0x5c, 0x82, 0x6a, 0xc2, 0xde, 0x2c, 0x71, 0xb7, 0x10, 0x7c, 0x8a, 0x18, 0x19, 0xf2,
0x89, 0xd8, 0x17, 0x74, 0x01, 0xca, 0x23, 0x67, 0x28, 0x0e, 0xb8, 0x58, 0x83, 0x64, 0x72, 0x17,
0x37, 0xb1, 0xaf, 0xe1, 0x81, 0x73, 0x8c, 0xdd, 0xd3, 0xc5, 0x0b, 0xb9, 0x0f, 0x22, 0x62, 0x9e,
0x33, 0xb1, 0x14, 0x1d, 0xd0, 0x83, 0x90, 0x09, 0x45, 0x59, 0x15, 0x2b, 0x6a, 0x77, 0xb8, 0x90,
0x86, 0xcc, 0xf8, 0x3d, 0x56, 0x92, 0x8e, 0x6f, 0x65, 0xde, 0x68, 0xe7, 0x85, 0xe4, 0x2b, 0xea,
0xcf, 0x15, 0xe8, 0x86, 0x65, 0x32, 0x6f, 0xfd, 0x74, 0xd1, 0x03, 0x9f, 0x17, 0x93, 0x46, 0xfd,
0xb2, 0x38, 0x91, 0x20, 0x4a, 0x9b, 0x2b, 0x01, 0x0a, 0xce, 0x23, 0x6c, 0x5a, 0x71, 0x4f, 0x6f,
0x68, 0x11, 0x91, 0xe9, 0x42, 0x55, 0xd4, 0x6a, 0xd8, 0xa9, 0x84, 0x68, 0xab, 0x7f, 0xa8, 0xc0,
0xa5, 0x4d, 0xec, 0x3f, 0x8a, 0x97, 0x79, 0x5e, 0x35, 0x5f, 0x2d, 0xca, 0xd6, 0xd4, 0xa2, 0x5e,
0x16, 0x11, 0x7e, 0x4b, 0x81, 0x0e, 0x9f, 0x85, 0xce, 0x49, 0xb2, 0x99, 0x11, 0xf6, 0xb1, 0xf1,
0x75, 0x97, 0x2c, 0xfe, 0x47, 0x81, 0x76, 0xd4, 0x93, 0x52, 0x67, 0xf8, 0x21, 0x94, 0x69, 0x65,
0x88, 0xaf, 0x60, 0xa6, 0xba, 0x33, 0x6c, 0x62, 0x8a, 0x69, 0xf8, 0xbc, 0x2f, 0x9c, 0x3e, 0x6f,
0x86, 0xee, 0xbc, 0x78, 0x76, 0x77, 0xce, 0xc3, 0x1b, 0x67, 0x42, 0xc6, 0x65, 0x25, 0xd5, 0x10,
0x10, 0xa9, 0xa7, 0x94, 0xe7, 0xa8, 0xa7, 0xa8, 0xbf, 0x0a, 0xab, 0x61, 0x22, 0xc9, 0xa6, 0x9d,
0x57, 0x10, 0xd5, 0x7f, 0x57, 0xe0, 0xfc, 0xde, 0xa9, 0x3d, 0x48, 0x8a, 0xf4, 0x2a, 0x54, 0xc6,
0x23, 0x3d, 0xac, 0xf0, 0xf2, 0x16, 0x0d, 0xed, 0xd8, 0xdc, 0xd8, 0x20, 0x7e, 0x81, 0xd1, 0xac,
0x2e, 0x60, 0xfb, 0xce, 0x4c, 0x77, 0x7d, 0x4b, 0x64, 0xbe, 0xd8, 0x60, 0x1e, 0x88, 0x95, 0xcd,
0x9a, 0x02, 0x4a, 0x3d, 0xd0, 0xc7, 0x00, 0xd4, 0x49, 0xf7, 0xcf, 0xe2, 0x98, 0x69, 0x8f, 0x2d,
0x62, 0x86, 0x7f, 0x56, 0x80, 0x4e, 0x84, 0x4a, 0x5f, 0x77, 0xcc, 0x92, 0x91, 0x69, 0x15, 0x5f,
0x50, 0xa6, 0x55, 0x5a, 0x3c, 0x4e, 0x29, 0xcb, 0xe2, 0x94, 0x7f, 0x28, 0x40, 0x2b, 0xa4, 0xda,
0xee, 0x48, 0xb7, 0x33, 0x25, 0x61, 0x4f, 0xc4, 0xe8, 0x71, 0x3a, 0xbd, 0x23, 0xd3, 0x93, 0x0c,
0x46, 0x68, 0x89, 0x21, 0xd0, 0x55, 0xca, 0x74, 0xd7, 0x67, 0x35, 0x2b, 0x9e, 0x17, 0x30, 0x85,
0x34, 0x2d, 0x8c, 0xee, 0x02, 0xe2, 0x5a, 0xd4, 0x37, 0xed, 0xbe, 0x87, 0x07, 0x8e, 0x6d, 0x30,
0xfd, 0x2a, 0x6b, 0x6d, 0xfe, 0xa5, 0x67, 0xef, 0x31, 0x38, 0xfa, 0x10, 0x4a, 0xfe, 0xe9, 0x98,
0x45, 0x20, 0x2d, 0xa9, 0x0f, 0x0f, 0xd7, 0xb5, 0x7f, 0x3a, 0xc6, 0x1a, 0x45, 0x0f, 0x6e, 0x16,
0xf9, 0xae, 0x7e, 0xcc, 0xc3, 0xb9, 0x92, 0x16, 0x81, 0x10, 0x8b, 0x11, 0xd0, 0x70, 0x89, 0x85,
0x3d, 0xbc, 0xa9, 0xfe, 0x5d, 0x01, 0xda, 0xe1, 0x90, 0x1a, 0xf6, 0x26, 0xa3, 0x6c, 0x4d, 0x9a,
0x5e, 0xc8, 0x98, 0xa5, 0x44, 0xdf, 0x82, 0x3a, 0xe7, 0xe7, 0x19, 0xe4, 0x01, 0x58, 0x97, 0xad,
0x29, 0x02, 0x5a, 0x7e, 0x41, 0x02, 0x5a, 0x39, 0xa3, 0x80, 0xaa, 0x3f, 0x55, 0xe0, 0xb5, 0x94,
0x55, 0x9b, 0x4a, 0xc0, 0xe9, 0xe9, 0x16, 0xb7, 0x76, 0xc9, 0x21, 0xb9, 0x7d, 0x7e, 0x00, 0x15,
0x97, 0x8e, 0xce, 0x4f, 0x9e, 0x6e, 0x4e, 0x15, 0x0e, 0xb6, 0x10, 0x8d, 0x77, 0x51, 0xff, 0x40,
0x81, 0x8b, 0xe9, 0xa5, 0x2e, 0xe0, 0x74, 0xd7, 0x61, 0x89, 0x0d, 0x1d, 0xe8, 0xd0, 0xed, 0xe9,
0x3a, 0x14, 0x12, 0x47, 0x0b, 0x3a, 0xaa, 0x7b, 0xb0, 0x1a, 0xf8, 0xe6, 0x90, 0xc0, 0xdb, 0xd8,
0xd7, 0xa7, 0x24, 0x1b, 0xd7, 0xa1, 0xce, 0xa2, 0x56, 0x16, 0xc4, 0xb3, 0x34, 0x1d, 0x9e, 0x8a,
0xea, 0x96, 0xfa, 0x5f, 0x0a, 0x5c, 0xa0, 0xce, 0x2d, 0x79, 0xd4, 0x93, 0xe7, 0x18, 0x50, 0x15,
0x55, 0x00, 0x92, 0xf1, 0xb3, 0xad, 0xd5, 0xb4, 0x18, 0x4c, 0x56, 0xfa, 0x2f, 0xce, 0x57, 0xfa,
0x8f, 0x38, 0xd5, 0xd2, 0x3c, 0x4e, 0x75, 0x0b, 0x5e, 0x4b, 0xec, 0x74, 0x01, 0x8e, 0xaa, 0x7f,
0xa1, 0x10, 0x76, 0xc4, 0xae, 0xef, 0xcc, 0x1f, 0x2c, 0x5e, 0x15, 0x67, 0x4c, 0x7d, 0xd3, 0x48,
0x9a, 0x0a, 0x03, 0x7d, 0x02, 0x35, 0x1b, 0x9f, 0xf4, 0xa3, 0xb1, 0x4a, 0x8e, 0x48, 0xba, 0x6a,
0xe3, 0x13, 0xfa, 0x4b, 0xdd, 0x81, 0x8b, 0xa9, 0xa5, 0x2e, 0xb2, 0xf7, 0xbf, 0x57, 0xe0, 0xd2,
0x86, 0xeb, 0x8c, 0xbf, 0x30, 0x5d, 0x7f, 0xa2, 0x8f, 0xe2, 0x27, 0xf2, 0x2f, 0xa7, 0x9a, 0xf4,
0x79, 0x24, 0x6a, 0x65, 0xf2, 0x73, 0x57, 0xa2, 0x41, 0xe9, 0x45, 0xf1, 0x4d, 0x47, 0x62, 0xdc,
0xff, 0x2c, 0xca, 0x16, 0xcf, 0xf1, 0x66, 0xc4, 0x0d, 0x79, 0x82, 0x7a, 0x69, 0xf1, 0xb9, 0x38,
0x6f, 0xf1, 0x39, 0xc3, 0x88, 0x97, 0x5e, 0x90, 0x11, 0x3f, 0x73, 0x35, 0xe4, 0x73, 0x88, 0x1f,
0x0c, 0x50, 0xef, 0x39, 0xd7, 0x89, 0xc2, 0x3a, 0x40, 0x58, 0x24, 0xe7, 0xb7, 0x2f, 0xf3, 0x0c,
0x13, 0xe9, 0x45, 0xb8, 0x25, 0x1c, 0x26, 0x3d, 0xff, 0x8a, 0x95, 0x6d, 0xbf, 0x03, 0x5d, 0x99,
0x94, 0x2e, 0x22, 0xf9, 0x3f, 0x2b, 0x00, 0xf4, 0xc4, 0x85, 0xdd, 0xf9, 0x7c, 0xc1, 0x4d, 0x68,
0x86, 0x02, 0x13, 0xea, 0x7b, 0x54, 0x8a, 0x0c, 0xa2, 0x12, 0x22, 0x0f, 0x24, 0x38, 0xa9, 0xdc,
0xd0, 0xa0, 0xe3, 0x44, 0xb4, 0x86, 0x09, 0x45, 0xd2, 0xfc, 0x5e, 0x86, 0x9a, 0xeb, 0x9c, 0xf4,
0x89, 0x9a, 0x19, 0xc1, 0x8d, 0x64, 0xd7, 0x39, 0x21, 0xca, 0x67, 0xa0, 0x8b, 0xb0, 0xe4, 0xeb,
0xde, 0x11, 0x19, 0xbf, 0x12, 0xb9, 0x14, 0x62, 0xa0, 0x0b, 0x50, 0x3e, 0x30, 0x47, 0x98, 0xdd,
0x41, 0xa8, 0x69, 0xac, 0x81, 0xbe, 0x11, 0x5c, 0x9d, 0xab, 0xe6, 0xbe, 0xf8, 0xc3, 0x6e, 0xcf,
0x7d, 0xa5, 0xc0, 0x72, 0x48, 0x35, 0x6a, 0x80, 0x88, 0x4d, 0xa3, 0xf6, 0xec, 0xa1, 0x63, 0x30,
0x53, 0xd1, 0xca, 0xf0, 0x08, 0xac, 0x23, 0xb3, 0x5a, 0x61, 0x97, 0x69, 0x69, 0x2c, 0xd9, 0x17,
0xd9, 0xb4, 0x69, 0x04, 0x67, 0xd1, 0x15, 0xd7, 0x39, 0xe9, 0x19, 0x82, 0x1a, 0xec, 0xba, 0x31,
0x4b, 0xda, 0x08, 0x35, 0x1e, 0xd2, 0x1b, 0xc7, 0x37, 0xa1, 0x89, 0x5d, 0xd7, 0x71, 0xfb, 0x16,
0xf6, 0x3c, 0x7d, 0x88, 0x79, 0xfc, 0xdc, 0xa0, 0xc0, 0x6d, 0x06, 0x53, 0xff, 0xa9, 0x08, 0xad,
0x70, 0x2b, 0xc1, 0x09, 0xb4, 0x69, 0x04, 0x27, 0xd0, 0x26, 0x61, 0x1d, 0xb8, 0xcc, 0x14, 0x0a,
0xe6, 0xae, 0x17, 0x3a, 0x8a, 0x56, 0xe3, 0xd0, 0x9e, 0x41, 0xdc, 0x32, 0x51, 0x32, 0xdb, 0x31,
0x70, 0xc8, 0x5c, 0x08, 0x40, 0x9c, 0xb7, 0x31, 0x19, 0x29, 0xe5, 0x90, 0x91, 0x72, 0x0e, 0x19,
0xa9, 0x48, 0x64, 0x64, 0x15, 0x2a, 0x4f, 0x27, 0x83, 0x23, 0xec, 0xf3, 0x68, 0x97, 0xb7, 0xe2,
0xb2, 0x53, 0x4d, 0xc8, 0x8e, 0x10, 0x91, 0x5a, 0x54, 0x44, 0x2e, 0x43, 0x8d, 0x1d, 0x85, 0xf6,
0x7d, 0x8f, 0x1e, 0xf8, 0x14, 0xb5, 0x2a, 0x03, 0xec, 0x7b, 0xe8, 0xa3, 0x20, 0x9c, 0xab, 0xcb,
0x94, 0x9d, 0x5a, 0x9d, 0x84, 0x94, 0x04, 0xc1, 0xdc, 0x5b, 0xb0, 0x1c, 0x21, 0x07, 0xf5, 0x11,
0x0d, 0xba, 0xd4, 0x56, 0x08, 0xa6, 0x6e, 0xe2, 0x16, 0xb4, 0x42, 0x92, 0x50, 0xbc, 0x26, 0x4b,
0x82, 0x04, 0x94, 0xa0, 0xa9, 0xdf, 0x07, 0x14, 0xce, 0xb4, 0x58, 0x64, 0x97, 0x60, 0x65, 0x21,
0xc9, 0x4a, 0xf5, 0x2f, 0x15, 0x58, 0x89, 0x4e, 0x36, 0xaf, 0x93, 0xfc, 0x04, 0xea, 0xec, 0x78,
0xac, 0x4f, 0x94, 0x94, 0x17, 0x54, 0xae, 0x4e, 0xa5, 0xa1, 0x06, 0xe1, 0xe3, 0x02, 0x22, 0x0a,
0x27, 0x8e, 0x7b, 0x64, 0xda, 0xc3, 0x3e, 0x59, 0x59, 0xa0, 0x1a, 0x0d, 0x0e, 0xdc, 0x21, 0x30,
0xf5, 0xc7, 0x0a, 0x5c, 0x7b, 0x3c, 0x36, 0x74, 0x1f, 0x47, 0xa2, 0x85, 0x45, 0xef, 0x2b, 0x7e,
0x18, 0x5c, 0x18, 0x2c, 0xe4, 0x3b, 0xe2, 0x61, 0xd8, 0xea, 0x36, 0x5c, 0xd2, 0xb0, 0x87, 0x6d,
0x23, 0xf6, 0x71, 0xee, 0x3a, 0xc8, 0x18, 0xba, 0xb2, 0xe1, 0x16, 0xe1, 0x3d, 0x0b, 0xdb, 0xfa,
0x2e, 0x19, 0xd6, 0xe7, 0x56, 0x88, 0x44, 0x0b, 0x74, 0x1e, 0x5f, 0xfd, 0xab, 0x02, 0x5c, 0xfc,
0xd4, 0x30, 0xb8, 0x01, 0xe3, 0x81, 0xc8, 0xcb, 0x8a, 0x11, 0x93, 0x31, 0x54, 0x31, 0x1d, 0x43,
0xbd, 0x28, 0xa3, 0xc2, 0xcd, 0xab, 0x3d, 0xb1, 0x02, 0xb7, 0xe1, 0xb2, 0x5b, 0x29, 0x0f, 0xf8,
0x31, 0x0d, 0xc9, 0x58, 0xa9, 0xeb, 0x98, 0x1d, 0x5a, 0x54, 0x83, 0x7a, 0x8e, 0x3a, 0x86, 0x4e,
0x9a, 0x58, 0x0b, 0x6a, 0x66, 0x40, 0x91, 0xb1, 0xc3, 0x6a, 0x7f, 0x0d, 0x12, 0x3d, 0x50, 0xd0,
0xae, 0xe3, 0xa9, 0xff, 0x5d, 0x80, 0xce, 0x9e, 0x7e, 0x8c, 0x7f, 0x71, 0x18, 0xf4, 0x5d, 0xb8,
0xe0, 0xe9, 0xc7, 0xb8, 0x1f, 0xc9, 0x09, 0xfb, 0x2e, 0x7e, 0xc6, 0xa3, 0xaf, 0xb7, 0x65, 0x8a,
0x29, 0xbd, 0xd5, 0xa1, 0xad, 0x78, 0x31, 0xb8, 0x86, 0x9f, 0xa1, 0x37, 0x61, 0x39, 0x7a, 0x3b,
0x88, 0x2c, 0xad, 0x4a, 0x49, 0xde, 0x8c, 0x5c, 0xfe, 0xe9, 0x19, 0xea, 0x33, 0xb8, 0xf2, 0xd8,
0xf6, 0xb0, 0xdf, 0x0b, 0x2f, 0xb0, 0x2c, 0x98, 0x3d, 0x5d, 0x87, 0x7a, 0x48, 0xf8, 0xd4, 0x7b,
0x03, 0xc3, 0x53, 0x1d, 0xe8, 0x6e, 0x87, 0x97, 0xf1, 0xbc, 0x0d, 0x76, 0x03, 0xe1, 0x25, 0x4e,
0x78, 0x20, 0x2e, 0xe4, 0x68, 0xf8, 0x00, 0xbb, 0xd8, 0x1e, 0xe0, 0x2d, 0x67, 0x70, 0x14, 0xb9,
0x84, 0xab, 0x44, 0x2f, 0xe1, 0xce, 0x7b, 0xa9, 0xf7, 0xce, 0x7d, 0x71, 0x17, 0x6e, 0xff, 0x74,
0x8c, 0xd1, 0x12, 0x14, 0x77, 0xf0, 0x49, 0xfb, 0x1c, 0x02, 0xa8, 0xec, 0x38, 0xae, 0xa5, 0x8f,
0xda, 0x0a, 0xaa, 0xc3, 0x12, 0x3f, 0x3f, 0x68, 0x17, 0xee, 0xfc, 0x89, 0x02, 0x2b, 0xa9, 0x92,
0x36, 0x6a, 0x01, 0x3c, 0xb6, 0x07, 0xbc, 0xd6, 0xdf, 0x3e, 0x87, 0x1a, 0x50, 0x0d, 0x2a, 0xff,
0x6c, 0x80, 0x7d, 0x87, 0x62, 0xb7, 0x0b, 0xa8, 0x0d, 0x0d, 0xd6, 0x71, 0x32, 0x18, 0x60, 0xcf,
0x6b, 0x17, 0x05, 0xe4, 0x91, 0x6e, 0x8e, 0x26, 0x2e, 0x6e, 0x97, 0x50, 0x13, 0x6a, 0xfb, 0x0e,
0xbf, 0xf3, 0xdc, 0x2e, 0x23, 0x04, 0xad, 0xe0, 0x02, 0x34, 0xef, 0x54, 0x89, 0xc0, 0x82, 0x6e,
0x4b, 0x77, 0x9e, 0x44, 0x0b, 0x93, 0x74, 0x3f, 0x17, 0xe1, 0xfc, 0x63, 0xdb, 0xc0, 0x07, 0xa6,
0x8d, 0x8d, 0xf0, 0x53, 0xfb, 0x1c, 0x3a, 0x0f, 0xcb, 0xdb, 0xd8, 0x1d, 0xe2, 0x08, 0xb0, 0x80,
0x56, 0xa0, 0xb9, 0x6d, 0x3e, 0x8f, 0x80, 0x8a, 0x6a, 0xa9, 0xaa, 0xb4, 0x95, 0xb5, 0x7f, 0xed,
0x42, 0x6d, 0x43, 0xf7, 0xf5, 0x87, 0x8e, 0xe3, 0x1a, 0x68, 0x04, 0x88, 0x3e, 0x11, 0xb0, 0xc6,
0x8e, 0x2d, 0x1e, 0xde, 0xa0, 0x7b, 0x71, 0xb6, 0xf3, 0x46, 0x1a, 0x91, 0x0b, 0x4d, 0xf7, 0x0d,
0x29, 0x7e, 0x02, 0x59, 0x3d, 0x87, 0x2c, 0x3a, 0xdb, 0xbe, 0x69, 0xe1, 0x7d, 0x73, 0x70, 0x14,
0xdc, 0x1b, 0x7c, 0x2f, 0x23, 0xcf, 0x49, 0xa3, 0x06, 0xf3, 0xdd, 0x94, 0xce, 0xc7, 0xde, 0x70,
0x04, 0x66, 0x52, 0x3d, 0x87, 0x9e, 0xc1, 0x85, 0x4d, 0x1c, 0x71, 0xda, 0xc1, 0x84, 0x6b, 0xd9,
0x13, 0xa6, 0x90, 0xcf, 0x38, 0xe5, 0x16, 0x94, 0xa9, 0x7c, 0x21, 0x99, 0x5f, 0x8f, 0xbe, 0x91,
0xed, 0xde, 0xc8, 0x46, 0x10, 0xa3, 0x7d, 0x1f, 0x96, 0x13, 0x2f, 0xeb, 0x90, 0xcc, 0x2c, 0xc9,
0xdf, 0x48, 0x76, 0xef, 0xe4, 0x41, 0x15, 0x73, 0x0d, 0xa1, 0x15, 0x7f, 0x5a, 0x80, 0x64, 0x55,
0x39, 0xe9, 0xa3, 0xa8, 0xee, 0xdb, 0x39, 0x30, 0xc5, 0x44, 0x16, 0xb4, 0x93, 0x2f, 0xbd, 0xd0,
0x9d, 0xa9, 0x03, 0xc4, 0x85, 0xed, 0x9d, 0x5c, 0xb8, 0x62, 0xba, 0x53, 0x2a, 0x04, 0xa9, 0xc7,
0x43, 0x49, 0x19, 0x0f, 0x86, 0xc9, 0x7a, 0xd5, 0xd4, 0xbd, 0x9f, 0x1b, 0x5f, 0x4c, 0xfd, 0x9b,
0xec, 0x94, 0x5f, 0xf6, 0x00, 0x07, 0xbd, 0x2f, 0x1f, 0x6e, 0xca, 0xcb, 0xa1, 0xee, 0xda, 0x59,
0xba, 0x88, 0x45, 0xfc, 0x90, 0x1e, 0xcf, 0x4b, 0x9e, 0xb0, 0x24, 0xf5, 0x2e, 0x18, 0x2f, 0xfb,
0x75, 0x4e, 0xf7, 0xfd, 0x33, 0xf4, 0x10, 0x0b, 0x70, 0x92, 0x4f, 0xe9, 0x02, 0x35, 0xbc, 0x3f,
0x53, 0x6a, 0xe6, 0xd3, 0xc1, 0xef, 0xc1, 0x72, 0xc2, 0x51, 0xa3, 0xfc, 0xce, 0xbc, 0x3b, 0x2d,
0x9a, 0x62, 0x2a, 0x99, 0xb8, 0xed, 0x80, 0x32, 0xa4, 0x5f, 0x72, 0x23, 0xa2, 0x7b, 0x27, 0x0f,
0xaa, 0xd8, 0x88, 0x47, 0xcd, 0x65, 0xe2, 0xbc, 0x1b, 0xdd, 0x95, 0x8f, 0x21, 0x3f, 0xab, 0xef,
0xbe, 0x9b, 0x13, 0x5b, 0x4c, 0x7a, 0x0c, 0xe7, 0x25, 0x57, 0x0d, 0xd0, 0xbb, 0x53, 0x99, 0x95,
0xbc, 0x63, 0xd1, 0xbd, 0x97, 0x17, 0x5d, 0xcc, 0xfb, 0x1b, 0x80, 0xf6, 0x0e, 0x9d, 0x93, 0x87,
0x8e, 0x7d, 0x60, 0x0e, 0x27, 0xae, 0xce, 0xaa, 0xdc, 0x59, 0xbe, 0x21, 0x8d, 0x9a, 0x21, 0xa3,
0x53, 0x7b, 0x88, 0xc9, 0xfb, 0x00, 0x9b, 0xd8, 0xdf, 0xc6, 0xbe, 0x4b, 0x14, 0xe3, 0xcd, 0x2c,
0xf7, 0xc7, 0x11, 0x82, 0xa9, 0xde, 0x9a, 0x89, 0x17, 0x71, 0x45, 0xed, 0x6d, 0xdd, 0x9e, 0xe8,
0xa3, 0xc8, 0x95, 0xe8, 0xbb, 0xd2, 0xee, 0x49, 0xb4, 0x0c, 0x46, 0x66, 0x62, 0x8b, 0x29, 0x4f,
0x84, 0x6b, 0x8f, 0x1c, 0xa3, 0x4c, 0x77, 0xed, 0xe9, 0x23, 0xf6, 0xa4, 0xd9, 0x9b, 0x82, 0x2f,
0x26, 0xfe, 0x52, 0xa1, 0xb7, 0x55, 0x12, 0x08, 0x4f, 0x4c, 0xff, 0x70, 0x77, 0xa4, 0xdb, 0x5e,
0x9e, 0x25, 0x50, 0xc4, 0x33, 0x2c, 0x81, 0xe3, 0x8b, 0x25, 0x18, 0xd0, 0x8c, 0x9d, 0x6e, 0x20,
0xd9, 0xe5, 0x62, 0xd9, 0x49, 0x4f, 0xf7, 0xf6, 0x6c, 0x44, 0x31, 0xcb, 0x21, 0x34, 0x03, 0x55,
0x62, 0xc4, 0x7d, 0x3b, 0x6b, 0xa5, 0x21, 0x4e, 0x86, 0x25, 0x90, 0xa3, 0x46, 0x2d, 0x41, 0xba,
0x78, 0x8b, 0xf2, 0x15, 0xfd, 0xa7, 0x59, 0x82, 0xec, 0x8a, 0x30, 0x33, 0x75, 0x89, 0x83, 0x12,
0xb9, 0x1d, 0x95, 0x9e, 0xfb, 0x48, 0x4d, 0x5d, 0xc6, 0xb9, 0x8b, 0x7a, 0x0e, 0x3d, 0x81, 0x0a,
0xff, 0x63, 0x88, 0x37, 0xa6, 0x17, 0x71, 0xf8, 0xe8, 0xb7, 0x66, 0x60, 0x89, 0x81, 0x8f, 0xe0,
0x62, 0x46, 0x09, 0x47, 0xea, 0x82, 0xa7, 0x97, 0x7b, 0x66, 0x39, 0x07, 0x1d, 0x50, 0xfa, 0xf5,
0xa5, 0x94, 0x4d, 0x99, 0x8f, 0x34, 0x73, 0x4c, 0x91, 0x7e, 0x40, 0x29, 0x9d, 0x22, 0xf3, 0x9d,
0xe5, 0xac, 0x29, 0xfa, 0xb0, 0x92, 0x2a, 0x04, 0xa0, 0x77, 0x32, 0x3c, 0xa8, 0xac, 0x5c, 0x30,
0x6b, 0x82, 0x21, 0xbc, 0x26, 0x4d, 0x7a, 0xa5, 0x11, 0xc1, 0xb4, 0xf4, 0x78, 0xd6, 0x44, 0x03,
0x38, 0x2f, 0x49, 0x75, 0xa5, 0xbe, 0x2c, 0x3b, 0x25, 0x9e, 0x31, 0xc9, 0xda, 0x57, 0x35, 0xa8,
0x06, 0xd7, 0x94, 0xbf, 0xe6, 0x7c, 0xea, 0x15, 0x24, 0x38, 0xdf, 0x83, 0xe5, 0xc4, 0x73, 0x48,
0xa9, 0x51, 0x90, 0x3f, 0x99, 0x9c, 0xc5, 0xaf, 0x27, 0xfc, 0xcf, 0x7a, 0x44, 0xac, 0xf3, 0x56,
0x56, 0x92, 0x94, 0x0c, 0x73, 0x66, 0x0c, 0xfc, 0xff, 0x3b, 0xb8, 0xd8, 0x01, 0x88, 0x84, 0x15,
0xd3, 0x2f, 0xfe, 0x10, 0x4f, 0x39, 0x8b, 0x5a, 0x96, 0x34, 0x72, 0x78, 0x3b, 0xcf, 0x25, 0x8d,
0x6c, 0xdb, 0x9f, 0x1d, 0x2f, 0x3c, 0x86, 0x46, 0xf4, 0x4a, 0x1e, 0x92, 0xfe, 0x35, 0x4c, 0xfa,
0xce, 0xde, 0xac, 0x5d, 0x6c, 0x9f, 0xd1, 0xa5, 0xcc, 0x18, 0xce, 0x23, 0x86, 0x37, 0x59, 0x31,
0xcf, 0x30, 0xbc, 0x19, 0x75, 0x7a, 0xa9, 0x0b, 0xce, 0x2e, 0xc3, 0xb3, 0x5c, 0x39, 0x59, 0x06,
0x96, 0xe6, 0xca, 0x19, 0x85, 0x75, 0x69, 0xae, 0x9c, 0x55, 0x57, 0x56, 0xcf, 0xad, 0x7f, 0xf0,
0xdd, 0xf7, 0x87, 0xa6, 0x7f, 0x38, 0x79, 0x4a, 0x76, 0x7f, 0x9f, 0x75, 0x7d, 0xd7, 0x74, 0xf8,
0xaf, 0xfb, 0x81, 0xb8, 0xdf, 0xa7, 0xa3, 0xdd, 0x27, 0xa3, 0x8d, 0x9f, 0x3e, 0xad, 0xd0, 0xd6,
0x07, 0xff, 0x1b, 0x00, 0x00, 0xff, 0xff, 0x4c, 0x22, 0x75, 0x3a, 0x6e, 0x4c, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
@ -5132,7 +5132,7 @@ const _ = grpc.SupportPackageIsVersion4
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type DataCoordClient interface {
GetComponentStates(ctx context.Context, in *internalpb.GetComponentStatesRequest, opts ...grpc.CallOption) (*internalpb.ComponentStates, error)
GetComponentStates(ctx context.Context, in *milvuspb.GetComponentStatesRequest, opts ...grpc.CallOption) (*milvuspb.ComponentStates, error)
GetTimeTickChannel(ctx context.Context, in *internalpb.GetTimeTickChannelRequest, opts ...grpc.CallOption) (*milvuspb.StringResponse, error)
GetStatisticsChannel(ctx context.Context, in *internalpb.GetStatisticsChannelRequest, opts ...grpc.CallOption) (*milvuspb.StringResponse, error)
Flush(ctx context.Context, in *FlushRequest, opts ...grpc.CallOption) (*FlushResponse, error)
@ -5175,8 +5175,8 @@ func NewDataCoordClient(cc *grpc.ClientConn) DataCoordClient {
return &dataCoordClient{cc}
}
func (c *dataCoordClient) GetComponentStates(ctx context.Context, in *internalpb.GetComponentStatesRequest, opts ...grpc.CallOption) (*internalpb.ComponentStates, error) {
out := new(internalpb.ComponentStates)
func (c *dataCoordClient) GetComponentStates(ctx context.Context, in *milvuspb.GetComponentStatesRequest, opts ...grpc.CallOption) (*milvuspb.ComponentStates, error) {
out := new(milvuspb.ComponentStates)
err := c.cc.Invoke(ctx, "/milvus.proto.data.DataCoord/GetComponentStates", in, out, opts...)
if err != nil {
return nil, err
@ -5456,7 +5456,7 @@ func (c *dataCoordClient) MarkSegmentsDropped(ctx context.Context, in *MarkSegme
// DataCoordServer is the server API for DataCoord service.
type DataCoordServer interface {
GetComponentStates(context.Context, *internalpb.GetComponentStatesRequest) (*internalpb.ComponentStates, error)
GetComponentStates(context.Context, *milvuspb.GetComponentStatesRequest) (*milvuspb.ComponentStates, error)
GetTimeTickChannel(context.Context, *internalpb.GetTimeTickChannelRequest) (*milvuspb.StringResponse, error)
GetStatisticsChannel(context.Context, *internalpb.GetStatisticsChannelRequest) (*milvuspb.StringResponse, error)
Flush(context.Context, *FlushRequest) (*FlushResponse, error)
@ -5495,7 +5495,7 @@ type DataCoordServer interface {
type UnimplementedDataCoordServer struct {
}
func (*UnimplementedDataCoordServer) GetComponentStates(ctx context.Context, req *internalpb.GetComponentStatesRequest) (*internalpb.ComponentStates, error) {
func (*UnimplementedDataCoordServer) GetComponentStates(ctx context.Context, req *milvuspb.GetComponentStatesRequest) (*milvuspb.ComponentStates, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetComponentStates not implemented")
}
func (*UnimplementedDataCoordServer) GetTimeTickChannel(ctx context.Context, req *internalpb.GetTimeTickChannelRequest) (*milvuspb.StringResponse, error) {
@ -5594,7 +5594,7 @@ func RegisterDataCoordServer(s *grpc.Server, srv DataCoordServer) {
}
func _DataCoord_GetComponentStates_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(internalpb.GetComponentStatesRequest)
in := new(milvuspb.GetComponentStatesRequest)
if err := dec(in); err != nil {
return nil, err
}
@ -5606,7 +5606,7 @@ func _DataCoord_GetComponentStates_Handler(srv interface{}, ctx context.Context,
FullMethod: "/milvus.proto.data.DataCoord/GetComponentStates",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DataCoordServer).GetComponentStates(ctx, req.(*internalpb.GetComponentStatesRequest))
return srv.(DataCoordServer).GetComponentStates(ctx, req.(*milvuspb.GetComponentStatesRequest))
}
return interceptor(ctx, in, info, handler)
}
@ -6288,7 +6288,7 @@ var _DataCoord_serviceDesc = grpc.ServiceDesc{
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type DataNodeClient interface {
GetComponentStates(ctx context.Context, in *internalpb.GetComponentStatesRequest, opts ...grpc.CallOption) (*internalpb.ComponentStates, error)
GetComponentStates(ctx context.Context, in *milvuspb.GetComponentStatesRequest, opts ...grpc.CallOption) (*milvuspb.ComponentStates, error)
GetStatisticsChannel(ctx context.Context, in *internalpb.GetStatisticsChannelRequest, opts ...grpc.CallOption) (*milvuspb.StringResponse, error)
WatchDmChannels(ctx context.Context, in *WatchDmChannelsRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
FlushSegments(ctx context.Context, in *FlushSegmentsRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
@ -6312,8 +6312,8 @@ func NewDataNodeClient(cc *grpc.ClientConn) DataNodeClient {
return &dataNodeClient{cc}
}
func (c *dataNodeClient) GetComponentStates(ctx context.Context, in *internalpb.GetComponentStatesRequest, opts ...grpc.CallOption) (*internalpb.ComponentStates, error) {
out := new(internalpb.ComponentStates)
func (c *dataNodeClient) GetComponentStates(ctx context.Context, in *milvuspb.GetComponentStatesRequest, opts ...grpc.CallOption) (*milvuspb.ComponentStates, error) {
out := new(milvuspb.ComponentStates)
err := c.cc.Invoke(ctx, "/milvus.proto.data.DataNode/GetComponentStates", in, out, opts...)
if err != nil {
return nil, err
@ -6422,7 +6422,7 @@ func (c *dataNodeClient) AddImportSegment(ctx context.Context, in *AddImportSegm
// DataNodeServer is the server API for DataNode service.
type DataNodeServer interface {
GetComponentStates(context.Context, *internalpb.GetComponentStatesRequest) (*internalpb.ComponentStates, error)
GetComponentStates(context.Context, *milvuspb.GetComponentStatesRequest) (*milvuspb.ComponentStates, error)
GetStatisticsChannel(context.Context, *internalpb.GetStatisticsChannelRequest) (*milvuspb.StringResponse, error)
WatchDmChannels(context.Context, *WatchDmChannelsRequest) (*commonpb.Status, error)
FlushSegments(context.Context, *FlushSegmentsRequest) (*commonpb.Status, error)
@ -6442,7 +6442,7 @@ type DataNodeServer interface {
type UnimplementedDataNodeServer struct {
}
func (*UnimplementedDataNodeServer) GetComponentStates(ctx context.Context, req *internalpb.GetComponentStatesRequest) (*internalpb.ComponentStates, error) {
func (*UnimplementedDataNodeServer) GetComponentStates(ctx context.Context, req *milvuspb.GetComponentStatesRequest) (*milvuspb.ComponentStates, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetComponentStates not implemented")
}
func (*UnimplementedDataNodeServer) GetStatisticsChannel(ctx context.Context, req *internalpb.GetStatisticsChannelRequest) (*milvuspb.StringResponse, error) {
@ -6484,7 +6484,7 @@ func RegisterDataNodeServer(s *grpc.Server, srv DataNodeServer) {
}
func _DataNode_GetComponentStates_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(internalpb.GetComponentStatesRequest)
in := new(milvuspb.GetComponentStatesRequest)
if err := dec(in); err != nil {
return nil, err
}
@ -6496,7 +6496,7 @@ func _DataNode_GetComponentStates_Handler(srv interface{}, ctx context.Context,
FullMethod: "/milvus.proto.data.DataNode/GetComponentStates",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DataNodeServer).GetComponentStates(ctx, req.(*internalpb.GetComponentStatesRequest))
return srv.(DataNodeServer).GetComponentStates(ctx, req.(*milvuspb.GetComponentStatesRequest))
}
return interceptor(ctx, in, info, handler)
}

4
internal/proto/index_coord.proto
View File

@ -9,7 +9,7 @@ import "internal.proto";
import "milvus.proto";
service IndexCoord {
rpc GetComponentStates(internal.GetComponentStatesRequest) returns (internal.ComponentStates) {}
rpc GetComponentStates(milvus.GetComponentStatesRequest) returns (milvus.ComponentStates) {}
rpc GetStatisticsChannel(internal.GetStatisticsChannelRequest) returns(milvus.StringResponse){}
rpc CreateIndex(CreateIndexRequest) returns (common.Status){}
// Deprecated: use DescribeIndex instead
@ -27,7 +27,7 @@ service IndexCoord {
}
service IndexNode {
rpc GetComponentStates(internal.GetComponentStatesRequest) returns (internal.ComponentStates) {}
rpc GetComponentStates(milvus.GetComponentStatesRequest) returns (milvus.ComponentStates) {}
rpc GetStatisticsChannel(internal.GetStatisticsChannelRequest) returns(milvus.StringResponse){}
rpc CreateJob(CreateJobRequest) returns (common.Status) {}
rpc QueryJobs(QueryJobsRequest) returns (QueryJobsResponse) {}

298
internal/proto/indexpb/index_coord.pb.go
View File

@ -2012,141 +2012,141 @@ func init() {
func init() { proto.RegisterFile("index_coord.proto", fileDescriptor_f9e019eb3fda53c2) }
var fileDescriptor_f9e019eb3fda53c2 = []byte{
// 2134 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x59, 0x5f, 0x6f, 0x1b, 0x59,
0x15, 0xef, 0xd8, 0x4e, 0xe2, 0x39, 0x63, 0x27, 0xe9, 0x6d, 0x16, 0xbc, 0x6e, 0x4b, 0xd3, 0x29,
0x6d, 0x0d, 0xd2, 0x26, 0x25, 0xcb, 0xa2, 0x05, 0x01, 0x52, 0xfe, 0x6c, 0xbb, 0x4e, 0x37, 0x51,
0x18, 0x57, 0x2b, 0xed, 0x0a, 0x69, 0x18, 0x7b, 0xae, 0x93, 0xbb, 0xb1, 0xe7, 0xba, 0x73, 0xef,
0xb4, 0x4d, 0x91, 0x10, 0x2f, 0x3c, 0x2c, 0x5a, 0x09, 0x89, 0x07, 0xf8, 0x02, 0x3c, 0x2d, 0x12,
0xbc, 0xf3, 0xc2, 0x07, 0x80, 0x8f, 0xc0, 0x13, 0x9f, 0x04, 0xdd, 0x3f, 0x33, 0x9e, 0x19, 0x8f,
0x63, 0xe7, 0x0f, 0x4f, 0xfb, 0xe6, 0x7b, 0xee, 0xb9, 0xff, 0xce, 0xf9, 0x9d, 0xf3, 0x3b, 0x67,
0x0c, 0x37, 0x49, 0xe0, 0xe3, 0x37, 0x6e, 0x8f, 0xd2, 0xd0, 0xdf, 0x18, 0x85, 0x94, 0x53, 0x84,
0x86, 0x64, 0xf0, 0x2a, 0x62, 0x6a, 0xb4, 0x21, 0xe7, 0x9b, 0xb5, 0x1e, 0x1d, 0x0e, 0x69, 0xa0,
0x64, 0xcd, 0x65, 0x12, 0x70, 0x1c, 0x06, 0xde, 0x40, 0x8f, 0x6b, 0xe9, 0x15, 0xf6, 0xdf, 0x2b,
0x60, 0xb6, 0xc5, 0xaa, 0x76, 0xd0, 0xa7, 0xc8, 0x86, 0x5a, 0x8f, 0x0e, 0x06, 0xb8, 0xc7, 0x09,
0x0d, 0xda, 0x7b, 0x0d, 0x63, 0xdd, 0x68, 0x95, 0x9d, 0x8c, 0x0c, 0x35, 0x60, 0xa9, 0x4f, 0xf0,
0xc0, 0x6f, 0xef, 0x35, 0x4a, 0x72, 0x3a, 0x1e, 0xa2, 0xbb, 0x00, 0xea, 0x82, 0x81, 0x37, 0xc4,
0x8d, 0xf2, 0xba, 0xd1, 0x32, 0x1d, 0x53, 0x4a, 0x0e, 0xbd, 0x21, 0x16, 0x0b, 0xe5, 0xa0, 0xbd,
0xd7, 0xa8, 0xa8, 0x85, 0x7a, 0x88, 0x76, 0xc0, 0xe2, 0x67, 0x23, 0xec, 0x8e, 0xbc, 0xd0, 0x1b,
0xb2, 0xc6, 0xc2, 0x7a, 0xb9, 0x65, 0x6d, 0xdd, 0xdf, 0xc8, 0x3c, 0x4d, 0xbf, 0xe9, 0x39, 0x3e,
0xfb, 0xd4, 0x1b, 0x44, 0xf8, 0xc8, 0x23, 0xa1, 0x03, 0x62, 0xd5, 0x91, 0x5c, 0x84, 0xf6, 0xa0,
0xa6, 0x0e, 0xd7, 0x9b, 0x2c, 0xce, 0xbb, 0x89, 0x25, 0x97, 0xe9, 0x5d, 0xee, 0xeb, 0x5d, 0xb0,
0xef, 0x86, 0xf4, 0x35, 0x6b, 0x2c, 0xc9, 0x8b, 0x5a, 0x5a, 0xe6, 0xd0, 0xd7, 0x4c, 0xbc, 0x92,
0x53, 0xee, 0x0d, 0x94, 0x42, 0x55, 0x2a, 0x98, 0x52, 0x22, 0xa7, 0x3f, 0x80, 0x05, 0xc6, 0x3d,
0x8e, 0x1b, 0xe6, 0xba, 0xd1, 0x5a, 0xde, 0xba, 0x57, 0x78, 0x01, 0x69, 0xf1, 0x8e, 0x50, 0x73,
0x94, 0x36, 0xfa, 0x00, 0xbe, 0xad, 0xae, 0x2f, 0x87, 0x6e, 0xdf, 0x23, 0x03, 0x37, 0xc4, 0x1e,
0xa3, 0x41, 0x03, 0xa4, 0x21, 0xd7, 0x48, 0xb2, 0xe6, 0xa9, 0x47, 0x06, 0x8e, 0x9c, 0x43, 0x36,
0xd4, 0x09, 0x73, 0xbd, 0x88, 0x53, 0x57, 0xce, 0x37, 0xac, 0x75, 0xa3, 0x55, 0x75, 0x2c, 0xc2,
0xb6, 0x23, 0x4e, 0xe5, 0x31, 0xe8, 0x00, 0x6e, 0x46, 0x0c, 0x87, 0x6e, 0xc6, 0x3c, 0xb5, 0x79,
0xcd, 0xb3, 0x22, 0xd6, 0xb6, 0xc7, 0x26, 0xb2, 0x7f, 0x67, 0x00, 0x3c, 0x95, 0x1e, 0x97, 0xbb,
0xff, 0x34, 0x76, 0x3a, 0x09, 0xfa, 0x54, 0x02, 0xc6, 0xda, 0xba, 0xbb, 0x31, 0x89, 0xca, 0x8d,
0x04, 0x65, 0x1a, 0x13, 0x12, 0x70, 0x0d, 0x58, 0xf2, 0xf1, 0x00, 0x73, 0xec, 0x4b, 0x30, 0x55,
0x9d, 0x78, 0x88, 0xee, 0x81, 0xd5, 0x0b, 0xb1, 0xb0, 0x05, 0x27, 0x1a, 0x4d, 0x15, 0x07, 0x94,
0xe8, 0x05, 0x19, 0x62, 0xfb, 0xcb, 0x0a, 0xd4, 0x3a, 0xf8, 0x78, 0x88, 0x03, 0xae, 0x6e, 0x32,
0x0f, 0x78, 0xd7, 0xc1, 0x1a, 0x79, 0x21, 0x27, 0x5a, 0x45, 0x01, 0x38, 0x2d, 0x42, 0x77, 0xc0,
0x64, 0x7a, 0xd7, 0x3d, 0x79, 0x6a, 0xd9, 0x19, 0x0b, 0xd0, 0xbb, 0x50, 0x0d, 0xa2, 0xa1, 0x72,
0xbd, 0x06, 0x71, 0x10, 0x0d, 0xa5, 0xe3, 0x53, 0xf0, 0x5e, 0xc8, 0xc2, 0xbb, 0x01, 0x4b, 0xdd,
0x88, 0xc8, 0x88, 0x59, 0x54, 0x33, 0x7a, 0x88, 0xbe, 0x05, 0x8b, 0x01, 0xf5, 0x71, 0x7b, 0x4f,
0x03, 0x4d, 0x8f, 0xd0, 0x03, 0xa8, 0x2b, 0xa3, 0xbe, 0xc2, 0x21, 0x23, 0x34, 0xd0, 0x30, 0x53,
0xd8, 0xfc, 0x54, 0xc9, 0x2e, 0x8b, 0xb4, 0x7b, 0x60, 0x4d, 0xa2, 0x0b, 0xfa, 0x63, 0x4c, 0x7d,
0x3f, 0xce, 0x33, 0x7d, 0x32, 0xc0, 0xcc, 0x1d, 0x79, 0xfc, 0x84, 0x35, 0xac, 0xf5, 0x72, 0xcb,
0x74, 0x56, 0xe4, 0xc4, 0x53, 0x21, 0x3f, 0x12, 0xe2, 0xb4, 0xff, 0x6a, 0xe7, 0xfa, 0xaf, 0x9e,
0xf7, 0x1f, 0x7a, 0x08, 0xcb, 0x0c, 0x87, 0xc4, 0x1b, 0x90, 0xb7, 0xd8, 0x65, 0xe4, 0x2d, 0x6e,
0x2c, 0x4b, 0x9d, 0x7a, 0x22, 0xed, 0x90, 0xb7, 0x58, 0x98, 0xe2, 0x75, 0x48, 0x38, 0x76, 0x4f,
0xbc, 0xc0, 0xa7, 0xfd, 0x7e, 0x63, 0x45, 0x9e, 0x53, 0x93, 0xc2, 0x8f, 0x95, 0xcc, 0xfe, 0xb3,
0x01, 0xb7, 0x1c, 0x7c, 0x4c, 0x18, 0xc7, 0xe1, 0x21, 0xf5, 0xb1, 0x83, 0x5f, 0x46, 0x98, 0x71,
0xf4, 0x04, 0x2a, 0x5d, 0x8f, 0x61, 0x0d, 0xcb, 0x3b, 0x85, 0x16, 0x3a, 0x60, 0xc7, 0x3b, 0x1e,
0xc3, 0x8e, 0xd4, 0x44, 0x3f, 0x82, 0x25, 0xcf, 0xf7, 0x43, 0xcc, 0x98, 0x04, 0xc7, 0xb4, 0x45,
0xdb, 0x4a, 0xc7, 0x89, 0x95, 0x53, 0x9e, 0x2c, 0xa7, 0x3d, 0x69, 0xff, 0xc1, 0x80, 0xb5, 0xec,
0xcd, 0xd8, 0x88, 0x06, 0x0c, 0xa3, 0xf7, 0x61, 0x51, 0xf8, 0x23, 0x62, 0xfa, 0x72, 0xb7, 0x0b,
0xcf, 0xe9, 0x48, 0x15, 0x47, 0xab, 0x8a, 0x44, 0x49, 0x02, 0xc2, 0xe3, 0x20, 0x56, 0x37, 0xbc,
0x9f, 0x8f, 0x36, 0x9d, 0xee, 0xdb, 0x01, 0xe1, 0x2a, 0x66, 0x1d, 0x20, 0xc9, 0x6f, 0xfb, 0x33,
0x58, 0x7b, 0x86, 0x79, 0x0a, 0x17, 0xda, 0x56, 0xf3, 0x84, 0x4f, 0x36, 0xc3, 0x97, 0x72, 0x19,
0xde, 0xfe, 0x8b, 0x01, 0xef, 0xe4, 0xf6, 0xbe, 0xca, 0x6b, 0x13, 0x80, 0x97, 0xae, 0x02, 0xf0,
0x72, 0x1e, 0xe0, 0xf6, 0x6f, 0x0d, 0xb8, 0xfd, 0x0c, 0xf3, 0x74, 0xf2, 0xb8, 0x66, 0x4b, 0xa0,
0xef, 0x00, 0x24, 0x49, 0x83, 0x35, 0xca, 0xeb, 0xe5, 0x56, 0xd9, 0x49, 0x49, 0xec, 0x2f, 0x0d,
0xb8, 0x39, 0x71, 0x7e, 0x36, 0xf7, 0x18, 0xf9, 0xdc, 0xf3, 0xff, 0x32, 0xc7, 0x1f, 0x0d, 0xb8,
0x53, 0x6c, 0x8e, 0xab, 0x38, 0xef, 0x67, 0x6a, 0x11, 0x16, 0x28, 0x15, 0x54, 0xf3, 0xb0, 0x88,
0x13, 0x26, 0xcf, 0xd4, 0x8b, 0xec, 0xaf, 0xca, 0x80, 0x76, 0x65, 0xb2, 0x90, 0x93, 0x17, 0x71,
0xcd, 0xa5, 0x0b, 0x94, 0x5c, 0x19, 0x52, 0xb9, 0x8e, 0x32, 0x64, 0xe1, 0x52, 0x65, 0xc8, 0x1d,
0x30, 0x45, 0xd6, 0x64, 0xdc, 0x1b, 0x8e, 0x24, 0x67, 0x54, 0x9c, 0xb1, 0x60, 0x92, 0xf4, 0x97,
0xe6, 0x24, 0xfd, 0xea, 0xa5, 0x49, 0xff, 0x0d, 0xdc, 0x8a, 0x03, 0x5b, 0x52, 0xf8, 0x05, 0xdc,
0x91, 0x0d, 0x85, 0x52, 0x3e, 0x14, 0x66, 0x38, 0xc5, 0xfe, 0x4f, 0x09, 0x6e, 0xb6, 0x63, 0xd6,
0x11, 0xa4, 0x23, 0xeb, 0x86, 0xf3, 0x23, 0x65, 0x3a, 0x02, 0x52, 0x24, 0x5d, 0x9e, 0x4a, 0xd2,
0x95, 0x2c, 0x49, 0x67, 0x2f, 0xb8, 0x90, 0x47, 0xcd, 0xf5, 0x14, 0x9e, 0x2d, 0x58, 0x1d, 0x93,
0xae, 0xe6, 0xdc, 0x25, 0xc9, 0xb9, 0xcb, 0x24, 0xfd, 0x7a, 0x86, 0x1e, 0xc3, 0x4a, 0xc2, 0x90,
0xbe, 0x22, 0xce, 0xaa, 0x44, 0xc8, 0x98, 0x4e, 0xfd, 0x98, 0x39, 0xb3, 0x45, 0x84, 0x39, 0x59,
0x44, 0xd8, 0xff, 0x30, 0xc0, 0x4a, 0xa2, 0x70, 0xce, 0x0e, 0x20, 0x63, 0xfc, 0x52, 0xde, 0xf8,
0xf7, 0xa1, 0x86, 0x03, 0xaf, 0x3b, 0xc0, 0x1a, 0x9c, 0x65, 0x05, 0x4e, 0x25, 0x53, 0xe0, 0x7c,
0x0a, 0xd6, 0xb8, 0x66, 0x8c, 0x03, 0xed, 0xe1, 0xd4, 0xa2, 0x31, 0xed, 0x79, 0x07, 0x92, 0xe2,
0x91, 0xd9, 0xbf, 0x2f, 0x8d, 0xb9, 0x4c, 0xc1, 0xf2, 0x2a, 0x19, 0xeb, 0x97, 0x50, 0xd3, 0xaf,
0x50, 0xb5, 0xac, 0xca, 0x5b, 0x3f, 0x2e, 0xba, 0x56, 0xd1, 0xa1, 0x1b, 0x29, 0x33, 0x7e, 0x14,
0xf0, 0xf0, 0xcc, 0xb1, 0xd8, 0x58, 0xd2, 0x74, 0x61, 0x35, 0xaf, 0x80, 0x56, 0xa1, 0x7c, 0x8a,
0xcf, 0xb4, 0x8d, 0xc5, 0x4f, 0x91, 0xe3, 0x5f, 0x09, 0x80, 0x68, 0x6a, 0xbf, 0x77, 0x6e, 0xd2,
0xec, 0x53, 0x47, 0x69, 0xff, 0xa4, 0xf4, 0xa1, 0x61, 0x9f, 0xc1, 0xea, 0x5e, 0x48, 0x47, 0x17,
0x4e, 0x97, 0x36, 0xd4, 0x52, 0xf5, 0x6f, 0x1c, 0xa1, 0x19, 0xd9, 0xac, 0x18, 0xfd, 0x0c, 0xd6,
0xf6, 0x30, 0xeb, 0x85, 0xa4, 0x7b, 0xf1, 0x6c, 0x3d, 0xa3, 0xa4, 0xf8, 0xca, 0x80, 0x77, 0x72,
0x7b, 0x5f, 0xc5, 0xc7, 0x3f, 0xcf, 0x22, 0x4f, 0xb9, 0x78, 0x46, 0xbb, 0x92, 0x46, 0x9c, 0x27,
0xa9, 0x52, 0xce, 0xed, 0x88, 0xf4, 0x70, 0x14, 0xd2, 0x63, 0x59, 0x08, 0x5e, 0xdf, 0x8b, 0xff,
0x64, 0xc0, 0xdd, 0x29, 0x67, 0x5c, 0xe5, 0xe5, 0xf9, 0xce, 0xb6, 0x34, 0xab, 0xb3, 0x2d, 0xe7,
0x3a, 0x5b, 0xfb, 0xaf, 0x25, 0xa8, 0x77, 0x38, 0x0d, 0xbd, 0x63, 0xbc, 0x4b, 0x83, 0x3e, 0x39,
0x16, 0x39, 0x33, 0x2e, 0x96, 0x0d, 0xf9, 0x8c, 0xa4, 0x1c, 0xbe, 0x0f, 0x35, 0xaf, 0xd7, 0xc3,
0x8c, 0xb9, 0xa7, 0xf8, 0x4c, 0x67, 0x09, 0xd3, 0xb1, 0x94, 0xec, 0xb9, 0x10, 0x89, 0x36, 0x83,
0xe1, 0x5e, 0x88, 0xb9, 0x3b, 0xd6, 0xd4, 0xd0, 0x5a, 0x51, 0x13, 0xdb, 0xb1, 0xb6, 0xa8, 0xae,
0x23, 0x86, 0x3b, 0x9d, 0x4f, 0x64, 0x6e, 0xae, 0x3a, 0x7a, 0x24, 0x6a, 0x9b, 0x6e, 0xd4, 0x3b,
0xc5, 0x3c, 0x9d, 0x9b, 0x41, 0x89, 0x64, 0x72, 0xbe, 0x0d, 0x66, 0x48, 0x29, 0x97, 0x09, 0x55,
0x12, 0xa9, 0xe9, 0x54, 0x85, 0x40, 0xa4, 0x13, 0xbd, 0x6b, 0x7b, 0xfb, 0x40, 0x13, 0xa8, 0x1e,
0x89, 0x26, 0xb1, 0xbd, 0x7d, 0xf0, 0x51, 0xe0, 0x8f, 0x28, 0x09, 0xb8, 0xcc, 0xae, 0xa6, 0x93,
0x16, 0x89, 0xe7, 0x31, 0x65, 0x09, 0x57, 0x70, 0xbf, 0xcc, 0xac, 0xa6, 0x63, 0x69, 0xd9, 0x8b,
0xb3, 0x11, 0xb6, 0xff, 0x5b, 0x86, 0x55, 0x55, 0xc0, 0xec, 0xd3, 0x6e, 0x0c, 0x8f, 0x3b, 0x60,
0xf6, 0x06, 0x91, 0xe8, 0x05, 0x34, 0x36, 0x4c, 0x67, 0x2c, 0xc8, 0x36, 0x5e, 0xee, 0x28, 0xc4,
0x7d, 0xf2, 0x46, 0x5b, 0x6e, 0xdc, 0x78, 0x1d, 0x49, 0x71, 0x9a, 0xae, 0xca, 0x13, 0x74, 0xe5,
0x7b, 0xdc, 0xd3, 0x1c, 0x52, 0x91, 0x1c, 0x62, 0x0a, 0x89, 0xa2, 0x8f, 0x09, 0x56, 0x58, 0x28,
0x68, 0x2d, 0x53, 0x34, 0xb9, 0x98, 0xa5, 0xc9, 0x2c, 0x78, 0x97, 0xf2, 0x64, 0xf8, 0x31, 0x2c,
0xc7, 0x86, 0xe9, 0x49, 0x8c, 0x48, 0xeb, 0x15, 0xf4, 0x28, 0x32, 0x91, 0xa5, 0xc1, 0xe4, 0xd4,
0x59, 0x06, 0x5b, 0x79, 0x5a, 0x35, 0x2f, 0x45, 0xab, 0xb9, 0x92, 0x0e, 0x2e, 0x53, 0xd2, 0xa5,
0x7b, 0x7e, 0x2b, 0xd3, 0xf3, 0xdb, 0x9f, 0xc0, 0xea, 0x2f, 0x22, 0x1c, 0x9e, 0xed, 0xd3, 0x2e,
0x9b, 0xcf, 0xc7, 0x4d, 0xa8, 0x6a, 0x47, 0xc5, 0x99, 0x36, 0x19, 0xdb, 0xff, 0x32, 0xa0, 0x2e,
0xc3, 0xfe, 0x85, 0xc7, 0x4e, 0xe3, 0xcf, 0x23, 0xb1, 0x97, 0x8d, 0xac, 0x97, 0x2f, 0xdf, 0x0c,
0xa4, 0x7a, 0x7b, 0xd9, 0x98, 0x98, 0x3a, 0xc1, 0xc9, 0xae, 0xbe, 0xa8, 0xba, 0xa8, 0x14, 0x56,
0x17, 0xb9, 0xb6, 0x62, 0x61, 0xa2, 0xad, 0xf8, 0xda, 0x80, 0x9b, 0x29, 0xe3, 0x5c, 0x25, 0x77,
0x65, 0x4c, 0x5a, 0xca, 0x9b, 0x74, 0x27, 0x9b, 0xd3, 0xcb, 0x45, 0x3e, 0x4e, 0xe5, 0xf4, 0xd8,
0xb8, 0x99, 0xbc, 0xfe, 0x1c, 0x56, 0x04, 0x79, 0x5e, 0x8f, 0x1f, 0xff, 0x6d, 0xc0, 0xd2, 0x3e,
0xed, 0x4a, 0x0f, 0xa6, 0xc1, 0x63, 0x64, 0x3f, 0x18, 0xad, 0x42, 0xd9, 0x27, 0x43, 0x9d, 0x88,
0xc5, 0x4f, 0x11, 0x5c, 0x8c, 0x7b, 0x21, 0x1f, 0x7f, 0xf2, 0x12, 0x95, 0x95, 0x90, 0xc8, 0x2f,
0x26, 0xef, 0x42, 0x15, 0x07, 0xbe, 0x9a, 0xd4, 0x35, 0x2a, 0x0e, 0x7c, 0x39, 0x75, 0x3d, 0x6d,
0xc7, 0x1a, 0x2c, 0x8c, 0xe8, 0xf8, 0x33, 0x95, 0x1a, 0xd8, 0x6b, 0x80, 0x9e, 0x61, 0xbe, 0x4f,
0xbb, 0xc2, 0x2b, 0xb1, 0x79, 0xec, 0x7f, 0x96, 0x64, 0x4b, 0x30, 0x16, 0x5f, 0xc5, 0xc1, 0x36,
0xd4, 0x15, 0xf3, 0x7c, 0x41, 0xbb, 0x6e, 0x10, 0xc5, 0x46, 0xb1, 0xa4, 0x70, 0x9f, 0x76, 0x0f,
0xa3, 0x21, 0x7a, 0x0f, 0x6e, 0x91, 0xc0, 0x1d, 0x69, 0x32, 0x4c, 0x34, 0x95, 0x95, 0x56, 0x49,
0x10, 0xd3, 0xa4, 0x56, 0x7f, 0x04, 0x2b, 0x38, 0x78, 0x19, 0xe1, 0x08, 0x27, 0xaa, 0xca, 0x66,
0x75, 0x2d, 0xd6, 0x7a, 0x82, 0xf4, 0x3c, 0x76, 0xea, 0xb2, 0x01, 0xe5, 0x4c, 0x27, 0x43, 0x53,
0x48, 0x3a, 0x42, 0x80, 0x3e, 0x04, 0x53, 0x2c, 0x57, 0xd0, 0x52, 0xa5, 0xfd, 0xed, 0x22, 0x68,
0x69, 0x7f, 0x3b, 0xd5, 0x2f, 0xd4, 0x0f, 0x26, 0x02, 0x44, 0xd7, 0xc1, 0x3e, 0x61, 0xa7, 0x9a,
0x62, 0x40, 0x89, 0xf6, 0x08, 0x3b, 0xdd, 0xfa, 0xda, 0x04, 0x90, 0x88, 0xdc, 0xa5, 0x34, 0xf4,
0xd1, 0x48, 0x9a, 0x79, 0x97, 0x0e, 0x47, 0x34, 0xc0, 0x01, 0x97, 0x61, 0xcb, 0xd0, 0x93, 0x29,
0x1f, 0x77, 0x26, 0x55, 0xb5, 0x63, 0x9a, 0x8f, 0xa6, 0xac, 0xc8, 0xa9, 0xdb, 0x37, 0xd0, 0x4b,
0x59, 0x3d, 0x8b, 0x21, 0x61, 0x9c, 0xf4, 0xd8, 0xee, 0x89, 0x17, 0x04, 0x78, 0x80, 0xb6, 0xa6,
0x9f, 0x39, 0xa1, 0x1c, 0x9f, 0xfa, 0x20, 0xbb, 0x46, 0x0f, 0x3a, 0x3c, 0x24, 0xc1, 0x71, 0x8c,
0x0d, 0xfb, 0x06, 0x7a, 0x01, 0x56, 0xaa, 0xab, 0x47, 0x8f, 0x8a, 0x4c, 0x39, 0xd9, 0xf6, 0x37,
0xcf, 0x03, 0x91, 0x7d, 0x03, 0xf5, 0xa1, 0x9e, 0xf9, 0xec, 0x84, 0x5a, 0xe7, 0x15, 0xed, 0xe9,
0x6f, 0x3d, 0xcd, 0xef, 0xcd, 0xa1, 0x99, 0xdc, 0xfe, 0xd7, 0xca, 0x60, 0x13, 0xdf, 0x6d, 0x36,
0xa7, 0x6c, 0x32, 0xed, 0x0b, 0x53, 0xf3, 0xc9, 0xfc, 0x0b, 0x92, 0xc3, 0xfd, 0xf1, 0x23, 0x15,
0xc0, 0x1e, 0xcf, 0xee, 0x4c, 0xd4, 0x69, 0xad, 0x79, 0x5b, 0x18, 0xfb, 0x06, 0x3a, 0x02, 0x33,
0xe9, 0x22, 0xd0, 0x77, 0x8b, 0x16, 0xe6, 0x9b, 0x8c, 0x39, 0x9c, 0x93, 0x29, 0xe0, 0x8b, 0x9d,
0x53, 0xd4, 0x3f, 0x14, 0x3b, 0xa7, 0xb0, 0x1b, 0xb0, 0x6f, 0xa0, 0xdf, 0x8c, 0xbf, 0x3d, 0x66,
0xca, 0x66, 0xf4, 0xe4, 0xbc, 0xe7, 0x17, 0x55, 0xf1, 0xcd, 0x1f, 0x5c, 0x60, 0x45, 0x0a, 0x1c,
0xa8, 0x73, 0x42, 0x5f, 0xab, 0xf2, 0x25, 0x0a, 0x3d, 0x51, 0xed, 0x4f, 0x8f, 0xdf, 0x49, 0xd5,
0xa9, 0x87, 0x9f, 0xb3, 0x22, 0x39, 0xdc, 0x05, 0x78, 0x86, 0xf9, 0x01, 0xe6, 0x21, 0xe9, 0xb1,
0x7c, 0x58, 0xe9, 0xc1, 0x58, 0x21, 0x3e, 0xea, 0xf1, 0x4c, 0xbd, 0xf8, 0x80, 0xad, 0xbf, 0x2d,
0xea, 0xff, 0x09, 0x0f, 0xa9, 0x8f, 0xbf, 0x19, 0xb9, 0xea, 0x08, 0xcc, 0xa4, 0x80, 0x2f, 0x0e,
0x85, 0x7c, 0x7d, 0x3f, 0x2b, 0x14, 0x3e, 0x07, 0x33, 0xa9, 0x88, 0x8a, 0x77, 0xcc, 0x57, 0x93,
0xcd, 0x87, 0x33, 0xb4, 0x92, 0xdb, 0x1e, 0x42, 0x35, 0xae, 0x60, 0xd0, 0x83, 0x69, 0x71, 0x9b,
0xde, 0x79, 0xc6, 0x5d, 0x7f, 0x05, 0x56, 0x8a, 0xde, 0x8b, 0x33, 0xf5, 0x64, 0x59, 0xd0, 0x7c,
0x3c, 0x53, 0xef, 0x9b, 0x11, 0x30, 0x3b, 0x3f, 0xfc, 0x7c, 0xeb, 0x98, 0xf0, 0x93, 0xa8, 0x2b,
0x2c, 0xbb, 0xa9, 0x34, 0xdf, 0x23, 0x54, 0xff, 0xda, 0x8c, 0x6f, 0xb9, 0x29, 0x77, 0xda, 0x94,
0x76, 0x1a, 0x75, 0xbb, 0x8b, 0x72, 0xf8, 0xfe, 0xff, 0x02, 0x00, 0x00, 0xff, 0xff, 0x8f, 0x26,
0xb1, 0x27, 0xea, 0x1f, 0x00, 0x00,
// 2138 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x59, 0x4f, 0x6f, 0x1b, 0xc7,
0x15, 0xf7, 0x92, 0x94, 0xc4, 0x7d, 0x4b, 0x4a, 0xf2, 0x58, 0x69, 0x19, 0xda, 0xae, 0xe5, 0x75,
0x1c, 0xb3, 0x05, 0x22, 0xb9, 0x4a, 0x53, 0xa4, 0x45, 0x5b, 0x40, 0x7f, 0x62, 0x87, 0x72, 0x24,
0xa8, 0x4b, 0x23, 0x40, 0x82, 0x02, 0xdb, 0x25, 0x77, 0x28, 0x4d, 0x44, 0xee, 0xd0, 0x3b, 0xb3,
0xb6, 0xe5, 0x02, 0x45, 0x2f, 0x3d, 0xa4, 0x08, 0x50, 0xa0, 0x87, 0xf6, 0x0b, 0x14, 0x3d, 0xa4,
0x87, 0xde, 0x7b, 0xe9, 0x07, 0x68, 0x3f, 0x42, 0x4f, 0xfd, 0x24, 0xc5, 0xfc, 0xd9, 0xe5, 0xee,
0x72, 0x29, 0x52, 0x7f, 0x7a, 0x69, 0x6e, 0x9c, 0x37, 0x6f, 0xfe, 0xbd, 0xf7, 0x7b, 0xef, 0xf7,
0xde, 0x12, 0x6e, 0x92, 0xc0, 0xc7, 0xaf, 0xdd, 0x1e, 0xa5, 0xa1, 0xbf, 0x31, 0x0a, 0x29, 0xa7,
0x08, 0x0d, 0xc9, 0xe0, 0x65, 0xc4, 0xd4, 0x68, 0x43, 0xce, 0x37, 0x6b, 0x3d, 0x3a, 0x1c, 0xd2,
0x40, 0xc9, 0x9a, 0xcb, 0x24, 0xe0, 0x38, 0x0c, 0xbc, 0x81, 0x1e, 0xd7, 0xd2, 0x2b, 0xec, 0xbf,
0x55, 0xc0, 0x6c, 0x8b, 0x55, 0xed, 0xa0, 0x4f, 0x91, 0x0d, 0xb5, 0x1e, 0x1d, 0x0c, 0x70, 0x8f,
0x13, 0x1a, 0xb4, 0xf7, 0x1a, 0xc6, 0xba, 0xd1, 0x2a, 0x3b, 0x19, 0x19, 0x6a, 0xc0, 0x52, 0x9f,
0xe0, 0x81, 0xdf, 0xde, 0x6b, 0x94, 0xe4, 0x74, 0x3c, 0x44, 0x77, 0x01, 0xd4, 0x05, 0x03, 0x6f,
0x88, 0x1b, 0xe5, 0x75, 0xa3, 0x65, 0x3a, 0xa6, 0x94, 0x1c, 0x7a, 0x43, 0x2c, 0x16, 0xca, 0x41,
0x7b, 0xaf, 0x51, 0x51, 0x0b, 0xf5, 0x10, 0xed, 0x80, 0xc5, 0xcf, 0x46, 0xd8, 0x1d, 0x79, 0xa1,
0x37, 0x64, 0x8d, 0x85, 0xf5, 0x72, 0xcb, 0xda, 0xba, 0xbf, 0x91, 0x79, 0x9a, 0x7e, 0xd3, 0x33,
0x7c, 0xf6, 0xa9, 0x37, 0x88, 0xf0, 0x91, 0x47, 0x42, 0x07, 0xc4, 0xaa, 0x23, 0xb9, 0x08, 0xed,
0x41, 0x4d, 0x1d, 0xae, 0x37, 0x59, 0x9c, 0x77, 0x13, 0x4b, 0x2e, 0xd3, 0xbb, 0xdc, 0xd7, 0xbb,
0x60, 0xdf, 0x0d, 0xe9, 0x2b, 0xd6, 0x58, 0x92, 0x17, 0xb5, 0xb4, 0xcc, 0xa1, 0xaf, 0x98, 0x78,
0x25, 0xa7, 0xdc, 0x1b, 0x28, 0x85, 0xaa, 0x54, 0x30, 0xa5, 0x44, 0x4e, 0x7f, 0x00, 0x0b, 0x8c,
0x7b, 0x1c, 0x37, 0xcc, 0x75, 0xa3, 0xb5, 0xbc, 0x75, 0xaf, 0xf0, 0x02, 0xd2, 0xe2, 0x1d, 0xa1,
0xe6, 0x28, 0x6d, 0xf4, 0x01, 0x7c, 0x5b, 0x5d, 0x5f, 0x0e, 0xdd, 0xbe, 0x47, 0x06, 0x6e, 0x88,
0x3d, 0x46, 0x83, 0x06, 0x48, 0x43, 0xae, 0x91, 0x64, 0xcd, 0x13, 0x8f, 0x0c, 0x1c, 0x39, 0x87,
0x6c, 0xa8, 0x13, 0xe6, 0x7a, 0x11, 0xa7, 0xae, 0x9c, 0x6f, 0x58, 0xeb, 0x46, 0xab, 0xea, 0x58,
0x84, 0x6d, 0x47, 0x9c, 0xca, 0x63, 0xd0, 0x01, 0xdc, 0x8c, 0x18, 0x0e, 0xdd, 0x8c, 0x79, 0x6a,
0xf3, 0x9a, 0x67, 0x45, 0xac, 0x6d, 0x8f, 0x4d, 0x64, 0xff, 0xd6, 0x00, 0x78, 0x22, 0x3d, 0x2e,
0x77, 0xff, 0x49, 0xec, 0x74, 0x12, 0xf4, 0xa9, 0x04, 0x8c, 0xb5, 0x75, 0x77, 0x63, 0x12, 0x95,
0x1b, 0x09, 0xca, 0x34, 0x26, 0x24, 0xe0, 0x1a, 0xb0, 0xe4, 0xe3, 0x01, 0xe6, 0xd8, 0x97, 0x60,
0xaa, 0x3a, 0xf1, 0x10, 0xdd, 0x03, 0xab, 0x17, 0x62, 0x61, 0x0b, 0x4e, 0x34, 0x9a, 0x2a, 0x0e,
0x28, 0xd1, 0x73, 0x32, 0xc4, 0xf6, 0x97, 0x15, 0xa8, 0x75, 0xf0, 0xf1, 0x10, 0x07, 0x5c, 0xdd,
0x64, 0x1e, 0xf0, 0xae, 0x83, 0x35, 0xf2, 0x42, 0x4e, 0xb4, 0x8a, 0x02, 0x70, 0x5a, 0x84, 0xee,
0x80, 0xc9, 0xf4, 0xae, 0x7b, 0xf2, 0xd4, 0xb2, 0x33, 0x16, 0xa0, 0xb7, 0xa1, 0x1a, 0x44, 0x43,
0xe5, 0x7a, 0x0d, 0xe2, 0x20, 0x1a, 0x4a, 0xc7, 0xa7, 0xe0, 0xbd, 0x90, 0x85, 0x77, 0x03, 0x96,
0xba, 0x11, 0x91, 0x11, 0xb3, 0xa8, 0x66, 0xf4, 0x10, 0x7d, 0x0b, 0x16, 0x03, 0xea, 0xe3, 0xf6,
0x9e, 0x06, 0x9a, 0x1e, 0xa1, 0x07, 0x50, 0x57, 0x46, 0x7d, 0x89, 0x43, 0x46, 0x68, 0xa0, 0x61,
0xa6, 0xb0, 0xf9, 0xa9, 0x92, 0x5d, 0x16, 0x69, 0xf7, 0xc0, 0x9a, 0x44, 0x17, 0xf4, 0xc7, 0x98,
0xfa, 0x5e, 0x9c, 0x67, 0xfa, 0x64, 0x80, 0x99, 0x3b, 0xf2, 0xf8, 0x09, 0x6b, 0x58, 0xeb, 0xe5,
0x96, 0xe9, 0xac, 0xc8, 0x89, 0x27, 0x42, 0x7e, 0x24, 0xc4, 0x69, 0xff, 0xd5, 0xce, 0xf5, 0x5f,
0x3d, 0xef, 0x3f, 0xf4, 0x10, 0x96, 0x19, 0x0e, 0x89, 0x37, 0x20, 0x6f, 0xb0, 0xcb, 0xc8, 0x1b,
0xdc, 0x58, 0x96, 0x3a, 0xf5, 0x44, 0xda, 0x21, 0x6f, 0xb0, 0x30, 0xc5, 0xab, 0x90, 0x70, 0xec,
0x9e, 0x78, 0x81, 0x4f, 0xfb, 0xfd, 0xc6, 0x8a, 0x3c, 0xa7, 0x26, 0x85, 0x1f, 0x2b, 0x99, 0xfd,
0x27, 0x03, 0x6e, 0x39, 0xf8, 0x98, 0x30, 0x8e, 0xc3, 0x43, 0xea, 0x63, 0x07, 0xbf, 0x88, 0x30,
0xe3, 0xe8, 0x31, 0x54, 0xba, 0x1e, 0xc3, 0x1a, 0x96, 0x77, 0x0a, 0x2d, 0x74, 0xc0, 0x8e, 0x77,
0x3c, 0x86, 0x1d, 0xa9, 0x89, 0x7e, 0x08, 0x4b, 0x9e, 0xef, 0x87, 0x98, 0x31, 0x09, 0x8e, 0x69,
0x8b, 0xb6, 0x95, 0x8e, 0x13, 0x2b, 0xa7, 0x3c, 0x59, 0x4e, 0x7b, 0xd2, 0xfe, 0xbd, 0x01, 0x6b,
0xd9, 0x9b, 0xb1, 0x11, 0x0d, 0x18, 0x46, 0xef, 0xc3, 0xa2, 0xf0, 0x47, 0xc4, 0xf4, 0xe5, 0x6e,
0x17, 0x9e, 0xd3, 0x91, 0x2a, 0x8e, 0x56, 0x15, 0x89, 0x92, 0x04, 0x84, 0xc7, 0x41, 0xac, 0x6e,
0x78, 0x3f, 0x1f, 0x6d, 0x3a, 0xdd, 0xb7, 0x03, 0xc2, 0x55, 0xcc, 0x3a, 0x40, 0x92, 0xdf, 0xf6,
0x67, 0xb0, 0xf6, 0x14, 0xf3, 0x14, 0x2e, 0xb4, 0xad, 0xe6, 0x09, 0x9f, 0x6c, 0x86, 0x2f, 0xe5,
0x32, 0xbc, 0xfd, 0x67, 0x03, 0xde, 0xca, 0xed, 0x7d, 0x95, 0xd7, 0x26, 0x00, 0x2f, 0x5d, 0x05,
0xe0, 0xe5, 0x3c, 0xc0, 0xed, 0xdf, 0x18, 0x70, 0xfb, 0x29, 0xe6, 0xe9, 0xe4, 0x71, 0xcd, 0x96,
0x40, 0xdf, 0x01, 0x48, 0x92, 0x06, 0x6b, 0x94, 0xd7, 0xcb, 0xad, 0xb2, 0x93, 0x92, 0xd8, 0x5f,
0x1a, 0x70, 0x73, 0xe2, 0xfc, 0x6c, 0xee, 0x31, 0xf2, 0xb9, 0xe7, 0x7f, 0x65, 0x8e, 0x3f, 0x18,
0x70, 0xa7, 0xd8, 0x1c, 0x57, 0x71, 0xde, 0x4f, 0xd5, 0x22, 0x2c, 0x50, 0x2a, 0xa8, 0xe6, 0x61,
0x11, 0x27, 0x4c, 0x9e, 0xa9, 0x17, 0xd9, 0x5f, 0x95, 0x01, 0xed, 0xca, 0x64, 0x21, 0x27, 0x2f,
0xe2, 0x9a, 0x4b, 0x17, 0x28, 0xb9, 0x32, 0xa4, 0x72, 0x1d, 0x65, 0xc8, 0xc2, 0xa5, 0xca, 0x90,
0x3b, 0x60, 0x8a, 0xac, 0xc9, 0xb8, 0x37, 0x1c, 0x49, 0xce, 0xa8, 0x38, 0x63, 0xc1, 0x24, 0xe9,
0x2f, 0xcd, 0x49, 0xfa, 0xd5, 0x4b, 0x93, 0xfe, 0x6b, 0xb8, 0x15, 0x07, 0xb6, 0xa4, 0xf0, 0x0b,
0xb8, 0x23, 0x1b, 0x0a, 0xa5, 0x7c, 0x28, 0xcc, 0x70, 0x8a, 0xfd, 0xef, 0x12, 0xdc, 0x6c, 0xc7,
0xac, 0x23, 0x48, 0x47, 0xd6, 0x0d, 0xe7, 0x47, 0xca, 0x74, 0x04, 0xa4, 0x48, 0xba, 0x3c, 0x95,
0xa4, 0x2b, 0x59, 0x92, 0xce, 0x5e, 0x70, 0x21, 0x8f, 0x9a, 0xeb, 0x29, 0x3c, 0x5b, 0xb0, 0x3a,
0x26, 0x5d, 0xcd, 0xb9, 0x4b, 0x92, 0x73, 0x97, 0x49, 0xfa, 0xf5, 0x0c, 0x3d, 0x82, 0x95, 0x84,
0x21, 0x7d, 0x45, 0x9c, 0x55, 0x89, 0x90, 0x31, 0x9d, 0xfa, 0x31, 0x73, 0x66, 0x8b, 0x08, 0x73,
0xb2, 0x88, 0xb0, 0xff, 0x6e, 0x80, 0x95, 0x44, 0xe1, 0x9c, 0x1d, 0x40, 0xc6, 0xf8, 0xa5, 0xbc,
0xf1, 0xef, 0x43, 0x0d, 0x07, 0x5e, 0x77, 0x80, 0x35, 0x38, 0xcb, 0x0a, 0x9c, 0x4a, 0xa6, 0xc0,
0xf9, 0x04, 0xac, 0x71, 0xcd, 0x18, 0x07, 0xda, 0xc3, 0xa9, 0x45, 0x63, 0xda, 0xf3, 0x0e, 0x24,
0xc5, 0x23, 0xb3, 0x7f, 0x57, 0x1a, 0x73, 0x99, 0x82, 0xe5, 0x55, 0x32, 0xd6, 0x2f, 0xa0, 0xa6,
0x5f, 0xa1, 0x6a, 0x59, 0x95, 0xb7, 0x7e, 0x54, 0x74, 0xad, 0xa2, 0x43, 0x37, 0x52, 0x66, 0xfc,
0x28, 0xe0, 0xe1, 0x99, 0x63, 0xb1, 0xb1, 0xa4, 0xe9, 0xc2, 0x6a, 0x5e, 0x01, 0xad, 0x42, 0xf9,
0x14, 0x9f, 0x69, 0x1b, 0x8b, 0x9f, 0x22, 0xc7, 0xbf, 0x14, 0x00, 0xd1, 0xd4, 0x7e, 0xef, 0xdc,
0xa4, 0xd9, 0xa7, 0x8e, 0xd2, 0xfe, 0x71, 0xe9, 0x43, 0xc3, 0x3e, 0x83, 0xd5, 0xbd, 0x90, 0x8e,
0x2e, 0x9c, 0x2e, 0x6d, 0xa8, 0xa5, 0xea, 0xdf, 0x38, 0x42, 0x33, 0xb2, 0x59, 0x31, 0xfa, 0x19,
0xac, 0xed, 0x61, 0xd6, 0x0b, 0x49, 0xf7, 0xe2, 0xd9, 0x7a, 0x46, 0x49, 0xf1, 0x95, 0x01, 0x6f,
0xe5, 0xf6, 0xbe, 0x8a, 0x8f, 0x7f, 0x96, 0x45, 0x9e, 0x72, 0xf1, 0x8c, 0x76, 0x25, 0x8d, 0x38,
0x4f, 0x52, 0xa5, 0x9c, 0xdb, 0x11, 0xe9, 0xe1, 0x28, 0xa4, 0xc7, 0xb2, 0x10, 0xbc, 0xbe, 0x17,
0xff, 0xd1, 0x80, 0xbb, 0x53, 0xce, 0xb8, 0xca, 0xcb, 0xf3, 0x9d, 0x6d, 0x69, 0x56, 0x67, 0x5b,
0xce, 0x75, 0xb6, 0xf6, 0x5f, 0x4b, 0x50, 0xef, 0x70, 0x1a, 0x7a, 0xc7, 0x78, 0x97, 0x06, 0x7d,
0x72, 0x2c, 0x72, 0x66, 0x5c, 0x2c, 0x1b, 0xf2, 0x19, 0x49, 0x39, 0x7c, 0x1f, 0x6a, 0x5e, 0xaf,
0x87, 0x19, 0x73, 0x4f, 0xf1, 0x99, 0xce, 0x12, 0xa6, 0x63, 0x29, 0xd9, 0x33, 0x21, 0x12, 0x6d,
0x06, 0xc3, 0xbd, 0x10, 0x73, 0x77, 0xac, 0xa9, 0xa1, 0xb5, 0xa2, 0x26, 0xb6, 0x63, 0x6d, 0x51,
0x5d, 0x47, 0x0c, 0x77, 0x3a, 0x9f, 0xc8, 0xdc, 0x5c, 0x75, 0xf4, 0x48, 0xd4, 0x36, 0xdd, 0xa8,
0x77, 0x8a, 0x79, 0x3a, 0x37, 0x83, 0x12, 0xc9, 0xe4, 0x7c, 0x1b, 0xcc, 0x90, 0x52, 0x2e, 0x13,
0xaa, 0x24, 0x52, 0xd3, 0xa9, 0x0a, 0x81, 0x48, 0x27, 0x7a, 0xd7, 0xf6, 0xf6, 0x81, 0x26, 0x50,
0x3d, 0x12, 0x4d, 0x62, 0x7b, 0xfb, 0xe0, 0xa3, 0xc0, 0x1f, 0x51, 0x12, 0x70, 0x99, 0x5d, 0x4d,
0x27, 0x2d, 0x12, 0xcf, 0x63, 0xca, 0x12, 0xae, 0xe0, 0x7e, 0x99, 0x59, 0x4d, 0xc7, 0xd2, 0xb2,
0xe7, 0x67, 0x23, 0x6c, 0xff, 0xa7, 0x0c, 0xab, 0xaa, 0x80, 0xd9, 0xa7, 0xdd, 0x18, 0x1e, 0x77,
0xc0, 0xec, 0x0d, 0x22, 0xd1, 0x0b, 0x68, 0x6c, 0x98, 0xce, 0x58, 0x90, 0x6d, 0xbc, 0xdc, 0x51,
0x88, 0xfb, 0xe4, 0xb5, 0xb6, 0xdc, 0xb8, 0xf1, 0x3a, 0x92, 0xe2, 0x34, 0x5d, 0x95, 0x27, 0xe8,
0xca, 0xf7, 0xb8, 0xa7, 0x39, 0xa4, 0x22, 0x39, 0xc4, 0x14, 0x12, 0x45, 0x1f, 0x13, 0xac, 0xb0,
0x50, 0xd0, 0x5a, 0xa6, 0x68, 0x72, 0x31, 0x4b, 0x93, 0x59, 0xf0, 0x2e, 0xe5, 0xc9, 0xf0, 0x63,
0x58, 0x8e, 0x0d, 0xd3, 0x93, 0x18, 0x91, 0xd6, 0x2b, 0xe8, 0x51, 0x64, 0x22, 0x4b, 0x83, 0xc9,
0xa9, 0xb3, 0x0c, 0xb6, 0xf2, 0xb4, 0x6a, 0x5e, 0x8a, 0x56, 0x73, 0x25, 0x1d, 0x5c, 0xa6, 0xa4,
0x4b, 0xf7, 0xfc, 0x56, 0xa6, 0xe7, 0xb7, 0x3f, 0x81, 0xd5, 0x9f, 0x47, 0x38, 0x3c, 0xdb, 0xa7,
0x5d, 0x36, 0x9f, 0x8f, 0x9b, 0x50, 0xd5, 0x8e, 0x8a, 0x33, 0x6d, 0x32, 0xb6, 0xff, 0x69, 0x40,
0x5d, 0x86, 0xfd, 0x73, 0x8f, 0x9d, 0xc6, 0x9f, 0x47, 0x62, 0x2f, 0x1b, 0x59, 0x2f, 0x5f, 0xbe,
0x19, 0x48, 0xf5, 0xf6, 0xb2, 0x31, 0x31, 0x75, 0x82, 0x93, 0x5d, 0x7d, 0x51, 0x75, 0x51, 0x29,
0xac, 0x2e, 0x72, 0x6d, 0xc5, 0xc2, 0x44, 0x5b, 0xf1, 0xb5, 0x01, 0x37, 0x53, 0xc6, 0xb9, 0x4a,
0xee, 0xca, 0x98, 0xb4, 0x94, 0x37, 0xe9, 0x4e, 0x36, 0xa7, 0x97, 0x8b, 0x7c, 0x9c, 0xca, 0xe9,
0xb1, 0x71, 0x33, 0x79, 0xfd, 0x19, 0xac, 0x08, 0xf2, 0xbc, 0x1e, 0x3f, 0xfe, 0xcb, 0x80, 0xa5,
0x7d, 0xda, 0x95, 0x1e, 0x4c, 0x83, 0xc7, 0xc8, 0x7e, 0x30, 0x5a, 0x85, 0xb2, 0x4f, 0x86, 0x3a,
0x11, 0x8b, 0x9f, 0x22, 0xb8, 0x18, 0xf7, 0x42, 0x3e, 0xfe, 0xe4, 0x25, 0x2a, 0x2b, 0x21, 0x91,
0x5f, 0x4c, 0xde, 0x86, 0x2a, 0x0e, 0x7c, 0x35, 0xa9, 0x6b, 0x54, 0x1c, 0xf8, 0x72, 0xea, 0x7a,
0xda, 0x8e, 0x35, 0x58, 0x18, 0xd1, 0xf1, 0x67, 0x2a, 0x35, 0xb0, 0xd7, 0x00, 0x3d, 0xc5, 0x7c,
0x9f, 0x76, 0x85, 0x57, 0x62, 0xf3, 0xd8, 0xff, 0x28, 0xc9, 0x96, 0x60, 0x2c, 0xbe, 0x8a, 0x83,
0x6d, 0xa8, 0x2b, 0xe6, 0xf9, 0x82, 0x76, 0xdd, 0x20, 0x8a, 0x8d, 0x62, 0x49, 0xe1, 0x3e, 0xed,
0x1e, 0x46, 0x43, 0xf4, 0x1e, 0xdc, 0x22, 0x81, 0x3b, 0xd2, 0x64, 0x98, 0x68, 0x2a, 0x2b, 0xad,
0x92, 0x20, 0xa6, 0x49, 0xad, 0xfe, 0x2e, 0xac, 0xe0, 0xe0, 0x45, 0x84, 0x23, 0x9c, 0xa8, 0x2a,
0x9b, 0xd5, 0xb5, 0x58, 0xeb, 0x09, 0xd2, 0xf3, 0xd8, 0xa9, 0xcb, 0x06, 0x94, 0x33, 0x9d, 0x0c,
0x4d, 0x21, 0xe9, 0x08, 0x01, 0xfa, 0x10, 0x4c, 0xb1, 0x5c, 0x41, 0x4b, 0x95, 0xf6, 0xb7, 0x8b,
0xa0, 0xa5, 0xfd, 0xed, 0x54, 0xbf, 0x50, 0x3f, 0x98, 0x08, 0x10, 0x5d, 0x07, 0xfb, 0x84, 0x9d,
0x6a, 0x8a, 0x01, 0x25, 0xda, 0x23, 0xec, 0x74, 0xeb, 0x2f, 0x26, 0x80, 0x44, 0xe4, 0x2e, 0xa5,
0xa1, 0x8f, 0x06, 0xd2, 0xcc, 0xbb, 0x74, 0x38, 0xa2, 0x01, 0x0e, 0xb8, 0x0c, 0x5b, 0x86, 0x36,
0xb2, 0x87, 0xe9, 0xc1, 0xa4, 0xa2, 0x76, 0x4b, 0xf3, 0x9d, 0x42, 0xfd, 0x9c, 0xb2, 0x7d, 0x03,
0xbd, 0x90, 0x95, 0xb3, 0x18, 0x12, 0xc6, 0x49, 0x8f, 0xed, 0x9e, 0x78, 0x41, 0x80, 0x07, 0x68,
0x6b, 0xca, 0xc7, 0xa4, 0x22, 0xe5, 0xf8, 0xcc, 0x07, 0x85, 0x67, 0x76, 0x78, 0x48, 0x82, 0xe3,
0x18, 0x17, 0xf6, 0x0d, 0xf4, 0x1c, 0xac, 0x54, 0x47, 0x8f, 0xde, 0x2d, 0x32, 0xe3, 0x64, 0xcb,
0xdf, 0x3c, 0x0f, 0x40, 0xf6, 0x0d, 0xd4, 0x87, 0x7a, 0xe6, 0x93, 0x13, 0x6a, 0x9d, 0x57, 0xb0,
0xa7, 0xbf, 0xf3, 0x34, 0xbf, 0x3b, 0x87, 0x66, 0x72, 0xfb, 0x5f, 0x29, 0x83, 0x4d, 0x7c, 0xb3,
0xd9, 0x9c, 0xb2, 0xc9, 0xb4, 0xaf, 0x4b, 0xcd, 0xc7, 0xf3, 0x2f, 0x48, 0x0e, 0xf7, 0xc7, 0x8f,
0x54, 0xe0, 0x7a, 0x34, 0xbb, 0x2b, 0x51, 0xa7, 0xb5, 0xe6, 0x6d, 0x5f, 0xec, 0x1b, 0xe8, 0x08,
0xcc, 0xa4, 0x83, 0x40, 0xef, 0x14, 0x2d, 0xcc, 0x37, 0x18, 0x73, 0x38, 0x27, 0x53, 0xbc, 0x17,
0x3b, 0xa7, 0xa8, 0x77, 0x28, 0x76, 0x4e, 0x61, 0x27, 0x60, 0xdf, 0x40, 0xbf, 0x1e, 0x7f, 0x77,
0xcc, 0x94, 0xcc, 0xe8, 0xf1, 0x79, 0xcf, 0x2f, 0xaa, 0xe0, 0x9b, 0xdf, 0xbf, 0xc0, 0x8a, 0x14,
0x38, 0x50, 0xe7, 0x84, 0xbe, 0x52, 0xa5, 0x4b, 0x14, 0x7a, 0xa2, 0xd2, 0x2f, 0x38, 0x5c, 0xc7,
0xd2, 0xa4, 0xea, 0xd4, 0xc3, 0xcf, 0x59, 0x91, 0x1c, 0xee, 0x02, 0x3c, 0xc5, 0xfc, 0x00, 0xf3,
0x90, 0xf4, 0x58, 0x3e, 0xac, 0xc6, 0x09, 0x43, 0x2b, 0xc4, 0x47, 0x3d, 0x9a, 0xa9, 0x17, 0x1f,
0xb0, 0xf5, 0xf5, 0xa2, 0xfe, 0x8f, 0xf0, 0x90, 0xfa, 0xf8, 0xff, 0x3f, 0x4f, 0x1d, 0x81, 0x99,
0x14, 0xee, 0xc5, 0x61, 0x90, 0xaf, 0xeb, 0x67, 0x85, 0xc1, 0xe7, 0x60, 0x26, 0x95, 0x50, 0xf1,
0x8e, 0xf9, 0x2a, 0xb2, 0xf9, 0x70, 0x86, 0x56, 0x72, 0xdb, 0x43, 0xa8, 0xc6, 0x95, 0x0b, 0x7a,
0x30, 0x2d, 0x66, 0xd3, 0x3b, 0xcf, 0xb8, 0xeb, 0x2f, 0xc1, 0x4a, 0xd1, 0x7a, 0x71, 0x96, 0x9e,
0x2c, 0x07, 0x9a, 0x8f, 0x66, 0xea, 0x7d, 0x33, 0x82, 0x65, 0xe7, 0x07, 0x9f, 0x6f, 0x1d, 0x13,
0x7e, 0x12, 0x75, 0x85, 0x65, 0x37, 0x95, 0xe6, 0x7b, 0x84, 0xea, 0x5f, 0x9b, 0xf1, 0x2d, 0x37,
0xe5, 0x4e, 0x9b, 0xd2, 0x4e, 0xa3, 0x6e, 0x77, 0x51, 0x0e, 0xdf, 0xff, 0x6f, 0x00, 0x00, 0x00,
0xff, 0xff, 0xe1, 0x00, 0x07, 0x45, 0xe2, 0x1f, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
@ -2161,7 +2161,7 @@ const _ = grpc.SupportPackageIsVersion4
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type IndexCoordClient interface {
GetComponentStates(ctx context.Context, in *internalpb.GetComponentStatesRequest, opts ...grpc.CallOption) (*internalpb.ComponentStates, error)
GetComponentStates(ctx context.Context, in *milvuspb.GetComponentStatesRequest, opts ...grpc.CallOption) (*milvuspb.ComponentStates, error)
GetStatisticsChannel(ctx context.Context, in *internalpb.GetStatisticsChannelRequest, opts ...grpc.CallOption) (*milvuspb.StringResponse, error)
CreateIndex(ctx context.Context, in *CreateIndexRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
// Deprecated: use DescribeIndex instead
@ -2185,8 +2185,8 @@ func NewIndexCoordClient(cc *grpc.ClientConn) IndexCoordClient {
return &indexCoordClient{cc}
}
func (c *indexCoordClient) GetComponentStates(ctx context.Context, in *internalpb.GetComponentStatesRequest, opts ...grpc.CallOption) (*internalpb.ComponentStates, error) {
out := new(internalpb.ComponentStates)
func (c *indexCoordClient) GetComponentStates(ctx context.Context, in *milvuspb.GetComponentStatesRequest, opts ...grpc.CallOption) (*milvuspb.ComponentStates, error) {
out := new(milvuspb.ComponentStates)
err := c.cc.Invoke(ctx, "/milvus.proto.index.IndexCoord/GetComponentStates", in, out, opts...)
if err != nil {
return nil, err
@ -2286,7 +2286,7 @@ func (c *indexCoordClient) GetMetrics(ctx context.Context, in *milvuspb.GetMetri
// IndexCoordServer is the server API for IndexCoord service.
type IndexCoordServer interface {
GetComponentStates(context.Context, *internalpb.GetComponentStatesRequest) (*internalpb.ComponentStates, error)
GetComponentStates(context.Context, *milvuspb.GetComponentStatesRequest) (*milvuspb.ComponentStates, error)
GetStatisticsChannel(context.Context, *internalpb.GetStatisticsChannelRequest) (*milvuspb.StringResponse, error)
CreateIndex(context.Context, *CreateIndexRequest) (*commonpb.Status, error)
// Deprecated: use DescribeIndex instead
@ -2306,7 +2306,7 @@ type IndexCoordServer interface {
type UnimplementedIndexCoordServer struct {
}
func (*UnimplementedIndexCoordServer) GetComponentStates(ctx context.Context, req *internalpb.GetComponentStatesRequest) (*internalpb.ComponentStates, error) {
func (*UnimplementedIndexCoordServer) GetComponentStates(ctx context.Context, req *milvuspb.GetComponentStatesRequest) (*milvuspb.ComponentStates, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetComponentStates not implemented")
}
func (*UnimplementedIndexCoordServer) GetStatisticsChannel(ctx context.Context, req *internalpb.GetStatisticsChannelRequest) (*milvuspb.StringResponse, error) {
@ -2345,7 +2345,7 @@ func RegisterIndexCoordServer(s *grpc.Server, srv IndexCoordServer) {
}
func _IndexCoord_GetComponentStates_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(internalpb.GetComponentStatesRequest)
in := new(milvuspb.GetComponentStatesRequest)
if err := dec(in); err != nil {
return nil, err
}
@ -2357,7 +2357,7 @@ func _IndexCoord_GetComponentStates_Handler(srv interface{}, ctx context.Context
FullMethod: "/milvus.proto.index.IndexCoord/GetComponentStates",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(IndexCoordServer).GetComponentStates(ctx, req.(*internalpb.GetComponentStatesRequest))
return srv.(IndexCoordServer).GetComponentStates(ctx, req.(*milvuspb.GetComponentStatesRequest))
}
return interceptor(ctx, in, info, handler)
}
@ -2599,7 +2599,7 @@ var _IndexCoord_serviceDesc = grpc.ServiceDesc{
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type IndexNodeClient interface {
GetComponentStates(ctx context.Context, in *internalpb.GetComponentStatesRequest, opts ...grpc.CallOption) (*internalpb.ComponentStates, error)
GetComponentStates(ctx context.Context, in *milvuspb.GetComponentStatesRequest, opts ...grpc.CallOption) (*milvuspb.ComponentStates, error)
GetStatisticsChannel(ctx context.Context, in *internalpb.GetStatisticsChannelRequest, opts ...grpc.CallOption) (*milvuspb.StringResponse, error)
CreateJob(ctx context.Context, in *CreateJobRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
QueryJobs(ctx context.Context, in *QueryJobsRequest, opts ...grpc.CallOption) (*QueryJobsResponse, error)
@ -2618,8 +2618,8 @@ func NewIndexNodeClient(cc *grpc.ClientConn) IndexNodeClient {
return &indexNodeClient{cc}
}
func (c *indexNodeClient) GetComponentStates(ctx context.Context, in *internalpb.GetComponentStatesRequest, opts ...grpc.CallOption) (*internalpb.ComponentStates, error) {
out := new(internalpb.ComponentStates)
func (c *indexNodeClient) GetComponentStates(ctx context.Context, in *milvuspb.GetComponentStatesRequest, opts ...grpc.CallOption) (*milvuspb.ComponentStates, error) {
out := new(milvuspb.ComponentStates)
err := c.cc.Invoke(ctx, "/milvus.proto.index.IndexNode/GetComponentStates", in, out, opts...)
if err != nil {
return nil, err
@ -2692,7 +2692,7 @@ func (c *indexNodeClient) GetMetrics(ctx context.Context, in *milvuspb.GetMetric
// IndexNodeServer is the server API for IndexNode service.
type IndexNodeServer interface {
GetComponentStates(context.Context, *internalpb.GetComponentStatesRequest) (*internalpb.ComponentStates, error)
GetComponentStates(context.Context, *milvuspb.GetComponentStatesRequest) (*milvuspb.ComponentStates, error)
GetStatisticsChannel(context.Context, *internalpb.GetStatisticsChannelRequest) (*milvuspb.StringResponse, error)
CreateJob(context.Context, *CreateJobRequest) (*commonpb.Status, error)
QueryJobs(context.Context, *QueryJobsRequest) (*QueryJobsResponse, error)
@ -2707,7 +2707,7 @@ type IndexNodeServer interface {
type UnimplementedIndexNodeServer struct {
}
func (*UnimplementedIndexNodeServer) GetComponentStates(ctx context.Context, req *internalpb.GetComponentStatesRequest) (*internalpb.ComponentStates, error) {
func (*UnimplementedIndexNodeServer) GetComponentStates(ctx context.Context, req *milvuspb.GetComponentStatesRequest) (*milvuspb.ComponentStates, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetComponentStates not implemented")
}
func (*UnimplementedIndexNodeServer) GetStatisticsChannel(ctx context.Context, req *internalpb.GetStatisticsChannelRequest) (*milvuspb.StringResponse, error) {
@ -2737,7 +2737,7 @@ func RegisterIndexNodeServer(s *grpc.Server, srv IndexNodeServer) {
}
func _IndexNode_GetComponentStates_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(internalpb.GetComponentStatesRequest)
in := new(milvuspb.GetComponentStatesRequest)
if err := dec(in); err != nil {
return nil, err
}
@ -2749,7 +2749,7 @@ func _IndexNode_GetComponentStates_Handler(srv interface{}, ctx context.Context,
FullMethod: "/milvus.proto.index.IndexNode/GetComponentStates",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(IndexNodeServer).GetComponentStates(ctx, req.(*internalpb.GetComponentStatesRequest))
return srv.(IndexNodeServer).GetComponentStates(ctx, req.(*milvuspb.GetComponentStatesRequest))
}
return interceptor(ctx, in, info, handler)
}

23
internal/proto/internal.proto
View File

@ -5,29 +5,6 @@ option go_package = "github.com/milvus-io/milvus/internal/proto/internalpb";
import "common.proto";
import "schema.proto";
enum StateCode {
Initializing = 0;
Healthy = 1;
Abnormal = 2;
StandBy = 3;
}
message ComponentInfo {
int64 nodeID = 1;
string role = 2;
StateCode state_code = 3;
repeated common.KeyValuePair extra_info = 4;
}
message ComponentStates {
ComponentInfo state = 1;
repeated ComponentInfo subcomponent_states = 2;
common.Status status = 3;
}
message GetComponentStatesRequest {
}
message GetTimeTickChannelRequest {
}

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

@ -22,37 +22,6 @@ var _ = math.Inf
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
type StateCode int32
const (
StateCode_Initializing StateCode = 0
StateCode_Healthy StateCode = 1
StateCode_Abnormal StateCode = 2
StateCode_StandBy StateCode = 3
)
var StateCode_name = map[int32]string{
0: "Initializing",
1: "Healthy",
2: "Abnormal",
3: "StandBy",
}
var StateCode_value = map[string]int32{
"Initializing": 0,
"Healthy": 1,
"Abnormal": 2,
"StandBy": 3,
}
func (x StateCode) String() string {
return proto.EnumName(StateCode_name, int32(x))
}
func (StateCode) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_41f4a519b878ee3b, []int{0}
}
type InsertDataVersion int32
const (
@ -76,7 +45,7 @@ func (x InsertDataVersion) String() string {
}
func (InsertDataVersion) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_41f4a519b878ee3b, []int{1}
return fileDescriptor_41f4a519b878ee3b, []int{0}
}
type RateType int32
@ -125,158 +94,9 @@ func (x RateType) String() string {
}
func (RateType) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_41f4a519b878ee3b, []int{2}
}
type ComponentInfo struct {
NodeID int64 `protobuf:"varint,1,opt,name=nodeID,proto3" json:"nodeID,omitempty"`
Role string `protobuf:"bytes,2,opt,name=role,proto3" json:"role,omitempty"`
StateCode StateCode `protobuf:"varint,3,opt,name=state_code,json=stateCode,proto3,enum=milvus.proto.internal.StateCode" json:"state_code,omitempty"`
ExtraInfo []*commonpb.KeyValuePair `protobuf:"bytes,4,rep,name=extra_info,json=extraInfo,proto3" json:"extra_info,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ComponentInfo) Reset() { *m = ComponentInfo{} }
func (m *ComponentInfo) String() string { return proto.CompactTextString(m) }
func (*ComponentInfo) ProtoMessage() {}
func (*ComponentInfo) Descriptor() ([]byte, []int) {
return fileDescriptor_41f4a519b878ee3b, []int{0}
}
func (m *ComponentInfo) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ComponentInfo.Unmarshal(m, b)
}
func (m *ComponentInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ComponentInfo.Marshal(b, m, deterministic)
}
func (m *ComponentInfo) XXX_Merge(src proto.Message) {
xxx_messageInfo_ComponentInfo.Merge(m, src)
}
func (m *ComponentInfo) XXX_Size() int {
return xxx_messageInfo_ComponentInfo.Size(m)
}
func (m *ComponentInfo) XXX_DiscardUnknown() {
xxx_messageInfo_ComponentInfo.DiscardUnknown(m)
}
var xxx_messageInfo_ComponentInfo proto.InternalMessageInfo
func (m *ComponentInfo) GetNodeID() int64 {
if m != nil {
return m.NodeID
}
return 0
}
func (m *ComponentInfo) GetRole() string {
if m != nil {
return m.Role
}
return ""
}
func (m *ComponentInfo) GetStateCode() StateCode {
if m != nil {
return m.StateCode
}
return StateCode_Initializing
}
func (m *ComponentInfo) GetExtraInfo() []*commonpb.KeyValuePair {
if m != nil {
return m.ExtraInfo
}
return nil
}
type ComponentStates struct {
State *ComponentInfo `protobuf:"bytes,1,opt,name=state,proto3" json:"state,omitempty"`
SubcomponentStates []*ComponentInfo `protobuf:"bytes,2,rep,name=subcomponent_states,json=subcomponentStates,proto3" json:"subcomponent_states,omitempty"`
Status *commonpb.Status `protobuf:"bytes,3,opt,name=status,proto3" json:"status,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ComponentStates) Reset() { *m = ComponentStates{} }
func (m *ComponentStates) String() string { return proto.CompactTextString(m) }
func (*ComponentStates) ProtoMessage() {}
func (*ComponentStates) Descriptor() ([]byte, []int) {
return fileDescriptor_41f4a519b878ee3b, []int{1}
}
func (m *ComponentStates) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ComponentStates.Unmarshal(m, b)
}
func (m *ComponentStates) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_ComponentStates.Marshal(b, m, deterministic)
}
func (m *ComponentStates) XXX_Merge(src proto.Message) {
xxx_messageInfo_ComponentStates.Merge(m, src)
}
func (m *ComponentStates) XXX_Size() int {
return xxx_messageInfo_ComponentStates.Size(m)
}
func (m *ComponentStates) XXX_DiscardUnknown() {
xxx_messageInfo_ComponentStates.DiscardUnknown(m)
}
var xxx_messageInfo_ComponentStates proto.InternalMessageInfo
func (m *ComponentStates) GetState() *ComponentInfo {
if m != nil {
return m.State
}
return nil
}
func (m *ComponentStates) GetSubcomponentStates() []*ComponentInfo {
if m != nil {
return m.SubcomponentStates
}
return nil
}
func (m *ComponentStates) GetStatus() *commonpb.Status {
if m != nil {
return m.Status
}
return nil
}
type GetComponentStatesRequest struct {
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *GetComponentStatesRequest) Reset() { *m = GetComponentStatesRequest{} }
func (m *GetComponentStatesRequest) String() string { return proto.CompactTextString(m) }
func (*GetComponentStatesRequest) ProtoMessage() {}
func (*GetComponentStatesRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_41f4a519b878ee3b, []int{2}
}
func (m *GetComponentStatesRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetComponentStatesRequest.Unmarshal(m, b)
}
func (m *GetComponentStatesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_GetComponentStatesRequest.Marshal(b, m, deterministic)
}
func (m *GetComponentStatesRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_GetComponentStatesRequest.Merge(m, src)
}
func (m *GetComponentStatesRequest) XXX_Size() int {
return xxx_messageInfo_GetComponentStatesRequest.Size(m)
}
func (m *GetComponentStatesRequest) XXX_DiscardUnknown() {
xxx_messageInfo_GetComponentStatesRequest.DiscardUnknown(m)
}
var xxx_messageInfo_GetComponentStatesRequest proto.InternalMessageInfo
type GetTimeTickChannelRequest struct {
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
@ -287,7 +107,7 @@ func (m *GetTimeTickChannelRequest) Reset() { *m = GetTimeTickChannelReq
func (m *GetTimeTickChannelRequest) String() string { return proto.CompactTextString(m) }
func (*GetTimeTickChannelRequest) ProtoMessage() {}
func (*GetTimeTickChannelRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_41f4a519b878ee3b, []int{3}
return fileDescriptor_41f4a519b878ee3b, []int{0}
}
func (m *GetTimeTickChannelRequest) XXX_Unmarshal(b []byte) error {
@ -318,7 +138,7 @@ func (m *GetStatisticsChannelRequest) Reset() { *m = GetStatisticsChanne
func (m *GetStatisticsChannelRequest) String() string { return proto.CompactTextString(m) }
func (*GetStatisticsChannelRequest) ProtoMessage() {}
func (*GetStatisticsChannelRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_41f4a519b878ee3b, []int{4}
return fileDescriptor_41f4a519b878ee3b, []int{1}
}
func (m *GetStatisticsChannelRequest) XXX_Unmarshal(b []byte) error {
@ -349,7 +169,7 @@ func (m *GetDdChannelRequest) Reset() { *m = GetDdChannelRequest{} }
func (m *GetDdChannelRequest) String() string { return proto.CompactTextString(m) }
func (*GetDdChannelRequest) ProtoMessage() {}
func (*GetDdChannelRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_41f4a519b878ee3b, []int{5}
return fileDescriptor_41f4a519b878ee3b, []int{2}
}
func (m *GetDdChannelRequest) XXX_Unmarshal(b []byte) error {
@ -382,7 +202,7 @@ func (m *NodeInfo) Reset() { *m = NodeInfo{} }
func (m *NodeInfo) String() string { return proto.CompactTextString(m) }
func (*NodeInfo) ProtoMessage() {}
func (*NodeInfo) Descriptor() ([]byte, []int) {
return fileDescriptor_41f4a519b878ee3b, []int{6}
return fileDescriptor_41f4a519b878ee3b, []int{3}
}
func (m *NodeInfo) XXX_Unmarshal(b []byte) error {
@ -429,7 +249,7 @@ func (m *InitParams) Reset() { *m = InitParams{} }
func (m *InitParams) String() string { return proto.CompactTextString(m) }
func (*InitParams) ProtoMessage() {}
func (*InitParams) Descriptor() ([]byte, []int) {
return fileDescriptor_41f4a519b878ee3b, []int{7}
return fileDescriptor_41f4a519b878ee3b, []int{4}
}
func (m *InitParams) XXX_Unmarshal(b []byte) error {
@ -476,7 +296,7 @@ func (m *StringList) Reset() { *m = StringList{} }
func (m *StringList) String() string { return proto.CompactTextString(m) }
func (*StringList) ProtoMessage() {}
func (*StringList) Descriptor() ([]byte, []int) {
return fileDescriptor_41f4a519b878ee3b, []int{8}
return fileDescriptor_41f4a519b878ee3b, []int{5}
}
func (m *StringList) XXX_Unmarshal(b []byte) error {
@ -522,7 +342,7 @@ func (m *TimeTickMsg) Reset() { *m = TimeTickMsg{} }
func (m *TimeTickMsg) String() string { return proto.CompactTextString(m) }
func (*TimeTickMsg) ProtoMessage() {}
func (*TimeTickMsg) Descriptor() ([]byte, []int) {
return fileDescriptor_41f4a519b878ee3b, []int{9}
return fileDescriptor_41f4a519b878ee3b, []int{6}
}
func (m *TimeTickMsg) XXX_Unmarshal(b []byte) error {
@ -571,7 +391,7 @@ func (m *GetStatisticsRequest) Reset() { *m = GetStatisticsRequest{} }
func (m *GetStatisticsRequest) String() string { return proto.CompactTextString(m) }
func (*GetStatisticsRequest) ProtoMessage() {}
func (*GetStatisticsRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_41f4a519b878ee3b, []int{10}
return fileDescriptor_41f4a519b878ee3b, []int{7}
}
func (m *GetStatisticsRequest) XXX_Unmarshal(b []byte) error {
@ -656,7 +476,7 @@ func (m *GetStatisticsResponse) Reset() { *m = GetStatisticsResponse{} }
func (m *GetStatisticsResponse) String() string { return proto.CompactTextString(m) }
func (*GetStatisticsResponse) ProtoMessage() {}
func (*GetStatisticsResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_41f4a519b878ee3b, []int{11}
return fileDescriptor_41f4a519b878ee3b, []int{8}
}
func (m *GetStatisticsResponse) XXX_Unmarshal(b []byte) error {
@ -719,7 +539,7 @@ func (m *CreateCollectionRequest) Reset() { *m = CreateCollectionRequest
func (m *CreateCollectionRequest) String() string { return proto.CompactTextString(m) }
func (*CreateCollectionRequest) ProtoMessage() {}
func (*CreateCollectionRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_41f4a519b878ee3b, []int{12}
return fileDescriptor_41f4a519b878ee3b, []int{9}
}
func (m *CreateCollectionRequest) XXX_Unmarshal(b []byte) error {
@ -825,7 +645,7 @@ func (m *DropCollectionRequest) Reset() { *m = DropCollectionRequest{} }
func (m *DropCollectionRequest) String() string { return proto.CompactTextString(m) }
func (*DropCollectionRequest) ProtoMessage() {}
func (*DropCollectionRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_41f4a519b878ee3b, []int{13}
return fileDescriptor_41f4a519b878ee3b, []int{10}
}
func (m *DropCollectionRequest) XXX_Unmarshal(b []byte) error {
@ -898,7 +718,7 @@ func (m *CreatePartitionRequest) Reset() { *m = CreatePartitionRequest{}
func (m *CreatePartitionRequest) String() string { return proto.CompactTextString(m) }
func (*CreatePartitionRequest) ProtoMessage() {}
func (*CreatePartitionRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_41f4a519b878ee3b, []int{14}
return fileDescriptor_41f4a519b878ee3b, []int{11}
}
func (m *CreatePartitionRequest) XXX_Unmarshal(b []byte) error {
@ -985,7 +805,7 @@ func (m *DropPartitionRequest) Reset() { *m = DropPartitionRequest{} }
func (m *DropPartitionRequest) String() string { return proto.CompactTextString(m) }
func (*DropPartitionRequest) ProtoMessage() {}
func (*DropPartitionRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_41f4a519b878ee3b, []int{15}
return fileDescriptor_41f4a519b878ee3b, []int{12}
}
func (m *DropPartitionRequest) XXX_Unmarshal(b []byte) error {
@ -1069,7 +889,7 @@ func (m *CreateAliasRequest) Reset() { *m = CreateAliasRequest{} }
func (m *CreateAliasRequest) String() string { return proto.CompactTextString(m) }
func (*CreateAliasRequest) ProtoMessage() {}
func (*CreateAliasRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_41f4a519b878ee3b, []int{16}
return fileDescriptor_41f4a519b878ee3b, []int{13}
}
func (m *CreateAliasRequest) XXX_Unmarshal(b []byte) error {
@ -1131,7 +951,7 @@ func (m *DropAliasRequest) Reset() { *m = DropAliasRequest{} }
func (m *DropAliasRequest) String() string { return proto.CompactTextString(m) }
func (*DropAliasRequest) ProtoMessage() {}
func (*DropAliasRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_41f4a519b878ee3b, []int{17}
return fileDescriptor_41f4a519b878ee3b, []int{14}
}
func (m *DropAliasRequest) XXX_Unmarshal(b []byte) error {
@ -1187,7 +1007,7 @@ func (m *AlterAliasRequest) Reset() { *m = AlterAliasRequest{} }
func (m *AlterAliasRequest) String() string { return proto.CompactTextString(m) }
func (*AlterAliasRequest) ProtoMessage() {}
func (*AlterAliasRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_41f4a519b878ee3b, []int{18}
return fileDescriptor_41f4a519b878ee3b, []int{15}
}
func (m *AlterAliasRequest) XXX_Unmarshal(b []byte) error {
@ -1254,7 +1074,7 @@ func (m *CreateIndexRequest) Reset() { *m = CreateIndexRequest{} }
func (m *CreateIndexRequest) String() string { return proto.CompactTextString(m) }
func (*CreateIndexRequest) ProtoMessage() {}
func (*CreateIndexRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_41f4a519b878ee3b, []int{19}
return fileDescriptor_41f4a519b878ee3b, []int{16}
}
func (m *CreateIndexRequest) XXX_Unmarshal(b []byte) error {
@ -1357,7 +1177,7 @@ func (m *InsertRequest) Reset() { *m = InsertRequest{} }
func (m *InsertRequest) String() string { return proto.CompactTextString(m) }
func (*InsertRequest) ProtoMessage() {}
func (*InsertRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_41f4a519b878ee3b, []int{20}
return fileDescriptor_41f4a519b878ee3b, []int{17}
}
func (m *InsertRequest) XXX_Unmarshal(b []byte) error {
@ -1510,7 +1330,7 @@ func (m *SearchRequest) Reset() { *m = SearchRequest{} }
func (m *SearchRequest) String() string { return proto.CompactTextString(m) }
func (*SearchRequest) ProtoMessage() {}
func (*SearchRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_41f4a519b878ee3b, []int{21}
return fileDescriptor_41f4a519b878ee3b, []int{18}
}
func (m *SearchRequest) XXX_Unmarshal(b []byte) error {
@ -1666,7 +1486,7 @@ func (m *SearchResults) Reset() { *m = SearchResults{} }
func (m *SearchResults) String() string { return proto.CompactTextString(m) }
func (*SearchResults) ProtoMessage() {}
func (*SearchResults) Descriptor() ([]byte, []int) {
return fileDescriptor_41f4a519b878ee3b, []int{22}
return fileDescriptor_41f4a519b878ee3b, []int{19}
}
func (m *SearchResults) XXX_Unmarshal(b []byte) error {
@ -1792,7 +1612,7 @@ func (m *RetrieveRequest) Reset() { *m = RetrieveRequest{} }
func (m *RetrieveRequest) String() string { return proto.CompactTextString(m) }
func (*RetrieveRequest) ProtoMessage() {}
func (*RetrieveRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_41f4a519b878ee3b, []int{23}
return fileDescriptor_41f4a519b878ee3b, []int{20}
}
func (m *RetrieveRequest) XXX_Unmarshal(b []byte) error {
@ -1908,7 +1728,7 @@ func (m *RetrieveResults) Reset() { *m = RetrieveResults{} }
func (m *RetrieveResults) String() string { return proto.CompactTextString(m) }
func (*RetrieveResults) ProtoMessage() {}
func (*RetrieveResults) Descriptor() ([]byte, []int) {
return fileDescriptor_41f4a519b878ee3b, []int{24}
return fileDescriptor_41f4a519b878ee3b, []int{21}
}
func (m *RetrieveResults) XXX_Unmarshal(b []byte) error {
@ -2007,7 +1827,7 @@ func (m *DeleteRequest) Reset() { *m = DeleteRequest{} }
func (m *DeleteRequest) String() string { return proto.CompactTextString(m) }
func (*DeleteRequest) ProtoMessage() {}
func (*DeleteRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_41f4a519b878ee3b, []int{25}
return fileDescriptor_41f4a519b878ee3b, []int{22}
}
func (m *DeleteRequest) XXX_Unmarshal(b []byte) error {
@ -2128,7 +1948,7 @@ func (m *LoadIndex) Reset() { *m = LoadIndex{} }
func (m *LoadIndex) String() string { return proto.CompactTextString(m) }
func (*LoadIndex) ProtoMessage() {}
func (*LoadIndex) Descriptor() ([]byte, []int) {
return fileDescriptor_41f4a519b878ee3b, []int{26}
return fileDescriptor_41f4a519b878ee3b, []int{23}
}
func (m *LoadIndex) XXX_Unmarshal(b []byte) error {
@ -2203,7 +2023,7 @@ func (m *IndexStats) Reset() { *m = IndexStats{} }
func (m *IndexStats) String() string { return proto.CompactTextString(m) }
func (*IndexStats) ProtoMessage() {}
func (*IndexStats) Descriptor() ([]byte, []int) {
return fileDescriptor_41f4a519b878ee3b, []int{27}
return fileDescriptor_41f4a519b878ee3b, []int{24}
}
func (m *IndexStats) XXX_Unmarshal(b []byte) error {
@ -2251,7 +2071,7 @@ func (m *FieldStats) Reset() { *m = FieldStats{} }
func (m *FieldStats) String() string { return proto.CompactTextString(m) }
func (*FieldStats) ProtoMessage() {}
func (*FieldStats) Descriptor() ([]byte, []int) {
return fileDescriptor_41f4a519b878ee3b, []int{28}
return fileDescriptor_41f4a519b878ee3b, []int{25}
}
func (m *FieldStats) XXX_Unmarshal(b []byte) error {
@ -2307,7 +2127,7 @@ func (m *SegmentStats) Reset() { *m = SegmentStats{} }
func (m *SegmentStats) String() string { return proto.CompactTextString(m) }
func (*SegmentStats) ProtoMessage() {}
func (*SegmentStats) Descriptor() ([]byte, []int) {
return fileDescriptor_41f4a519b878ee3b, []int{29}
return fileDescriptor_41f4a519b878ee3b, []int{26}
}
func (m *SegmentStats) XXX_Unmarshal(b []byte) error {
@ -2370,7 +2190,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{30}
return fileDescriptor_41f4a519b878ee3b, []int{27}
}
func (m *MsgPosition) XXX_Unmarshal(b []byte) error {
@ -2433,7 +2253,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{31}
return fileDescriptor_41f4a519b878ee3b, []int{28}
}
func (m *ChannelTimeTickMsg) XXX_Unmarshal(b []byte) error {
@ -2499,7 +2319,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{32}
return fileDescriptor_41f4a519b878ee3b, []int{29}
}
func (m *CredentialInfo) XXX_Unmarshal(b []byte) error {
@ -2567,7 +2387,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{33}
return fileDescriptor_41f4a519b878ee3b, []int{30}
}
func (m *ListPolicyRequest) XXX_Unmarshal(b []byte) error {
@ -2609,7 +2429,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{34}
return fileDescriptor_41f4a519b878ee3b, []int{31}
}
func (m *ListPolicyResponse) XXX_Unmarshal(b []byte) error {
@ -2663,7 +2483,7 @@ func (m *ShowConfigurationsRequest) Reset() { *m = ShowConfigurationsReq
func (m *ShowConfigurationsRequest) String() string { return proto.CompactTextString(m) }
func (*ShowConfigurationsRequest) ProtoMessage() {}
func (*ShowConfigurationsRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_41f4a519b878ee3b, []int{35}
return fileDescriptor_41f4a519b878ee3b, []int{32}
}
func (m *ShowConfigurationsRequest) XXX_Unmarshal(b []byte) error {
@ -2710,7 +2530,7 @@ func (m *ShowConfigurationsResponse) Reset() { *m = ShowConfigurationsRe
func (m *ShowConfigurationsResponse) String() string { return proto.CompactTextString(m) }
func (*ShowConfigurationsResponse) ProtoMessage() {}
func (*ShowConfigurationsResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_41f4a519b878ee3b, []int{36}
return fileDescriptor_41f4a519b878ee3b, []int{33}
}
func (m *ShowConfigurationsResponse) XXX_Unmarshal(b []byte) error {
@ -2757,7 +2577,7 @@ func (m *Rate) Reset() { *m = Rate{} }
func (m *Rate) String() string { return proto.CompactTextString(m) }
func (*Rate) ProtoMessage() {}
func (*Rate) Descriptor() ([]byte, []int) {
return fileDescriptor_41f4a519b878ee3b, []int{37}
return fileDescriptor_41f4a519b878ee3b, []int{34}
}
func (m *Rate) XXX_Unmarshal(b []byte) error {
@ -2793,12 +2613,8 @@ func (m *Rate) GetR() float64 {
}
func init() {
proto.RegisterEnum("milvus.proto.internal.StateCode", StateCode_name, StateCode_value)
proto.RegisterEnum("milvus.proto.internal.InsertDataVersion", InsertDataVersion_name, InsertDataVersion_value)
proto.RegisterEnum("milvus.proto.internal.RateType", RateType_name, RateType_value)
proto.RegisterType((*ComponentInfo)(nil), "milvus.proto.internal.ComponentInfo")
proto.RegisterType((*ComponentStates)(nil), "milvus.proto.internal.ComponentStates")
proto.RegisterType((*GetComponentStatesRequest)(nil), "milvus.proto.internal.GetComponentStatesRequest")
proto.RegisterType((*GetTimeTickChannelRequest)(nil), "milvus.proto.internal.GetTimeTickChannelRequest")
proto.RegisterType((*GetStatisticsChannelRequest)(nil), "milvus.proto.internal.GetStatisticsChannelRequest")
proto.RegisterType((*GetDdChannelRequest)(nil), "milvus.proto.internal.GetDdChannelRequest")
@ -2839,153 +2655,143 @@ func init() {
func init() { proto.RegisterFile("internal.proto", fileDescriptor_41f4a519b878ee3b) }
var fileDescriptor_41f4a519b878ee3b = []byte{
// 2356 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x59, 0xcf, 0x6f, 0x1c, 0x49,
0xf5, 0xdf, 0x9e, 0x9e, 0xf1, 0xcc, 0xbc, 0x19, 0x8f, 0xdb, 0x15, 0x27, 0x3b, 0x71, 0x92, 0x8d,
0xd3, 0xdf, 0xfd, 0x82, 0x49, 0xd8, 0x24, 0x78, 0x77, 0x13, 0x04, 0x88, 0x10, 0x7b, 0xb2, 0xc1,
0x8a, 0x1d, 0x9c, 0x76, 0x88, 0x04, 0x97, 0x56, 0xcd, 0x74, 0x79, 0xa6, 0x49, 0x77, 0x57, 0xa7,
0xaa, 0xda, 0xce, 0xe4, 0xc4, 0x81, 0x13, 0x2b, 0xb8, 0x71, 0x41, 0x82, 0x33, 0x42, 0x42, 0xe2,
0xb6, 0x37, 0x90, 0x38, 0x71, 0xe2, 0xc4, 0x85, 0x7f, 0x05, 0x71, 0x40, 0xf5, 0xa3, 0x7b, 0x7e,
0x78, 0xec, 0xd8, 0x8e, 0x76, 0x37, 0x48, 0x7b, 0xeb, 0x7a, 0xef, 0xd5, 0xeb, 0x57, 0xef, 0x7d,
0xde, 0xab, 0xf7, 0xba, 0xa1, 0x15, 0x26, 0x82, 0xb0, 0x04, 0x47, 0x37, 0x53, 0x46, 0x05, 0x45,
0xe7, 0xe3, 0x30, 0xda, 0xcf, 0xb8, 0x5e, 0xdd, 0xcc, 0x99, 0xcb, 0xcd, 0x1e, 0x8d, 0x63, 0x9a,
0x68, 0xf2, 0x72, 0x93, 0xf7, 0x06, 0x24, 0xc6, 0x7a, 0xe5, 0xfe, 0xc5, 0x82, 0xf9, 0x0d, 0x1a,
0xa7, 0x34, 0x21, 0x89, 0xd8, 0x4c, 0xf6, 0x28, 0xba, 0x00, 0x73, 0x09, 0x0d, 0xc8, 0x66, 0xa7,
0x6d, 0xad, 0x58, 0xab, 0xb6, 0x67, 0x56, 0x08, 0x41, 0x99, 0xd1, 0x88, 0xb4, 0x4b, 0x2b, 0xd6,
0x6a, 0xdd, 0x53, 0xcf, 0xe8, 0x1e, 0x00, 0x17, 0x58, 0x10, 0xbf, 0x47, 0x03, 0xd2, 0xb6, 0x57,
0xac, 0xd5, 0xd6, 0xda, 0xca, 0xcd, 0x99, 0x56, 0xdc, 0xdc, 0x95, 0x82, 0x1b, 0x34, 0x20, 0x5e,
0x9d, 0xe7, 0x8f, 0xe8, 0x07, 0x00, 0xe4, 0xa5, 0x60, 0xd8, 0x0f, 0x93, 0x3d, 0xda, 0x2e, 0xaf,
0xd8, 0xab, 0x8d, 0xb5, 0x6b, 0x93, 0x0a, 0x8c, 0xf1, 0x8f, 0xc8, 0xf0, 0x19, 0x8e, 0x32, 0xb2,
0x83, 0x43, 0xe6, 0xd5, 0xd5, 0x26, 0x69, 0xae, 0xfb, 0x2f, 0x0b, 0x16, 0x8a, 0x03, 0xa8, 0x77,
0x70, 0xf4, 0x1d, 0xa8, 0xa8, 0x57, 0xa8, 0x13, 0x34, 0xd6, 0xde, 0x3f, 0xc2, 0xa2, 0x89, 0x73,
0x7b, 0x7a, 0x0b, 0xfa, 0x31, 0x9c, 0xe3, 0x59, 0xb7, 0x97, 0xb3, 0x7c, 0x45, 0xe5, 0xed, 0x92,
0x32, 0xed, 0x64, 0x9a, 0xd0, 0xb8, 0x02, 0x63, 0xd2, 0x87, 0x30, 0x27, 0x35, 0x65, 0x5c, 0x79,
0xa9, 0xb1, 0x76, 0x69, 0xe6, 0x21, 0x77, 0x95, 0x88, 0x67, 0x44, 0xdd, 0x4b, 0x70, 0xf1, 0x21,
0x11, 0x53, 0xa7, 0xf3, 0xc8, 0x8b, 0x8c, 0x70, 0x61, 0x98, 0x4f, 0xc3, 0x98, 0x3c, 0x0d, 0x7b,
0xcf, 0x37, 0x06, 0x38, 0x49, 0x48, 0x94, 0x33, 0xaf, 0xc0, 0xa5, 0x87, 0x44, 0x6d, 0x08, 0xb9,
0x08, 0x7b, 0x7c, 0x8a, 0x7d, 0x1e, 0xce, 0x3d, 0x24, 0xa2, 0x13, 0x4c, 0x91, 0x9f, 0x41, 0xed,
0xb1, 0x0c, 0xb6, 0x84, 0xc1, 0x1d, 0xa8, 0xe2, 0x20, 0x60, 0x84, 0x73, 0xe3, 0xc5, 0xcb, 0x33,
0x2d, 0xbe, 0xaf, 0x65, 0xbc, 0x5c, 0x78, 0x16, 0x4c, 0xdc, 0x9f, 0x01, 0x6c, 0x26, 0xa1, 0xd8,
0xc1, 0x0c, 0xc7, 0xfc, 0x48, 0x80, 0x75, 0xa0, 0xc9, 0x05, 0x66, 0xc2, 0x4f, 0x95, 0x9c, 0x71,
0xf9, 0x09, 0xd0, 0xd0, 0x50, 0xdb, 0xb4, 0x76, 0xf7, 0x27, 0x00, 0xbb, 0x82, 0x85, 0x49, 0x7f,
0x2b, 0xe4, 0x42, 0xbe, 0x6b, 0x5f, 0xca, 0xc9, 0x43, 0xd8, 0xab, 0x75, 0xcf, 0xac, 0xc6, 0xc2,
0x51, 0x3a, 0x79, 0x38, 0xee, 0x41, 0x23, 0x77, 0xf7, 0x36, 0xef, 0xa3, 0xdb, 0x50, 0xee, 0x62,
0x4e, 0x8e, 0x75, 0xcf, 0x36, 0xef, 0xaf, 0x63, 0x4e, 0x3c, 0x25, 0xe9, 0xfe, 0xa9, 0x04, 0x4b,
0x13, 0x61, 0x31, 0x8e, 0x3f, 0xbd, 0x2a, 0xe9, 0xe6, 0xa0, 0xbb, 0xd9, 0x51, 0xe6, 0xdb, 0x9e,
0x7a, 0x46, 0x2e, 0x34, 0x7b, 0x34, 0x8a, 0x48, 0x4f, 0x84, 0x34, 0xd9, 0xec, 0x28, 0xa4, 0xd9,
0xde, 0x04, 0x4d, 0xca, 0xa4, 0x98, 0x89, 0x50, 0x2f, 0xb9, 0x4a, 0x39, 0xdb, 0x9b, 0xa0, 0xa1,
0x6f, 0x80, 0x23, 0x18, 0xde, 0x27, 0x91, 0x2f, 0xc2, 0x98, 0x70, 0x81, 0xe3, 0xb4, 0x5d, 0x59,
0xb1, 0x56, 0xcb, 0xde, 0x82, 0xa6, 0x3f, 0xcd, 0xc9, 0xe8, 0x16, 0x9c, 0xeb, 0x67, 0x98, 0xe1,
0x44, 0x10, 0x32, 0x26, 0x3d, 0xa7, 0xa4, 0x51, 0xc1, 0x1a, 0x6d, 0xb8, 0x01, 0x8b, 0x52, 0x8c,
0x66, 0x62, 0x4c, 0xbc, 0xaa, 0xc4, 0x1d, 0xc3, 0x28, 0x84, 0xdd, 0xcf, 0x2c, 0x38, 0x3f, 0xe5,
0x2f, 0x9e, 0xd2, 0x84, 0x93, 0x33, 0x38, 0xec, 0x2c, 0x11, 0x47, 0x77, 0x75, 0x21, 0x91, 0x49,
0x7b, 0x42, 0x2c, 0x6a, 0x79, 0xf7, 0x97, 0x36, 0xbc, 0xbb, 0xc1, 0x88, 0x2a, 0x73, 0xb9, 0xf7,
0xcf, 0x1e, 0xec, 0x77, 0xa1, 0x1a, 0x74, 0xfd, 0x04, 0xc7, 0x79, 0x5a, 0xcd, 0x05, 0xdd, 0xc7,
0x38, 0x26, 0xe8, 0x6b, 0xd0, 0x1a, 0x45, 0x57, 0x52, 0x54, 0xcc, 0xeb, 0xde, 0x14, 0x15, 0xbd,
0x0f, 0xf3, 0x45, 0x84, 0x95, 0x58, 0x59, 0x89, 0x4d, 0x12, 0x0b, 0x4c, 0x55, 0x8e, 0xc1, 0xd4,
0xdc, 0x0c, 0x4c, 0xad, 0x40, 0x63, 0x0c, 0x3f, 0x2a, 0x9a, 0xb6, 0x37, 0x4e, 0x92, 0x69, 0xa8,
0x6f, 0x9d, 0x76, 0x6d, 0xc5, 0x5a, 0x6d, 0x7a, 0x66, 0x85, 0x6e, 0xc3, 0xb9, 0xfd, 0x90, 0x89,
0x0c, 0x47, 0xa6, 0x12, 0x49, 0x3b, 0x78, 0xbb, 0xae, 0x72, 0x75, 0x16, 0x0b, 0xad, 0xc1, 0x52,
0x3a, 0x18, 0xf2, 0xb0, 0x37, 0xb5, 0x05, 0xd4, 0x96, 0x99, 0x3c, 0xf7, 0x6f, 0x16, 0x9c, 0xef,
0x30, 0x9a, 0xbe, 0x15, 0xa1, 0xc8, 0x9d, 0x5c, 0x3e, 0xc6, 0xc9, 0x95, 0xc3, 0x4e, 0x76, 0x7f,
0x55, 0x82, 0x0b, 0x1a, 0x51, 0x3b, 0xb9, 0x63, 0x3f, 0x87, 0x53, 0x7c, 0x1d, 0x16, 0x46, 0x6f,
0xd5, 0x02, 0xb3, 0x8f, 0xf1, 0xff, 0xd0, 0x2a, 0x02, 0xac, 0xe5, 0xbe, 0x58, 0x48, 0xb9, 0x9f,
0x96, 0x60, 0x49, 0x06, 0xf5, 0x2b, 0x6f, 0x48, 0x6f, 0xfc, 0xde, 0x02, 0xa4, 0xd1, 0x71, 0x3f,
0x0a, 0x31, 0xff, 0x32, 0x7d, 0xb1, 0x04, 0x15, 0x2c, 0x6d, 0x30, 0x2e, 0xd0, 0x0b, 0x97, 0x83,
0x23, 0xa3, 0xf5, 0x79, 0x59, 0x57, 0xbc, 0xd4, 0x1e, 0x7f, 0xe9, 0xef, 0x2c, 0x58, 0xbc, 0x1f,
0x09, 0xc2, 0xde, 0x52, 0xa7, 0xfc, 0xb5, 0x94, 0x47, 0x6d, 0x33, 0x09, 0xc8, 0xcb, 0x2f, 0xd3,
0xc0, 0x2b, 0x00, 0x7b, 0x21, 0x89, 0x82, 0x71, 0xf4, 0xd6, 0x15, 0xe5, 0x8d, 0x90, 0xdb, 0x86,
0xaa, 0x52, 0x52, 0xa0, 0x36, 0x5f, 0xca, 0x6e, 0x4f, 0x77, 0xfe, 0xa6, 0xdb, 0xab, 0x9d, 0xb8,
0xdb, 0x53, 0xdb, 0x4c, 0xb7, 0xf7, 0x8f, 0x32, 0xcc, 0x6f, 0x26, 0x9c, 0x30, 0x71, 0x76, 0xe7,
0x5d, 0x86, 0x3a, 0x1f, 0x60, 0xa6, 0x0e, 0x6a, 0xdc, 0x37, 0x22, 0x8c, 0xbb, 0xd6, 0x7e, 0x9d,
0x6b, 0xcb, 0x27, 0x2c, 0x0e, 0x95, 0xe3, 0x8a, 0xc3, 0xdc, 0x31, 0x2e, 0xae, 0xbe, 0xbe, 0x38,
0xd4, 0x0e, 0xdf, 0xbe, 0xf2, 0x80, 0xa4, 0x1f, 0xcb, 0xf1, 0xa4, 0xd3, 0xae, 0x2b, 0xfe, 0x88,
0x80, 0xde, 0x03, 0x28, 0x3a, 0x31, 0x7d, 0x8f, 0x96, 0xbd, 0x31, 0x8a, 0xbc, 0xbb, 0x19, 0x3d,
0x90, 0xbd, 0x62, 0x43, 0xf5, 0x8a, 0x66, 0x85, 0x3e, 0x82, 0x1a, 0xa3, 0x07, 0x7e, 0x80, 0x05,
0x6e, 0x37, 0x55, 0xf0, 0x2e, 0xce, 0x74, 0xf6, 0x7a, 0x44, 0xbb, 0x5e, 0x95, 0xd1, 0x83, 0x0e,
0x16, 0x18, 0xdd, 0x83, 0x86, 0x42, 0x00, 0xd7, 0x1b, 0xe7, 0xd5, 0xc6, 0xf7, 0x26, 0x37, 0x9a,
0x01, 0xf5, 0x13, 0x29, 0x27, 0x37, 0x79, 0x1a, 0x9a, 0x5c, 0x29, 0xb8, 0x08, 0xb5, 0x24, 0x8b,
0x7d, 0x46, 0x0f, 0x78, 0xbb, 0xa5, 0xfa, 0xc6, 0x6a, 0x92, 0xc5, 0x1e, 0x3d, 0xe0, 0x68, 0x1d,
0xaa, 0xfb, 0x84, 0xf1, 0x90, 0x26, 0xed, 0x05, 0x35, 0x8a, 0xae, 0x1e, 0x31, 0xae, 0x69, 0xc4,
0x48, 0x75, 0xcf, 0xb4, 0xbc, 0x97, 0x6f, 0x74, 0xff, 0x59, 0x86, 0xf9, 0x5d, 0x82, 0x59, 0x6f,
0x70, 0x76, 0x40, 0x2d, 0x41, 0x85, 0x91, 0x17, 0x45, 0x73, 0xae, 0x17, 0x45, 0x7c, 0xed, 0x63,
0xe2, 0x5b, 0x3e, 0x41, 0xc7, 0x5e, 0x99, 0xd1, 0xb1, 0x3b, 0x60, 0x07, 0x3c, 0x52, 0xd0, 0xa9,
0x7b, 0xf2, 0x51, 0xf6, 0xd9, 0x69, 0x84, 0x7b, 0x64, 0x40, 0xa3, 0x80, 0x30, 0xbf, 0xcf, 0x68,
0xa6, 0xfb, 0xec, 0xa6, 0xe7, 0x8c, 0x31, 0x1e, 0x4a, 0x3a, 0xba, 0x0b, 0xb5, 0x80, 0x47, 0xbe,
0x18, 0xa6, 0x44, 0xe1, 0xa7, 0x75, 0xc4, 0x31, 0x3b, 0x3c, 0x7a, 0x3a, 0x4c, 0x89, 0x57, 0x0d,
0xf4, 0x03, 0xba, 0x0d, 0x4b, 0x9c, 0xb0, 0x10, 0x47, 0xe1, 0x2b, 0x12, 0xf8, 0xe4, 0x65, 0xca,
0xfc, 0x34, 0xc2, 0x89, 0x02, 0x59, 0xd3, 0x43, 0x23, 0xde, 0x83, 0x97, 0x29, 0xdb, 0x89, 0x70,
0x82, 0x56, 0xc1, 0xa1, 0x99, 0x48, 0x33, 0xe1, 0x1b, 0x18, 0x84, 0x81, 0xc2, 0x9c, 0xed, 0xb5,
0x34, 0x5d, 0x45, 0x9d, 0x6f, 0x06, 0x33, 0xa7, 0x90, 0xc6, 0xa9, 0xa6, 0x90, 0xe6, 0xe9, 0xa6,
0x90, 0xf9, 0xd9, 0x53, 0x08, 0x6a, 0x41, 0x29, 0x79, 0xa1, 0xb0, 0x66, 0x7b, 0xa5, 0xe4, 0x85,
0x0c, 0xa4, 0xa0, 0xe9, 0x73, 0x85, 0x31, 0xdb, 0x53, 0xcf, 0x32, 0x89, 0x62, 0x22, 0x58, 0xd8,
0x93, 0x6e, 0x69, 0x3b, 0x2a, 0x0e, 0x63, 0x14, 0xf7, 0x3f, 0xf6, 0x08, 0x56, 0x3c, 0x8b, 0x04,
0xff, 0xa2, 0x26, 0x98, 0x02, 0x8b, 0xf6, 0x38, 0x16, 0xaf, 0x42, 0x43, 0x1b, 0xa7, 0x63, 0x5e,
0x9e, 0xb6, 0x57, 0x0a, 0xc8, 0x2c, 0x7b, 0x91, 0x11, 0x16, 0x12, 0x6e, 0xca, 0x3e, 0x24, 0x59,
0xfc, 0x44, 0x53, 0xd0, 0x39, 0xa8, 0x08, 0x9a, 0xfa, 0xcf, 0xf3, 0x72, 0x25, 0x68, 0xfa, 0x08,
0x7d, 0x0f, 0x96, 0x39, 0xc1, 0x11, 0x09, 0xfc, 0xa2, 0xbc, 0x70, 0x9f, 0xab, 0x63, 0x93, 0xa0,
0x5d, 0x55, 0x61, 0x6e, 0x6b, 0x89, 0xdd, 0x42, 0x60, 0xd7, 0xf0, 0x65, 0x14, 0x7b, 0xba, 0x6d,
0x9f, 0xd8, 0x56, 0x53, 0x9d, 0x3d, 0x1a, 0xb1, 0x8a, 0x0d, 0xdf, 0x86, 0x76, 0x3f, 0xa2, 0x5d,
0x1c, 0xf9, 0x87, 0xde, 0xaa, 0x46, 0x08, 0xdb, 0xbb, 0xa0, 0xf9, 0xbb, 0x53, 0xaf, 0x94, 0xc7,
0xe3, 0x51, 0xd8, 0x23, 0x81, 0xdf, 0x8d, 0x68, 0xb7, 0x0d, 0x0a, 0xae, 0xa0, 0x49, 0xb2, 0x5e,
0x49, 0x98, 0x1a, 0x01, 0xe9, 0x86, 0x1e, 0xcd, 0x12, 0xa1, 0xc0, 0x67, 0x7b, 0x2d, 0x4d, 0x7f,
0x9c, 0xc5, 0x1b, 0x92, 0x8a, 0xfe, 0x0f, 0xe6, 0x8d, 0x24, 0xdd, 0xdb, 0xe3, 0x44, 0x28, 0xd4,
0xd9, 0x5e, 0x53, 0x13, 0x7f, 0xa4, 0x68, 0xee, 0x9f, 0x6d, 0x58, 0xf0, 0xa4, 0x77, 0xc9, 0x3e,
0xf9, 0x5f, 0xaa, 0x2b, 0x47, 0xe5, 0xf7, 0xdc, 0xa9, 0xf2, 0xbb, 0x7a, 0xe2, 0xfc, 0xae, 0x9d,
0x2a, 0xbf, 0xeb, 0xa7, 0xcb, 0x6f, 0x38, 0x22, 0xbf, 0x97, 0xa0, 0x12, 0x85, 0x71, 0x98, 0x07,
0x58, 0x2f, 0xdc, 0x3f, 0x4c, 0x84, 0xec, 0x2d, 0xc8, 0xd9, 0xeb, 0x60, 0x87, 0x81, 0x6e, 0x20,
0x1b, 0x6b, 0xed, 0x99, 0x37, 0xe6, 0x66, 0x87, 0x7b, 0x52, 0x68, 0xfa, 0x96, 0xad, 0x9c, 0xfa,
0x96, 0xfd, 0x3e, 0x5c, 0x3a, 0x9c, 0xc9, 0xcc, 0xb8, 0x23, 0x68, 0xcf, 0xa9, 0x88, 0x5e, 0x9c,
0x4e, 0xe5, 0xdc, 0x5f, 0x01, 0xfa, 0x16, 0x2c, 0x8d, 0xe5, 0xf2, 0x68, 0x63, 0x55, 0x4f, 0xf6,
0x23, 0xde, 0x68, 0xcb, 0x71, 0xd9, 0x5c, 0x3b, 0x2e, 0x9b, 0xdd, 0xbf, 0xdb, 0x30, 0xdf, 0x21,
0x11, 0x11, 0xe4, 0xab, 0x26, 0xf0, 0xc8, 0x26, 0xf0, 0x9b, 0x80, 0xc2, 0x44, 0xdc, 0xf9, 0xc8,
0x4f, 0x59, 0x18, 0x63, 0x36, 0xf4, 0x9f, 0x93, 0x61, 0x5e, 0x26, 0x1d, 0xc5, 0xd9, 0xd1, 0x8c,
0x47, 0x64, 0xc8, 0x5f, 0xdb, 0x14, 0x8e, 0x77, 0x61, 0x3a, 0x6d, 0x8a, 0x2e, 0xec, 0xbb, 0xd0,
0x9c, 0x78, 0x45, 0xf3, 0x35, 0x80, 0x6d, 0xa4, 0xa3, 0xf7, 0xba, 0xff, 0xb6, 0xa0, 0xbe, 0x45,
0x71, 0xa0, 0xe6, 0xa1, 0x33, 0x86, 0xb1, 0x68, 0x75, 0x4b, 0xd3, 0xad, 0xee, 0x65, 0x18, 0x8d,
0x34, 0x26, 0x90, 0x63, 0x33, 0xce, 0xd8, 0xac, 0x52, 0x9e, 0x9c, 0x55, 0xae, 0x42, 0x23, 0x94,
0x06, 0xf9, 0x29, 0x16, 0x03, 0x5d, 0x29, 0xeb, 0x1e, 0x28, 0xd2, 0x8e, 0xa4, 0xc8, 0x61, 0x26,
0x17, 0x50, 0xc3, 0xcc, 0xdc, 0x89, 0x87, 0x19, 0xa3, 0x44, 0x0d, 0x33, 0xbf, 0xb0, 0x00, 0xd4,
0xc1, 0x65, 0x3d, 0x38, 0xac, 0xd4, 0x3a, 0x8b, 0x52, 0x59, 0xc2, 0x55, 0xa4, 0x48, 0x84, 0xc5,
0x28, 0xa9, 0xb8, 0x71, 0x0e, 0x92, 0x51, 0xd3, 0x2c, 0x93, 0x50, 0xdc, 0xfd, 0xb5, 0x05, 0xa0,
0xaa, 0x82, 0x36, 0x63, 0x1a, 0x7e, 0xd6, 0xf1, 0x63, 0x5e, 0x69, 0xd2, 0x75, 0xeb, 0xb9, 0xeb,
0x8e, 0xf9, 0x8e, 0x3a, 0xd6, 0x97, 0xe7, 0x87, 0x37, 0xde, 0x55, 0xcf, 0xee, 0x6f, 0x2c, 0x68,
0x1a, 0xeb, 0xb4, 0x49, 0x13, 0x51, 0xb6, 0xa6, 0xa3, 0xac, 0x9a, 0x9b, 0x98, 0xb2, 0xa1, 0xcf,
0xc3, 0x57, 0xc4, 0x18, 0x04, 0x9a, 0xb4, 0x1b, 0xbe, 0x22, 0x13, 0xe0, 0xb5, 0x27, 0xc1, 0x7b,
0x03, 0x16, 0x19, 0xe9, 0x91, 0x44, 0x44, 0x43, 0x3f, 0xa6, 0x41, 0xb8, 0x17, 0x92, 0x40, 0xa1,
0xa1, 0xe6, 0x39, 0x39, 0x63, 0xdb, 0xd0, 0xdd, 0x9f, 0x5b, 0xd0, 0xd8, 0xe6, 0xfd, 0x1d, 0xca,
0x55, 0x92, 0xa1, 0x6b, 0xd0, 0x34, 0x85, 0x4d, 0x67, 0xb8, 0xa5, 0x10, 0xd6, 0xe8, 0x8d, 0xbe,
0x45, 0xca, 0xd2, 0x1e, 0xf3, 0xbe, 0x71, 0x53, 0xd3, 0xd3, 0x0b, 0xb4, 0x0c, 0xb5, 0x98, 0xf7,
0x55, 0x2f, 0x6e, 0x60, 0x59, 0xac, 0xe5, 0x59, 0x47, 0x57, 0x58, 0x59, 0x5d, 0x61, 0x23, 0x82,
0xfb, 0x99, 0x05, 0xc8, 0x7c, 0xeb, 0x7c, 0xa3, 0x5f, 0x13, 0x2a, 0xca, 0xe3, 0xdf, 0x53, 0x4b,
0x0a, 0xe3, 0x13, 0xb4, 0xa9, 0xa2, 0x60, 0x1f, 0x2a, 0x0a, 0x37, 0x60, 0x31, 0x20, 0x7b, 0x38,
0x8b, 0xc6, 0x6f, 0x5d, 0x6d, 0xb2, 0x63, 0x18, 0x13, 0xdf, 0xf6, 0x5b, 0x1b, 0x8c, 0x04, 0x24,
0x11, 0x21, 0x8e, 0xd4, 0x2f, 0xa7, 0x65, 0xa8, 0x65, 0x5c, 0x22, 0xa1, 0xf0, 0x5d, 0xb1, 0x46,
0x1f, 0x00, 0x22, 0x49, 0x8f, 0x0d, 0x53, 0x09, 0xe2, 0x14, 0x73, 0x7e, 0x40, 0x59, 0x60, 0x0a,
0xf5, 0x62, 0xc1, 0xd9, 0x31, 0x0c, 0x39, 0xb4, 0x0a, 0x92, 0xe0, 0x44, 0xe4, 0xf5, 0x5a, 0xaf,
0x64, 0xe8, 0x43, 0xee, 0xf3, 0x2c, 0x25, 0xcc, 0x84, 0xb5, 0x1a, 0xf2, 0x5d, 0xb9, 0x94, 0xa5,
0x9c, 0x0f, 0xf0, 0xda, 0xc7, 0x77, 0x46, 0xea, 0x75, 0x89, 0x6e, 0x69, 0x72, 0xae, 0xdb, 0x7d,
0x00, 0x8b, 0x5b, 0x21, 0x17, 0x3b, 0x34, 0x0a, 0x7b, 0xc3, 0x33, 0xdf, 0x38, 0xee, 0xa7, 0x16,
0xa0, 0x71, 0x3d, 0xe6, 0xcf, 0xc6, 0xa8, 0x63, 0xb0, 0x4e, 0xde, 0x31, 0x5c, 0x83, 0x66, 0xaa,
0xd4, 0xa8, 0xff, 0xa8, 0x79, 0xf4, 0x1a, 0x9a, 0x26, 0x7d, 0xcb, 0xd1, 0x15, 0x00, 0xe9, 0x4c,
0x9f, 0xd1, 0x88, 0xe8, 0xe0, 0xd5, 0xbd, 0xba, 0xa4, 0x78, 0x92, 0xe0, 0xf6, 0xe1, 0xe2, 0xee,
0x80, 0x1e, 0x6c, 0xd0, 0x64, 0x2f, 0xec, 0x67, 0x0c, 0x4b, 0x40, 0xbf, 0xc1, 0x17, 0xb3, 0x36,
0x54, 0x53, 0x2c, 0x64, 0x5a, 0x9b, 0x18, 0xe5, 0x4b, 0xf7, 0xb7, 0x16, 0x2c, 0xcf, 0x7a, 0xd3,
0x9b, 0x1c, 0xff, 0x21, 0xcc, 0xf7, 0xb4, 0x3a, 0xad, 0xed, 0xe4, 0xbf, 0x0e, 0x27, 0xf7, 0xb9,
0x0f, 0xa0, 0xec, 0x61, 0x41, 0xd0, 0x2d, 0x28, 0x31, 0xa1, 0x2c, 0x68, 0xad, 0x5d, 0x3d, 0xa2,
0x58, 0x49, 0x41, 0x35, 0x0d, 0x97, 0x98, 0x40, 0x4d, 0xb0, 0x98, 0x3a, 0xa9, 0xe5, 0x59, 0xec,
0xfa, 0x03, 0xa8, 0x17, 0x7f, 0xbb, 0x91, 0x03, 0xcd, 0xcd, 0x24, 0x14, 0xaa, 0x51, 0x0e, 0x93,
0xbe, 0xf3, 0x0e, 0x6a, 0x40, 0xf5, 0x87, 0x04, 0x47, 0x62, 0x30, 0x74, 0x2c, 0xd4, 0x84, 0xda,
0xfd, 0x6e, 0x42, 0x59, 0x8c, 0x23, 0xa7, 0x24, 0x59, 0xbb, 0x02, 0x27, 0xc1, 0xfa, 0xd0, 0xb1,
0xaf, 0xaf, 0xc1, 0xe2, 0xa1, 0x2f, 0x15, 0x52, 0xde, 0xa3, 0x07, 0xd2, 0xd5, 0x81, 0xf3, 0x0e,
0x5a, 0x80, 0xc6, 0x06, 0x8d, 0xb2, 0x38, 0xd1, 0x04, 0xeb, 0xfa, 0x1f, 0x2d, 0xa8, 0xe5, 0x96,
0xa1, 0x45, 0x98, 0xef, 0x74, 0xb6, 0x46, 0xbf, 0x3d, 0x9c, 0x77, 0xa4, 0x35, 0x9d, 0xce, 0x56,
0xf1, 0xd1, 0x5c, 0x1b, 0xd0, 0xe9, 0x6c, 0xa9, 0xd2, 0xeb, 0x94, 0xcc, 0xea, 0x93, 0x28, 0xe3,
0x03, 0xc7, 0x2e, 0x14, 0xc4, 0x29, 0xd6, 0x0a, 0xca, 0x68, 0x1e, 0xea, 0x9d, 0xed, 0x2d, 0x6d,
0x97, 0x53, 0x31, 0x4b, 0xdd, 0x7d, 0x39, 0x73, 0xd2, 0x9e, 0xce, 0xf6, 0xd6, 0x7a, 0x16, 0x3d,
0x97, 0xb7, 0xb8, 0x53, 0x55, 0xfc, 0x27, 0x5b, 0x7a, 0x64, 0x73, 0x6a, 0x4a, 0xfd, 0x93, 0x2d,
0x39, 0x44, 0x0e, 0x9d, 0xfa, 0xfa, 0xdd, 0x9f, 0x7e, 0xdc, 0x0f, 0xc5, 0x20, 0xeb, 0xca, 0xd8,
0xdc, 0xd2, 0x6e, 0xfe, 0x20, 0xa4, 0xe6, 0xe9, 0x56, 0xee, 0xea, 0x5b, 0xca, 0xf3, 0xc5, 0x32,
0xed, 0x76, 0xe7, 0x14, 0xe5, 0xc3, 0xff, 0x06, 0x00, 0x00, 0xff, 0xff, 0x82, 0x36, 0x36, 0xda,
0x01, 0x21, 0x00, 0x00,
// 2194 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x59, 0xcd, 0x6f, 0xdb, 0xc8,
0x15, 0x5f, 0x8a, 0x92, 0x25, 0x3d, 0xc9, 0x0a, 0x3d, 0x71, 0xb2, 0x8c, 0x93, 0x6c, 0x1c, 0xf6,
0xcb, 0x4d, 0xba, 0x49, 0xea, 0xdd, 0x4d, 0x0a, 0xb4, 0xe8, 0x22, 0xb6, 0xb2, 0x81, 0x11, 0x3b,
0x75, 0xe8, 0x20, 0x40, 0x7b, 0x21, 0x46, 0xe2, 0x58, 0x9a, 0x86, 0xe4, 0x30, 0x33, 0x43, 0x3b,
0xca, 0xa9, 0x87, 0x9e, 0xba, 0x68, 0x6f, 0xbd, 0x14, 0x68, 0xcf, 0x45, 0x81, 0x02, 0xbd, 0xed,
0xb1, 0x40, 0x4f, 0x3d, 0xf5, 0xd4, 0xbf, 0xa6, 0xe8, 0xa1, 0x98, 0x19, 0x92, 0xfa, 0xb0, 0xe2,
0xd8, 0x0e, 0x76, 0x37, 0x05, 0xf6, 0xc6, 0x79, 0xef, 0xcd, 0xd7, 0xef, 0xfd, 0xde, 0xe3, 0x7b,
0x24, 0x74, 0x68, 0x22, 0x09, 0x4f, 0x70, 0x74, 0x2b, 0xe5, 0x4c, 0x32, 0x74, 0x21, 0xa6, 0xd1,
0x41, 0x26, 0xcc, 0xe8, 0x56, 0xa1, 0x5c, 0x69, 0xf7, 0x59, 0x1c, 0xb3, 0xc4, 0x88, 0x57, 0xda,
0xa2, 0x3f, 0x24, 0x31, 0x36, 0x23, 0xef, 0x32, 0x5c, 0x7a, 0x48, 0xe4, 0x53, 0x1a, 0x93, 0xa7,
0xb4, 0xff, 0x7c, 0x73, 0x88, 0x93, 0x84, 0x44, 0x3e, 0x79, 0x91, 0x11, 0x21, 0xbd, 0xab, 0x70,
0xf9, 0x21, 0x91, 0x7b, 0x12, 0x4b, 0x2a, 0x24, 0xed, 0x8b, 0x19, 0xf5, 0x05, 0x38, 0xff, 0x90,
0xc8, 0x6e, 0x38, 0x23, 0x7e, 0x06, 0x8d, 0xc7, 0x2c, 0x24, 0x5b, 0xc9, 0x3e, 0x43, 0x77, 0xa1,
0x8e, 0xc3, 0x90, 0x13, 0x21, 0x5c, 0x6b, 0xd5, 0x5a, 0x6b, 0xad, 0x5f, 0xb9, 0x35, 0x75, 0xc6,
0xfc, 0x64, 0xf7, 0x8d, 0x8d, 0x5f, 0x18, 0x23, 0x04, 0x55, 0xce, 0x22, 0xe2, 0x56, 0x56, 0xad,
0xb5, 0xa6, 0xaf, 0x9f, 0xbd, 0x5f, 0x02, 0x6c, 0x25, 0x54, 0xee, 0x62, 0x8e, 0x63, 0x81, 0x2e,
0xc2, 0x42, 0xa2, 0x76, 0xe9, 0xea, 0x85, 0x6d, 0x3f, 0x1f, 0xa1, 0x2e, 0xb4, 0x85, 0xc4, 0x5c,
0x06, 0xa9, 0xb6, 0x73, 0x2b, 0xab, 0xf6, 0x5a, 0x6b, 0xfd, 0xfa, 0xdc, 0x6d, 0x1f, 0x91, 0xd1,
0x33, 0x1c, 0x65, 0x64, 0x17, 0x53, 0xee, 0xb7, 0xf4, 0x34, 0xb3, 0xba, 0xf7, 0x73, 0x80, 0x3d,
0xc9, 0x69, 0x32, 0xd8, 0xa6, 0x42, 0xaa, 0xbd, 0x0e, 0x94, 0x9d, 0xba, 0x84, 0xbd, 0xd6, 0xf4,
0xf3, 0x11, 0xfa, 0x08, 0x16, 0x84, 0xc4, 0x32, 0x13, 0xfa, 0x9c, 0xad, 0xf5, 0xcb, 0x73, 0x77,
0xd9, 0xd3, 0x26, 0x7e, 0x6e, 0xea, 0x7d, 0x0a, 0xad, 0x02, 0xee, 0x1d, 0x31, 0x40, 0x77, 0xa0,
0xda, 0xc3, 0x82, 0x1c, 0x0b, 0xcf, 0x8e, 0x18, 0x6c, 0x60, 0x41, 0x7c, 0x6d, 0xe9, 0xfd, 0xb5,
0x02, 0xcb, 0x53, 0x6e, 0xc9, 0x81, 0x3f, 0xfd, 0x52, 0x0a, 0xe6, 0xb0, 0xb7, 0xd5, 0xd5, 0xc7,
0xb7, 0x7d, 0xfd, 0x8c, 0x3c, 0x68, 0xf7, 0x59, 0x14, 0x91, 0xbe, 0xa4, 0x2c, 0xd9, 0xea, 0xba,
0xb6, 0xd6, 0x4d, 0xc9, 0x94, 0x4d, 0x8a, 0xb9, 0xa4, 0x66, 0x28, 0xdc, 0xea, 0xaa, 0xad, 0x6c,
0x26, 0x65, 0xe8, 0xfb, 0xe0, 0x48, 0x8e, 0x0f, 0x48, 0x14, 0x48, 0x1a, 0x13, 0x21, 0x71, 0x9c,
0xba, 0xb5, 0x55, 0x6b, 0xad, 0xea, 0x9f, 0x33, 0xf2, 0xa7, 0x85, 0x18, 0xdd, 0x86, 0xf3, 0x83,
0x0c, 0x73, 0x9c, 0x48, 0x42, 0x26, 0xac, 0x17, 0xb4, 0x35, 0x2a, 0x55, 0xe3, 0x09, 0x37, 0x61,
0x49, 0x99, 0xb1, 0x4c, 0x4e, 0x98, 0xd7, 0xb5, 0xb9, 0x93, 0x2b, 0x4a, 0x63, 0xef, 0x0b, 0x0b,
0x2e, 0xcc, 0xe0, 0x25, 0x52, 0x96, 0x08, 0x72, 0x06, 0xc0, 0xce, 0xe2, 0x71, 0x74, 0x0f, 0x6a,
0xea, 0x49, 0xb8, 0xf6, 0x49, 0xb9, 0x68, 0xec, 0xbd, 0xdf, 0xd8, 0xf0, 0xfe, 0x26, 0x27, 0x58,
0x92, 0xcd, 0x12, 0xfd, 0xb3, 0x3b, 0xfb, 0x7d, 0xa8, 0x87, 0xbd, 0x20, 0xc1, 0x71, 0x11, 0x56,
0x0b, 0x61, 0xef, 0x31, 0x8e, 0x09, 0xfa, 0x2e, 0x74, 0xc6, 0xde, 0x55, 0x12, 0xed, 0xf3, 0xa6,
0x3f, 0x23, 0x45, 0xdf, 0x86, 0xc5, 0xd2, 0xc3, 0xda, 0xac, 0xaa, 0xcd, 0xa6, 0x85, 0x25, 0xa7,
0x6a, 0xc7, 0x70, 0x6a, 0x61, 0x0e, 0xa7, 0x56, 0xa1, 0x35, 0xc1, 0x1f, 0xed, 0x4d, 0xdb, 0x9f,
0x14, 0xa9, 0x30, 0x34, 0xb9, 0xcb, 0x6d, 0xac, 0x5a, 0x6b, 0x6d, 0x3f, 0x1f, 0xa1, 0x3b, 0x70,
0xfe, 0x80, 0x72, 0x99, 0xe1, 0x28, 0xcf, 0x44, 0xea, 0x1c, 0xc2, 0x6d, 0xea, 0x58, 0x9d, 0xa7,
0x42, 0xeb, 0xb0, 0x9c, 0x0e, 0x47, 0x82, 0xf6, 0x67, 0xa6, 0x80, 0x9e, 0x32, 0x57, 0xe7, 0xfd,
0xc3, 0x82, 0x0b, 0x5d, 0xce, 0xd2, 0x77, 0xc2, 0x15, 0x05, 0xc8, 0xd5, 0x63, 0x40, 0xae, 0x1d,
0x05, 0xd9, 0xfb, 0x6d, 0x05, 0x2e, 0x1a, 0x46, 0xed, 0x16, 0xc0, 0x7e, 0x09, 0xb7, 0xf8, 0x1e,
0x9c, 0x1b, 0xef, 0x6a, 0x0c, 0xe6, 0x5f, 0xe3, 0x3b, 0xd0, 0x29, 0x1d, 0x6c, 0xec, 0xbe, 0x5a,
0x4a, 0x79, 0x9f, 0x57, 0x60, 0x59, 0x39, 0xf5, 0x1b, 0x34, 0x14, 0x1a, 0x7f, 0xb2, 0x00, 0x19,
0x76, 0xdc, 0x8f, 0x28, 0x16, 0x5f, 0x27, 0x16, 0xcb, 0x50, 0xc3, 0xea, 0x0c, 0x39, 0x04, 0x66,
0xe0, 0x09, 0x70, 0x94, 0xb7, 0xbe, 0xac, 0xd3, 0x95, 0x9b, 0xda, 0x93, 0x9b, 0xfe, 0xd1, 0x82,
0xa5, 0xfb, 0x91, 0x24, 0xfc, 0x1d, 0x05, 0xe5, 0xef, 0x95, 0xc2, 0x6b, 0x5b, 0x49, 0x48, 0x5e,
0x7e, 0x9d, 0x07, 0xbc, 0x0a, 0xb0, 0x4f, 0x49, 0x14, 0x4e, 0xb2, 0xb7, 0xa9, 0x25, 0x6f, 0xc5,
0x5c, 0x17, 0xea, 0x7a, 0x91, 0x92, 0xb5, 0xc5, 0x50, 0x55, 0x7b, 0xe4, 0xa5, 0xe4, 0xb8, 0xa8,
0xf6, 0x1a, 0x27, 0xae, 0xf6, 0xf4, 0xb4, 0xbc, 0xda, 0xfb, 0x57, 0x15, 0x16, 0xb7, 0x12, 0x41,
0xb8, 0x3c, 0x3b, 0x78, 0x57, 0xa0, 0x29, 0x86, 0x98, 0xeb, 0x8b, 0xe6, 0xf0, 0x8d, 0x05, 0x93,
0xd0, 0xda, 0x6f, 0x82, 0xb6, 0x7a, 0xc2, 0xe4, 0x50, 0x3b, 0x2e, 0x39, 0x2c, 0x1c, 0x03, 0x71,
0xfd, 0xcd, 0xc9, 0xa1, 0x71, 0xf4, 0xed, 0xab, 0x2e, 0x48, 0x06, 0x31, 0x49, 0xe4, 0x56, 0xd7,
0x6d, 0x6a, 0xfd, 0x58, 0x80, 0x3e, 0x00, 0x28, 0x2b, 0x31, 0xf3, 0x1e, 0xad, 0xfa, 0x13, 0x12,
0xf5, 0xee, 0xe6, 0xec, 0x50, 0xd5, 0x8a, 0x2d, 0x5d, 0x2b, 0xe6, 0x23, 0xf4, 0x31, 0x34, 0x38,
0x3b, 0x0c, 0x42, 0x2c, 0xb1, 0xdb, 0xd6, 0xce, 0xbb, 0x34, 0x17, 0xec, 0x8d, 0x88, 0xf5, 0xfc,
0x3a, 0x67, 0x87, 0x5d, 0x2c, 0x31, 0xfa, 0x14, 0x5a, 0x9a, 0x01, 0xc2, 0x4c, 0x5c, 0xd4, 0x13,
0x3f, 0x98, 0x9e, 0x98, 0xb7, 0x39, 0x9f, 0x29, 0x3b, 0x35, 0xc9, 0x37, 0xd4, 0x14, 0x7a, 0x81,
0x4b, 0xd0, 0x48, 0xb2, 0x38, 0xe0, 0xec, 0x50, 0xb8, 0x1d, 0x5d, 0x37, 0xd6, 0x93, 0x2c, 0xf6,
0xd9, 0xa1, 0x40, 0x1b, 0x50, 0x3f, 0x20, 0x5c, 0x50, 0x96, 0xb8, 0xe7, 0x56, 0xad, 0xb5, 0xce,
0xfa, 0xda, 0xad, 0xb9, 0x6d, 0xd5, 0x2d, 0xc3, 0x18, 0xb5, 0xdc, 0x33, 0x63, 0xef, 0x17, 0x13,
0xbd, 0x7f, 0x57, 0x61, 0x71, 0x8f, 0x60, 0xde, 0x1f, 0x9e, 0x9d, 0x50, 0xcb, 0x50, 0xe3, 0xe4,
0x45, 0x59, 0x9c, 0x9b, 0x41, 0xe9, 0x5f, 0xfb, 0x18, 0xff, 0x56, 0x4f, 0x50, 0xb1, 0xd7, 0xe6,
0x54, 0xec, 0x0e, 0xd8, 0xa1, 0x88, 0x34, 0x75, 0x9a, 0xbe, 0x7a, 0x54, 0x75, 0x76, 0x1a, 0xe1,
0x3e, 0x19, 0xb2, 0x28, 0x24, 0x3c, 0x18, 0x70, 0x96, 0x99, 0x3a, 0xbb, 0xed, 0x3b, 0x13, 0x8a,
0x87, 0x4a, 0x8e, 0xee, 0x41, 0x23, 0x14, 0x51, 0x20, 0x47, 0x29, 0xd1, 0xfc, 0xe9, 0xbc, 0xe6,
0x9a, 0x5d, 0x11, 0x3d, 0x1d, 0xa5, 0xc4, 0xaf, 0x87, 0xe6, 0x01, 0xdd, 0x81, 0x65, 0x41, 0x38,
0xc5, 0x11, 0x7d, 0x45, 0xc2, 0x80, 0xbc, 0x4c, 0x79, 0x90, 0x46, 0x38, 0xd1, 0x24, 0x6b, 0xfb,
0x68, 0xac, 0x7b, 0xf0, 0x32, 0xe5, 0xbb, 0x11, 0x4e, 0xd0, 0x1a, 0x38, 0x2c, 0x93, 0x69, 0x26,
0x83, 0x9c, 0x06, 0x34, 0xd4, 0x9c, 0xb3, 0xfd, 0x8e, 0x91, 0x6b, 0xaf, 0x8b, 0xad, 0x70, 0x6e,
0x17, 0xd2, 0x3a, 0x55, 0x17, 0xd2, 0x3e, 0x5d, 0x17, 0xb2, 0x38, 0xbf, 0x0b, 0x41, 0x1d, 0xa8,
0x24, 0x2f, 0x34, 0xd7, 0x6c, 0xbf, 0x92, 0xbc, 0x50, 0x8e, 0x94, 0x2c, 0x7d, 0xae, 0x39, 0x66,
0xfb, 0xfa, 0x59, 0x05, 0x51, 0x4c, 0x24, 0xa7, 0x7d, 0x05, 0x8b, 0xeb, 0x68, 0x3f, 0x4c, 0x48,
0xbc, 0xff, 0xda, 0x63, 0x5a, 0x89, 0x2c, 0x92, 0xe2, 0xab, 0xea, 0x60, 0x4a, 0x2e, 0xda, 0x93,
0x5c, 0xbc, 0x06, 0x2d, 0x73, 0x38, 0xe3, 0xf3, 0xea, 0xec, 0x79, 0x95, 0x81, 0x8a, 0xb2, 0x17,
0x19, 0xe1, 0x94, 0x88, 0x3c, 0xed, 0x43, 0x92, 0xc5, 0x4f, 0x8c, 0x04, 0x9d, 0x87, 0x9a, 0x64,
0x69, 0xf0, 0xbc, 0x48, 0x57, 0x92, 0xa5, 0x8f, 0xd0, 0x4f, 0x60, 0x45, 0x10, 0x1c, 0x91, 0x30,
0x28, 0xd3, 0x8b, 0x08, 0x84, 0xbe, 0x36, 0x09, 0xdd, 0xba, 0x76, 0xb3, 0x6b, 0x2c, 0xf6, 0x4a,
0x83, 0xbd, 0x5c, 0xaf, 0xbc, 0xd8, 0x37, 0x65, 0xfb, 0xd4, 0xb4, 0x86, 0xae, 0xec, 0xd1, 0x58,
0x55, 0x4e, 0xf8, 0x11, 0xb8, 0x83, 0x88, 0xf5, 0x70, 0x14, 0x1c, 0xd9, 0x55, 0xb7, 0x10, 0xb6,
0x7f, 0xd1, 0xe8, 0xf7, 0x66, 0xb6, 0x54, 0xd7, 0x13, 0x11, 0xed, 0x93, 0x30, 0xe8, 0x45, 0xac,
0xe7, 0x82, 0xa6, 0x2b, 0x18, 0x91, 0xca, 0x57, 0x8a, 0xa6, 0xb9, 0x81, 0x82, 0xa1, 0xcf, 0xb2,
0x44, 0x6a, 0xf2, 0xd9, 0x7e, 0xc7, 0xc8, 0x1f, 0x67, 0xf1, 0xa6, 0x92, 0xa2, 0x6f, 0xc1, 0x62,
0x6e, 0xc9, 0xf6, 0xf7, 0x05, 0x91, 0x9a, 0x75, 0xb6, 0xdf, 0x36, 0xc2, 0x9f, 0x69, 0x99, 0xf7,
0x37, 0x1b, 0xce, 0xf9, 0x0a, 0x5d, 0x72, 0x40, 0xfe, 0x9f, 0xf2, 0xca, 0xeb, 0xe2, 0x7b, 0xe1,
0x54, 0xf1, 0x5d, 0x3f, 0x71, 0x7c, 0x37, 0x4e, 0x15, 0xdf, 0xcd, 0xd3, 0xc5, 0x37, 0xbc, 0x26,
0xbe, 0x97, 0xa1, 0x16, 0xd1, 0x98, 0x16, 0x0e, 0x36, 0x03, 0xef, 0xcf, 0x53, 0x2e, 0x7b, 0x07,
0x62, 0xf6, 0x06, 0xd8, 0x34, 0x34, 0x05, 0x64, 0x6b, 0xdd, 0x9d, 0xfb, 0xc6, 0xdc, 0xea, 0x0a,
0x5f, 0x19, 0xcd, 0xbe, 0x65, 0x6b, 0xa7, 0x7e, 0xcb, 0xfe, 0x14, 0x2e, 0x1f, 0x8d, 0x64, 0x9e,
0xc3, 0x11, 0xba, 0x0b, 0xda, 0xa3, 0x97, 0x66, 0x43, 0xb9, 0xc0, 0x2b, 0x44, 0x3f, 0x84, 0xe5,
0x89, 0x58, 0x1e, 0x4f, 0xac, 0x9b, 0xce, 0x7e, 0xac, 0x1b, 0x4f, 0x39, 0x2e, 0x9a, 0x1b, 0xc7,
0x45, 0xb3, 0xf7, 0x4f, 0x1b, 0x16, 0xbb, 0x24, 0x22, 0x92, 0x7c, 0x53, 0x04, 0xbe, 0xb6, 0x08,
0xfc, 0x01, 0x20, 0x9a, 0xc8, 0xbb, 0x1f, 0x07, 0x29, 0xa7, 0x31, 0xe6, 0xa3, 0xe0, 0x39, 0x19,
0x15, 0x69, 0xd2, 0xd1, 0x9a, 0x5d, 0xa3, 0x78, 0x44, 0x46, 0xe2, 0x8d, 0x45, 0xe1, 0x64, 0x15,
0x66, 0xc2, 0xa6, 0xac, 0xc2, 0x7e, 0x0c, 0xed, 0xa9, 0x2d, 0xda, 0x6f, 0x20, 0x6c, 0x2b, 0x1d,
0xef, 0xeb, 0xfd, 0xc7, 0x82, 0xe6, 0x36, 0xc3, 0xa1, 0xee, 0x87, 0xce, 0xe8, 0xc6, 0xb2, 0xd4,
0xad, 0xcc, 0x96, 0xba, 0x57, 0x60, 0xdc, 0xd2, 0xe4, 0x8e, 0x9c, 0xe8, 0x71, 0x26, 0x7a, 0x95,
0xea, 0x74, 0xaf, 0x72, 0x0d, 0x5a, 0x54, 0x1d, 0x28, 0x48, 0xb1, 0x1c, 0x9a, 0x4c, 0xd9, 0xf4,
0x41, 0x8b, 0x76, 0x95, 0x44, 0x35, 0x33, 0x85, 0x81, 0x6e, 0x66, 0x16, 0x4e, 0xdc, 0xcc, 0xe4,
0x8b, 0xe8, 0x66, 0xe6, 0xd7, 0x16, 0x80, 0xbe, 0xb8, 0xca, 0x07, 0x47, 0x17, 0xb5, 0xce, 0xb2,
0xa8, 0x4a, 0xe1, 0xda, 0x53, 0x24, 0xc2, 0x72, 0x1c, 0x54, 0x22, 0x07, 0x07, 0x29, 0xaf, 0x19,
0x55, 0x1e, 0x50, 0xc2, 0xfb, 0x9d, 0x05, 0xa0, 0xb3, 0x82, 0x39, 0xc6, 0x2c, 0xfd, 0xac, 0xe3,
0xdb, 0xbc, 0xca, 0x34, 0x74, 0x1b, 0x05, 0x74, 0xc7, 0x7c, 0x47, 0x9d, 0xa8, 0xcb, 0x8b, 0xcb,
0xe7, 0xe8, 0xea, 0x67, 0xef, 0xf7, 0x16, 0xb4, 0xf3, 0xd3, 0x99, 0x23, 0x4d, 0x79, 0xd9, 0x9a,
0xf5, 0xb2, 0x2e, 0x6e, 0x62, 0xc6, 0x47, 0x81, 0xa0, 0xaf, 0x48, 0x7e, 0x20, 0x30, 0xa2, 0x3d,
0xfa, 0x8a, 0x4c, 0x91, 0xd7, 0x9e, 0x26, 0xef, 0x4d, 0x58, 0xe2, 0xa4, 0x4f, 0x12, 0x19, 0x8d,
0x82, 0x98, 0x85, 0x74, 0x9f, 0x92, 0x50, 0xb3, 0xa1, 0xe1, 0x3b, 0x85, 0x62, 0x27, 0x97, 0x7b,
0xbf, 0xb2, 0xa0, 0xb5, 0x23, 0x06, 0xbb, 0x4c, 0xe8, 0x20, 0x43, 0xd7, 0xa1, 0x9d, 0x27, 0x36,
0x13, 0xe1, 0x96, 0x66, 0x58, 0xab, 0x3f, 0xfe, 0x16, 0xa9, 0x52, 0x7b, 0x2c, 0x06, 0x39, 0x4c,
0x6d, 0xdf, 0x0c, 0xd0, 0x0a, 0x34, 0x62, 0x31, 0xd0, 0xb5, 0x78, 0x4e, 0xcb, 0x72, 0xac, 0xee,
0x3a, 0x7e, 0x85, 0x55, 0xf5, 0x2b, 0x6c, 0x2c, 0xf0, 0xbe, 0xb0, 0x00, 0xe5, 0xdf, 0x3a, 0xdf,
0xea, 0xd7, 0x84, 0xf6, 0xf2, 0xe4, 0xf7, 0xd4, 0x8a, 0xe6, 0xf8, 0x94, 0x6c, 0x26, 0x29, 0xd8,
0x47, 0x92, 0xc2, 0x4d, 0x58, 0x0a, 0xc9, 0x3e, 0xce, 0xa2, 0xc9, 0xb7, 0xae, 0x39, 0xb2, 0x93,
0x2b, 0xa6, 0xbe, 0xed, 0x77, 0x36, 0x39, 0x09, 0x49, 0x22, 0x29, 0x8e, 0xf4, 0x2f, 0xa7, 0x15,
0x68, 0x64, 0x42, 0x31, 0xa1, 0xc4, 0xae, 0x1c, 0xa3, 0x0f, 0x01, 0x91, 0xa4, 0xcf, 0x47, 0xa9,
0x22, 0x71, 0x8a, 0x85, 0x38, 0x64, 0x3c, 0xcc, 0x13, 0xf5, 0x52, 0xa9, 0xd9, 0xcd, 0x15, 0xaa,
0x69, 0x95, 0x24, 0xc1, 0x89, 0x2c, 0xf2, 0xb5, 0x19, 0x29, 0xd7, 0x53, 0x11, 0x88, 0x2c, 0x25,
0x3c, 0x77, 0x6b, 0x9d, 0x8a, 0x3d, 0x35, 0x54, 0xa9, 0x5c, 0x0c, 0xf1, 0xfa, 0x27, 0x77, 0xc7,
0xcb, 0x9b, 0x14, 0xdd, 0x31, 0xe2, 0x62, 0x6d, 0xef, 0x01, 0x2c, 0x6d, 0x53, 0x21, 0x77, 0x59,
0x44, 0xfb, 0xa3, 0x33, 0xbf, 0x71, 0xbc, 0xcf, 0x2d, 0x40, 0x93, 0xeb, 0xe4, 0x7f, 0x36, 0xc6,
0x15, 0x83, 0x75, 0xf2, 0x8a, 0xe1, 0x3a, 0xb4, 0x53, 0xbd, 0x4c, 0x40, 0x93, 0x7d, 0x56, 0x78,
0xaf, 0x65, 0x64, 0x0a, 0x5b, 0x81, 0xae, 0x02, 0x28, 0x30, 0x03, 0xce, 0x22, 0x62, 0x9c, 0xd7,
0xf4, 0x9b, 0x4a, 0xe2, 0x2b, 0x81, 0x37, 0x80, 0x4b, 0x7b, 0x43, 0x76, 0xb8, 0xc9, 0x92, 0x7d,
0x3a, 0xc8, 0x38, 0x56, 0x84, 0x7e, 0x8b, 0x2f, 0x66, 0x2e, 0xd4, 0x53, 0x2c, 0x55, 0x58, 0xe7,
0x3e, 0x2a, 0x86, 0xde, 0x1f, 0x2c, 0x58, 0x99, 0xb7, 0xd3, 0xdb, 0x5c, 0xff, 0x21, 0x2c, 0xf6,
0xcd, 0x72, 0x66, 0xb5, 0x93, 0xff, 0x3a, 0x9c, 0x9e, 0xe7, 0x3d, 0x80, 0xaa, 0x8f, 0x25, 0x41,
0xb7, 0xa1, 0xc2, 0xa5, 0x3e, 0x41, 0x67, 0xfd, 0xda, 0x6b, 0x92, 0x95, 0x32, 0xd4, 0xdd, 0x70,
0x85, 0x4b, 0xd4, 0x06, 0x8b, 0xeb, 0x9b, 0x5a, 0xbe, 0xc5, 0x6f, 0xac, 0xc3, 0xd2, 0x91, 0x4f,
0x0c, 0xa8, 0x0d, 0x0d, 0x9f, 0x1d, 0x2a, 0x8c, 0x42, 0xe7, 0x3d, 0x74, 0x0e, 0x5a, 0x9b, 0x2c,
0xca, 0xe2, 0xc4, 0x08, 0xac, 0x1b, 0x7f, 0xb1, 0xa0, 0x51, 0x2c, 0x89, 0x96, 0x60, 0xb1, 0xdb,
0xdd, 0x1e, 0xff, 0xaf, 0x70, 0xde, 0x43, 0x0e, 0xb4, 0xbb, 0xdd, 0xed, 0xf2, 0x6b, 0xb7, 0x63,
0xa9, 0x05, 0xbb, 0xdd, 0x6d, 0x9d, 0x33, 0x9d, 0x4a, 0x3e, 0xfa, 0x2c, 0xca, 0xc4, 0xd0, 0xb1,
0xcb, 0x05, 0xe2, 0x14, 0x9b, 0x05, 0xaa, 0x68, 0x11, 0x9a, 0xdd, 0x9d, 0x6d, 0x73, 0x2e, 0xa7,
0x96, 0x0f, 0x4d, 0xd9, 0xe4, 0x2c, 0xa8, 0xf3, 0x74, 0x77, 0xb6, 0x37, 0xb2, 0xe8, 0xb9, 0x7a,
0xfd, 0x3a, 0x75, 0xad, 0x7f, 0xb2, 0x6d, 0x7a, 0x2d, 0xa7, 0xa1, 0x97, 0x7f, 0xb2, 0xad, 0xba,
0xbf, 0x91, 0xd3, 0xdc, 0xb8, 0xf7, 0x8b, 0x4f, 0x06, 0x54, 0x0e, 0xb3, 0x9e, 0x02, 0xf5, 0xb6,
0xc1, 0xe7, 0x43, 0xca, 0xf2, 0xa7, 0xdb, 0x05, 0x46, 0xb7, 0x35, 0x64, 0xe5, 0x30, 0xed, 0xf5,
0x16, 0xb4, 0xe4, 0xa3, 0xff, 0x05, 0x00, 0x00, 0xff, 0xff, 0xad, 0xe9, 0xa6, 0xf9, 0x00, 0x1f,
0x00, 0x00,
}

18
internal/proto/milvus.proto
View File

@ -63,6 +63,8 @@ service MilvusService {
// https://wiki.lfaidata.foundation/display/MIL/MEP+8+--+Add+metrics+for+proxy
rpc GetMetrics(GetMetricsRequest) returns (GetMetricsResponse) {}
rpc GetComponentStates(GetComponentStatesRequest) returns (ComponentStates) {}
rpc LoadBalance(LoadBalanceRequest) returns (common.Status) {}
rpc GetCompactionState(GetCompactionStateRequest) returns (GetCompactionStateResponse) {}
rpc ManualCompaction(ManualCompactionRequest) returns (ManualCompactionResponse) {}
@ -885,6 +887,22 @@ message GetMetricsResponse {
string component_name = 3; // metrics from which component
}
message ComponentInfo {
int64 nodeID = 1;
string role = 2;
common.StateCode state_code = 3;
repeated common.KeyValuePair extra_info = 4;
}
message ComponentStates {
ComponentInfo state = 1;
repeated ComponentInfo subcomponent_states = 2;
common.Status status = 3;
}
message GetComponentStatesRequest {
}
/*
* Do load balancing operation from src_nodeID to dst_nodeID.
*/

2
internal/proto/proxy.proto
View File

@ -8,7 +8,7 @@ import "internal.proto";
import "milvus.proto";
service Proxy {
rpc GetComponentStates(internal.GetComponentStatesRequest) returns (internal.ComponentStates) {}
rpc GetComponentStates(milvus.GetComponentStatesRequest) returns (milvus.ComponentStates) {}
rpc GetStatisticsChannel(internal.GetStatisticsChannelRequest) returns(milvus.StringResponse){}
rpc InvalidateCollectionMetaCache(InvalidateCollMetaCacheRequest) returns (common.Status) {}

86
internal/proto/proxypb/proxy.pb.go
View File

@ -309,43 +309,43 @@ func init() {
func init() { proto.RegisterFile("proxy.proto", fileDescriptor_700b50b08ed8dbaf) }
var fileDescriptor_700b50b08ed8dbaf = []byte{
// 575 bytes of a gzipped FileDescriptorProto
// 573 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x54, 0xdd, 0x6e, 0xda, 0x30,
0x18, 0x6d, 0xda, 0xd2, 0x76, 0x1f, 0xa8, 0x48, 0x56, 0xc7, 0x58, 0xba, 0x4e, 0x28, 0x95, 0x5a,
0x54, 0x69, 0xd0, 0xb2, 0x3d, 0x41, 0xa9, 0x84, 0xd0, 0x44, 0x55, 0x85, 0xed, 0x66, 0x37, 0x93,
0x93, 0x7c, 0x05, 0xa3, 0xc4, 0x4e, 0x63, 0xc3, 0xc6, 0xd5, 0xa4, 0xbd, 0xd3, 0xa4, 0x3d, 0xde,
0x94, 0x1f, 0x02, 0xa1, 0xa1, 0xd1, 0x56, 0xed, 0x8e, 0x63, 0x9f, 0xcf, 0xe7, 0x1c, 0xc7, 0x07,
0x28, 0xfb, 0x81, 0xf8, 0x3e, 0x6f, 0xf9, 0x81, 0x50, 0x82, 0x10, 0x8f, 0xb9, 0xb3, 0xa9, 0x8c,
0x51, 0x2b, 0xda, 0xd1, 0x2b, 0xb6, 0xf0, 0x3c, 0xc1, 0xe3, 0x35, 0xfd, 0x90, 0x71, 0x85, 0x01,
0xa7, 0x6e, 0x82, 0x2b, 0xab, 0x13, 0xc6, 0x6f, 0x0d, 0xde, 0xf6, 0xf9, 0x8c, 0xba, 0xcc, 0xa1,
0x0a, 0xbb, 0xc2, 0x75, 0x07, 0xa8, 0x68, 0x97, 0xda, 0x63, 0x34, 0xf1, 0x61, 0x8a, 0x52, 0x91,
0x4b, 0xd8, 0xb5, 0xa8, 0xc4, 0xba, 0xd6, 0xd0, 0x9a, 0xe5, 0xce, 0x9b, 0x56, 0x46, 0x31, 0x91,
0x1a, 0xc8, 0xd1, 0x35, 0x95, 0x68, 0x46, 0x4c, 0xf2, 0x0a, 0xf6, 0x1d, 0xeb, 0x2b, 0xa7, 0x1e,
0xd6, 0xb7, 0x1b, 0x5a, 0xf3, 0x85, 0xb9, 0xe7, 0x58, 0xb7, 0xd4, 0x43, 0x72, 0x0e, 0x55, 0x5b,
0xb8, 0x2e, 0xda, 0x8a, 0x09, 0x1e, 0x13, 0x76, 0x22, 0xc2, 0xe1, 0x72, 0x39, 0x22, 0x1a, 0x50,
0x59, 0xae, 0xf4, 0x6f, 0xea, 0xbb, 0x0d, 0xad, 0xb9, 0x63, 0x66, 0xd6, 0x8c, 0x09, 0xe8, 0x2b,
0xce, 0x03, 0x74, 0x9e, 0xe9, 0x5a, 0x87, 0x83, 0xa9, 0x0c, 0x6f, 0x2a, 0xb5, 0x9d, 0x62, 0xe3,
0xa7, 0x06, 0xb5, 0xcf, 0xfe, 0xff, 0x17, 0x0a, 0xf7, 0x7c, 0x2a, 0xe5, 0x37, 0x11, 0x38, 0xc9,
0xd5, 0xa4, 0xd8, 0xf8, 0x01, 0x27, 0x26, 0xde, 0x07, 0x28, 0xc7, 0x77, 0xc2, 0x65, 0xf6, 0xbc,
0xcf, 0xef, 0xc5, 0x33, 0xad, 0xd4, 0x60, 0x4f, 0xf8, 0x9f, 0xe6, 0x7e, 0x6c, 0xa4, 0x64, 0x26,
0x88, 0x1c, 0x41, 0x49, 0xf8, 0x1f, 0x71, 0x9e, 0x78, 0x88, 0x81, 0x31, 0x83, 0xea, 0x10, 0x95,
0x49, 0x15, 0xca, 0x7f, 0x97, 0xbc, 0x82, 0x52, 0x10, 0x9e, 0x50, 0xdf, 0x6e, 0xec, 0x34, 0xcb,
0x9d, 0xe3, 0xec, 0x48, 0xfa, 0x58, 0x43, 0x15, 0x33, 0x66, 0x76, 0x7e, 0xed, 0x43, 0xe9, 0x2e,
0x7c, 0xda, 0xc4, 0x07, 0xd2, 0x43, 0xd5, 0x15, 0x9e, 0x2f, 0x38, 0x72, 0x35, 0x54, 0xe1, 0x3e,
0xb9, 0xdc, 0x70, 0xc6, 0x63, 0x6a, 0x62, 0x5b, 0x3f, 0xdb, 0x30, 0xb1, 0x46, 0x37, 0xb6, 0xc8,
0x03, 0x1c, 0xf5, 0x30, 0x82, 0x4c, 0x2a, 0x66, 0xcb, 0xee, 0x98, 0x72, 0x8e, 0x2e, 0xe9, 0x6c,
0xd6, 0x7c, 0x44, 0x5e, 0xa8, 0x9e, 0x66, 0x67, 0x12, 0x30, 0x54, 0x01, 0xe3, 0x23, 0x13, 0xa5,
0x2f, 0xb8, 0x44, 0x63, 0x8b, 0x04, 0x70, 0x92, 0xad, 0x64, 0xfc, 0xe4, 0xd3, 0x62, 0xae, 0x6b,
0xc7, 0xff, 0x07, 0x4f, 0xb7, 0x58, 0x3f, 0xce, 0xfd, 0x34, 0xa1, 0xd5, 0x69, 0x18, 0x93, 0x42,
0xa5, 0x87, 0xea, 0xc6, 0x59, 0xc4, 0xbb, 0xd8, 0x1c, 0x2f, 0x25, 0xfd, 0x65, 0xac, 0x09, 0xbc,
0xce, 0xf6, 0x15, 0xb9, 0x62, 0xd4, 0x8d, 0x23, 0xb5, 0x0a, 0x22, 0xad, 0xb5, 0xae, 0x28, 0x8e,
0x05, 0x2f, 0x97, 0x75, 0x5d, 0xd5, 0xb9, 0xc8, 0xd3, 0xc9, 0x6f, 0x76, 0x91, 0xc6, 0x04, 0x6a,
0xf9, 0x75, 0x24, 0x57, 0x79, 0x22, 0x4f, 0x56, 0xb7, 0x48, 0xcb, 0x81, 0x6a, 0x0f, 0x55, 0xd4,
0x81, 0x01, 0xaa, 0x80, 0xd9, 0x92, 0x9c, 0xe5, 0xde, 0x7a, 0x0f, 0x55, 0x42, 0x58, 0x9c, 0x7c,
0x5e, 0xc8, 0x4b, 0xbf, 0xd0, 0x2d, 0x1c, 0x2c, 0xfa, 0x4d, 0x4e, 0xf3, 0x32, 0xac, 0xb5, 0xbf,
0xc0, 0xf5, 0xf5, 0x87, 0x2f, 0x9d, 0x11, 0x53, 0xe3, 0xa9, 0x15, 0xee, 0xb4, 0x63, 0xea, 0x3b,
0x26, 0x92, 0x5f, 0xed, 0xc5, 0xa3, 0x6a, 0x47, 0xd3, 0xed, 0x48, 0xc2, 0xb7, 0xac, 0xbd, 0x08,
0xbe, 0xff, 0x13, 0x00, 0x00, 0xff, 0xff, 0xa9, 0x32, 0xfe, 0x3d, 0xe8, 0x06, 0x00, 0x00,
0x18, 0x6d, 0xda, 0x42, 0xbb, 0x0f, 0x54, 0x24, 0xab, 0x63, 0x2c, 0x5d, 0x27, 0x94, 0x4e, 0x2b,
0xaa, 0x34, 0x58, 0xd9, 0x9e, 0xa0, 0x54, 0x42, 0x68, 0xa2, 0xaa, 0xc2, 0x76, 0xb3, 0x9b, 0xc9,
0x49, 0xbe, 0x82, 0x51, 0x62, 0xa7, 0xb1, 0x61, 0xe3, 0x6a, 0xd2, 0xde, 0x68, 0x77, 0x7b, 0xbc,
0x29, 0x3f, 0x04, 0xc2, 0x42, 0xa3, 0xad, 0xda, 0x1d, 0xc7, 0x3e, 0xf6, 0x39, 0x27, 0xfe, 0x0e,
0x50, 0xf1, 0x03, 0xf1, 0x6d, 0xd1, 0xf6, 0x03, 0xa1, 0x04, 0x21, 0x1e, 0x73, 0xe7, 0x33, 0x19,
0xa3, 0x76, 0xb4, 0xa3, 0x57, 0x6d, 0xe1, 0x79, 0x82, 0xc7, 0x6b, 0xfa, 0x11, 0xe3, 0x0a, 0x03,
0x4e, 0xdd, 0x04, 0x57, 0xd7, 0x4f, 0x18, 0xbf, 0x34, 0x78, 0x39, 0xe0, 0x73, 0xea, 0x32, 0x87,
0x2a, 0xec, 0x09, 0xd7, 0x1d, 0xa2, 0xa2, 0x3d, 0x6a, 0x4f, 0xd0, 0xc4, 0xfb, 0x19, 0x4a, 0x45,
0xde, 0xc2, 0xbe, 0x45, 0x25, 0x36, 0xb4, 0xa6, 0xd6, 0xaa, 0x74, 0x5f, 0xb4, 0x33, 0x8a, 0x89,
0xd4, 0x50, 0x8e, 0xaf, 0xa8, 0x44, 0x33, 0x62, 0x92, 0x67, 0x70, 0xe0, 0x58, 0x5f, 0x38, 0xf5,
0xb0, 0xb1, 0xdb, 0xd4, 0x5a, 0x4f, 0xcc, 0xb2, 0x63, 0xdd, 0x50, 0x0f, 0xc9, 0x39, 0xd4, 0x6c,
0xe1, 0xba, 0x68, 0x2b, 0x26, 0x78, 0x4c, 0xd8, 0x8b, 0x08, 0x47, 0xab, 0xe5, 0x88, 0x68, 0x40,
0x75, 0xb5, 0x32, 0xb8, 0x6e, 0xec, 0x37, 0xb5, 0xd6, 0x9e, 0x99, 0x59, 0x33, 0xa6, 0xa0, 0xaf,
0x39, 0x0f, 0xd0, 0x79, 0xa4, 0x6b, 0x1d, 0x0e, 0x67, 0x32, 0xfc, 0x52, 0xa9, 0xed, 0x14, 0x1b,
0x3f, 0x34, 0xa8, 0x7f, 0xf2, 0xff, 0xbf, 0x50, 0xb8, 0xe7, 0x53, 0x29, 0xbf, 0x8a, 0xc0, 0x49,
0x3e, 0x4d, 0x8a, 0x8d, 0xef, 0x70, 0x6a, 0xe2, 0x5d, 0x80, 0x72, 0x72, 0x2b, 0x5c, 0x66, 0x2f,
0x06, 0xfc, 0x4e, 0x3c, 0xd2, 0x4a, 0x1d, 0xca, 0xc2, 0xff, 0xb8, 0xf0, 0x63, 0x23, 0x25, 0x33,
0x41, 0xe4, 0x18, 0x4a, 0xc2, 0xff, 0x80, 0x8b, 0xc4, 0x43, 0x0c, 0x8c, 0x39, 0xd4, 0x46, 0xa8,
0x4c, 0xaa, 0x50, 0xfe, 0xbb, 0xe4, 0x25, 0x94, 0x82, 0xf0, 0x86, 0xc6, 0x6e, 0x73, 0xaf, 0x55,
0xe9, 0x9e, 0x64, 0x8f, 0xa4, 0xc3, 0x1a, 0xaa, 0x98, 0x31, 0xb3, 0xfb, 0xf3, 0x00, 0x4a, 0xb7,
0xe1, 0x68, 0x13, 0x17, 0x48, 0x1f, 0x55, 0x4f, 0x78, 0xbe, 0xe0, 0xc8, 0xd5, 0x48, 0x85, 0xfb,
0xa4, 0x9d, 0xbd, 0x23, 0x01, 0x7f, 0x12, 0x13, 0xd3, 0xfa, 0xab, 0x5c, 0xfe, 0x06, 0xd9, 0xd8,
0x21, 0xf7, 0x70, 0xdc, 0xc7, 0x08, 0x32, 0xa9, 0x98, 0x2d, 0x7b, 0x13, 0xca, 0x39, 0xba, 0xa4,
0xbb, 0xc5, 0x73, 0x1e, 0x79, 0xa9, 0x79, 0x96, 0xab, 0x39, 0x52, 0x01, 0xe3, 0x63, 0x13, 0xa5,
0x2f, 0xb8, 0x44, 0x63, 0x87, 0x04, 0x70, 0x9a, 0xad, 0x63, 0x3c, 0xee, 0x69, 0x29, 0x37, 0xb5,
0xe3, 0xff, 0x82, 0x87, 0x1b, 0xac, 0x9f, 0xe4, 0x3e, 0x4b, 0x68, 0x75, 0x16, 0xc6, 0xa4, 0x50,
0xed, 0xa3, 0xba, 0x76, 0x96, 0xf1, 0x2e, 0xb6, 0xc7, 0x4b, 0x49, 0x7f, 0x19, 0x6b, 0x0a, 0xcf,
0xb3, 0x5d, 0x45, 0xae, 0x18, 0x75, 0xe3, 0x48, 0xed, 0x82, 0x48, 0x1b, 0x8d, 0x2b, 0x8a, 0x63,
0xc1, 0xd3, 0x55, 0x55, 0xd7, 0x75, 0x2e, 0xf2, 0x74, 0xf2, 0x5b, 0x5d, 0xa4, 0x31, 0x85, 0x7a,
0x7e, 0x15, 0xc9, 0x65, 0x9e, 0xc8, 0x83, 0xb5, 0x2d, 0xd2, 0x72, 0xa0, 0xd6, 0x47, 0x15, 0xcd,
0xff, 0x10, 0x55, 0xc0, 0x6c, 0x49, 0x5e, 0x6f, 0x1b, 0xf8, 0x84, 0xb0, 0xbc, 0xf9, 0xbc, 0x90,
0x97, 0xbe, 0xd0, 0x0d, 0x1c, 0x2e, 0xbb, 0x4d, 0xce, 0xf2, 0x32, 0x6c, 0x34, 0xbf, 0xc0, 0xf5,
0xd5, 0xfb, 0xcf, 0xdd, 0x31, 0x53, 0x93, 0x99, 0x15, 0xee, 0x74, 0x62, 0xea, 0x1b, 0x26, 0x92,
0x5f, 0x9d, 0xe5, 0x50, 0x75, 0xa2, 0xd3, 0x9d, 0x48, 0xc2, 0xb7, 0xac, 0x72, 0x04, 0xdf, 0xfd,
0x0e, 0x00, 0x00, 0xff, 0xff, 0x9d, 0xbe, 0x61, 0x31, 0xe4, 0x06, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
@ -360,7 +360,7 @@ const _ = grpc.SupportPackageIsVersion4
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type ProxyClient interface {
GetComponentStates(ctx context.Context, in *internalpb.GetComponentStatesRequest, opts ...grpc.CallOption) (*internalpb.ComponentStates, error)
GetComponentStates(ctx context.Context, in *milvuspb.GetComponentStatesRequest, opts ...grpc.CallOption) (*milvuspb.ComponentStates, error)
GetStatisticsChannel(ctx context.Context, in *internalpb.GetStatisticsChannelRequest, opts ...grpc.CallOption) (*milvuspb.StringResponse, error)
InvalidateCollectionMetaCache(ctx context.Context, in *InvalidateCollMetaCacheRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
GetDdChannel(ctx context.Context, in *internalpb.GetDdChannelRequest, opts ...grpc.CallOption) (*milvuspb.StringResponse, error)
@ -379,8 +379,8 @@ func NewProxyClient(cc *grpc.ClientConn) ProxyClient {
return &proxyClient{cc}
}
func (c *proxyClient) GetComponentStates(ctx context.Context, in *internalpb.GetComponentStatesRequest, opts ...grpc.CallOption) (*internalpb.ComponentStates, error) {
out := new(internalpb.ComponentStates)
func (c *proxyClient) GetComponentStates(ctx context.Context, in *milvuspb.GetComponentStatesRequest, opts ...grpc.CallOption) (*milvuspb.ComponentStates, error) {
out := new(milvuspb.ComponentStates)
err := c.cc.Invoke(ctx, "/milvus.proto.proxy.Proxy/GetComponentStates", in, out, opts...)
if err != nil {
return nil, err
@ -462,7 +462,7 @@ func (c *proxyClient) SetRates(ctx context.Context, in *SetRatesRequest, opts ..
// ProxyServer is the server API for Proxy service.
type ProxyServer interface {
GetComponentStates(context.Context, *internalpb.GetComponentStatesRequest) (*internalpb.ComponentStates, error)
GetComponentStates(context.Context, *milvuspb.GetComponentStatesRequest) (*milvuspb.ComponentStates, error)
GetStatisticsChannel(context.Context, *internalpb.GetStatisticsChannelRequest) (*milvuspb.StringResponse, error)
InvalidateCollectionMetaCache(context.Context, *InvalidateCollMetaCacheRequest) (*commonpb.Status, error)
GetDdChannel(context.Context, *internalpb.GetDdChannelRequest) (*milvuspb.StringResponse, error)
@ -477,7 +477,7 @@ type ProxyServer interface {
type UnimplementedProxyServer struct {
}
func (*UnimplementedProxyServer) GetComponentStates(ctx context.Context, req *internalpb.GetComponentStatesRequest) (*internalpb.ComponentStates, error) {
func (*UnimplementedProxyServer) GetComponentStates(ctx context.Context, req *milvuspb.GetComponentStatesRequest) (*milvuspb.ComponentStates, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetComponentStates not implemented")
}
func (*UnimplementedProxyServer) GetStatisticsChannel(ctx context.Context, req *internalpb.GetStatisticsChannelRequest) (*milvuspb.StringResponse, error) {
@ -510,7 +510,7 @@ func RegisterProxyServer(s *grpc.Server, srv ProxyServer) {
}
func _Proxy_GetComponentStates_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(internalpb.GetComponentStatesRequest)
in := new(milvuspb.GetComponentStatesRequest)
if err := dec(in); err != nil {
return nil, err
}
@ -522,7 +522,7 @@ func _Proxy_GetComponentStates_Handler(srv interface{}, ctx context.Context, dec
FullMethod: "/milvus.proto.proxy.Proxy/GetComponentStates",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ProxyServer).GetComponentStates(ctx, req.(*internalpb.GetComponentStatesRequest))
return srv.(ProxyServer).GetComponentStates(ctx, req.(*milvuspb.GetComponentStatesRequest))
}
return interceptor(ctx, in, info, handler)
}

4
internal/proto/query_coord.proto
View File

@ -11,7 +11,7 @@ import "schema.proto";
import "data_coord.proto";
service QueryCoord {
rpc GetComponentStates(internal.GetComponentStatesRequest) returns (internal.ComponentStates) {}
rpc GetComponentStates(milvus.GetComponentStatesRequest) returns (milvus.ComponentStates) {}
rpc GetTimeTickChannel(internal.GetTimeTickChannelRequest) returns(milvus.StringResponse) {}
rpc GetStatisticsChannel(internal.GetStatisticsChannelRequest) returns(milvus.StringResponse){}
@ -37,7 +37,7 @@ service QueryCoord {
}
service QueryNode {
rpc GetComponentStates(internal.GetComponentStatesRequest) returns (internal.ComponentStates) {}
rpc GetComponentStates(milvus.GetComponentStatesRequest) returns (milvus.ComponentStates) {}
rpc GetTimeTickChannel(internal.GetTimeTickChannelRequest) returns(milvus.StringResponse) {}
rpc GetStatisticsChannel(internal.GetStatisticsChannelRequest) returns(milvus.StringResponse){}

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

@ -3654,229 +3654,229 @@ func init() {
func init() { proto.RegisterFile("query_coord.proto", fileDescriptor_aab7cc9a69ed26e8) }
var fileDescriptor_aab7cc9a69ed26e8 = []byte{
// 3540 bytes of a gzipped FileDescriptorProto
// 3543 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x3b, 0x49, 0x6c, 0x1c, 0xd7,
0x95, 0xac, 0x5e, 0xc8, 0xee, 0xd7, 0x0b, 0x8b, 0x9f, 0x12, 0xd5, 0x6e, 0x6b, 0x73, 0xc9, 0x92,
0x39, 0x94, 0x4d, 0xca, 0x94, 0x6d, 0xc8, 0x33, 0x36, 0x66, 0x24, 0xd2, 0xa2, 0x39, 0x92, 0x68,
0x4e, 0xb5, 0xa4, 0x19, 0x08, 0xc6, 0xf4, 0x54, 0x77, 0x7d, 0x36, 0x0b, 0xaa, 0xa5, 0x55, 0x55,
0x4d, 0x89, 0x9e, 0x6b, 0x2e, 0x59, 0x81, 0xe4, 0x90, 0x53, 0x92, 0x53, 0x02, 0x24, 0x81, 0x0d,
0x24, 0x40, 0x02, 0xe4, 0x10, 0x04, 0x01, 0x72, 0x48, 0x4e, 0x41, 0x0e, 0x39, 0x06, 0xc8, 0x31,
0x87, 0xe4, 0x9a, 0x43, 0x6e, 0xc1, 0xdf, 0x6a, 0x2f, 0xb2, 0x44, 0x5a, 0x5e, 0x82, 0xdc, 0xba,
0xde, 0x5f, 0xde, 0xfb, 0x6f, 0x7f, 0xef, 0xff, 0x86, 0xb9, 0x47, 0x13, 0xec, 0xee, 0xf7, 0x87,
0x8e, 0xe3, 0xea, 0xcb, 0x63, 0xd7, 0xf1, 0x1d, 0x84, 0x2c, 0xc3, 0xdc, 0x9b, 0x78, 0xec, 0x6b,
0x99, 0x8e, 0x77, 0x9b, 0x43, 0xc7, 0xb2, 0x1c, 0x9b, 0xc1, 0xba, 0xcd, 0xe8, 0x8c, 0x6e, 0xdb,
0xb0, 0x7d, 0xec, 0xda, 0x9a, 0x29, 0x46, 0xbd, 0xe1, 0x2e, 0xb6, 0x34, 0xfe, 0x25, 0xeb, 0x9a,
0xaf, 0x45, 0xf7, 0x57, 0xbe, 0x20, 0xc1, 0x42, 0x6f, 0xd7, 0x79, 0xbc, 0xe6, 0x98, 0x26, 0x1e,
0xfa, 0x86, 0x63, 0x7b, 0x2a, 0x7e, 0x34, 0xc1, 0x9e, 0x8f, 0xae, 0x40, 0x65, 0xa0, 0x79, 0xb8,
0x23, 0x9d, 0x97, 0x16, 0x1b, 0xab, 0xa7, 0x97, 0x63, 0x94, 0x70, 0x12, 0xee, 0x78, 0xa3, 0x1b,
0x9a, 0x87, 0x55, 0x3a, 0x13, 0x21, 0xa8, 0xe8, 0x83, 0xcd, 0xf5, 0x4e, 0xe9, 0xbc, 0xb4, 0x58,
0x56, 0xe9, 0x6f, 0xf4, 0x22, 0xb4, 0x86, 0xc1, 0xde, 0x9b, 0xeb, 0x5e, 0xa7, 0x7c, 0xbe, 0xbc,
0x58, 0x56, 0xe3, 0x40, 0xe5, 0x8f, 0x12, 0x9c, 0x4a, 0x91, 0xe1, 0x8d, 0x1d, 0xdb, 0xc3, 0xe8,
0x2a, 0x4c, 0x7b, 0xbe, 0xe6, 0x4f, 0x3c, 0x4e, 0xc9, 0xf3, 0x99, 0x94, 0xf4, 0xe8, 0x14, 0x95,
0x4f, 0x4d, 0xa3, 0x2d, 0x65, 0xa0, 0x45, 0xaf, 0xc2, 0x09, 0xc3, 0xbe, 0x83, 0x2d, 0xc7, 0xdd,
0xef, 0x8f, 0xb1, 0x3b, 0xc4, 0xb6, 0xaf, 0x8d, 0xb0, 0xa0, 0x71, 0x5e, 0x8c, 0x6d, 0x87, 0x43,
0xe8, 0x0d, 0x38, 0xc5, 0xa4, 0xe4, 0x61, 0x77, 0xcf, 0x18, 0xe2, 0xbe, 0xb6, 0xa7, 0x19, 0xa6,
0x36, 0x30, 0x71, 0xa7, 0x72, 0xbe, 0xbc, 0x58, 0x53, 0x4f, 0xd2, 0xe1, 0x1e, 0x1b, 0xbd, 0x2e,
0x06, 0x95, 0xef, 0x49, 0x70, 0x92, 0x9c, 0x70, 0x5b, 0x73, 0x7d, 0xe3, 0x19, 0xf0, 0x59, 0x81,
0x66, 0xf4, 0x6c, 0x9d, 0x32, 0x1d, 0x8b, 0xc1, 0xc8, 0x9c, 0xb1, 0x40, 0x4f, 0x78, 0x52, 0xa1,
0xc7, 0x8c, 0xc1, 0x94, 0xef, 0x72, 0x85, 0x88, 0xd2, 0x79, 0x1c, 0x41, 0x24, 0x71, 0x96, 0xd2,
0x38, 0x8f, 0x20, 0x06, 0xe5, 0x4f, 0x12, 0x9c, 0xbc, 0xed, 0x68, 0x7a, 0xa8, 0x30, 0x9f, 0x3c,
0x3b, 0xdf, 0x86, 0x69, 0x66, 0x5d, 0x9d, 0x0a, 0xc5, 0x75, 0x31, 0x8e, 0x8b, 0x5b, 0x5e, 0x48,
0x61, 0x8f, 0x02, 0x54, 0xbe, 0x08, 0x5d, 0x84, 0xb6, 0x8b, 0xc7, 0xa6, 0x31, 0xd4, 0xfa, 0xf6,
0xc4, 0x1a, 0x60, 0xb7, 0x53, 0x3d, 0x2f, 0x2d, 0x56, 0xd5, 0x16, 0x87, 0x6e, 0x51, 0xa0, 0xf2,
0x2d, 0x09, 0x3a, 0x2a, 0x36, 0xb1, 0xe6, 0xe1, 0x4f, 0xf3, 0xb0, 0x0b, 0x30, 0x6d, 0x3b, 0x3a,
0xde, 0x5c, 0xa7, 0x87, 0x2d, 0xab, 0xfc, 0x4b, 0xf9, 0x9b, 0x04, 0x27, 0x36, 0xb0, 0x4f, 0xa4,
0x6e, 0x78, 0xbe, 0x31, 0x0c, 0xd4, 0xfa, 0x6d, 0x28, 0xbb, 0xf8, 0x11, 0xa7, 0xec, 0x72, 0x9c,
0xb2, 0xc0, 0x49, 0x65, 0xad, 0x54, 0xc9, 0x3a, 0xf4, 0x02, 0x34, 0x75, 0xcb, 0xec, 0x0f, 0x77,
0x35, 0xdb, 0xc6, 0x26, 0xd3, 0x9b, 0xba, 0xda, 0xd0, 0x2d, 0x73, 0x8d, 0x83, 0xd0, 0x59, 0x00,
0x0f, 0x8f, 0x2c, 0x6c, 0xfb, 0xa1, 0x5f, 0x89, 0x40, 0xd0, 0x12, 0xcc, 0xed, 0xb8, 0x8e, 0xd5,
0xf7, 0x76, 0x35, 0x57, 0xef, 0x9b, 0x58, 0xd3, 0xb1, 0x4b, 0xa9, 0xaf, 0xa9, 0xb3, 0x64, 0xa0,
0x47, 0xe0, 0xb7, 0x29, 0x18, 0x5d, 0x85, 0xaa, 0x37, 0x74, 0xc6, 0x98, 0xca, 0xa0, 0xbd, 0x7a,
0x66, 0x39, 0xed, 0x77, 0x97, 0xd7, 0x35, 0x5f, 0xeb, 0x91, 0x49, 0x2a, 0x9b, 0xab, 0x7c, 0xb9,
0xc4, 0x94, 0xf0, 0x33, 0x6e, 0xd3, 0x11, 0x45, 0xad, 0x7e, 0x3c, 0x8a, 0x3a, 0x9d, 0xa5, 0xa8,
0xbf, 0x0c, 0x15, 0xf5, 0xb3, 0xce, 0x90, 0x50, 0x99, 0xab, 0x31, 0x65, 0xfe, 0x81, 0x04, 0xcf,
0x6d, 0x60, 0x3f, 0x20, 0x9f, 0xe8, 0x26, 0xfe, 0x8c, 0x3a, 0xea, 0x8f, 0x24, 0xe8, 0x66, 0xd1,
0x7a, 0x1c, 0x67, 0xfd, 0x00, 0x16, 0x02, 0x1c, 0x7d, 0x1d, 0x7b, 0x43, 0xd7, 0x18, 0x53, 0x31,
0x52, 0xf3, 0x6b, 0xac, 0x5e, 0xc8, 0x32, 0x8b, 0x24, 0x05, 0x27, 0x83, 0x2d, 0xd6, 0x23, 0x3b,
0x28, 0x5f, 0x95, 0xe0, 0x24, 0x31, 0x77, 0x6e, 0x9f, 0xf6, 0x8e, 0x73, 0x74, 0xbe, 0xc6, 0x2d,
0xbf, 0x94, 0xb2, 0xfc, 0x02, 0x3c, 0xa6, 0x99, 0x4f, 0x92, 0x9e, 0xe3, 0xf0, 0xee, 0x75, 0xa8,
0x1a, 0xf6, 0x8e, 0x23, 0x58, 0x75, 0x2e, 0x8b, 0x55, 0x51, 0x64, 0x6c, 0xb6, 0x62, 0x33, 0x2a,
0x42, 0x57, 0x74, 0x0c, 0x75, 0x4b, 0x1e, 0xbb, 0x94, 0x71, 0xec, 0xaf, 0x48, 0x70, 0x2a, 0x85,
0xf0, 0x38, 0xe7, 0x7e, 0x0b, 0xa6, 0xa9, 0x83, 0x15, 0x07, 0x7f, 0x31, 0xf3, 0xe0, 0x11, 0x74,
0xb7, 0x0d, 0xcf, 0x57, 0xf9, 0x1a, 0xc5, 0x01, 0x39, 0x39, 0x46, 0x5c, 0x3f, 0x77, 0xfb, 0x7d,
0x5b, 0xb3, 0x18, 0x03, 0xea, 0x6a, 0x83, 0xc3, 0xb6, 0x34, 0x0b, 0xa3, 0xe7, 0xa0, 0x46, 0x4c,
0xb6, 0x6f, 0xe8, 0x42, 0xfc, 0x33, 0xd4, 0x84, 0x75, 0x0f, 0x9d, 0x01, 0xa0, 0x43, 0x9a, 0xae,
0xbb, 0x2c, 0x2a, 0xd4, 0xd5, 0x3a, 0x81, 0x5c, 0x27, 0x00, 0xe5, 0xeb, 0x12, 0x34, 0x89, 0xcf,
0xbe, 0x83, 0x7d, 0x8d, 0xc8, 0x01, 0xbd, 0x09, 0x75, 0xd3, 0xd1, 0xf4, 0xbe, 0xbf, 0x3f, 0x66,
0xa8, 0xda, 0x49, 0x5e, 0xb3, 0x23, 0x90, 0x45, 0x77, 0xf7, 0xc7, 0x58, 0xad, 0x99, 0xfc, 0x57,
0x11, 0x7e, 0xa7, 0x4c, 0xb9, 0x9c, 0x61, 0xca, 0x1f, 0x56, 0x61, 0xe1, 0xbf, 0x35, 0x7f, 0xb8,
0xbb, 0x6e, 0x89, 0xe0, 0x76, 0x74, 0x25, 0x08, 0x7d, 0x5b, 0x29, 0xea, 0xdb, 0x3e, 0x36, 0xdf,
0x19, 0xe8, 0x79, 0x35, 0x4b, 0xcf, 0x49, 0x81, 0xb1, 0x7c, 0x9f, 0x8b, 0x2a, 0xa2, 0xe7, 0x91,
0x18, 0x34, 0x7d, 0x94, 0x18, 0xb4, 0x06, 0x2d, 0xfc, 0x64, 0x68, 0x4e, 0x88, 0xcc, 0x29, 0xf6,
0x19, 0x8a, 0xfd, 0x6c, 0x06, 0xf6, 0xa8, 0x91, 0x35, 0xf9, 0xa2, 0x4d, 0x4e, 0x03, 0x13, 0xb5,
0x85, 0x7d, 0xad, 0x53, 0xa3, 0x64, 0x9c, 0xcf, 0x13, 0xb5, 0xd0, 0x0f, 0x26, 0x6e, 0xf2, 0x85,
0x4e, 0x43, 0x9d, 0x47, 0xbc, 0xcd, 0xf5, 0x4e, 0x9d, 0xb2, 0x2f, 0x04, 0x20, 0x0d, 0x5a, 0xdc,
0x03, 0x71, 0x0a, 0x81, 0x52, 0xf8, 0x56, 0x16, 0x82, 0x6c, 0x61, 0x47, 0x29, 0xf7, 0xde, 0xb1,
0x7d, 0x77, 0x5f, 0x6d, 0x7a, 0x11, 0x10, 0x29, 0x6a, 0x9c, 0x9d, 0x1d, 0xd3, 0xb0, 0xf1, 0x16,
0x93, 0x70, 0x83, 0x12, 0x11, 0x07, 0x76, 0xfb, 0x30, 0x97, 0xda, 0x08, 0xc9, 0x50, 0x7e, 0x88,
0xf7, 0xa9, 0x1a, 0x95, 0x55, 0xf2, 0x13, 0xbd, 0x06, 0xd5, 0x3d, 0xcd, 0x9c, 0x60, 0xaa, 0x26,
0x87, 0x73, 0x92, 0x4d, 0xfe, 0xd7, 0xd2, 0x35, 0x49, 0xf9, 0xbe, 0x04, 0x27, 0xef, 0xd9, 0xde,
0x64, 0x10, 0x9c, 0xe0, 0xd3, 0xd1, 0xd6, 0xa4, 0x9f, 0xa8, 0xa4, 0xfc, 0x84, 0xf2, 0x8b, 0x0a,
0xcc, 0xf2, 0x53, 0x10, 0xa1, 0x52, 0x83, 0x3f, 0x0d, 0xf5, 0x20, 0x54, 0x70, 0x86, 0x84, 0x00,
0x74, 0x1e, 0x1a, 0x11, 0x75, 0xe7, 0x54, 0x45, 0x41, 0x85, 0x48, 0x13, 0x81, 0xbf, 0x12, 0x09,
0xfc, 0x67, 0x00, 0x76, 0xcc, 0x89, 0xb7, 0xdb, 0xf7, 0x0d, 0x0b, 0xf3, 0xc4, 0xa3, 0x4e, 0x21,
0x77, 0x0d, 0x0b, 0xa3, 0xeb, 0xd0, 0x1c, 0x18, 0xb6, 0xe9, 0x8c, 0xfa, 0x63, 0xcd, 0xdf, 0xf5,
0x3a, 0xd3, 0xb9, 0x0a, 0x7e, 0xd3, 0xc0, 0xa6, 0x7e, 0x83, 0xce, 0x55, 0x1b, 0x6c, 0xcd, 0x36,
0x59, 0x82, 0xce, 0x42, 0xc3, 0x9e, 0x58, 0x7d, 0x67, 0xa7, 0xef, 0x3a, 0x8f, 0x89, 0x89, 0x50,
0x14, 0xf6, 0xc4, 0x7a, 0x6f, 0x47, 0x75, 0x1e, 0x13, 0x57, 0x5d, 0x27, 0x4e, 0xdb, 0x33, 0x9d,
0x91, 0xd7, 0xa9, 0x15, 0xda, 0x3f, 0x5c, 0x40, 0x56, 0xeb, 0xd8, 0xf4, 0x35, 0xba, 0xba, 0x5e,
0x6c, 0x75, 0xb0, 0x00, 0x5d, 0x82, 0xf6, 0xd0, 0xb1, 0xc6, 0x1a, 0xe5, 0xd0, 0x4d, 0xd7, 0xb1,
0xa8, 0x7d, 0x94, 0xd5, 0x04, 0x14, 0xad, 0x41, 0xc3, 0xb0, 0x75, 0xfc, 0x84, 0x1b, 0x51, 0x83,
0xe2, 0x51, 0xb2, 0x8c, 0x88, 0x22, 0xda, 0x24, 0x73, 0xa9, 0x82, 0x82, 0x21, 0x7e, 0x7a, 0x44,
0x33, 0x84, 0x2d, 0x7a, 0xc6, 0x07, 0xb8, 0xd3, 0x64, 0x52, 0xe4, 0xb0, 0x9e, 0xf1, 0x01, 0x26,
0x49, 0xad, 0x61, 0x7b, 0xd8, 0xf5, 0x45, 0x89, 0xd1, 0x69, 0x51, 0xf5, 0x69, 0x31, 0x28, 0x57,
0x6c, 0xe5, 0xf7, 0x25, 0x68, 0xc7, 0x11, 0xa1, 0x0e, 0xcc, 0xec, 0x50, 0x88, 0xd0, 0x1e, 0xf1,
0x49, 0xd0, 0x62, 0x9b, 0x54, 0xfb, 0x7d, 0x4a, 0x0b, 0x55, 0x9e, 0x9a, 0xda, 0x60, 0x30, 0xba,
0x01, 0x51, 0x02, 0x76, 0x3c, 0xaa, 0xb1, 0x65, 0x8a, 0xb2, 0x4e, 0x21, 0x34, 0xae, 0x75, 0x60,
0x86, 0x1d, 0x43, 0xa8, 0x8e, 0xf8, 0x24, 0x23, 0x83, 0x89, 0x41, 0xb1, 0x32, 0xd5, 0x11, 0x9f,
0x68, 0x1d, 0x9a, 0x6c, 0xcb, 0xb1, 0xe6, 0x6a, 0x96, 0x50, 0x9c, 0x17, 0x32, 0x8d, 0xef, 0x16,
0xde, 0xbf, 0x4f, 0xec, 0x78, 0x5b, 0x33, 0x5c, 0x95, 0x31, 0x7a, 0x9b, 0xae, 0x42, 0x8b, 0x20,
0xb3, 0x5d, 0x76, 0x0c, 0x13, 0x73, 0x15, 0x9c, 0xa1, 0xc1, 0xb3, 0x4d, 0xe1, 0x37, 0x0d, 0x13,
0x33, 0x2d, 0x0b, 0x8e, 0x40, 0x59, 0x5b, 0x63, 0x4a, 0x46, 0x21, 0x94, 0xb1, 0x17, 0xa0, 0xc5,
0x86, 0xf7, 0xb0, 0xeb, 0x19, 0x8e, 0xcd, 0x3d, 0x25, 0xa3, 0xf1, 0x3e, 0x83, 0x29, 0xdf, 0xa8,
0xc0, 0x3c, 0x31, 0x48, 0x6e, 0x9b, 0xc7, 0x08, 0x77, 0x67, 0x00, 0x74, 0xcf, 0xef, 0xc7, 0x9c,
0x48, 0x5d, 0xf7, 0x7c, 0xe6, 0x0c, 0xd1, 0x9b, 0x22, 0x5a, 0x95, 0xf3, 0x13, 0xd8, 0x84, 0x83,
0x48, 0x47, 0xac, 0x23, 0x95, 0xf7, 0x17, 0xa0, 0xe5, 0x39, 0x13, 0x77, 0x88, 0xfb, 0xb1, 0x52,
0xa3, 0xc9, 0x80, 0x5b, 0xd9, 0x6e, 0x6e, 0x3a, 0xb3, 0xcd, 0x10, 0x89, 0x5a, 0x33, 0xc7, 0x8b,
0x5a, 0xb5, 0x64, 0xd4, 0xba, 0x05, 0xb3, 0xd4, 0x46, 0xfb, 0x63, 0xc7, 0x63, 0x15, 0x1b, 0x37,
0x6d, 0x25, 0xa7, 0x62, 0xbf, 0xe3, 0x8d, 0xb6, 0xf9, 0x54, 0xb5, 0x4d, 0x97, 0x8a, 0x4f, 0x8f,
0xe8, 0xa8, 0x10, 0x3a, 0x30, 0x1d, 0xe5, 0x9f, 0x84, 0x19, 0x36, 0xc6, 0x7a, 0xdf, 0x77, 0x35,
0xdb, 0xdb, 0xc1, 0x2e, 0x8d, 0x5c, 0x35, 0xb5, 0x49, 0x80, 0x77, 0x39, 0x4c, 0xf9, 0x6d, 0x09,
0x16, 0x78, 0x01, 0x79, 0x7c, 0xbd, 0xc8, 0x0b, 0x2c, 0xc2, 0x33, 0x97, 0x0f, 0x28, 0xc9, 0x2a,
0x05, 0x52, 0xa3, 0x6a, 0x46, 0x6a, 0x14, 0x2f, 0x4b, 0xa6, 0x53, 0x65, 0x49, 0xd0, 0x64, 0x98,
0x29, 0xde, 0x64, 0x40, 0x27, 0xa0, 0x4a, 0x73, 0x65, 0x2a, 0xbb, 0xba, 0xca, 0x3e, 0x8a, 0x31,
0xf4, 0xcf, 0x12, 0xb4, 0x7a, 0x58, 0x73, 0x87, 0xbb, 0x82, 0x8f, 0x6f, 0x44, 0x9b, 0x32, 0x2f,
0xe6, 0x88, 0x38, 0xb6, 0xe4, 0xf3, 0xd3, 0x8d, 0xf9, 0x8b, 0x04, 0xcd, 0xff, 0x22, 0x43, 0xe2,
0xb0, 0xd7, 0xa2, 0x87, 0xbd, 0x94, 0x73, 0x58, 0x15, 0xfb, 0xae, 0x81, 0xf7, 0xf0, 0xe7, 0xee,
0xb8, 0xbf, 0x96, 0xa0, 0xdb, 0xdb, 0xb7, 0x87, 0x2a, 0xb3, 0xe5, 0xe3, 0x5b, 0xcc, 0x05, 0x68,
0xed, 0xc5, 0xf2, 0xa9, 0x12, 0x55, 0xb8, 0xe6, 0x5e, 0xb4, 0xf0, 0x52, 0x41, 0x16, 0xbd, 0x20,
0x7e, 0x58, 0xe1, 0x5a, 0x5f, 0xca, 0xa2, 0x3a, 0x41, 0x1c, 0x75, 0x4d, 0xb3, 0x6e, 0x1c, 0xa8,
0x7c, 0x4d, 0x82, 0xf9, 0x8c, 0x89, 0xe8, 0x14, 0xcc, 0xf0, 0x22, 0x8f, 0x07, 0x5a, 0x66, 0xc3,
0x3a, 0x11, 0x4f, 0xd8, 0xa6, 0x30, 0xf4, 0x74, 0x92, 0xa6, 0xa3, 0x73, 0xd0, 0x08, 0xb2, 0x71,
0x3d, 0x25, 0x1f, 0xdd, 0x43, 0x5d, 0xa8, 0x71, 0xe7, 0x24, 0xca, 0x9c, 0xe0, 0x5b, 0xf9, 0xb9,
0x04, 0x0b, 0xef, 0x6a, 0xb6, 0xee, 0xec, 0xec, 0x1c, 0x9f, 0xad, 0x6b, 0x10, 0x4b, 0xe2, 0x8b,
0xb6, 0x07, 0xe2, 0x99, 0xff, 0x65, 0x98, 0x73, 0x99, 0x67, 0xd4, 0xe3, 0x7c, 0x2f, 0xab, 0xb2,
0x18, 0x08, 0xf8, 0xf9, 0x61, 0x09, 0x10, 0x09, 0x06, 0x37, 0x34, 0x53, 0xb3, 0x87, 0xf8, 0xe8,
0xa4, 0x5f, 0x84, 0x76, 0x2c, 0x84, 0x05, 0xb7, 0x28, 0xd1, 0x18, 0xe6, 0xa1, 0x5b, 0xd0, 0x1e,
0x30, 0x54, 0x7d, 0x17, 0x6b, 0x9e, 0x63, 0x53, 0xe7, 0xda, 0xce, 0xee, 0x04, 0xdc, 0x75, 0x8d,
0xd1, 0x08, 0xbb, 0x6b, 0x8e, 0xad, 0xb3, 0x20, 0xd2, 0x1a, 0x08, 0x32, 0xc9, 0x52, 0x22, 0xb8,
0x30, 0x9e, 0x0b, 0xd1, 0x40, 0x10, 0xd0, 0x29, 0x2b, 0x3c, 0xac, 0x99, 0x21, 0x23, 0x42, 0x6f,
0x2c, 0xb3, 0x81, 0x5e, 0x7e, 0x23, 0x28, 0x23, 0xbe, 0x2a, 0x3f, 0x91, 0x00, 0x05, 0x95, 0x0c,
0xad, 0xcc, 0xa8, 0xf6, 0x25, 0x97, 0x4a, 0x19, 0x41, 0xe1, 0x34, 0xd4, 0x75, 0xb1, 0x92, 0x9b,
0x4b, 0x08, 0xa0, 0x3e, 0x9a, 0x12, 0xdd, 0x27, 0xc1, 0x18, 0xeb, 0xa2, 0x52, 0x60, 0xc0, 0xdb,
0x14, 0x16, 0x0f, 0xcf, 0x95, 0x64, 0x78, 0x8e, 0xf6, 0x39, 0xaa, 0xb1, 0x3e, 0x87, 0xf2, 0x51,
0x09, 0x64, 0xea, 0xee, 0xd6, 0xc2, 0x62, 0xbb, 0x10, 0xd1, 0x17, 0xa0, 0xc5, 0xef, 0x19, 0x63,
0x84, 0x37, 0x1f, 0x45, 0x36, 0x43, 0x57, 0xe0, 0x04, 0x9b, 0xe4, 0x62, 0x6f, 0x62, 0x86, 0x49,
0x32, 0xcb, 0x58, 0xd1, 0x23, 0xe6, 0x67, 0xc9, 0x90, 0x58, 0x71, 0x0f, 0x16, 0x46, 0xa6, 0x33,
0xd0, 0xcc, 0x7e, 0x5c, 0x3c, 0x4c, 0x86, 0x05, 0x34, 0xfe, 0x04, 0x5b, 0xde, 0x8b, 0xca, 0xd0,
0x43, 0x1b, 0xa4, 0xac, 0xc6, 0x0f, 0x83, 0xfc, 0x84, 0xb7, 0xb0, 0x8b, 0xa4, 0x27, 0x4d, 0xb2,
0x50, 0x7c, 0x29, 0xdf, 0x91, 0x60, 0x36, 0xd1, 0xaa, 0x4c, 0x16, 0x7b, 0x52, 0xba, 0xd8, 0xbb,
0x06, 0x55, 0x52, 0x01, 0x31, 0x67, 0xd8, 0xce, 0x2e, 0x44, 0xe2, 0xbb, 0xaa, 0x6c, 0x01, 0x5a,
0x81, 0xf9, 0x8c, 0x4b, 0x2d, 0xae, 0x03, 0x28, 0x7d, 0xa7, 0xa5, 0xfc, 0xa1, 0x02, 0x8d, 0x08,
0x3f, 0x0e, 0xa9, 0x53, 0x8b, 0xf4, 0x9e, 0x12, 0xc7, 0x2b, 0xa7, 0x8f, 0x97, 0x73, 0xab, 0x43,
0xf4, 0xce, 0xc2, 0x16, 0xcb, 0xf0, 0x79, 0xb9, 0x61, 0x61, 0x8b, 0xe6, 0xf7, 0x44, 0x25, 0x27,
0x16, 0xab, 0x30, 0x99, 0x39, 0xcd, 0xd8, 0x13, 0x8b, 0xd6, 0x97, 0xf1, 0xe2, 0x66, 0xe6, 0x80,
0xe2, 0xa6, 0x16, 0x2f, 0x6e, 0x62, 0x76, 0x54, 0x4f, 0xda, 0x51, 0xd1, 0xd2, 0xf1, 0x0a, 0xcc,
0x0f, 0x5d, 0xac, 0xf9, 0x58, 0xbf, 0xb1, 0xbf, 0x16, 0x0c, 0xf1, 0xcc, 0x28, 0x6b, 0x08, 0xdd,
0x0c, 0x7b, 0x36, 0x4c, 0xca, 0x4d, 0x2a, 0xe5, 0xec, 0xda, 0x89, 0xcb, 0x86, 0x09, 0x59, 0xb8,
0x67, 0xfa, 0x95, 0x2c, 0x5a, 0x5b, 0x47, 0x2a, 0x5a, 0xcf, 0x41, 0x43, 0x84, 0x56, 0x62, 0xee,
0x6d, 0xe6, 0xf9, 0x84, 0x2f, 0xd0, 0xbd, 0x98, 0x33, 0x98, 0x8d, 0x37, 0x3d, 0x93, 0x95, 0xa7,
0x9c, 0xaa, 0x3c, 0x95, 0xdf, 0x95, 0xa1, 0x1d, 0x16, 0x2b, 0x85, 0xbd, 0x45, 0x91, 0xfb, 0xdb,
0x2d, 0x90, 0xc3, 0x78, 0x4c, 0x19, 0x79, 0x60, 0xbd, 0x95, 0xbc, 0x30, 0x98, 0x1d, 0x27, 0xcc,
0x32, 0xd6, 0x92, 0xad, 0x3c, 0x55, 0x4b, 0xf6, 0x98, 0x57, 0x5d, 0x57, 0xe1, 0x64, 0x10, 0x67,
0x63, 0xc7, 0x66, 0xc9, 0xfc, 0x09, 0x31, 0xb8, 0x1d, 0x3d, 0x7e, 0x8e, 0xa5, 0xcf, 0xe4, 0x59,
0x7a, 0x52, 0xd2, 0xb5, 0x94, 0xa4, 0xd3, 0x37, 0x6e, 0xf5, 0xac, 0x1b, 0xb7, 0x7b, 0x30, 0x4f,
0xfb, 0x70, 0xde, 0xd0, 0x35, 0x06, 0x38, 0x48, 0x4d, 0x8b, 0x88, 0xb5, 0x0b, 0xb5, 0x44, 0x76,
0x1b, 0x7c, 0x2b, 0x5f, 0x92, 0x60, 0x21, 0xbd, 0x2f, 0xd5, 0x98, 0xd0, 0x5f, 0x48, 0x31, 0x7f,
0xf1, 0x3f, 0x30, 0x1f, 0x6e, 0x1f, 0xcf, 0x9b, 0x73, 0x32, 0xc3, 0x0c, 0xc2, 0x55, 0x14, 0xee,
0x21, 0x60, 0xca, 0x5f, 0xa5, 0xa0, 0x9d, 0x49, 0x60, 0x23, 0xda, 0xca, 0x25, 0x31, 0xcc, 0xb1,
0x4d, 0xc3, 0x0e, 0x8a, 0x6b, 0x7e, 0x46, 0x06, 0xe4, 0xc5, 0xf5, 0xbb, 0x30, 0xcb, 0x27, 0x05,
0xa1, 0xa8, 0x60, 0xf2, 0xd5, 0x66, 0xeb, 0x82, 0x20, 0x74, 0x11, 0xda, 0xbc, 0xc7, 0x2a, 0xf0,
0x95, 0x33, 0x3a, 0xaf, 0xe8, 0x3f, 0x41, 0x16, 0xd3, 0x9e, 0x36, 0xf8, 0xcd, 0xf2, 0x85, 0x41,
0x12, 0xf7, 0x45, 0x09, 0x3a, 0xf1, 0x50, 0x18, 0x39, 0xfe, 0xd3, 0xa7, 0x72, 0xff, 0x16, 0xbf,
0x9d, 0xba, 0x78, 0x00, 0x3d, 0x21, 0x1e, 0x71, 0x47, 0xb5, 0x45, 0x6f, 0x1a, 0x49, 0x05, 0xb2,
0x6e, 0x78, 0xbe, 0x6b, 0x0c, 0x26, 0xc7, 0x7a, 0x83, 0xa0, 0xfc, 0xb4, 0x04, 0xcf, 0x67, 0x6e,
0x78, 0x9c, 0x7b, 0xa8, 0xbc, 0x82, 0xff, 0x06, 0xd4, 0x12, 0x95, 0xca, 0xa5, 0x03, 0x0e, 0xcf,
0x1b, 0x54, 0xac, 0x87, 0x22, 0xd6, 0x91, 0x3d, 0x02, 0x9d, 0xae, 0xe4, 0xef, 0xc1, 0x95, 0x36,
0xb6, 0x87, 0x58, 0x87, 0xae, 0x43, 0x93, 0x55, 0x81, 0xfd, 0x3d, 0x03, 0x3f, 0x16, 0xd7, 0x27,
0x67, 0x33, 0xfd, 0x1a, 0x9d, 0x77, 0xdf, 0xc0, 0x8f, 0xd5, 0x86, 0x19, 0xfc, 0xf6, 0x94, 0x1f,
0x96, 0x00, 0xc2, 0x31, 0x52, 0x82, 0x86, 0x06, 0xc3, 0x2d, 0x20, 0x02, 0x21, 0xf1, 0x36, 0x9e,
0xe2, 0x89, 0x4f, 0xa4, 0x86, 0xfd, 0x51, 0xdd, 0xf0, 0x7c, 0xce, 0x97, 0x95, 0x83, 0x69, 0x11,
0x2c, 0x22, 0x22, 0x63, 0xb7, 0x13, 0xa2, 0xc4, 0x22, 0x10, 0xf4, 0x0a, 0xa0, 0x91, 0xeb, 0x3c,
0x36, 0xec, 0x51, 0x34, 0x31, 0x67, 0xf9, 0xfb, 0x1c, 0x1f, 0x09, 0x33, 0xf3, 0x6e, 0x1f, 0xe4,
0xe4, 0x7e, 0x19, 0x97, 0x14, 0xaf, 0xc7, 0x2f, 0x29, 0x0e, 0x32, 0x23, 0xb2, 0x4d, 0xf4, 0x96,
0xe2, 0xdf, 0x83, 0x6c, 0x8a, 0x92, 0x97, 0xe7, 0xb9, 0x22, 0x3d, 0xab, 0x52, 0xac, 0x67, 0xa5,
0x7c, 0x53, 0x02, 0x94, 0xd6, 0x0a, 0xd4, 0x86, 0x52, 0xb0, 0x49, 0x69, 0x73, 0x3d, 0x21, 0x85,
0x52, 0x4a, 0x0a, 0xa7, 0xa1, 0x1e, 0x44, 0x12, 0xee, 0x36, 0x42, 0x40, 0x54, 0x46, 0x95, 0xb8,
0x8c, 0x22, 0x84, 0x55, 0xe3, 0x84, 0xed, 0x02, 0x4a, 0x6b, 0x5a, 0x74, 0x27, 0x29, 0xbe, 0xd3,
0x61, 0x14, 0x46, 0x30, 0x95, 0xe3, 0x98, 0x7e, 0x23, 0x01, 0x0a, 0x63, 0x65, 0x70, 0x83, 0x52,
0x24, 0xc0, 0xac, 0xc0, 0x7c, 0x3a, 0x92, 0x8a, 0xf4, 0x01, 0xa5, 0xe2, 0x68, 0x56, 0xcc, 0x2b,
0x67, 0xc4, 0x3c, 0xf4, 0x46, 0xe0, 0x1b, 0x58, 0x62, 0x70, 0x36, 0x2f, 0x31, 0x88, 0xbb, 0x07,
0xe5, 0x67, 0x12, 0xcc, 0x05, 0xd8, 0x9e, 0xea, 0x24, 0x87, 0xdf, 0x08, 0x3d, 0x63, 0xd2, 0x7b,
0x30, 0xc3, 0xdb, 0x23, 0x29, 0xe5, 0x2b, 0x52, 0x05, 0x9c, 0x80, 0x2a, 0xd1, 0x75, 0xd1, 0x2f,
0x60, 0x1f, 0xca, 0x8f, 0x24, 0x80, 0xde, 0xbe, 0x3d, 0xbc, 0xce, 0x74, 0xe0, 0x0a, 0x54, 0x0e,
0xbb, 0x00, 0x27, 0xb3, 0x69, 0xb6, 0x45, 0x67, 0x16, 0x60, 0x4b, 0xac, 0x80, 0x29, 0x27, 0x0b,
0x98, 0xbc, 0xd2, 0x23, 0x5f, 0xef, 0x7f, 0x25, 0xc1, 0x29, 0x42, 0xc4, 0xc7, 0x12, 0x84, 0x0a,
0xb1, 0x2e, 0x62, 0x53, 0xe5, 0xb8, 0x4d, 0x5d, 0x83, 0x19, 0x56, 0x43, 0x88, 0x80, 0x70, 0x36,
0x8f, 0x65, 0x8c, 0xc1, 0xaa, 0x98, 0xbe, 0xf4, 0x1f, 0x50, 0x0f, 0x7a, 0x79, 0xa8, 0x01, 0x33,
0xf7, 0xec, 0x5b, 0xb6, 0xf3, 0xd8, 0x96, 0xa7, 0xd0, 0x0c, 0x94, 0xaf, 0x9b, 0xa6, 0x2c, 0xa1,
0x16, 0xd4, 0x7b, 0xbe, 0x8b, 0x35, 0xcb, 0xb0, 0x47, 0x72, 0x09, 0xb5, 0x01, 0xde, 0x35, 0x3c,
0xdf, 0x71, 0x8d, 0xa1, 0x66, 0xca, 0xe5, 0xa5, 0x0f, 0xa0, 0x1d, 0x4f, 0xa1, 0x51, 0x13, 0x6a,
0x5b, 0x8e, 0xff, 0xce, 0x13, 0xc3, 0xf3, 0xe5, 0x29, 0x32, 0x7f, 0xcb, 0xf1, 0xb7, 0x5d, 0xec,
0x61, 0xdb, 0x97, 0x25, 0x04, 0x30, 0xfd, 0x9e, 0xbd, 0x6e, 0x78, 0x0f, 0xe5, 0x12, 0x9a, 0xe7,
0x45, 0xb0, 0x66, 0x6e, 0xf2, 0xbc, 0x54, 0x2e, 0x93, 0xe5, 0xc1, 0x57, 0x05, 0xc9, 0xd0, 0x0c,
0xa6, 0x6c, 0x6c, 0xdf, 0x93, 0xab, 0xa8, 0x0e, 0x55, 0xf6, 0x73, 0x7a, 0x49, 0x07, 0x39, 0xd9,
0xc1, 0x21, 0x7b, 0xb2, 0x43, 0x04, 0x20, 0x79, 0x8a, 0x9c, 0x8c, 0xb7, 0xd0, 0x64, 0x09, 0xcd,
0x42, 0x23, 0xd2, 0x90, 0x92, 0x4b, 0x04, 0xb0, 0xe1, 0x8e, 0x87, 0x5c, 0x7a, 0x8c, 0x04, 0x92,
0x44, 0xad, 0x13, 0x4e, 0x54, 0x96, 0x6e, 0x40, 0x4d, 0xe4, 0xf6, 0x64, 0x2a, 0x67, 0x11, 0xf9,
0x94, 0xa7, 0xd0, 0x1c, 0xb4, 0x62, 0x8f, 0xee, 0x64, 0x09, 0x21, 0x68, 0xc7, 0x1f, 0x83, 0xca,
0xa5, 0xa5, 0x55, 0x80, 0xd0, 0x96, 0x08, 0x39, 0x9b, 0xf6, 0x9e, 0x66, 0x1a, 0x3a, 0xa3, 0x8d,
0x0c, 0x11, 0xee, 0x52, 0xee, 0xb0, 0x56, 0x8c, 0x5c, 0x5a, 0x3a, 0x07, 0x35, 0xa1, 0xe5, 0x04,
0xae, 0x62, 0xcb, 0xd9, 0xc3, 0x4c, 0x32, 0x3d, 0xec, 0xcb, 0xd2, 0xea, 0xb7, 0x5b, 0x00, 0xac,
0xe9, 0xe2, 0x38, 0xae, 0x8e, 0xc6, 0x80, 0x36, 0xb0, 0x4f, 0x0a, 0x4a, 0xc7, 0x16, 0xc5, 0xa0,
0x87, 0xae, 0xe4, 0x3f, 0x76, 0x4c, 0x4c, 0xe5, 0xe7, 0xef, 0xe6, 0x35, 0xa7, 0x13, 0xd3, 0x95,
0x29, 0x64, 0x51, 0x8c, 0x77, 0x0d, 0x0b, 0xdf, 0x35, 0x86, 0x0f, 0x83, 0x6e, 0x4d, 0x3e, 0xc6,
0xc4, 0x54, 0x81, 0x31, 0x51, 0x98, 0xf1, 0x8f, 0x9e, 0xef, 0x1a, 0xf6, 0x48, 0xe4, 0x61, 0xca,
0x14, 0x7a, 0x94, 0x78, 0xdc, 0x29, 0x10, 0xae, 0x16, 0x79, 0xcf, 0x79, 0x34, 0x94, 0x26, 0xcc,
0x26, 0x5e, 0x82, 0xa3, 0xa5, 0xec, 0x27, 0x45, 0x59, 0xaf, 0xd6, 0xbb, 0x97, 0x0b, 0xcd, 0x0d,
0xb0, 0x19, 0xd0, 0x8e, 0xbf, 0x76, 0x46, 0xff, 0x92, 0xb7, 0x41, 0xea, 0x51, 0x63, 0x77, 0xa9,
0xc8, 0xd4, 0x00, 0xd5, 0x03, 0xa6, 0xa4, 0x87, 0xa1, 0xca, 0x7c, 0x50, 0xda, 0x3d, 0x28, 0x05,
0x56, 0xa6, 0xd0, 0xff, 0xc1, 0x5c, 0xea, 0xe9, 0x25, 0x7a, 0x39, 0xbb, 0x23, 0x9f, 0xfd, 0x42,
0xf3, 0x30, 0x0c, 0x0f, 0x92, 0x26, 0x96, 0x4f, 0x7d, 0xea, 0x99, 0x72, 0x71, 0xea, 0x23, 0xdb,
0x1f, 0x44, 0xfd, 0x53, 0x63, 0x98, 0x50, 0xb3, 0x49, 0xb6, 0xff, 0x5e, 0xc9, 0x42, 0x91, 0xfb,
0xfe, 0xb3, 0xbb, 0x5c, 0x74, 0x7a, 0x54, 0xbb, 0xe2, 0x4f, 0x0c, 0xb3, 0x99, 0x96, 0xf9, 0x2c,
0x32, 0x5b, 0xbb, 0xb2, 0x5f, 0x2c, 0x2a, 0x53, 0xe8, 0x6e, 0xcc, 0xc5, 0xa2, 0x4b, 0x79, 0xc2,
0x89, 0x5f, 0x0a, 0x1c, 0xc6, 0xb7, 0xff, 0x07, 0xc4, 0x6c, 0xc7, 0xde, 0x31, 0x46, 0x13, 0x57,
0x63, 0x8a, 0x95, 0xe7, 0x6e, 0xd2, 0x53, 0x05, 0x9a, 0x57, 0x9f, 0x62, 0x45, 0x70, 0xa4, 0x3e,
0xc0, 0x06, 0xf6, 0xef, 0x60, 0xdf, 0x35, 0x86, 0x5e, 0xf2, 0x44, 0xfc, 0x23, 0x9c, 0x20, 0x50,
0xbd, 0x74, 0xe8, 0xbc, 0x00, 0xc1, 0x00, 0x1a, 0x1b, 0xd8, 0xe7, 0xb9, 0x95, 0x87, 0x72, 0x57,
0x8a, 0x19, 0x02, 0xc5, 0xe2, 0xe1, 0x13, 0xa3, 0xee, 0x2c, 0xf1, 0xdc, 0x12, 0xe5, 0x0a, 0x36,
0xfd, 0x08, 0x34, 0xdb, 0x9d, 0xe5, 0xbc, 0xdf, 0x54, 0xa6, 0x56, 0x7f, 0xdc, 0x86, 0x3a, 0x8d,
0x4f, 0x24, 0x98, 0xfe, 0x33, 0x3c, 0x3d, 0x83, 0xf0, 0xf4, 0x3e, 0xcc, 0x26, 0x5e, 0xef, 0x65,
0xcb, 0x33, 0xfb, 0x89, 0x5f, 0x01, 0x2f, 0x1b, 0x7f, 0x59, 0x97, 0xed, 0x30, 0x32, 0x5f, 0xdf,
0x1d, 0xb6, 0xf7, 0x7d, 0xf6, 0xf0, 0x35, 0x68, 0x6a, 0xbd, 0x94, 0x5b, 0x7e, 0xc4, 0xef, 0x3c,
0x3f, 0x7d, 0xef, 0xfd, 0xec, 0xa3, 0xdb, 0xfb, 0x30, 0x9b, 0x78, 0x79, 0x92, 0x2d, 0xd5, 0xec,
0xe7, 0x29, 0x87, 0xed, 0xfe, 0x09, 0x86, 0x01, 0x1d, 0xe6, 0x33, 0x1e, 0x05, 0xa0, 0xe5, 0xbc,
0xea, 0x24, 0xfb, 0xf5, 0xc0, 0xe1, 0x07, 0x6a, 0xc5, 0x4c, 0x09, 0x2d, 0xe6, 0x11, 0x99, 0xfc,
0x73, 0x4f, 0xf7, 0xe5, 0x62, 0xff, 0x04, 0x0a, 0x0e, 0xd4, 0x83, 0x69, 0xf6, 0x1e, 0x05, 0xbd,
0x90, 0xdd, 0xfc, 0x89, 0xbc, 0x55, 0xe9, 0x1e, 0xf6, 0xa2, 0xc5, 0x9b, 0x98, 0xbe, 0x47, 0x37,
0xad, 0x52, 0x2f, 0x89, 0x32, 0x1f, 0x52, 0x45, 0x1f, 0x91, 0x74, 0x0f, 0x7f, 0x37, 0x22, 0x36,
0xfd, 0xc7, 0x8e, 0x95, 0x4f, 0x60, 0x3e, 0xa3, 0x65, 0x8b, 0xf2, 0x72, 0xa2, 0x9c, 0x66, 0x71,
0x77, 0xa5, 0xf0, 0xfc, 0x00, 0xf3, 0xff, 0x82, 0x9c, 0xac, 0xfa, 0xd1, 0xe5, 0x3c, 0x7d, 0xce,
0xc2, 0x79, 0xb0, 0x32, 0xdf, 0x78, 0xed, 0xc1, 0xea, 0xc8, 0xf0, 0x77, 0x27, 0x03, 0x32, 0xb2,
0xc2, 0xa6, 0xbe, 0x62, 0x38, 0xfc, 0xd7, 0x8a, 0xe0, 0xff, 0x0a, 0x5d, 0xbd, 0x42, 0x51, 0x8d,
0x07, 0x83, 0x69, 0xfa, 0x79, 0xf5, 0xef, 0x01, 0x00, 0x00, 0xff, 0xff, 0xa1, 0xec, 0xe6, 0x23,
0xb4, 0x3b, 0x00, 0x00,
0x95, 0xac, 0x5e, 0xc8, 0xee, 0xd7, 0x0b, 0x8b, 0x9f, 0x12, 0xd5, 0x6e, 0x6b, 0x73, 0x69, 0x31,
0x87, 0xb2, 0x49, 0x99, 0xb2, 0x0d, 0x79, 0xc6, 0xc6, 0x8c, 0x44, 0x5a, 0x34, 0x47, 0x12, 0xcd,
0xa9, 0x96, 0x34, 0x03, 0xc1, 0x98, 0x9e, 0xea, 0xae, 0xcf, 0x66, 0x41, 0xd5, 0x55, 0xad, 0xaa,
0x6a, 0x4a, 0xf4, 0x5c, 0xe7, 0x32, 0xd9, 0x80, 0xe4, 0x10, 0x20, 0x40, 0x90, 0x53, 0x02, 0x24,
0x81, 0x0d, 0xe4, 0x90, 0x00, 0x39, 0x04, 0x41, 0x80, 0x1c, 0x92, 0x53, 0x90, 0x43, 0x8e, 0x01,
0x72, 0xcc, 0x21, 0xb9, 0xe6, 0x90, 0x5b, 0xf0, 0xb7, 0x5a, 0x7f, 0x91, 0x2d, 0x52, 0xde, 0x82,
0xdc, 0xba, 0xde, 0x5f, 0xde, 0xfb, 0x6f, 0x7f, 0xef, 0xff, 0x86, 0xb9, 0xc7, 0x63, 0xec, 0xed,
0x77, 0xfb, 0xae, 0xeb, 0x99, 0xcb, 0x23, 0xcf, 0x0d, 0x5c, 0x84, 0x86, 0x96, 0xbd, 0x37, 0xf6,
0xd9, 0xd7, 0x32, 0x1d, 0x6f, 0xd7, 0xfb, 0xee, 0x70, 0xe8, 0x3a, 0x0c, 0xd6, 0xae, 0xc7, 0x67,
0xb4, 0x9b, 0x96, 0x13, 0x60, 0xcf, 0x31, 0x6c, 0x31, 0xea, 0xf7, 0x77, 0xf1, 0xd0, 0xe0, 0x5f,
0xaa, 0x69, 0x04, 0x46, 0x7c, 0x7f, 0xed, 0xff, 0x14, 0x58, 0xe8, 0xec, 0xba, 0x4f, 0xd6, 0x5c,
0xdb, 0xc6, 0xfd, 0xc0, 0x72, 0x1d, 0x5f, 0xc7, 0x8f, 0xc7, 0xd8, 0x0f, 0xd0, 0x55, 0x28, 0xf5,
0x0c, 0x1f, 0xb7, 0x94, 0xf3, 0xca, 0x62, 0x6d, 0xf5, 0xf4, 0x72, 0x82, 0x12, 0x4e, 0xc2, 0x5d,
0x7f, 0x70, 0xd3, 0xf0, 0xb1, 0x4e, 0x67, 0x22, 0x04, 0x25, 0xb3, 0xb7, 0xb9, 0xde, 0x2a, 0x9c,
0x57, 0x16, 0x8b, 0x3a, 0xfd, 0x8d, 0x2e, 0x42, 0xa3, 0x1f, 0xee, 0xbd, 0xb9, 0xee, 0xb7, 0x8a,
0xe7, 0x8b, 0x8b, 0x45, 0x3d, 0x09, 0xd4, 0xfe, 0xa0, 0xc0, 0xa9, 0x0c, 0x19, 0xfe, 0xc8, 0x75,
0x7c, 0x8c, 0xae, 0xc1, 0xb4, 0x1f, 0x18, 0xc1, 0xd8, 0xe7, 0x94, 0xbc, 0x28, 0xa5, 0xa4, 0x43,
0xa7, 0xe8, 0x7c, 0x6a, 0x16, 0x6d, 0x41, 0x82, 0x16, 0xbd, 0x06, 0x27, 0x2c, 0xe7, 0x2e, 0x1e,
0xba, 0xde, 0x7e, 0x77, 0x84, 0xbd, 0x3e, 0x76, 0x02, 0x63, 0x80, 0x05, 0x8d, 0xf3, 0x62, 0x6c,
0x3b, 0x1a, 0x42, 0x6f, 0xc2, 0x29, 0x26, 0x25, 0x1f, 0x7b, 0x7b, 0x56, 0x1f, 0x77, 0x8d, 0x3d,
0xc3, 0xb2, 0x8d, 0x9e, 0x8d, 0x5b, 0xa5, 0xf3, 0xc5, 0xc5, 0x8a, 0x7e, 0x92, 0x0e, 0x77, 0xd8,
0xe8, 0x0d, 0x31, 0xa8, 0x7d, 0x4f, 0x81, 0x93, 0xe4, 0x84, 0xdb, 0x86, 0x17, 0x58, 0x9f, 0x00,
0x9f, 0x35, 0xa8, 0xc7, 0xcf, 0xd6, 0x2a, 0xd2, 0xb1, 0x04, 0x8c, 0xcc, 0x19, 0x09, 0xf4, 0x84,
0x27, 0x25, 0x7a, 0xcc, 0x04, 0x4c, 0xfb, 0x2e, 0x57, 0x88, 0x38, 0x9d, 0xc7, 0x11, 0x44, 0x1a,
0x67, 0x21, 0x8b, 0xf3, 0x08, 0x62, 0xd0, 0xfe, 0xa8, 0xc0, 0xc9, 0x3b, 0xae, 0x61, 0x46, 0x0a,
0xf3, 0xe9, 0xb3, 0xf3, 0x1d, 0x98, 0x66, 0xd6, 0xd5, 0x2a, 0x51, 0x5c, 0x97, 0x92, 0xb8, 0xb8,
0xe5, 0x45, 0x14, 0x76, 0x28, 0x40, 0xe7, 0x8b, 0xd0, 0x25, 0x68, 0x7a, 0x78, 0x64, 0x5b, 0x7d,
0xa3, 0xeb, 0x8c, 0x87, 0x3d, 0xec, 0xb5, 0xca, 0xe7, 0x95, 0xc5, 0xb2, 0xde, 0xe0, 0xd0, 0x2d,
0x0a, 0xd4, 0xbe, 0xad, 0x40, 0x4b, 0xc7, 0x36, 0x36, 0x7c, 0xfc, 0x59, 0x1e, 0x76, 0x01, 0xa6,
0x1d, 0xd7, 0xc4, 0x9b, 0xeb, 0xf4, 0xb0, 0x45, 0x9d, 0x7f, 0x69, 0x7f, 0x55, 0xe0, 0xc4, 0x06,
0x0e, 0x88, 0xd4, 0x2d, 0x3f, 0xb0, 0xfa, 0xa1, 0x5a, 0xbf, 0x03, 0x45, 0x0f, 0x3f, 0xe6, 0x94,
0x5d, 0x49, 0x52, 0x16, 0x3a, 0x29, 0xd9, 0x4a, 0x9d, 0xac, 0x43, 0x2f, 0x41, 0xdd, 0x1c, 0xda,
0xdd, 0xfe, 0xae, 0xe1, 0x38, 0xd8, 0x66, 0x7a, 0x53, 0xd5, 0x6b, 0xe6, 0xd0, 0x5e, 0xe3, 0x20,
0x74, 0x16, 0xc0, 0xc7, 0x83, 0x21, 0x76, 0x82, 0xc8, 0xaf, 0xc4, 0x20, 0x68, 0x09, 0xe6, 0x76,
0x3c, 0x77, 0xd8, 0xf5, 0x77, 0x0d, 0xcf, 0xec, 0xda, 0xd8, 0x30, 0xb1, 0x47, 0xa9, 0xaf, 0xe8,
0xb3, 0x64, 0xa0, 0x43, 0xe0, 0x77, 0x28, 0x18, 0x5d, 0x83, 0xb2, 0xdf, 0x77, 0x47, 0x98, 0xca,
0xa0, 0xb9, 0x7a, 0x66, 0x39, 0xeb, 0x77, 0x97, 0xd7, 0x8d, 0xc0, 0xe8, 0x90, 0x49, 0x3a, 0x9b,
0xab, 0x7d, 0xb9, 0xc0, 0x94, 0xf0, 0x73, 0x6e, 0xd3, 0x31, 0x45, 0x2d, 0x3f, 0x1f, 0x45, 0x9d,
0x96, 0x29, 0xea, 0x2f, 0x22, 0x45, 0xfd, 0xbc, 0x33, 0x24, 0x52, 0xe6, 0x72, 0x42, 0x99, 0x7f,
0xa0, 0xc0, 0x0b, 0x1b, 0x38, 0x08, 0xc9, 0x27, 0xba, 0x89, 0x3f, 0xa7, 0x8e, 0xfa, 0x63, 0x05,
0xda, 0x32, 0x5a, 0x8f, 0xe3, 0xac, 0x1f, 0xc2, 0x42, 0x88, 0xa3, 0x6b, 0x62, 0xbf, 0xef, 0x59,
0x23, 0x2a, 0x46, 0x6a, 0x7e, 0xb5, 0xd5, 0x0b, 0x32, 0xb3, 0x48, 0x53, 0x70, 0x32, 0xdc, 0x62,
0x3d, 0xb6, 0x83, 0xf6, 0x55, 0x05, 0x4e, 0x12, 0x73, 0xe7, 0xf6, 0xe9, 0xec, 0xb8, 0x47, 0xe7,
0x6b, 0xd2, 0xf2, 0x0b, 0x19, 0xcb, 0x9f, 0x80, 0xc7, 0x34, 0xf3, 0x49, 0xd3, 0x73, 0x1c, 0xde,
0xbd, 0x01, 0x65, 0xcb, 0xd9, 0x71, 0x05, 0xab, 0xce, 0xc9, 0x58, 0x15, 0x47, 0xc6, 0x66, 0x6b,
0x0e, 0xa3, 0x22, 0x72, 0x45, 0xc7, 0x50, 0xb7, 0xf4, 0xb1, 0x0b, 0x92, 0x63, 0x7f, 0x45, 0x81,
0x53, 0x19, 0x84, 0xc7, 0x39, 0xf7, 0xdb, 0x30, 0x4d, 0x1d, 0xac, 0x38, 0xf8, 0x45, 0xe9, 0xc1,
0x63, 0xe8, 0xee, 0x58, 0x7e, 0xa0, 0xf3, 0x35, 0x9a, 0x0b, 0x6a, 0x7a, 0x8c, 0xb8, 0x7e, 0xee,
0xf6, 0xbb, 0x8e, 0x31, 0x64, 0x0c, 0xa8, 0xea, 0x35, 0x0e, 0xdb, 0x32, 0x86, 0x18, 0xbd, 0x00,
0x15, 0x62, 0xb2, 0x5d, 0xcb, 0x14, 0xe2, 0x9f, 0xa1, 0x26, 0x6c, 0xfa, 0xe8, 0x0c, 0x00, 0x1d,
0x32, 0x4c, 0xd3, 0x63, 0x51, 0xa1, 0xaa, 0x57, 0x09, 0xe4, 0x06, 0x01, 0x68, 0x5f, 0x57, 0xa0,
0x4e, 0x7c, 0xf6, 0x5d, 0x1c, 0x18, 0x44, 0x0e, 0xe8, 0x2d, 0xa8, 0xda, 0xae, 0x61, 0x76, 0x83,
0xfd, 0x11, 0x43, 0xd5, 0x4c, 0xf3, 0x9a, 0x1d, 0x81, 0x2c, 0xba, 0xb7, 0x3f, 0xc2, 0x7a, 0xc5,
0xe6, 0xbf, 0x26, 0xe1, 0x77, 0xc6, 0x94, 0x8b, 0x12, 0x53, 0xfe, 0xa8, 0x0c, 0x0b, 0xff, 0x69,
0x04, 0xfd, 0xdd, 0xf5, 0xa1, 0x08, 0x6e, 0x47, 0x57, 0x82, 0xc8, 0xb7, 0x15, 0xe2, 0xbe, 0xed,
0xb9, 0xf9, 0xce, 0x50, 0xcf, 0xcb, 0x32, 0x3d, 0x27, 0x05, 0xc6, 0xf2, 0x03, 0x2e, 0xaa, 0x98,
0x9e, 0xc7, 0x62, 0xd0, 0xf4, 0x51, 0x62, 0xd0, 0x1a, 0x34, 0xf0, 0xd3, 0xbe, 0x3d, 0x26, 0x32,
0xa7, 0xd8, 0x67, 0x28, 0xf6, 0xb3, 0x12, 0xec, 0x71, 0x23, 0xab, 0xf3, 0x45, 0x9b, 0x9c, 0x06,
0x26, 0xea, 0x21, 0x0e, 0x8c, 0x56, 0x85, 0x92, 0x71, 0x3e, 0x4f, 0xd4, 0x42, 0x3f, 0x98, 0xb8,
0xc9, 0x17, 0x3a, 0x0d, 0x55, 0x1e, 0xf1, 0x36, 0xd7, 0x5b, 0x55, 0xca, 0xbe, 0x08, 0x80, 0x0c,
0x68, 0x70, 0x0f, 0xc4, 0x29, 0x04, 0x4a, 0xe1, 0xdb, 0x32, 0x04, 0x72, 0x61, 0xc7, 0x29, 0xf7,
0xdf, 0x75, 0x02, 0x6f, 0x5f, 0xaf, 0xfb, 0x31, 0x10, 0x29, 0x6a, 0xdc, 0x9d, 0x1d, 0xdb, 0x72,
0xf0, 0x16, 0x93, 0x70, 0x8d, 0x12, 0x91, 0x04, 0xb6, 0xbb, 0x30, 0x97, 0xd9, 0x08, 0xa9, 0x50,
0x7c, 0x84, 0xf7, 0xa9, 0x1a, 0x15, 0x75, 0xf2, 0x13, 0xbd, 0x0e, 0xe5, 0x3d, 0xc3, 0x1e, 0x63,
0xaa, 0x26, 0x87, 0x73, 0x92, 0x4d, 0xfe, 0xe7, 0xc2, 0x75, 0x45, 0xfb, 0xbe, 0x02, 0x27, 0xef,
0x3b, 0xfe, 0xb8, 0x17, 0x9e, 0xe0, 0xb3, 0xd1, 0xd6, 0xb4, 0x9f, 0x28, 0x65, 0xfc, 0x84, 0xf6,
0xf3, 0x12, 0xcc, 0xf2, 0x53, 0x10, 0xa1, 0x52, 0x83, 0x3f, 0x0d, 0xd5, 0x30, 0x54, 0x70, 0x86,
0x44, 0x00, 0x74, 0x1e, 0x6a, 0x31, 0x75, 0xe7, 0x54, 0xc5, 0x41, 0x13, 0x91, 0x26, 0x02, 0x7f,
0x29, 0x16, 0xf8, 0xcf, 0x00, 0xec, 0xd8, 0x63, 0x7f, 0xb7, 0x1b, 0x58, 0x43, 0xcc, 0x13, 0x8f,
0x2a, 0x85, 0xdc, 0xb3, 0x86, 0x18, 0xdd, 0x80, 0x7a, 0xcf, 0x72, 0x6c, 0x77, 0xd0, 0x1d, 0x19,
0xc1, 0xae, 0xdf, 0x9a, 0xce, 0x55, 0xf0, 0x5b, 0x16, 0xb6, 0xcd, 0x9b, 0x74, 0xae, 0x5e, 0x63,
0x6b, 0xb6, 0xc9, 0x12, 0x74, 0x16, 0x6a, 0xce, 0x78, 0xd8, 0x75, 0x77, 0xba, 0x9e, 0xfb, 0x84,
0x98, 0x08, 0x45, 0xe1, 0x8c, 0x87, 0xef, 0xef, 0xe8, 0xee, 0x13, 0xe2, 0xaa, 0xab, 0xc4, 0x69,
0xfb, 0xb6, 0x3b, 0xf0, 0x5b, 0x95, 0x89, 0xf6, 0x8f, 0x16, 0x90, 0xd5, 0x26, 0xb6, 0x03, 0x83,
0xae, 0xae, 0x4e, 0xb6, 0x3a, 0x5c, 0x80, 0x2e, 0x43, 0xb3, 0xef, 0x0e, 0x47, 0x06, 0xe5, 0xd0,
0x2d, 0xcf, 0x1d, 0x52, 0xfb, 0x28, 0xea, 0x29, 0x28, 0x5a, 0x83, 0x9a, 0xe5, 0x98, 0xf8, 0x29,
0x37, 0xa2, 0x1a, 0xc5, 0xa3, 0xc9, 0x8c, 0x88, 0x22, 0xda, 0x24, 0x73, 0xa9, 0x82, 0x82, 0x25,
0x7e, 0xfa, 0x44, 0x33, 0x84, 0x2d, 0xfa, 0xd6, 0x87, 0xb8, 0x55, 0x67, 0x52, 0xe4, 0xb0, 0x8e,
0xf5, 0x21, 0x26, 0x49, 0xad, 0xe5, 0xf8, 0xd8, 0x0b, 0x44, 0x89, 0xd1, 0x6a, 0x50, 0xf5, 0x69,
0x30, 0x28, 0x57, 0x6c, 0xed, 0x77, 0x05, 0x68, 0x26, 0x11, 0xa1, 0x16, 0xcc, 0xec, 0x50, 0x88,
0xd0, 0x1e, 0xf1, 0x49, 0xd0, 0x62, 0x87, 0x54, 0xfb, 0x5d, 0x4a, 0x0b, 0x55, 0x9e, 0x8a, 0x5e,
0x63, 0x30, 0xba, 0x01, 0x51, 0x02, 0x76, 0x3c, 0xaa, 0xb1, 0x45, 0x8a, 0xb2, 0x4a, 0x21, 0x34,
0xae, 0xb5, 0x60, 0x86, 0x1d, 0x43, 0xa8, 0x8e, 0xf8, 0x24, 0x23, 0xbd, 0xb1, 0x45, 0xb1, 0x32,
0xd5, 0x11, 0x9f, 0x68, 0x1d, 0xea, 0x6c, 0xcb, 0x91, 0xe1, 0x19, 0x43, 0xa1, 0x38, 0x2f, 0x49,
0x8d, 0xef, 0x36, 0xde, 0x7f, 0x40, 0xec, 0x78, 0xdb, 0xb0, 0x3c, 0x9d, 0x31, 0x7a, 0x9b, 0xae,
0x42, 0x8b, 0xa0, 0xb2, 0x5d, 0x76, 0x2c, 0x1b, 0x73, 0x15, 0x9c, 0xa1, 0xc1, 0xb3, 0x49, 0xe1,
0xb7, 0x2c, 0x1b, 0x33, 0x2d, 0x0b, 0x8f, 0x40, 0x59, 0x5b, 0x61, 0x4a, 0x46, 0x21, 0x94, 0xb1,
0x17, 0xa0, 0xc1, 0x86, 0xf7, 0xb0, 0xe7, 0x5b, 0xae, 0xc3, 0x3d, 0x25, 0xa3, 0xf1, 0x01, 0x83,
0x69, 0xdf, 0x28, 0xc1, 0x3c, 0x31, 0x48, 0x6e, 0x9b, 0xc7, 0x08, 0x77, 0x67, 0x00, 0x4c, 0x3f,
0xe8, 0x26, 0x9c, 0x48, 0xd5, 0xf4, 0x03, 0xe6, 0x0c, 0xd1, 0x5b, 0x22, 0x5a, 0x15, 0xf3, 0x13,
0xd8, 0x94, 0x83, 0xc8, 0x46, 0xac, 0x23, 0x95, 0xf7, 0x17, 0xa0, 0xe1, 0xbb, 0x63, 0xaf, 0x8f,
0xbb, 0x89, 0x52, 0xa3, 0xce, 0x80, 0x5b, 0x72, 0x37, 0x37, 0x2d, 0x6d, 0x33, 0xc4, 0xa2, 0xd6,
0xcc, 0xf1, 0xa2, 0x56, 0x25, 0x1d, 0xb5, 0x6e, 0xc3, 0x2c, 0xb5, 0xd1, 0xee, 0xc8, 0xf5, 0x59,
0xc5, 0xc6, 0x4d, 0x5b, 0xcb, 0xa9, 0xd8, 0xef, 0xfa, 0x83, 0x6d, 0x3e, 0x55, 0x6f, 0xd2, 0xa5,
0xe2, 0xd3, 0x27, 0x3a, 0x2a, 0x84, 0x0e, 0x4c, 0x47, 0xf9, 0x27, 0x61, 0x86, 0x83, 0xb1, 0xd9,
0x0d, 0x3c, 0xc3, 0xf1, 0x77, 0xb0, 0x47, 0x23, 0x57, 0x45, 0xaf, 0x13, 0xe0, 0x3d, 0x0e, 0xd3,
0x7e, 0x53, 0x80, 0x05, 0x5e, 0x40, 0x1e, 0x5f, 0x2f, 0xf2, 0x02, 0x8b, 0xf0, 0xcc, 0xc5, 0x03,
0x4a, 0xb2, 0xd2, 0x04, 0xa9, 0x51, 0x59, 0x92, 0x1a, 0x25, 0xcb, 0x92, 0xe9, 0x4c, 0x59, 0x12,
0x36, 0x19, 0x66, 0x26, 0x6f, 0x32, 0xa0, 0x13, 0x50, 0xa6, 0xb9, 0x32, 0x95, 0x5d, 0x55, 0x67,
0x1f, 0x93, 0x31, 0xf4, 0x4f, 0x0a, 0x34, 0x3a, 0xd8, 0xf0, 0xfa, 0xbb, 0x82, 0x8f, 0x6f, 0xc6,
0x9b, 0x32, 0x17, 0x73, 0x44, 0x9c, 0x58, 0xf2, 0xc5, 0xe9, 0xc6, 0xfc, 0x59, 0x81, 0xfa, 0x7f,
0x90, 0x21, 0x71, 0xd8, 0xeb, 0xf1, 0xc3, 0x5e, 0xce, 0x39, 0xac, 0x8e, 0x03, 0xcf, 0xc2, 0x7b,
0xf8, 0x0b, 0x77, 0xdc, 0x5f, 0x29, 0xd0, 0xee, 0xec, 0x3b, 0x7d, 0x9d, 0xd9, 0xf2, 0xf1, 0x2d,
0xe6, 0x02, 0x34, 0xf6, 0x12, 0xf9, 0x54, 0x81, 0x2a, 0x5c, 0x7d, 0x2f, 0x5e, 0x78, 0xe9, 0xa0,
0x8a, 0x5e, 0x10, 0x3f, 0xac, 0x70, 0xad, 0x2f, 0xcb, 0xa8, 0x4e, 0x11, 0x47, 0x5d, 0xd3, 0xac,
0x97, 0x04, 0x6a, 0x5f, 0x53, 0x60, 0x5e, 0x32, 0x11, 0x9d, 0x82, 0x19, 0x5e, 0xe4, 0xf1, 0x40,
0xcb, 0x6c, 0xd8, 0x24, 0xe2, 0x89, 0xda, 0x14, 0x96, 0x99, 0x4d, 0xd2, 0x4c, 0x74, 0x0e, 0x6a,
0x61, 0x36, 0x6e, 0x66, 0xe4, 0x63, 0xfa, 0xa8, 0x0d, 0x15, 0xee, 0x9c, 0x44, 0x99, 0x13, 0x7e,
0x6b, 0x3f, 0x53, 0x60, 0xe1, 0x3d, 0xc3, 0x31, 0xdd, 0x9d, 0x9d, 0xe3, 0xb3, 0x75, 0x0d, 0x12,
0x49, 0xfc, 0xa4, 0xed, 0x81, 0x64, 0xe6, 0x7f, 0x05, 0xe6, 0x3c, 0xe6, 0x19, 0xcd, 0x24, 0xdf,
0x8b, 0xba, 0x2a, 0x06, 0x42, 0x7e, 0x7e, 0x54, 0x00, 0x44, 0x82, 0xc1, 0x4d, 0xc3, 0x36, 0x9c,
0x3e, 0x3e, 0x3a, 0xe9, 0x97, 0xa0, 0x99, 0x08, 0x61, 0xe1, 0x2d, 0x4a, 0x3c, 0x86, 0xf9, 0xe8,
0x36, 0x34, 0x7b, 0x0c, 0x55, 0xd7, 0xc3, 0x86, 0xef, 0x3a, 0xd4, 0xb9, 0x36, 0xe5, 0x9d, 0x80,
0x7b, 0x9e, 0x35, 0x18, 0x60, 0x6f, 0xcd, 0x75, 0x4c, 0x16, 0x44, 0x1a, 0x3d, 0x41, 0x26, 0x59,
0x4a, 0x04, 0x17, 0xc5, 0x73, 0x21, 0x1a, 0x08, 0x03, 0x3a, 0x65, 0x85, 0x8f, 0x0d, 0x3b, 0x62,
0x44, 0xe4, 0x8d, 0x55, 0x36, 0xd0, 0xc9, 0x6f, 0x04, 0x49, 0xe2, 0xab, 0xf6, 0x63, 0x05, 0x50,
0x58, 0xc9, 0xd0, 0xca, 0x8c, 0x6a, 0x5f, 0x7a, 0xa9, 0x22, 0x09, 0x0a, 0xa7, 0xa1, 0x6a, 0x8a,
0x95, 0xdc, 0x5c, 0x22, 0x00, 0xf5, 0xd1, 0x94, 0xe8, 0x2e, 0x09, 0xc6, 0xd8, 0x14, 0x95, 0x02,
0x03, 0xde, 0xa1, 0xb0, 0x64, 0x78, 0x2e, 0xa5, 0xc3, 0x73, 0xbc, 0xcf, 0x51, 0x4e, 0xf4, 0x39,
0xb4, 0x8f, 0x0b, 0xa0, 0x52, 0x77, 0xb7, 0x16, 0x15, 0xdb, 0x13, 0x11, 0x7d, 0x01, 0x1a, 0xfc,
0x9e, 0x31, 0x41, 0x78, 0xfd, 0x71, 0x6c, 0x33, 0x74, 0x15, 0x4e, 0xb0, 0x49, 0x1e, 0xf6, 0xc7,
0x76, 0x94, 0x24, 0xb3, 0x8c, 0x15, 0x3d, 0x66, 0x7e, 0x96, 0x0c, 0x89, 0x15, 0xf7, 0x61, 0x61,
0x60, 0xbb, 0x3d, 0xc3, 0xee, 0x26, 0xc5, 0xc3, 0x64, 0x38, 0x81, 0xc6, 0x9f, 0x60, 0xcb, 0x3b,
0x71, 0x19, 0xfa, 0x68, 0x83, 0x94, 0xd5, 0xf8, 0x51, 0x98, 0x9f, 0xf0, 0x16, 0xf6, 0x24, 0xe9,
0x49, 0x9d, 0x2c, 0x14, 0x5f, 0xda, 0x77, 0x14, 0x98, 0x4d, 0xb5, 0x2a, 0xd3, 0xc5, 0x9e, 0x92,
0x2d, 0xf6, 0xae, 0x43, 0x99, 0x54, 0x40, 0xcc, 0x19, 0x36, 0xe5, 0x85, 0x48, 0x72, 0x57, 0x9d,
0x2d, 0x40, 0x2b, 0x30, 0x2f, 0xb9, 0xd4, 0xe2, 0x3a, 0x80, 0xb2, 0x77, 0x5a, 0xda, 0xef, 0x4b,
0x50, 0x8b, 0xf1, 0xe3, 0x90, 0x3a, 0x75, 0x92, 0xde, 0x53, 0xea, 0x78, 0xc5, 0xec, 0xf1, 0x72,
0x6e, 0x75, 0x88, 0xde, 0x0d, 0xf1, 0x90, 0x65, 0xf8, 0xbc, 0xdc, 0x18, 0xe2, 0x21, 0xcd, 0xef,
0x89, 0x4a, 0x8e, 0x87, 0xac, 0xc2, 0x64, 0xe6, 0x34, 0xe3, 0x8c, 0x87, 0xb4, 0xbe, 0x4c, 0x16,
0x37, 0x33, 0x07, 0x14, 0x37, 0x95, 0x64, 0x71, 0x93, 0xb0, 0xa3, 0x6a, 0xda, 0x8e, 0x26, 0x2d,
0x1d, 0xaf, 0xc2, 0x7c, 0xdf, 0xc3, 0x46, 0x80, 0xcd, 0x9b, 0xfb, 0x6b, 0xe1, 0x10, 0xcf, 0x8c,
0x64, 0x43, 0xe8, 0x56, 0xd4, 0xb3, 0x61, 0x52, 0xae, 0x53, 0x29, 0xcb, 0x6b, 0x27, 0x2e, 0x1b,
0x26, 0x64, 0xe1, 0x9e, 0xe9, 0x57, 0xba, 0x68, 0x6d, 0x1c, 0xa9, 0x68, 0x3d, 0x07, 0x35, 0x11,
0x5a, 0x89, 0xb9, 0x37, 0x99, 0xe7, 0x13, 0xbe, 0xc0, 0xf4, 0x13, 0xce, 0x60, 0x36, 0xd9, 0xf4,
0x4c, 0x57, 0x9e, 0x6a, 0xa6, 0xf2, 0xd4, 0x7e, 0x5b, 0x84, 0x66, 0x54, 0xac, 0x4c, 0xec, 0x2d,
0x26, 0xb9, 0xbf, 0xdd, 0x02, 0x35, 0x8a, 0xc7, 0x94, 0x91, 0x07, 0xd6, 0x5b, 0xe9, 0x0b, 0x83,
0xd9, 0x51, 0xca, 0x2c, 0x13, 0x2d, 0xd9, 0xd2, 0x33, 0xb5, 0x64, 0x8f, 0x79, 0xd5, 0x75, 0x0d,
0x4e, 0x86, 0x71, 0x36, 0x71, 0x6c, 0x96, 0xcc, 0x9f, 0x10, 0x83, 0xdb, 0xf1, 0xe3, 0xe7, 0x58,
0xfa, 0x4c, 0x9e, 0xa5, 0xa7, 0x25, 0x5d, 0xc9, 0x48, 0x3a, 0x7b, 0xe3, 0x56, 0x95, 0xdd, 0xb8,
0xdd, 0x87, 0x79, 0xda, 0x87, 0xf3, 0xfb, 0x9e, 0xd5, 0xc3, 0x61, 0x6a, 0x3a, 0x89, 0x58, 0xdb,
0x50, 0x49, 0x65, 0xb7, 0xe1, 0xb7, 0xf6, 0x25, 0x05, 0x16, 0xb2, 0xfb, 0x52, 0x8d, 0x89, 0xfc,
0x85, 0x92, 0xf0, 0x17, 0xff, 0x05, 0xf3, 0xd1, 0xf6, 0xc9, 0xbc, 0x39, 0x27, 0x33, 0x94, 0x10,
0xae, 0xa3, 0x68, 0x0f, 0x01, 0xd3, 0xfe, 0xa2, 0x84, 0xed, 0x4c, 0x02, 0x1b, 0xd0, 0x56, 0x2e,
0x89, 0x61, 0xae, 0x63, 0x5b, 0x4e, 0x58, 0x5c, 0xf3, 0x33, 0x32, 0x20, 0x2f, 0xae, 0xdf, 0x83,
0x59, 0x3e, 0x29, 0x0c, 0x45, 0x13, 0x26, 0x5f, 0x4d, 0xb6, 0x2e, 0x0c, 0x42, 0x97, 0xa0, 0xc9,
0x7b, 0xac, 0x02, 0x5f, 0x51, 0xd2, 0x79, 0x45, 0xff, 0x0e, 0xaa, 0x98, 0xf6, 0xac, 0xc1, 0x6f,
0x96, 0x2f, 0x0c, 0x93, 0xb8, 0xff, 0x57, 0xa0, 0x95, 0x0c, 0x85, 0xb1, 0xe3, 0x3f, 0x7b, 0x2a,
0xf7, 0x2f, 0xc9, 0xdb, 0xa9, 0x4b, 0x07, 0xd0, 0x13, 0xe1, 0x11, 0x77, 0x54, 0x5b, 0xf4, 0xa6,
0x91, 0x54, 0x20, 0xeb, 0x96, 0x1f, 0x78, 0x56, 0x6f, 0x7c, 0xac, 0x37, 0x08, 0xda, 0x4f, 0x0a,
0xf0, 0xa2, 0x74, 0xc3, 0xe3, 0xdc, 0x43, 0xe5, 0x15, 0xfc, 0x37, 0xa1, 0x92, 0xaa, 0x54, 0x2e,
0x1f, 0x70, 0x78, 0xde, 0xa0, 0x62, 0x3d, 0x14, 0xb1, 0x8e, 0xec, 0x11, 0xea, 0x74, 0x29, 0x7f,
0x0f, 0xae, 0xb4, 0x89, 0x3d, 0xc4, 0x3a, 0x74, 0x03, 0xea, 0xac, 0x0a, 0xec, 0xee, 0x59, 0xf8,
0x89, 0xb8, 0x3e, 0x39, 0x2b, 0xf5, 0x6b, 0x74, 0xde, 0x03, 0x0b, 0x3f, 0xd1, 0x6b, 0x76, 0xf8,
0xdb, 0xd7, 0x7e, 0x58, 0x00, 0x88, 0xc6, 0x48, 0x09, 0x1a, 0x19, 0x0c, 0xb7, 0x80, 0x18, 0x84,
0xc4, 0xdb, 0x64, 0x8a, 0x27, 0x3e, 0x91, 0x1e, 0xf5, 0x47, 0x4d, 0xcb, 0x0f, 0x38, 0x5f, 0x56,
0x0e, 0xa6, 0x45, 0xb0, 0x88, 0x88, 0x8c, 0xdd, 0x4e, 0x88, 0x12, 0x8b, 0x40, 0xd0, 0xab, 0x80,
0x06, 0x9e, 0xfb, 0xc4, 0x72, 0x06, 0xf1, 0xc4, 0x9c, 0xe5, 0xef, 0x73, 0x7c, 0x24, 0xca, 0xcc,
0xdb, 0x5d, 0x50, 0xd3, 0xfb, 0x49, 0x2e, 0x29, 0xde, 0x48, 0x5e, 0x52, 0x1c, 0x64, 0x46, 0x64,
0x9b, 0xf8, 0x2d, 0xc5, 0xbf, 0x86, 0xd9, 0x14, 0x25, 0x2f, 0xcf, 0x73, 0xc5, 0x7a, 0x56, 0x85,
0x44, 0xcf, 0x4a, 0xfb, 0xa6, 0x02, 0x28, 0xab, 0x15, 0xa8, 0x09, 0x85, 0x70, 0x93, 0xc2, 0xe6,
0x7a, 0x4a, 0x0a, 0x85, 0x8c, 0x14, 0x4e, 0x43, 0x35, 0x8c, 0x24, 0xdc, 0x6d, 0x44, 0x80, 0xb8,
0x8c, 0x4a, 0x49, 0x19, 0xc5, 0x08, 0x2b, 0x27, 0x09, 0xdb, 0x05, 0x94, 0xd5, 0xb4, 0xf8, 0x4e,
0x4a, 0x72, 0xa7, 0xc3, 0x28, 0x8c, 0x61, 0x2a, 0x26, 0x31, 0xfd, 0x5a, 0x01, 0x14, 0xc5, 0xca,
0xf0, 0x06, 0x65, 0x92, 0x00, 0xb3, 0x02, 0xf3, 0xd9, 0x48, 0x2a, 0xd2, 0x07, 0x94, 0x89, 0xa3,
0xb2, 0x98, 0x57, 0x94, 0xc4, 0x3c, 0xf4, 0x66, 0xe8, 0x1b, 0x58, 0x62, 0x70, 0x36, 0x2f, 0x31,
0x48, 0xba, 0x07, 0xed, 0xa7, 0x0a, 0xcc, 0x85, 0xd8, 0x9e, 0xe9, 0x24, 0x87, 0xdf, 0x08, 0x7d,
0xc2, 0xa4, 0x77, 0x60, 0x86, 0xb7, 0x47, 0x32, 0xca, 0x37, 0x49, 0x15, 0x70, 0x02, 0xca, 0x44,
0xd7, 0x45, 0xbf, 0x80, 0x7d, 0x68, 0x3f, 0x52, 0x00, 0x3a, 0xfb, 0x4e, 0xff, 0x06, 0xd3, 0x81,
0xab, 0x50, 0x3a, 0xec, 0x02, 0x9c, 0xcc, 0xa6, 0xd9, 0x16, 0x9d, 0x39, 0x01, 0x5b, 0x12, 0x05,
0x4c, 0x31, 0x5d, 0xc0, 0xe4, 0x95, 0x1e, 0xf9, 0x7a, 0xff, 0x4b, 0x05, 0x4e, 0x11, 0x22, 0x9e,
0x4b, 0x10, 0x9a, 0x88, 0x75, 0x31, 0x9b, 0x2a, 0x26, 0x6d, 0xea, 0x3a, 0xcc, 0xb0, 0x1a, 0x42,
0x04, 0x84, 0xb3, 0x79, 0x2c, 0x63, 0x0c, 0xd6, 0xc5, 0xf4, 0xa5, 0x7f, 0x83, 0x6a, 0xd8, 0xcb,
0x43, 0x35, 0x98, 0xb9, 0xef, 0xdc, 0x76, 0xdc, 0x27, 0x8e, 0x3a, 0x85, 0x66, 0xa0, 0x78, 0xc3,
0xb6, 0x55, 0x05, 0x35, 0xa0, 0xda, 0x09, 0x3c, 0x6c, 0x0c, 0x2d, 0x67, 0xa0, 0x16, 0x50, 0x13,
0xe0, 0x3d, 0xcb, 0x0f, 0x5c, 0xcf, 0xea, 0x1b, 0xb6, 0x5a, 0x5c, 0xfa, 0x10, 0x9a, 0xc9, 0x14,
0x1a, 0xd5, 0xa1, 0xb2, 0xe5, 0x06, 0xef, 0x3e, 0xb5, 0xfc, 0x40, 0x9d, 0x22, 0xf3, 0xb7, 0xdc,
0x60, 0xdb, 0xc3, 0x3e, 0x76, 0x02, 0x55, 0x41, 0x00, 0xd3, 0xef, 0x3b, 0xeb, 0x96, 0xff, 0x48,
0x2d, 0xa0, 0x79, 0x5e, 0x04, 0x1b, 0xf6, 0x26, 0xcf, 0x4b, 0xd5, 0x22, 0x59, 0x1e, 0x7e, 0x95,
0x90, 0x0a, 0xf5, 0x70, 0xca, 0xc6, 0xf6, 0x7d, 0xb5, 0x8c, 0xaa, 0x50, 0x66, 0x3f, 0xa7, 0x97,
0x4c, 0x50, 0xd3, 0x1d, 0x1c, 0xb2, 0x27, 0x3b, 0x44, 0x08, 0x52, 0xa7, 0xc8, 0xc9, 0x78, 0x0b,
0x4d, 0x55, 0xd0, 0x2c, 0xd4, 0x62, 0x0d, 0x29, 0xb5, 0x40, 0x00, 0x1b, 0xde, 0xa8, 0xcf, 0xa5,
0xc7, 0x48, 0x20, 0x49, 0xd4, 0x3a, 0xe1, 0x44, 0x69, 0xe9, 0x26, 0x54, 0x44, 0x6e, 0x4f, 0xa6,
0x72, 0x16, 0x91, 0x4f, 0x75, 0x0a, 0xcd, 0x41, 0x23, 0xf1, 0xe8, 0x4e, 0x55, 0x10, 0x82, 0x66,
0xf2, 0x31, 0xa8, 0x5a, 0x58, 0x5a, 0x05, 0x88, 0x6c, 0x89, 0x90, 0xb3, 0xe9, 0xec, 0x19, 0xb6,
0x65, 0x32, 0xda, 0xc8, 0x10, 0xe1, 0x2e, 0xe5, 0x0e, 0x6b, 0xc5, 0xa8, 0x85, 0xa5, 0x73, 0x50,
0x11, 0x5a, 0x4e, 0xe0, 0x3a, 0x1e, 0xba, 0x7b, 0x98, 0x49, 0xa6, 0x83, 0x03, 0x55, 0x59, 0xfd,
0x56, 0x03, 0x80, 0x35, 0x5d, 0x5c, 0xd7, 0x33, 0x91, 0x0d, 0x68, 0x03, 0x07, 0xa4, 0xa0, 0x74,
0x1d, 0x51, 0x0c, 0xfa, 0x68, 0x39, 0xa9, 0x0a, 0xfc, 0x23, 0x3b, 0x91, 0x9f, 0xbe, 0x7d, 0x51,
0x3a, 0x3f, 0x35, 0x59, 0x9b, 0x42, 0x43, 0x8a, 0xed, 0x9e, 0x35, 0xc4, 0xf7, 0xac, 0xfe, 0xa3,
0xb0, 0x53, 0x93, 0xff, 0xb4, 0x32, 0x35, 0x55, 0xe0, 0xbb, 0x20, 0xc5, 0xd7, 0x09, 0x3c, 0xcb,
0x19, 0x88, 0x1c, 0x4c, 0x9b, 0x42, 0x8f, 0x53, 0x0f, 0x3b, 0x05, 0xc2, 0xd5, 0x49, 0xde, 0x72,
0x1e, 0x0d, 0xa5, 0x0d, 0xb3, 0xa9, 0x57, 0xe0, 0x68, 0x49, 0xfe, 0x9c, 0x48, 0xf6, 0x62, 0xbd,
0x7d, 0x65, 0xa2, 0xb9, 0x21, 0x36, 0x0b, 0x9a, 0xc9, 0x97, 0xce, 0xe8, 0x9f, 0xf2, 0x36, 0xc8,
0x3c, 0x68, 0x6c, 0x2f, 0x4d, 0x32, 0x35, 0x44, 0xf5, 0x90, 0x29, 0xe8, 0x61, 0xa8, 0xa4, 0x8f,
0x49, 0xdb, 0x07, 0xa5, 0xbf, 0xda, 0x14, 0xfa, 0x1f, 0x98, 0xcb, 0x3c, 0xbb, 0x44, 0xaf, 0xc8,
0xbb, 0xf1, 0xf2, 0xd7, 0x99, 0x87, 0x61, 0x78, 0x98, 0x36, 0xaf, 0x7c, 0xea, 0x33, 0x4f, 0x94,
0x27, 0xa7, 0x3e, 0xb6, 0xfd, 0x41, 0xd4, 0x3f, 0x33, 0x86, 0x31, 0x35, 0x9b, 0x74, 0xeb, 0xef,
0x55, 0x19, 0x8a, 0xdc, 0xb7, 0x9f, 0xed, 0xe5, 0x49, 0xa7, 0xc7, 0xb5, 0x2b, 0xf9, 0xbc, 0x50,
0xce, 0x34, 0xe9, 0x93, 0x48, 0xb9, 0x76, 0xc9, 0x5f, 0x2b, 0x6a, 0x53, 0xe8, 0x5e, 0xc2, 0xbd,
0xa2, 0xcb, 0x79, 0xc2, 0x49, 0x5e, 0x08, 0x1c, 0xc6, 0xb7, 0xff, 0x05, 0xc4, 0x6c, 0xc7, 0xd9,
0xb1, 0x06, 0x63, 0xcf, 0x60, 0x8a, 0x95, 0xe7, 0x6e, 0xb2, 0x53, 0x05, 0x9a, 0xd7, 0x9e, 0x61,
0x45, 0x78, 0xa4, 0x2e, 0xc0, 0x06, 0x0e, 0xee, 0xe2, 0xc0, 0xb3, 0xfa, 0x7e, 0xfa, 0x44, 0x91,
0x47, 0xe5, 0x13, 0x04, 0xaa, 0x97, 0x0f, 0x9d, 0x17, 0x22, 0xe8, 0x41, 0x6d, 0x03, 0x07, 0x3c,
0xaf, 0xf2, 0x51, 0xee, 0x4a, 0x31, 0x43, 0xa0, 0x58, 0x3c, 0x7c, 0x62, 0xdc, 0x9d, 0xa5, 0x9e,
0x5a, 0xa2, 0x5c, 0xc1, 0x66, 0x1f, 0x80, 0xca, 0xdd, 0x59, 0xce, 0xdb, 0x4d, 0x6d, 0x6a, 0xf5,
0xe3, 0x26, 0x54, 0x69, 0x6c, 0x22, 0x81, 0xf4, 0x1f, 0xa1, 0xe9, 0x39, 0x87, 0xa6, 0x0f, 0x60,
0x36, 0xf5, 0x6a, 0x4f, 0x2e, 0x4b, 0xf9, 0xd3, 0xbe, 0x09, 0x3c, 0x6c, 0xf2, 0x45, 0x9d, 0xdc,
0x59, 0x48, 0x5f, 0xdd, 0x1d, 0xb6, 0xf7, 0x03, 0xf6, 0xe0, 0x35, 0x6c, 0x66, 0xbd, 0x9c, 0x5b,
0x76, 0x24, 0xef, 0x3a, 0x3f, 0x7b, 0xcf, 0xfd, 0xc9, 0x47, 0xb6, 0x0f, 0x60, 0x36, 0xf5, 0xe2,
0x44, 0x2e, 0x55, 0xf9, 0xb3, 0x94, 0xc3, 0x76, 0xff, 0x14, 0x43, 0x80, 0x09, 0xf3, 0x92, 0xc7,
0x00, 0x68, 0x39, 0xaf, 0x2a, 0x91, 0xbf, 0x1a, 0x38, 0xfc, 0x40, 0x8d, 0x84, 0x29, 0xa1, 0xc5,
0x3c, 0x22, 0xd3, 0x7f, 0xea, 0x69, 0xbf, 0x32, 0xd9, 0x3f, 0x80, 0xc2, 0x03, 0x75, 0x60, 0x9a,
0xbd, 0x43, 0x41, 0x2f, 0xc9, 0x9b, 0x3e, 0xb1, 0x37, 0x2a, 0xed, 0xc3, 0x5e, 0xb2, 0xf8, 0x63,
0x3b, 0xf0, 0xe9, 0xa6, 0x65, 0xea, 0x21, 0x91, 0xf4, 0x01, 0x55, 0xfc, 0xf1, 0x48, 0xfb, 0xf0,
0xf7, 0x22, 0x62, 0xd3, 0xbf, 0xef, 0x38, 0xf9, 0x14, 0xe6, 0x25, 0xad, 0x5a, 0x94, 0x97, 0x0f,
0xe5, 0x34, 0x89, 0xdb, 0x2b, 0x13, 0xcf, 0x0f, 0x31, 0xff, 0x37, 0xa8, 0xe9, 0x6a, 0x1f, 0x5d,
0xc9, 0xd3, 0x67, 0x19, 0xce, 0x83, 0x95, 0xf9, 0xe6, 0xeb, 0x0f, 0x57, 0x07, 0x56, 0xb0, 0x3b,
0xee, 0x91, 0x91, 0x15, 0x36, 0xf5, 0x55, 0xcb, 0xe5, 0xbf, 0x56, 0x04, 0xff, 0x57, 0xe8, 0xea,
0x15, 0x8a, 0x6a, 0xd4, 0xeb, 0x4d, 0xd3, 0xcf, 0x6b, 0x7f, 0x0b, 0x00, 0x00, 0xff, 0xff, 0x1f,
0xf2, 0x39, 0xb5, 0xac, 0x3b, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
@ -3891,7 +3891,7 @@ const _ = grpc.SupportPackageIsVersion4
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type QueryCoordClient interface {
GetComponentStates(ctx context.Context, in *internalpb.GetComponentStatesRequest, opts ...grpc.CallOption) (*internalpb.ComponentStates, error)
GetComponentStates(ctx context.Context, in *milvuspb.GetComponentStatesRequest, opts ...grpc.CallOption) (*milvuspb.ComponentStates, error)
GetTimeTickChannel(ctx context.Context, in *internalpb.GetTimeTickChannelRequest, opts ...grpc.CallOption) (*milvuspb.StringResponse, error)
GetStatisticsChannel(ctx context.Context, in *internalpb.GetStatisticsChannelRequest, opts ...grpc.CallOption) (*milvuspb.StringResponse, error)
ShowCollections(ctx context.Context, in *ShowCollectionsRequest, opts ...grpc.CallOption) (*ShowCollectionsResponse, error)
@ -3919,8 +3919,8 @@ func NewQueryCoordClient(cc *grpc.ClientConn) QueryCoordClient {
return &queryCoordClient{cc}
}
func (c *queryCoordClient) GetComponentStates(ctx context.Context, in *internalpb.GetComponentStatesRequest, opts ...grpc.CallOption) (*internalpb.ComponentStates, error) {
out := new(internalpb.ComponentStates)
func (c *queryCoordClient) GetComponentStates(ctx context.Context, in *milvuspb.GetComponentStatesRequest, opts ...grpc.CallOption) (*milvuspb.ComponentStates, error) {
out := new(milvuspb.ComponentStates)
err := c.cc.Invoke(ctx, "/milvus.proto.query.QueryCoord/GetComponentStates", in, out, opts...)
if err != nil {
return nil, err
@ -4065,7 +4065,7 @@ func (c *queryCoordClient) GetShardLeaders(ctx context.Context, in *GetShardLead
// QueryCoordServer is the server API for QueryCoord service.
type QueryCoordServer interface {
GetComponentStates(context.Context, *internalpb.GetComponentStatesRequest) (*internalpb.ComponentStates, error)
GetComponentStates(context.Context, *milvuspb.GetComponentStatesRequest) (*milvuspb.ComponentStates, error)
GetTimeTickChannel(context.Context, *internalpb.GetTimeTickChannelRequest) (*milvuspb.StringResponse, error)
GetStatisticsChannel(context.Context, *internalpb.GetStatisticsChannelRequest) (*milvuspb.StringResponse, error)
ShowCollections(context.Context, *ShowCollectionsRequest) (*ShowCollectionsResponse, error)
@ -4089,7 +4089,7 @@ type QueryCoordServer interface {
type UnimplementedQueryCoordServer struct {
}
func (*UnimplementedQueryCoordServer) GetComponentStates(ctx context.Context, req *internalpb.GetComponentStatesRequest) (*internalpb.ComponentStates, error) {
func (*UnimplementedQueryCoordServer) GetComponentStates(ctx context.Context, req *milvuspb.GetComponentStatesRequest) (*milvuspb.ComponentStates, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetComponentStates not implemented")
}
func (*UnimplementedQueryCoordServer) GetTimeTickChannel(ctx context.Context, req *internalpb.GetTimeTickChannelRequest) (*milvuspb.StringResponse, error) {
@ -4143,7 +4143,7 @@ func RegisterQueryCoordServer(s *grpc.Server, srv QueryCoordServer) {
}
func _QueryCoord_GetComponentStates_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(internalpb.GetComponentStatesRequest)
in := new(milvuspb.GetComponentStatesRequest)
if err := dec(in); err != nil {
return nil, err
}
@ -4155,7 +4155,7 @@ func _QueryCoord_GetComponentStates_Handler(srv interface{}, ctx context.Context
FullMethod: "/milvus.proto.query.QueryCoord/GetComponentStates",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(QueryCoordServer).GetComponentStates(ctx, req.(*internalpb.GetComponentStatesRequest))
return srv.(QueryCoordServer).GetComponentStates(ctx, req.(*milvuspb.GetComponentStatesRequest))
}
return interceptor(ctx, in, info, handler)
}
@ -4507,7 +4507,7 @@ var _QueryCoord_serviceDesc = grpc.ServiceDesc{
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type QueryNodeClient interface {
GetComponentStates(ctx context.Context, in *internalpb.GetComponentStatesRequest, opts ...grpc.CallOption) (*internalpb.ComponentStates, error)
GetComponentStates(ctx context.Context, in *milvuspb.GetComponentStatesRequest, opts ...grpc.CallOption) (*milvuspb.ComponentStates, error)
GetTimeTickChannel(ctx context.Context, in *internalpb.GetTimeTickChannelRequest, opts ...grpc.CallOption) (*milvuspb.StringResponse, error)
GetStatisticsChannel(ctx context.Context, in *internalpb.GetStatisticsChannelRequest, opts ...grpc.CallOption) (*milvuspb.StringResponse, error)
WatchDmChannels(ctx context.Context, in *WatchDmChannelsRequest, opts ...grpc.CallOption) (*commonpb.Status, error)
@ -4536,8 +4536,8 @@ func NewQueryNodeClient(cc *grpc.ClientConn) QueryNodeClient {
return &queryNodeClient{cc}
}
func (c *queryNodeClient) GetComponentStates(ctx context.Context, in *internalpb.GetComponentStatesRequest, opts ...grpc.CallOption) (*internalpb.ComponentStates, error) {
out := new(internalpb.ComponentStates)
func (c *queryNodeClient) GetComponentStates(ctx context.Context, in *milvuspb.GetComponentStatesRequest, opts ...grpc.CallOption) (*milvuspb.ComponentStates, error) {
out := new(milvuspb.ComponentStates)
err := c.cc.Invoke(ctx, "/milvus.proto.query.QueryNode/GetComponentStates", in, out, opts...)
if err != nil {
return nil, err
@ -4700,7 +4700,7 @@ func (c *queryNodeClient) SyncDistribution(ctx context.Context, in *SyncDistribu
// QueryNodeServer is the server API for QueryNode service.
type QueryNodeServer interface {
GetComponentStates(context.Context, *internalpb.GetComponentStatesRequest) (*internalpb.ComponentStates, error)
GetComponentStates(context.Context, *milvuspb.GetComponentStatesRequest) (*milvuspb.ComponentStates, error)
GetTimeTickChannel(context.Context, *internalpb.GetTimeTickChannelRequest) (*milvuspb.StringResponse, error)
GetStatisticsChannel(context.Context, *internalpb.GetStatisticsChannelRequest) (*milvuspb.StringResponse, error)
WatchDmChannels(context.Context, *WatchDmChannelsRequest) (*commonpb.Status, error)
@ -4725,7 +4725,7 @@ type QueryNodeServer interface {
type UnimplementedQueryNodeServer struct {
}
func (*UnimplementedQueryNodeServer) GetComponentStates(ctx context.Context, req *internalpb.GetComponentStatesRequest) (*internalpb.ComponentStates, error) {
func (*UnimplementedQueryNodeServer) GetComponentStates(ctx context.Context, req *milvuspb.GetComponentStatesRequest) (*milvuspb.ComponentStates, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetComponentStates not implemented")
}
func (*UnimplementedQueryNodeServer) GetTimeTickChannel(ctx context.Context, req *internalpb.GetTimeTickChannelRequest) (*milvuspb.StringResponse, error) {
@ -4785,7 +4785,7 @@ func RegisterQueryNodeServer(s *grpc.Server, srv QueryNodeServer) {
}
func _QueryNode_GetComponentStates_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(internalpb.GetComponentStatesRequest)
in := new(milvuspb.GetComponentStatesRequest)
if err := dec(in); err != nil {
return nil, err
}
@ -4797,7 +4797,7 @@ func _QueryNode_GetComponentStates_Handler(srv interface{}, ctx context.Context,
FullMethod: "/milvus.proto.query.QueryNode/GetComponentStates",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(QueryNodeServer).GetComponentStates(ctx, req.(*internalpb.GetComponentStatesRequest))
return srv.(QueryNodeServer).GetComponentStates(ctx, req.(*milvuspb.GetComponentStatesRequest))
}
return interceptor(ctx, in, info, handler)
}

2
internal/proto/root_coord.proto
View File

@ -11,7 +11,7 @@ import "proxy.proto";
import "etcd_meta.proto";
service RootCoord {
rpc GetComponentStates(internal.GetComponentStatesRequest) returns (internal.ComponentStates) {}
rpc GetComponentStates(milvus.GetComponentStatesRequest) returns (milvus.ComponentStates) {}
rpc GetTimeTickChannel(internal.GetTimeTickChannelRequest) returns(milvus.StringResponse) {}
rpc GetStatisticsChannel(internal.GetStatisticsChannelRequest) returns(milvus.StringResponse){}
/**

198
internal/proto/rootcoordpb/root_coord.pb.go
View File

@ -674,101 +674,101 @@ func init() {
func init() { proto.RegisterFile("root_coord.proto", fileDescriptor_4513485a144f6b06) }
var fileDescriptor_4513485a144f6b06 = []byte{
// 1496 bytes of a gzipped FileDescriptorProto
// 1498 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x58, 0x5b, 0x73, 0x13, 0x37,
0x14, 0xc6, 0x36, 0x49, 0xec, 0x63, 0xc7, 0x0e, 0x1a, 0x2e, 0xae, 0xa1, 0xd4, 0xb8, 0x14, 0xcc,
0x14, 0xc6, 0x36, 0x49, 0xec, 0x63, 0xc7, 0x0e, 0x1a, 0x2e, 0xae, 0xa1, 0xd4, 0x18, 0x5a, 0xcc,
0xcd, 0xa1, 0x61, 0x86, 0x52, 0xde, 0x88, 0xcd, 0x04, 0x4f, 0x9b, 0x21, 0x5d, 0x43, 0x87, 0x5e,
0x18, 0x57, 0xde, 0x15, 0x8e, 0x26, 0xeb, 0x95, 0x59, 0xc9, 0xb9, 0x4c, 0x9f, 0x3a, 0xd3, 0xf7,
0xfe, 0xa5, 0x4e, 0xfb, 0x53, 0xfa, 0x47, 0x3a, 0x5a, 0xed, 0xca, 0xbb, 0xeb, 0x5d, 0x67, 0x03,
0xbc, 0x59, 0xda, 0x4f, 0xdf, 0x77, 0xf4, 0x49, 0x47, 0x47, 0x32, 0x6c, 0xb8, 0x8c, 0x89, 0xa1,
0xc9, 0x98, 0x6b, 0x75, 0xa6, 0x2e, 0x13, 0x0c, 0x5d, 0x9e, 0x50, 0xfb, 0x70, 0xc6, 0x55, 0xab,
0x23, 0x3f, 0x7b, 0x5f, 0x1b, 0x15, 0x93, 0x4d, 0x26, 0xcc, 0x51, 0xfd, 0x8d, 0x4a, 0x18, 0xd5,
0xa8, 0x52, 0x47, 0x10, 0xd7, 0xc1, 0xb6, 0xdf, 0x2e, 0x4f, 0x5d, 0x76, 0x7c, 0xe2, 0x37, 0x6a,
0x44, 0x98, 0xd6, 0x70, 0x42, 0x04, 0x56, 0x1d, 0xad, 0x21, 0x5c, 0x7a, 0x66, 0xdb, 0xcc, 0x7c,
0x45, 0x27, 0x84, 0x0b, 0x3c, 0x99, 0x1a, 0xe4, 0xfd, 0x8c, 0x70, 0x81, 0x1e, 0xc2, 0xf9, 0x11,
0xe6, 0xa4, 0x9e, 0x6b, 0xe6, 0xda, 0xe5, 0xad, 0x6b, 0x9d, 0x48, 0x24, 0xbe, 0xfc, 0x2e, 0x1f,
0x6f, 0x63, 0x4e, 0x0c, 0x0f, 0x89, 0x2e, 0xc2, 0x8a, 0xc9, 0x66, 0x8e, 0xa8, 0x17, 0x9a, 0xb9,
0xf6, 0xba, 0xa1, 0x1a, 0xad, 0x3f, 0x72, 0x70, 0x39, 0xae, 0xc0, 0xa7, 0xcc, 0xe1, 0x04, 0x3d,
0x82, 0x55, 0x2e, 0xb0, 0x98, 0x71, 0x5f, 0xe4, 0x6a, 0xa2, 0xc8, 0xc0, 0x83, 0x18, 0x3e, 0x14,
0x5d, 0x83, 0x92, 0x08, 0x98, 0xea, 0xf9, 0x66, 0xae, 0x7d, 0xde, 0x98, 0x77, 0xa4, 0xc4, 0xf0,
0x06, 0xaa, 0x5e, 0x08, 0xfd, 0xde, 0x27, 0x98, 0x5d, 0x3e, 0xcc, 0x6c, 0x43, 0x4d, 0x33, 0x7f,
0xcc, 0xac, 0xaa, 0x90, 0xef, 0xf7, 0x3c, 0xea, 0x82, 0x91, 0xef, 0xf7, 0x52, 0xe6, 0xf1, 0x4f,
0x1e, 0x2a, 0xfd, 0xc9, 0x94, 0xb9, 0xc2, 0x20, 0x7c, 0x66, 0x8b, 0x0f, 0xd3, 0xba, 0x02, 0x6b,
0x02, 0xf3, 0x83, 0x21, 0xb5, 0x7c, 0xc1, 0x55, 0xd9, 0xec, 0x5b, 0xe8, 0x0b, 0x28, 0x5b, 0x58,
0x60, 0x87, 0x59, 0x44, 0x7e, 0x2c, 0x78, 0x1f, 0x21, 0xe8, 0xea, 0x5b, 0xe8, 0x31, 0xac, 0x48,
0x0e, 0x52, 0x3f, 0xdf, 0xcc, 0xb5, 0xab, 0x5b, 0xcd, 0x44, 0x35, 0x15, 0xa0, 0xd4, 0x24, 0x86,
0x82, 0xa3, 0x06, 0x14, 0x39, 0x19, 0x4f, 0x88, 0x23, 0x78, 0x7d, 0xa5, 0x59, 0x68, 0x17, 0x0c,
0xdd, 0x46, 0x9f, 0x41, 0x11, 0xcf, 0x04, 0x1b, 0x52, 0x8b, 0xd7, 0x57, 0xbd, 0x6f, 0x6b, 0xb2,
0xdd, 0xb7, 0x38, 0xba, 0x0a, 0x25, 0x97, 0x1d, 0x0d, 0x95, 0x11, 0x6b, 0x5e, 0x34, 0x45, 0x97,
0x1d, 0x75, 0x65, 0x1b, 0x7d, 0x03, 0x2b, 0xd4, 0x79, 0xc7, 0x78, 0xbd, 0xd8, 0x2c, 0xb4, 0xcb,
0x5b, 0x37, 0x12, 0x63, 0xf9, 0x8e, 0x9c, 0xfc, 0x88, 0xed, 0x19, 0xd9, 0xc3, 0xd4, 0x35, 0x14,
0xbe, 0xf5, 0x57, 0x0e, 0xae, 0xf4, 0x08, 0x37, 0x5d, 0x3a, 0x22, 0x03, 0x3f, 0x8a, 0x0f, 0xdf,
0x16, 0x2d, 0xa8, 0x98, 0xcc, 0xb6, 0x89, 0x29, 0x28, 0x73, 0xf4, 0x12, 0x46, 0xfa, 0xd0, 0x75,
0x00, 0x7f, 0xba, 0xfd, 0x1e, 0xaf, 0x17, 0xbc, 0x49, 0x86, 0x7a, 0x5a, 0x33, 0xa8, 0xf9, 0x81,
0x48, 0xe2, 0xbe, 0xf3, 0x8e, 0x2d, 0xd0, 0xe6, 0x12, 0x68, 0x9b, 0x50, 0x9e, 0x62, 0x57, 0xd0,
0x88, 0x72, 0xb8, 0x4b, 0xe6, 0x8a, 0x96, 0xf1, 0x97, 0x73, 0xde, 0xd1, 0xfa, 0x2f, 0x0f, 0x15,
0x5f, 0x57, 0x6a, 0x72, 0xd4, 0x83, 0x92, 0x9c, 0xd3, 0x50, 0xfa, 0xe4, 0x5b, 0x70, 0xbb, 0x93,
0x7c, 0x02, 0x75, 0x62, 0x01, 0x1b, 0xc5, 0x51, 0x10, 0x7a, 0x0f, 0xca, 0xd4, 0xb1, 0xc8, 0xf1,
0x50, 0x2d, 0x4f, 0xde, 0x5b, 0x9e, 0x2f, 0xa3, 0x3c, 0xf2, 0x14, 0xea, 0x68, 0x6d, 0x8b, 0x1c,
0x7b, 0x1c, 0x40, 0x83, 0x9f, 0x1c, 0x11, 0xb8, 0x40, 0x8e, 0x85, 0x8b, 0x87, 0x61, 0xae, 0x82,
0xc7, 0xf5, 0xed, 0x29, 0x31, 0x79, 0x04, 0x9d, 0xe7, 0x72, 0xb4, 0xe6, 0xe6, 0xcf, 0x1d, 0xe1,
0x9e, 0x18, 0x35, 0x12, 0xed, 0x6d, 0xfc, 0x06, 0x17, 0x93, 0x80, 0x68, 0x03, 0x0a, 0x07, 0xe4,
0xc4, 0xb7, 0x5d, 0xfe, 0x44, 0x5b, 0xb0, 0x72, 0x28, 0xb7, 0x92, 0xe7, 0xf3, 0xc2, 0xde, 0xf0,
0x26, 0x34, 0x9f, 0x89, 0x82, 0x3e, 0xcd, 0x3f, 0xc9, 0xb5, 0xfe, 0xcd, 0x43, 0x7d, 0x71, 0xbb,
0x7d, 0xcc, 0x59, 0x91, 0x65, 0xcb, 0x8d, 0x61, 0xdd, 0x5f, 0xe8, 0x88, 0x75, 0xdb, 0x69, 0xd6,
0xa5, 0x45, 0x18, 0xf1, 0x54, 0x79, 0x58, 0xe1, 0xa1, 0xae, 0x06, 0x81, 0x0b, 0x0b, 0x90, 0x04,
0xf7, 0x9e, 0x46, 0xdd, 0xbb, 0x99, 0x65, 0x09, 0xc3, 0x2e, 0x5a, 0x70, 0x71, 0x87, 0x88, 0xae,
0x4b, 0x2c, 0xe2, 0x08, 0x8a, 0xed, 0x0f, 0x4f, 0xd8, 0x06, 0x14, 0x67, 0x5c, 0xd6, 0xc7, 0x89,
0x0a, 0xa6, 0x64, 0xe8, 0x76, 0xeb, 0xcf, 0x1c, 0x5c, 0x8a, 0xc9, 0x7c, 0xcc, 0x42, 0x2d, 0x91,
0x92, 0xdf, 0xa6, 0x98, 0xf3, 0x23, 0xe6, 0xaa, 0x83, 0xb6, 0x64, 0xe8, 0xf6, 0xd6, 0xdf, 0xd7,
0xa1, 0x64, 0x30, 0x26, 0xba, 0xd2, 0x12, 0x34, 0x05, 0x24, 0x63, 0x62, 0x93, 0x29, 0x73, 0x88,
0xa3, 0x0e, 0x56, 0x8e, 0x1e, 0x46, 0x03, 0xd0, 0x35, 0x7f, 0x11, 0xea, 0x5b, 0xd5, 0xb8, 0x95,
0x32, 0x22, 0x06, 0x6f, 0x9d, 0x43, 0x13, 0x4f, 0x51, 0xd6, 0xeb, 0x57, 0xd4, 0x3c, 0xe8, 0xee,
0x63, 0xc7, 0x21, 0xf6, 0x32, 0xc5, 0x18, 0x34, 0x50, 0x8c, 0x25, 0xbd, 0xdf, 0x18, 0x08, 0x97,
0x3a, 0xe3, 0xc0, 0xd9, 0xd6, 0x39, 0xf4, 0xde, 0x5b, 0x5b, 0xa9, 0x4e, 0xb9, 0xa0, 0x26, 0x0f,
0x04, 0xb7, 0xd2, 0x05, 0x17, 0xc0, 0x67, 0x94, 0x1c, 0xc2, 0x46, 0xd7, 0x25, 0x58, 0x90, 0xae,
0x4e, 0x1a, 0x74, 0x3f, 0x71, 0x68, 0x1c, 0x16, 0x08, 0x2d, 0xdb, 0x00, 0xad, 0x73, 0xe8, 0x17,
0xa8, 0xf6, 0x5c, 0x36, 0x0d, 0xd1, 0xdf, 0x4d, 0xa4, 0x8f, 0x82, 0x32, 0x92, 0x0f, 0x61, 0xfd,
0x05, 0xe6, 0x21, 0xee, 0x3b, 0x89, 0xdc, 0x11, 0x4c, 0x40, 0x7d, 0x23, 0x11, 0xba, 0xcd, 0x98,
0x1d, 0xb2, 0xe7, 0x08, 0x50, 0x70, 0x20, 0x84, 0x54, 0x3a, 0xc9, 0x33, 0x58, 0x00, 0x06, 0x52,
0x9b, 0x99, 0xf1, 0x5a, 0xf8, 0x35, 0x94, 0x95, 0xe1, 0xcf, 0x6c, 0x8a, 0x39, 0xba, 0xbd, 0x64,
0x49, 0x3c, 0x44, 0x46, 0xc3, 0x7e, 0x80, 0x92, 0x34, 0x5a, 0x91, 0x7e, 0x95, 0xba, 0x10, 0x67,
0xa1, 0x1c, 0x00, 0x3c, 0xb3, 0x05, 0x71, 0x15, 0xe7, 0xad, 0x44, 0xce, 0x39, 0x20, 0x23, 0xa9,
0x03, 0xb5, 0xc1, 0xbe, 0xbc, 0xe0, 0x04, 0xd6, 0x70, 0x74, 0x2f, 0x79, 0x43, 0x47, 0x51, 0x01,
0xfd, 0xfd, 0x6c, 0x60, 0x6d, 0xf7, 0x5b, 0xa8, 0x29, 0x33, 0xf7, 0x82, 0x4b, 0x43, 0x8a, 0x5e,
0x0c, 0x95, 0x71, 0x3a, 0x3f, 0xc1, 0xba, 0xb4, 0x75, 0x4e, 0x7e, 0x27, 0xd5, 0xfa, 0xb3, 0x52,
0xbf, 0x85, 0xca, 0x0b, 0xcc, 0xe7, 0xcc, 0xed, 0xb4, 0x0c, 0x58, 0x20, 0xce, 0x94, 0x00, 0x07,
0x50, 0x95, 0xae, 0xe9, 0xc1, 0x3c, 0x25, 0x7d, 0xa3, 0xa0, 0x40, 0xe2, 0x5e, 0x26, 0xac, 0x16,
0x23, 0x50, 0x91, 0xdf, 0x82, 0xd2, 0x9b, 0x32, 0x97, 0x30, 0x24, 0x10, 0xba, 0x93, 0x01, 0x19,
0x3a, 0x66, 0xab, 0xd1, 0x77, 0x18, 0x7a, 0x90, 0x56, 0x85, 0x13, 0x5f, 0x84, 0x8d, 0x4e, 0x56,
0xb8, 0x96, 0xfc, 0x15, 0xd6, 0xfc, 0xd7, 0x51, 0x3c, 0x43, 0x62, 0x83, 0xf5, 0xc3, 0xac, 0x71,
0xfb, 0x54, 0x9c, 0x66, 0xc7, 0x70, 0xe9, 0xf5, 0xd4, 0x92, 0xa7, 0xb3, 0xaa, 0x01, 0x41, 0x15,
0x8a, 0x6f, 0xb3, 0x79, 0xa5, 0x8b, 0xe2, 0x76, 0xf9, 0xf8, 0xb4, 0x6d, 0xe6, 0xc2, 0xe7, 0x7d,
0xe7, 0x10, 0xdb, 0xd4, 0x8a, 0x14, 0x81, 0x5d, 0x22, 0x70, 0x17, 0x9b, 0xfb, 0x24, 0x5e, 0xa3,
0xd4, 0x53, 0x3b, 0x3a, 0x44, 0x83, 0x33, 0x6e, 0xed, 0xdf, 0x01, 0xa9, 0x8c, 0x75, 0xde, 0xd1,
0xf1, 0xcc, 0xc5, 0x6a, 0xff, 0xa5, 0x55, 0xdf, 0x45, 0x68, 0x20, 0xf3, 0xf5, 0x19, 0x46, 0x84,
0x0a, 0x23, 0xec, 0x10, 0xb1, 0x4b, 0x84, 0x4b, 0xcd, 0xb4, 0x63, 0x6d, 0x0e, 0x48, 0x59, 0xb4,
0x04, 0x9c, 0x16, 0x18, 0xc0, 0xaa, 0x7a, 0x20, 0xa2, 0x56, 0xe2, 0xa0, 0xe0, 0x79, 0xbb, 0xac,
0x9c, 0xeb, 0x27, 0x70, 0x28, 0x5d, 0x77, 0x88, 0x08, 0x3d, 0x3c, 0x53, 0xd2, 0x35, 0x0a, 0x5a,
0x9e, 0xae, 0x71, 0xac, 0x16, 0x73, 0xa0, 0xf6, 0x3d, 0xe5, 0xfe, 0xc7, 0x57, 0x98, 0x1f, 0xa4,
0x1d, 0xd2, 0x31, 0xd4, 0xf2, 0x43, 0x7a, 0x01, 0x1c, 0x72, 0xac, 0x62, 0x10, 0xf9, 0xc1, 0xf7,
0x2d, 0xf5, 0xee, 0x1c, 0xfe, 0x67, 0xe0, 0xb4, 0x4d, 0xf6, 0x46, 0x5f, 0x80, 0xf4, 0x5d, 0x37,
0x5e, 0x18, 0xe7, 0x69, 0xa3, 0x21, 0xf2, 0x5a, 0x9e, 0x81, 0xd9, 0xcf, 0xca, 0x4f, 0xcd, 0x3c,
0x84, 0x8d, 0x1e, 0xb1, 0x49, 0x84, 0xf9, 0x7e, 0xca, 0x1d, 0x23, 0x0a, 0xcb, 0x98, 0x79, 0xfb,
0xb0, 0x2e, 0x97, 0x41, 0x8e, 0x7b, 0xcd, 0x89, 0xcb, 0x53, 0xea, 0x55, 0x04, 0x13, 0x50, 0xdf,
0xcd, 0x02, 0x0d, 0xed, 0xa1, 0xf5, 0xc8, 0x3b, 0x23, 0x3e, 0x8f, 0xf9, 0xa2, 0x26, 0xbd, 0x7a,
0x1a, 0x0f, 0x32, 0xa2, 0x43, 0x7b, 0x08, 0xd4, 0x72, 0x1b, 0xcc, 0x26, 0x29, 0x69, 0x3d, 0x07,
0x64, 0xb4, 0xeb, 0x25, 0x14, 0x65, 0xe9, 0xf6, 0x28, 0x6f, 0xa6, 0x56, 0xf6, 0x33, 0x10, 0xbe,
0x85, 0xda, 0xcb, 0x29, 0x71, 0xb1, 0x20, 0xd2, 0x2f, 0x8f, 0x37, 0x39, 0xb3, 0x62, 0xa8, 0xcc,
0xd7, 0x66, 0x18, 0x10, 0x79, 0x82, 0x2f, 0x31, 0x61, 0x0e, 0x58, 0x7e, 0xb6, 0x85, 0x71, 0xe1,
0xc3, 0x53, 0xf5, 0xcb, 0xc0, 0x96, 0x0a, 0x78, 0x91, 0x67, 0x10, 0x50, 0xb8, 0xf0, 0xb3, 0xc5,
0x9f, 0xfa, 0x9e, 0x4b, 0x0f, 0xa9, 0x4d, 0xc6, 0x24, 0x25, 0x03, 0xe2, 0xb0, 0x8c, 0x16, 0x8d,
0xa0, 0xac, 0x84, 0x77, 0x5c, 0xec, 0x08, 0xb4, 0x2c, 0x34, 0x0f, 0x11, 0xd0, 0xb6, 0x4f, 0x07,
0xea, 0x49, 0x98, 0x00, 0x32, 0x2d, 0xf6, 0x98, 0x4d, 0xcd, 0x93, 0xf8, 0x65, 0x47, 0x1f, 0x0d,
0x73, 0x48, 0xca, 0x65, 0x27, 0x11, 0x19, 0x88, 0x6c, 0x3f, 0xf9, 0xf9, 0xf1, 0x98, 0x8a, 0xfd,
0xd9, 0x48, 0x4e, 0x71, 0x53, 0x0d, 0x7c, 0x40, 0x99, 0xff, 0x6b, 0x33, 0x18, 0xbc, 0xe9, 0x71,
0x6d, 0xea, 0x04, 0x9a, 0x8e, 0x46, 0xab, 0x5e, 0xd7, 0xa3, 0xff, 0x03, 0x00, 0x00, 0xff, 0xff,
0x19, 0x92, 0xda, 0x17, 0x8d, 0x17, 0x00, 0x00,
0xfe, 0xa1, 0x3e, 0xb5, 0x3f, 0xa5, 0x7f, 0xa4, 0xa3, 0xd5, 0xae, 0xbc, 0xbb, 0xde, 0x75, 0x36,
0xc0, 0x9b, 0xa5, 0xfd, 0xf4, 0x7d, 0x47, 0x9f, 0x74, 0x74, 0x24, 0xc3, 0x86, 0xcb, 0x98, 0x18,
0x9a, 0x8c, 0xb9, 0x56, 0x67, 0xea, 0x32, 0xc1, 0xd0, 0xe5, 0x09, 0xb5, 0x0f, 0x67, 0x5c, 0xb5,
0x3a, 0xf2, 0xb3, 0xf7, 0xb5, 0x51, 0x31, 0xd9, 0x64, 0xc2, 0x1c, 0xd5, 0xdf, 0xa8, 0x84, 0x51,
0x8d, 0x2a, 0x75, 0x04, 0x71, 0x1d, 0x6c, 0xfb, 0xed, 0xf2, 0xd4, 0x65, 0xc7, 0x27, 0x7e, 0xa3,
0x46, 0x84, 0x69, 0x0d, 0x27, 0x44, 0x60, 0xd5, 0xd1, 0x1a, 0xc2, 0xa5, 0x67, 0xb6, 0xcd, 0xcc,
0x57, 0x74, 0x42, 0xb8, 0xc0, 0x93, 0xa9, 0x41, 0xde, 0xcf, 0x08, 0x17, 0xe8, 0x21, 0x9c, 0x1f,
0x61, 0x4e, 0xea, 0xb9, 0x66, 0xae, 0x5d, 0xde, 0xba, 0xd6, 0x89, 0x44, 0xe2, 0xcb, 0xef, 0xf2,
0xf1, 0x36, 0xe6, 0xc4, 0xf0, 0x90, 0xe8, 0x22, 0xac, 0x98, 0x6c, 0xe6, 0x88, 0x7a, 0xa1, 0x99,
0x6b, 0xaf, 0x1b, 0xaa, 0xd1, 0xfa, 0x23, 0x07, 0x97, 0xe3, 0x0a, 0x7c, 0xca, 0x1c, 0x4e, 0xd0,
0x23, 0x58, 0xe5, 0x02, 0x8b, 0x19, 0xf7, 0x45, 0xae, 0x26, 0x8a, 0x0c, 0x3c, 0x88, 0xe1, 0x43,
0xd1, 0x35, 0x28, 0x89, 0x80, 0xa9, 0x9e, 0x6f, 0xe6, 0xda, 0xe7, 0x8d, 0x79, 0x47, 0x4a, 0x0c,
0x6f, 0xa0, 0xea, 0x85, 0xd0, 0xef, 0x7d, 0x82, 0xd9, 0xe5, 0xc3, 0xcc, 0x36, 0xd4, 0x34, 0xf3,
0xc7, 0xcc, 0xaa, 0x0a, 0xf9, 0x7e, 0xcf, 0xa3, 0x2e, 0x18, 0xf9, 0x7e, 0x2f, 0x65, 0x1e, 0xff,
0xe4, 0xa1, 0xd2, 0x9f, 0x4c, 0x99, 0x2b, 0x0c, 0xc2, 0x67, 0xb6, 0xf8, 0x30, 0xad, 0x2b, 0xb0,
0x26, 0x30, 0x3f, 0x18, 0x52, 0xcb, 0x17, 0x5c, 0x95, 0xcd, 0xbe, 0x85, 0xbe, 0x80, 0xb2, 0x85,
0x05, 0x76, 0x98, 0x45, 0xe4, 0xc7, 0x82, 0xf7, 0x11, 0x82, 0xae, 0xbe, 0x85, 0x1e, 0xc3, 0x8a,
0xe4, 0x20, 0xf5, 0xf3, 0xcd, 0x5c, 0xbb, 0xba, 0xd5, 0x4c, 0x54, 0x53, 0x01, 0x4a, 0x4d, 0x62,
0x28, 0x38, 0x6a, 0x40, 0x91, 0x93, 0xf1, 0x84, 0x38, 0x82, 0xd7, 0x57, 0x9a, 0x85, 0x76, 0xc1,
0xd0, 0x6d, 0xf4, 0x19, 0x14, 0xf1, 0x4c, 0xb0, 0x21, 0xb5, 0x78, 0x7d, 0xd5, 0xfb, 0xb6, 0x26,
0xdb, 0x7d, 0x8b, 0xa3, 0xab, 0x50, 0x72, 0xd9, 0xd1, 0x50, 0x19, 0xb1, 0xe6, 0x45, 0x53, 0x74,
0xd9, 0x51, 0x57, 0xb6, 0xd1, 0x37, 0xb0, 0x42, 0x9d, 0x77, 0x8c, 0xd7, 0x8b, 0xcd, 0x42, 0xbb,
0xbc, 0x75, 0x23, 0x31, 0x96, 0xef, 0xc8, 0xc9, 0x8f, 0xd8, 0x9e, 0x91, 0x3d, 0x4c, 0x5d, 0x43,
0xe1, 0x5b, 0x7f, 0xe5, 0xe0, 0x4a, 0x8f, 0x70, 0xd3, 0xa5, 0x23, 0x32, 0xf0, 0xa3, 0xf8, 0xf0,
0x6d, 0xd1, 0x82, 0x8a, 0xc9, 0x6c, 0x9b, 0x98, 0x82, 0x32, 0x47, 0x2f, 0x61, 0xa4, 0x0f, 0x5d,
0x07, 0xf0, 0xa7, 0xdb, 0xef, 0xf1, 0x7a, 0xc1, 0x9b, 0x64, 0xa8, 0xa7, 0x35, 0x83, 0x9a, 0x1f,
0x88, 0x24, 0xee, 0x3b, 0xef, 0xd8, 0x02, 0x6d, 0x2e, 0x81, 0xb6, 0x09, 0xe5, 0x29, 0x76, 0x05,
0x8d, 0x28, 0x87, 0xbb, 0x64, 0xae, 0x68, 0x19, 0x7f, 0x39, 0xe7, 0x1d, 0xad, 0xff, 0xf2, 0x50,
0xf1, 0x75, 0xa5, 0x26, 0x47, 0x3d, 0x28, 0xc9, 0x39, 0x0d, 0xa5, 0x4f, 0xbe, 0x05, 0xb7, 0x3b,
0xc9, 0x27, 0x50, 0x27, 0x16, 0xb0, 0x51, 0x1c, 0x05, 0xa1, 0xf7, 0xa0, 0x4c, 0x1d, 0x8b, 0x1c,
0x0f, 0xd5, 0xf2, 0xe4, 0xbd, 0xe5, 0xb9, 0x19, 0xe5, 0x91, 0xa7, 0x50, 0x47, 0x6b, 0x5b, 0xe4,
0xd8, 0xe3, 0x00, 0x1a, 0xfc, 0xe4, 0x88, 0xc0, 0x05, 0x72, 0x2c, 0x5c, 0x3c, 0x0c, 0x73, 0x15,
0x3c, 0xae, 0x6f, 0x4f, 0x89, 0xc9, 0x23, 0xe8, 0x3c, 0x97, 0xa3, 0x35, 0x37, 0x7f, 0xee, 0x08,
0xf7, 0xc4, 0xa8, 0x91, 0x68, 0x6f, 0xe3, 0x37, 0xb8, 0x98, 0x04, 0x44, 0x1b, 0x50, 0x38, 0x20,
0x27, 0xbe, 0xed, 0xf2, 0x27, 0xda, 0x82, 0x95, 0x43, 0xb9, 0x95, 0x3c, 0x9f, 0x17, 0xf6, 0x86,
0x37, 0xa1, 0xf9, 0x4c, 0x14, 0xf4, 0x69, 0xfe, 0x49, 0xae, 0xf5, 0x6f, 0x1e, 0xea, 0x8b, 0xdb,
0xed, 0x63, 0xce, 0x8a, 0x2c, 0x5b, 0x6e, 0x0c, 0xeb, 0xfe, 0x42, 0x47, 0xac, 0xdb, 0x4e, 0xb3,
0x2e, 0x2d, 0xc2, 0x88, 0xa7, 0xca, 0xc3, 0x0a, 0x0f, 0x75, 0x35, 0x08, 0x5c, 0x58, 0x80, 0x24,
0xb8, 0xf7, 0x34, 0xea, 0xde, 0xad, 0x2c, 0x4b, 0x18, 0x76, 0xd1, 0x82, 0x8b, 0x3b, 0x44, 0x74,
0x5d, 0x62, 0x11, 0x47, 0x50, 0x6c, 0x7f, 0x78, 0xc2, 0x36, 0xa0, 0x38, 0xe3, 0xb2, 0x3e, 0x4e,
0x54, 0x30, 0x25, 0x43, 0xb7, 0x5b, 0x7f, 0xe6, 0xe0, 0x52, 0x4c, 0xe6, 0x63, 0x16, 0x6a, 0x89,
0x94, 0xfc, 0x36, 0xc5, 0x9c, 0x1f, 0x31, 0x57, 0x1d, 0xb4, 0x25, 0x43, 0xb7, 0xb7, 0xfe, 0xbe,
0x0e, 0x25, 0x83, 0x31, 0xd1, 0x95, 0x96, 0x20, 0x1b, 0x90, 0x8c, 0x89, 0x4d, 0xa6, 0xcc, 0x21,
0x8e, 0x3a, 0x58, 0x39, 0xea, 0x44, 0x03, 0xf0, 0x1b, 0x8b, 0x40, 0xdf, 0xa8, 0xc6, 0xad, 0x44,
0x7c, 0x0c, 0xdc, 0x3a, 0x87, 0x26, 0x9e, 0x9a, 0xac, 0xd5, 0xaf, 0xa8, 0x79, 0xd0, 0xdd, 0xc7,
0x8e, 0x43, 0x6c, 0xf4, 0x30, 0x3a, 0x5a, 0xdf, 0x30, 0x16, 0xa1, 0x81, 0xde, 0xcd, 0x44, 0xbd,
0x81, 0x70, 0xa9, 0x33, 0x0e, 0x5c, 0x6d, 0x9d, 0x43, 0xef, 0xbd, 0x75, 0x95, 0xea, 0x94, 0x0b,
0x6a, 0xf2, 0x40, 0x70, 0x2b, 0x5d, 0x70, 0x01, 0x7c, 0x46, 0xc9, 0x21, 0x6c, 0x74, 0x5d, 0x82,
0x05, 0xe9, 0xea, 0x84, 0x41, 0xf7, 0x93, 0xdd, 0x89, 0xc1, 0x02, 0xa1, 0x65, 0x8b, 0xdf, 0x3a,
0x87, 0x7e, 0x81, 0x6a, 0xcf, 0x65, 0xd3, 0x10, 0xfd, 0xdd, 0x44, 0xfa, 0x28, 0x28, 0x23, 0xf9,
0x10, 0xd6, 0x5f, 0x60, 0x1e, 0xe2, 0xbe, 0x93, 0xc8, 0x1d, 0xc1, 0x04, 0xd4, 0x37, 0x12, 0xa1,
0xdb, 0x8c, 0xd9, 0x21, 0x7b, 0x8e, 0x00, 0x05, 0x87, 0x41, 0x48, 0x25, 0x79, 0xbb, 0x2d, 0x02,
0x03, 0xa9, 0xcd, 0xcc, 0x78, 0x2d, 0xfc, 0x1a, 0xca, 0xca, 0xf0, 0x67, 0x36, 0xc5, 0x1c, 0xdd,
0x5e, 0xb2, 0x24, 0x1e, 0x22, 0xa3, 0x61, 0x3f, 0x40, 0x49, 0x1a, 0xad, 0x48, 0xbf, 0x4c, 0x5d,
0x88, 0xb3, 0x50, 0x0e, 0x00, 0x9e, 0xd9, 0x82, 0xb8, 0x8a, 0xf3, 0xab, 0x44, 0xce, 0x39, 0x20,
0x23, 0xa9, 0x03, 0xb5, 0xc1, 0xbe, 0xbc, 0xdc, 0x04, 0xd6, 0x70, 0x74, 0x2f, 0x79, 0x43, 0x47,
0x51, 0x01, 0xfd, 0xfd, 0x6c, 0x60, 0x6d, 0xf7, 0x5b, 0xa8, 0x29, 0x33, 0xf7, 0x82, 0x0b, 0x43,
0x8a, 0x5e, 0x0c, 0x95, 0x71, 0x3a, 0x3f, 0xc1, 0xba, 0xb4, 0x75, 0x4e, 0x7e, 0x27, 0xd5, 0xfa,
0xb3, 0x52, 0xbf, 0x85, 0xca, 0x0b, 0xcc, 0xe7, 0xcc, 0xed, 0xb4, 0x0c, 0x58, 0x20, 0xce, 0x94,
0x00, 0x07, 0x50, 0x95, 0xae, 0xe9, 0xc1, 0x3c, 0x25, 0x7d, 0xa3, 0xa0, 0x40, 0xe2, 0x5e, 0x26,
0xac, 0x16, 0x23, 0x50, 0x91, 0xdf, 0x82, 0xb2, 0x9b, 0x32, 0x97, 0x30, 0x24, 0x10, 0xba, 0x93,
0x01, 0x19, 0x3a, 0x66, 0xab, 0xd1, 0x37, 0x18, 0x7a, 0x90, 0x56, 0x81, 0x13, 0x5f, 0x83, 0x8d,
0x4e, 0x56, 0xb8, 0x96, 0xfc, 0x15, 0xd6, 0xfc, 0x97, 0x51, 0x3c, 0x43, 0x62, 0x83, 0xf5, 0xa3,
0xac, 0x71, 0xfb, 0x54, 0x9c, 0x66, 0xc7, 0x70, 0xe9, 0xf5, 0xd4, 0x92, 0xa7, 0xb3, 0xaa, 0x01,
0x41, 0x15, 0x8a, 0x6f, 0x33, 0x5d, 0x38, 0x62, 0xb8, 0x5d, 0x3e, 0x3e, 0x6d, 0x9b, 0xb9, 0xf0,
0x79, 0xdf, 0x39, 0xc4, 0x36, 0xb5, 0x22, 0x45, 0x60, 0x97, 0x08, 0xdc, 0xc5, 0xe6, 0x3e, 0x89,
0xd7, 0x28, 0xf5, 0xcc, 0x8e, 0x0e, 0xd1, 0xe0, 0x8c, 0x5b, 0xfb, 0x77, 0x40, 0x2a, 0x63, 0x9d,
0x77, 0x74, 0x3c, 0x73, 0xb1, 0xda, 0x7f, 0x69, 0xd5, 0x77, 0x11, 0x1a, 0xc8, 0x7c, 0x7d, 0x86,
0x11, 0xa1, 0xc2, 0x08, 0x3b, 0x44, 0xec, 0x12, 0xe1, 0x52, 0x33, 0xed, 0x58, 0x9b, 0x03, 0x52,
0x16, 0x2d, 0x01, 0xa7, 0x05, 0x06, 0xb0, 0xaa, 0x1e, 0x87, 0xa8, 0x95, 0x38, 0x28, 0x78, 0xda,
0x2e, 0x2b, 0xe7, 0xfa, 0xf9, 0x1b, 0x4a, 0xd7, 0x1d, 0x22, 0x42, 0x8f, 0xce, 0x94, 0x74, 0x8d,
0x82, 0x96, 0xa7, 0x6b, 0x1c, 0xab, 0xc5, 0x1c, 0xa8, 0x7d, 0x4f, 0xb9, 0xff, 0xf1, 0x15, 0xe6,
0x07, 0x69, 0x87, 0x74, 0x0c, 0xb5, 0xfc, 0x90, 0x5e, 0x00, 0x87, 0x1c, 0xab, 0x18, 0x44, 0x7e,
0xf0, 0x7d, 0x4b, 0xbd, 0x37, 0x87, 0xff, 0x15, 0x38, 0x6d, 0x93, 0xbd, 0xd1, 0x17, 0x20, 0x7d,
0xcf, 0x8d, 0x17, 0xc6, 0x79, 0xda, 0x68, 0x88, 0xbc, 0x92, 0x67, 0x60, 0xf6, 0xb3, 0xf2, 0x53,
0x33, 0x0f, 0x61, 0xa3, 0x47, 0x6c, 0x12, 0x61, 0xbe, 0x9f, 0x72, 0xc7, 0x88, 0xc2, 0x32, 0x66,
0xde, 0x3e, 0xac, 0xcb, 0x65, 0x90, 0xe3, 0x5e, 0x73, 0xe2, 0xf2, 0x94, 0x7a, 0x15, 0xc1, 0x04,
0xd4, 0x77, 0xb3, 0x40, 0x43, 0x7b, 0x68, 0x3d, 0xf2, 0xc6, 0x88, 0xcf, 0x63, 0xbe, 0xa8, 0x49,
0x2f, 0x9e, 0xc6, 0x83, 0x8c, 0xe8, 0xd0, 0x1e, 0x02, 0xb5, 0xdc, 0x06, 0xb3, 0x49, 0x4a, 0x5a,
0xcf, 0x01, 0x19, 0xed, 0x7a, 0x09, 0x45, 0x59, 0xba, 0x3d, 0xca, 0x5b, 0xa9, 0x95, 0xfd, 0x0c,
0x84, 0x6f, 0xa1, 0xf6, 0x72, 0x4a, 0x5c, 0x2c, 0x88, 0xf4, 0xcb, 0xe3, 0x4d, 0xce, 0xac, 0x18,
0x2a, 0xf3, 0xb5, 0x19, 0x06, 0x44, 0x9e, 0xe0, 0x4b, 0x4c, 0x98, 0x03, 0x96, 0x9f, 0x6d, 0x61,
0x5c, 0xf8, 0xf0, 0x54, 0xfd, 0x32, 0xb0, 0xa5, 0x02, 0x5e, 0xe4, 0x19, 0x04, 0x14, 0x2e, 0xfc,
0x6c, 0xf1, 0xa7, 0xbe, 0xe7, 0xd2, 0x43, 0x6a, 0x93, 0x31, 0x49, 0xc9, 0x80, 0x38, 0x2c, 0xa3,
0x45, 0x23, 0x28, 0x2b, 0xe1, 0x1d, 0x17, 0x3b, 0x02, 0x2d, 0x0b, 0xcd, 0x43, 0x04, 0xb4, 0xed,
0xd3, 0x81, 0x7a, 0x12, 0x26, 0x80, 0x4c, 0x8b, 0x3d, 0x66, 0x53, 0xf3, 0x24, 0x7e, 0xd9, 0xd1,
0x47, 0xc3, 0x1c, 0x92, 0x72, 0xd9, 0x49, 0x44, 0x06, 0x22, 0xdb, 0x4f, 0x7e, 0x7e, 0x3c, 0xa6,
0x62, 0x7f, 0x36, 0x92, 0x53, 0xdc, 0x54, 0x03, 0x1f, 0x50, 0xe6, 0xff, 0xda, 0x0c, 0x06, 0x6f,
0x7a, 0x5c, 0x9b, 0x3a, 0x81, 0xa6, 0xa3, 0xd1, 0xaa, 0xd7, 0xf5, 0xe8, 0xff, 0x00, 0x00, 0x00,
0xff, 0xff, 0xb6, 0xc3, 0xbe, 0xa7, 0x89, 0x17, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
@ -783,7 +783,7 @@ const _ = grpc.SupportPackageIsVersion4
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type RootCoordClient interface {
GetComponentStates(ctx context.Context, in *internalpb.GetComponentStatesRequest, opts ...grpc.CallOption) (*internalpb.ComponentStates, error)
GetComponentStates(ctx context.Context, in *milvuspb.GetComponentStatesRequest, opts ...grpc.CallOption) (*milvuspb.ComponentStates, error)
GetTimeTickChannel(ctx context.Context, in *internalpb.GetTimeTickChannelRequest, opts ...grpc.CallOption) (*milvuspb.StringResponse, error)
GetStatisticsChannel(ctx context.Context, in *internalpb.GetStatisticsChannelRequest, opts ...grpc.CallOption) (*milvuspb.StringResponse, error)
//*
@ -884,8 +884,8 @@ func NewRootCoordClient(cc *grpc.ClientConn) RootCoordClient {
return &rootCoordClient{cc}
}
func (c *rootCoordClient) GetComponentStates(ctx context.Context, in *internalpb.GetComponentStatesRequest, opts ...grpc.CallOption) (*internalpb.ComponentStates, error) {
out := new(internalpb.ComponentStates)
func (c *rootCoordClient) GetComponentStates(ctx context.Context, in *milvuspb.GetComponentStatesRequest, opts ...grpc.CallOption) (*milvuspb.ComponentStates, error) {
out := new(milvuspb.ComponentStates)
err := c.cc.Invoke(ctx, "/milvus.proto.rootcoord.RootCoord/GetComponentStates", in, out, opts...)
if err != nil {
return nil, err
@ -1237,7 +1237,7 @@ func (c *rootCoordClient) ListPolicy(ctx context.Context, in *internalpb.ListPol
// RootCoordServer is the server API for RootCoord service.
type RootCoordServer interface {
GetComponentStates(context.Context, *internalpb.GetComponentStatesRequest) (*internalpb.ComponentStates, error)
GetComponentStates(context.Context, *milvuspb.GetComponentStatesRequest) (*milvuspb.ComponentStates, error)
GetTimeTickChannel(context.Context, *internalpb.GetTimeTickChannelRequest) (*milvuspb.StringResponse, error)
GetStatisticsChannel(context.Context, *internalpb.GetStatisticsChannelRequest) (*milvuspb.StringResponse, error)
//*
@ -1334,7 +1334,7 @@ type RootCoordServer interface {
type UnimplementedRootCoordServer struct {
}
func (*UnimplementedRootCoordServer) GetComponentStates(ctx context.Context, req *internalpb.GetComponentStatesRequest) (*internalpb.ComponentStates, error) {
func (*UnimplementedRootCoordServer) GetComponentStates(ctx context.Context, req *milvuspb.GetComponentStatesRequest) (*milvuspb.ComponentStates, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetComponentStates not implemented")
}
func (*UnimplementedRootCoordServer) GetTimeTickChannel(ctx context.Context, req *internalpb.GetTimeTickChannelRequest) (*milvuspb.StringResponse, error) {
@ -1457,7 +1457,7 @@ func RegisterRootCoordServer(s *grpc.Server, srv RootCoordServer) {
}
func _RootCoord_GetComponentStates_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(internalpb.GetComponentStatesRequest)
in := new(milvuspb.GetComponentStatesRequest)
if err := dec(in); err != nil {
return nil, err
}
@ -1469,7 +1469,7 @@ func _RootCoord_GetComponentStates_Handler(srv interface{}, ctx context.Context,
FullMethod: "/milvus.proto.rootcoord.RootCoord/GetComponentStates",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(RootCoordServer).GetComponentStates(ctx, req.(*internalpb.GetComponentStatesRequest))
return srv.(RootCoordServer).GetComponentStates(ctx, req.(*milvuspb.GetComponentStatesRequest))
}
return interceptor(ctx, in, info, handler)
}

20
internal/proxy/data_coord_mock_test.go
View File

@ -41,38 +41,38 @@ type DataCoordMock struct {
timeTickChannel string
}
func (coord *DataCoordMock) updateState(state internalpb.StateCode) {
func (coord *DataCoordMock) updateState(state commonpb.StateCode) {
coord.state.Store(state)
}
func (coord *DataCoordMock) getState() internalpb.StateCode {
return coord.state.Load().(internalpb.StateCode)
func (coord *DataCoordMock) getState() commonpb.StateCode {
return coord.state.Load().(commonpb.StateCode)
}
func (coord *DataCoordMock) healthy() bool {
return coord.getState() == internalpb.StateCode_Healthy
return coord.getState() == commonpb.StateCode_Healthy
}
func (coord *DataCoordMock) Init() error {
coord.updateState(internalpb.StateCode_Initializing)
coord.updateState(commonpb.StateCode_Initializing)
return nil
}
func (coord *DataCoordMock) Start() error {
defer coord.updateState(internalpb.StateCode_Healthy)
defer coord.updateState(commonpb.StateCode_Healthy)
return nil
}
func (coord *DataCoordMock) Stop() error {
defer coord.updateState(internalpb.StateCode_Abnormal)
defer coord.updateState(commonpb.StateCode_Abnormal)
return nil
}
func (coord *DataCoordMock) GetComponentStates(ctx context.Context) (*internalpb.ComponentStates, error) {
return &internalpb.ComponentStates{
State: &internalpb.ComponentInfo{
func (coord *DataCoordMock) GetComponentStates(ctx context.Context) (*milvuspb.ComponentStates, error) {
return &milvuspb.ComponentStates{
State: &milvuspb.ComponentInfo{
NodeID: coord.nodeID,
Role: typeutil.DataCoordRole,
StateCode: coord.getState(),

24
internal/proxy/impl.go
View File

@ -49,18 +49,18 @@ import (
const moduleName = "Proxy"
// UpdateStateCode updates the state code of Proxy.
func (node *Proxy) UpdateStateCode(code internalpb.StateCode) {
func (node *Proxy) UpdateStateCode(code commonpb.StateCode) {
node.stateCode.Store(code)
}
// GetComponentStates get state of Proxy.
func (node *Proxy) GetComponentStates(ctx context.Context) (*internalpb.ComponentStates, error) {
stats := &internalpb.ComponentStates{
func (node *Proxy) GetComponentStates(ctx context.Context) (*milvuspb.ComponentStates, error) {
stats := &milvuspb.ComponentStates{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_Success,
},
}
code, ok := node.stateCode.Load().(internalpb.StateCode)
code, ok := node.stateCode.Load().(commonpb.StateCode)
if !ok {
errMsg := "unexpected error in type assertion"
stats.Status = &commonpb.Status{
@ -73,7 +73,7 @@ func (node *Proxy) GetComponentStates(ctx context.Context) (*internalpb.Componen
if node.session != nil && node.session.Registered() {
nodeID = node.session.ServerID
}
info := &internalpb.ComponentInfo{
info := &milvuspb.ComponentInfo{
// NodeID: Params.ProxyID, // will race with Proxy.Register()
NodeID: nodeID,
Role: typeutil.ProxyRole,
@ -3577,12 +3577,12 @@ func (node *Proxy) Dummy(ctx context.Context, req *milvuspb.DummyRequest) (*milv
// RegisterLink registers a link
func (node *Proxy) RegisterLink(ctx context.Context, req *milvuspb.RegisterLinkRequest) (*milvuspb.RegisterLinkResponse, error) {
code := node.stateCode.Load().(internalpb.StateCode)
code := node.stateCode.Load().(commonpb.StateCode)
log.Debug("RegisterLink",
zap.String("role", typeutil.ProxyRole),
zap.Any("state code of proxy", code))
if code != internalpb.StateCode_Healthy {
if code != commonpb.StateCode_Healthy {
return &milvuspb.RegisterLinkResponse{
Address: nil,
Status: &commonpb.Status{
@ -3882,13 +3882,13 @@ func (node *Proxy) GetFlushState(ctx context.Context, req *milvuspb.GetFlushStat
// checkHealthy checks proxy state is Healthy
func (node *Proxy) checkHealthy() bool {
code := node.stateCode.Load().(internalpb.StateCode)
return code == internalpb.StateCode_Healthy
code := node.stateCode.Load().(commonpb.StateCode)
return code == commonpb.StateCode_Healthy
}
func (node *Proxy) checkHealthyAndReturnCode() (internalpb.StateCode, bool) {
code := node.stateCode.Load().(internalpb.StateCode)
return code, code == internalpb.StateCode_Healthy
func (node *Proxy) checkHealthyAndReturnCode() (commonpb.StateCode, bool) {
code := node.stateCode.Load().(commonpb.StateCode)
return code, code == commonpb.StateCode_Healthy
}
//unhealthyStatus returns the proxy not healthy status

20
internal/proxy/index_coord_mock_test.go
View File

@ -50,38 +50,38 @@ type IndexCoordMock struct {
minioBucketName string
}
func (coord *IndexCoordMock) updateState(state internalpb.StateCode) {
func (coord *IndexCoordMock) updateState(state commonpb.StateCode) {
coord.state.Store(state)
}
func (coord *IndexCoordMock) getState() internalpb.StateCode {
return coord.state.Load().(internalpb.StateCode)
func (coord *IndexCoordMock) getState() commonpb.StateCode {
return coord.state.Load().(commonpb.StateCode)
}
func (coord *IndexCoordMock) healthy() bool {
return coord.getState() == internalpb.StateCode_Healthy
return coord.getState() == commonpb.StateCode_Healthy
}
func (coord *IndexCoordMock) Init() error {
coord.updateState(internalpb.StateCode_Initializing)
coord.updateState(commonpb.StateCode_Initializing)
return nil
}
func (coord *IndexCoordMock) Start() error {
defer coord.updateState(internalpb.StateCode_Healthy)
defer coord.updateState(commonpb.StateCode_Healthy)
return nil
}
func (coord *IndexCoordMock) Stop() error {
defer coord.updateState(internalpb.StateCode_Abnormal)
defer coord.updateState(commonpb.StateCode_Abnormal)
return nil
}
func (coord *IndexCoordMock) GetComponentStates(ctx context.Context) (*internalpb.ComponentStates, error) {
return &internalpb.ComponentStates{
State: &internalpb.ComponentInfo{
func (coord *IndexCoordMock) GetComponentStates(ctx context.Context) (*milvuspb.ComponentStates, error) {
return &milvuspb.ComponentStates{
State: &milvuspb.ComponentInfo{
NodeID: coord.nodeID,
Role: typeutil.IndexCoordRole,
StateCode: coord.getState(),

8
internal/proxy/proxy.go
View File

@ -121,7 +121,7 @@ func NewProxy(ctx context.Context, factory dependency.Factory) (*Proxy, error) {
shardMgr: newShardClientMgr(),
multiRateLimiter: NewMultiRateLimiter(),
}
node.UpdateStateCode(internalpb.StateCode_Abnormal)
node.UpdateStateCode(commonpb.StateCode_Abnormal)
logutil.Logger(ctx).Debug("create a new Proxy instance", zap.Any("state", node.stateCode.Load()))
return node, nil
}
@ -367,8 +367,8 @@ func (node *Proxy) Start() error {
Params.ProxyCfg.CreatedTime = now
Params.ProxyCfg.UpdatedTime = now
log.Debug("update state code", zap.String("role", typeutil.ProxyRole), zap.String("State", internalpb.StateCode_Healthy.String()))
node.UpdateStateCode(internalpb.StateCode_Healthy)
log.Debug("update state code", zap.String("role", typeutil.ProxyRole), zap.String("State", commonpb.StateCode_Healthy.String()))
node.UpdateStateCode(commonpb.StateCode_Healthy)
return nil
}
@ -417,7 +417,7 @@ func (node *Proxy) Stop() error {
}
// https://github.com/milvus-io/milvus/issues/12282
node.UpdateStateCode(internalpb.StateCode_Abnormal)
node.UpdateStateCode(commonpb.StateCode_Abnormal)
return nil
}

60
internal/proxy/proxy_test.go
View File

@ -328,7 +328,7 @@ func newProxyTestServer(node *Proxy) *proxyTestServer {
}
}
func (s *proxyTestServer) GetComponentStates(ctx context.Context, request *internalpb.GetComponentStatesRequest) (*internalpb.ComponentStates, error) {
func (s *proxyTestServer) GetComponentStates(ctx context.Context, request *milvuspb.GetComponentStatesRequest) (*milvuspb.ComponentStates, error) {
return s.Proxy.GetComponentStates(ctx)
}
@ -554,13 +554,13 @@ func TestProxy(t *testing.T) {
proxy.SetIndexCoordClient(indexCoordClient)
log.Info("Proxy set index coordinator client")
proxy.UpdateStateCode(internalpb.StateCode_Initializing)
proxy.UpdateStateCode(commonpb.StateCode_Initializing)
err = proxy.Init()
assert.NoError(t, err)
err = proxy.Start()
assert.NoError(t, err)
assert.Equal(t, internalpb.StateCode_Healthy, proxy.stateCode.Load().(internalpb.StateCode))
assert.Equal(t, commonpb.StateCode_Healthy, proxy.stateCode.Load().(commonpb.StateCode))
// register proxy
err = proxy.Register()
@ -577,7 +577,7 @@ func TestProxy(t *testing.T) {
assert.Equal(t, commonpb.ErrorCode_Success, states.Status.ErrorCode)
assert.Equal(t, Params.ProxyCfg.GetNodeID(), states.State.NodeID)
assert.Equal(t, typeutil.ProxyRole, states.State.Role)
assert.Equal(t, proxy.stateCode.Load().(internalpb.StateCode), states.State.StateCode)
assert.Equal(t, proxy.stateCode.Load().(commonpb.StateCode), states.State.StateCode)
})
t.Run("get statistics channel", func(t *testing.T) {
@ -1656,11 +1656,11 @@ func TestProxy(t *testing.T) {
assert.NotEqual(t, commonpb.ErrorCode_Success, resp.Status.ErrorCode)
// unhealthy
proxy.UpdateStateCode(internalpb.StateCode_Abnormal)
proxy.UpdateStateCode(commonpb.StateCode_Abnormal)
resp, err = proxy.GetProxyMetrics(ctx, req)
assert.NoError(t, err)
assert.NotEqual(t, commonpb.ErrorCode_Success, resp.Status.ErrorCode)
proxy.UpdateStateCode(internalpb.StateCode_Healthy)
proxy.UpdateStateCode(commonpb.StateCode_Healthy)
// getProxyMetric failed
rateCol.Deregister(internalpb.RateType_DMLInsert.String())
@ -1677,7 +1677,7 @@ func TestProxy(t *testing.T) {
CollectionName: collectionName,
Files: []string{"f1.json", "f2.json", "f3.csv"},
}
proxy.stateCode.Store(internalpb.StateCode_Healthy)
proxy.stateCode.Store(commonpb.StateCode_Healthy)
resp, err := proxy.Import(context.TODO(), req)
assert.EqualValues(t, commonpb.ErrorCode_Success, resp.Status.ErrorCode)
assert.Nil(t, err)
@ -1692,7 +1692,7 @@ func TestProxy(t *testing.T) {
CollectionName: "bad_collection_name",
Files: []string{"f1", "f2", "f3"},
}
proxy.stateCode.Store(internalpb.StateCode_Healthy)
proxy.stateCode.Store(commonpb.StateCode_Healthy)
resp, err := proxy.Import(context.TODO(), req)
assert.NoError(t, err)
assert.EqualValues(t, commonpb.ErrorCode_UnexpectedError, resp.Status.ErrorCode)
@ -1705,7 +1705,7 @@ func TestProxy(t *testing.T) {
CollectionName: "bad_collection_name",
Files: []string{"f1", "f2", "f3"},
}
proxy.stateCode.Store(internalpb.StateCode_Healthy)
proxy.stateCode.Store(commonpb.StateCode_Healthy)
resp, err := proxy.Import(context.TODO(), req)
assert.NoError(t, err)
assert.EqualValues(t, commonpb.ErrorCode_UnexpectedError, resp.Status.ErrorCode)
@ -2340,7 +2340,7 @@ func TestProxy(t *testing.T) {
// assert.Error(t, err)
//})
proxy.UpdateStateCode(internalpb.StateCode_Abnormal)
proxy.UpdateStateCode(commonpb.StateCode_Abnormal)
wg.Add(1)
t.Run("CreateCollection fail, unhealthy", func(t *testing.T) {
@ -2666,7 +2666,7 @@ func TestProxy(t *testing.T) {
testProxyPrivilegeUnhealthy(ctx, t, proxy)
testProxyRefreshPolicyInfoCacheUnhealthy(ctx, t, proxy)
proxy.UpdateStateCode(internalpb.StateCode_Healthy)
proxy.UpdateStateCode(commonpb.StateCode_Healthy)
// queue full
@ -3666,7 +3666,7 @@ func Test_GetCompactionState(t *testing.T) {
t.Run("get compaction state", func(t *testing.T) {
datacoord := &DataCoordMock{}
proxy := &Proxy{dataCoord: datacoord}
proxy.stateCode.Store(internalpb.StateCode_Healthy)
proxy.stateCode.Store(commonpb.StateCode_Healthy)
resp, err := proxy.GetCompactionState(context.TODO(), nil)
assert.EqualValues(t, &milvuspb.GetCompactionStateResponse{}, resp)
assert.Nil(t, err)
@ -3675,7 +3675,7 @@ func Test_GetCompactionState(t *testing.T) {
t.Run("get compaction state with unhealthy proxy", func(t *testing.T) {
datacoord := &DataCoordMock{}
proxy := &Proxy{dataCoord: datacoord}
proxy.stateCode.Store(internalpb.StateCode_Abnormal)
proxy.stateCode.Store(commonpb.StateCode_Abnormal)
resp, err := proxy.GetCompactionState(context.TODO(), nil)
assert.EqualValues(t, unhealthyStatus(), resp.Status)
assert.Nil(t, err)
@ -3686,7 +3686,7 @@ func Test_ManualCompaction(t *testing.T) {
t.Run("test manual compaction", func(t *testing.T) {
datacoord := &DataCoordMock{}
proxy := &Proxy{dataCoord: datacoord}
proxy.stateCode.Store(internalpb.StateCode_Healthy)
proxy.stateCode.Store(commonpb.StateCode_Healthy)
resp, err := proxy.ManualCompaction(context.TODO(), nil)
assert.EqualValues(t, &milvuspb.ManualCompactionResponse{}, resp)
assert.Nil(t, err)
@ -3694,7 +3694,7 @@ func Test_ManualCompaction(t *testing.T) {
t.Run("test manual compaction with unhealthy", func(t *testing.T) {
datacoord := &DataCoordMock{}
proxy := &Proxy{dataCoord: datacoord}
proxy.stateCode.Store(internalpb.StateCode_Abnormal)
proxy.stateCode.Store(commonpb.StateCode_Abnormal)
resp, err := proxy.ManualCompaction(context.TODO(), nil)
assert.EqualValues(t, unhealthyStatus(), resp.Status)
assert.Nil(t, err)
@ -3705,7 +3705,7 @@ func Test_GetCompactionStateWithPlans(t *testing.T) {
t.Run("test get compaction state with plans", func(t *testing.T) {
datacoord := &DataCoordMock{}
proxy := &Proxy{dataCoord: datacoord}
proxy.stateCode.Store(internalpb.StateCode_Healthy)
proxy.stateCode.Store(commonpb.StateCode_Healthy)
resp, err := proxy.GetCompactionStateWithPlans(context.TODO(), nil)
assert.EqualValues(t, &milvuspb.GetCompactionPlansResponse{}, resp)
assert.Nil(t, err)
@ -3713,7 +3713,7 @@ func Test_GetCompactionStateWithPlans(t *testing.T) {
t.Run("test get compaction state with plans with unhealthy proxy", func(t *testing.T) {
datacoord := &DataCoordMock{}
proxy := &Proxy{dataCoord: datacoord}
proxy.stateCode.Store(internalpb.StateCode_Abnormal)
proxy.stateCode.Store(commonpb.StateCode_Abnormal)
resp, err := proxy.GetCompactionStateWithPlans(context.TODO(), nil)
assert.EqualValues(t, unhealthyStatus(), resp.Status)
assert.Nil(t, err)
@ -3724,7 +3724,7 @@ func Test_GetFlushState(t *testing.T) {
t.Run("normal test", func(t *testing.T) {
datacoord := &DataCoordMock{}
proxy := &Proxy{dataCoord: datacoord}
proxy.stateCode.Store(internalpb.StateCode_Healthy)
proxy.stateCode.Store(commonpb.StateCode_Healthy)
resp, err := proxy.GetFlushState(context.TODO(), nil)
assert.EqualValues(t, &milvuspb.GetFlushStateResponse{}, resp)
assert.Nil(t, err)
@ -3733,7 +3733,7 @@ func Test_GetFlushState(t *testing.T) {
t.Run("test get flush state with unhealthy proxy", func(t *testing.T) {
datacoord := &DataCoordMock{}
proxy := &Proxy{dataCoord: datacoord}
proxy.stateCode.Store(internalpb.StateCode_Abnormal)
proxy.stateCode.Store(commonpb.StateCode_Abnormal)
resp, err := proxy.GetFlushState(context.TODO(), nil)
assert.EqualValues(t, unhealthyStatus(), resp.Status)
assert.Nil(t, err)
@ -3742,7 +3742,7 @@ func Test_GetFlushState(t *testing.T) {
func TestProxy_GetComponentStates(t *testing.T) {
n := &Proxy{}
n.stateCode.Store(internalpb.StateCode_Healthy)
n.stateCode.Store(commonpb.StateCode_Healthy)
resp, err := n.GetComponentStates(context.Background())
assert.NoError(t, err)
assert.Equal(t, commonpb.ErrorCode_Success, resp.Status.ErrorCode)
@ -3756,7 +3756,7 @@ func TestProxy_GetComponentStates(t *testing.T) {
func TestProxy_GetComponentStates_state_code(t *testing.T) {
p := &Proxy{}
p.stateCode.Store("not internalpb.StateCode")
p.stateCode.Store("not commonpb.StateCode")
states, err := p.GetComponentStates(context.Background())
assert.NoError(t, err)
assert.NotEqual(t, commonpb.ErrorCode_Success, states.Status.ErrorCode)
@ -3772,7 +3772,7 @@ func TestProxy_Import(t *testing.T) {
CollectionName: "dummy",
}
proxy := &Proxy{}
proxy.UpdateStateCode(internalpb.StateCode_Abnormal)
proxy.UpdateStateCode(commonpb.StateCode_Abnormal)
resp, err := proxy.Import(context.TODO(), req)
assert.NoError(t, err)
assert.EqualValues(t, unhealthyStatus(), resp.GetStatus())
@ -3782,7 +3782,7 @@ func TestProxy_Import(t *testing.T) {
t.Run("rootcoord fail", func(t *testing.T) {
defer wg.Done()
proxy := &Proxy{}
proxy.UpdateStateCode(internalpb.StateCode_Healthy)
proxy.UpdateStateCode(commonpb.StateCode_Healthy)
cache := newMockCache()
globalMetaCache = cache
chMgr := newMockChannelsMgr()
@ -3804,7 +3804,7 @@ func TestProxy_Import(t *testing.T) {
t.Run("normal case", func(t *testing.T) {
defer wg.Done()
proxy := &Proxy{}
proxy.UpdateStateCode(internalpb.StateCode_Healthy)
proxy.UpdateStateCode(commonpb.StateCode_Healthy)
cache := newMockCache()
globalMetaCache = cache
chMgr := newMockChannelsMgr()
@ -3830,10 +3830,10 @@ func TestProxy_GetImportState(t *testing.T) {
Task: 1,
}
rootCoord := &RootCoordMock{}
rootCoord.state.Store(internalpb.StateCode_Healthy)
rootCoord.state.Store(commonpb.StateCode_Healthy)
t.Run("test get import state", func(t *testing.T) {
proxy := &Proxy{rootCoord: rootCoord}
proxy.stateCode.Store(internalpb.StateCode_Healthy)
proxy.stateCode.Store(commonpb.StateCode_Healthy)
resp, err := proxy.GetImportState(context.TODO(), req)
assert.EqualValues(t, commonpb.ErrorCode_Success, resp.Status.ErrorCode)
@ -3841,7 +3841,7 @@ func TestProxy_GetImportState(t *testing.T) {
})
t.Run("test get import state with unhealthy", func(t *testing.T) {
proxy := &Proxy{rootCoord: rootCoord}
proxy.stateCode.Store(internalpb.StateCode_Abnormal)
proxy.stateCode.Store(commonpb.StateCode_Abnormal)
resp, err := proxy.GetImportState(context.TODO(), req)
assert.EqualValues(t, unhealthyStatus(), resp.Status)
assert.Nil(t, err)
@ -3851,10 +3851,10 @@ func TestProxy_GetImportState(t *testing.T) {
func TestProxy_ListImportTasks(t *testing.T) {
req := &milvuspb.ListImportTasksRequest{}
rootCoord := &RootCoordMock{}
rootCoord.state.Store(internalpb.StateCode_Healthy)
rootCoord.state.Store(commonpb.StateCode_Healthy)
t.Run("test list import tasks", func(t *testing.T) {
proxy := &Proxy{rootCoord: rootCoord}
proxy.stateCode.Store(internalpb.StateCode_Healthy)
proxy.stateCode.Store(commonpb.StateCode_Healthy)
resp, err := proxy.ListImportTasks(context.TODO(), req)
assert.EqualValues(t, commonpb.ErrorCode_Success, resp.Status.ErrorCode)
@ -3862,7 +3862,7 @@ func TestProxy_ListImportTasks(t *testing.T) {
})
t.Run("test list import tasks with unhealthy", func(t *testing.T) {
proxy := &Proxy{rootCoord: rootCoord}
proxy.stateCode.Store(internalpb.StateCode_Abnormal)
proxy.stateCode.Store(commonpb.StateCode_Abnormal)
resp, err := proxy.ListImportTasks(context.TODO(), req)
assert.EqualValues(t, unhealthyStatus(), resp.Status)
assert.Nil(t, err)

20
internal/proxy/query_coord_mock_test.go
View File

@ -73,38 +73,38 @@ type QueryCoordMock struct {
validShardLeaders bool
}
func (coord *QueryCoordMock) updateState(state internalpb.StateCode) {
func (coord *QueryCoordMock) updateState(state commonpb.StateCode) {
coord.state.Store(state)
}
func (coord *QueryCoordMock) getState() internalpb.StateCode {
return coord.state.Load().(internalpb.StateCode)
func (coord *QueryCoordMock) getState() commonpb.StateCode {
return coord.state.Load().(commonpb.StateCode)
}
func (coord *QueryCoordMock) healthy() bool {
return coord.getState() == internalpb.StateCode_Healthy
return coord.getState() == commonpb.StateCode_Healthy
}
func (coord *QueryCoordMock) Init() error {
coord.updateState(internalpb.StateCode_Initializing)
coord.updateState(commonpb.StateCode_Initializing)
return nil
}
func (coord *QueryCoordMock) Start() error {
defer coord.updateState(internalpb.StateCode_Healthy)
defer coord.updateState(commonpb.StateCode_Healthy)
return nil
}
func (coord *QueryCoordMock) Stop() error {
defer coord.updateState(internalpb.StateCode_Abnormal)
defer coord.updateState(commonpb.StateCode_Abnormal)
return nil
}
func (coord *QueryCoordMock) GetComponentStates(ctx context.Context) (*internalpb.ComponentStates, error) {
return &internalpb.ComponentStates{
State: &internalpb.ComponentInfo{
func (coord *QueryCoordMock) GetComponentStates(ctx context.Context) (*milvuspb.ComponentStates, error) {
return &milvuspb.ComponentStates{
State: &milvuspb.ComponentInfo{
NodeID: coord.nodeID,
Role: typeutil.QueryCoordRole,
StateCode: coord.getState(),

2
internal/proxy/query_node_mock_test.go
View File

@ -109,7 +109,7 @@ func (m *QueryNodeMock) Init() error { return nil }
func (m *QueryNodeMock) Start() error { return nil }
func (m *QueryNodeMock) Stop() error { return nil }
func (m *QueryNodeMock) Register() error { return nil }
func (m *QueryNodeMock) GetComponentStates(ctx context.Context) (*internalpb.ComponentStates, error) {
func (m *QueryNodeMock) GetComponentStates(ctx context.Context) (*milvuspb.ComponentStates, error) {
return nil, nil
}
func (m *QueryNodeMock) GetStatisticsChannel(ctx context.Context) (*milvuspb.StringResponse, error) {

194
internal/proxy/rootcoord_mock_test.go
View File

@ -112,11 +112,11 @@ type RootCoordMock struct {
}
func (coord *RootCoordMock) CreateAlias(ctx context.Context, req *milvuspb.CreateAliasRequest) (*commonpb.Status, error) {
code := coord.state.Load().(internalpb.StateCode)
if code != internalpb.StateCode_Healthy {
code := coord.state.Load().(commonpb.StateCode)
if code != commonpb.StateCode_Healthy {
return &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: fmt.Sprintf("state code = %s", internalpb.StateCode_name[int32(code)]),
Reason: fmt.Sprintf("state code = %s", commonpb.StateCode_name[int32(code)]),
}, nil
}
coord.collMtx.Lock()
@ -146,11 +146,11 @@ func (coord *RootCoordMock) CreateAlias(ctx context.Context, req *milvuspb.Creat
}
func (coord *RootCoordMock) DropAlias(ctx context.Context, req *milvuspb.DropAliasRequest) (*commonpb.Status, error) {
code := coord.state.Load().(internalpb.StateCode)
if code != internalpb.StateCode_Healthy {
code := coord.state.Load().(commonpb.StateCode)
if code != commonpb.StateCode_Healthy {
return &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: fmt.Sprintf("state code = %s", internalpb.StateCode_name[int32(code)]),
Reason: fmt.Sprintf("state code = %s", commonpb.StateCode_name[int32(code)]),
}, nil
}
coord.collMtx.Lock()
@ -172,11 +172,11 @@ func (coord *RootCoordMock) DropAlias(ctx context.Context, req *milvuspb.DropAli
}
func (coord *RootCoordMock) AlterAlias(ctx context.Context, req *milvuspb.AlterAliasRequest) (*commonpb.Status, error) {
code := coord.state.Load().(internalpb.StateCode)
if code != internalpb.StateCode_Healthy {
code := coord.state.Load().(commonpb.StateCode)
if code != commonpb.StateCode_Healthy {
return &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: fmt.Sprintf("state code = %s", internalpb.StateCode_name[int32(code)]),
Reason: fmt.Sprintf("state code = %s", commonpb.StateCode_name[int32(code)]),
}, nil
}
coord.collMtx.Lock()
@ -203,38 +203,38 @@ func (coord *RootCoordMock) AlterAlias(ctx context.Context, req *milvuspb.AlterA
}, nil
}
func (coord *RootCoordMock) updateState(state internalpb.StateCode) {
func (coord *RootCoordMock) updateState(state commonpb.StateCode) {
coord.state.Store(state)
}
func (coord *RootCoordMock) getState() internalpb.StateCode {
return coord.state.Load().(internalpb.StateCode)
func (coord *RootCoordMock) getState() commonpb.StateCode {
return coord.state.Load().(commonpb.StateCode)
}
func (coord *RootCoordMock) healthy() bool {
return coord.getState() == internalpb.StateCode_Healthy
return coord.getState() == commonpb.StateCode_Healthy
}
func (coord *RootCoordMock) Init() error {
coord.updateState(internalpb.StateCode_Initializing)
coord.updateState(commonpb.StateCode_Initializing)
return nil
}
func (coord *RootCoordMock) Start() error {
defer coord.updateState(internalpb.StateCode_Healthy)
defer coord.updateState(commonpb.StateCode_Healthy)
return nil
}
func (coord *RootCoordMock) Stop() error {
defer coord.updateState(internalpb.StateCode_Abnormal)
defer coord.updateState(commonpb.StateCode_Abnormal)
return nil
}
func (coord *RootCoordMock) GetComponentStates(ctx context.Context) (*internalpb.ComponentStates, error) {
return &internalpb.ComponentStates{
State: &internalpb.ComponentInfo{
func (coord *RootCoordMock) GetComponentStates(ctx context.Context) (*milvuspb.ComponentStates, error) {
return &milvuspb.ComponentStates{
State: &milvuspb.ComponentInfo{
NodeID: coord.nodeID,
Role: typeutil.RootCoordRole,
StateCode: coord.getState(),
@ -249,12 +249,12 @@ func (coord *RootCoordMock) GetComponentStates(ctx context.Context) (*internalpb
}
func (coord *RootCoordMock) GetStatisticsChannel(ctx context.Context) (*milvuspb.StringResponse, error) {
code := coord.state.Load().(internalpb.StateCode)
if code != internalpb.StateCode_Healthy {
code := coord.state.Load().(commonpb.StateCode)
if code != commonpb.StateCode_Healthy {
return &milvuspb.StringResponse{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: fmt.Sprintf("state code = %s", internalpb.StateCode_name[int32(code)]),
Reason: fmt.Sprintf("state code = %s", commonpb.StateCode_name[int32(code)]),
},
}, nil
}
@ -272,12 +272,12 @@ func (coord *RootCoordMock) Register() error {
}
func (coord *RootCoordMock) GetTimeTickChannel(ctx context.Context) (*milvuspb.StringResponse, error) {
code := coord.state.Load().(internalpb.StateCode)
if code != internalpb.StateCode_Healthy {
code := coord.state.Load().(commonpb.StateCode)
if code != commonpb.StateCode_Healthy {
return &milvuspb.StringResponse{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: fmt.Sprintf("state code = %s", internalpb.StateCode_name[int32(code)]),
Reason: fmt.Sprintf("state code = %s", commonpb.StateCode_name[int32(code)]),
},
}, nil
}
@ -291,11 +291,11 @@ func (coord *RootCoordMock) GetTimeTickChannel(ctx context.Context) (*milvuspb.S
}
func (coord *RootCoordMock) CreateCollection(ctx context.Context, req *milvuspb.CreateCollectionRequest) (*commonpb.Status, error) {
code := coord.state.Load().(internalpb.StateCode)
if code != internalpb.StateCode_Healthy {
code := coord.state.Load().(commonpb.StateCode)
if code != commonpb.StateCode_Healthy {
return &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: fmt.Sprintf("state code = %s", internalpb.StateCode_name[int32(code)]),
Reason: fmt.Sprintf("state code = %s", commonpb.StateCode_name[int32(code)]),
}, nil
}
coord.collMtx.Lock()
@ -368,11 +368,11 @@ func (coord *RootCoordMock) CreateCollection(ctx context.Context, req *milvuspb.
}
func (coord *RootCoordMock) DropCollection(ctx context.Context, req *milvuspb.DropCollectionRequest) (*commonpb.Status, error) {
code := coord.state.Load().(internalpb.StateCode)
if code != internalpb.StateCode_Healthy {
code := coord.state.Load().(commonpb.StateCode)
if code != commonpb.StateCode_Healthy {
return &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: fmt.Sprintf("state code = %s", internalpb.StateCode_name[int32(code)]),
Reason: fmt.Sprintf("state code = %s", commonpb.StateCode_name[int32(code)]),
}, nil
}
coord.collMtx.Lock()
@ -402,12 +402,12 @@ func (coord *RootCoordMock) DropCollection(ctx context.Context, req *milvuspb.Dr
}
func (coord *RootCoordMock) HasCollection(ctx context.Context, req *milvuspb.HasCollectionRequest) (*milvuspb.BoolResponse, error) {
code := coord.state.Load().(internalpb.StateCode)
if code != internalpb.StateCode_Healthy {
code := coord.state.Load().(commonpb.StateCode)
if code != commonpb.StateCode_Healthy {
return &milvuspb.BoolResponse{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: fmt.Sprintf("state code = %s", internalpb.StateCode_name[int32(code)]),
Reason: fmt.Sprintf("state code = %s", commonpb.StateCode_name[int32(code)]),
},
Value: false,
}, nil
@ -435,12 +435,12 @@ func (coord *RootCoordMock) ResetDescribeCollectionFunc() {
}
func (coord *RootCoordMock) DescribeCollection(ctx context.Context, req *milvuspb.DescribeCollectionRequest) (*milvuspb.DescribeCollectionResponse, error) {
code := coord.state.Load().(internalpb.StateCode)
if code != internalpb.StateCode_Healthy {
code := coord.state.Load().(commonpb.StateCode)
if code != commonpb.StateCode_Healthy {
return &milvuspb.DescribeCollectionResponse{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: fmt.Sprintf("state code = %s", internalpb.StateCode_name[int32(code)]),
Reason: fmt.Sprintf("state code = %s", commonpb.StateCode_name[int32(code)]),
},
Schema: nil,
CollectionID: 0,
@ -495,12 +495,12 @@ func (coord *RootCoordMock) DescribeCollection(ctx context.Context, req *milvusp
}
func (coord *RootCoordMock) ShowCollections(ctx context.Context, req *milvuspb.ShowCollectionsRequest) (*milvuspb.ShowCollectionsResponse, error) {
code := coord.state.Load().(internalpb.StateCode)
if code != internalpb.StateCode_Healthy {
code := coord.state.Load().(commonpb.StateCode)
if code != commonpb.StateCode_Healthy {
return &milvuspb.ShowCollectionsResponse{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: fmt.Sprintf("state code = %s", internalpb.StateCode_name[int32(code)]),
Reason: fmt.Sprintf("state code = %s", commonpb.StateCode_name[int32(code)]),
},
CollectionNames: nil,
}, nil
@ -536,11 +536,11 @@ func (coord *RootCoordMock) ShowCollections(ctx context.Context, req *milvuspb.S
}
func (coord *RootCoordMock) CreatePartition(ctx context.Context, req *milvuspb.CreatePartitionRequest) (*commonpb.Status, error) {
code := coord.state.Load().(internalpb.StateCode)
if code != internalpb.StateCode_Healthy {
code := coord.state.Load().(commonpb.StateCode)
if code != commonpb.StateCode_Healthy {
return &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: fmt.Sprintf("state code = %s", internalpb.StateCode_name[int32(code)]),
Reason: fmt.Sprintf("state code = %s", commonpb.StateCode_name[int32(code)]),
}, nil
}
coord.collMtx.RLock()
@ -582,11 +582,11 @@ func (coord *RootCoordMock) CreatePartition(ctx context.Context, req *milvuspb.C
}
func (coord *RootCoordMock) DropPartition(ctx context.Context, req *milvuspb.DropPartitionRequest) (*commonpb.Status, error) {
code := coord.state.Load().(internalpb.StateCode)
if code != internalpb.StateCode_Healthy {
code := coord.state.Load().(commonpb.StateCode)
if code != commonpb.StateCode_Healthy {
return &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: fmt.Sprintf("state code = %s", internalpb.StateCode_name[int32(code)]),
Reason: fmt.Sprintf("state code = %s", commonpb.StateCode_name[int32(code)]),
}, nil
}
coord.collMtx.RLock()
@ -621,12 +621,12 @@ func (coord *RootCoordMock) DropPartition(ctx context.Context, req *milvuspb.Dro
}
func (coord *RootCoordMock) HasPartition(ctx context.Context, req *milvuspb.HasPartitionRequest) (*milvuspb.BoolResponse, error) {
code := coord.state.Load().(internalpb.StateCode)
if code != internalpb.StateCode_Healthy {
code := coord.state.Load().(commonpb.StateCode)
if code != commonpb.StateCode_Healthy {
return &milvuspb.BoolResponse{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: fmt.Sprintf("state code = %s", internalpb.StateCode_name[int32(code)]),
Reason: fmt.Sprintf("state code = %s", commonpb.StateCode_name[int32(code)]),
},
Value: false,
}, nil
@ -659,12 +659,12 @@ func (coord *RootCoordMock) HasPartition(ctx context.Context, req *milvuspb.HasP
}
func (coord *RootCoordMock) ShowPartitions(ctx context.Context, req *milvuspb.ShowPartitionsRequest) (*milvuspb.ShowPartitionsResponse, error) {
code := coord.state.Load().(internalpb.StateCode)
if code != internalpb.StateCode_Healthy {
code := coord.state.Load().(commonpb.StateCode)
if code != commonpb.StateCode_Healthy {
return &milvuspb.ShowPartitionsResponse{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: fmt.Sprintf("rootcoord is not healthy, state code = %s", internalpb.StateCode_name[int32(code)]),
Reason: fmt.Sprintf("rootcoord is not healthy, state code = %s", commonpb.StateCode_name[int32(code)]),
},
PartitionNames: nil,
PartitionIDs: nil,
@ -720,11 +720,11 @@ func (coord *RootCoordMock) ShowPartitions(ctx context.Context, req *milvuspb.Sh
}
//func (coord *RootCoordMock) CreateIndex(ctx context.Context, req *milvuspb.CreateIndexRequest) (*commonpb.Status, error) {
// code := coord.state.Load().(internalpb.StateCode)
// if code != internalpb.StateCode_Healthy {
// code := coord.state.Load().(commonpb.StateCode)
// if code != commonpb.StateCode_Healthy {
// return &commonpb.Status{
// ErrorCode: commonpb.ErrorCode_UnexpectedError,
// Reason: fmt.Sprintf("state code = %s", internalpb.StateCode_name[int32(code)]),
// Reason: fmt.Sprintf("state code = %s", commonpb.StateCode_name[int32(code)]),
// }, nil
// }
// return &commonpb.Status{
@ -734,12 +734,12 @@ func (coord *RootCoordMock) ShowPartitions(ctx context.Context, req *milvuspb.Sh
//}
//func (coord *RootCoordMock) DescribeIndex(ctx context.Context, req *milvuspb.DescribeIndexRequest) (*milvuspb.DescribeIndexResponse, error) {
// code := coord.state.Load().(internalpb.StateCode)
// if code != internalpb.StateCode_Healthy {
// code := coord.state.Load().(commonpb.StateCode)
// if code != commonpb.StateCode_Healthy {
// return &milvuspb.DescribeIndexResponse{
// Status: &commonpb.Status{
// ErrorCode: commonpb.ErrorCode_UnexpectedError,
// Reason: fmt.Sprintf("state code = %s", internalpb.StateCode_name[int32(code)]),
// Reason: fmt.Sprintf("state code = %s", commonpb.StateCode_name[int32(code)]),
// },
// IndexDescriptions: nil,
// }, nil
@ -754,12 +754,12 @@ func (coord *RootCoordMock) ShowPartitions(ctx context.Context, req *milvuspb.Sh
//}
//func (coord *RootCoordMock) GetIndexState(ctx context.Context, req *milvuspb.GetIndexStateRequest) (*indexpb.GetIndexStatesResponse, error) {
// code := coord.state.Load().(internalpb.StateCode)
// if code != internalpb.StateCode_Healthy {
// code := coord.state.Load().(commonpb.StateCode)
// if code != commonpb.StateCode_Healthy {
// return &indexpb.GetIndexStatesResponse{
// Status: &commonpb.Status{
// ErrorCode: commonpb.ErrorCode_UnexpectedError,
// Reason: fmt.Sprintf("state code = %s", internalpb.StateCode_name[int32(code)]),
// Reason: fmt.Sprintf("state code = %s", commonpb.StateCode_name[int32(code)]),
// },
// }, nil
// }
@ -772,11 +772,11 @@ func (coord *RootCoordMock) ShowPartitions(ctx context.Context, req *milvuspb.Sh
//}
//func (coord *RootCoordMock) DropIndex(ctx context.Context, req *milvuspb.DropIndexRequest) (*commonpb.Status, error) {
// code := coord.state.Load().(internalpb.StateCode)
// if code != internalpb.StateCode_Healthy {
// code := coord.state.Load().(commonpb.StateCode)
// if code != commonpb.StateCode_Healthy {
// return &commonpb.Status{
// ErrorCode: commonpb.ErrorCode_UnexpectedError,
// Reason: fmt.Sprintf("state code = %s", internalpb.StateCode_name[int32(code)]),
// Reason: fmt.Sprintf("state code = %s", commonpb.StateCode_name[int32(code)]),
// }, nil
// }
// return &commonpb.Status{
@ -786,12 +786,12 @@ func (coord *RootCoordMock) ShowPartitions(ctx context.Context, req *milvuspb.Sh
//}
func (coord *RootCoordMock) AllocTimestamp(ctx context.Context, req *rootcoordpb.AllocTimestampRequest) (*rootcoordpb.AllocTimestampResponse, error) {
code := coord.state.Load().(internalpb.StateCode)
if code != internalpb.StateCode_Healthy {
code := coord.state.Load().(commonpb.StateCode)
if code != commonpb.StateCode_Healthy {
return &rootcoordpb.AllocTimestampResponse{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: fmt.Sprintf("state code = %s", internalpb.StateCode_name[int32(code)]),
Reason: fmt.Sprintf("state code = %s", commonpb.StateCode_name[int32(code)]),
},
Timestamp: 0,
Count: 0,
@ -817,12 +817,12 @@ func (coord *RootCoordMock) AllocTimestamp(ctx context.Context, req *rootcoordpb
}
func (coord *RootCoordMock) AllocID(ctx context.Context, req *rootcoordpb.AllocIDRequest) (*rootcoordpb.AllocIDResponse, error) {
code := coord.state.Load().(internalpb.StateCode)
if code != internalpb.StateCode_Healthy {
code := coord.state.Load().(commonpb.StateCode)
if code != commonpb.StateCode_Healthy {
return &rootcoordpb.AllocIDResponse{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: fmt.Sprintf("state code = %s", internalpb.StateCode_name[int32(code)]),
Reason: fmt.Sprintf("state code = %s", commonpb.StateCode_name[int32(code)]),
},
ID: 0,
Count: 0,
@ -840,11 +840,11 @@ func (coord *RootCoordMock) AllocID(ctx context.Context, req *rootcoordpb.AllocI
}
func (coord *RootCoordMock) UpdateChannelTimeTick(ctx context.Context, req *internalpb.ChannelTimeTickMsg) (*commonpb.Status, error) {
code := coord.state.Load().(internalpb.StateCode)
if code != internalpb.StateCode_Healthy {
code := coord.state.Load().(commonpb.StateCode)
if code != commonpb.StateCode_Healthy {
return &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: fmt.Sprintf("state code = %s", internalpb.StateCode_name[int32(code)]),
Reason: fmt.Sprintf("state code = %s", commonpb.StateCode_name[int32(code)]),
}, nil
}
return &commonpb.Status{
@ -854,12 +854,12 @@ func (coord *RootCoordMock) UpdateChannelTimeTick(ctx context.Context, req *inte
}
func (coord *RootCoordMock) DescribeSegment(ctx context.Context, req *milvuspb.DescribeSegmentRequest) (*milvuspb.DescribeSegmentResponse, error) {
code := coord.state.Load().(internalpb.StateCode)
if code != internalpb.StateCode_Healthy {
code := coord.state.Load().(commonpb.StateCode)
if code != commonpb.StateCode_Healthy {
return &milvuspb.DescribeSegmentResponse{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: fmt.Sprintf("state code = %s", internalpb.StateCode_name[int32(code)]),
Reason: fmt.Sprintf("state code = %s", commonpb.StateCode_name[int32(code)]),
},
IndexID: 0,
}, nil
@ -876,12 +876,12 @@ func (coord *RootCoordMock) DescribeSegment(ctx context.Context, req *milvuspb.D
}
func (coord *RootCoordMock) ShowSegments(ctx context.Context, req *milvuspb.ShowSegmentsRequest) (*milvuspb.ShowSegmentsResponse, error) {
code := coord.state.Load().(internalpb.StateCode)
if code != internalpb.StateCode_Healthy {
code := coord.state.Load().(commonpb.StateCode)
if code != commonpb.StateCode_Healthy {
return &milvuspb.ShowSegmentsResponse{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: fmt.Sprintf("state code = %s", internalpb.StateCode_name[int32(code)]),
Reason: fmt.Sprintf("state code = %s", commonpb.StateCode_name[int32(code)]),
},
SegmentIDs: nil,
}, nil
@ -900,11 +900,11 @@ func (coord *RootCoordMock) DescribeSegments(ctx context.Context, req *rootcoord
}
func (coord *RootCoordMock) InvalidateCollectionMetaCache(ctx context.Context, in *proxypb.InvalidateCollMetaCacheRequest) (*commonpb.Status, error) {
code := coord.state.Load().(internalpb.StateCode)
if code != internalpb.StateCode_Healthy {
code := coord.state.Load().(commonpb.StateCode)
if code != commonpb.StateCode_Healthy {
return &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: fmt.Sprintf("state code = %s", internalpb.StateCode_name[int32(code)]),
Reason: fmt.Sprintf("state code = %s", commonpb.StateCode_name[int32(code)]),
}, nil
}
return &commonpb.Status{
@ -914,11 +914,11 @@ func (coord *RootCoordMock) InvalidateCollectionMetaCache(ctx context.Context, i
}
func (coord *RootCoordMock) SegmentFlushCompleted(ctx context.Context, in *datapb.SegmentFlushCompletedMsg) (*commonpb.Status, error) {
code := coord.state.Load().(internalpb.StateCode)
if code != internalpb.StateCode_Healthy {
code := coord.state.Load().(commonpb.StateCode)
if code != commonpb.StateCode_Healthy {
return &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: fmt.Sprintf("state code = %s", internalpb.StateCode_name[int32(code)]),
Reason: fmt.Sprintf("state code = %s", commonpb.StateCode_name[int32(code)]),
}, nil
}
return &commonpb.Status{
@ -974,12 +974,12 @@ func (coord *RootCoordMock) GetMetrics(ctx context.Context, req *milvuspb.GetMet
}
func (coord *RootCoordMock) Import(ctx context.Context, req *milvuspb.ImportRequest) (*milvuspb.ImportResponse, error) {
code := coord.state.Load().(internalpb.StateCode)
if code != internalpb.StateCode_Healthy {
code := coord.state.Load().(commonpb.StateCode)
if code != commonpb.StateCode_Healthy {
return &milvuspb.ImportResponse{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: fmt.Sprintf("state code = %s", internalpb.StateCode_name[int32(code)]),
Reason: fmt.Sprintf("state code = %s", commonpb.StateCode_name[int32(code)]),
},
Tasks: make([]int64, 0),
}, nil
@ -994,12 +994,12 @@ func (coord *RootCoordMock) Import(ctx context.Context, req *milvuspb.ImportRequ
}
func (coord *RootCoordMock) GetImportState(ctx context.Context, req *milvuspb.GetImportStateRequest) (*milvuspb.GetImportStateResponse, error) {
code := coord.state.Load().(internalpb.StateCode)
if code != internalpb.StateCode_Healthy {
code := coord.state.Load().(commonpb.StateCode)
if code != commonpb.StateCode_Healthy {
return &milvuspb.GetImportStateResponse{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: fmt.Sprintf("state code = %s", internalpb.StateCode_name[int32(code)]),
Reason: fmt.Sprintf("state code = %s", commonpb.StateCode_name[int32(code)]),
},
RowCount: 0,
IdList: make([]int64, 0),
@ -1016,12 +1016,12 @@ func (coord *RootCoordMock) GetImportState(ctx context.Context, req *milvuspb.Ge
}
func (coord *RootCoordMock) ListImportTasks(ctx context.Context, in *milvuspb.ListImportTasksRequest) (*milvuspb.ListImportTasksResponse, error) {
code := coord.state.Load().(internalpb.StateCode)
if code != internalpb.StateCode_Healthy {
code := coord.state.Load().(commonpb.StateCode)
if code != commonpb.StateCode_Healthy {
return &milvuspb.ListImportTasksResponse{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: fmt.Sprintf("state code = %s", internalpb.StateCode_name[int32(code)]),
Reason: fmt.Sprintf("state code = %s", commonpb.StateCode_name[int32(code)]),
},
Tasks: make([]*milvuspb.GetImportStateResponse, 0),
}, nil
@ -1036,11 +1036,11 @@ func (coord *RootCoordMock) ListImportTasks(ctx context.Context, in *milvuspb.Li
}
func (coord *RootCoordMock) ReportImport(ctx context.Context, req *rootcoordpb.ImportResult) (*commonpb.Status, error) {
code := coord.state.Load().(internalpb.StateCode)
if code != internalpb.StateCode_Healthy {
code := coord.state.Load().(commonpb.StateCode)
if code != commonpb.StateCode_Healthy {
return &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
Reason: fmt.Sprintf("state code = %s", internalpb.StateCode_name[int32(code)]),
Reason: fmt.Sprintf("state code = %s", commonpb.StateCode_name[int32(code)]),
}, nil
}
return &commonpb.Status{

2
internal/proxy/task_test.go
View File

@ -827,7 +827,7 @@ func TestHasCollectionTask(t *testing.T) {
err = task.PreExecute(ctx)
assert.NotNil(t, err)
rc.updateState(internalpb.StateCode_Abnormal)
rc.updateState(commonpb.StateCode_Abnormal)
task.CollectionName = collectionName
err = task.PreExecute(ctx)
assert.Nil(t, err)

6
internal/querycoord/cluster.go
View File

@ -78,7 +78,7 @@ type Cluster interface {
// Inner
reloadFromKV() error
getComponentInfos(ctx context.Context) []*internalpb.ComponentInfo
getComponentInfos(ctx context.Context) []*milvuspb.ComponentInfo
}
type newQueryNodeFn func(ctx context.Context, address string, id UniqueID, kv *etcdkv.EtcdKV) (Node, error)
@ -185,10 +185,10 @@ func (c *queryNodeCluster) GetSessionVersion() int64 {
return c.sessionVersion
}
func (c *queryNodeCluster) getComponentInfos(ctx context.Context) []*internalpb.ComponentInfo {
func (c *queryNodeCluster) getComponentInfos(ctx context.Context) []*milvuspb.ComponentInfo {
c.RLock()
defer c.RUnlock()
var subComponentInfos []*internalpb.ComponentInfo
var subComponentInfos []*milvuspb.ComponentInfo
for _, node := range c.nodes {
componentState := node.getComponentInfo(ctx)
subComponentInfos = append(subComponentInfos, componentState)

36
internal/querycoord/impl.go
View File

@ -35,27 +35,27 @@ import (
)
// GetComponentStates return information about whether the coord is healthy
func (qc *QueryCoord) GetComponentStates(ctx context.Context) (*internalpb.ComponentStates, error) {
func (qc *QueryCoord) GetComponentStates(ctx context.Context) (*milvuspb.ComponentStates, error) {
nodeID := common.NotRegisteredID
if qc.session != nil && qc.session.Registered() {
nodeID = qc.session.ServerID
}
serviceComponentInfo := &internalpb.ComponentInfo{
serviceComponentInfo := &milvuspb.ComponentInfo{
// NodeID: Params.QueryCoordID, // will race with QueryCoord.Register()
NodeID: nodeID,
StateCode: qc.stateCode.Load().(internalpb.StateCode),
StateCode: qc.stateCode.Load().(commonpb.StateCode),
}
//subComponentInfos, err := qs.cluster.GetComponentInfos(ctx)
//if err != nil {
// return &internalpb.ComponentStates{
// return &milvuspb.ComponentStates{
// Status: &commonpb.Status{
// ErrorCode: commonpb.ErrorCode_UnexpectedError,
// Reason: err.Error(),
// },
// }, err
//}
return &internalpb.ComponentStates{
return &milvuspb.ComponentStates{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_Success,
},
@ -141,7 +141,7 @@ func (qc *QueryCoord) ShowCollections(ctx context.Context, req *querypb.ShowColl
status := &commonpb.Status{
ErrorCode: commonpb.ErrorCode_Success,
}
if qc.stateCode.Load() != internalpb.StateCode_Healthy {
if qc.stateCode.Load() != commonpb.StateCode_Healthy {
status.ErrorCode = commonpb.ErrorCode_UnexpectedError
err := errors.New("QueryCoord is not healthy")
status.Reason = err.Error()
@ -253,7 +253,7 @@ func (qc *QueryCoord) LoadCollection(ctx context.Context, req *querypb.LoadColle
status := &commonpb.Status{
ErrorCode: commonpb.ErrorCode_Success,
}
if qc.stateCode.Load() != internalpb.StateCode_Healthy {
if qc.stateCode.Load() != commonpb.StateCode_Healthy {
status.ErrorCode = commonpb.ErrorCode_UnexpectedError
err := errors.New("QueryCoord is not healthy")
status.Reason = err.Error()
@ -324,7 +324,7 @@ func (qc *QueryCoord) ReleaseCollection(ctx context.Context, req *querypb.Releas
status := &commonpb.Status{
ErrorCode: commonpb.ErrorCode_Success,
}
if qc.stateCode.Load() != internalpb.StateCode_Healthy {
if qc.stateCode.Load() != commonpb.StateCode_Healthy {
status.ErrorCode = commonpb.ErrorCode_UnexpectedError
err := errors.New("QueryCoord is not healthy")
status.Reason = err.Error()
@ -405,7 +405,7 @@ func (qc *QueryCoord) ShowPartitions(ctx context.Context, req *querypb.ShowParti
status := &commonpb.Status{
ErrorCode: commonpb.ErrorCode_Success,
}
if qc.stateCode.Load() != internalpb.StateCode_Healthy {
if qc.stateCode.Load() != commonpb.StateCode_Healthy {
status.ErrorCode = commonpb.ErrorCode_UnexpectedError
err := errors.New("QueryCoord is not healthy")
status.Reason = err.Error()
@ -498,7 +498,7 @@ func (qc *QueryCoord) LoadPartitions(ctx context.Context, req *querypb.LoadParti
status := &commonpb.Status{
ErrorCode: commonpb.ErrorCode_Success,
}
if qc.stateCode.Load() != internalpb.StateCode_Healthy {
if qc.stateCode.Load() != commonpb.StateCode_Healthy {
status.ErrorCode = commonpb.ErrorCode_UnexpectedError
err := errors.New("QueryCoord is not healthy")
status.Reason = err.Error()
@ -590,7 +590,7 @@ func (qc *QueryCoord) ReleasePartitions(ctx context.Context, req *querypb.Releas
status := &commonpb.Status{
ErrorCode: commonpb.ErrorCode_Success,
}
if qc.stateCode.Load() != internalpb.StateCode_Healthy {
if qc.stateCode.Load() != commonpb.StateCode_Healthy {
status.ErrorCode = commonpb.ErrorCode_UnexpectedError
err := errors.New("QueryCoord is not healthy")
status.Reason = err.Error()
@ -751,7 +751,7 @@ func (qc *QueryCoord) GetPartitionStates(ctx context.Context, req *querypb.GetPa
status := &commonpb.Status{
ErrorCode: commonpb.ErrorCode_Success,
}
if qc.stateCode.Load() != internalpb.StateCode_Healthy {
if qc.stateCode.Load() != commonpb.StateCode_Healthy {
status.ErrorCode = commonpb.ErrorCode_UnexpectedError
err := errors.New("QueryCoord is not healthy")
status.Reason = err.Error()
@ -807,7 +807,7 @@ func (qc *QueryCoord) GetSegmentInfo(ctx context.Context, req *querypb.GetSegmen
status := &commonpb.Status{
ErrorCode: commonpb.ErrorCode_Success,
}
if qc.stateCode.Load() != internalpb.StateCode_Healthy {
if qc.stateCode.Load() != commonpb.StateCode_Healthy {
status.ErrorCode = commonpb.ErrorCode_UnexpectedError
err := errors.New("QueryCoord is not healthy")
status.Reason = err.Error()
@ -866,7 +866,7 @@ func (qc *QueryCoord) LoadBalance(ctx context.Context, req *querypb.LoadBalanceR
status := &commonpb.Status{
ErrorCode: commonpb.ErrorCode_Success,
}
if qc.stateCode.Load() != internalpb.StateCode_Healthy {
if qc.stateCode.Load() != commonpb.StateCode_Healthy {
status.ErrorCode = commonpb.ErrorCode_UnexpectedError
err := errors.New("QueryCoord is not healthy")
status.Reason = err.Error()
@ -920,7 +920,7 @@ func (qc *QueryCoord) ShowConfigurations(ctx context.Context, req *internalpb.Sh
zap.String("pattern", req.Pattern),
zap.Int64("msgID", req.GetBase().GetMsgID()))
if qc.stateCode.Load() != internalpb.StateCode_Healthy {
if qc.stateCode.Load() != commonpb.StateCode_Healthy {
err := errors.New("QueryCoord is not healthy")
log.Warn("ShowConfigurations failed", zap.String("role", typeutil.QueryCoordRole), zap.Int64("msgID", req.GetBase().GetMsgID()), zap.Error(err))
return &internalpb.ShowConfigurationsResponse{
@ -949,7 +949,7 @@ func (qc *QueryCoord) GetMetrics(ctx context.Context, req *milvuspb.GetMetricsRe
ComponentName: metricsinfo.ConstructComponentName(typeutil.QueryCoordRole, Params.QueryCoordCfg.GetNodeID()),
}
if qc.stateCode.Load() != internalpb.StateCode_Healthy {
if qc.stateCode.Load() != commonpb.StateCode_Healthy {
err := errors.New("QueryCoord is not healthy")
getMetricsResponse.Status.Reason = err.Error()
log.Warn("getMetrics failed", zap.String("role", typeutil.QueryCoordRole), zap.Int64("msgID", req.GetBase().GetMsgID()), zap.Error(err))
@ -1027,7 +1027,7 @@ func (qc *QueryCoord) GetReplicas(ctx context.Context, req *milvuspb.GetReplicas
ErrorCode: commonpb.ErrorCode_Success,
}
if qc.stateCode.Load() != internalpb.StateCode_Healthy {
if qc.stateCode.Load() != commonpb.StateCode_Healthy {
status.ErrorCode = commonpb.ErrorCode_UnexpectedError
err := errors.New("QueryCoord is not healthy")
status.Reason = err.Error()
@ -1090,7 +1090,7 @@ func (qc *QueryCoord) GetShardLeaders(ctx context.Context, req *querypb.GetShard
ErrorCode: commonpb.ErrorCode_Success,
}
if qc.stateCode.Load() != internalpb.StateCode_Healthy {
if qc.stateCode.Load() != commonpb.StateCode_Healthy {
status.ErrorCode = commonpb.ErrorCode_UnexpectedError
err := errors.New("QueryCoord is not healthy")
status.Reason = err.Error()

6
internal/querycoord/impl_test.go
View File

@ -366,7 +366,7 @@ func TestGrpcTask(t *testing.T) {
t.Run("Test GetComponentStates", func(t *testing.T) {
states, err := queryCoord.GetComponentStates(ctx)
assert.Equal(t, commonpb.ErrorCode_Success, states.Status.ErrorCode)
assert.Equal(t, internalpb.StateCode_Healthy, states.State.StateCode)
assert.Equal(t, commonpb.StateCode_Healthy, states.State.StateCode)
assert.Nil(t, err)
})
@ -775,7 +775,7 @@ func TestGrpcTaskBeforeHealthy(t *testing.T) {
t.Run("Test GetComponentStates", func(t *testing.T) {
states, err := unHealthyCoord.GetComponentStates(ctx)
assert.Equal(t, commonpb.ErrorCode_Success, states.Status.ErrorCode)
assert.Equal(t, internalpb.StateCode_Abnormal, states.State.StateCode)
assert.Equal(t, commonpb.StateCode_Abnormal, states.State.StateCode)
assert.Nil(t, err)
})
@ -833,7 +833,7 @@ func TestGrpcTaskBeforeHealthy(t *testing.T) {
func TestQueryCoord_GetComponentStates(t *testing.T) {
n := &QueryCoord{}
n.stateCode.Store(internalpb.StateCode_Healthy)
n.stateCode.Store(commonpb.StateCode_Healthy)
resp, err := n.GetComponentStates(context.Background())
assert.NoError(t, err)
assert.Equal(t, commonpb.ErrorCode_Success, resp.Status.ErrorCode)

4
internal/querycoord/mock_querynode_client_test.go
View File

@ -101,8 +101,8 @@ func (client *queryNodeClientMock) Register() error {
return nil
}
func (client *queryNodeClientMock) GetComponentStates(ctx context.Context) (*internalpb.ComponentStates, error) {
return client.grpcClient.GetComponentStates(ctx, &internalpb.GetComponentStatesRequest{})
func (client *queryNodeClientMock) GetComponentStates(ctx context.Context) (*milvuspb.ComponentStates, error) {
return client.grpcClient.GetComponentStates(ctx, &milvuspb.GetComponentStatesRequest{})
}
func (client *queryNodeClientMock) GetTimeTickChannel(ctx context.Context) (*milvuspb.StringResponse, error) {

5
internal/querycoord/mock_querynode_server_test.go
View File

@ -30,7 +30,6 @@ import (
"github.com/milvus-io/milvus/api/commonpb"
"github.com/milvus-io/milvus/api/milvuspb"
"github.com/milvus-io/milvus/internal/log"
"github.com/milvus-io/milvus/internal/proto/internalpb"
"github.com/milvus-io/milvus/internal/proto/querypb"
"github.com/milvus-io/milvus/internal/util/etcd"
"github.com/milvus-io/milvus/internal/util/funcutil"
@ -195,8 +194,8 @@ func (qs *queryNodeServerMock) run() error {
return nil
}
func (qs *queryNodeServerMock) GetComponentStates(ctx context.Context, req *internalpb.GetComponentStatesRequest) (*internalpb.ComponentStates, error) {
return &internalpb.ComponentStates{
func (qs *queryNodeServerMock) GetComponentStates(ctx context.Context, req *milvuspb.GetComponentStatesRequest) (*milvuspb.ComponentStates, error) {
return &milvuspb.ComponentStates{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_Success,
},

13
internal/querycoord/query_coord.go
View File

@ -41,7 +41,6 @@ import (
"github.com/milvus-io/milvus/internal/allocator"
etcdkv "github.com/milvus-io/milvus/internal/kv/etcd"
"github.com/milvus-io/milvus/internal/log"
"github.com/milvus-io/milvus/internal/proto/internalpb"
"github.com/milvus-io/milvus/internal/proto/querypb"
"github.com/milvus-io/milvus/internal/storage"
"github.com/milvus-io/milvus/internal/types"
@ -269,11 +268,11 @@ func (qc *QueryCoord) Start() error {
// todo to complete
log.Info("querycoord switch from standby to active, activating")
qc.meta.reloadFromKV()
qc.UpdateStateCode(internalpb.StateCode_Healthy)
qc.UpdateStateCode(commonpb.StateCode_Healthy)
}
qc.UpdateStateCode(internalpb.StateCode_StandBy)
qc.UpdateStateCode(commonpb.StateCode_StandBy)
} else {
qc.UpdateStateCode(internalpb.StateCode_Healthy)
qc.UpdateStateCode(commonpb.StateCode_Healthy)
}
return nil
@ -281,7 +280,7 @@ func (qc *QueryCoord) Start() error {
// Stop function stops watching the meta and node updates
func (qc *QueryCoord) Stop() error {
qc.UpdateStateCode(internalpb.StateCode_Abnormal)
qc.UpdateStateCode(commonpb.StateCode_Abnormal)
if qc.scheduler != nil {
log.Info("close scheduler...")
@ -310,7 +309,7 @@ func (qc *QueryCoord) Stop() error {
}
// UpdateStateCode updates the status of the coord, including healthy, unhealthy
func (qc *QueryCoord) UpdateStateCode(code internalpb.StateCode) {
func (qc *QueryCoord) UpdateStateCode(code commonpb.StateCode) {
qc.stateCode.Store(code)
}
@ -328,7 +327,7 @@ func NewQueryCoord(ctx context.Context, factory dependency.Factory) (*QueryCoord
enableActiveStandBy: Params.QueryCoordCfg.EnableActiveStandby,
}
service.UpdateStateCode(internalpb.StateCode_Abnormal)
service.UpdateStateCode(commonpb.StateCode_Abnormal)
return service, nil
}

5
internal/querycoord/query_coord_test.go
View File

@ -40,7 +40,6 @@ import (
"github.com/milvus-io/milvus/api/milvuspb"
etcdkv "github.com/milvus-io/milvus/internal/kv/etcd"
"github.com/milvus-io/milvus/internal/log"
"github.com/milvus-io/milvus/internal/proto/internalpb"
"github.com/milvus-io/milvus/internal/proto/querypb"
"github.com/milvus-io/milvus/internal/util"
"github.com/milvus-io/milvus/internal/util/dependency"
@ -130,7 +129,7 @@ func TestQueryCoord_DisableActiveStandby(t *testing.T) {
resp, err := queryCoord.GetComponentStates(ctx)
assert.Nil(t, err)
assert.Equal(t, commonpb.ErrorCode_Success, resp.GetStatus().GetErrorCode())
assert.Equal(t, internalpb.StateCode_Healthy, resp.GetState().GetStateCode())
assert.Equal(t, commonpb.StateCode_Healthy, resp.GetState().GetStateCode())
defer queryCoord.Stop()
}
@ -144,7 +143,7 @@ func TestQueryCoord_EnableActiveStandby(t *testing.T) {
resp, err := queryCoord.GetComponentStates(ctx)
assert.Nil(t, err)
assert.Equal(t, commonpb.ErrorCode_Success, resp.GetStatus().GetErrorCode())
assert.Equal(t, internalpb.StateCode_Healthy, resp.GetState().GetStateCode())
assert.Equal(t, commonpb.StateCode_Healthy, resp.GetState().GetStateCode())
defer queryCoord.Stop()
}

13
internal/querycoord/querynode.go
View File

@ -30,7 +30,6 @@ import (
nodeclient "github.com/milvus-io/milvus/internal/distributed/querynode/client"
etcdkv "github.com/milvus-io/milvus/internal/kv/etcd"
"github.com/milvus-io/milvus/internal/log"
"github.com/milvus-io/milvus/internal/proto/internalpb"
"github.com/milvus-io/milvus/internal/proto/querypb"
"github.com/milvus-io/milvus/internal/types"
"github.com/milvus-io/milvus/internal/util/metricsinfo"
@ -55,7 +54,7 @@ type Node interface {
getSegmentInfo(ctx context.Context, in *querypb.GetSegmentInfoRequest) (*querypb.GetSegmentInfoResponse, error)
loadSegments(ctx context.Context, in *querypb.LoadSegmentsRequest) error
releaseSegments(ctx context.Context, in *querypb.ReleaseSegmentsRequest) error
getComponentInfo(ctx context.Context) *internalpb.ComponentInfo
getComponentInfo(ctx context.Context) *milvuspb.ComponentInfo
getMetrics(ctx context.Context, in *milvuspb.GetMetricsRequest) (*milvuspb.GetMetricsResponse, error)
}
@ -217,19 +216,19 @@ func (qn *queryNode) getSegmentInfo(ctx context.Context, in *querypb.GetSegmentI
return res, nil
}
func (qn *queryNode) getComponentInfo(ctx context.Context) *internalpb.ComponentInfo {
func (qn *queryNode) getComponentInfo(ctx context.Context) *milvuspb.ComponentInfo {
if !qn.isOnline() {
return &internalpb.ComponentInfo{
return &milvuspb.ComponentInfo{
NodeID: qn.id,
StateCode: internalpb.StateCode_Abnormal,
StateCode: commonpb.StateCode_Abnormal,
}
}
res, err := qn.client.GetComponentStates(qn.ctx)
if err != nil || res.Status.ErrorCode != commonpb.ErrorCode_Success {
return &internalpb.ComponentInfo{
return &milvuspb.ComponentInfo{
NodeID: qn.id,
StateCode: internalpb.StateCode_Abnormal,
StateCode: commonpb.StateCode_Abnormal,
}
}

3
internal/querycoord/querynode_test.go
View File

@ -28,7 +28,6 @@ import (
"github.com/milvus-io/milvus/api/milvuspb"
etcdkv "github.com/milvus-io/milvus/internal/kv/etcd"
"github.com/milvus-io/milvus/internal/log"
"github.com/milvus-io/milvus/internal/proto/internalpb"
"github.com/milvus-io/milvus/internal/proto/querypb"
"github.com/milvus-io/milvus/internal/util/etcd"
"github.com/milvus-io/milvus/internal/util/typeutil"
@ -335,7 +334,7 @@ func TestGrpcRequestWithNodeOffline(t *testing.T) {
t.Run("Test getComponentInfo", func(t *testing.T) {
res := node.getComponentInfo(baseCtx)
assert.Equal(t, internalpb.StateCode_Abnormal, res.StateCode)
assert.Equal(t, commonpb.StateCode_Abnormal, res.StateCode)
})
t.Run("Test getMetrics", func(t *testing.T) {

16
internal/querycoordv2/mocks/mock_querynode.go
View File

@ -30,20 +30,20 @@ func (_m *MockQueryNodeServer) EXPECT() *MockQueryNodeServer_Expecter {
}
// GetComponentStates provides a mock function with given fields: _a0, _a1
func (_m *MockQueryNodeServer) GetComponentStates(_a0 context.Context, _a1 *internalpb.GetComponentStatesRequest) (*internalpb.ComponentStates, error) {
func (_m *MockQueryNodeServer) GetComponentStates(_a0 context.Context, _a1 *milvuspb.GetComponentStatesRequest) (*milvuspb.ComponentStates, error) {
ret := _m.Called(_a0, _a1)
var r0 *internalpb.ComponentStates
if rf, ok := ret.Get(0).(func(context.Context, *internalpb.GetComponentStatesRequest) *internalpb.ComponentStates); ok {
var r0 *milvuspb.ComponentStates
if rf, ok := ret.Get(0).(func(context.Context, *milvuspb.GetComponentStatesRequest) *milvuspb.ComponentStates); ok {
r0 = rf(_a0, _a1)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*internalpb.ComponentStates)
r0 = ret.Get(0).(*milvuspb.ComponentStates)
}
}
var r1 error
if rf, ok := ret.Get(1).(func(context.Context, *internalpb.GetComponentStatesRequest) error); ok {
if rf, ok := ret.Get(1).(func(context.Context, *milvuspb.GetComponentStatesRequest) error); ok {
r1 = rf(_a0, _a1)
} else {
r1 = ret.Error(1)
@ -64,14 +64,14 @@ func (_e *MockQueryNodeServer_Expecter) GetComponentStates(_a0 interface{}, _a1
return &MockQueryNodeServer_GetComponentStates_Call{Call: _e.mock.On("GetComponentStates", _a0, _a1)}
}
func (_c *MockQueryNodeServer_GetComponentStates_Call) Run(run func(_a0 context.Context, _a1 *internalpb.GetComponentStatesRequest)) *MockQueryNodeServer_GetComponentStates_Call {
func (_c *MockQueryNodeServer_GetComponentStates_Call) Run(run func(_a0 context.Context, _a1 *milvuspb.GetComponentStatesRequest)) *MockQueryNodeServer_GetComponentStates_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(context.Context), args[1].(*internalpb.GetComponentStatesRequest))
run(args[0].(context.Context), args[1].(*milvuspb.GetComponentStatesRequest))
})
return _c
}
func (_c *MockQueryNodeServer_GetComponentStates_Call) Return(_a0 *internalpb.ComponentStates, _a1 error) *MockQueryNodeServer_GetComponentStates_Call {
func (_c *MockQueryNodeServer_GetComponentStates_Call) Return(_a0 *milvuspb.ComponentStates, _a1 error) *MockQueryNodeServer_GetComponentStates_Call {
_c.Call.Return(_a0, _a1)
return _c
}

15
internal/querycoordv2/server.go
View File

@ -23,7 +23,6 @@ import (
"github.com/milvus-io/milvus/internal/kv"
etcdkv "github.com/milvus-io/milvus/internal/kv/etcd"
"github.com/milvus-io/milvus/internal/log"
"github.com/milvus-io/milvus/internal/proto/internalpb"
"github.com/milvus-io/milvus/internal/proto/querypb"
"github.com/milvus-io/milvus/internal/querycoordv2/balance"
"github.com/milvus-io/milvus/internal/querycoordv2/checkers"
@ -101,7 +100,7 @@ func NewQueryCoord(ctx context.Context, factory dependency.Factory) (*Server, er
cancel: cancel,
factory: factory,
}
server.UpdateStateCode(internalpb.StateCode_Abnormal)
server.UpdateStateCode(commonpb.StateCode_Abnormal)
return server, nil
}
@ -310,7 +309,7 @@ func (s *Server) Start() error {
panic(err.Error())
}
s.status.Store(internalpb.StateCode_Healthy)
s.status.Store(commonpb.StateCode_Healthy)
log.Info("QueryCoord started")
return nil
@ -345,22 +344,22 @@ func (s *Server) Stop() error {
}
// UpdateStateCode updates the status of the coord, including healthy, unhealthy
func (s *Server) UpdateStateCode(code internalpb.StateCode) {
func (s *Server) UpdateStateCode(code commonpb.StateCode) {
s.status.Store(code)
}
func (s *Server) GetComponentStates(ctx context.Context) (*internalpb.ComponentStates, error) {
func (s *Server) GetComponentStates(ctx context.Context) (*milvuspb.ComponentStates, error) {
nodeID := common.NotRegisteredID
if s.session != nil && s.session.Registered() {
nodeID = s.session.ServerID
}
serviceComponentInfo := &internalpb.ComponentInfo{
serviceComponentInfo := &milvuspb.ComponentInfo{
// NodeID: Params.QueryCoordID, // will race with QueryCoord.Register()
NodeID: nodeID,
StateCode: s.status.Load().(internalpb.StateCode),
StateCode: s.status.Load().(commonpb.StateCode),
}
return &internalpb.ComponentStates{
return &milvuspb.ComponentStates{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_Success,
},

26
internal/querycoordv2/services.go
View File

@ -30,7 +30,7 @@ func (s *Server) ShowCollections(ctx context.Context, req *querypb.ShowCollectio
log.Info("show collections request received", zap.Int64s("collections", req.GetCollectionIDs()))
if s.status.Load() != internalpb.StateCode_Healthy {
if s.status.Load() != commonpb.StateCode_Healthy {
msg := "failed to show collections"
log.Warn(msg, zap.Error(ErrNotHealthy))
return &querypb.ShowCollectionsResponse{
@ -89,7 +89,7 @@ func (s *Server) ShowPartitions(ctx context.Context, req *querypb.ShowPartitions
log.Info("show partitions request received", zap.Int64s("partitions", req.GetPartitionIDs()))
if s.status.Load() != internalpb.StateCode_Healthy {
if s.status.Load() != commonpb.StateCode_Healthy {
msg := "failed to show partitions"
log.Warn(msg, zap.Error(ErrNotHealthy))
return &querypb.ShowPartitionsResponse{
@ -170,7 +170,7 @@ func (s *Server) LoadCollection(ctx context.Context, req *querypb.LoadCollection
zap.Int32("replicaNumber", req.ReplicaNumber))
metrics.QueryCoordLoadCount.WithLabelValues(metrics.TotalLabel).Inc()
if s.status.Load() != internalpb.StateCode_Healthy {
if s.status.Load() != commonpb.StateCode_Healthy {
msg := "failed to load collection"
log.Warn(msg, zap.Error(ErrNotHealthy))
metrics.QueryCoordLoadCount.WithLabelValues(metrics.FailLabel).Inc()
@ -209,7 +209,7 @@ func (s *Server) ReleaseCollection(ctx context.Context, req *querypb.ReleaseColl
metrics.QueryCoordReleaseCount.WithLabelValues(metrics.TotalLabel).Inc()
tr := timerecord.NewTimeRecorder("release-collection")
if s.status.Load() != internalpb.StateCode_Healthy {
if s.status.Load() != commonpb.StateCode_Healthy {
msg := "failed to release collection"
log.Warn(msg, zap.Error(ErrNotHealthy))
metrics.QueryCoordReleaseCount.WithLabelValues(metrics.FailLabel).Inc()
@ -250,7 +250,7 @@ func (s *Server) LoadPartitions(ctx context.Context, req *querypb.LoadPartitions
zap.Int64s("partitions", req.GetPartitionIDs()))
metrics.QueryCoordLoadCount.WithLabelValues(metrics.TotalLabel).Inc()
if s.status.Load() != internalpb.StateCode_Healthy {
if s.status.Load() != commonpb.StateCode_Healthy {
msg := "failed to load partitions"
log.Warn(msg, zap.Error(ErrNotHealthy))
metrics.QueryCoordLoadCount.WithLabelValues(metrics.FailLabel).Inc()
@ -288,7 +288,7 @@ func (s *Server) ReleasePartitions(ctx context.Context, req *querypb.ReleasePart
log.Info("release partitions", zap.Int64s("partitions", req.GetPartitionIDs()))
metrics.QueryCoordReleaseCount.WithLabelValues(metrics.TotalLabel).Inc()
if s.status.Load() != internalpb.StateCode_Healthy {
if s.status.Load() != commonpb.StateCode_Healthy {
msg := "failed to release partitions"
log.Warn(msg, zap.Error(ErrNotHealthy))
metrics.QueryCoordReleaseCount.WithLabelValues(metrics.FailLabel).Inc()
@ -332,7 +332,7 @@ func (s *Server) GetPartitionStates(ctx context.Context, req *querypb.GetPartiti
log.Info("get partition states", zap.Int64s("partitions", req.GetPartitionIDs()))
if s.status.Load() != internalpb.StateCode_Healthy {
if s.status.Load() != commonpb.StateCode_Healthy {
msg := "failed to get partition states"
log.Warn(msg, zap.Error(ErrNotHealthy))
return &querypb.GetPartitionStatesResponse{
@ -401,7 +401,7 @@ func (s *Server) GetSegmentInfo(ctx context.Context, req *querypb.GetSegmentInfo
log.Info("get segment info", zap.Int64s("segments", req.GetSegmentIDs()))
if s.status.Load() != internalpb.StateCode_Healthy {
if s.status.Load() != commonpb.StateCode_Healthy {
msg := "failed to get segment info"
log.Warn(msg, zap.Error(ErrNotHealthy))
return &querypb.GetSegmentInfoResponse{
@ -445,7 +445,7 @@ func (s *Server) LoadBalance(ctx context.Context, req *querypb.LoadBalanceReques
zap.Int64s("dest", req.GetDstNodeIDs()),
zap.Int64s("segments", req.GetSealedSegmentIDs()))
if s.status.Load() != internalpb.StateCode_Healthy {
if s.status.Load() != commonpb.StateCode_Healthy {
msg := "failed to load balance"
log.Warn(msg, zap.Error(ErrNotHealthy))
return utils.WrapStatus(commonpb.ErrorCode_UnexpectedError, msg, ErrNotHealthy), nil
@ -493,7 +493,7 @@ func (s *Server) ShowConfigurations(ctx context.Context, req *internalpb.ShowCon
log.Debug("show configurations request received", zap.String("pattern", req.GetPattern()))
if s.status.Load() != internalpb.StateCode_Healthy {
if s.status.Load() != commonpb.StateCode_Healthy {
msg := "failed to show configurations"
log.Warn(msg, zap.Error(ErrNotHealthy))
return &internalpb.ShowConfigurationsResponse{
@ -527,7 +527,7 @@ func (s *Server) GetMetrics(ctx context.Context, req *milvuspb.GetMetricsRequest
log.Info("get metrics request received",
zap.String("metricType", req.GetRequest()))
if s.status.Load() != internalpb.StateCode_Healthy {
if s.status.Load() != commonpb.StateCode_Healthy {
msg := "failed to get metrics"
log.Warn(msg, zap.Error(ErrNotHealthy))
return &milvuspb.GetMetricsResponse{
@ -582,7 +582,7 @@ func (s *Server) GetReplicas(ctx context.Context, req *milvuspb.GetReplicasReque
log.Info("get replicas request received", zap.Bool("with-shard-nodes", req.GetWithShardNodes()))
if s.status.Load() != internalpb.StateCode_Healthy {
if s.status.Load() != commonpb.StateCode_Healthy {
msg := "failed to get replicas"
log.Warn(msg, zap.Error(ErrNotHealthy))
return &milvuspb.GetReplicasResponse{
@ -624,7 +624,7 @@ func (s *Server) GetShardLeaders(ctx context.Context, req *querypb.GetShardLeade
)
log.Info("get shard leaders request received")
if s.status.Load() != internalpb.StateCode_Healthy {
if s.status.Load() != commonpb.StateCode_Healthy {
msg := "failed to get shard leaders"
log.Warn(msg, zap.Error(ErrNotHealthy))
return &querypb.GetShardLeadersResponse{

28
internal/querycoordv2/services_test.go
View File

@ -140,7 +140,7 @@ func (suite *ServiceSuite) SetupTest() {
balancer: suite.balancer,
handoffObserver: suite.handoffObserver,
}
suite.server.UpdateStateCode(internalpb.StateCode_Healthy)
suite.server.UpdateStateCode(commonpb.StateCode_Healthy)
}
func (suite *ServiceSuite) TestShowCollections() {
@ -169,7 +169,7 @@ func (suite *ServiceSuite) TestShowCollections() {
suite.Equal(collection, resp.CollectionIDs[0])
// Test when server is not healthy
server.UpdateStateCode(internalpb.StateCode_Initializing)
server.UpdateStateCode(commonpb.StateCode_Initializing)
resp, err = server.ShowCollections(ctx, req)
suite.NoError(err)
suite.Contains(resp.Status.Reason, ErrNotHealthy.Error())
@ -214,7 +214,7 @@ func (suite *ServiceSuite) TestShowPartitions() {
req := &querypb.ShowPartitionsRequest{
CollectionID: suite.collections[0],
}
server.UpdateStateCode(internalpb.StateCode_Initializing)
server.UpdateStateCode(commonpb.StateCode_Initializing)
resp, err := server.ShowPartitions(ctx, req)
suite.NoError(err)
suite.Contains(resp.Status.Reason, ErrNotHealthy.Error())
@ -249,7 +249,7 @@ func (suite *ServiceSuite) TestLoadCollection() {
}
// Test when server is not healthy
server.UpdateStateCode(internalpb.StateCode_Initializing)
server.UpdateStateCode(commonpb.StateCode_Initializing)
req := &querypb.LoadCollectionRequest{
CollectionID: suite.collections[0],
}
@ -321,7 +321,7 @@ func (suite *ServiceSuite) TestLoadPartition() {
}
// Test when server is not healthy
server.UpdateStateCode(internalpb.StateCode_Initializing)
server.UpdateStateCode(commonpb.StateCode_Initializing)
req := &querypb.LoadPartitionsRequest{
CollectionID: suite.collections[0],
PartitionIDs: suite.partitions[suite.collections[0]],
@ -407,7 +407,7 @@ func (suite *ServiceSuite) TestReleaseCollection() {
}
// Test when server is not healthy
server.UpdateStateCode(internalpb.StateCode_Initializing)
server.UpdateStateCode(commonpb.StateCode_Initializing)
req := &querypb.ReleaseCollectionRequest{
CollectionID: suite.collections[0],
}
@ -454,7 +454,7 @@ func (suite *ServiceSuite) TestReleasePartition() {
}
// Test when server is not healthy
server.UpdateStateCode(internalpb.StateCode_Initializing)
server.UpdateStateCode(commonpb.StateCode_Initializing)
req := &querypb.ReleasePartitionsRequest{
CollectionID: suite.collections[0],
PartitionIDs: suite.partitions[suite.collections[0]][0:1],
@ -482,7 +482,7 @@ func (suite *ServiceSuite) TestGetPartitionStates() {
}
// Test when server is not healthy
server.UpdateStateCode(internalpb.StateCode_Initializing)
server.UpdateStateCode(commonpb.StateCode_Initializing)
req := &querypb.GetPartitionStatesRequest{
CollectionID: suite.collections[0],
}
@ -521,7 +521,7 @@ func (suite *ServiceSuite) TestGetSegmentInfo() {
}
// Test when server is not healthy
server.UpdateStateCode(internalpb.StateCode_Initializing)
server.UpdateStateCode(commonpb.StateCode_Initializing)
req := &querypb.GetSegmentInfoRequest{
CollectionID: suite.collections[0],
}
@ -565,7 +565,7 @@ func (suite *ServiceSuite) TestLoadBalance() {
}
// Test when server is not healthy
server.UpdateStateCode(internalpb.StateCode_Initializing)
server.UpdateStateCode(commonpb.StateCode_Initializing)
req := &querypb.LoadBalanceRequest{
CollectionID: suite.collections[0],
SourceNodeIDs: []int64{1},
@ -680,7 +680,7 @@ func (suite *ServiceSuite) TestShowConfigurations() {
suite.Equal("querycoord.port", resp.Configuations[0].Key)
// Test when server is not healthy
server.UpdateStateCode(internalpb.StateCode_Initializing)
server.UpdateStateCode(commonpb.StateCode_Initializing)
req = &internalpb.ShowConfigurationsRequest{
Pattern: "Port",
}
@ -712,7 +712,7 @@ func (suite *ServiceSuite) TestGetMetrics() {
suite.Equal(commonpb.ErrorCode_Success, resp.Status.ErrorCode)
// Test when server is not healthy
server.UpdateStateCode(internalpb.StateCode_Initializing)
server.UpdateStateCode(commonpb.StateCode_Initializing)
resp, err = server.GetMetrics(ctx, &milvuspb.GetMetricsRequest{
Base: &commonpb.MsgBase{},
Request: string(req),
@ -755,7 +755,7 @@ func (suite *ServiceSuite) TestGetReplicas() {
}
// Test when server is not healthy
server.UpdateStateCode(internalpb.StateCode_Initializing)
server.UpdateStateCode(commonpb.StateCode_Initializing)
req := &milvuspb.GetReplicasRequest{
CollectionID: suite.collections[0],
}
@ -785,7 +785,7 @@ func (suite *ServiceSuite) TestGetShardLeaders() {
}
// Test when server is not healthy
server.UpdateStateCode(internalpb.StateCode_Initializing)
server.UpdateStateCode(commonpb.StateCode_Initializing)
req := &querypb.GetShardLeadersRequest{
CollectionID: suite.collections[0],
}

44
internal/querynode/impl.go
View File

@ -40,13 +40,13 @@ import (
)
// GetComponentStates returns information about whether the node is healthy
func (node *QueryNode) GetComponentStates(ctx context.Context) (*internalpb.ComponentStates, error) {
stats := &internalpb.ComponentStates{
func (node *QueryNode) GetComponentStates(ctx context.Context) (*milvuspb.ComponentStates, error) {
stats := &milvuspb.ComponentStates{
Status: &commonpb.Status{
ErrorCode: commonpb.ErrorCode_Success,
},
}
code, ok := node.stateCode.Load().(internalpb.StateCode)
code, ok := node.stateCode.Load().(commonpb.StateCode)
if !ok {
errMsg := "unexpected error in type assertion"
stats.Status = &commonpb.Status{
@ -59,7 +59,7 @@ func (node *QueryNode) GetComponentStates(ctx context.Context) (*internalpb.Comp
if node.session != nil && node.session.Registered() {
nodeID = node.session.ServerID
}
info := &internalpb.ComponentInfo{
info := &milvuspb.ComponentInfo{
NodeID: nodeID,
Role: typeutil.QueryNodeRole,
StateCode: code,
@ -280,8 +280,8 @@ func (node *QueryNode) getStatisticsWithDmlChannel(ctx context.Context, req *que
// WatchDmChannels create consumers on dmChannels to receive Incremental data，which is the important part of real-time query
func (node *QueryNode) WatchDmChannels(ctx context.Context, in *querypb.WatchDmChannelsRequest) (*commonpb.Status, error) {
// check node healthy
code := node.stateCode.Load().(internalpb.StateCode)
if code != internalpb.StateCode_Healthy {
code := node.stateCode.Load().(commonpb.StateCode)
if code != commonpb.StateCode_Healthy {
err := fmt.Errorf("query node %d is not ready", Params.QueryNodeCfg.GetNodeID())
status := &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
@ -347,8 +347,8 @@ func (node *QueryNode) WatchDmChannels(ctx context.Context, in *querypb.WatchDmC
func (node *QueryNode) UnsubDmChannel(ctx context.Context, req *querypb.UnsubDmChannelRequest) (*commonpb.Status, error) {
// check node healthy
code := node.stateCode.Load().(internalpb.StateCode)
if code != internalpb.StateCode_Healthy {
code := node.stateCode.Load().(commonpb.StateCode)
if code != commonpb.StateCode_Healthy {
err := fmt.Errorf("query node %d is not ready", Params.QueryNodeCfg.GetNodeID())
status := &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
@ -408,8 +408,8 @@ func (node *QueryNode) UnsubDmChannel(ctx context.Context, req *querypb.UnsubDmC
// LoadSegments load historical data into query node, historical data can be vector data or index
func (node *QueryNode) LoadSegments(ctx context.Context, in *querypb.LoadSegmentsRequest) (*commonpb.Status, error) {
// check node healthy
code := node.stateCode.Load().(internalpb.StateCode)
if code != internalpb.StateCode_Healthy {
code := node.stateCode.Load().(commonpb.StateCode)
if code != commonpb.StateCode_Healthy {
err := fmt.Errorf("query node %d is not ready", Params.QueryNodeCfg.GetNodeID())
status := &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
@ -476,8 +476,8 @@ func (node *QueryNode) LoadSegments(ctx context.Context, in *querypb.LoadSegment
// ReleaseCollection clears all data related to this collection on the querynode
func (node *QueryNode) ReleaseCollection(ctx context.Context, in *querypb.ReleaseCollectionRequest) (*commonpb.Status, error) {
code := node.stateCode.Load().(internalpb.StateCode)
if code != internalpb.StateCode_Healthy {
code := node.stateCode.Load().(commonpb.StateCode)
if code != commonpb.StateCode_Healthy {
err := fmt.Errorf("query node %d is not ready", Params.QueryNodeCfg.GetNodeID())
status := &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
@ -522,8 +522,8 @@ func (node *QueryNode) ReleaseCollection(ctx context.Context, in *querypb.Releas
// ReleasePartitions clears all data related to this partition on the querynode
func (node *QueryNode) ReleasePartitions(ctx context.Context, in *querypb.ReleasePartitionsRequest) (*commonpb.Status, error) {
code := node.stateCode.Load().(internalpb.StateCode)
if code != internalpb.StateCode_Healthy {
code := node.stateCode.Load().(commonpb.StateCode)
if code != commonpb.StateCode_Healthy {
err := fmt.Errorf("query node %d is not ready", Params.QueryNodeCfg.GetNodeID())
status := &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
@ -569,8 +569,8 @@ func (node *QueryNode) ReleasePartitions(ctx context.Context, in *querypb.Releas
// ReleaseSegments remove the specified segments from query node according segmentIDs, partitionIDs, and collectionID
func (node *QueryNode) ReleaseSegments(ctx context.Context, in *querypb.ReleaseSegmentsRequest) (*commonpb.Status, error) {
// check node healthy
code := node.stateCode.Load().(internalpb.StateCode)
if code != internalpb.StateCode_Healthy {
code := node.stateCode.Load().(commonpb.StateCode)
if code != commonpb.StateCode_Healthy {
err := fmt.Errorf("query node %d is not ready", Params.QueryNodeCfg.GetNodeID())
status := &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,
@ -611,8 +611,8 @@ func (node *QueryNode) ReleaseSegments(ctx context.Context, in *querypb.ReleaseS
// GetSegmentInfo returns segment information of the collection on the queryNode, and the information includes memSize, numRow, indexName, indexID ...
func (node *QueryNode) GetSegmentInfo(ctx context.Context, in *querypb.GetSegmentInfoRequest) (*querypb.GetSegmentInfoResponse, error) {
code := node.stateCode.Load().(internalpb.StateCode)
if code != internalpb.StateCode_Healthy {
code := node.stateCode.Load().(commonpb.StateCode)
if code != commonpb.StateCode_Healthy {
err := fmt.Errorf("query node %d is not ready", Params.QueryNodeCfg.GetNodeID())
res := &querypb.GetSegmentInfoResponse{
Status: &commonpb.Status{
@ -658,8 +658,8 @@ func filterSegmentInfo(segmentInfos []*querypb.SegmentInfo, segmentIDs map[int64
// isHealthy checks if QueryNode is healthy
func (node *QueryNode) isHealthy() bool {
code := node.stateCode.Load().(internalpb.StateCode)
return code == internalpb.StateCode_Healthy
code := node.stateCode.Load().(commonpb.StateCode)
return code == commonpb.StateCode_Healthy
}
// Search performs replica search tasks.
@ -1275,8 +1275,8 @@ func (node *QueryNode) GetDataDistribution(ctx context.Context, req *querypb.Get
func (node *QueryNode) SyncDistribution(ctx context.Context, req *querypb.SyncDistributionRequest) (*commonpb.Status, error) {
log := log.Ctx(ctx).With(zap.Int64("collectionID", req.GetCollectionID()), zap.String("channel", req.GetChannel()))
// check node healthy
code := node.stateCode.Load().(internalpb.StateCode)
if code != internalpb.StateCode_Healthy {
code := node.stateCode.Load().(commonpb.StateCode)
if code != commonpb.StateCode_Healthy {
err := fmt.Errorf("query node %d is not ready", Params.QueryNodeCfg.GetNodeID())
status := &commonpb.Status{
ErrorCode: commonpb.ErrorCode_UnexpectedError,

28
internal/querynode/impl_test.go
View File

@ -51,7 +51,7 @@ func TestImpl_GetComponentStates(t *testing.T) {
assert.NoError(t, err)
assert.Equal(t, commonpb.ErrorCode_Success, rsp.Status.ErrorCode)
node.UpdateStateCode(internalpb.StateCode_Abnormal)
node.UpdateStateCode(commonpb.StateCode_Abnormal)
rsp, err = node.GetComponentStates(ctx)
assert.NoError(t, err)
assert.Equal(t, commonpb.ErrorCode_Success, rsp.Status.ErrorCode)
@ -136,7 +136,7 @@ func TestImpl_WatchDmChannels(t *testing.T) {
MsgID: rand.Int63(),
},
}
node.UpdateStateCode(internalpb.StateCode_Abnormal)
node.UpdateStateCode(commonpb.StateCode_Abnormal)
status, err := node.WatchDmChannels(ctx, req)
assert.NoError(t, err)
assert.Equal(t, commonpb.ErrorCode_UnexpectedError, status.ErrorCode)
@ -169,7 +169,7 @@ func TestImpl_UnsubDmChannel(t *testing.T) {
MsgID: rand.Int63(),
},
}
node.UpdateStateCode(internalpb.StateCode_Abnormal)
node.UpdateStateCode(commonpb.StateCode_Abnormal)
status, err := node.UnsubDmChannel(ctx, req)
assert.NoError(t, err)
assert.Equal(t, commonpb.ErrorCode_UnexpectedError, status.ErrorCode)
@ -214,7 +214,7 @@ func TestImpl_LoadSegments(t *testing.T) {
})
t.Run("server unhealthy", func(t *testing.T) {
node.UpdateStateCode(internalpb.StateCode_Abnormal)
node.UpdateStateCode(commonpb.StateCode_Abnormal)
status, err := node.LoadSegments(ctx, req)
assert.NoError(t, err)
assert.Equal(t, commonpb.ErrorCode_UnexpectedError, status.ErrorCode)
@ -240,7 +240,7 @@ func TestImpl_ReleaseCollection(t *testing.T) {
assert.NoError(t, err)
assert.Equal(t, commonpb.ErrorCode_Success, status.ErrorCode)
node.UpdateStateCode(internalpb.StateCode_Abnormal)
node.UpdateStateCode(commonpb.StateCode_Abnormal)
status, err = node.ReleaseCollection(ctx, req)
assert.NoError(t, err)
assert.Equal(t, commonpb.ErrorCode_UnexpectedError, status.ErrorCode)
@ -266,7 +266,7 @@ func TestImpl_ReleasePartitions(t *testing.T) {
assert.NoError(t, err)
assert.Equal(t, commonpb.ErrorCode_Success, status.ErrorCode)
node.UpdateStateCode(internalpb.StateCode_Abnormal)
node.UpdateStateCode(commonpb.StateCode_Abnormal)
status, err = node.ReleasePartitions(ctx, req)
assert.NoError(t, err)
assert.Equal(t, commonpb.ErrorCode_UnexpectedError, status.ErrorCode)
@ -299,7 +299,7 @@ func TestImpl_GetSegmentInfo(t *testing.T) {
assert.Equal(t, commonpb.ErrorCode_Success, rsp.Status.ErrorCode)
assert.Equal(t, 0, len(rsp.GetInfos()))
node.UpdateStateCode(internalpb.StateCode_Abnormal)
node.UpdateStateCode(commonpb.StateCode_Abnormal)
rsp, err = node.GetSegmentInfo(ctx, req)
assert.NoError(t, err)
assert.Equal(t, commonpb.ErrorCode_UnexpectedError, rsp.Status.ErrorCode)
@ -386,7 +386,7 @@ func TestImpl_GetSegmentInfo(t *testing.T) {
assert.NoError(t, err)
assert.Equal(t, commonpb.ErrorCode_Success, rsp.Status.ErrorCode)
node.UpdateStateCode(internalpb.StateCode_Abnormal)
node.UpdateStateCode(commonpb.StateCode_Abnormal)
rsp, err = node.GetSegmentInfo(ctx, req)
assert.NoError(t, err)
assert.Equal(t, commonpb.ErrorCode_UnexpectedError, rsp.Status.ErrorCode)
@ -430,7 +430,7 @@ func TestImpl_ShowConfigurations(t *testing.T) {
node, err := genSimpleQueryNode(ctx)
assert.NoError(t, err)
node.session = sessionutil.NewSession(node.queryNodeLoopCtx, Params.EtcdCfg.MetaRootPath, etcdCli)
node.UpdateStateCode(internalpb.StateCode_Abnormal)
node.UpdateStateCode(commonpb.StateCode_Abnormal)
pattern := "Cache"
req := &internalpb.ShowConfigurationsRequest{
@ -493,7 +493,7 @@ func TestImpl_GetMetrics(t *testing.T) {
_, err = node.GetMetrics(ctx, req)
assert.NoError(t, err)
node.UpdateStateCode(internalpb.StateCode_Abnormal)
node.UpdateStateCode(commonpb.StateCode_Abnormal)
_, err = node.GetMetrics(ctx, req)
assert.NoError(t, err)
})
@ -539,7 +539,7 @@ func TestImpl_ReleaseSegments(t *testing.T) {
SegmentIDs: []UniqueID{defaultSegmentID},
}
node.UpdateStateCode(internalpb.StateCode_Abnormal)
node.UpdateStateCode(commonpb.StateCode_Abnormal)
resp, err := node.ReleaseSegments(ctx, req)
assert.NoError(t, err)
assert.Equal(t, commonpb.ErrorCode_UnexpectedError, resp.GetErrorCode())
@ -782,7 +782,7 @@ func TestImpl_SyncReplicaSegments(t *testing.T) {
defer node.Stop()
assert.NoError(t, err)
node.UpdateStateCode(internalpb.StateCode_Abnormal)
node.UpdateStateCode(commonpb.StateCode_Abnormal)
resp, err := node.SyncReplicaSegments(ctx, &querypb.SyncReplicaSegmentsRequest{})
assert.NoError(t, err)
@ -856,7 +856,7 @@ func TestSyncDistribution(t *testing.T) {
defer node.Stop()
assert.NoError(t, err)
node.UpdateStateCode(internalpb.StateCode_Abnormal)
node.UpdateStateCode(commonpb.StateCode_Abnormal)
resp, err := node.SyncDistribution(ctx, &querypb.SyncDistributionRequest{})
assert.NoError(t, err)
@ -979,7 +979,7 @@ func TestGetDataDistribution(t *testing.T) {
defer node.Stop()
assert.NoError(t, err)
node.UpdateStateCode(internalpb.StateCode_Abnormal)
node.UpdateStateCode(commonpb.StateCode_Abnormal)
resp, err := node.GetDataDistribution(ctx, &querypb.GetDataDistributionRequest{})
assert.NoError(t, err)

2
internal/querynode/mock_test.go
View File

@ -1749,7 +1749,7 @@ func genSimpleQueryNodeWithMQFactory(ctx context.Context, fac dependency.Factory
return nil, err
}
node.UpdateStateCode(internalpb.StateCode_Healthy)
node.UpdateStateCode(commonpb.StateCode_Healthy)
return node, nil
}

Some files were not shown because too many files have changed in this diff Show More