diff --git a/pkg/kvrpcpb/kvrpcpb.pb.go b/pkg/kvrpcpb/kvrpcpb.pb.go index 3d81c5c24..169cc302a 100644 --- a/pkg/kvrpcpb/kvrpcpb.pb.go +++ b/pkg/kvrpcpb/kvrpcpb.pb.go @@ -6322,10 +6322,13 @@ type ResourceControlContext struct { ResourceGroupName string `protobuf:"bytes,1,opt,name=resource_group_name,json=resourceGroupName,proto3" json:"resource_group_name,omitempty"` // The resource consumption of the resource group that have completed at all TiKVs between the previous request to this TiKV and current request. // It's used as penalty to make the local resource scheduling on one TiKV takes the gloabl resource consumption into consideration. - Penalty *resource_manager.Consumption `protobuf:"bytes,2,opt,name=penalty,proto3" json:"penalty,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + Penalty *resource_manager.Consumption `protobuf:"bytes,2,opt,name=penalty,proto3" json:"penalty,omitempty"` + // This priority would override the original priority of the resource group for the request. + // Used to deprioritize the runaway queries. + OverridePriority uint64 `protobuf:"varint,3,opt,name=override_priority,json=overridePriority,proto3" json:"override_priority,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } func (m *ResourceControlContext) Reset() { *m = ResourceControlContext{} } @@ -6375,6 +6378,13 @@ func (m *ResourceControlContext) GetPenalty() *resource_manager.Consumption { return nil } +func (m *ResourceControlContext) GetOverridePriority() uint64 { + if m != nil { + return m.OverridePriority + } + return 0 +} + type LockInfo struct { PrimaryLock []byte `protobuf:"bytes,1,opt,name=primary_lock,json=primaryLock,proto3" json:"primary_lock,omitempty"` LockVersion uint64 `protobuf:"varint,2,opt,name=lock_version,json=lockVersion,proto3" json:"lock_version,omitempty"` @@ -10366,432 +10376,433 @@ func init() { func init() { proto.RegisterFile("kvrpcpb.proto", fileDescriptor_1afe832be69693c7) } var fileDescriptor_1afe832be69693c7 = []byte{ - // 6794 bytes of a gzipped FileDescriptorProto + // 6816 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x7c, 0x5b, 0x6c, 0x23, 0xc9, 0x75, 0xe8, 0x34, 0x49, 0x89, 0xd4, 0xa1, 0x44, 0xb6, 0x4a, 0x2f, 0x4a, 0x33, 0xb3, 0x33, 0xd3, - 0xeb, 0xd9, 0x1d, 0xcb, 0x5e, 0x8d, 0x57, 0xfb, 0xf0, 0xf3, 0xae, 0x77, 0x46, 0xf3, 0xd2, 0xce, - 0x43, 0x42, 0x93, 0x3b, 0x7b, 0x17, 0xf7, 0xda, 0xed, 0x52, 0xb3, 0x44, 0x36, 0xd4, 0xec, 0xee, - 0xed, 0x2a, 0x4a, 0xa2, 0x2f, 0x2e, 0x70, 0x17, 0xf7, 0x01, 0x18, 0xb8, 0x71, 0x12, 0xc3, 0x80, - 0x03, 0xd8, 0x08, 0x90, 0x0f, 0x03, 0x71, 0xfe, 0x82, 0xfc, 0xe4, 0xf1, 0x11, 0x04, 0xf0, 0xc7, - 0x26, 0x88, 0x61, 0x03, 0x41, 0xe0, 0xc0, 0x0e, 0x8c, 0x60, 0x03, 0xe4, 0x3b, 0x3f, 0x41, 0xf2, - 0x13, 0x24, 0xa8, 0x57, 0x3f, 0x48, 0x8e, 0x46, 0xa3, 0xd1, 0x8c, 0x9d, 0x7c, 0x91, 0x75, 0xce, - 0xa9, 0xaa, 0x53, 0xe7, 0x9c, 0x3a, 0x55, 0x75, 0xea, 0x54, 0xc3, 0xcc, 0xde, 0x7e, 0x1c, 0xb9, - 0xd1, 0xce, 0x5a, 0x14, 0x87, 0x2c, 0x44, 0x65, 0x55, 0x5c, 0x99, 0xee, 0x11, 0x86, 0x35, 0x78, - 0x65, 0x86, 0xc4, 0x71, 0x18, 0x27, 0xc5, 0xf9, 0x4e, 0xd8, 0x09, 0xc5, 0xdf, 0xab, 0xfc, 0x9f, - 0x82, 0xd6, 0xe3, 0x3e, 0x65, 0xe2, 0xaf, 0x02, 0xd4, 0xda, 0x04, 0xb7, 0xfd, 0xd0, 0xdd, 0xd3, - 0xad, 0xb0, 0x18, 0xbb, 0x24, 0x69, 0x65, 0x31, 0x26, 0x34, 0xec, 0xc7, 0x2e, 0x71, 0x7a, 0x38, - 0xc0, 0x1d, 0x12, 0x4b, 0xb8, 0xd5, 0x06, 0xb8, 0x4d, 0x98, 0x4d, 0x3e, 0xe8, 0x13, 0xca, 0xd0, - 0x2a, 0x94, 0xdd, 0x30, 0x60, 0xe4, 0x90, 0x35, 0x8c, 0x8b, 0xc6, 0x95, 0xea, 0xba, 0xb9, 0xa6, - 0x59, 0xde, 0x90, 0x70, 0x5b, 0x13, 0x20, 0x13, 0x8a, 0x7b, 0x64, 0xd0, 0x28, 0x5c, 0x34, 0xae, - 0x4c, 0xdb, 0xfc, 0x2f, 0x6a, 0x40, 0x79, 0x9f, 0xc4, 0xd4, 0x0b, 0x83, 0x46, 0xf1, 0xa2, 0x71, - 0xa5, 0x64, 0xeb, 0xa2, 0xf5, 0xb1, 0x01, 0x55, 0xd1, 0x0d, 0x8d, 0xc2, 0x80, 0x12, 0xf4, 0x2a, - 0x4c, 0xc7, 0xa4, 0xe3, 0x85, 0x81, 0x23, 0xc6, 0xaa, 0x3a, 0xab, 0xad, 0xe9, 0x91, 0xdf, 0xe4, - 0xbf, 0x76, 0x55, 0xd2, 0x88, 0x02, 0x7a, 0x19, 0x26, 0x24, 0x6d, 0x41, 0xd0, 0xce, 0x26, 0x8c, - 0xdd, 0x25, 0x03, 0x49, 0x2e, 0xf1, 0x68, 0x1e, 0x26, 0xf6, 0xb1, 0xdf, 0x27, 0x82, 0x87, 0x69, - 0x5b, 0x16, 0xd0, 0x59, 0x98, 0x0a, 0x42, 0xe6, 0xec, 0x86, 0xfd, 0xa0, 0xdd, 0x28, 0x5d, 0x34, - 0xae, 0x54, 0xec, 0x4a, 0x10, 0xb2, 0x5b, 0xbc, 0x8c, 0xde, 0x82, 0x3a, 0x39, 0x24, 0xae, 0xd3, - 0x26, 0x0c, 0x7b, 0x3e, 0x75, 0xf6, 0xd7, 0x1b, 0x93, 0xa2, 0x97, 0xc5, 0xa4, 0x97, 0x9b, 0x87, - 0xc4, 0xbd, 0x21, 0xd1, 0x0f, 0xd7, 0xed, 0x19, 0x92, 0x2d, 0xbe, 0x53, 0xaa, 0x4c, 0x98, 0x93, - 0xd6, 0x3f, 0x19, 0x50, 0x6d, 0xba, 0x38, 0x38, 0x89, 0x30, 0xcf, 0xc2, 0x14, 0x65, 0x38, 0x66, - 0x4e, 0x2a, 0xd2, 0x8a, 0x00, 0xdc, 0x25, 0x03, 0x3e, 0x22, 0xdf, 0xeb, 0x79, 0x4c, 0x8c, 0x68, - 0xc6, 0x96, 0x85, 0xac, 0xb4, 0x4b, 0x39, 0x69, 0xa3, 0x65, 0xa8, 0xec, 0x91, 0x81, 0x13, 0x06, - 0xfe, 0xa0, 0x31, 0x21, 0x86, 0x5a, 0xde, 0x23, 0x83, 0xad, 0xc0, 0x17, 0x2a, 0x8a, 0x09, 0xa7, - 0x23, 0x62, 0x84, 0x15, 0x5b, 0x17, 0xd1, 0x12, 0x94, 0x49, 0xd0, 0x16, 0xfd, 0x97, 0x45, 0xff, - 0x93, 0x24, 0x68, 0xf3, 0xde, 0x2f, 0x40, 0x95, 0xe2, 0x5e, 0xe4, 0x13, 0x87, 0x32, 0x12, 0x35, - 0x2a, 0x82, 0x07, 0x90, 0xa0, 0x26, 0x23, 0x91, 0xf5, 0x9b, 0x06, 0x4c, 0xcb, 0x71, 0x9f, 0x5c, - 0xbb, 0x97, 0x61, 0x22, 0xc2, 0x5e, 0x4c, 0x1b, 0x85, 0x8b, 0xc5, 0x2b, 0xd5, 0xf5, 0x7a, 0xaa, - 0xdd, 0xfd, 0x6d, 0xec, 0xc5, 0xb6, 0xc4, 0xa6, 0x46, 0x50, 0x3c, 0xda, 0x08, 0xac, 0x8f, 0xca, - 0x50, 0xdf, 0x8e, 0xc9, 0x41, 0xec, 0x31, 0x72, 0x12, 0x7d, 0x5c, 0x85, 0xa9, 0x5e, 0x9f, 0x61, - 0xe6, 0x85, 0x81, 0xe6, 0x29, 0xed, 0xec, 0xbe, 0xc2, 0xd8, 0x29, 0x0d, 0xba, 0x04, 0xd3, 0x51, - 0xec, 0xf5, 0x70, 0x3c, 0x70, 0xf8, 0x24, 0x54, 0xc6, 0x57, 0x55, 0xb0, 0x7b, 0xa1, 0xbb, 0x87, - 0x5e, 0x84, 0x19, 0xa9, 0xe3, 0xbc, 0xda, 0xa6, 0x05, 0xf0, 0x61, 0xaa, 0x3b, 0x5e, 0xdf, 0x61, - 0xcc, 0x17, 0xba, 0x2b, 0xd9, 0x65, 0x5e, 0x6e, 0x31, 0x1f, 0xad, 0xc3, 0x02, 0xdd, 0xf3, 0x22, - 0xc7, 0x0d, 0x03, 0xca, 0x62, 0xec, 0x05, 0xcc, 0x71, 0xbb, 0xc4, 0xdd, 0x53, 0x9a, 0x9c, 0xe3, - 0xc8, 0x8d, 0x04, 0xb7, 0xc1, 0x51, 0xe8, 0xbf, 0xc1, 0x5c, 0x44, 0x28, 0xf5, 0x7a, 0x1e, 0x65, - 0x9e, 0xeb, 0x60, 0x57, 0x8e, 0xa8, 0x7c, 0xb1, 0x78, 0xa5, 0xb6, 0xbe, 0x9a, 0x8c, 0x68, 0x48, - 0x54, 0x6b, 0xdb, 0x69, 0x9d, 0x6b, 0xa2, 0x8a, 0x8d, 0xa2, 0x61, 0x10, 0xe5, 0xbc, 0xb2, 0xc3, - 0xc0, 0xa1, 0xde, 0xd7, 0x89, 0x30, 0x8b, 0x92, 0x5d, 0x66, 0x87, 0x41, 0xd3, 0xfb, 0x3a, 0x41, - 0x16, 0xcc, 0xec, 0x86, 0xb1, 0xd3, 0x8f, 0xda, 0x98, 0x11, 0x87, 0xd1, 0xc6, 0x94, 0xc0, 0x57, - 0x77, 0xc3, 0xf8, 0x5d, 0x01, 0x6b, 0x51, 0x4e, 0xd3, 0xf3, 0x02, 0xc7, 0x0d, 0x7b, 0x3d, 0x8f, - 0x71, 0x1a, 0x90, 0x34, 0x3d, 0x2f, 0xd8, 0x10, 0xb0, 0x16, 0x45, 0x57, 0xc0, 0xec, 0x53, 0xe2, - 0x60, 0x3a, 0x08, 0x5c, 0x45, 0xd9, 0xa8, 0x8a, 0xe1, 0xd6, 0xfa, 0x94, 0x5c, 0xe3, 0x60, 0x49, - 0x8b, 0x2e, 0x42, 0x95, 0x12, 0x37, 0x0c, 0xda, 0x38, 0xf6, 0x08, 0x6d, 0x4c, 0x5f, 0x2c, 0x72, - 0xf9, 0x67, 0x40, 0xe8, 0x1c, 0x00, 0x8b, 0xf9, 0xb4, 0x20, 0x4e, 0xe4, 0x36, 0x66, 0xa4, 0x0f, - 0x60, 0xf1, 0x60, 0x2b, 0x20, 0xdb, 0xae, 0xe0, 0x06, 0x1f, 0x66, 0xb8, 0xa9, 0x29, 0x6e, 0xf0, - 0x61, 0xc2, 0xcd, 0xdb, 0x50, 0xc7, 0x94, 0x92, 0x98, 0x0f, 0xdf, 0xf1, 0xc9, 0x3e, 0xf1, 0x1b, - 0xf5, 0x8b, 0xc6, 0x95, 0xda, 0xfa, 0x52, 0x22, 0xc9, 0x6b, 0x1a, 0x7f, 0x8f, 0xa3, 0xed, 0x1a, - 0xce, 0x95, 0x91, 0x07, 0xcb, 0x39, 0xb9, 0x64, 0x94, 0x49, 0x1b, 0xa6, 0xb0, 0xb3, 0xb5, 0x47, - 0x6a, 0xe5, 0x56, 0x22, 0xbc, 0x66, 0xaa, 0x67, 0x7b, 0x31, 0x23, 0xd3, 0x14, 0x4c, 0x57, 0x76, - 0x60, 0x61, 0x6c, 0x05, 0xee, 0x4e, 0xbc, 0xa0, 0x4d, 0x0e, 0xc5, 0x2c, 0x98, 0xb1, 0x65, 0x01, - 0xbd, 0x06, 0x8b, 0xe4, 0x30, 0x22, 0x2e, 0x23, 0x6d, 0x27, 0xaf, 0xba, 0x82, 0x10, 0xc4, 0x9c, - 0xc6, 0xa6, 0x8d, 0x52, 0x6b, 0x07, 0x66, 0x47, 0x4c, 0x05, 0xad, 0xc0, 0x62, 0xf3, 0xee, 0xe6, - 0xb6, 0xb3, 0x7d, 0xb3, 0xd9, 0xdc, 0xbc, 0xbf, 0xd9, 0x6c, 0x6d, 0x6e, 0x38, 0x1b, 0x77, 0x6e, - 0x6e, 0xdc, 0x35, 0xcf, 0xa0, 0x06, 0xcc, 0xdf, 0xd8, 0x1a, 0x83, 0x31, 0xd0, 0x12, 0xcc, 0xdd, - 0xd8, 0x72, 0x36, 0xb6, 0x1e, 0x34, 0x5b, 0xf6, 0xb5, 0xcd, 0x07, 0x2d, 0x85, 0x28, 0x58, 0xff, - 0x6a, 0x80, 0x99, 0x4a, 0xe2, 0xe4, 0x2e, 0xe6, 0x93, 0x30, 0x29, 0xb0, 0xa3, 0xf3, 0x39, 0x71, - 0x1e, 0x8a, 0x60, 0xd4, 0x32, 0x8b, 0xa3, 0x96, 0xf9, 0x32, 0x98, 0xd2, 0x92, 0x32, 0x64, 0x72, - 0x42, 0xcf, 0x84, 0xdc, 0xa0, 0x12, 0xc2, 0x31, 0x8b, 0xcb, 0xc4, 0x13, 0x2c, 0x2e, 0xd6, 0x0f, - 0x4b, 0xb0, 0x98, 0x11, 0x32, 0x77, 0x25, 0xff, 0x59, 0x3c, 0xda, 0x88, 0x97, 0x98, 0x1c, 0xeb, - 0x25, 0x3c, 0xea, 0xec, 0x7a, 0x31, 0x65, 0x92, 0x8f, 0xb2, 0x98, 0xb8, 0x55, 0x8f, 0xde, 0xe2, - 0x30, 0xc1, 0xc7, 0x25, 0x98, 0x3e, 0xc0, 0x5c, 0x05, 0x5e, 0x8f, 0x84, 0x7d, 0x26, 0x9c, 0x51, - 0xd1, 0xae, 0x72, 0x58, 0x4b, 0x82, 0x50, 0x03, 0x26, 0x76, 0xc3, 0xd8, 0x25, 0xc2, 0x11, 0x55, - 0xae, 0x17, 0x1a, 0x86, 0x2d, 0x01, 0x7c, 0x10, 0x31, 0x61, 0xfd, 0x38, 0x70, 0xc4, 0x4e, 0x41, - 0xba, 0xa1, 0x8a, 0x3d, 0x2d, 0x81, 0x0f, 0x05, 0x6c, 0xd4, 0x22, 0xaa, 0xe3, 0x2c, 0xa2, 0x2e, - 0xfc, 0xb1, 0x43, 0x0e, 0x3d, 0xca, 0x48, 0xe0, 0x92, 0xc6, 0xb4, 0x74, 0x55, 0x02, 0x7c, 0x53, - 0x43, 0xd1, 0x2b, 0x30, 0x27, 0x24, 0xc2, 0x17, 0x68, 0xc7, 0xdb, 0x95, 0xf4, 0x54, 0x79, 0x24, - 0x93, 0xa3, 0xf8, 0x5a, 0xbd, 0xb9, 0x2b, 0x6a, 0x50, 0x74, 0x83, 0x8f, 0x6e, 0x8f, 0x38, 0xfd, - 0xc8, 0xe9, 0x85, 0x6d, 0x22, 0x1c, 0x53, 0x6d, 0xdd, 0x4a, 0xdd, 0x44, 0xde, 0x38, 0xde, 0xc3, - 0x7b, 0xe4, 0xdd, 0xe8, 0x7e, 0xd8, 0x26, 0x36, 0x1c, 0x24, 0xff, 0xad, 0x7f, 0x34, 0xa0, 0x31, - 0x44, 0x79, 0x97, 0x0c, 0x6c, 0x42, 0xfb, 0x3e, 0x43, 0x9f, 0x87, 0x12, 0x1b, 0x44, 0x44, 0x58, - 0x51, 0x6d, 0xfd, 0xf2, 0xa3, 0x9a, 0x4e, 0x2a, 0xb4, 0x06, 0x11, 0xb1, 0x45, 0x95, 0x74, 0xbb, - 0x55, 0xc8, 0x6e, 0xb7, 0xce, 0xc1, 0x54, 0x2a, 0x85, 0xa2, 0x18, 0x58, 0x0a, 0x40, 0x6f, 0xc0, - 0x12, 0x1f, 0x25, 0x69, 0x3b, 0x07, 0x1e, 0xeb, 0x72, 0x1f, 0xb8, 0xeb, 0x7b, 0x6e, 0x66, 0x0a, - 0xcd, 0x4b, 0xf4, 0x7b, 0x1e, 0xeb, 0x6e, 0x28, 0x64, 0x8b, 0xa2, 0x35, 0x10, 0x6b, 0x9c, 0xc3, - 0xb7, 0xb2, 0xfe, 0xbe, 0x17, 0x74, 0xa4, 0x41, 0xc8, 0xf5, 0x60, 0x96, 0xa3, 0x6c, 0x8d, 0xe1, - 0xdc, 0x5a, 0xff, 0x50, 0x80, 0xa5, 0x91, 0x99, 0xf3, 0x5c, 0x1c, 0xc8, 0x05, 0x98, 0x1a, 0x72, - 0x1e, 0xc2, 0xe2, 0x2a, 0xae, 0xb6, 0x95, 0x86, 0x96, 0x1a, 0x1f, 0xef, 0xb4, 0x34, 0x47, 0x29, - 0xb9, 0x45, 0x98, 0x54, 0x76, 0x38, 0x21, 0x96, 0x30, 0x55, 0x42, 0xe7, 0x01, 0x92, 0x0d, 0x2c, - 0x9f, 0x28, 0x45, 0x2e, 0x52, 0xbd, 0x83, 0x1d, 0xeb, 0x65, 0xca, 0x4f, 0xe0, 0x65, 0xd0, 0x17, - 0xf9, 0xc6, 0x90, 0xab, 0x96, 0x36, 0x2a, 0x62, 0x74, 0x97, 0x1e, 0x6b, 0x04, 0xb6, 0xae, 0x61, - 0x7d, 0xdf, 0x80, 0x95, 0x0c, 0x95, 0x1d, 0xfa, 0xfe, 0x0e, 0x3e, 0x99, 0x9b, 0x1a, 0x71, 0x29, - 0x85, 0x31, 0x2e, 0x65, 0xc4, 0x6f, 0x14, 0x47, 0xfd, 0x06, 0x82, 0xd2, 0x1e, 0x19, 0x70, 0x83, - 0xe2, 0x52, 0x14, 0xff, 0xad, 0x3f, 0x31, 0xe0, 0xec, 0x58, 0x3e, 0x9f, 0x8b, 0x51, 0x8c, 0x51, - 0x51, 0xf1, 0x49, 0x16, 0x82, 0xdf, 0x37, 0x60, 0xae, 0x75, 0x18, 0xdc, 0x21, 0x38, 0x66, 0xd7, - 0x09, 0x3e, 0xd1, 0xa1, 0x6d, 0xd8, 0xa9, 0x17, 0x8e, 0xe1, 0xd4, 0x8b, 0x63, 0x34, 0xf0, 0x12, - 0xd4, 0x71, 0x7b, 0xdf, 0xa3, 0xc4, 0x49, 0x7c, 0xbb, 0x5a, 0xfc, 0x24, 0xf8, 0x9e, 0xf4, 0xf0, - 0xd6, 0x8f, 0x0c, 0x98, 0xcf, 0xf3, 0xfc, 0x1c, 0x4e, 0x80, 0xd9, 0x15, 0xa7, 0x98, 0x5f, 0x71, - 0xc6, 0xe8, 0xa0, 0xf4, 0x24, 0x3a, 0xf8, 0xb5, 0x22, 0x2c, 0x88, 0x9d, 0x75, 0xeb, 0x30, 0x68, - 0x32, 0xcc, 0xfa, 0xf4, 0x24, 0x5a, 0xb8, 0x00, 0x5a, 0xe2, 0x99, 0xf3, 0x1e, 0x28, 0x10, 0x3f, - 0x73, 0x2d, 0x41, 0x59, 0x8e, 0x40, 0x9b, 0xf6, 0xa4, 0x18, 0x00, 0xe5, 0x72, 0x77, 0xb1, 0xef, - 0x93, 0xd8, 0x91, 0x3a, 0x4a, 0x37, 0x1d, 0x12, 0xdc, 0xe4, 0xd0, 0x96, 0xf0, 0x16, 0x6e, 0x3f, - 0x8e, 0x49, 0x20, 0x48, 0xe4, 0xb2, 0x3b, 0xa5, 0x20, 0x2d, 0x8a, 0x5e, 0x85, 0x85, 0x58, 0x19, - 0x3f, 0x5f, 0x80, 0xb8, 0x63, 0x11, 0xde, 0x59, 0x1d, 0x25, 0x90, 0x46, 0x6e, 0xee, 0x3e, 0x08, - 0x99, 0x58, 0x86, 0xd0, 0x2a, 0xcc, 0x8a, 0xf5, 0xd2, 0xc9, 0x6e, 0xc5, 0xe5, 0x5a, 0x5c, 0x17, - 0x88, 0x66, 0xba, 0x17, 0xff, 0x12, 0xac, 0xa4, 0x3e, 0x3a, 0x7b, 0xfe, 0x10, 0x36, 0x57, 0x11, - 0x95, 0x1a, 0x09, 0xc5, 0x90, 0x7f, 0xe1, 0x3d, 0xed, 0x93, 0xd8, 0xdb, 0x1d, 0x38, 0x1e, 0x75, - 0x94, 0x50, 0xe4, 0xb2, 0x6d, 0xd7, 0x25, 0x62, 0x93, 0x6e, 0x4b, 0xb0, 0xf5, 0xe3, 0x02, 0x2c, - 0x0e, 0xeb, 0xe3, 0x97, 0x6b, 0x61, 0x97, 0xa1, 0xa6, 0x5c, 0x7f, 0x7e, 0x53, 0x34, 0x23, 0xa1, - 0x7a, 0x02, 0xbd, 0x0c, 0x93, 0xf2, 0x30, 0x26, 0x94, 0x53, 0xcb, 0x9c, 0x78, 0xd5, 0x81, 0x4b, - 0xa1, 0xd1, 0x1a, 0x4c, 0x89, 0xae, 0xbc, 0x60, 0x37, 0x54, 0x51, 0x89, 0x94, 0x2f, 0x2e, 0xaf, - 0xcd, 0x60, 0x37, 0xb4, 0x05, 0x3b, 0xfc, 0xdf, 0xd3, 0x2e, 0x04, 0xd6, 0x87, 0x06, 0xac, 0x08, - 0x89, 0x36, 0xd5, 0xd1, 0x49, 0x78, 0x85, 0x13, 0x99, 0xb9, 0x76, 0xc1, 0x85, 0xd4, 0x05, 0x1f, - 0xcb, 0xbb, 0x58, 0xff, 0x66, 0xc0, 0xd9, 0xb1, 0x3c, 0x3c, 0x07, 0xd5, 0xbe, 0x0c, 0x13, 0x5c, - 0x96, 0x7c, 0xe2, 0x15, 0xc7, 0xcb, 0x5a, 0xe2, 0xd1, 0xd9, 0xec, 0x1a, 0x2f, 0x75, 0x9c, 0xae, - 0xef, 0x4f, 0xbb, 0xe9, 0xff, 0x81, 0x01, 0x33, 0x72, 0x32, 0x3d, 0xb3, 0x45, 0x54, 0x6b, 0xa7, - 0x98, 0xd1, 0xce, 0xf1, 0x8c, 0x57, 0xc6, 0xbb, 0xec, 0xc9, 0x1d, 0x2f, 0xf0, 0xc3, 0x8e, 0xf5, - 0x57, 0x06, 0xd4, 0x34, 0xaf, 0xcf, 0x41, 0x41, 0xa3, 0x3c, 0x16, 0xc7, 0x4d, 0xb0, 0xa7, 0xf5, - 0xf4, 0x1d, 0x98, 0xd9, 0xec, 0x45, 0x61, 0x9c, 0x28, 0x20, 0x77, 0x80, 0x32, 0x8e, 0x71, 0x80, - 0x1a, 0x65, 0xb4, 0x30, 0x86, 0x51, 0xeb, 0x7d, 0xa8, 0xe9, 0x8e, 0x4e, 0x2e, 0xbd, 0xf9, 0xac, - 0xf4, 0xa6, 0x74, 0x14, 0xec, 0x5b, 0x5c, 0x33, 0x3e, 0xc1, 0x41, 0x3f, 0x3a, 0x9d, 0x08, 0xef, - 0xb1, 0xf6, 0x06, 0xf9, 0xb5, 0xa7, 0x34, 0xb4, 0xf6, 0x58, 0xdf, 0x36, 0xa0, 0x9e, 0x30, 0xf5, - 0x2b, 0x63, 0x2f, 0xd6, 0x1e, 0xd4, 0xaf, 0x63, 0xe6, 0x76, 0x4f, 0x18, 0x0d, 0x1f, 0xe7, 0xeb, - 0x1e, 0x1d, 0x0f, 0xff, 0xb9, 0x01, 0x66, 0xda, 0xdb, 0x33, 0x0f, 0x9b, 0x3e, 0xe5, 0x5c, 0x48, - 0x65, 0x3d, 0x71, 0xb4, 0xac, 0xdf, 0x29, 0x55, 0x8a, 0x66, 0xc9, 0xfa, 0x1f, 0x30, 0x2f, 0x06, - 0xf7, 0xcc, 0xcf, 0x01, 0x63, 0x5c, 0x98, 0xf5, 0x07, 0x06, 0x2c, 0x0c, 0xf5, 0xfe, 0x1c, 0x8c, - 0xec, 0x69, 0xf7, 0xf6, 0xbf, 0x67, 0x40, 0xbd, 0xe9, 0xe2, 0xe0, 0xa4, 0xd1, 0x9d, 0x0b, 0x50, - 0xed, 0xe1, 0xc3, 0x21, 0x61, 0x41, 0x0f, 0x1f, 0x6a, 0x51, 0xe5, 0x2e, 0x18, 0x8a, 0x8f, 0xba, - 0x60, 0x28, 0x65, 0x2f, 0x18, 0x32, 0x37, 0x02, 0x13, 0xd9, 0x1b, 0x01, 0xeb, 0xa7, 0x06, 0x98, - 0x29, 0xb3, 0xbf, 0x4a, 0x6b, 0xf2, 0xd3, 0x3a, 0xfd, 0x1f, 0x1b, 0x80, 0x64, 0x0c, 0x81, 0x9c, - 0x54, 0x13, 0xc7, 0x32, 0xdc, 0x63, 0xae, 0x61, 0xaf, 0xc0, 0x14, 0x3b, 0x0c, 0xc4, 0xd6, 0x4f, - 0x1e, 0x64, 0xb3, 0x3d, 0xb7, 0x0e, 0x03, 0xb9, 0xf5, 0x63, 0xf2, 0x4f, 0x7a, 0xe4, 0x9d, 0xc8, - 0x4c, 0x07, 0x7e, 0x68, 0xcc, 0x8d, 0xe8, 0x3f, 0xc0, 0x64, 0x78, 0x08, 0x53, 0xb7, 0x37, 0x4e, - 0x22, 0xfb, 0xf3, 0x00, 0x14, 0xef, 0x12, 0x27, 0x0a, 0xbd, 0x80, 0x29, 0xc1, 0x4f, 0x71, 0xc8, - 0x36, 0x07, 0x58, 0x5d, 0x00, 0xde, 0xee, 0xb3, 0x97, 0x80, 0xf5, 0x1d, 0x03, 0xd0, 0x0d, 0xe2, - 0x13, 0x46, 0x6c, 0x1c, 0x74, 0xc8, 0xa9, 0xdf, 0x08, 0x66, 0xa6, 0x66, 0x71, 0xf8, 0xb2, 0x2e, - 0x08, 0x19, 0x3f, 0x3b, 0x89, 0xdb, 0x3f, 0x79, 0xd1, 0x09, 0x12, 0xb4, 0x15, 0xf8, 0x03, 0xeb, - 0xab, 0x30, 0x97, 0x63, 0xec, 0xb4, 0xb7, 0x1c, 0x7f, 0x64, 0xc0, 0xc5, 0xed, 0x98, 0x44, 0x38, - 0x26, 0xb7, 0x7c, 0x4c, 0xbb, 0xdc, 0x03, 0xb7, 0x42, 0x65, 0xd0, 0xcf, 0x4f, 0x0e, 0xcb, 0x50, - 0x19, 0x3a, 0x20, 0x97, 0xa9, 0x3a, 0x1a, 0x67, 0x56, 0xe5, 0x89, 0xfc, 0xaa, 0xec, 0xc3, 0xa5, - 0x23, 0x58, 0x3f, 0x6d, 0x49, 0xfd, 0xd8, 0x80, 0xe5, 0xd3, 0x11, 0x51, 0x66, 0x44, 0x85, 0xfc, - 0x4d, 0xf0, 0x91, 0x5e, 0x3f, 0x23, 0xbc, 0xd2, 0x23, 0x85, 0x37, 0x91, 0x17, 0x5e, 0xee, 0xd0, - 0x33, 0x99, 0x3f, 0xf4, 0x58, 0x04, 0x56, 0x9e, 0x87, 0xe0, 0xbe, 0x02, 0x33, 0x36, 0x3e, 0x38, - 0xb5, 0xac, 0x85, 0x1a, 0x14, 0xdc, 0x5d, 0x21, 0x9c, 0x29, 0xbb, 0xe0, 0xee, 0x5a, 0xff, 0xdf, - 0x80, 0x9a, 0x6e, 0xff, 0x94, 0x59, 0x3f, 0x41, 0x6e, 0x82, 0xd5, 0x06, 0x64, 0xe3, 0x83, 0xd3, - 0xde, 0x9a, 0x0e, 0x0f, 0x3a, 0x84, 0xb9, 0x5c, 0x2f, 0xcf, 0x7a, 0x4b, 0x6a, 0xfd, 0xb6, 0x21, - 0xb4, 0xb8, 0xdd, 0x3f, 0x25, 0x2d, 0x8e, 0x97, 0xac, 0x1c, 0x66, 0x49, 0x0f, 0x93, 0xd7, 0x4b, - 0xaf, 0xa1, 0xf8, 0x5f, 0x3e, 0x09, 0x76, 0xc3, 0xd8, 0x71, 0x31, 0x55, 0xb1, 0xaf, 0xc9, 0xdd, - 0x30, 0xde, 0xc0, 0x94, 0x1f, 0xcb, 0x34, 0x7f, 0xa7, 0x6d, 0xc0, 0x7f, 0x6c, 0xa4, 0x3a, 0x3d, - 0xa1, 0x00, 0x8e, 0xb9, 0xf1, 0x1f, 0x52, 0x33, 0x9a, 0x97, 0xe3, 0x2f, 0x25, 0x37, 0x12, 0xc3, - 0x32, 0x98, 0xc8, 0xca, 0x80, 0x5b, 0x0e, 0x63, 0xbe, 0xbc, 0x6d, 0x28, 0xd9, 0xe2, 0x3f, 0x5f, - 0x40, 0x72, 0xbc, 0x9f, 0xb6, 0x70, 0x06, 0x60, 0xda, 0xf8, 0x40, 0xad, 0x51, 0xcf, 0x62, 0x82, - 0x67, 0x87, 0x5b, 0xca, 0xa9, 0xfc, 0xbf, 0xc3, 0x6c, 0xa6, 0xeb, 0xd3, 0x1e, 0xd8, 0xff, 0x32, - 0x60, 0x41, 0x4b, 0xee, 0xe4, 0xc3, 0x3b, 0xc6, 0x64, 0x7e, 0xf4, 0x00, 0x31, 0x2c, 0x0e, 0x73, - 0x70, 0xda, 0xa3, 0xfc, 0x91, 0xf4, 0x9e, 0xcf, 0x31, 0x0f, 0x2a, 0x9b, 0xed, 0x54, 0xca, 0x67, - 0x3b, 0x49, 0xc1, 0x4c, 0x24, 0x82, 0x79, 0xf2, 0xec, 0x27, 0xab, 0x03, 0xf5, 0x64, 0x38, 0x27, - 0x97, 0xd5, 0x25, 0x28, 0xee, 0xed, 0x3f, 0x72, 0xb2, 0x72, 0x9c, 0xf5, 0x0d, 0x69, 0x1e, 0xbf, - 0x94, 0x5d, 0xe3, 0x90, 0x9b, 0x54, 0x76, 0xf2, 0x4c, 0xf7, 0x89, 0x3f, 0x31, 0x52, 0x3f, 0x72, - 0x52, 0x63, 0xf9, 0x24, 0x4c, 0xc6, 0x9c, 0xbb, 0xb1, 0x77, 0x6f, 0x92, 0x6f, 0x45, 0xc0, 0x4f, - 0x06, 0x04, 0xbb, 0x5d, 0x27, 0x6b, 0x3f, 0x53, 0x1c, 0x72, 0xef, 0xd4, 0x6c, 0xc8, 0xf2, 0x61, - 0x3e, 0x3f, 0xa2, 0x67, 0x6a, 0x2f, 0xff, 0x13, 0x96, 0xdf, 0x0d, 0xf8, 0xd9, 0xe6, 0x06, 0xa1, - 0x2c, 0x0e, 0x07, 0xcf, 0xd7, 0x64, 0xf8, 0x5e, 0x6f, 0x5c, 0xf7, 0xa7, 0x6d, 0x26, 0x5f, 0x83, - 0xb3, 0x36, 0xe9, 0x78, 0x94, 0x91, 0x98, 0x1f, 0x5f, 0xb7, 0x76, 0x28, 0x89, 0xf7, 0x49, 0x7c, - 0x92, 0x71, 0x2e, 0xc0, 0x64, 0x0f, 0x1f, 0xa6, 0x09, 0x4d, 0x13, 0x3d, 0x7c, 0xd8, 0xa2, 0xd6, - 0xeb, 0x70, 0x6e, 0x7c, 0x0f, 0x6a, 0x28, 0x09, 0x5f, 0x46, 0x7e, 0x0f, 0xda, 0x10, 0x17, 0x14, - 0xcf, 0x88, 0xa9, 0x3e, 0x2c, 0x8f, 0x69, 0xfe, 0x28, 0x8e, 0xb8, 0x09, 0x7b, 0xd4, 0x71, 0x7d, - 0x82, 0xe5, 0x29, 0xa0, 0x62, 0x97, 0x3d, 0x2a, 0xe2, 0xac, 0xc7, 0x0e, 0x9f, 0x58, 0x5f, 0x85, - 0x65, 0x9b, 0xf4, 0x42, 0x19, 0x2a, 0x78, 0x06, 0xc3, 0x5a, 0x87, 0x95, 0x71, 0xed, 0x1f, 0x29, - 0xe9, 0x5f, 0x37, 0x60, 0x69, 0xbb, 0x3b, 0xa0, 0x9e, 0x8b, 0xfd, 0xa7, 0x89, 0x90, 0x8d, 0x67, - 0xe9, 0x04, 0x71, 0x31, 0xeb, 0x7d, 0x68, 0x8c, 0x32, 0x74, 0xa4, 0x6e, 0x12, 0x05, 0x14, 0x1e, - 0xa3, 0x80, 0xef, 0x19, 0x80, 0x9a, 0x91, 0xef, 0x31, 0x5b, 0xcc, 0x8c, 0x93, 0x45, 0x02, 0xa7, - 0x28, 0x6f, 0x21, 0x9d, 0xce, 0x32, 0xf5, 0x44, 0x00, 0xf9, 0xa0, 0xce, 0x03, 0x24, 0x04, 0x3a, - 0x74, 0x3a, 0xa5, 0xb1, 0x14, 0xad, 0xc0, 0x94, 0x47, 0x9d, 0x18, 0x1f, 0x38, 0x7b, 0xfb, 0xda, - 0x17, 0x7a, 0xd4, 0xc6, 0x07, 0x77, 0xf7, 0xad, 0x1f, 0x1a, 0x30, 0x97, 0x63, 0xef, 0xe4, 0xd3, - 0xfd, 0x25, 0x28, 0xf9, 0x64, 0x97, 0xa9, 0x48, 0x4a, 0x6d, 0x4d, 0x65, 0xc0, 0xcb, 0x86, 0x05, - 0xc7, 0x02, 0x8f, 0xae, 0xc0, 0x44, 0xec, 0x75, 0xba, 0x4c, 0x45, 0x90, 0xc6, 0x11, 0x4a, 0x02, - 0x74, 0x85, 0x3b, 0xe6, 0x8e, 0xb8, 0x9d, 0x91, 0xa1, 0xb2, 0x21, 0x5a, 0x5b, 0xa3, 0xad, 0xff, - 0x63, 0x80, 0x69, 0x13, 0xdc, 0xde, 0x0c, 0xda, 0xe4, 0xf0, 0x24, 0x32, 0xce, 0x1e, 0x90, 0x0b, - 0xf9, 0x03, 0x72, 0xba, 0x26, 0x15, 0x1f, 0xb3, 0x26, 0x59, 0xbf, 0x61, 0xc0, 0x6c, 0x86, 0x8d, - 0x93, 0xcb, 0xf2, 0x3c, 0x40, 0x4c, 0x70, 0xdb, 0x91, 0x59, 0x9d, 0x2a, 0xec, 0x15, 0xeb, 0x96, - 0x39, 0x4b, 0x32, 0x9d, 0x6a, 0x24, 0x6b, 0x3a, 0x31, 0x3f, 0x45, 0x60, 0x35, 0x61, 0xee, 0xfe, - 0xbe, 0xeb, 0xde, 0x26, 0xec, 0xfa, 0x40, 0xe4, 0xf9, 0x9c, 0xc2, 0xfe, 0xdb, 0xfa, 0x7f, 0x06, - 0xcc, 0xe7, 0x5b, 0x3d, 0xed, 0x63, 0xf5, 0x65, 0x28, 0x89, 0xeb, 0xf1, 0xe1, 0xf1, 0xf1, 0x5e, - 0xc5, 0xf8, 0x04, 0xda, 0xfa, 0x1a, 0x2c, 0x25, 0x7c, 0xa8, 0x44, 0x89, 0xd3, 0xd5, 0x3e, 0x9f, - 0xbf, 0x8d, 0xd1, 0x2e, 0x4e, 0x7b, 0xb8, 0x4a, 0xc4, 0xc5, 0xf4, 0x88, 0xa3, 0x05, 0x50, 0x3a, - 0x5a, 0x00, 0x3f, 0x9f, 0x82, 0xf2, 0x46, 0xba, 0xec, 0x2b, 0x6e, 0xbc, 0xb6, 0x60, 0xa5, 0x64, - 0x57, 0x24, 0x60, 0xb3, 0x8d, 0xde, 0x4c, 0x59, 0x8d, 0x42, 0xb7, 0xab, 0x66, 0xe9, 0x5c, 0x7e, - 0x42, 0xdd, 0xe4, 0xa8, 0x84, 0x5f, 0x5e, 0x40, 0x17, 0xa1, 0x14, 0x11, 0xa2, 0xd3, 0xf3, 0xa7, - 0x35, 0xfd, 0x36, 0x21, 0xb1, 0x2d, 0x30, 0xe2, 0x48, 0x49, 0xe2, 0x9e, 0x3a, 0x82, 0x8b, 0xff, - 0xe8, 0x2a, 0x54, 0xa2, 0xd8, 0x0b, 0x63, 0x8f, 0x0d, 0xc4, 0x9e, 0xaa, 0xb6, 0x3e, 0x97, 0x91, - 0x7e, 0xaf, 0x87, 0x83, 0xf6, 0x76, 0xec, 0xd9, 0x09, 0x11, 0x7a, 0x1b, 0xea, 0x1e, 0x0d, 0x7d, - 0x9c, 0xc9, 0xc3, 0x2e, 0x0f, 0xe5, 0x61, 0x6f, 0x6a, 0xbc, 0xca, 0xc3, 0xf6, 0x72, 0x65, 0xf4, - 0x09, 0xa8, 0x89, 0x90, 0x8b, 0xe7, 0xfb, 0x8e, 0x8b, 0xdd, 0x2e, 0x51, 0x59, 0x29, 0xd3, 0x41, - 0xc8, 0x6e, 0x79, 0xbe, 0xbf, 0xc1, 0x61, 0x42, 0xd3, 0x83, 0xc0, 0x75, 0xfc, 0xb0, 0xa3, 0x12, - 0x50, 0xca, 0xbc, 0x7c, 0x2f, 0xec, 0xa0, 0x2b, 0x60, 0xc6, 0xc4, 0x0d, 0xe3, 0xb6, 0x48, 0x3a, - 0x75, 0x28, 0xc3, 0x4c, 0x25, 0x8e, 0xd6, 0x24, 0xbc, 0xe5, 0xf5, 0x48, 0x93, 0x61, 0x96, 0xa1, - 0xa4, 0x2e, 0x0e, 0x24, 0x65, 0x35, 0x4b, 0xc9, 0x17, 0x11, 0x41, 0x79, 0x89, 0x4b, 0x3d, 0xf2, - 0x3d, 0x17, 0x3b, 0x7c, 0xf6, 0xaa, 0xec, 0xd1, 0xaa, 0x82, 0x71, 0x57, 0x81, 0x2e, 0x43, 0x4d, - 0xe6, 0xcd, 0x90, 0xb6, 0x23, 0x97, 0x94, 0x19, 0x71, 0x36, 0x9f, 0xd1, 0x50, 0x91, 0x28, 0x81, - 0x3e, 0x0f, 0xcb, 0x7c, 0xb1, 0x23, 0x87, 0xc4, 0xed, 0x0b, 0x21, 0xb5, 0xfb, 0xb1, 0x94, 0x56, - 0x4f, 0x27, 0xb6, 0x2f, 0xf6, 0xf0, 0xe1, 0x4d, 0x8d, 0xbf, 0xa1, 0xd0, 0xf7, 0x45, 0x82, 0x06, - 0x8e, 0x22, 0xdf, 0x23, 0xda, 0x9f, 0xd4, 0xe5, 0xfd, 0x85, 0x02, 0x4a, 0x97, 0xb2, 0x04, 0x65, - 0x86, 0xe9, 0x1e, 0x37, 0x1d, 0x53, 0xe6, 0x27, 0xf1, 0xe2, 0x66, 0x5b, 0x2c, 0x2e, 0x0c, 0xfb, - 0x44, 0x0e, 0x60, 0x56, 0x26, 0x7e, 0x0a, 0x88, 0x60, 0xff, 0xd3, 0x80, 0x92, 0x77, 0x48, 0x9d, - 0x38, 0xec, 0x47, 0x0e, 0xc3, 0x9d, 0x06, 0x12, 0x86, 0x6c, 0x6a, 0xcc, 0x6d, 0x8e, 0x68, 0xe1, - 0x0e, 0xfa, 0x1c, 0xcc, 0xb4, 0x3d, 0xba, 0xe7, 0xec, 0xf6, 0x7d, 0xdf, 0x09, 0x23, 0xd6, 0x98, - 0x13, 0x4a, 0x9e, 0x4f, 0x94, 0x7c, 0xc3, 0xa3, 0x7b, 0xb7, 0xfa, 0xbe, 0xbf, 0x15, 0x31, 0xbb, - 0xda, 0x4e, 0x0b, 0x5c, 0xe6, 0x7c, 0x11, 0x23, 0x2c, 0x1e, 0x38, 0xb1, 0x9c, 0xe2, 0x8d, 0x79, - 0x29, 0x73, 0x8f, 0xda, 0x1c, 0xac, 0x27, 0xfe, 0xeb, 0x50, 0xc5, 0x91, 0x97, 0x5c, 0xc3, 0x2c, - 0x0c, 0x99, 0xdf, 0xb5, 0xed, 0x4d, 0x1d, 0xc7, 0x04, 0x1c, 0x79, 0x69, 0xf6, 0x4e, 0x5d, 0x46, - 0x3d, 0x59, 0xa2, 0x87, 0x45, 0xa1, 0x87, 0x5a, 0x02, 0x96, 0x8a, 0xf8, 0x02, 0xc8, 0x77, 0x58, - 0x8e, 0xf6, 0x2e, 0x4b, 0x62, 0x66, 0x2c, 0xac, 0xe9, 0xd7, 0x59, 0x2d, 0xfe, 0xab, 0x5d, 0xcc, - 0x34, 0xcb, 0x94, 0xa4, 0xae, 0x05, 0x97, 0x8e, 0x14, 0x4c, 0xa3, 0x21, 0xbc, 0xc0, 0x8c, 0x82, - 0x36, 0x05, 0x90, 0x8b, 0x5c, 0xbc, 0xc2, 0x90, 0x24, 0xcb, 0xd2, 0xfb, 0xb3, 0xc3, 0x40, 0xa1, - 0x57, 0x61, 0x76, 0xa7, 0x4f, 0x07, 0x0e, 0xeb, 0xc6, 0x84, 0x76, 0x43, 0xbf, 0xcd, 0x4d, 0xe0, - 0xac, 0xd8, 0xcf, 0xd4, 0x39, 0xa2, 0xa5, 0xe1, 0xf7, 0x29, 0x7a, 0x1f, 0x1a, 0x89, 0x7a, 0x38, - 0xc3, 0x71, 0xe8, 0x27, 0x8c, 0x9f, 0x13, 0x8c, 0x5f, 0x48, 0x24, 0x63, 0x2b, 0xc2, 0x0d, 0x49, - 0xa7, 0x87, 0x90, 0xbc, 0x33, 0xcb, 0xc3, 0xd1, 0x05, 0xa8, 0xf2, 0xfd, 0x46, 0xc4, 0x65, 0xe1, - 0xb5, 0x1b, 0x17, 0xe5, 0x2b, 0x22, 0x0d, 0xda, 0x6c, 0x73, 0x91, 0xee, 0xf4, 0xdd, 0x3d, 0xc2, - 0x68, 0xa2, 0x8c, 0x4b, 0x62, 0x2c, 0x35, 0x05, 0x4e, 0x93, 0x4f, 0x4a, 0xe6, 0xc4, 0x3b, 0xa5, - 0xca, 0x8a, 0x79, 0x96, 0xcf, 0x0d, 0xdc, 0x76, 0x3e, 0xe8, 0x87, 0x71, 0xbf, 0x67, 0x7d, 0x68, - 0xc0, 0xe2, 0x78, 0xae, 0xd0, 0x1a, 0xcc, 0x0d, 0xd9, 0x5d, 0x80, 0x7b, 0x44, 0x6d, 0xd2, 0x66, - 0x73, 0x86, 0xf7, 0x00, 0xf7, 0x08, 0xfa, 0x2c, 0x94, 0x23, 0x12, 0x60, 0x9f, 0x0d, 0x94, 0xeb, - 0x3b, 0xbf, 0x36, 0xf2, 0x7e, 0x6e, 0x23, 0x0c, 0x68, 0xbf, 0x17, 0x89, 0xac, 0x0f, 0x4d, 0x6d, - 0x7d, 0xb7, 0x08, 0x15, 0xbd, 0xaa, 0x8e, 0x24, 0x5b, 0x1a, 0xa3, 0xc9, 0x96, 0x97, 0x60, 0x5a, - 0x64, 0x77, 0xe5, 0xe3, 0xf7, 0x55, 0x0e, 0xd3, 0xb6, 0x36, 0xea, 0xed, 0xb3, 0xd9, 0x67, 0xa5, - 0x7c, 0xf6, 0x59, 0xf6, 0x49, 0xce, 0x44, 0xfe, 0x49, 0xce, 0x15, 0x95, 0x48, 0x26, 0x12, 0xbd, - 0xa5, 0x9b, 0xad, 0x26, 0xda, 0xdc, 0x8a, 0x64, 0x0a, 0x59, 0x6b, 0x10, 0x11, 0xf4, 0x29, 0x40, - 0x82, 0x32, 0x9f, 0x63, 0x5b, 0x16, 0xcd, 0xd5, 0x39, 0x26, 0xf3, 0x04, 0x64, 0xec, 0x0b, 0x9d, - 0xca, 0xd8, 0x17, 0x3a, 0x23, 0x39, 0xf4, 0x53, 0xa3, 0x39, 0xf4, 0x43, 0xaf, 0x78, 0x60, 0xf4, - 0x15, 0xcf, 0x17, 0x60, 0x25, 0x71, 0x66, 0x2c, 0x74, 0x7c, 0x4c, 0x99, 0x66, 0xb2, 0xa7, 0xd3, - 0xf2, 0x17, 0x35, 0x45, 0x2b, 0xbc, 0x87, 0x29, 0x93, 0xbc, 0xde, 0xa7, 0xd6, 0xdf, 0x96, 0xa0, - 0xa2, 0xaf, 0xea, 0x32, 0xdb, 0x22, 0xe3, 0x31, 0xdb, 0x22, 0x74, 0x8e, 0xaf, 0x95, 0x2c, 0x1e, - 0xe0, 0x1d, 0x9f, 0xa8, 0xa5, 0x38, 0x05, 0xf0, 0x45, 0x1a, 0xef, 0x84, 0x31, 0x53, 0x11, 0x38, - 0x59, 0x40, 0xeb, 0x50, 0xd1, 0x79, 0xed, 0x23, 0x77, 0xd0, 0xef, 0xc5, 0x1e, 0x23, 0x3a, 0xb1, - 0xdd, 0x4e, 0xe8, 0xb8, 0xb7, 0xc0, 0x3e, 0x37, 0xe9, 0x81, 0x4a, 0xc7, 0x9c, 0x50, 0xde, 0x22, - 0x71, 0x47, 0x12, 0x2b, 0x32, 0x32, 0xed, 0x69, 0x9c, 0x29, 0xa1, 0x57, 0xa0, 0xa2, 0x5f, 0x80, - 0x8e, 0xa4, 0x09, 0xde, 0x50, 0x08, 0x3b, 0x21, 0x41, 0x37, 0x60, 0x36, 0x51, 0x84, 0x43, 0x0e, - 0x23, 0x2f, 0x26, 0x6d, 0x95, 0x28, 0xd8, 0xc8, 0x2d, 0xbe, 0x5c, 0x2d, 0x37, 0x25, 0xde, 0xae, - 0xbb, 0x79, 0x00, 0xf7, 0xd0, 0xdc, 0xdc, 0xd2, 0xdb, 0x8b, 0x8a, 0x68, 0x61, 0x3e, 0x7b, 0x49, - 0xfd, 0x40, 0xdd, 0x64, 0xd8, 0x55, 0x96, 0x16, 0xd0, 0x1d, 0x98, 0x4b, 0xfb, 0x67, 0x21, 0x57, - 0x64, 0xdc, 0x91, 0xaf, 0x33, 0xaa, 0xeb, 0xcb, 0x23, 0x1c, 0xb4, 0xc2, 0xf0, 0x1e, 0x27, 0xb0, - 0x4d, 0x77, 0x08, 0x82, 0x36, 0xc0, 0x4c, 0x1f, 0x65, 0xed, 0x62, 0xcf, 0x27, 0x6d, 0xb1, 0x12, - 0x67, 0x07, 0x92, 0xbc, 0xca, 0xba, 0x25, 0xf0, 0x76, 0xfa, 0x8c, 0x4b, 0x02, 0x78, 0x23, 0x7a, - 0xaa, 0xf6, 0x3c, 0xda, 0xc3, 0xcc, 0xed, 0x0a, 0x5b, 0xca, 0x36, 0xa2, 0x72, 0x4e, 0xef, 0x2b, - 0xbc, 0x5d, 0x8f, 0xf2, 0x00, 0xeb, 0xaf, 0x0b, 0x30, 0x93, 0x53, 0x6d, 0x6e, 0xab, 0x68, 0xe4, - 0x0f, 0x0a, 0x17, 0xa0, 0x9a, 0x7d, 0xf7, 0xa0, 0x32, 0x36, 0xdc, 0xf4, 0xb5, 0xc3, 0xe8, 0xbc, - 0x6f, 0x40, 0x59, 0xa7, 0xc3, 0xca, 0x0b, 0x3b, 0x5d, 0xe4, 0xeb, 0x6a, 0xd2, 0x58, 0x3a, 0xbf, - 0xa4, 0x03, 0x30, 0x35, 0x26, 0x99, 0x64, 0x6f, 0xc0, 0x64, 0x4c, 0x30, 0x0d, 0x03, 0xe5, 0x06, - 0xce, 0x8f, 0x37, 0xcc, 0x35, 0x5b, 0x10, 0xd9, 0x8a, 0xd8, 0x3a, 0x80, 0x49, 0x09, 0x41, 0x55, - 0x28, 0xbf, 0x1b, 0xec, 0x05, 0xe1, 0x41, 0x60, 0x9e, 0x41, 0x35, 0x80, 0xad, 0x88, 0xa9, 0x04, - 0x5e, 0xd3, 0x40, 0xf3, 0x60, 0x66, 0x73, 0xec, 0xf9, 0x34, 0x31, 0x0b, 0x08, 0x41, 0xad, 0x49, - 0xfc, 0x5d, 0x3b, 0xf4, 0x7d, 0xd2, 0xbe, 0x8e, 0xdd, 0x3d, 0xb3, 0x88, 0x66, 0x60, 0xca, 0x76, - 0x65, 0xf6, 0x2e, 0x35, 0x4b, 0x68, 0x09, 0xe6, 0xee, 0xe1, 0xaf, 0x0f, 0xde, 0x0d, 0xbc, 0x0f, - 0xfa, 0x24, 0x20, 0x94, 0x0a, 0x94, 0x39, 0x61, 0x5d, 0x84, 0xe9, 0xac, 0xe1, 0x6b, 0xc9, 0x18, - 0xe9, 0x11, 0xe3, 0x77, 0x0c, 0xa8, 0x68, 0x23, 0xcf, 0x26, 0x4f, 0x1b, 0xb9, 0xe4, 0x69, 0xed, - 0x37, 0xd3, 0xf3, 0x89, 0x20, 0xe4, 0x87, 0xe2, 0x55, 0x98, 0xd5, 0x53, 0x83, 0xa3, 0x9d, 0x2e, - 0xa6, 0x5d, 0x95, 0x93, 0x51, 0xd7, 0x88, 0xbb, 0x64, 0x70, 0x07, 0xd3, 0x2e, 0x7a, 0x03, 0x40, - 0xbc, 0x36, 0x72, 0xbb, 0xd8, 0x0b, 0xd4, 0x59, 0x73, 0x71, 0x2d, 0x79, 0x7e, 0xfd, 0x1e, 0xf6, - 0xd8, 0xad, 0x30, 0xbe, 0x19, 0xf0, 0x5d, 0xc6, 0x14, 0xa7, 0xdc, 0xe0, 0x84, 0xd6, 0xb7, 0x0c, - 0xa8, 0x0f, 0x4d, 0xa8, 0xa3, 0xec, 0x63, 0x0d, 0xe6, 0x30, 0x63, 0xa4, 0x17, 0xf1, 0x2d, 0x46, - 0xaa, 0x53, 0x69, 0x27, 0xb3, 0x09, 0x2a, 0x51, 0xea, 0xa8, 0xb9, 0x8c, 0xf8, 0xdb, 0xd2, 0x88, - 0xbf, 0xb5, 0x36, 0xa1, 0x9a, 0x99, 0xa2, 0x8f, 0xb1, 0xd7, 0x23, 0x73, 0xd6, 0xad, 0xab, 0x60, - 0x0e, 0xcf, 0xd6, 0xfc, 0x75, 0xb1, 0x31, 0x74, 0x5d, 0xfc, 0x17, 0x06, 0xd4, 0x87, 0x26, 0xe6, - 0x51, 0x0c, 0x8c, 0x5e, 0xec, 0x7c, 0x06, 0xa6, 0x92, 0x79, 0x2c, 0x06, 0x5e, 0x5b, 0x47, 0xa3, - 0x53, 0xde, 0x4e, 0x89, 0xb8, 0x9a, 0x85, 0x63, 0xf5, 0x82, 0xce, 0x70, 0x02, 0x7d, 0x5d, 0x23, - 0x74, 0x0a, 0xfd, 0xa7, 0x01, 0x25, 0xb4, 0x23, 0x73, 0x4a, 0x63, 0x12, 0x41, 0x5e, 0x83, 0xfa, - 0x90, 0x7f, 0xc8, 0x67, 0x6e, 0x1b, 0x8f, 0xcd, 0xdc, 0xb6, 0xfe, 0xd2, 0x00, 0xe0, 0xa7, 0x06, - 0x99, 0x08, 0x83, 0x3e, 0x09, 0xb3, 0xc2, 0xcc, 0x0e, 0xb0, 0xef, 0xcb, 0x43, 0x46, 0x4f, 0xcb, - 0xa4, 0xc6, 0x11, 0xef, 0x61, 0xdf, 0xe7, 0xe4, 0xf7, 0x29, 0xba, 0x0a, 0xf3, 0x51, 0x1c, 0xba, - 0x84, 0xd2, 0x3c, 0xb5, 0x32, 0x16, 0x85, 0xcb, 0x54, 0x58, 0x83, 0xf9, 0xbd, 0x7d, 0xb1, 0x47, - 0xcf, 0x57, 0x90, 0x16, 0x6f, 0xee, 0xed, 0xf3, 0xdd, 0x7a, 0x86, 0x7e, 0x1d, 0x16, 0x59, 0xc8, - 0xb0, 0xef, 0xc4, 0x91, 0x9b, 0xa9, 0x11, 0x68, 0xe1, 0x21, 0x81, 0xb5, 0x23, 0x57, 0xd7, 0x79, - 0x40, 0xad, 0x6f, 0x16, 0x60, 0x3a, 0x1d, 0xce, 0xc3, 0xf5, 0x31, 0x03, 0x0a, 0xc6, 0x0e, 0xe8, - 0xc1, 0x23, 0x06, 0x14, 0x3c, 0x6a, 0x40, 0x0f, 0x28, 0x7a, 0x0b, 0xce, 0xe9, 0x0a, 0xb4, 0x4f, - 0x23, 0x12, 0xb4, 0xf3, 0x15, 0xe5, 0xc0, 0x1a, 0x8a, 0xa6, 0x29, 0x49, 0x32, 0xf5, 0xc7, 0x0a, - 0x24, 0x19, 0xde, 0x90, 0x40, 0x1e, 0x1c, 0x25, 0x90, 0x89, 0x47, 0x0a, 0xe4, 0x2b, 0x50, 0xe1, - 0x47, 0x3d, 0xb1, 0x35, 0x9c, 0x87, 0x09, 0x41, 0x21, 0xc6, 0x5f, 0xb4, 0x65, 0x81, 0xef, 0x33, - 0x14, 0x87, 0xa4, 0x2d, 0xc6, 0x5a, 0xb4, 0x53, 0x40, 0x12, 0xe6, 0xd9, 0x19, 0x30, 0x22, 0x47, - 0x54, 0x94, 0x61, 0x9e, 0xeb, 0x1c, 0x60, 0xfd, 0x6f, 0x03, 0x80, 0xb7, 0xaf, 0xcc, 0xe7, 0x65, - 0x98, 0x10, 0x4f, 0x66, 0x47, 0x2c, 0x4f, 0xf3, 0x60, 0x4b, 0x3c, 0xba, 0x0c, 0xa5, 0xe4, 0x29, - 0xd0, 0x58, 0x3a, 0x81, 0xe6, 0x64, 0x6d, 0xcc, 0xf0, 0x48, 0x8c, 0x25, 0x25, 0xe3, 0x68, 0xeb, - 0x9f, 0x27, 0xe4, 0xc7, 0x00, 0x12, 0xad, 0xbf, 0x02, 0x28, 0x19, 0x82, 0xde, 0xe6, 0x6a, 0xb5, - 0xcf, 0x26, 0x18, 0xb5, 0xd9, 0xa5, 0xe8, 0x4d, 0x58, 0x1a, 0x25, 0xcf, 0x3e, 0x31, 0x5f, 0x18, - 0xa9, 0x23, 0x76, 0xb7, 0x97, 0xa1, 0x26, 0x15, 0x92, 0x74, 0xa1, 0x92, 0xad, 0x05, 0x34, 0x69, - 0xfe, 0xcb, 0x70, 0x2e, 0xe6, 0x07, 0xb3, 0xf6, 0x8e, 0xd3, 0x16, 0xd7, 0x5b, 0x0e, 0xdd, 0xf3, - 0xa2, 0x48, 0xb8, 0xd8, 0x7e, 0xc0, 0x94, 0x9d, 0x2c, 0x2b, 0x1a, 0x79, 0x03, 0xd6, 0x94, 0x14, - 0x1b, 0x9c, 0x80, 0x9f, 0xac, 0x75, 0x03, 0x7c, 0x9d, 0xc8, 0xd7, 0x96, 0xd6, 0xb2, 0xa8, 0x08, - 0xee, 0x92, 0x41, 0xae, 0xea, 0xdb, 0x70, 0x5e, 0x57, 0xdd, 0x11, 0x8e, 0x41, 0x04, 0x1e, 0x9c, - 0x2e, 0x5f, 0x4a, 0x44, 0xf5, 0x89, 0x5c, 0xe7, 0xd7, 0x39, 0x8d, 0x88, 0x43, 0xdc, 0xf1, 0x98, - 0x6c, 0xe1, 0xb3, 0xd0, 0xc8, 0xb7, 0x20, 0xec, 0x41, 0x56, 0x96, 0xc9, 0x38, 0x0b, 0xd9, 0xca, - 0xdc, 0x66, 0x65, 0xc5, 0x37, 0x60, 0x69, 0x4c, 0x45, 0x6e, 0x48, 0x6a, 0x5b, 0x3f, 0x3f, 0x5c, - 0x8f, 0xdb, 0xd4, 0x23, 0xfa, 0x0b, 0x70, 0x10, 0xea, 0xcd, 0xfb, 0x48, 0x7f, 0x0f, 0x38, 0x92, - 0xfb, 0xce, 0x0e, 0x61, 0x0e, 0x0d, 0x70, 0x44, 0xbb, 0x21, 0x53, 0x55, 0xe4, 0xfb, 0x7e, 0xb3, - 0x43, 0x58, 0x53, 0x21, 0x24, 0x35, 0x17, 0x4c, 0x12, 0xbf, 0x74, 0xa2, 0x38, 0x8c, 0x42, 0x4a, - 0x1c, 0xe1, 0x2b, 0x64, 0xc5, 0xaa, 0x12, 0x8c, 0x0e, 0x69, 0x6e, 0x4b, 0x12, 0xbe, 0xd2, 0x8e, - 0x6b, 0x81, 0x6f, 0x78, 0xbc, 0xb8, 0x97, 0x6d, 0x61, 0x7a, 0xa8, 0x85, 0x0d, 0x49, 0x32, 0xda, - 0x42, 0x14, 0x86, 0xbe, 0x43, 0xdd, 0x2e, 0x69, 0xf7, 0xfd, 0x1c, 0x0f, 0x33, 0x69, 0x0b, 0xdb, - 0x61, 0xe8, 0x37, 0x15, 0x49, 0xd2, 0x82, 0xf5, 0x7f, 0x0d, 0xa8, 0x66, 0xd2, 0x1a, 0xd1, 0xeb, - 0x50, 0x15, 0x3e, 0x41, 0x66, 0x41, 0xaa, 0x69, 0x98, 0x46, 0x16, 0x52, 0xd7, 0x68, 0x03, 0x4b, - 0xbd, 0xfe, 0xeb, 0x50, 0x15, 0x61, 0x22, 0x55, 0xab, 0x30, 0x54, 0x2b, 0x9d, 0x5a, 0x36, 0xd0, - 0xe4, 0xbf, 0xcc, 0xbb, 0x96, 0x27, 0x63, 0xeb, 0x5f, 0x0c, 0x98, 0xc9, 0xa5, 0x57, 0x9e, 0x90, - 0x93, 0x2f, 0x42, 0x2d, 0xc3, 0x89, 0xb3, 0xbf, 0xae, 0x98, 0x59, 0x18, 0xc3, 0xcc, 0xc3, 0x75, - 0x7b, 0x9a, 0x66, 0x67, 0xfd, 0x67, 0x61, 0x5a, 0x78, 0x17, 0xdd, 0x67, 0x71, 0xe8, 0x5c, 0x20, - 0x36, 0x9a, 0xaa, 0xd3, 0xea, 0x41, 0x5a, 0xe0, 0xbd, 0x66, 0x78, 0x4d, 0x13, 0x78, 0x17, 0xc6, - 0xb0, 0xcb, 0x7b, 0x65, 0x99, 0x92, 0xf5, 0x61, 0x19, 0xaa, 0x99, 0x96, 0xd1, 0x6b, 0xb0, 0x48, - 0x59, 0x18, 0x13, 0x67, 0x87, 0x2f, 0xc8, 0x59, 0x6d, 0x4a, 0xff, 0x33, 0x27, 0xb0, 0xe2, 0xc6, - 0x36, 0xb5, 0x84, 0x37, 0x84, 0x07, 0x12, 0x26, 0x48, 0xe5, 0x3a, 0x92, 0xd4, 0x92, 0x2e, 0x65, - 0x5e, 0xa1, 0x9b, 0x62, 0x09, 0xd1, 0xd5, 0x56, 0x61, 0x36, 0xe2, 0x5e, 0x46, 0x3c, 0x53, 0xef, - 0xa8, 0x0a, 0x6a, 0x07, 0xa9, 0x10, 0xf7, 0xc2, 0x8e, 0xa4, 0xdd, 0x80, 0x0b, 0x31, 0xde, 0x65, - 0x4e, 0x7b, 0xc7, 0x91, 0x52, 0xf2, 0x09, 0x6e, 0x93, 0x38, 0xdb, 0x95, 0x74, 0x25, 0x2b, 0x9c, - 0xec, 0xc6, 0x8e, 0x18, 0xd3, 0x3d, 0x41, 0x93, 0x76, 0xb8, 0x0e, 0x8b, 0xba, 0x11, 0x1d, 0xa4, - 0x54, 0x75, 0xd5, 0x12, 0x24, 0xeb, 0x36, 0x65, 0xc0, 0x52, 0xd6, 0x79, 0x0b, 0xce, 0xe5, 0x3b, - 0xee, 0x91, 0x1e, 0xe3, 0x87, 0x58, 0x55, 0x53, 0x3a, 0x91, 0x46, 0xa6, 0xd7, 0xfb, 0x8a, 0x40, - 0xd6, 0xbf, 0x02, 0xea, 0xfc, 0x95, 0xe9, 0x4d, 0x3a, 0x10, 0x15, 0xf8, 0x4a, 0x7a, 0x7a, 0x0d, - 0x16, 0x71, 0x14, 0xf9, 0x83, 0x51, 0xd1, 0x4b, 0x37, 0x3e, 0x27, 0xb0, 0x43, 0xa2, 0x7f, 0x09, - 0xea, 0xb2, 0x52, 0xda, 0xfa, 0x94, 0x7a, 0x55, 0xca, 0xc1, 0xa3, 0x8d, 0xf7, 0xfa, 0x8c, 0x1c, - 0xca, 0x27, 0xa8, 0x59, 0x17, 0x23, 0x1b, 0xbf, 0xcf, 0x91, 0x7c, 0x9f, 0x95, 0xcc, 0x70, 0x59, - 0xe9, 0x51, 0x22, 0x57, 0x5e, 0x46, 0x10, 0x8d, 0x95, 0xf8, 0xab, 0xb0, 0x90, 0x6d, 0xe1, 0x00, - 0xfb, 0x39, 0xef, 0x82, 0xd2, 0x9a, 0xef, 0x61, 0x5f, 0x56, 0xf9, 0x22, 0xac, 0x64, 0xab, 0x0c, - 0x89, 0x5b, 0xfa, 0x94, 0xa5, 0xb4, 0xde, 0x88, 0xb4, 0xfd, 0x61, 0xe9, 0xc9, 0xe0, 0x6d, 0xcd, - 0xcf, 0x0b, 0xee, 0x45, 0x98, 0xd1, 0xdb, 0x1f, 0x49, 0xa6, 0x82, 0xb6, 0x0a, 0x28, 0x89, 0xf8, - 0x12, 0xd9, 0x8d, 0x43, 0xc6, 0x92, 0xfe, 0x4d, 0xb5, 0x44, 0x2a, 0xa8, 0x24, 0xfb, 0x2f, 0x70, - 0x76, 0xf8, 0xc9, 0x66, 0x96, 0x81, 0x59, 0xb5, 0x93, 0x1a, 0xfe, 0xe8, 0x80, 0x76, 0x83, 0xef, - 0xc3, 0xa4, 0x4c, 0x53, 0x48, 0xb3, 0xa5, 0x8d, 0xc7, 0xe4, 0x8b, 0x1f, 0x33, 0x9b, 0xcf, 0xfa, - 0xd0, 0x80, 0x8a, 0x7e, 0x68, 0x85, 0xce, 0x42, 0x21, 0x8c, 0xd4, 0x07, 0x0b, 0x72, 0x71, 0xac, - 0x42, 0x18, 0x1d, 0x3b, 0x3f, 0x30, 0x77, 0x82, 0x28, 0x1d, 0xe3, 0x04, 0x61, 0xfd, 0xb4, 0x00, - 0x53, 0xf7, 0xf7, 0x5d, 0x57, 0xa8, 0x0b, 0x5d, 0xc8, 0x7d, 0x37, 0x21, 0xc7, 0x86, 0xfc, 0x3a, - 0xc2, 0x11, 0x37, 0x85, 0x67, 0x47, 0xbe, 0x11, 0x90, 0x79, 0x3f, 0x78, 0x01, 0xaa, 0xb4, 0x1b, - 0xc6, 0xcc, 0xc9, 0x7c, 0x25, 0xc0, 0x06, 0x01, 0x12, 0x5f, 0xa4, 0xe0, 0xfb, 0xa4, 0x2e, 0xa6, - 0x4e, 0xb8, 0x4f, 0x62, 0x1f, 0x8b, 0x2d, 0x88, 0x7e, 0xb3, 0xab, 0x72, 0xf8, 0x16, 0xba, 0x98, - 0x6e, 0x25, 0x58, 0xfd, 0x18, 0x06, 0x5d, 0x84, 0x69, 0x5e, 0xaf, 0xe3, 0x3a, 0xbb, 0xe2, 0xdb, - 0x0c, 0x32, 0x87, 0x05, 0xba, 0x98, 0xde, 0x76, 0x6f, 0x89, 0x8f, 0x33, 0x2c, 0x43, 0x25, 0xc1, - 0xca, 0xb9, 0x5d, 0xee, 0x28, 0xd4, 0x27, 0xa0, 0x26, 0xe2, 0x6d, 0x6e, 0x17, 0x07, 0x1d, 0x11, - 0x14, 0x94, 0x93, 0x79, 0x9a, 0x43, 0x37, 0x04, 0x50, 0x84, 0x17, 0x96, 0x92, 0x8d, 0x9b, 0x8e, - 0xd0, 0xc9, 0x1a, 0x6a, 0x36, 0xcf, 0x6b, 0xb4, 0x0c, 0xcf, 0xc9, 0x8a, 0xd6, 0x97, 0xa4, 0x60, - 0xe5, 0xf0, 0x8e, 0x38, 0x07, 0x8e, 0xfd, 0xe0, 0x84, 0xf5, 0xbd, 0x22, 0x54, 0x78, 0x75, 0x11, - 0x55, 0x7d, 0x1a, 0xb5, 0x64, 0x82, 0x2c, 0xc5, 0x7c, 0x90, 0xe5, 0xb1, 0x3a, 0x19, 0xcd, 0x2e, - 0x3d, 0xce, 0x07, 0x4e, 0xb2, 0x21, 0xdb, 0xf2, 0x70, 0xc8, 0xf6, 0xb8, 0xb1, 0xd5, 0xa1, 0xb8, - 0xe9, 0xd4, 0x68, 0xdc, 0xf4, 0x02, 0x54, 0x93, 0x27, 0xdf, 0x4c, 0x46, 0x56, 0x4b, 0x36, 0x68, - 0x50, 0x8b, 0x8e, 0x51, 0x6e, 0xf5, 0xc9, 0x94, 0x3b, 0x7d, 0x84, 0x72, 0xbf, 0x61, 0x48, 0xf5, - 0x88, 0xc3, 0x8f, 0x3e, 0x71, 0x18, 0x63, 0x6e, 0x2b, 0x45, 0x36, 0x85, 0x3c, 0x71, 0xac, 0xc2, - 0xa4, 0xf0, 0x9a, 0x3a, 0x6d, 0x02, 0xe5, 0x08, 0xc5, 0x04, 0xb4, 0x15, 0x05, 0xa7, 0x55, 0x5f, - 0xcd, 0x28, 0x8e, 0xa1, 0x15, 0xea, 0xd1, 0x5f, 0xd2, 0xb0, 0x5e, 0x83, 0xb2, 0x7a, 0x3b, 0x23, - 0x34, 0x76, 0x18, 0x28, 0x0b, 0xe3, 0x7f, 0xd1, 0x22, 0x4c, 0x52, 0xf1, 0x8e, 0x5c, 0xd9, 0x85, - 0x2a, 0x59, 0x6f, 0x8b, 0xc8, 0xb1, 0xb8, 0xc0, 0xcf, 0xe7, 0x8c, 0x18, 0x8f, 0xce, 0x98, 0x2a, - 0xe4, 0x32, 0xa6, 0xfe, 0xcc, 0x00, 0x90, 0x2b, 0x8a, 0xe8, 0xfa, 0xc8, 0xfb, 0xd7, 0x25, 0x28, - 0x47, 0x84, 0xc4, 0x1c, 0xa5, 0xd8, 0xe0, 0xc5, 0xcd, 0x76, 0x72, 0x7d, 0x5a, 0xcc, 0x5c, 0x9f, - 0x0e, 0x5f, 0xd6, 0x96, 0x8e, 0x79, 0x59, 0xfb, 0xaa, 0x3a, 0x4f, 0xf2, 0x11, 0x12, 0x15, 0x6a, - 0x46, 0x99, 0xfb, 0x1d, 0xdc, 0x6e, 0x72, 0x8c, 0x3c, 0x63, 0x8a, 0xbf, 0xd6, 0x26, 0x4c, 0x25, - 0xf0, 0xd1, 0x9b, 0x42, 0x63, 0xfc, 0x4d, 0xa1, 0x78, 0x92, 0xc3, 0x52, 0x81, 0xe2, 0x5d, 0xd2, - 0xa2, 0x56, 0x13, 0x90, 0x4c, 0x71, 0x12, 0x22, 0xd1, 0xd7, 0x71, 0xaf, 0xa4, 0x49, 0x1c, 0xf2, - 0x89, 0x6d, 0xba, 0x4d, 0x4d, 0x65, 0x97, 0x64, 0x72, 0xa0, 0x1a, 0x14, 0x92, 0x86, 0x0b, 0x8c, - 0x5a, 0x5f, 0x86, 0xb9, 0x5c, 0xa3, 0xea, 0xe6, 0xbd, 0x91, 0x6f, 0xb5, 0xf4, 0xe8, 0x06, 0x6e, - 0x00, 0x6a, 0xf2, 0x3d, 0x61, 0x93, 0x33, 0xd9, 0xd4, 0x5c, 0xad, 0xc1, 0x14, 0x3f, 0xec, 0x89, - 0xbc, 0x8d, 0x71, 0xab, 0x99, 0xcc, 0xeb, 0xa8, 0xec, 0xa9, 0x7f, 0xd6, 0x1a, 0xcc, 0xe5, 0x5a, - 0x51, 0x6c, 0x64, 0x64, 0x61, 0xe4, 0x64, 0xe1, 0x8a, 0x5c, 0xc8, 0xdb, 0x84, 0x1b, 0x50, 0xab, - 0x75, 0xef, 0xd9, 0xbc, 0x6b, 0xf8, 0xa6, 0x21, 0xf2, 0x13, 0x33, 0xbd, 0x3c, 0x83, 0xbc, 0x84, - 0xf4, 0x83, 0x08, 0xc2, 0xff, 0x1d, 0xf9, 0xb2, 0xe1, 0x67, 0xf2, 0x09, 0xc0, 0xc6, 0xb5, 0xe6, - 0xb3, 0x7c, 0x02, 0xf0, 0x69, 0x40, 0x51, 0x4c, 0xf6, 0xbd, 0xb0, 0x4f, 0x33, 0xdf, 0xb9, 0x90, - 0xbc, 0x98, 0x1a, 0x93, 0x7c, 0xe5, 0xe2, 0x32, 0xd4, 0x12, 0x6a, 0xd9, 0x98, 0x7c, 0xfa, 0x38, - 0xa3, 0xa1, 0x0f, 0x33, 0xef, 0x0a, 0x26, 0x87, 0xdf, 0x15, 0x94, 0x93, 0x91, 0x5b, 0x1f, 0xc9, - 0x3c, 0x68, 0x31, 0xb8, 0xd3, 0x96, 0x73, 0x03, 0xca, 0xb4, 0xef, 0xba, 0x44, 0x65, 0xf4, 0x54, - 0x6c, 0x5d, 0x7c, 0x26, 0x83, 0xb5, 0x6e, 0xc0, 0xe2, 0x6d, 0xc2, 0xf4, 0x2e, 0x4f, 0x4c, 0xc0, - 0x27, 0xd7, 0x97, 0xf5, 0x6d, 0x03, 0x96, 0x46, 0x9a, 0x39, 0x6d, 0xc9, 0x7c, 0x86, 0x3b, 0x5f, - 0x26, 0x96, 0xc0, 0xe2, 0x91, 0x71, 0x79, 0x4d, 0x66, 0xdd, 0x86, 0xe5, 0x0c, 0x57, 0x77, 0x3c, - 0x7e, 0x22, 0x3c, 0x49, 0xde, 0x93, 0xf5, 0x1d, 0x03, 0x56, 0xc6, 0xb5, 0xf4, 0xcb, 0x1f, 0xe2, - 0x9f, 0xcb, 0xcc, 0xf2, 0x8d, 0x50, 0x9d, 0x06, 0xc2, 0xf8, 0x84, 0x69, 0xc2, 0x6e, 0x18, 0xc5, - 0xf2, 0xe2, 0x5c, 0x72, 0x54, 0xe1, 0x00, 0x71, 0x5f, 0x2e, 0xce, 0x85, 0x51, 0xac, 0x83, 0x6f, - 0x4e, 0x4c, 0x3e, 0x50, 0x9e, 0xa7, 0xc6, 0xe1, 0xe9, 0xdb, 0xb6, 0x4c, 0x7e, 0x5c, 0xe9, 0x71, - 0x39, 0xdb, 0x48, 0x45, 0x1c, 0xa5, 0x51, 0xca, 0xf0, 0x62, 0x5f, 0x64, 0xa6, 0xe7, 0x86, 0x72, - 0xda, 0x02, 0x46, 0x99, 0x40, 0xa7, 0xee, 0xf6, 0xfb, 0xf2, 0xc5, 0x8e, 0x58, 0x5b, 0x68, 0xbf, - 0x77, 0x12, 0xf9, 0x7d, 0x0e, 0xa6, 0xb0, 0xdf, 0x09, 0x63, 0x8f, 0x75, 0x7b, 0xa2, 0xc3, 0xda, - 0xfa, 0x4a, 0x4a, 0xad, 0x1a, 0xbe, 0xa6, 0x29, 0xec, 0x94, 0xf8, 0x49, 0x52, 0x0a, 0xff, 0x50, - 0x66, 0xd5, 0xa7, 0x7c, 0x9e, 0xb6, 0x70, 0x56, 0xa0, 0xe2, 0xaa, 0xc6, 0x93, 0x33, 0x8b, 0x2a, - 0x73, 0x0b, 0x91, 0x21, 0xd8, 0xbd, 0xfd, 0xe4, 0x83, 0x28, 0x02, 0x70, 0x77, 0x5f, 0x6c, 0x3f, - 0x25, 0x52, 0x46, 0xaf, 0xe5, 0x1e, 0x19, 0x04, 0x48, 0x86, 0xaf, 0x7f, 0x50, 0x84, 0xe9, 0x8d, - 0xb0, 0x17, 0x61, 0x97, 0x49, 0x06, 0xde, 0x87, 0x05, 0x12, 0xc7, 0x8e, 0x17, 0xec, 0x63, 0xdf, - 0x6b, 0x3b, 0xf9, 0x1d, 0x57, 0x75, 0xfd, 0x13, 0xd9, 0x3b, 0xe2, 0xa4, 0xd6, 0xa6, 0xa4, 0x6e, - 0xaa, 0xdd, 0xd8, 0x9d, 0x33, 0x36, 0x22, 0xf1, 0x30, 0x14, 0xf9, 0x70, 0x8e, 0x37, 0x1d, 0xa9, - 0x2c, 0x5e, 0x47, 0x9d, 0xc9, 0x13, 0x87, 0x29, 0x03, 0x5d, 0xab, 0x63, 0x7b, 0xd0, 0xa9, 0xbf, - 0x2d, 0x71, 0x4e, 0x57, 0xae, 0xf4, 0xce, 0x19, 0xbb, 0x41, 0xe2, 0xf1, 0x38, 0xe4, 0xc0, 0x12, - 0xef, 0xcd, 0x95, 0x8d, 0x38, 0x5e, 0xe0, 0x44, 0x71, 0xd8, 0x89, 0x09, 0xa5, 0x2a, 0x2c, 0xf6, - 0xd2, 0xd8, 0x8e, 0xd4, 0xff, 0xcd, 0x60, 0x5b, 0x51, 0xdf, 0x39, 0x63, 0xcf, 0x93, 0x78, 0x14, - 0x8e, 0x76, 0x61, 0x85, 0x77, 0xc0, 0xc2, 0xd0, 0xe9, 0xe1, 0x60, 0xe0, 0x44, 0x24, 0x68, 0x7b, - 0x41, 0xc7, 0x61, 0x98, 0xee, 0x51, 0xb5, 0x1d, 0xbc, 0x32, 0xb6, 0x8f, 0x56, 0x18, 0xde, 0xc7, - 0xc1, 0x60, 0x5b, 0x56, 0x68, 0x71, 0xfa, 0x3b, 0x67, 0xec, 0x45, 0x12, 0x8f, 0xc3, 0x5c, 0x2f, - 0x2b, 0x93, 0xb0, 0xce, 0xc3, 0xd9, 0x23, 0x84, 0x6e, 0xbd, 0x08, 0x97, 0x1e, 0x2b, 0x31, 0xeb, - 0x02, 0x9c, 0x3f, 0x72, 0xb4, 0xd6, 0x25, 0xb8, 0xf0, 0x18, 0x56, 0xf9, 0x0e, 0xa2, 0xa6, 0x68, - 0xf4, 0x94, 0x3c, 0x72, 0x6f, 0xbe, 0x0a, 0xb3, 0x43, 0x3a, 0xf7, 0xf4, 0x3d, 0x4b, 0x3d, 0xca, - 0x72, 0xb9, 0xd9, 0x16, 0xc1, 0x97, 0xb0, 0x93, 0x27, 0x95, 0x77, 0x2e, 0x35, 0x05, 0xd7, 0x94, - 0x43, 0x29, 0x64, 0xe5, 0xe3, 0xa5, 0x90, 0x0d, 0x25, 0x44, 0x55, 0x86, 0x13, 0xa2, 0xac, 0x3f, - 0x95, 0xf7, 0xc5, 0x72, 0x70, 0x6a, 0x1e, 0x7f, 0x2a, 0x1f, 0x52, 0x59, 0x18, 0xab, 0x54, 0x3d, - 0x57, 0x5f, 0x84, 0x19, 0x7e, 0xd4, 0x8f, 0x49, 0x0f, 0x7b, 0x81, 0x17, 0x74, 0xd4, 0xb3, 0x00, - 0x7e, 0xfe, 0xb7, 0x35, 0x0c, 0xad, 0x89, 0x3c, 0x0c, 0x5e, 0x97, 0x64, 0xe7, 0x98, 0x74, 0x7e, - 0xb3, 0x09, 0xaa, 0x99, 0x11, 0x61, 0x4a, 0x9f, 0x7f, 0x3e, 0x5c, 0x4f, 0x10, 0x37, 0xe5, 0x89, - 0xe7, 0x15, 0x58, 0x6e, 0x79, 0xe2, 0x45, 0x70, 0x73, 0x40, 0x19, 0xe9, 0x09, 0x81, 0x69, 0x45, - 0x99, 0x50, 0xa4, 0x1f, 0xf8, 0x2a, 0x05, 0x8b, 0xff, 0xb5, 0x22, 0x58, 0x19, 0x47, 0xae, 0x86, - 0x6e, 0x2b, 0xb7, 0x2c, 0x74, 0x7a, 0xfd, 0xad, 0x8f, 0x7e, 0x71, 0xe1, 0xcc, 0xcf, 0x7e, 0x71, - 0xe1, 0xcd, 0x8e, 0xc7, 0xba, 0xfd, 0x9d, 0x35, 0x37, 0xec, 0x5d, 0x8d, 0xbc, 0xa0, 0xe3, 0xe2, - 0xe8, 0xea, 0xde, 0xbe, 0xfc, 0x5a, 0x7a, 0xb4, 0xd7, 0xb9, 0x4a, 0xbb, 0x38, 0x26, 0x6d, 0xe1, - 0x73, 0xd6, 0x9a, 0xe2, 0xbf, 0xf0, 0x36, 0xd2, 0xad, 0xaf, 0xbe, 0x03, 0xcb, 0x8f, 0xfc, 0x78, - 0x26, 0x9a, 0x07, 0x33, 0x2d, 0x3d, 0x08, 0xe3, 0x1e, 0xf6, 0xcd, 0x33, 0x68, 0x09, 0xe6, 0x52, - 0xe8, 0xad, 0x30, 0x76, 0xc5, 0x5b, 0x06, 0xd3, 0x58, 0xf5, 0xe1, 0xdc, 0x51, 0x5f, 0xcb, 0xe4, - 0xcd, 0xa9, 0x97, 0x02, 0x7d, 0x9f, 0x25, 0xcd, 0x5d, 0x84, 0x73, 0x29, 0xf4, 0xde, 0xc8, 0x47, - 0x2f, 0x65, 0x3a, 0x45, 0x4a, 0x21, 0x6f, 0xc9, 0xcd, 0xc2, 0xea, 0xcb, 0x00, 0xa9, 0x5d, 0xa1, - 0x49, 0x28, 0x3c, 0x7c, 0xd5, 0x3c, 0x83, 0xa6, 0x60, 0xe2, 0xe1, 0xab, 0xad, 0xd6, 0x3d, 0xd3, - 0x10, 0xa0, 0x75, 0xb3, 0xb0, 0xfa, 0x29, 0x80, 0x34, 0x85, 0x16, 0x01, 0x4c, 0x26, 0x5d, 0x97, - 0xa1, 0x78, 0x2f, 0x3c, 0x30, 0x0d, 0x54, 0x81, 0xd2, 0x1d, 0xaf, 0xd3, 0x35, 0x0b, 0xab, 0x57, - 0xa1, 0x96, 0xcf, 0x9b, 0xe5, 0xcd, 0x34, 0x37, 0xcd, 0x33, 0xfc, 0xd7, 0xde, 0x30, 0x0d, 0x91, - 0xb2, 0xb1, 0x21, 0x53, 0x36, 0x9a, 0x66, 0x61, 0xf5, 0x21, 0x54, 0x33, 0x39, 0x98, 0x9c, 0xd7, - 0x07, 0x21, 0xbb, 0xe6, 0xfb, 0xe1, 0x01, 0x69, 0x6f, 0x05, 0x1c, 0x2c, 0x45, 0x96, 0x80, 0xae, - 0xf9, 0xbd, 0x90, 0x32, 0x81, 0x30, 0x50, 0x03, 0xe6, 0x33, 0x08, 0x91, 0xe0, 0x21, 0x30, 0x85, - 0x55, 0x17, 0x0a, 0x5b, 0x11, 0xe7, 0x70, 0xbb, 0xcf, 0x24, 0xab, 0x37, 0x88, 0x2f, 0x59, 0x15, - 0xe2, 0x2e, 0xa0, 0x69, 0xa8, 0xe8, 0x98, 0x96, 0x59, 0xe4, 0xe3, 0xda, 0x0c, 0x28, 0x89, 0x99, - 0x59, 0x42, 0x73, 0x50, 0x1f, 0x52, 0x84, 0x39, 0x81, 0x10, 0xd4, 0x04, 0xd7, 0xda, 0xfd, 0x50, - 0x73, 0x72, 0x75, 0x0d, 0xa6, 0x92, 0x10, 0x1f, 0x6f, 0xf9, 0x41, 0x18, 0x10, 0x29, 0x44, 0x41, - 0x62, 0x1a, 0xbc, 0x13, 0x5d, 0x41, 0x4a, 0x27, 0xff, 0x75, 0x67, 0xce, 0xd7, 0xd6, 0xee, 0xae, - 0x79, 0x86, 0xd7, 0xbe, 0x85, 0x45, 0x15, 0x80, 0xc9, 0x26, 0x8b, 0xb9, 0xea, 0x0a, 0xab, 0xdf, - 0x35, 0x60, 0x52, 0x7d, 0x13, 0x59, 0xb4, 0x24, 0xff, 0x9b, 0x67, 0xd0, 0x02, 0xcc, 0xb6, 0x5a, - 0xf7, 0x64, 0x12, 0x48, 0x32, 0x0a, 0x21, 0x0f, 0x11, 0xae, 0x56, 0x5d, 0x26, 0x98, 0x02, 0xaf, - 0x70, 0x3f, 0xc9, 0xda, 0x68, 0x6e, 0xf7, 0x69, 0x97, 0xb4, 0xcd, 0x22, 0xb7, 0x9e, 0xa4, 0x9d, - 0x31, 0xdf, 0xb5, 0x34, 0x4b, 0x68, 0x19, 0x16, 0xb2, 0x4d, 0xde, 0x08, 0x1f, 0x84, 0xac, 0xeb, - 0x05, 0x1d, 0x73, 0x62, 0xf5, 0x32, 0x94, 0x6f, 0x1e, 0xb2, 0x18, 0x6f, 0x45, 0x72, 0xf0, 0x61, - 0x64, 0x9e, 0x41, 0x26, 0x4c, 0xf3, 0x03, 0xfe, 0x96, 0xdf, 0x16, 0x7b, 0x7f, 0xd3, 0x58, 0xb5, - 0x60, 0x76, 0x64, 0x77, 0xc2, 0xcd, 0x60, 0x23, 0x76, 0xdf, 0x7c, 0xdd, 0xf9, 0xaf, 0x61, 0x6c, - 0x9e, 0xb9, 0xfe, 0xd2, 0xdf, 0xfc, 0x6e, 0xc5, 0xf8, 0xe8, 0xe3, 0x17, 0x8c, 0x9f, 0x7c, 0xfc, - 0x82, 0xf1, 0x77, 0x1f, 0xbf, 0x60, 0xfc, 0xd6, 0xdf, 0xbf, 0x70, 0x06, 0xcc, 0x30, 0xee, 0xac, - 0x31, 0x6f, 0x6f, 0x7f, 0x4d, 0xcd, 0xc8, 0x9d, 0x49, 0xf1, 0xf3, 0xda, 0xbf, 0x07, 0x00, 0x00, - 0xff, 0xff, 0x0b, 0x1e, 0x48, 0xfa, 0x08, 0x61, 0x00, 0x00, + 0xeb, 0xd9, 0x1d, 0x6b, 0xbd, 0x1a, 0xaf, 0xf6, 0xe1, 0xe7, 0x5d, 0xef, 0x8c, 0xe6, 0xa5, 0x9d, + 0x87, 0x84, 0x26, 0x77, 0xf6, 0x2e, 0xee, 0xb5, 0xdb, 0xa5, 0x66, 0x89, 0x6c, 0xa8, 0xd9, 0xdd, + 0xdb, 0x55, 0x94, 0x44, 0x5f, 0x5c, 0xe0, 0x1a, 0xf7, 0x01, 0x18, 0xb8, 0xd7, 0x37, 0x31, 0x0c, + 0x38, 0x80, 0x8d, 0x00, 0xf9, 0x30, 0x10, 0xe7, 0x23, 0x40, 0x90, 0x9f, 0x3c, 0x3e, 0x82, 0x00, + 0xfe, 0xd8, 0x04, 0x31, 0x6c, 0x20, 0x08, 0x1c, 0xd8, 0x81, 0x11, 0x6c, 0x80, 0x7c, 0xe7, 0x27, + 0x48, 0x7e, 0x82, 0x04, 0xf5, 0xea, 0x07, 0xc9, 0xd1, 0x68, 0x34, 0x9a, 0xb1, 0x93, 0x2f, 0xb2, + 0xce, 0x39, 0x55, 0x75, 0xea, 0x9c, 0x53, 0xa7, 0xaa, 0x4e, 0x9d, 0x6a, 0x98, 0xd9, 0xdb, 0x8f, + 0x23, 0x37, 0xda, 0x59, 0x8b, 0xe2, 0x90, 0x85, 0xa8, 0xac, 0x8a, 0x2b, 0xd3, 0x3d, 0xc2, 0xb0, + 0x06, 0xaf, 0xcc, 0x90, 0x38, 0x0e, 0xe3, 0xa4, 0x38, 0xdf, 0x09, 0x3b, 0xa1, 0xf8, 0x7b, 0x95, + 0xff, 0x53, 0xd0, 0x7a, 0xdc, 0xa7, 0x4c, 0xfc, 0x55, 0x80, 0x5a, 0x9b, 0xe0, 0xb6, 0x1f, 0xba, + 0x7b, 0xba, 0x15, 0x16, 0x63, 0x97, 0x24, 0xad, 0x2c, 0xc6, 0x84, 0x86, 0xfd, 0xd8, 0x25, 0x4e, + 0x0f, 0x07, 0xb8, 0x43, 0x62, 0x09, 0xb7, 0xda, 0x00, 0xb7, 0x09, 0xb3, 0xc9, 0x87, 0x7d, 0x42, + 0x19, 0x5a, 0x85, 0xb2, 0x1b, 0x06, 0x8c, 0x1c, 0xb2, 0x86, 0x71, 0xd1, 0xb8, 0x52, 0x5d, 0x37, + 0xd7, 0x34, 0xcb, 0x1b, 0x12, 0x6e, 0x6b, 0x02, 0x64, 0x42, 0x71, 0x8f, 0x0c, 0x1a, 0x85, 0x8b, + 0xc6, 0x95, 0x69, 0x9b, 0xff, 0x45, 0x0d, 0x28, 0xef, 0x93, 0x98, 0x7a, 0x61, 0xd0, 0x28, 0x5e, + 0x34, 0xae, 0x94, 0x6c, 0x5d, 0xb4, 0x3e, 0x36, 0xa0, 0x2a, 0xba, 0xa1, 0x51, 0x18, 0x50, 0x82, + 0x5e, 0x83, 0xe9, 0x98, 0x74, 0xbc, 0x30, 0x70, 0xc4, 0x58, 0x55, 0x67, 0xb5, 0x35, 0x3d, 0xf2, + 0x9b, 0xfc, 0xd7, 0xae, 0x4a, 0x1a, 0x51, 0x40, 0x2f, 0xc3, 0x84, 0xa4, 0x2d, 0x08, 0xda, 0xd9, + 0x84, 0xb1, 0xbb, 0x64, 0x20, 0xc9, 0x25, 0x1e, 0xcd, 0xc3, 0xc4, 0x3e, 0xf6, 0xfb, 0x44, 0xf0, + 0x30, 0x6d, 0xcb, 0x02, 0x3a, 0x0b, 0x53, 0x41, 0xc8, 0x9c, 0xdd, 0xb0, 0x1f, 0xb4, 0x1b, 0xa5, + 0x8b, 0xc6, 0x95, 0x8a, 0x5d, 0x09, 0x42, 0x76, 0x8b, 0x97, 0xd1, 0xdb, 0x50, 0x27, 0x87, 0xc4, + 0x75, 0xda, 0x84, 0x61, 0xcf, 0xa7, 0xce, 0xfe, 0x7a, 0x63, 0x52, 0xf4, 0xb2, 0x98, 0xf4, 0x72, + 0xf3, 0x90, 0xb8, 0x37, 0x24, 0xfa, 0xe1, 0xba, 0x3d, 0x43, 0xb2, 0xc5, 0x77, 0x4b, 0x95, 0x09, + 0x73, 0xd2, 0xfa, 0x47, 0x03, 0xaa, 0x4d, 0x17, 0x07, 0x27, 0x11, 0xe6, 0x59, 0x98, 0xa2, 0x0c, + 0xc7, 0xcc, 0x49, 0x45, 0x5a, 0x11, 0x80, 0xbb, 0x64, 0xc0, 0x47, 0xe4, 0x7b, 0x3d, 0x8f, 0x89, + 0x11, 0xcd, 0xd8, 0xb2, 0x90, 0x95, 0x76, 0x29, 0x27, 0x6d, 0xb4, 0x0c, 0x95, 0x3d, 0x32, 0x70, + 0xc2, 0xc0, 0x1f, 0x34, 0x26, 0xc4, 0x50, 0xcb, 0x7b, 0x64, 0xb0, 0x15, 0xf8, 0x42, 0x45, 0x31, + 0xe1, 0x74, 0x44, 0x8c, 0xb0, 0x62, 0xeb, 0x22, 0x5a, 0x82, 0x32, 0x09, 0xda, 0xa2, 0xff, 0xb2, + 0xe8, 0x7f, 0x92, 0x04, 0x6d, 0xde, 0xfb, 0x05, 0xa8, 0x52, 0xdc, 0x8b, 0x7c, 0xe2, 0x50, 0x46, + 0xa2, 0x46, 0x45, 0xf0, 0x00, 0x12, 0xd4, 0x64, 0x24, 0xb2, 0x7e, 0xdd, 0x80, 0x69, 0x39, 0xee, + 0x93, 0x6b, 0xf7, 0x32, 0x4c, 0x44, 0xd8, 0x8b, 0x69, 0xa3, 0x70, 0xb1, 0x78, 0xa5, 0xba, 0x5e, + 0x4f, 0xb5, 0xbb, 0xbf, 0x8d, 0xbd, 0xd8, 0x96, 0xd8, 0xd4, 0x08, 0x8a, 0x47, 0x1b, 0x81, 0xf5, + 0x51, 0x19, 0xea, 0xdb, 0x31, 0x39, 0x88, 0x3d, 0x46, 0x4e, 0xa2, 0x8f, 0xab, 0x30, 0xd5, 0xeb, + 0x33, 0xcc, 0xbc, 0x30, 0xd0, 0x3c, 0xa5, 0x9d, 0xdd, 0x57, 0x18, 0x3b, 0xa5, 0x41, 0x97, 0x60, + 0x3a, 0x8a, 0xbd, 0x1e, 0x8e, 0x07, 0x0e, 0x9f, 0x84, 0xca, 0xf8, 0xaa, 0x0a, 0x76, 0x2f, 0x74, + 0xf7, 0xd0, 0x8b, 0x30, 0x23, 0x75, 0x9c, 0x57, 0xdb, 0xb4, 0x00, 0x3e, 0x4c, 0x75, 0xc7, 0xeb, + 0x3b, 0x8c, 0xf9, 0x42, 0x77, 0x25, 0xbb, 0xcc, 0xcb, 0x2d, 0xe6, 0xa3, 0x75, 0x58, 0xa0, 0x7b, + 0x5e, 0xe4, 0xb8, 0x61, 0x40, 0x59, 0x8c, 0xbd, 0x80, 0x39, 0x6e, 0x97, 0xb8, 0x7b, 0x4a, 0x93, + 0x73, 0x1c, 0xb9, 0x91, 0xe0, 0x36, 0x38, 0x0a, 0xfd, 0x17, 0x98, 0x8b, 0x08, 0xa5, 0x5e, 0xcf, + 0xa3, 0xcc, 0x73, 0x1d, 0xec, 0xca, 0x11, 0x95, 0x2f, 0x16, 0xaf, 0xd4, 0xd6, 0x57, 0x93, 0x11, + 0x0d, 0x89, 0x6a, 0x6d, 0x3b, 0xad, 0x73, 0x4d, 0x54, 0xb1, 0x51, 0x34, 0x0c, 0xa2, 0x9c, 0x57, + 0x76, 0x18, 0x38, 0xd4, 0xfb, 0x1a, 0x11, 0x66, 0x51, 0xb2, 0xcb, 0xec, 0x30, 0x68, 0x7a, 0x5f, + 0x23, 0xc8, 0x82, 0x99, 0xdd, 0x30, 0x76, 0xfa, 0x51, 0x1b, 0x33, 0xe2, 0x30, 0xda, 0x98, 0x12, + 0xf8, 0xea, 0x6e, 0x18, 0xbf, 0x27, 0x60, 0x2d, 0xca, 0x69, 0x7a, 0x5e, 0xe0, 0xb8, 0x61, 0xaf, + 0xe7, 0x31, 0x4e, 0x03, 0x92, 0xa6, 0xe7, 0x05, 0x1b, 0x02, 0xd6, 0xa2, 0xe8, 0x0a, 0x98, 0x7d, + 0x4a, 0x1c, 0x4c, 0x07, 0x81, 0xab, 0x28, 0x1b, 0x55, 0x31, 0xdc, 0x5a, 0x9f, 0x92, 0x6b, 0x1c, + 0x2c, 0x69, 0xd1, 0x45, 0xa8, 0x52, 0xe2, 0x86, 0x41, 0x1b, 0xc7, 0x1e, 0xa1, 0x8d, 0xe9, 0x8b, + 0x45, 0x2e, 0xff, 0x0c, 0x08, 0x9d, 0x03, 0x60, 0x31, 0x9f, 0x16, 0xc4, 0x89, 0xdc, 0xc6, 0x8c, + 0xf4, 0x01, 0x2c, 0x1e, 0x6c, 0x05, 0x64, 0xdb, 0x15, 0xdc, 0xe0, 0xc3, 0x0c, 0x37, 0x35, 0xc5, + 0x0d, 0x3e, 0x4c, 0xb8, 0x79, 0x07, 0xea, 0x98, 0x52, 0x12, 0xf3, 0xe1, 0x3b, 0x3e, 0xd9, 0x27, + 0x7e, 0xa3, 0x7e, 0xd1, 0xb8, 0x52, 0x5b, 0x5f, 0x4a, 0x24, 0x79, 0x4d, 0xe3, 0xef, 0x71, 0xb4, + 0x5d, 0xc3, 0xb9, 0x32, 0xf2, 0x60, 0x39, 0x27, 0x97, 0x8c, 0x32, 0x69, 0xc3, 0x14, 0x76, 0xb6, + 0xf6, 0x48, 0xad, 0xdc, 0x4a, 0x84, 0xd7, 0x4c, 0xf5, 0x6c, 0x2f, 0x66, 0x64, 0x9a, 0x82, 0xe9, + 0xca, 0x0e, 0x2c, 0x8c, 0xad, 0xc0, 0xdd, 0x89, 0x17, 0xb4, 0xc9, 0xa1, 0x98, 0x05, 0x33, 0xb6, + 0x2c, 0xa0, 0xd7, 0x61, 0x91, 0x1c, 0x46, 0xc4, 0x65, 0xa4, 0xed, 0xe4, 0x55, 0x57, 0x10, 0x82, + 0x98, 0xd3, 0xd8, 0xb4, 0x51, 0x6a, 0xed, 0xc0, 0xec, 0x88, 0xa9, 0xa0, 0x15, 0x58, 0x6c, 0xde, + 0xdd, 0xdc, 0x76, 0xb6, 0x6f, 0x36, 0x9b, 0x9b, 0xf7, 0x37, 0x9b, 0xad, 0xcd, 0x0d, 0x67, 0xe3, + 0xce, 0xcd, 0x8d, 0xbb, 0xe6, 0x19, 0xd4, 0x80, 0xf9, 0x1b, 0x5b, 0x63, 0x30, 0x06, 0x5a, 0x82, + 0xb9, 0x1b, 0x5b, 0xce, 0xc6, 0xd6, 0x83, 0x66, 0xcb, 0xbe, 0xb6, 0xf9, 0xa0, 0xa5, 0x10, 0x05, + 0xeb, 0x5f, 0x0c, 0x30, 0x53, 0x49, 0x9c, 0xdc, 0xc5, 0x7c, 0x12, 0x26, 0x05, 0x76, 0x74, 0x3e, + 0x27, 0xce, 0x43, 0x11, 0x8c, 0x5a, 0x66, 0x71, 0xd4, 0x32, 0x5f, 0x06, 0x53, 0x5a, 0x52, 0x86, + 0x4c, 0x4e, 0xe8, 0x99, 0x90, 0x1b, 0x54, 0x42, 0x38, 0x66, 0x71, 0x99, 0x78, 0x82, 0xc5, 0xc5, + 0xfa, 0x61, 0x09, 0x16, 0x33, 0x42, 0xe6, 0xae, 0xe4, 0x3f, 0x8a, 0x47, 0x1b, 0xf1, 0x12, 0x93, + 0x63, 0xbd, 0x84, 0x47, 0x9d, 0x5d, 0x2f, 0xa6, 0x4c, 0xf2, 0x51, 0x16, 0x13, 0xb7, 0xea, 0xd1, + 0x5b, 0x1c, 0x26, 0xf8, 0xb8, 0x04, 0xd3, 0x07, 0x98, 0xab, 0xc0, 0xeb, 0x91, 0xb0, 0xcf, 0x84, + 0x33, 0x2a, 0xda, 0x55, 0x0e, 0x6b, 0x49, 0x10, 0x6a, 0xc0, 0xc4, 0x6e, 0x18, 0xbb, 0x44, 0x38, + 0xa2, 0xca, 0xf5, 0x42, 0xc3, 0xb0, 0x25, 0x80, 0x0f, 0x22, 0x26, 0xac, 0x1f, 0x07, 0x8e, 0xd8, + 0x29, 0x48, 0x37, 0x54, 0xb1, 0xa7, 0x25, 0xf0, 0xa1, 0x80, 0x8d, 0x5a, 0x44, 0x75, 0x9c, 0x45, + 0xd4, 0x85, 0x3f, 0x76, 0xc8, 0xa1, 0x47, 0x19, 0x09, 0x5c, 0xd2, 0x98, 0x96, 0xae, 0x4a, 0x80, + 0x6f, 0x6a, 0x28, 0x7a, 0x15, 0xe6, 0x84, 0x44, 0xf8, 0x02, 0xed, 0x78, 0xbb, 0x92, 0x9e, 0x2a, + 0x8f, 0x64, 0x72, 0x14, 0x5f, 0xab, 0x37, 0x77, 0x45, 0x0d, 0x8a, 0x6e, 0xf0, 0xd1, 0xed, 0x11, + 0xa7, 0x1f, 0x39, 0xbd, 0xb0, 0x4d, 0x84, 0x63, 0xaa, 0xad, 0x5b, 0xa9, 0x9b, 0xc8, 0x1b, 0xc7, + 0xfb, 0x78, 0x8f, 0xbc, 0x17, 0xdd, 0x0f, 0xdb, 0xc4, 0x86, 0x83, 0xe4, 0xbf, 0xf5, 0x0f, 0x06, + 0x34, 0x86, 0x28, 0xef, 0x92, 0x81, 0x4d, 0x68, 0xdf, 0x67, 0xe8, 0x73, 0x50, 0x62, 0x83, 0x88, + 0x08, 0x2b, 0xaa, 0xad, 0x5f, 0x7e, 0x54, 0xd3, 0x49, 0x85, 0xd6, 0x20, 0x22, 0xb6, 0xa8, 0x92, + 0x6e, 0xb7, 0x0a, 0xd9, 0xed, 0xd6, 0x39, 0x98, 0x4a, 0xa5, 0x50, 0x14, 0x03, 0x4b, 0x01, 0xe8, + 0x4d, 0x58, 0xe2, 0xa3, 0x24, 0x6d, 0xe7, 0xc0, 0x63, 0x5d, 0xee, 0x03, 0x77, 0x7d, 0xcf, 0xcd, + 0x4c, 0xa1, 0x79, 0x89, 0x7e, 0xdf, 0x63, 0xdd, 0x0d, 0x85, 0x6c, 0x51, 0xb4, 0x06, 0x62, 0x8d, + 0x73, 0xf8, 0x56, 0xd6, 0xdf, 0xf7, 0x82, 0x8e, 0x34, 0x08, 0xb9, 0x1e, 0xcc, 0x72, 0x94, 0xad, + 0x31, 0x9c, 0x5b, 0xeb, 0xef, 0x0b, 0xb0, 0x34, 0x32, 0x73, 0x9e, 0x8b, 0x03, 0xb9, 0x00, 0x53, + 0x43, 0xce, 0x43, 0x58, 0x5c, 0xc5, 0xd5, 0xb6, 0xd2, 0xd0, 0x52, 0xe3, 0xe3, 0x9d, 0x96, 0xe6, + 0x28, 0x25, 0xb7, 0x08, 0x93, 0xca, 0x0e, 0x27, 0xc4, 0x12, 0xa6, 0x4a, 0xe8, 0x3c, 0x40, 0xb2, + 0x81, 0xe5, 0x13, 0xa5, 0xc8, 0x45, 0xaa, 0x77, 0xb0, 0x63, 0xbd, 0x4c, 0xf9, 0x09, 0xbc, 0x0c, + 0xfa, 0x02, 0xdf, 0x18, 0x72, 0xd5, 0xd2, 0x46, 0x45, 0x8c, 0xee, 0xd2, 0x63, 0x8d, 0xc0, 0xd6, + 0x35, 0xac, 0xef, 0x1b, 0xb0, 0x92, 0xa1, 0xb2, 0x43, 0xdf, 0xdf, 0xc1, 0x27, 0x73, 0x53, 0x23, + 0x2e, 0xa5, 0x30, 0xc6, 0xa5, 0x8c, 0xf8, 0x8d, 0xe2, 0xa8, 0xdf, 0x40, 0x50, 0xda, 0x23, 0x03, + 0x6e, 0x50, 0x5c, 0x8a, 0xe2, 0xbf, 0xf5, 0xc7, 0x06, 0x9c, 0x1d, 0xcb, 0xe7, 0x73, 0x31, 0x8a, + 0x31, 0x2a, 0x2a, 0x3e, 0xc9, 0x42, 0xf0, 0x7b, 0x06, 0xcc, 0xb5, 0x0e, 0x83, 0x3b, 0x04, 0xc7, + 0xec, 0x3a, 0xc1, 0x27, 0x3a, 0xb4, 0x0d, 0x3b, 0xf5, 0xc2, 0x31, 0x9c, 0x7a, 0x71, 0x8c, 0x06, + 0x5e, 0x82, 0x3a, 0x6e, 0xef, 0x7b, 0x94, 0x38, 0x89, 0x6f, 0x57, 0x8b, 0x9f, 0x04, 0xdf, 0x93, + 0x1e, 0xde, 0xfa, 0x91, 0x01, 0xf3, 0x79, 0x9e, 0x9f, 0xc3, 0x09, 0x30, 0xbb, 0xe2, 0x14, 0xf3, + 0x2b, 0xce, 0x18, 0x1d, 0x94, 0x9e, 0x44, 0x07, 0xff, 0xaf, 0x08, 0x0b, 0x62, 0x67, 0xdd, 0x3a, + 0x0c, 0x9a, 0x0c, 0xb3, 0x3e, 0x3d, 0x89, 0x16, 0x2e, 0x80, 0x96, 0x78, 0xe6, 0xbc, 0x07, 0x0a, + 0xc4, 0xcf, 0x5c, 0x4b, 0x50, 0x96, 0x23, 0xd0, 0xa6, 0x3d, 0x29, 0x06, 0x40, 0xb9, 0xdc, 0x5d, + 0xec, 0xfb, 0x24, 0x76, 0xa4, 0x8e, 0xd2, 0x4d, 0x87, 0x04, 0x37, 0x39, 0xb4, 0x25, 0xbc, 0x85, + 0xdb, 0x8f, 0x63, 0x12, 0x08, 0x12, 0xb9, 0xec, 0x4e, 0x29, 0x48, 0x8b, 0xa2, 0xd7, 0x60, 0x21, + 0x56, 0xc6, 0xcf, 0x17, 0x20, 0xee, 0x58, 0x84, 0x77, 0x56, 0x47, 0x09, 0xa4, 0x91, 0x9b, 0xbb, + 0x0f, 0x42, 0x26, 0x96, 0x21, 0xb4, 0x0a, 0xb3, 0x62, 0xbd, 0x74, 0xb2, 0x5b, 0x71, 0xb9, 0x16, + 0xd7, 0x05, 0xa2, 0x99, 0xee, 0xc5, 0xbf, 0x08, 0x2b, 0xa9, 0x8f, 0xce, 0x9e, 0x3f, 0x84, 0xcd, + 0x55, 0x44, 0xa5, 0x46, 0x42, 0x31, 0xe4, 0x5f, 0x78, 0x4f, 0xfb, 0x24, 0xf6, 0x76, 0x07, 0x8e, + 0x47, 0x1d, 0x25, 0x14, 0xb9, 0x6c, 0xdb, 0x75, 0x89, 0xd8, 0xa4, 0xdb, 0x12, 0x6c, 0xfd, 0xb8, + 0x00, 0x8b, 0xc3, 0xfa, 0xf8, 0xe5, 0x5a, 0xd8, 0x65, 0xa8, 0x29, 0xd7, 0x9f, 0xdf, 0x14, 0xcd, + 0x48, 0xa8, 0x9e, 0x40, 0x2f, 0xc3, 0xa4, 0x3c, 0x8c, 0x09, 0xe5, 0xd4, 0x32, 0x27, 0x5e, 0x75, + 0xe0, 0x52, 0x68, 0xb4, 0x06, 0x53, 0xa2, 0x2b, 0x2f, 0xd8, 0x0d, 0x55, 0x54, 0x22, 0xe5, 0x8b, + 0xcb, 0x6b, 0x33, 0xd8, 0x0d, 0x6d, 0xc1, 0x0e, 0xff, 0xf7, 0xb4, 0x0b, 0x81, 0xf5, 0x75, 0x03, + 0x56, 0x84, 0x44, 0x9b, 0xea, 0xe8, 0x24, 0xbc, 0xc2, 0x89, 0xcc, 0x5c, 0xbb, 0xe0, 0x42, 0xea, + 0x82, 0x8f, 0xe5, 0x5d, 0xac, 0x7f, 0x35, 0xe0, 0xec, 0x58, 0x1e, 0x9e, 0x83, 0x6a, 0x5f, 0x86, + 0x09, 0x2e, 0x4b, 0x3e, 0xf1, 0x8a, 0xe3, 0x65, 0x2d, 0xf1, 0xe8, 0x6c, 0x76, 0x8d, 0x97, 0x3a, + 0x4e, 0xd7, 0xf7, 0xa7, 0xdd, 0xf4, 0xff, 0xc0, 0x80, 0x19, 0x39, 0x99, 0x9e, 0xd9, 0x22, 0xaa, + 0xb5, 0x53, 0xcc, 0x68, 0xe7, 0x78, 0xc6, 0x2b, 0xe3, 0x5d, 0xf6, 0xe4, 0x8e, 0x17, 0xf8, 0x61, + 0xc7, 0xfa, 0x4b, 0x03, 0x6a, 0x9a, 0xd7, 0xe7, 0xa0, 0xa0, 0x51, 0x1e, 0x8b, 0xe3, 0x26, 0xd8, + 0xd3, 0x7a, 0xfa, 0x0e, 0xcc, 0x6c, 0xf6, 0xa2, 0x30, 0x4e, 0x14, 0x90, 0x3b, 0x40, 0x19, 0xc7, + 0x38, 0x40, 0x8d, 0x32, 0x5a, 0x18, 0xc3, 0xa8, 0xf5, 0x01, 0xd4, 0x74, 0x47, 0x27, 0x97, 0xde, + 0x7c, 0x56, 0x7a, 0x53, 0x3a, 0x0a, 0xf6, 0x2d, 0xae, 0x19, 0x9f, 0xe0, 0xa0, 0x1f, 0x9d, 0x4e, + 0x84, 0xf7, 0x58, 0x7b, 0x83, 0xfc, 0xda, 0x53, 0x1a, 0x5a, 0x7b, 0xac, 0x6f, 0x1b, 0x50, 0x4f, + 0x98, 0xfa, 0x95, 0xb1, 0x17, 0x6b, 0x0f, 0xea, 0xd7, 0x31, 0x73, 0xbb, 0x27, 0x8c, 0x86, 0x8f, + 0xf3, 0x75, 0x8f, 0x8e, 0x87, 0xff, 0xdc, 0x00, 0x33, 0xed, 0xed, 0x99, 0x87, 0x4d, 0x9f, 0x72, + 0x2e, 0xa4, 0xb2, 0x9e, 0x38, 0x5a, 0xd6, 0xef, 0x96, 0x2a, 0x45, 0xb3, 0x64, 0xfd, 0x37, 0x98, + 0x17, 0x83, 0x7b, 0xe6, 0xe7, 0x80, 0x31, 0x2e, 0xcc, 0xfa, 0x7d, 0x03, 0x16, 0x86, 0x7a, 0x7f, + 0x0e, 0x46, 0xf6, 0xb4, 0x7b, 0xfb, 0xdf, 0x31, 0xa0, 0xde, 0x74, 0x71, 0x70, 0xd2, 0xe8, 0xce, + 0x05, 0xa8, 0xf6, 0xf0, 0xe1, 0x90, 0xb0, 0xa0, 0x87, 0x0f, 0xb5, 0xa8, 0x72, 0x17, 0x0c, 0xc5, + 0x47, 0x5d, 0x30, 0x94, 0xb2, 0x17, 0x0c, 0x99, 0x1b, 0x81, 0x89, 0xec, 0x8d, 0x80, 0xf5, 0x53, + 0x03, 0xcc, 0x94, 0xd9, 0x5f, 0xa5, 0x35, 0xf9, 0x69, 0x9d, 0xfe, 0x8f, 0x0d, 0x40, 0x32, 0x86, + 0x40, 0x4e, 0xaa, 0x89, 0x63, 0x19, 0xee, 0x31, 0xd7, 0xb0, 0x57, 0x61, 0x8a, 0x1d, 0x06, 0x62, + 0xeb, 0x27, 0x0f, 0xb2, 0xd9, 0x9e, 0x5b, 0x87, 0x81, 0xdc, 0xfa, 0x31, 0xf9, 0x27, 0x3d, 0xf2, + 0x4e, 0x64, 0xa6, 0x03, 0x3f, 0x34, 0xe6, 0x46, 0xf4, 0xef, 0x60, 0x32, 0x3c, 0x84, 0xa9, 0xdb, + 0x1b, 0x27, 0x91, 0xfd, 0x79, 0x00, 0x8a, 0x77, 0x89, 0x13, 0x85, 0x5e, 0xc0, 0x94, 0xe0, 0xa7, + 0x38, 0x64, 0x9b, 0x03, 0xac, 0x2e, 0x00, 0x6f, 0xf7, 0xd9, 0x4b, 0xc0, 0xfa, 0x8e, 0x01, 0xe8, + 0x06, 0xf1, 0x09, 0x23, 0x36, 0x0e, 0x3a, 0xe4, 0xd4, 0x6f, 0x04, 0x33, 0x53, 0xb3, 0x38, 0x7c, + 0x59, 0x17, 0x84, 0x8c, 0x9f, 0x9d, 0xc4, 0xed, 0x9f, 0xbc, 0xe8, 0x04, 0x09, 0xda, 0x0a, 0xfc, + 0x81, 0xf5, 0x15, 0x98, 0xcb, 0x31, 0x76, 0xda, 0x5b, 0x8e, 0x3f, 0x34, 0xe0, 0xe2, 0x76, 0x4c, + 0x22, 0x1c, 0x93, 0x5b, 0x3e, 0xa6, 0x5d, 0xee, 0x81, 0x5b, 0xa1, 0x32, 0xe8, 0xe7, 0x27, 0x87, + 0x65, 0xa8, 0x0c, 0x1d, 0x90, 0xcb, 0x54, 0x1d, 0x8d, 0x33, 0xab, 0xf2, 0x44, 0x7e, 0x55, 0xf6, + 0xe1, 0xd2, 0x11, 0xac, 0x9f, 0xb6, 0xa4, 0x7e, 0x6c, 0xc0, 0xf2, 0xe9, 0x88, 0x28, 0x33, 0xa2, + 0x42, 0xfe, 0x26, 0xf8, 0x48, 0xaf, 0x9f, 0x11, 0x5e, 0xe9, 0x91, 0xc2, 0x9b, 0xc8, 0x0b, 0x2f, + 0x77, 0xe8, 0x99, 0xcc, 0x1f, 0x7a, 0x2c, 0x02, 0x2b, 0xcf, 0x43, 0x70, 0x5f, 0x86, 0x19, 0x1b, + 0x1f, 0x9c, 0x5a, 0xd6, 0x42, 0x0d, 0x0a, 0xee, 0xae, 0x10, 0xce, 0x94, 0x5d, 0x70, 0x77, 0xad, + 0xff, 0x6b, 0x40, 0x4d, 0xb7, 0x7f, 0xca, 0xac, 0x9f, 0x20, 0x37, 0xc1, 0x6a, 0x03, 0xb2, 0xf1, + 0xc1, 0x69, 0x6f, 0x4d, 0x87, 0x07, 0x1d, 0xc2, 0x5c, 0xae, 0x97, 0x67, 0xbd, 0x25, 0xb5, 0x7e, + 0xd3, 0x10, 0x5a, 0xdc, 0xee, 0x9f, 0x92, 0x16, 0xc7, 0x4b, 0x56, 0x0e, 0xb3, 0xa4, 0x87, 0xc9, + 0xeb, 0xa5, 0xd7, 0x50, 0xfc, 0x2f, 0x9f, 0x04, 0xbb, 0x61, 0xec, 0xb8, 0x98, 0xaa, 0xd8, 0xd7, + 0xe4, 0x6e, 0x18, 0x6f, 0x60, 0xca, 0x8f, 0x65, 0x9a, 0xbf, 0xd3, 0x36, 0xe0, 0x3f, 0x32, 0x52, + 0x9d, 0x9e, 0x50, 0x00, 0xc7, 0xdc, 0xf8, 0x0f, 0xa9, 0x19, 0xcd, 0xcb, 0xf1, 0x97, 0x92, 0x1b, + 0x89, 0x61, 0x19, 0x4c, 0x64, 0x65, 0xc0, 0x2d, 0x87, 0x31, 0x5f, 0xde, 0x36, 0x94, 0x6c, 0xf1, + 0x9f, 0x2f, 0x20, 0x39, 0xde, 0x4f, 0x5b, 0x38, 0x03, 0x30, 0x6d, 0x7c, 0xa0, 0xd6, 0xa8, 0x67, + 0x31, 0xc1, 0xb3, 0xc3, 0x2d, 0xe5, 0x54, 0xfe, 0x5f, 0x61, 0x36, 0xd3, 0xf5, 0x69, 0x0f, 0xec, + 0x7f, 0x18, 0xb0, 0xa0, 0x25, 0x77, 0xf2, 0xe1, 0x1d, 0x63, 0x32, 0x3f, 0x7a, 0x80, 0x18, 0x16, + 0x87, 0x39, 0x38, 0xed, 0x51, 0xfe, 0x48, 0x7a, 0xcf, 0xe7, 0x98, 0x07, 0x95, 0xcd, 0x76, 0x2a, + 0xe5, 0xb3, 0x9d, 0xa4, 0x60, 0x26, 0x12, 0xc1, 0x3c, 0x79, 0xf6, 0x93, 0xd5, 0x81, 0x7a, 0x32, + 0x9c, 0x93, 0xcb, 0xea, 0x12, 0x14, 0xf7, 0xf6, 0x1f, 0x39, 0x59, 0x39, 0xce, 0xfa, 0x86, 0x34, + 0x8f, 0x5f, 0xca, 0xae, 0x71, 0xc8, 0x4d, 0x2a, 0x3b, 0x79, 0xa6, 0xfb, 0xc4, 0x9f, 0x18, 0xa9, + 0x1f, 0x39, 0xa9, 0xb1, 0x7c, 0x12, 0x26, 0x63, 0xce, 0xdd, 0xd8, 0xbb, 0x37, 0xc9, 0xb7, 0x22, + 0xe0, 0x27, 0x03, 0x82, 0xdd, 0xae, 0x93, 0xb5, 0x9f, 0x29, 0x0e, 0xb9, 0x77, 0x6a, 0x36, 0x64, + 0xf9, 0x30, 0x9f, 0x1f, 0xd1, 0x33, 0xb5, 0x97, 0xff, 0x0e, 0xcb, 0xef, 0x05, 0xfc, 0x6c, 0x73, + 0x83, 0x50, 0x16, 0x87, 0x83, 0xe7, 0x6b, 0x32, 0x7c, 0xaf, 0x37, 0xae, 0xfb, 0xd3, 0x36, 0x93, + 0xaf, 0xc2, 0x59, 0x9b, 0x74, 0x3c, 0xca, 0x48, 0xcc, 0x8f, 0xaf, 0x5b, 0x3b, 0x94, 0xc4, 0xfb, + 0x24, 0x3e, 0xc9, 0x38, 0x17, 0x60, 0xb2, 0x87, 0x0f, 0xd3, 0x84, 0xa6, 0x89, 0x1e, 0x3e, 0x6c, + 0x51, 0xeb, 0x0d, 0x38, 0x37, 0xbe, 0x07, 0x35, 0x94, 0x84, 0x2f, 0x23, 0xbf, 0x07, 0x6d, 0x88, + 0x0b, 0x8a, 0x67, 0xc4, 0x54, 0x1f, 0x96, 0xc7, 0x34, 0x7f, 0x14, 0x47, 0xdc, 0x84, 0x3d, 0xea, + 0xb8, 0x3e, 0xc1, 0xf2, 0x14, 0x50, 0xb1, 0xcb, 0x1e, 0x15, 0x71, 0xd6, 0x63, 0x87, 0x4f, 0xac, + 0xaf, 0xc0, 0xb2, 0x4d, 0x7a, 0xa1, 0x0c, 0x15, 0x3c, 0x83, 0x61, 0xad, 0xc3, 0xca, 0xb8, 0xf6, + 0x8f, 0x94, 0xf4, 0xff, 0x37, 0x60, 0x69, 0xbb, 0x3b, 0xa0, 0x9e, 0x8b, 0xfd, 0xa7, 0x89, 0x90, + 0x8d, 0x67, 0xe9, 0x04, 0x71, 0x31, 0xeb, 0x03, 0x68, 0x8c, 0x32, 0x74, 0xa4, 0x6e, 0x12, 0x05, + 0x14, 0x1e, 0xa3, 0x80, 0xef, 0x19, 0x80, 0x9a, 0x91, 0xef, 0x31, 0x5b, 0xcc, 0x8c, 0x93, 0x45, + 0x02, 0xa7, 0x28, 0x6f, 0x21, 0x9d, 0xce, 0x32, 0xf5, 0x44, 0x00, 0xf9, 0xa0, 0xce, 0x03, 0x24, + 0x04, 0x3a, 0x74, 0x3a, 0xa5, 0xb1, 0x14, 0xad, 0xc0, 0x94, 0x47, 0x9d, 0x18, 0x1f, 0x38, 0x7b, + 0xfb, 0xda, 0x17, 0x7a, 0xd4, 0xc6, 0x07, 0x77, 0xf7, 0xad, 0x1f, 0x1a, 0x30, 0x97, 0x63, 0xef, + 0xe4, 0xd3, 0xfd, 0x25, 0x28, 0xf9, 0x64, 0x97, 0xa9, 0x48, 0x4a, 0x6d, 0x4d, 0x65, 0xc0, 0xcb, + 0x86, 0x05, 0xc7, 0x02, 0x8f, 0xae, 0xc0, 0x44, 0xec, 0x75, 0xba, 0x4c, 0x45, 0x90, 0xc6, 0x11, + 0x4a, 0x02, 0x74, 0x85, 0x3b, 0xe6, 0x8e, 0xb8, 0x9d, 0x91, 0xa1, 0xb2, 0x21, 0x5a, 0x5b, 0xa3, + 0xad, 0xff, 0x65, 0x80, 0x69, 0x13, 0xdc, 0xde, 0x0c, 0xda, 0xe4, 0xf0, 0x24, 0x32, 0xce, 0x1e, + 0x90, 0x0b, 0xf9, 0x03, 0x72, 0xba, 0x26, 0x15, 0x1f, 0xb3, 0x26, 0x59, 0xbf, 0x66, 0xc0, 0x6c, + 0x86, 0x8d, 0x93, 0xcb, 0xf2, 0x3c, 0x40, 0x4c, 0x70, 0xdb, 0x91, 0x59, 0x9d, 0x2a, 0xec, 0x15, + 0xeb, 0x96, 0x39, 0x4b, 0x32, 0x9d, 0x6a, 0x24, 0x6b, 0x3a, 0x31, 0x3f, 0x45, 0x60, 0x35, 0x61, + 0xee, 0xfe, 0xbe, 0xeb, 0xde, 0x26, 0xec, 0xfa, 0x40, 0xe4, 0xf9, 0x9c, 0xc2, 0xfe, 0xdb, 0xfa, + 0x3f, 0x06, 0xcc, 0xe7, 0x5b, 0x3d, 0xed, 0x63, 0xf5, 0x65, 0x28, 0x89, 0xeb, 0xf1, 0xe1, 0xf1, + 0xf1, 0x5e, 0xc5, 0xf8, 0x04, 0xda, 0xfa, 0x2a, 0x2c, 0x25, 0x7c, 0xa8, 0x44, 0x89, 0xd3, 0xd5, + 0x3e, 0x9f, 0xbf, 0x8d, 0xd1, 0x2e, 0x4e, 0x7b, 0xb8, 0x4a, 0xc4, 0xc5, 0xf4, 0x88, 0xa3, 0x05, + 0x50, 0x3a, 0x5a, 0x00, 0x3f, 0x9f, 0x82, 0xf2, 0x46, 0xba, 0xec, 0x2b, 0x6e, 0xbc, 0xb6, 0x60, + 0xa5, 0x64, 0x57, 0x24, 0x60, 0xb3, 0x8d, 0xde, 0x4a, 0x59, 0x8d, 0x42, 0xb7, 0xab, 0x66, 0xe9, + 0x5c, 0x7e, 0x42, 0xdd, 0xe4, 0xa8, 0x84, 0x5f, 0x5e, 0x40, 0x17, 0xa1, 0x14, 0x11, 0xa2, 0xd3, + 0xf3, 0xa7, 0x35, 0xfd, 0x36, 0x21, 0xb1, 0x2d, 0x30, 0xe2, 0x48, 0x49, 0xe2, 0x9e, 0x3a, 0x82, + 0x8b, 0xff, 0xe8, 0x2a, 0x54, 0xa2, 0xd8, 0x0b, 0x63, 0x8f, 0x0d, 0xc4, 0x9e, 0xaa, 0xb6, 0x3e, + 0x97, 0x91, 0x7e, 0xaf, 0x87, 0x83, 0xf6, 0x76, 0xec, 0xd9, 0x09, 0x11, 0x7a, 0x07, 0xea, 0x1e, + 0x0d, 0x7d, 0x9c, 0xc9, 0xc3, 0x2e, 0x0f, 0xe5, 0x61, 0x6f, 0x6a, 0xbc, 0xca, 0xc3, 0xf6, 0x72, + 0x65, 0xf4, 0x09, 0xa8, 0x89, 0x90, 0x8b, 0xe7, 0xfb, 0x8e, 0x8b, 0xdd, 0x2e, 0x51, 0x59, 0x29, + 0xd3, 0x41, 0xc8, 0x6e, 0x79, 0xbe, 0xbf, 0xc1, 0x61, 0x42, 0xd3, 0x83, 0xc0, 0x75, 0xfc, 0xb0, + 0xa3, 0x12, 0x50, 0xca, 0xbc, 0x7c, 0x2f, 0xec, 0xa0, 0x2b, 0x60, 0xc6, 0xc4, 0x0d, 0xe3, 0xb6, + 0x48, 0x3a, 0x75, 0x28, 0xc3, 0x4c, 0x25, 0x8e, 0xd6, 0x24, 0xbc, 0xe5, 0xf5, 0x48, 0x93, 0x61, + 0x96, 0xa1, 0xa4, 0x2e, 0x0e, 0x24, 0x65, 0x35, 0x4b, 0xc9, 0x17, 0x11, 0x41, 0x79, 0x89, 0x4b, + 0x3d, 0xf2, 0x3d, 0x17, 0x3b, 0x7c, 0xf6, 0xaa, 0xec, 0xd1, 0xaa, 0x82, 0x71, 0x57, 0x81, 0x2e, + 0x43, 0x4d, 0xe6, 0xcd, 0x90, 0xb6, 0x23, 0x97, 0x94, 0x19, 0x71, 0x36, 0x9f, 0xd1, 0x50, 0x91, + 0x28, 0x81, 0x3e, 0x07, 0xcb, 0x7c, 0xb1, 0x23, 0x87, 0xc4, 0xed, 0x0b, 0x21, 0xb5, 0xfb, 0xb1, + 0x94, 0x56, 0x4f, 0x27, 0xb6, 0x2f, 0xf6, 0xf0, 0xe1, 0x4d, 0x8d, 0xbf, 0xa1, 0xd0, 0xf7, 0x45, + 0x82, 0x06, 0x8e, 0x22, 0xdf, 0x23, 0xda, 0x9f, 0xd4, 0xe5, 0xfd, 0x85, 0x02, 0x4a, 0x97, 0xb2, + 0x04, 0x65, 0x86, 0xe9, 0x1e, 0x37, 0x1d, 0x53, 0xe6, 0x27, 0xf1, 0xe2, 0x66, 0x5b, 0x2c, 0x2e, + 0x0c, 0xfb, 0x44, 0x0e, 0x60, 0x56, 0x26, 0x7e, 0x0a, 0x88, 0x60, 0xff, 0x53, 0x80, 0x92, 0x77, + 0x48, 0x9d, 0x38, 0xec, 0x47, 0x0e, 0xc3, 0x9d, 0x06, 0x12, 0x86, 0x6c, 0x6a, 0xcc, 0x6d, 0x8e, + 0x68, 0xe1, 0x0e, 0xfa, 0x2c, 0xcc, 0xb4, 0x3d, 0xba, 0xe7, 0xec, 0xf6, 0x7d, 0xdf, 0x09, 0x23, + 0xd6, 0x98, 0x13, 0x4a, 0x9e, 0x4f, 0x94, 0x7c, 0xc3, 0xa3, 0x7b, 0xb7, 0xfa, 0xbe, 0xbf, 0x15, + 0x31, 0xbb, 0xda, 0x4e, 0x0b, 0x5c, 0xe6, 0x7c, 0x11, 0x23, 0x2c, 0x1e, 0x38, 0xb1, 0x9c, 0xe2, + 0x8d, 0x79, 0x29, 0x73, 0x8f, 0xda, 0x1c, 0xac, 0x27, 0xfe, 0x1b, 0x50, 0xc5, 0x91, 0x97, 0x5c, + 0xc3, 0x2c, 0x0c, 0x99, 0xdf, 0xb5, 0xed, 0x4d, 0x1d, 0xc7, 0x04, 0x1c, 0x79, 0x69, 0xf6, 0x4e, + 0x5d, 0x46, 0x3d, 0x59, 0xa2, 0x87, 0x45, 0xa1, 0x87, 0x5a, 0x02, 0x96, 0x8a, 0xf8, 0x3c, 0xc8, + 0x77, 0x58, 0x8e, 0xf6, 0x2e, 0x4b, 0x62, 0x66, 0x2c, 0xac, 0xe9, 0xd7, 0x59, 0x2d, 0xfe, 0xab, + 0x5d, 0xcc, 0x34, 0xcb, 0x94, 0xa4, 0xae, 0x05, 0x97, 0x8e, 0x14, 0x4c, 0xa3, 0x21, 0xbc, 0xc0, + 0x8c, 0x82, 0x36, 0x05, 0x90, 0x8b, 0x5c, 0xbc, 0xc2, 0x90, 0x24, 0xcb, 0xd2, 0xfb, 0xb3, 0xc3, + 0x40, 0xa1, 0x57, 0x61, 0x76, 0xa7, 0x4f, 0x07, 0x0e, 0xeb, 0xc6, 0x84, 0x76, 0x43, 0xbf, 0xcd, + 0x4d, 0xe0, 0xac, 0xd8, 0xcf, 0xd4, 0x39, 0xa2, 0xa5, 0xe1, 0xf7, 0x29, 0xfa, 0x00, 0x1a, 0x89, + 0x7a, 0x38, 0xc3, 0x71, 0xe8, 0x27, 0x8c, 0x9f, 0x13, 0x8c, 0x5f, 0x48, 0x24, 0x63, 0x2b, 0xc2, + 0x0d, 0x49, 0xa7, 0x87, 0x90, 0xbc, 0x33, 0xcb, 0xc3, 0xd1, 0x05, 0xa8, 0xf2, 0xfd, 0x46, 0xc4, + 0x65, 0xe1, 0xb5, 0x1b, 0x17, 0xe5, 0x2b, 0x22, 0x0d, 0xda, 0x6c, 0x73, 0x91, 0xee, 0xf4, 0xdd, + 0x3d, 0xc2, 0x68, 0xa2, 0x8c, 0x4b, 0x62, 0x2c, 0x35, 0x05, 0x4e, 0x93, 0x4f, 0x4a, 0xe6, 0xc4, + 0xbb, 0xa5, 0xca, 0x8a, 0x79, 0x96, 0xcf, 0x0d, 0xdc, 0x76, 0x3e, 0xec, 0x87, 0x71, 0xbf, 0x67, + 0xfd, 0xae, 0x01, 0x8b, 0xe3, 0xb9, 0x42, 0x6b, 0x30, 0x37, 0x64, 0x77, 0x01, 0xee, 0x11, 0xb5, + 0x49, 0x9b, 0xcd, 0x19, 0xde, 0x03, 0xdc, 0x23, 0xe8, 0x33, 0x50, 0x8e, 0x48, 0x80, 0x7d, 0x36, + 0x50, 0xae, 0xef, 0xfc, 0xda, 0xc8, 0xfb, 0xb9, 0x8d, 0x30, 0xa0, 0xfd, 0x5e, 0x24, 0xb2, 0x3e, + 0x34, 0x35, 0x7a, 0x05, 0x66, 0xc3, 0x7d, 0x12, 0xc7, 0x5e, 0x9b, 0x38, 0x89, 0x4f, 0x93, 0x77, + 0x7b, 0xa6, 0x46, 0x6c, 0x2b, 0xb8, 0xf5, 0xdd, 0x22, 0x54, 0xf4, 0x12, 0x3c, 0x92, 0x99, 0x69, + 0x8c, 0x66, 0x66, 0x5e, 0x82, 0x69, 0x91, 0x0a, 0x96, 0x0f, 0xf6, 0x57, 0x39, 0x4c, 0x1b, 0xe6, + 0xe8, 0xd2, 0x90, 0x4d, 0x55, 0x2b, 0xe5, 0x53, 0xd5, 0xb2, 0xef, 0x77, 0x26, 0xf2, 0xef, 0x77, + 0xae, 0xa8, 0xac, 0x33, 0x91, 0x15, 0x2e, 0x7d, 0x72, 0x35, 0x51, 0xfd, 0x56, 0x24, 0xf3, 0xcd, + 0x5a, 0x83, 0x88, 0xa0, 0x57, 0x00, 0x09, 0xca, 0x7c, 0x42, 0x6e, 0x59, 0x34, 0x57, 0xe7, 0x98, + 0xcc, 0x7b, 0x91, 0xb1, 0xcf, 0x79, 0x2a, 0x63, 0x9f, 0xf3, 0x8c, 0x24, 0xdc, 0x4f, 0x8d, 0x26, + 0xdc, 0x0f, 0x3d, 0xf9, 0x81, 0xd1, 0x27, 0x3f, 0x9f, 0x87, 0x95, 0xc4, 0xf3, 0xb1, 0xd0, 0xf1, + 0x31, 0x65, 0x9a, 0xc9, 0x9e, 0xce, 0xe1, 0x5f, 0xd4, 0x14, 0xad, 0xf0, 0x1e, 0xa6, 0x4c, 0xf2, + 0x7a, 0x9f, 0x5a, 0x7f, 0x53, 0x82, 0x8a, 0xbe, 0xd7, 0xcb, 0xec, 0xa1, 0x8c, 0xc7, 0xec, 0xa1, + 0xd0, 0x39, 0xbe, 0xb0, 0xb2, 0x78, 0x80, 0x77, 0x7c, 0xa2, 0xd6, 0xed, 0x14, 0xc0, 0x57, 0x74, + 0xbc, 0x13, 0xc6, 0x4c, 0x85, 0xeb, 0x64, 0x01, 0xad, 0x43, 0x45, 0x27, 0xc1, 0x8f, 0x5c, 0x58, + 0xbf, 0x1f, 0x7b, 0x8c, 0xe8, 0x2c, 0x78, 0x3b, 0xa1, 0xe3, 0xae, 0x05, 0xfb, 0xdc, 0xfe, 0x07, + 0x2a, 0x77, 0x73, 0x42, 0xb9, 0x96, 0xc4, 0x77, 0x49, 0xac, 0x48, 0xdf, 0xb4, 0xa7, 0x71, 0xa6, + 0x84, 0x5e, 0x85, 0x8a, 0x7e, 0x2e, 0x3a, 0x92, 0x53, 0x78, 0x43, 0x21, 0xec, 0x84, 0x04, 0xdd, + 0x80, 0xd9, 0x44, 0x11, 0x0e, 0x39, 0x8c, 0xbc, 0x98, 0xb4, 0x55, 0x56, 0x61, 0x23, 0xb7, 0x52, + 0x73, 0xb5, 0xdc, 0x94, 0x78, 0xbb, 0xee, 0xe6, 0x01, 0xdc, 0x9d, 0x73, 0x73, 0x4b, 0xaf, 0x3a, + 0x2a, 0xa2, 0x85, 0xf9, 0xec, 0x8d, 0xf6, 0x03, 0x75, 0xed, 0x61, 0x57, 0x59, 0x5a, 0x40, 0x77, + 0x60, 0x2e, 0xed, 0x9f, 0x85, 0x5c, 0x91, 0x71, 0x47, 0x3e, 0xe5, 0xa8, 0xae, 0x2f, 0x8f, 0x70, + 0xd0, 0x0a, 0xc3, 0x7b, 0x9c, 0xc0, 0x36, 0xdd, 0x21, 0x08, 0xda, 0x00, 0x33, 0x7d, 0xc1, 0xb5, + 0x8b, 0x3d, 0x9f, 0xb4, 0xc5, 0xb2, 0x9d, 0x1d, 0x48, 0xf2, 0x84, 0xeb, 0x96, 0xc0, 0xdb, 0xe9, + 0x9b, 0x2f, 0x09, 0xe0, 0x8d, 0xe8, 0xa9, 0xda, 0xf3, 0x68, 0x0f, 0x33, 0xb7, 0x2b, 0x6c, 0x29, + 0xdb, 0x88, 0x4a, 0x50, 0xbd, 0xaf, 0xf0, 0x76, 0x3d, 0xca, 0x03, 0xac, 0xbf, 0x2a, 0xc0, 0x4c, + 0x4e, 0xb5, 0xb9, 0x7d, 0xa5, 0x91, 0x3f, 0x55, 0x5c, 0x80, 0x6a, 0xf6, 0x91, 0x84, 0x4a, 0xef, + 0x70, 0xd3, 0xa7, 0x11, 0xa3, 0xf3, 0xbe, 0x01, 0x65, 0x9d, 0x3b, 0x2b, 0x6f, 0xf7, 0x74, 0x91, + 0x2f, 0xc2, 0x49, 0x63, 0xe9, 0xfc, 0x92, 0x0e, 0xc0, 0xd4, 0x98, 0x64, 0x92, 0xbd, 0x09, 0x93, + 0x31, 0xc1, 0x34, 0x0c, 0x94, 0x1b, 0x38, 0x3f, 0xde, 0x30, 0xd7, 0x6c, 0x41, 0x64, 0x2b, 0x62, + 0xeb, 0x00, 0x26, 0x25, 0x04, 0x55, 0xa1, 0xfc, 0x5e, 0xb0, 0x17, 0x84, 0x07, 0x81, 0x79, 0x06, + 0xd5, 0x00, 0xb6, 0x22, 0xa6, 0xb2, 0x7d, 0x4d, 0x03, 0xcd, 0x83, 0x99, 0x4d, 0xc8, 0xe7, 0xd3, + 0xc4, 0x2c, 0x20, 0x04, 0xb5, 0x26, 0xf1, 0x77, 0xed, 0xd0, 0xf7, 0x49, 0xfb, 0x3a, 0x76, 0xf7, + 0xcc, 0x22, 0x9a, 0x81, 0x29, 0xdb, 0x95, 0xa9, 0xbe, 0xd4, 0x2c, 0xa1, 0x25, 0x98, 0xbb, 0x87, + 0xbf, 0x36, 0x78, 0x2f, 0xf0, 0x3e, 0xec, 0x93, 0x80, 0x50, 0x2a, 0x50, 0xe6, 0x84, 0x75, 0x11, + 0xa6, 0xb3, 0x86, 0xaf, 0x25, 0x63, 0xa4, 0xe7, 0x91, 0xdf, 0x32, 0xa0, 0xa2, 0x8d, 0x3c, 0x9b, + 0x69, 0x6d, 0xe4, 0x32, 0xad, 0xb5, 0xdf, 0x4c, 0x0f, 0x33, 0x82, 0x90, 0x9f, 0xa0, 0x57, 0x61, + 0x56, 0x4f, 0x0d, 0x8e, 0x76, 0xba, 0x98, 0x76, 0x95, 0x93, 0xaf, 0x6b, 0xc4, 0x5d, 0x32, 0xb8, + 0x83, 0x69, 0x17, 0xbd, 0x09, 0x20, 0x9e, 0x26, 0xb9, 0x5d, 0xec, 0x05, 0xea, 0x60, 0xba, 0xb8, + 0x96, 0xbc, 0xd5, 0x7e, 0x1f, 0x7b, 0xec, 0x56, 0x18, 0xdf, 0x0c, 0xf8, 0x96, 0x64, 0x8a, 0x53, + 0x6e, 0x70, 0x42, 0xeb, 0x5b, 0x06, 0xd4, 0x87, 0x26, 0xd4, 0x51, 0xf6, 0xb1, 0x06, 0x73, 0x98, + 0x31, 0xd2, 0x8b, 0xf8, 0x7e, 0x24, 0xd5, 0xa9, 0xb4, 0x93, 0xd9, 0x04, 0x95, 0x28, 0x75, 0xd4, + 0x5c, 0x46, 0xfc, 0x6d, 0x69, 0xc4, 0xdf, 0x5a, 0x9b, 0x50, 0xcd, 0x4c, 0xd1, 0xc7, 0xd8, 0xeb, + 0x91, 0x09, 0xee, 0xd6, 0x55, 0x30, 0x87, 0x67, 0x6b, 0xfe, 0x6e, 0xd9, 0x18, 0xba, 0x5b, 0xfe, + 0x73, 0x03, 0xea, 0x43, 0x13, 0xf3, 0x28, 0x06, 0x46, 0x6f, 0x81, 0x3e, 0x0d, 0x53, 0xc9, 0x3c, + 0x16, 0x03, 0xaf, 0xad, 0xa3, 0xd1, 0x29, 0x6f, 0xa7, 0x44, 0x5c, 0xcd, 0xc2, 0xb1, 0x7a, 0x41, + 0x67, 0x38, 0xdb, 0xbe, 0xae, 0x11, 0x3a, 0xdf, 0xfe, 0x53, 0x80, 0x12, 0xda, 0x91, 0x39, 0xa5, + 0x31, 0x89, 0x20, 0xaf, 0x41, 0x7d, 0xc8, 0x3f, 0xe4, 0xd3, 0xbc, 0x8d, 0xc7, 0xa6, 0x79, 0x5b, + 0x7f, 0x61, 0x00, 0xf0, 0x23, 0x86, 0xcc, 0x9a, 0x41, 0x9f, 0x84, 0x59, 0x61, 0x66, 0x07, 0xd8, + 0xf7, 0xe5, 0x89, 0xa4, 0xa7, 0x65, 0x52, 0xe3, 0x88, 0xf7, 0xb1, 0xef, 0x73, 0xf2, 0xfb, 0x14, + 0x5d, 0x85, 0xf9, 0x28, 0x0e, 0x5d, 0x42, 0x69, 0x9e, 0x5a, 0x19, 0x8b, 0xc2, 0x65, 0x2a, 0xac, + 0xc1, 0xfc, 0xde, 0xbe, 0xd8, 0xd0, 0xe7, 0x2b, 0xa8, 0x6d, 0xcd, 0xde, 0x3e, 0xdf, 0xda, 0x67, + 0xe8, 0xd7, 0x61, 0x91, 0x85, 0x0c, 0xfb, 0x4e, 0x1c, 0xb9, 0x99, 0x1a, 0x81, 0x16, 0x1e, 0x12, + 0x58, 0x3b, 0x72, 0x75, 0x9d, 0x07, 0xd4, 0xfa, 0x66, 0x01, 0xa6, 0xd3, 0xe1, 0x3c, 0x5c, 0x1f, + 0x33, 0xa0, 0x60, 0xec, 0x80, 0x1e, 0x3c, 0x62, 0x40, 0xc1, 0xa3, 0x06, 0xf4, 0x80, 0xa2, 0xb7, + 0xe1, 0x9c, 0xae, 0x40, 0xfb, 0x34, 0x22, 0x41, 0x3b, 0x5f, 0x51, 0x0e, 0xac, 0xa1, 0x68, 0x9a, + 0x92, 0x24, 0x53, 0x7f, 0xac, 0x40, 0x92, 0xe1, 0x0d, 0x09, 0xe4, 0xc1, 0x51, 0x02, 0x99, 0x78, + 0xa4, 0x40, 0xbe, 0x0c, 0x15, 0x7e, 0x2e, 0x14, 0x5b, 0xc3, 0x79, 0x98, 0x10, 0x14, 0x62, 0xfc, + 0x45, 0x5b, 0x16, 0xf8, 0x3e, 0x43, 0x71, 0x48, 0xda, 0x62, 0xac, 0x45, 0x3b, 0x05, 0x24, 0x31, + 0xa1, 0x9d, 0x01, 0x23, 0x72, 0x44, 0x45, 0x19, 0x13, 0xba, 0xce, 0x01, 0xd6, 0xff, 0x34, 0x00, + 0x78, 0xfb, 0xca, 0x7c, 0x5e, 0x86, 0x09, 0xf1, 0xbe, 0x76, 0xc4, 0xf2, 0x34, 0x0f, 0xb6, 0xc4, + 0xa3, 0xcb, 0x50, 0x4a, 0xde, 0x0d, 0x8d, 0xa5, 0x13, 0x68, 0x4e, 0xd6, 0xc6, 0x0c, 0x8f, 0x04, + 0x64, 0x52, 0x32, 0x8e, 0xb6, 0xfe, 0x69, 0x42, 0x7e, 0x39, 0x20, 0xd1, 0xfa, 0xab, 0x80, 0x92, + 0x21, 0xe8, 0x6d, 0xae, 0x56, 0xfb, 0x6c, 0x82, 0x51, 0x9b, 0x5d, 0x8a, 0xde, 0x82, 0xa5, 0x51, + 0xf2, 0xec, 0x7b, 0xf4, 0x85, 0x91, 0x3a, 0x62, 0x77, 0x7b, 0x19, 0x6a, 0x52, 0x21, 0x49, 0x17, + 0x2a, 0x33, 0x5b, 0x40, 0x93, 0xe6, 0xbf, 0x04, 0xe7, 0x62, 0x7e, 0x8a, 0x6b, 0xef, 0x38, 0x6d, + 0x71, 0x17, 0xe6, 0xd0, 0x3d, 0x2f, 0x8a, 0x84, 0x8b, 0xed, 0x07, 0x4c, 0xd9, 0xc9, 0xb2, 0xa2, + 0x91, 0xd7, 0x65, 0x4d, 0x49, 0xb1, 0xc1, 0x09, 0xf8, 0x31, 0x5c, 0x37, 0xc0, 0xd7, 0x89, 0x7c, + 0x6d, 0x69, 0x2d, 0x8b, 0x8a, 0xe0, 0x2e, 0x19, 0xe4, 0xaa, 0xbe, 0x03, 0xe7, 0x75, 0xd5, 0x1d, + 0xe1, 0x18, 0x44, 0x94, 0xc2, 0xe9, 0xf2, 0xa5, 0x44, 0x54, 0x9f, 0xc8, 0x75, 0x7e, 0x9d, 0xd3, + 0x88, 0xa0, 0xc5, 0x1d, 0x8f, 0xc9, 0x16, 0x3e, 0x03, 0x8d, 0x7c, 0x0b, 0xc2, 0x1e, 0x64, 0x65, + 0x99, 0xb9, 0xb3, 0x90, 0xad, 0xcc, 0x6d, 0x56, 0x56, 0x7c, 0x13, 0x96, 0xc6, 0x54, 0xe4, 0x86, + 0xa4, 0xb6, 0xf5, 0xf3, 0xc3, 0xf5, 0xb8, 0x4d, 0x3d, 0xa2, 0xbf, 0x00, 0x07, 0xa1, 0xde, 0xbc, + 0x8f, 0xf4, 0xf7, 0x80, 0x23, 0xb9, 0xef, 0xec, 0x10, 0xe6, 0xd0, 0x00, 0x47, 0xb4, 0x1b, 0x32, + 0x55, 0x45, 0x7e, 0x0c, 0xc0, 0xec, 0x10, 0xd6, 0x54, 0x08, 0x49, 0xcd, 0x05, 0x93, 0x04, 0x3b, + 0x9d, 0x28, 0x0e, 0xa3, 0x90, 0x12, 0x47, 0xf8, 0x0a, 0x59, 0xb1, 0xaa, 0x04, 0xa3, 0xe3, 0x9f, + 0xdb, 0x92, 0x84, 0xaf, 0xb4, 0xe3, 0x5a, 0xe0, 0x1b, 0x1e, 0x2f, 0xee, 0x65, 0x5b, 0x98, 0x1e, + 0x6a, 0x61, 0x43, 0x92, 0x8c, 0xb6, 0x10, 0x85, 0xa1, 0xef, 0x50, 0xb7, 0x4b, 0xda, 0x7d, 0x3f, + 0xc7, 0xc3, 0x4c, 0xda, 0xc2, 0x76, 0x18, 0xfa, 0x4d, 0x45, 0x92, 0xb4, 0x60, 0xfd, 0x6f, 0x03, + 0xaa, 0x99, 0x1c, 0x48, 0xf4, 0x06, 0x54, 0x85, 0x4f, 0x90, 0x29, 0x93, 0x6a, 0x1a, 0xa6, 0x61, + 0x88, 0xd4, 0x35, 0xda, 0xc0, 0x52, 0xaf, 0xff, 0x06, 0x54, 0x45, 0x4c, 0x49, 0xd5, 0x2a, 0x0c, + 0xd5, 0x4a, 0xa7, 0x96, 0x0d, 0x34, 0xf9, 0x2f, 0x93, 0xb4, 0xe5, 0x31, 0xda, 0xfa, 0x67, 0x03, + 0x66, 0x72, 0xb9, 0x98, 0x27, 0xe4, 0xe4, 0x0b, 0x50, 0xcb, 0x70, 0xe2, 0xec, 0xaf, 0x2b, 0x66, + 0x16, 0xc6, 0x30, 0xf3, 0x70, 0xdd, 0x9e, 0xa6, 0xd9, 0x59, 0xff, 0x19, 0x98, 0x16, 0xde, 0x45, + 0xf7, 0x59, 0x1c, 0x3a, 0x17, 0x88, 0x8d, 0xa6, 0xea, 0xb4, 0x7a, 0x90, 0x16, 0x78, 0xaf, 0x19, + 0x5e, 0xd3, 0x6c, 0xdf, 0x85, 0x31, 0xec, 0xf2, 0x5e, 0x59, 0xa6, 0x64, 0x7d, 0xbd, 0x0c, 0xd5, + 0x4c, 0xcb, 0xe8, 0x75, 0x58, 0xa4, 0x2c, 0x8c, 0x89, 0xb3, 0xc3, 0x17, 0xe4, 0xac, 0x36, 0xa5, + 0xff, 0x99, 0x13, 0x58, 0x71, 0xbd, 0x9b, 0x5a, 0xc2, 0x9b, 0xc2, 0x03, 0x09, 0x13, 0xa4, 0x72, + 0x1d, 0x49, 0x6a, 0x49, 0x97, 0x32, 0xaf, 0xd0, 0x4d, 0xb1, 0x84, 0xe8, 0x6a, 0xab, 0x30, 0x1b, + 0x71, 0x2f, 0x23, 0xde, 0xb4, 0x77, 0x54, 0x05, 0xb5, 0x83, 0x54, 0x88, 0x7b, 0x61, 0x47, 0xd2, + 0x6e, 0xc0, 0x85, 0x18, 0xef, 0x32, 0xa7, 0xbd, 0xe3, 0x48, 0x29, 0xf9, 0x04, 0xb7, 0x49, 0x9c, + 0xed, 0x4a, 0xba, 0x92, 0x15, 0x4e, 0x76, 0x63, 0x47, 0x8c, 0xe9, 0x9e, 0xa0, 0x49, 0x3b, 0x5c, + 0x87, 0x45, 0xdd, 0x88, 0x8e, 0x68, 0xaa, 0xba, 0x6a, 0x09, 0x92, 0x75, 0x9b, 0x32, 0xba, 0x29, + 0xeb, 0xbc, 0x0d, 0xe7, 0xf2, 0x1d, 0xf7, 0x48, 0x8f, 0xf1, 0x43, 0xac, 0xaa, 0x29, 0x9d, 0x48, + 0x23, 0xd3, 0xeb, 0x7d, 0x45, 0x20, 0xeb, 0x5f, 0x01, 0x75, 0xfe, 0xca, 0xf4, 0x26, 0x1d, 0x88, + 0x8a, 0x92, 0x25, 0x3d, 0xbd, 0x0e, 0x8b, 0x38, 0x8a, 0xfc, 0xc1, 0xa8, 0xe8, 0xa5, 0x1b, 0x9f, + 0x13, 0xd8, 0x21, 0xd1, 0xbf, 0x04, 0x75, 0x59, 0x29, 0x6d, 0x7d, 0x4a, 0x3d, 0x41, 0xe5, 0xe0, + 0xd1, 0xc6, 0x7b, 0x7d, 0x46, 0x0e, 0xe5, 0x7b, 0xd5, 0xac, 0x8b, 0x91, 0x8d, 0xdf, 0xe7, 0x48, + 0xbe, 0xcf, 0x4a, 0x66, 0xb8, 0xac, 0xf4, 0x28, 0x91, 0x2b, 0x2f, 0x23, 0x88, 0xc6, 0x4a, 0xfc, + 0x35, 0x58, 0xc8, 0xb6, 0x70, 0x80, 0xfd, 0x9c, 0x77, 0x41, 0x69, 0xcd, 0xf7, 0xb1, 0x2f, 0xab, + 0x7c, 0x01, 0x56, 0xb2, 0x55, 0x86, 0xc4, 0x2d, 0x7d, 0xca, 0x52, 0x5a, 0x6f, 0x44, 0xda, 0xfe, + 0xb0, 0xf4, 0x64, 0xa4, 0xb7, 0xe6, 0xe7, 0x05, 0xf7, 0x22, 0xcc, 0xe8, 0xed, 0x8f, 0x24, 0x53, + 0x11, 0x5e, 0x05, 0x94, 0x44, 0x7c, 0x89, 0xec, 0xc6, 0x21, 0x63, 0x49, 0xff, 0xa6, 0x5a, 0x22, + 0x15, 0x54, 0x92, 0xfd, 0x27, 0x38, 0x3b, 0xfc, 0xbe, 0x33, 0xcb, 0xc0, 0xac, 0xda, 0x49, 0x0d, + 0x7f, 0xa1, 0x40, 0xbb, 0xc1, 0x0f, 0x60, 0x52, 0xe6, 0x34, 0xa4, 0xa9, 0xd5, 0xc6, 0x63, 0x92, + 0xcb, 0x8f, 0x99, 0xfa, 0x67, 0x7d, 0xdd, 0x80, 0x8a, 0x7e, 0x95, 0x85, 0xce, 0x42, 0x21, 0x8c, + 0xd4, 0xd7, 0x0d, 0x72, 0x71, 0xac, 0x42, 0x18, 0x1d, 0x3b, 0x99, 0x30, 0x77, 0x82, 0x28, 0x1d, + 0xe3, 0x04, 0x61, 0xfd, 0xb4, 0x00, 0x53, 0xf7, 0xf7, 0x5d, 0x57, 0xa8, 0x0b, 0x5d, 0xc8, 0x7d, + 0x64, 0x21, 0xc7, 0x86, 0xfc, 0x94, 0xc2, 0x11, 0xd7, 0x8a, 0x67, 0x47, 0x3e, 0x28, 0x90, 0x79, + 0x6c, 0x78, 0x01, 0xaa, 0xb4, 0x1b, 0xc6, 0xcc, 0xc9, 0x7c, 0x52, 0xc0, 0x06, 0x01, 0x12, 0x9f, + 0xaf, 0xe0, 0xfb, 0xa4, 0x2e, 0xa6, 0x4e, 0xb8, 0x4f, 0x62, 0x1f, 0x8b, 0x2d, 0x88, 0x7e, 0xe0, + 0xab, 0x12, 0xfe, 0x16, 0xba, 0x98, 0x6e, 0x25, 0x58, 0xfd, 0x72, 0x06, 0x5d, 0x84, 0x69, 0x5e, + 0xaf, 0xe3, 0x3a, 0xbb, 0xe2, 0x43, 0x0e, 0x32, 0xe1, 0x05, 0xba, 0x98, 0xde, 0x76, 0x6f, 0x89, + 0x2f, 0x39, 0x2c, 0x43, 0x25, 0xc1, 0xca, 0xb9, 0x5d, 0xee, 0x28, 0xd4, 0x27, 0xa0, 0x26, 0xe2, + 0x6d, 0x6e, 0x17, 0x07, 0x1d, 0x11, 0x14, 0x94, 0x93, 0x79, 0x9a, 0x43, 0x37, 0x04, 0x50, 0x84, + 0x17, 0x96, 0x92, 0x8d, 0x9b, 0x8e, 0xd0, 0xc9, 0x1a, 0x6a, 0x36, 0xcf, 0x6b, 0xb4, 0x0c, 0xcf, + 0xc9, 0x8a, 0xd6, 0x17, 0xa5, 0x60, 0xe5, 0xf0, 0x8e, 0x38, 0x07, 0x8e, 0xfd, 0x3a, 0x85, 0xf5, + 0xbd, 0x22, 0x54, 0x78, 0x75, 0x11, 0x55, 0x7d, 0x1a, 0xb5, 0x64, 0x82, 0x2c, 0xc5, 0x7c, 0x90, + 0xe5, 0xb1, 0x3a, 0x19, 0x4d, 0x45, 0x3d, 0xce, 0xd7, 0x50, 0xb2, 0x21, 0xdb, 0xf2, 0x70, 0xc8, + 0xf6, 0xb8, 0xb1, 0xd5, 0xa1, 0xb8, 0xe9, 0xd4, 0x68, 0xdc, 0xf4, 0x02, 0x54, 0x93, 0xf7, 0xe1, + 0x4c, 0x46, 0x56, 0x4b, 0x36, 0x68, 0x50, 0x8b, 0x8e, 0x51, 0x6e, 0xf5, 0xc9, 0x94, 0x3b, 0x7d, + 0x84, 0x72, 0xbf, 0x61, 0x48, 0xf5, 0x88, 0xc3, 0x8f, 0x3e, 0x71, 0x18, 0x63, 0xae, 0x36, 0x45, + 0xea, 0x85, 0x3c, 0x71, 0xac, 0xc2, 0xa4, 0xf0, 0x9a, 0x3a, 0xc7, 0x02, 0xe5, 0x08, 0xc5, 0x04, + 0xb4, 0x15, 0x05, 0xa7, 0x55, 0x9f, 0xd8, 0x28, 0x8e, 0xa1, 0x15, 0xea, 0xd1, 0x9f, 0xdd, 0xb0, + 0x5e, 0x87, 0xb2, 0x7a, 0x68, 0x23, 0x34, 0x76, 0x18, 0x28, 0x0b, 0xe3, 0x7f, 0xd1, 0x22, 0x4c, + 0x52, 0xf1, 0xe8, 0x5c, 0xd9, 0x85, 0x2a, 0x59, 0xef, 0x88, 0xc8, 0xb1, 0xb8, 0xed, 0xcf, 0x27, + 0x98, 0x18, 0x8f, 0x4e, 0xaf, 0x2a, 0xe4, 0xd2, 0xab, 0xfe, 0xd4, 0x00, 0x90, 0x2b, 0x8a, 0xe8, + 0xfa, 0xc8, 0xcb, 0xda, 0x25, 0x28, 0x47, 0x84, 0xc4, 0x1c, 0xa5, 0xd8, 0xe0, 0xc5, 0xcd, 0x76, + 0x72, 0xd7, 0x5a, 0xcc, 0xdc, 0xb5, 0x0e, 0xdf, 0xec, 0x96, 0x8e, 0x79, 0xb3, 0xfb, 0x9a, 0x3a, + 0x4f, 0xf2, 0x11, 0x12, 0x15, 0x6a, 0x46, 0x99, 0xcb, 0x20, 0xdc, 0x6e, 0x72, 0x8c, 0x3c, 0x63, + 0x8a, 0xbf, 0xd6, 0x26, 0x4c, 0x25, 0xf0, 0xd1, 0x6b, 0x45, 0x63, 0xfc, 0xb5, 0xa2, 0x78, 0xbf, + 0xc3, 0x52, 0x81, 0xe2, 0x5d, 0xd2, 0xa2, 0x56, 0x13, 0x90, 0xcc, 0x87, 0x12, 0x22, 0xd1, 0x77, + 0x77, 0xaf, 0xa6, 0x19, 0x1f, 0xf2, 0x3d, 0x6e, 0xba, 0x4d, 0x4d, 0x65, 0x97, 0xa4, 0x7d, 0xa0, + 0x1a, 0x14, 0x92, 0x86, 0x0b, 0x8c, 0x5a, 0x5f, 0x82, 0xb9, 0x5c, 0xa3, 0xea, 0x9a, 0xbe, 0x91, + 0x6f, 0xb5, 0xf4, 0xe8, 0x06, 0x6e, 0x00, 0x6a, 0xf2, 0x3d, 0x61, 0x93, 0x33, 0xd9, 0xd4, 0x5c, + 0xad, 0xc1, 0x14, 0x3f, 0xec, 0x89, 0x24, 0x8f, 0x71, 0xab, 0x99, 0x4c, 0x02, 0xa9, 0xec, 0xa9, + 0x7f, 0xd6, 0x1a, 0xcc, 0xe5, 0x5a, 0x51, 0x6c, 0x64, 0x64, 0x61, 0xe4, 0x64, 0xe1, 0x8a, 0xc4, + 0xc9, 0xdb, 0x84, 0x1b, 0x50, 0xab, 0x75, 0xef, 0xd9, 0x3c, 0x82, 0xf8, 0xa6, 0x21, 0x92, 0x19, + 0x33, 0xbd, 0x3c, 0x83, 0x24, 0x86, 0xf4, 0xeb, 0x09, 0xc2, 0xff, 0x1d, 0xf9, 0x0c, 0xe2, 0x67, + 0xf2, 0xbd, 0xc0, 0xc6, 0xb5, 0xe6, 0xb3, 0x7c, 0x2f, 0xf0, 0x29, 0x40, 0x51, 0x4c, 0xf6, 0xbd, + 0xb0, 0x4f, 0x33, 0x1f, 0xc5, 0x90, 0xbc, 0x98, 0x1a, 0x93, 0x7c, 0x12, 0xe3, 0x32, 0xd4, 0x12, + 0x6a, 0xd9, 0x98, 0x7c, 0x27, 0x39, 0xa3, 0xa1, 0x0f, 0x33, 0x8f, 0x10, 0x26, 0x87, 0x1f, 0x21, + 0x94, 0x93, 0x91, 0x5b, 0x1f, 0xc9, 0xa4, 0x69, 0x31, 0xb8, 0xd3, 0x96, 0x73, 0x03, 0xca, 0xb4, + 0xef, 0xba, 0x44, 0xa5, 0xff, 0x54, 0x6c, 0x5d, 0x7c, 0x26, 0x83, 0xb5, 0x6e, 0xc0, 0xe2, 0x6d, + 0xc2, 0xf4, 0x2e, 0x4f, 0x4c, 0xc0, 0x27, 0xd7, 0x97, 0xf5, 0x6d, 0x03, 0x96, 0x46, 0x9a, 0x39, + 0x6d, 0xc9, 0x7c, 0x9a, 0x3b, 0x5f, 0x26, 0x96, 0xc0, 0xe2, 0x91, 0x71, 0x79, 0x4d, 0x66, 0xdd, + 0x86, 0xe5, 0x0c, 0x57, 0x77, 0x3c, 0x7e, 0x22, 0x3c, 0x49, 0x92, 0x94, 0xf5, 0x1d, 0x03, 0x56, + 0xc6, 0xb5, 0xf4, 0xcb, 0x1f, 0xe2, 0x9f, 0xc9, 0x34, 0xf4, 0x8d, 0x50, 0x9d, 0x06, 0xc2, 0xf8, + 0x84, 0x39, 0xc5, 0x6e, 0x18, 0xc5, 0xf2, 0x96, 0x5d, 0x72, 0x54, 0xe1, 0x00, 0x71, 0xb9, 0x2e, + 0xce, 0x85, 0x51, 0xac, 0x83, 0x6f, 0x4e, 0x4c, 0x3e, 0x54, 0x9e, 0xa7, 0xc6, 0xe1, 0xe9, 0x43, + 0xb8, 0x4c, 0x32, 0x5d, 0xe9, 0x71, 0x09, 0xde, 0x48, 0x45, 0x1c, 0xa5, 0x51, 0xca, 0xf0, 0x62, + 0x5f, 0xa4, 0xb1, 0xe7, 0x86, 0x72, 0xda, 0x02, 0x46, 0x99, 0x40, 0xa7, 0xee, 0xf6, 0xfb, 0xf2, + 0x79, 0x8f, 0x58, 0x5b, 0x68, 0xbf, 0x77, 0x12, 0xf9, 0x7d, 0x16, 0xa6, 0xb0, 0xdf, 0x09, 0x63, + 0x8f, 0x75, 0x7b, 0xa2, 0xc3, 0xda, 0xfa, 0x4a, 0x4a, 0xad, 0x1a, 0xbe, 0xa6, 0x29, 0xec, 0x94, + 0xf8, 0x49, 0xf2, 0x0f, 0xff, 0x40, 0xa6, 0xe0, 0xa7, 0x7c, 0x9e, 0xb6, 0x70, 0x56, 0xa0, 0xe2, + 0xaa, 0xc6, 0x93, 0x33, 0x8b, 0x2a, 0x73, 0x0b, 0x91, 0x21, 0xd8, 0xbd, 0xfd, 0xe4, 0xeb, 0x29, + 0x02, 0x70, 0x77, 0x5f, 0x6c, 0x3f, 0x25, 0x52, 0x46, 0xaf, 0xe5, 0x1e, 0x19, 0x04, 0x48, 0x86, + 0xaf, 0x7f, 0x50, 0x84, 0xe9, 0x8d, 0xb0, 0x17, 0x61, 0x97, 0x49, 0x06, 0x3e, 0x80, 0x05, 0x12, + 0xc7, 0x8e, 0x17, 0xec, 0x63, 0xdf, 0x6b, 0x3b, 0xf9, 0x1d, 0x57, 0x75, 0xfd, 0x13, 0xd9, 0x3b, + 0xe2, 0xa4, 0xd6, 0xa6, 0xa4, 0x6e, 0xaa, 0xdd, 0xd8, 0x9d, 0x33, 0x36, 0x22, 0xf1, 0x30, 0x14, + 0xf9, 0x70, 0x8e, 0x37, 0x1d, 0xa9, 0x94, 0x5f, 0x47, 0x9d, 0xc9, 0x13, 0x87, 0x29, 0x03, 0x5d, + 0xab, 0x63, 0x7b, 0xd0, 0x79, 0xc2, 0x2d, 0x71, 0x4e, 0x57, 0xae, 0xf4, 0xce, 0x19, 0xbb, 0x41, + 0xe2, 0xf1, 0x38, 0xe4, 0xc0, 0x12, 0xef, 0xcd, 0x95, 0x8d, 0x38, 0x5e, 0xe0, 0x44, 0x71, 0xd8, + 0x89, 0x09, 0xa5, 0x2a, 0x2c, 0xf6, 0xd2, 0xd8, 0x8e, 0xd4, 0xff, 0xcd, 0x60, 0x5b, 0x51, 0xdf, + 0x39, 0x63, 0xcf, 0x93, 0x78, 0x14, 0x8e, 0x76, 0x61, 0x85, 0x77, 0xc0, 0xc2, 0xd0, 0xe9, 0xe1, + 0x60, 0xe0, 0x44, 0x24, 0x68, 0x7b, 0x41, 0xc7, 0x61, 0x98, 0xee, 0x51, 0xb5, 0x1d, 0xbc, 0x32, + 0xb6, 0x8f, 0x56, 0x18, 0xde, 0xc7, 0xc1, 0x60, 0x5b, 0x56, 0x68, 0x71, 0xfa, 0x3b, 0x67, 0xec, + 0x45, 0x12, 0x8f, 0xc3, 0x5c, 0x2f, 0x2b, 0x93, 0xb0, 0xce, 0xc3, 0xd9, 0x23, 0x84, 0x6e, 0xbd, + 0x08, 0x97, 0x1e, 0x2b, 0x31, 0xeb, 0x02, 0x9c, 0x3f, 0x72, 0xb4, 0xd6, 0x25, 0xb8, 0xf0, 0x18, + 0x56, 0xf9, 0x0e, 0xa2, 0xa6, 0x68, 0xf4, 0x94, 0x3c, 0x72, 0x6f, 0xbe, 0x0a, 0xb3, 0x43, 0x3a, + 0xf7, 0xf4, 0x3d, 0x4b, 0x3d, 0xca, 0x72, 0xb9, 0xd9, 0x16, 0xc1, 0x97, 0xb0, 0x93, 0x27, 0x95, + 0x77, 0x2e, 0x35, 0x05, 0xd7, 0x94, 0x43, 0xf9, 0x66, 0xe5, 0xe3, 0xe5, 0x9b, 0x0d, 0x65, 0x4f, + 0x55, 0x86, 0xb3, 0xa7, 0xac, 0x3f, 0x91, 0xf7, 0xc5, 0x72, 0x70, 0x6a, 0x1e, 0xbf, 0x92, 0x0f, + 0xa9, 0x2c, 0x8c, 0x55, 0xaa, 0x9e, 0xab, 0x2f, 0xc2, 0x0c, 0x3f, 0xea, 0xc7, 0xa4, 0x87, 0xbd, + 0xc0, 0x0b, 0x3a, 0xea, 0x0d, 0x01, 0x3f, 0xff, 0xdb, 0x1a, 0x86, 0xd6, 0x44, 0x1e, 0x06, 0xaf, + 0x4b, 0xb2, 0x73, 0x4c, 0x3a, 0xbf, 0xd9, 0x04, 0xd5, 0xcc, 0x88, 0x30, 0xa5, 0xcf, 0xbf, 0x35, + 0xae, 0x27, 0x88, 0x9b, 0xf2, 0xc4, 0xf3, 0x2a, 0x2c, 0xb7, 0x3c, 0xf1, 0x7c, 0xb8, 0x39, 0xa0, + 0x8c, 0xf4, 0x84, 0xc0, 0xb4, 0xa2, 0x4c, 0x28, 0xd2, 0x0f, 0x7d, 0x95, 0xaf, 0xc5, 0xff, 0x5a, + 0x11, 0xac, 0x8c, 0x23, 0x57, 0x43, 0xb7, 0x95, 0x5b, 0x16, 0x3a, 0xbd, 0xfe, 0xf6, 0x47, 0xbf, + 0xb8, 0x70, 0xe6, 0x67, 0xbf, 0xb8, 0xf0, 0x56, 0xc7, 0x63, 0xdd, 0xfe, 0xce, 0x9a, 0x1b, 0xf6, + 0xae, 0x46, 0x5e, 0xd0, 0x71, 0x71, 0x74, 0x75, 0x6f, 0x5f, 0x7e, 0x5a, 0x3d, 0xda, 0xeb, 0x5c, + 0xa5, 0x5d, 0x1c, 0x93, 0xb6, 0xf0, 0x39, 0x6b, 0x4d, 0xf1, 0x5f, 0x78, 0x1b, 0xe9, 0xd6, 0x57, + 0xdf, 0x85, 0xe5, 0x47, 0x7e, 0x69, 0x13, 0xcd, 0x83, 0x99, 0x96, 0x1e, 0x84, 0x71, 0x0f, 0xfb, + 0xe6, 0x19, 0xb4, 0x04, 0x73, 0x29, 0xf4, 0x56, 0x18, 0xbb, 0xe2, 0xe1, 0x83, 0x69, 0xac, 0xfa, + 0x70, 0xee, 0xa8, 0x4f, 0x6b, 0xf2, 0xe6, 0xd4, 0xb3, 0x82, 0xbe, 0xcf, 0x92, 0xe6, 0x2e, 0xc2, + 0xb9, 0x14, 0x7a, 0x6f, 0xe4, 0x0b, 0x99, 0x32, 0x9d, 0x22, 0xa5, 0x90, 0xb7, 0xe4, 0x66, 0x61, + 0xf5, 0x65, 0x80, 0xd4, 0xae, 0xd0, 0x24, 0x14, 0x1e, 0xbe, 0x66, 0x9e, 0x41, 0x53, 0x30, 0xf1, + 0xf0, 0xb5, 0x56, 0xeb, 0x9e, 0x69, 0x08, 0xd0, 0xba, 0x59, 0x58, 0x7d, 0x05, 0x20, 0xcd, 0xb7, + 0x45, 0x00, 0x93, 0x49, 0xd7, 0x65, 0x28, 0xde, 0x0b, 0x0f, 0x4c, 0x03, 0x55, 0xa0, 0x74, 0xc7, + 0xeb, 0x74, 0xcd, 0xc2, 0xea, 0x55, 0xa8, 0xe5, 0x93, 0x6c, 0x79, 0x33, 0xcd, 0x4d, 0xf3, 0x0c, + 0xff, 0xb5, 0x37, 0x4c, 0x43, 0xa4, 0x6c, 0x6c, 0xc8, 0x94, 0x8d, 0xa6, 0x59, 0x58, 0x7d, 0x08, + 0xd5, 0x4c, 0xc2, 0x26, 0xe7, 0xf5, 0x41, 0xc8, 0xae, 0xf9, 0x7e, 0x78, 0x40, 0xda, 0x5b, 0x01, + 0x07, 0x4b, 0x91, 0x25, 0xa0, 0x6b, 0x7e, 0x2f, 0xa4, 0x4c, 0x20, 0x0c, 0xd4, 0x80, 0xf9, 0x0c, + 0x42, 0x24, 0x78, 0x08, 0x4c, 0x61, 0xd5, 0x85, 0xc2, 0x56, 0xc4, 0x39, 0xdc, 0xee, 0x33, 0xc9, + 0xea, 0x0d, 0xe2, 0x4b, 0x56, 0x85, 0xb8, 0x0b, 0x68, 0x1a, 0x2a, 0x3a, 0xa6, 0x65, 0x16, 0xf9, + 0xb8, 0x36, 0x03, 0x4a, 0x62, 0x66, 0x96, 0xd0, 0x1c, 0xd4, 0x87, 0x14, 0x61, 0x4e, 0x20, 0x04, + 0x35, 0xc1, 0xb5, 0x76, 0x3f, 0xd4, 0x9c, 0x5c, 0x5d, 0x83, 0xa9, 0x24, 0xc4, 0xc7, 0x5b, 0x7e, + 0x10, 0x06, 0x44, 0x0a, 0x51, 0x90, 0x98, 0x06, 0xef, 0x44, 0x57, 0x90, 0xd2, 0xc9, 0x7f, 0x0a, + 0x9a, 0xf3, 0xb5, 0xb5, 0xbb, 0x6b, 0x9e, 0xe1, 0xb5, 0x6f, 0x61, 0x51, 0x05, 0x60, 0xb2, 0xc9, + 0x62, 0xae, 0xba, 0xc2, 0xea, 0x77, 0x0d, 0x98, 0x54, 0x1f, 0x50, 0x16, 0x2d, 0xc9, 0xff, 0xe6, + 0x19, 0xb4, 0x00, 0xb3, 0xad, 0xd6, 0x3d, 0x99, 0x04, 0x92, 0x8c, 0x42, 0xc8, 0x43, 0x84, 0xab, + 0x55, 0x97, 0x09, 0xa6, 0xc0, 0x2b, 0xdc, 0x4f, 0xb2, 0x36, 0x9a, 0xdb, 0x7d, 0xda, 0x25, 0x6d, + 0xb3, 0xc8, 0xad, 0x27, 0x69, 0x67, 0xcc, 0x47, 0x30, 0xcd, 0x12, 0x5a, 0x86, 0x85, 0x6c, 0x93, + 0x37, 0xc2, 0x07, 0x21, 0xeb, 0x7a, 0x41, 0xc7, 0x9c, 0x58, 0xbd, 0x0c, 0xe5, 0x9b, 0x87, 0x2c, + 0xc6, 0x5b, 0x91, 0x1c, 0x7c, 0x18, 0x99, 0x67, 0x90, 0x09, 0xd3, 0xfc, 0x80, 0xbf, 0xe5, 0xb7, + 0xc5, 0xde, 0xdf, 0x34, 0x56, 0x2d, 0x98, 0x1d, 0xd9, 0x9d, 0x70, 0x33, 0xd8, 0x88, 0xdd, 0xb7, + 0xde, 0x70, 0xfe, 0x73, 0x18, 0x9b, 0x67, 0xae, 0xbf, 0xf4, 0xd7, 0xbf, 0x5d, 0x31, 0x3e, 0xfa, + 0xf8, 0x05, 0xe3, 0x27, 0x1f, 0xbf, 0x60, 0xfc, 0xed, 0xc7, 0x2f, 0x18, 0xbf, 0xf1, 0x77, 0x2f, + 0x9c, 0x01, 0x33, 0x8c, 0x3b, 0x6b, 0xcc, 0xdb, 0xdb, 0x5f, 0x53, 0x33, 0x72, 0x67, 0x52, 0xfc, + 0xbc, 0xfe, 0x6f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x24, 0xed, 0x7d, 0xa4, 0x35, 0x61, 0x00, 0x00, } func (m *GetRequest) Marshal() (dAtA []byte, err error) { @@ -15854,6 +15865,11 @@ func (m *ResourceControlContext) MarshalToSizedBuffer(dAtA []byte) (int, error) i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } + if m.OverridePriority != 0 { + i = encodeVarintKvrpcpb(dAtA, i, uint64(m.OverridePriority)) + i-- + dAtA[i] = 0x18 + } if m.Penalty != nil { { size, err := m.Penalty.MarshalToSizedBuffer(dAtA[:i]) @@ -21097,6 +21113,9 @@ func (m *ResourceControlContext) Size() (n int) { l = m.Penalty.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } + if m.OverridePriority != 0 { + n += 1 + sovKvrpcpb(uint64(m.OverridePriority)) + } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } @@ -36027,6 +36046,25 @@ func (m *ResourceControlContext) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field OverridePriority", wireType) + } + m.OverridePriority = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowKvrpcpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.OverridePriority |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) diff --git a/pkg/pdpb/pdpb.pb.go b/pkg/pdpb/pdpb.pb.go index b8124e8e0..197fee881 100644 --- a/pkg/pdpb/pdpb.pb.go +++ b/pkg/pdpb/pdpb.pb.go @@ -5714,30 +5714,26 @@ func (m *UpdateServiceGCSafePointResponse) GetMinSafePoint() uint64 { return 0 } -type RegionStat struct { - // Bytes read/written during this period. - BytesWritten uint64 `protobuf:"varint,1,opt,name=bytes_written,json=bytesWritten,proto3" json:"bytes_written,omitempty"` - BytesRead uint64 `protobuf:"varint,2,opt,name=bytes_read,json=bytesRead,proto3" json:"bytes_read,omitempty"` - // Keys read/written during this period. - KeysWritten uint64 `protobuf:"varint,3,opt,name=keys_written,json=keysWritten,proto3" json:"keys_written,omitempty"` - KeysRead uint64 `protobuf:"varint,4,opt,name=keys_read,json=keysRead,proto3" json:"keys_read,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` +type GetGCSafePointV2Request struct { + Header *RequestHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"` + KeyspaceId uint32 `protobuf:"varint,2,opt,name=keyspace_id,json=keyspaceId,proto3" json:"keyspace_id,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } -func (m *RegionStat) Reset() { *m = RegionStat{} } -func (m *RegionStat) String() string { return proto.CompactTextString(m) } -func (*RegionStat) ProtoMessage() {} -func (*RegionStat) Descriptor() ([]byte, []int) { +func (m *GetGCSafePointV2Request) Reset() { *m = GetGCSafePointV2Request{} } +func (m *GetGCSafePointV2Request) String() string { return proto.CompactTextString(m) } +func (*GetGCSafePointV2Request) ProtoMessage() {} +func (*GetGCSafePointV2Request) Descriptor() ([]byte, []int) { return fileDescriptor_78b27e6f04f44c6e, []int{83} } -func (m *RegionStat) XXX_Unmarshal(b []byte) error { +func (m *GetGCSafePointV2Request) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *RegionStat) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *GetGCSafePointV2Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_RegionStat.Marshal(b, m, deterministic) + return xxx_messageInfo_GetGCSafePointV2Request.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -5747,69 +5743,52 @@ func (m *RegionStat) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return b[:n], nil } } -func (m *RegionStat) XXX_Merge(src proto.Message) { - xxx_messageInfo_RegionStat.Merge(m, src) +func (m *GetGCSafePointV2Request) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetGCSafePointV2Request.Merge(m, src) } -func (m *RegionStat) XXX_Size() int { +func (m *GetGCSafePointV2Request) XXX_Size() int { return m.Size() } -func (m *RegionStat) XXX_DiscardUnknown() { - xxx_messageInfo_RegionStat.DiscardUnknown(m) -} - -var xxx_messageInfo_RegionStat proto.InternalMessageInfo - -func (m *RegionStat) GetBytesWritten() uint64 { - if m != nil { - return m.BytesWritten - } - return 0 +func (m *GetGCSafePointV2Request) XXX_DiscardUnknown() { + xxx_messageInfo_GetGCSafePointV2Request.DiscardUnknown(m) } -func (m *RegionStat) GetBytesRead() uint64 { - if m != nil { - return m.BytesRead - } - return 0 -} +var xxx_messageInfo_GetGCSafePointV2Request proto.InternalMessageInfo -func (m *RegionStat) GetKeysWritten() uint64 { +func (m *GetGCSafePointV2Request) GetHeader() *RequestHeader { if m != nil { - return m.KeysWritten + return m.Header } - return 0 + return nil } -func (m *RegionStat) GetKeysRead() uint64 { +func (m *GetGCSafePointV2Request) GetKeyspaceId() uint32 { if m != nil { - return m.KeysRead + return m.KeyspaceId } return 0 } -type SyncRegionRequest struct { - Header *RequestHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"` - Member *Member `protobuf:"bytes,2,opt,name=member,proto3" json:"member,omitempty"` - // the follower PD will use the start index to locate historical changes - // that require synchronization. - StartIndex uint64 `protobuf:"varint,3,opt,name=start_index,json=startIndex,proto3" json:"start_index,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` +type GetGCSafePointV2Response struct { + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"` + SafePoint uint64 `protobuf:"varint,2,opt,name=safe_point,json=safePoint,proto3" json:"safe_point,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } -func (m *SyncRegionRequest) Reset() { *m = SyncRegionRequest{} } -func (m *SyncRegionRequest) String() string { return proto.CompactTextString(m) } -func (*SyncRegionRequest) ProtoMessage() {} -func (*SyncRegionRequest) Descriptor() ([]byte, []int) { +func (m *GetGCSafePointV2Response) Reset() { *m = GetGCSafePointV2Response{} } +func (m *GetGCSafePointV2Response) String() string { return proto.CompactTextString(m) } +func (*GetGCSafePointV2Response) ProtoMessage() {} +func (*GetGCSafePointV2Response) Descriptor() ([]byte, []int) { return fileDescriptor_78b27e6f04f44c6e, []int{84} } -func (m *SyncRegionRequest) XXX_Unmarshal(b []byte) error { +func (m *GetGCSafePointV2Response) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *SyncRegionRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *GetGCSafePointV2Response) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_SyncRegionRequest.Marshal(b, m, deterministic) + return xxx_messageInfo_GetGCSafePointV2Response.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -5819,58 +5798,52 @@ func (m *SyncRegionRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, e return b[:n], nil } } -func (m *SyncRegionRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_SyncRegionRequest.Merge(m, src) +func (m *GetGCSafePointV2Response) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetGCSafePointV2Response.Merge(m, src) } -func (m *SyncRegionRequest) XXX_Size() int { +func (m *GetGCSafePointV2Response) XXX_Size() int { return m.Size() } -func (m *SyncRegionRequest) XXX_DiscardUnknown() { - xxx_messageInfo_SyncRegionRequest.DiscardUnknown(m) +func (m *GetGCSafePointV2Response) XXX_DiscardUnknown() { + xxx_messageInfo_GetGCSafePointV2Response.DiscardUnknown(m) } -var xxx_messageInfo_SyncRegionRequest proto.InternalMessageInfo +var xxx_messageInfo_GetGCSafePointV2Response proto.InternalMessageInfo -func (m *SyncRegionRequest) GetHeader() *RequestHeader { +func (m *GetGCSafePointV2Response) GetHeader() *ResponseHeader { if m != nil { return m.Header } return nil } -func (m *SyncRegionRequest) GetMember() *Member { - if m != nil { - return m.Member - } - return nil -} - -func (m *SyncRegionRequest) GetStartIndex() uint64 { +func (m *GetGCSafePointV2Response) GetSafePoint() uint64 { if m != nil { - return m.StartIndex + return m.SafePoint } return 0 } -type PeersStats struct { - Peers []*PeerStats `protobuf:"bytes,1,rep,name=peers,proto3" json:"peers,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` +type WatchGCSafePointV2Request struct { + Header *RequestHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"` + Revision int64 `protobuf:"varint,2,opt,name=revision,proto3" json:"revision,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } -func (m *PeersStats) Reset() { *m = PeersStats{} } -func (m *PeersStats) String() string { return proto.CompactTextString(m) } -func (*PeersStats) ProtoMessage() {} -func (*PeersStats) Descriptor() ([]byte, []int) { +func (m *WatchGCSafePointV2Request) Reset() { *m = WatchGCSafePointV2Request{} } +func (m *WatchGCSafePointV2Request) String() string { return proto.CompactTextString(m) } +func (*WatchGCSafePointV2Request) ProtoMessage() {} +func (*WatchGCSafePointV2Request) Descriptor() ([]byte, []int) { return fileDescriptor_78b27e6f04f44c6e, []int{85} } -func (m *PeersStats) XXX_Unmarshal(b []byte) error { +func (m *WatchGCSafePointV2Request) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *PeersStats) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *WatchGCSafePointV2Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_PeersStats.Marshal(b, m, deterministic) + return xxx_messageInfo_WatchGCSafePointV2Request.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -5880,44 +5853,54 @@ func (m *PeersStats) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return b[:n], nil } } -func (m *PeersStats) XXX_Merge(src proto.Message) { - xxx_messageInfo_PeersStats.Merge(m, src) +func (m *WatchGCSafePointV2Request) XXX_Merge(src proto.Message) { + xxx_messageInfo_WatchGCSafePointV2Request.Merge(m, src) } -func (m *PeersStats) XXX_Size() int { +func (m *WatchGCSafePointV2Request) XXX_Size() int { return m.Size() } -func (m *PeersStats) XXX_DiscardUnknown() { - xxx_messageInfo_PeersStats.DiscardUnknown(m) +func (m *WatchGCSafePointV2Request) XXX_DiscardUnknown() { + xxx_messageInfo_WatchGCSafePointV2Request.DiscardUnknown(m) } -var xxx_messageInfo_PeersStats proto.InternalMessageInfo +var xxx_messageInfo_WatchGCSafePointV2Request proto.InternalMessageInfo -func (m *PeersStats) GetPeers() []*PeerStats { +func (m *WatchGCSafePointV2Request) GetHeader() *RequestHeader { if m != nil { - return m.Peers + return m.Header } return nil } -type Peers struct { - Peers []*metapb.Peer `protobuf:"bytes,1,rep,name=peers,proto3" json:"peers,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` +func (m *WatchGCSafePointV2Request) GetRevision() int64 { + if m != nil { + return m.Revision + } + return 0 } -func (m *Peers) Reset() { *m = Peers{} } -func (m *Peers) String() string { return proto.CompactTextString(m) } -func (*Peers) ProtoMessage() {} -func (*Peers) Descriptor() ([]byte, []int) { +// SafePointEvent is for the rpc WatchGCSafePointV2. +type SafePointEvent struct { + KeyspaceId uint32 `protobuf:"varint,1,opt,name=keyspace_id,json=keyspaceId,proto3" json:"keyspace_id,omitempty"` + SafePoint uint64 `protobuf:"varint,2,opt,name=safe_point,json=safePoint,proto3" json:"safe_point,omitempty"` + Type EventType `protobuf:"varint,3,opt,name=type,proto3,enum=pdpb.EventType" json:"type,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *SafePointEvent) Reset() { *m = SafePointEvent{} } +func (m *SafePointEvent) String() string { return proto.CompactTextString(m) } +func (*SafePointEvent) ProtoMessage() {} +func (*SafePointEvent) Descriptor() ([]byte, []int) { return fileDescriptor_78b27e6f04f44c6e, []int{86} } -func (m *Peers) XXX_Unmarshal(b []byte) error { +func (m *SafePointEvent) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *Peers) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *SafePointEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_Peers.Marshal(b, m, deterministic) + return xxx_messageInfo_SafePointEvent.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -5927,54 +5910,60 @@ func (m *Peers) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return b[:n], nil } } -func (m *Peers) XXX_Merge(src proto.Message) { - xxx_messageInfo_Peers.Merge(m, src) +func (m *SafePointEvent) XXX_Merge(src proto.Message) { + xxx_messageInfo_SafePointEvent.Merge(m, src) } -func (m *Peers) XXX_Size() int { +func (m *SafePointEvent) XXX_Size() int { return m.Size() } -func (m *Peers) XXX_DiscardUnknown() { - xxx_messageInfo_Peers.DiscardUnknown(m) +func (m *SafePointEvent) XXX_DiscardUnknown() { + xxx_messageInfo_SafePointEvent.DiscardUnknown(m) } -var xxx_messageInfo_Peers proto.InternalMessageInfo +var xxx_messageInfo_SafePointEvent proto.InternalMessageInfo -func (m *Peers) GetPeers() []*metapb.Peer { +func (m *SafePointEvent) GetKeyspaceId() uint32 { if m != nil { - return m.Peers + return m.KeyspaceId } - return nil + return 0 } -type SyncRegionResponse struct { - Header *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"` - // the leader PD will send the repsonds include - // changed regions records and the index of the first record. - Regions []*metapb.Region `protobuf:"bytes,2,rep,name=regions,proto3" json:"regions,omitempty"` - StartIndex uint64 `protobuf:"varint,3,opt,name=start_index,json=startIndex,proto3" json:"start_index,omitempty"` - RegionStats []*RegionStat `protobuf:"bytes,4,rep,name=region_stats,json=regionStats,proto3" json:"region_stats,omitempty"` - RegionLeaders []*metapb.Peer `protobuf:"bytes,5,rep,name=region_leaders,json=regionLeaders,proto3" json:"region_leaders,omitempty"` - // the buckets informations without stats. - Buckets []*metapb.Buckets `protobuf:"bytes,6,rep,name=buckets,proto3" json:"buckets,omitempty"` - DownPeers []*PeersStats `protobuf:"bytes,16,rep,name=down_peers,json=downPeers,proto3" json:"down_peers,omitempty"` - PendingPeers []*Peers `protobuf:"bytes,17,rep,name=pending_peers,json=pendingPeers,proto3" json:"pending_peers,omitempty"` +func (m *SafePointEvent) GetSafePoint() uint64 { + if m != nil { + return m.SafePoint + } + return 0 +} + +func (m *SafePointEvent) GetType() EventType { + if m != nil { + return m.Type + } + return EventType_PUT +} + +type WatchGCSafePointV2Response struct { + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"` + Events []*SafePointEvent `protobuf:"bytes,2,rep,name=events,proto3" json:"events,omitempty"` + Revision int64 `protobuf:"varint,3,opt,name=revision,proto3" json:"revision,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } -func (m *SyncRegionResponse) Reset() { *m = SyncRegionResponse{} } -func (m *SyncRegionResponse) String() string { return proto.CompactTextString(m) } -func (*SyncRegionResponse) ProtoMessage() {} -func (*SyncRegionResponse) Descriptor() ([]byte, []int) { +func (m *WatchGCSafePointV2Response) Reset() { *m = WatchGCSafePointV2Response{} } +func (m *WatchGCSafePointV2Response) String() string { return proto.CompactTextString(m) } +func (*WatchGCSafePointV2Response) ProtoMessage() {} +func (*WatchGCSafePointV2Response) Descriptor() ([]byte, []int) { return fileDescriptor_78b27e6f04f44c6e, []int{87} } -func (m *SyncRegionResponse) XXX_Unmarshal(b []byte) error { +func (m *WatchGCSafePointV2Response) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *SyncRegionResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *WatchGCSafePointV2Response) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_SyncRegionResponse.Marshal(b, m, deterministic) + return xxx_messageInfo_WatchGCSafePointV2Response.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -5984,94 +5973,60 @@ func (m *SyncRegionResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, return b[:n], nil } } -func (m *SyncRegionResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_SyncRegionResponse.Merge(m, src) +func (m *WatchGCSafePointV2Response) XXX_Merge(src proto.Message) { + xxx_messageInfo_WatchGCSafePointV2Response.Merge(m, src) } -func (m *SyncRegionResponse) XXX_Size() int { +func (m *WatchGCSafePointV2Response) XXX_Size() int { return m.Size() } -func (m *SyncRegionResponse) XXX_DiscardUnknown() { - xxx_messageInfo_SyncRegionResponse.DiscardUnknown(m) +func (m *WatchGCSafePointV2Response) XXX_DiscardUnknown() { + xxx_messageInfo_WatchGCSafePointV2Response.DiscardUnknown(m) } -var xxx_messageInfo_SyncRegionResponse proto.InternalMessageInfo +var xxx_messageInfo_WatchGCSafePointV2Response proto.InternalMessageInfo -func (m *SyncRegionResponse) GetHeader() *ResponseHeader { +func (m *WatchGCSafePointV2Response) GetHeader() *ResponseHeader { if m != nil { return m.Header } return nil } -func (m *SyncRegionResponse) GetRegions() []*metapb.Region { +func (m *WatchGCSafePointV2Response) GetEvents() []*SafePointEvent { if m != nil { - return m.Regions + return m.Events } return nil } -func (m *SyncRegionResponse) GetStartIndex() uint64 { +func (m *WatchGCSafePointV2Response) GetRevision() int64 { if m != nil { - return m.StartIndex + return m.Revision } return 0 } -func (m *SyncRegionResponse) GetRegionStats() []*RegionStat { - if m != nil { - return m.RegionStats - } - return nil -} - -func (m *SyncRegionResponse) GetRegionLeaders() []*metapb.Peer { - if m != nil { - return m.RegionLeaders - } - return nil -} - -func (m *SyncRegionResponse) GetBuckets() []*metapb.Buckets { - if m != nil { - return m.Buckets - } - return nil -} - -func (m *SyncRegionResponse) GetDownPeers() []*PeersStats { - if m != nil { - return m.DownPeers - } - return nil -} - -func (m *SyncRegionResponse) GetPendingPeers() []*Peers { - if m != nil { - return m.PendingPeers - } - return nil -} - -type GetOperatorRequest struct { +type UpdateGCSafePointV2Request struct { Header *RequestHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"` - RegionId uint64 `protobuf:"varint,2,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty"` + KeyspaceId uint32 `protobuf:"varint,2,opt,name=keyspace_id,json=keyspaceId,proto3" json:"keyspace_id,omitempty"` + SafePoint uint64 `protobuf:"varint,3,opt,name=safe_point,json=safePoint,proto3" json:"safe_point,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } -func (m *GetOperatorRequest) Reset() { *m = GetOperatorRequest{} } -func (m *GetOperatorRequest) String() string { return proto.CompactTextString(m) } -func (*GetOperatorRequest) ProtoMessage() {} -func (*GetOperatorRequest) Descriptor() ([]byte, []int) { +func (m *UpdateGCSafePointV2Request) Reset() { *m = UpdateGCSafePointV2Request{} } +func (m *UpdateGCSafePointV2Request) String() string { return proto.CompactTextString(m) } +func (*UpdateGCSafePointV2Request) ProtoMessage() {} +func (*UpdateGCSafePointV2Request) Descriptor() ([]byte, []int) { return fileDescriptor_78b27e6f04f44c6e, []int{88} } -func (m *GetOperatorRequest) XXX_Unmarshal(b []byte) error { +func (m *UpdateGCSafePointV2Request) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *GetOperatorRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *UpdateGCSafePointV2Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_GetOperatorRequest.Marshal(b, m, deterministic) + return xxx_messageInfo_UpdateGCSafePointV2Request.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -6081,55 +6036,59 @@ func (m *GetOperatorRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, return b[:n], nil } } -func (m *GetOperatorRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetOperatorRequest.Merge(m, src) +func (m *UpdateGCSafePointV2Request) XXX_Merge(src proto.Message) { + xxx_messageInfo_UpdateGCSafePointV2Request.Merge(m, src) } -func (m *GetOperatorRequest) XXX_Size() int { +func (m *UpdateGCSafePointV2Request) XXX_Size() int { return m.Size() } -func (m *GetOperatorRequest) XXX_DiscardUnknown() { - xxx_messageInfo_GetOperatorRequest.DiscardUnknown(m) +func (m *UpdateGCSafePointV2Request) XXX_DiscardUnknown() { + xxx_messageInfo_UpdateGCSafePointV2Request.DiscardUnknown(m) } -var xxx_messageInfo_GetOperatorRequest proto.InternalMessageInfo +var xxx_messageInfo_UpdateGCSafePointV2Request proto.InternalMessageInfo -func (m *GetOperatorRequest) GetHeader() *RequestHeader { +func (m *UpdateGCSafePointV2Request) GetHeader() *RequestHeader { if m != nil { return m.Header } return nil } -func (m *GetOperatorRequest) GetRegionId() uint64 { +func (m *UpdateGCSafePointV2Request) GetKeyspaceId() uint32 { if m != nil { - return m.RegionId + return m.KeyspaceId } return 0 } -type GetOperatorResponse struct { +func (m *UpdateGCSafePointV2Request) GetSafePoint() uint64 { + if m != nil { + return m.SafePoint + } + return 0 +} + +type UpdateGCSafePointV2Response struct { Header *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"` - RegionId uint64 `protobuf:"varint,2,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty"` - Desc []byte `protobuf:"bytes,3,opt,name=desc,proto3" json:"desc,omitempty"` - Status OperatorStatus `protobuf:"varint,4,opt,name=status,proto3,enum=pdpb.OperatorStatus" json:"status,omitempty"` - Kind []byte `protobuf:"bytes,5,opt,name=kind,proto3" json:"kind,omitempty"` + NewSafePoint uint64 `protobuf:"varint,2,opt,name=new_safe_point,json=newSafePoint,proto3" json:"new_safe_point,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } -func (m *GetOperatorResponse) Reset() { *m = GetOperatorResponse{} } -func (m *GetOperatorResponse) String() string { return proto.CompactTextString(m) } -func (*GetOperatorResponse) ProtoMessage() {} -func (*GetOperatorResponse) Descriptor() ([]byte, []int) { +func (m *UpdateGCSafePointV2Response) Reset() { *m = UpdateGCSafePointV2Response{} } +func (m *UpdateGCSafePointV2Response) String() string { return proto.CompactTextString(m) } +func (*UpdateGCSafePointV2Response) ProtoMessage() {} +func (*UpdateGCSafePointV2Response) Descriptor() ([]byte, []int) { return fileDescriptor_78b27e6f04f44c6e, []int{89} } -func (m *GetOperatorResponse) XXX_Unmarshal(b []byte) error { +func (m *UpdateGCSafePointV2Response) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *GetOperatorResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *UpdateGCSafePointV2Response) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_GetOperatorResponse.Marshal(b, m, deterministic) + return xxx_messageInfo_UpdateGCSafePointV2Response.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -6139,75 +6098,60 @@ func (m *GetOperatorResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, return b[:n], nil } } -func (m *GetOperatorResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetOperatorResponse.Merge(m, src) +func (m *UpdateGCSafePointV2Response) XXX_Merge(src proto.Message) { + xxx_messageInfo_UpdateGCSafePointV2Response.Merge(m, src) } -func (m *GetOperatorResponse) XXX_Size() int { +func (m *UpdateGCSafePointV2Response) XXX_Size() int { return m.Size() } -func (m *GetOperatorResponse) XXX_DiscardUnknown() { - xxx_messageInfo_GetOperatorResponse.DiscardUnknown(m) +func (m *UpdateGCSafePointV2Response) XXX_DiscardUnknown() { + xxx_messageInfo_UpdateGCSafePointV2Response.DiscardUnknown(m) } -var xxx_messageInfo_GetOperatorResponse proto.InternalMessageInfo +var xxx_messageInfo_UpdateGCSafePointV2Response proto.InternalMessageInfo -func (m *GetOperatorResponse) GetHeader() *ResponseHeader { +func (m *UpdateGCSafePointV2Response) GetHeader() *ResponseHeader { if m != nil { return m.Header } return nil } -func (m *GetOperatorResponse) GetRegionId() uint64 { +func (m *UpdateGCSafePointV2Response) GetNewSafePoint() uint64 { if m != nil { - return m.RegionId + return m.NewSafePoint } return 0 } -func (m *GetOperatorResponse) GetDesc() []byte { - if m != nil { - return m.Desc - } - return nil -} - -func (m *GetOperatorResponse) GetStatus() OperatorStatus { - if m != nil { - return m.Status - } - return OperatorStatus_SUCCESS -} - -func (m *GetOperatorResponse) GetKind() []byte { - if m != nil { - return m.Kind - } - return nil -} - -type SyncMaxTSRequest struct { - Header *RequestHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"` - MaxTs *Timestamp `protobuf:"bytes,2,opt,name=max_ts,json=maxTs,proto3" json:"max_ts,omitempty"` - // If skip_check is true, the sync will try to write the max_ts without checking whether it's bigger. - SkipCheck bool `protobuf:"varint,3,opt,name=skip_check,json=skipCheck,proto3" json:"skip_check,omitempty"` +type UpdateServiceSafePointV2Request struct { + Header *RequestHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"` + KeyspaceId uint32 `protobuf:"varint,2,opt,name=keyspace_id,json=keyspaceId,proto3" json:"keyspace_id,omitempty"` + ServiceId []byte `protobuf:"bytes,3,opt,name=service_id,json=serviceId,proto3" json:"service_id,omitempty"` + SafePoint uint64 `protobuf:"varint,4,opt,name=safe_point,json=safePoint,proto3" json:"safe_point,omitempty"` + // Safe point will be set to expire on (PD Server time + TTL), + // pass in a ttl < 0 to remove target safe point; + // pass in MAX_INT64 to set a safe point that never expire. + // This should be set by component that may crash unexpectedly so that it doesn't block + // cluster garbage collection. + Ttl int64 `protobuf:"varint,5,opt,name=ttl,proto3" json:"ttl,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } -func (m *SyncMaxTSRequest) Reset() { *m = SyncMaxTSRequest{} } -func (m *SyncMaxTSRequest) String() string { return proto.CompactTextString(m) } -func (*SyncMaxTSRequest) ProtoMessage() {} -func (*SyncMaxTSRequest) Descriptor() ([]byte, []int) { +func (m *UpdateServiceSafePointV2Request) Reset() { *m = UpdateServiceSafePointV2Request{} } +func (m *UpdateServiceSafePointV2Request) String() string { return proto.CompactTextString(m) } +func (*UpdateServiceSafePointV2Request) ProtoMessage() {} +func (*UpdateServiceSafePointV2Request) Descriptor() ([]byte, []int) { return fileDescriptor_78b27e6f04f44c6e, []int{90} } -func (m *SyncMaxTSRequest) XXX_Unmarshal(b []byte) error { +func (m *UpdateServiceSafePointV2Request) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *SyncMaxTSRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *UpdateServiceSafePointV2Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_SyncMaxTSRequest.Marshal(b, m, deterministic) + return xxx_messageInfo_UpdateServiceSafePointV2Request.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -6217,60 +6161,75 @@ func (m *SyncMaxTSRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, er return b[:n], nil } } -func (m *SyncMaxTSRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_SyncMaxTSRequest.Merge(m, src) +func (m *UpdateServiceSafePointV2Request) XXX_Merge(src proto.Message) { + xxx_messageInfo_UpdateServiceSafePointV2Request.Merge(m, src) } -func (m *SyncMaxTSRequest) XXX_Size() int { +func (m *UpdateServiceSafePointV2Request) XXX_Size() int { return m.Size() } -func (m *SyncMaxTSRequest) XXX_DiscardUnknown() { - xxx_messageInfo_SyncMaxTSRequest.DiscardUnknown(m) +func (m *UpdateServiceSafePointV2Request) XXX_DiscardUnknown() { + xxx_messageInfo_UpdateServiceSafePointV2Request.DiscardUnknown(m) } -var xxx_messageInfo_SyncMaxTSRequest proto.InternalMessageInfo +var xxx_messageInfo_UpdateServiceSafePointV2Request proto.InternalMessageInfo -func (m *SyncMaxTSRequest) GetHeader() *RequestHeader { +func (m *UpdateServiceSafePointV2Request) GetHeader() *RequestHeader { if m != nil { return m.Header } return nil } -func (m *SyncMaxTSRequest) GetMaxTs() *Timestamp { +func (m *UpdateServiceSafePointV2Request) GetKeyspaceId() uint32 { if m != nil { - return m.MaxTs + return m.KeyspaceId + } + return 0 +} + +func (m *UpdateServiceSafePointV2Request) GetServiceId() []byte { + if m != nil { + return m.ServiceId } return nil } -func (m *SyncMaxTSRequest) GetSkipCheck() bool { +func (m *UpdateServiceSafePointV2Request) GetSafePoint() uint64 { if m != nil { - return m.SkipCheck + return m.SafePoint } - return false + return 0 } -type SyncMaxTSResponse struct { +func (m *UpdateServiceSafePointV2Request) GetTtl() int64 { + if m != nil { + return m.Ttl + } + return 0 +} + +type UpdateServiceSafePointV2Response struct { Header *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"` - MaxLocalTs *Timestamp `protobuf:"bytes,2,opt,name=max_local_ts,json=maxLocalTs,proto3" json:"max_local_ts,omitempty"` - SyncedDcs []string `protobuf:"bytes,3,rep,name=synced_dcs,json=syncedDcs,proto3" json:"synced_dcs,omitempty"` + ServiceId []byte `protobuf:"bytes,2,opt,name=service_id,json=serviceId,proto3" json:"service_id,omitempty"` + Ttl int64 `protobuf:"varint,3,opt,name=ttl,proto3" json:"ttl,omitempty"` + MinSafePoint uint64 `protobuf:"varint,4,opt,name=min_safe_point,json=minSafePoint,proto3" json:"min_safe_point,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } -func (m *SyncMaxTSResponse) Reset() { *m = SyncMaxTSResponse{} } -func (m *SyncMaxTSResponse) String() string { return proto.CompactTextString(m) } -func (*SyncMaxTSResponse) ProtoMessage() {} -func (*SyncMaxTSResponse) Descriptor() ([]byte, []int) { +func (m *UpdateServiceSafePointV2Response) Reset() { *m = UpdateServiceSafePointV2Response{} } +func (m *UpdateServiceSafePointV2Response) String() string { return proto.CompactTextString(m) } +func (*UpdateServiceSafePointV2Response) ProtoMessage() {} +func (*UpdateServiceSafePointV2Response) Descriptor() ([]byte, []int) { return fileDescriptor_78b27e6f04f44c6e, []int{91} } -func (m *SyncMaxTSResponse) XXX_Unmarshal(b []byte) error { +func (m *UpdateServiceSafePointV2Response) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *SyncMaxTSResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *UpdateServiceSafePointV2Response) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_SyncMaxTSResponse.Marshal(b, m, deterministic) + return xxx_messageInfo_UpdateServiceSafePointV2Response.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -6280,60 +6239,70 @@ func (m *SyncMaxTSResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, e return b[:n], nil } } -func (m *SyncMaxTSResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_SyncMaxTSResponse.Merge(m, src) +func (m *UpdateServiceSafePointV2Response) XXX_Merge(src proto.Message) { + xxx_messageInfo_UpdateServiceSafePointV2Response.Merge(m, src) } -func (m *SyncMaxTSResponse) XXX_Size() int { +func (m *UpdateServiceSafePointV2Response) XXX_Size() int { return m.Size() } -func (m *SyncMaxTSResponse) XXX_DiscardUnknown() { - xxx_messageInfo_SyncMaxTSResponse.DiscardUnknown(m) +func (m *UpdateServiceSafePointV2Response) XXX_DiscardUnknown() { + xxx_messageInfo_UpdateServiceSafePointV2Response.DiscardUnknown(m) } -var xxx_messageInfo_SyncMaxTSResponse proto.InternalMessageInfo +var xxx_messageInfo_UpdateServiceSafePointV2Response proto.InternalMessageInfo -func (m *SyncMaxTSResponse) GetHeader() *ResponseHeader { +func (m *UpdateServiceSafePointV2Response) GetHeader() *ResponseHeader { if m != nil { return m.Header } return nil } -func (m *SyncMaxTSResponse) GetMaxLocalTs() *Timestamp { +func (m *UpdateServiceSafePointV2Response) GetServiceId() []byte { if m != nil { - return m.MaxLocalTs + return m.ServiceId } return nil } -func (m *SyncMaxTSResponse) GetSyncedDcs() []string { +func (m *UpdateServiceSafePointV2Response) GetTtl() int64 { if m != nil { - return m.SyncedDcs + return m.Ttl } - return nil + return 0 } -type SplitRegionsRequest struct { - Header *RequestHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"` - SplitKeys [][]byte `protobuf:"bytes,2,rep,name=split_keys,json=splitKeys,proto3" json:"split_keys,omitempty"` - RetryLimit uint64 `protobuf:"varint,3,opt,name=retry_limit,json=retryLimit,proto3" json:"retry_limit,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` +func (m *UpdateServiceSafePointV2Response) GetMinSafePoint() uint64 { + if m != nil { + return m.MinSafePoint + } + return 0 } -func (m *SplitRegionsRequest) Reset() { *m = SplitRegionsRequest{} } -func (m *SplitRegionsRequest) String() string { return proto.CompactTextString(m) } -func (*SplitRegionsRequest) ProtoMessage() {} -func (*SplitRegionsRequest) Descriptor() ([]byte, []int) { +type RegionStat struct { + // Bytes read/written during this period. + BytesWritten uint64 `protobuf:"varint,1,opt,name=bytes_written,json=bytesWritten,proto3" json:"bytes_written,omitempty"` + BytesRead uint64 `protobuf:"varint,2,opt,name=bytes_read,json=bytesRead,proto3" json:"bytes_read,omitempty"` + // Keys read/written during this period. + KeysWritten uint64 `protobuf:"varint,3,opt,name=keys_written,json=keysWritten,proto3" json:"keys_written,omitempty"` + KeysRead uint64 `protobuf:"varint,4,opt,name=keys_read,json=keysRead,proto3" json:"keys_read,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RegionStat) Reset() { *m = RegionStat{} } +func (m *RegionStat) String() string { return proto.CompactTextString(m) } +func (*RegionStat) ProtoMessage() {} +func (*RegionStat) Descriptor() ([]byte, []int) { return fileDescriptor_78b27e6f04f44c6e, []int{92} } -func (m *SplitRegionsRequest) XXX_Unmarshal(b []byte) error { +func (m *RegionStat) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *SplitRegionsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *RegionStat) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_SplitRegionsRequest.Marshal(b, m, deterministic) + return xxx_messageInfo_RegionStat.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -6343,60 +6312,69 @@ func (m *SplitRegionsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, return b[:n], nil } } -func (m *SplitRegionsRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_SplitRegionsRequest.Merge(m, src) +func (m *RegionStat) XXX_Merge(src proto.Message) { + xxx_messageInfo_RegionStat.Merge(m, src) } -func (m *SplitRegionsRequest) XXX_Size() int { +func (m *RegionStat) XXX_Size() int { return m.Size() } -func (m *SplitRegionsRequest) XXX_DiscardUnknown() { - xxx_messageInfo_SplitRegionsRequest.DiscardUnknown(m) +func (m *RegionStat) XXX_DiscardUnknown() { + xxx_messageInfo_RegionStat.DiscardUnknown(m) } -var xxx_messageInfo_SplitRegionsRequest proto.InternalMessageInfo +var xxx_messageInfo_RegionStat proto.InternalMessageInfo -func (m *SplitRegionsRequest) GetHeader() *RequestHeader { +func (m *RegionStat) GetBytesWritten() uint64 { if m != nil { - return m.Header + return m.BytesWritten } - return nil + return 0 } -func (m *SplitRegionsRequest) GetSplitKeys() [][]byte { +func (m *RegionStat) GetBytesRead() uint64 { if m != nil { - return m.SplitKeys + return m.BytesRead } - return nil + return 0 } -func (m *SplitRegionsRequest) GetRetryLimit() uint64 { +func (m *RegionStat) GetKeysWritten() uint64 { if m != nil { - return m.RetryLimit + return m.KeysWritten } return 0 } -type SplitRegionsResponse struct { - Header *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"` - FinishedPercentage uint64 `protobuf:"varint,2,opt,name=finished_percentage,json=finishedPercentage,proto3" json:"finished_percentage,omitempty"` - RegionsId []uint64 `protobuf:"varint,3,rep,packed,name=regions_id,json=regionsId,proto3" json:"regions_id,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` +func (m *RegionStat) GetKeysRead() uint64 { + if m != nil { + return m.KeysRead + } + return 0 } -func (m *SplitRegionsResponse) Reset() { *m = SplitRegionsResponse{} } -func (m *SplitRegionsResponse) String() string { return proto.CompactTextString(m) } -func (*SplitRegionsResponse) ProtoMessage() {} -func (*SplitRegionsResponse) Descriptor() ([]byte, []int) { +type SyncRegionRequest struct { + Header *RequestHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"` + Member *Member `protobuf:"bytes,2,opt,name=member,proto3" json:"member,omitempty"` + // the follower PD will use the start index to locate historical changes + // that require synchronization. + StartIndex uint64 `protobuf:"varint,3,opt,name=start_index,json=startIndex,proto3" json:"start_index,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *SyncRegionRequest) Reset() { *m = SyncRegionRequest{} } +func (m *SyncRegionRequest) String() string { return proto.CompactTextString(m) } +func (*SyncRegionRequest) ProtoMessage() {} +func (*SyncRegionRequest) Descriptor() ([]byte, []int) { return fileDescriptor_78b27e6f04f44c6e, []int{93} } -func (m *SplitRegionsResponse) XXX_Unmarshal(b []byte) error { +func (m *SyncRegionRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *SplitRegionsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *SyncRegionRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_SplitRegionsResponse.Marshal(b, m, deterministic) + return xxx_messageInfo_SyncRegionRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -6406,61 +6384,58 @@ func (m *SplitRegionsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte return b[:n], nil } } -func (m *SplitRegionsResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_SplitRegionsResponse.Merge(m, src) +func (m *SyncRegionRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_SyncRegionRequest.Merge(m, src) } -func (m *SplitRegionsResponse) XXX_Size() int { +func (m *SyncRegionRequest) XXX_Size() int { return m.Size() } -func (m *SplitRegionsResponse) XXX_DiscardUnknown() { - xxx_messageInfo_SplitRegionsResponse.DiscardUnknown(m) +func (m *SyncRegionRequest) XXX_DiscardUnknown() { + xxx_messageInfo_SyncRegionRequest.DiscardUnknown(m) } -var xxx_messageInfo_SplitRegionsResponse proto.InternalMessageInfo +var xxx_messageInfo_SyncRegionRequest proto.InternalMessageInfo -func (m *SplitRegionsResponse) GetHeader() *ResponseHeader { +func (m *SyncRegionRequest) GetHeader() *RequestHeader { if m != nil { return m.Header } return nil } -func (m *SplitRegionsResponse) GetFinishedPercentage() uint64 { +func (m *SyncRegionRequest) GetMember() *Member { if m != nil { - return m.FinishedPercentage + return m.Member } - return 0 + return nil } -func (m *SplitRegionsResponse) GetRegionsId() []uint64 { +func (m *SyncRegionRequest) GetStartIndex() uint64 { if m != nil { - return m.RegionsId + return m.StartIndex } - return nil + return 0 } -type SplitAndScatterRegionsRequest struct { - Header *RequestHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"` - SplitKeys [][]byte `protobuf:"bytes,2,rep,name=split_keys,json=splitKeys,proto3" json:"split_keys,omitempty"` - Group string `protobuf:"bytes,3,opt,name=group,proto3" json:"group,omitempty"` - RetryLimit uint64 `protobuf:"varint,4,opt,name=retry_limit,json=retryLimit,proto3" json:"retry_limit,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` +type PeersStats struct { + Peers []*PeerStats `protobuf:"bytes,1,rep,name=peers,proto3" json:"peers,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } -func (m *SplitAndScatterRegionsRequest) Reset() { *m = SplitAndScatterRegionsRequest{} } -func (m *SplitAndScatterRegionsRequest) String() string { return proto.CompactTextString(m) } -func (*SplitAndScatterRegionsRequest) ProtoMessage() {} -func (*SplitAndScatterRegionsRequest) Descriptor() ([]byte, []int) { +func (m *PeersStats) Reset() { *m = PeersStats{} } +func (m *PeersStats) String() string { return proto.CompactTextString(m) } +func (*PeersStats) ProtoMessage() {} +func (*PeersStats) Descriptor() ([]byte, []int) { return fileDescriptor_78b27e6f04f44c6e, []int{94} } -func (m *SplitAndScatterRegionsRequest) XXX_Unmarshal(b []byte) error { +func (m *PeersStats) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *SplitAndScatterRegionsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *PeersStats) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_SplitAndScatterRegionsRequest.Marshal(b, m, deterministic) + return xxx_messageInfo_PeersStats.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -6470,68 +6445,101 @@ func (m *SplitAndScatterRegionsRequest) XXX_Marshal(b []byte, deterministic bool return b[:n], nil } } -func (m *SplitAndScatterRegionsRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_SplitAndScatterRegionsRequest.Merge(m, src) +func (m *PeersStats) XXX_Merge(src proto.Message) { + xxx_messageInfo_PeersStats.Merge(m, src) } -func (m *SplitAndScatterRegionsRequest) XXX_Size() int { +func (m *PeersStats) XXX_Size() int { return m.Size() } -func (m *SplitAndScatterRegionsRequest) XXX_DiscardUnknown() { - xxx_messageInfo_SplitAndScatterRegionsRequest.DiscardUnknown(m) +func (m *PeersStats) XXX_DiscardUnknown() { + xxx_messageInfo_PeersStats.DiscardUnknown(m) } -var xxx_messageInfo_SplitAndScatterRegionsRequest proto.InternalMessageInfo +var xxx_messageInfo_PeersStats proto.InternalMessageInfo -func (m *SplitAndScatterRegionsRequest) GetHeader() *RequestHeader { +func (m *PeersStats) GetPeers() []*PeerStats { if m != nil { - return m.Header + return m.Peers } return nil } -func (m *SplitAndScatterRegionsRequest) GetSplitKeys() [][]byte { - if m != nil { - return m.SplitKeys - } - return nil +type Peers struct { + Peers []*metapb.Peer `protobuf:"bytes,1,rep,name=peers,proto3" json:"peers,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } -func (m *SplitAndScatterRegionsRequest) GetGroup() string { - if m != nil { - return m.Group +func (m *Peers) Reset() { *m = Peers{} } +func (m *Peers) String() string { return proto.CompactTextString(m) } +func (*Peers) ProtoMessage() {} +func (*Peers) Descriptor() ([]byte, []int) { + return fileDescriptor_78b27e6f04f44c6e, []int{95} +} +func (m *Peers) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Peers) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Peers.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - return "" +} +func (m *Peers) XXX_Merge(src proto.Message) { + xxx_messageInfo_Peers.Merge(m, src) +} +func (m *Peers) XXX_Size() int { + return m.Size() +} +func (m *Peers) XXX_DiscardUnknown() { + xxx_messageInfo_Peers.DiscardUnknown(m) } -func (m *SplitAndScatterRegionsRequest) GetRetryLimit() uint64 { +var xxx_messageInfo_Peers proto.InternalMessageInfo + +func (m *Peers) GetPeers() []*metapb.Peer { if m != nil { - return m.RetryLimit + return m.Peers } - return 0 + return nil } -type SplitAndScatterRegionsResponse struct { - Header *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"` - SplitFinishedPercentage uint64 `protobuf:"varint,2,opt,name=split_finished_percentage,json=splitFinishedPercentage,proto3" json:"split_finished_percentage,omitempty"` - ScatterFinishedPercentage uint64 `protobuf:"varint,3,opt,name=scatter_finished_percentage,json=scatterFinishedPercentage,proto3" json:"scatter_finished_percentage,omitempty"` - RegionsId []uint64 `protobuf:"varint,4,rep,packed,name=regions_id,json=regionsId,proto3" json:"regions_id,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` +type SyncRegionResponse struct { + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"` + // the leader PD will send the repsonds include + // changed regions records and the index of the first record. + Regions []*metapb.Region `protobuf:"bytes,2,rep,name=regions,proto3" json:"regions,omitempty"` + StartIndex uint64 `protobuf:"varint,3,opt,name=start_index,json=startIndex,proto3" json:"start_index,omitempty"` + RegionStats []*RegionStat `protobuf:"bytes,4,rep,name=region_stats,json=regionStats,proto3" json:"region_stats,omitempty"` + RegionLeaders []*metapb.Peer `protobuf:"bytes,5,rep,name=region_leaders,json=regionLeaders,proto3" json:"region_leaders,omitempty"` + // the buckets informations without stats. + Buckets []*metapb.Buckets `protobuf:"bytes,6,rep,name=buckets,proto3" json:"buckets,omitempty"` + DownPeers []*PeersStats `protobuf:"bytes,16,rep,name=down_peers,json=downPeers,proto3" json:"down_peers,omitempty"` + PendingPeers []*Peers `protobuf:"bytes,17,rep,name=pending_peers,json=pendingPeers,proto3" json:"pending_peers,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } -func (m *SplitAndScatterRegionsResponse) Reset() { *m = SplitAndScatterRegionsResponse{} } -func (m *SplitAndScatterRegionsResponse) String() string { return proto.CompactTextString(m) } -func (*SplitAndScatterRegionsResponse) ProtoMessage() {} -func (*SplitAndScatterRegionsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_78b27e6f04f44c6e, []int{95} +func (m *SyncRegionResponse) Reset() { *m = SyncRegionResponse{} } +func (m *SyncRegionResponse) String() string { return proto.CompactTextString(m) } +func (*SyncRegionResponse) ProtoMessage() {} +func (*SyncRegionResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_78b27e6f04f44c6e, []int{96} } -func (m *SplitAndScatterRegionsResponse) XXX_Unmarshal(b []byte) error { +func (m *SyncRegionResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *SplitAndScatterRegionsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *SyncRegionResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_SplitAndScatterRegionsResponse.Marshal(b, m, deterministic) + return xxx_messageInfo_SyncRegionResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -6541,66 +6549,94 @@ func (m *SplitAndScatterRegionsResponse) XXX_Marshal(b []byte, deterministic boo return b[:n], nil } } -func (m *SplitAndScatterRegionsResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_SplitAndScatterRegionsResponse.Merge(m, src) +func (m *SyncRegionResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_SyncRegionResponse.Merge(m, src) } -func (m *SplitAndScatterRegionsResponse) XXX_Size() int { +func (m *SyncRegionResponse) XXX_Size() int { return m.Size() } -func (m *SplitAndScatterRegionsResponse) XXX_DiscardUnknown() { - xxx_messageInfo_SplitAndScatterRegionsResponse.DiscardUnknown(m) +func (m *SyncRegionResponse) XXX_DiscardUnknown() { + xxx_messageInfo_SyncRegionResponse.DiscardUnknown(m) } -var xxx_messageInfo_SplitAndScatterRegionsResponse proto.InternalMessageInfo +var xxx_messageInfo_SyncRegionResponse proto.InternalMessageInfo -func (m *SplitAndScatterRegionsResponse) GetHeader() *ResponseHeader { +func (m *SyncRegionResponse) GetHeader() *ResponseHeader { if m != nil { return m.Header } return nil } -func (m *SplitAndScatterRegionsResponse) GetSplitFinishedPercentage() uint64 { +func (m *SyncRegionResponse) GetRegions() []*metapb.Region { if m != nil { - return m.SplitFinishedPercentage + return m.Regions } - return 0 + return nil } -func (m *SplitAndScatterRegionsResponse) GetScatterFinishedPercentage() uint64 { +func (m *SyncRegionResponse) GetStartIndex() uint64 { if m != nil { - return m.ScatterFinishedPercentage + return m.StartIndex } return 0 } -func (m *SplitAndScatterRegionsResponse) GetRegionsId() []uint64 { +func (m *SyncRegionResponse) GetRegionStats() []*RegionStat { if m != nil { - return m.RegionsId + return m.RegionStats } return nil } -type GetDCLocationInfoRequest struct { +func (m *SyncRegionResponse) GetRegionLeaders() []*metapb.Peer { + if m != nil { + return m.RegionLeaders + } + return nil +} + +func (m *SyncRegionResponse) GetBuckets() []*metapb.Buckets { + if m != nil { + return m.Buckets + } + return nil +} + +func (m *SyncRegionResponse) GetDownPeers() []*PeersStats { + if m != nil { + return m.DownPeers + } + return nil +} + +func (m *SyncRegionResponse) GetPendingPeers() []*Peers { + if m != nil { + return m.PendingPeers + } + return nil +} + +type GetOperatorRequest struct { Header *RequestHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"` - DcLocation string `protobuf:"bytes,2,opt,name=dc_location,json=dcLocation,proto3" json:"dc_location,omitempty"` + RegionId uint64 `protobuf:"varint,2,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } -func (m *GetDCLocationInfoRequest) Reset() { *m = GetDCLocationInfoRequest{} } -func (m *GetDCLocationInfoRequest) String() string { return proto.CompactTextString(m) } -func (*GetDCLocationInfoRequest) ProtoMessage() {} -func (*GetDCLocationInfoRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_78b27e6f04f44c6e, []int{96} +func (m *GetOperatorRequest) Reset() { *m = GetOperatorRequest{} } +func (m *GetOperatorRequest) String() string { return proto.CompactTextString(m) } +func (*GetOperatorRequest) ProtoMessage() {} +func (*GetOperatorRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_78b27e6f04f44c6e, []int{97} } -func (m *GetDCLocationInfoRequest) XXX_Unmarshal(b []byte) error { +func (m *GetOperatorRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *GetDCLocationInfoRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *GetOperatorRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_GetDCLocationInfoRequest.Marshal(b, m, deterministic) + return xxx_messageInfo_GetOperatorRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -6610,56 +6646,55 @@ func (m *GetDCLocationInfoRequest) XXX_Marshal(b []byte, deterministic bool) ([] return b[:n], nil } } -func (m *GetDCLocationInfoRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetDCLocationInfoRequest.Merge(m, src) +func (m *GetOperatorRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetOperatorRequest.Merge(m, src) } -func (m *GetDCLocationInfoRequest) XXX_Size() int { +func (m *GetOperatorRequest) XXX_Size() int { return m.Size() } -func (m *GetDCLocationInfoRequest) XXX_DiscardUnknown() { - xxx_messageInfo_GetDCLocationInfoRequest.DiscardUnknown(m) +func (m *GetOperatorRequest) XXX_DiscardUnknown() { + xxx_messageInfo_GetOperatorRequest.DiscardUnknown(m) } -var xxx_messageInfo_GetDCLocationInfoRequest proto.InternalMessageInfo +var xxx_messageInfo_GetOperatorRequest proto.InternalMessageInfo -func (m *GetDCLocationInfoRequest) GetHeader() *RequestHeader { +func (m *GetOperatorRequest) GetHeader() *RequestHeader { if m != nil { return m.Header } return nil } -func (m *GetDCLocationInfoRequest) GetDcLocation() string { +func (m *GetOperatorRequest) GetRegionId() uint64 { if m != nil { - return m.DcLocation + return m.RegionId } - return "" + return 0 } -type GetDCLocationInfoResponse struct { - Header *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"` - // suffix sign - Suffix int32 `protobuf:"varint,2,opt,name=suffix,proto3" json:"suffix,omitempty"` - // max_ts will be included into this response if PD leader think the receiver needs, - // which it's set when the number of the max suffix bits changes. - MaxTs *Timestamp `protobuf:"bytes,3,opt,name=max_ts,json=maxTs,proto3" json:"max_ts,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` +type GetOperatorResponse struct { + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"` + RegionId uint64 `protobuf:"varint,2,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty"` + Desc []byte `protobuf:"bytes,3,opt,name=desc,proto3" json:"desc,omitempty"` + Status OperatorStatus `protobuf:"varint,4,opt,name=status,proto3,enum=pdpb.OperatorStatus" json:"status,omitempty"` + Kind []byte `protobuf:"bytes,5,opt,name=kind,proto3" json:"kind,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } -func (m *GetDCLocationInfoResponse) Reset() { *m = GetDCLocationInfoResponse{} } -func (m *GetDCLocationInfoResponse) String() string { return proto.CompactTextString(m) } -func (*GetDCLocationInfoResponse) ProtoMessage() {} -func (*GetDCLocationInfoResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_78b27e6f04f44c6e, []int{97} +func (m *GetOperatorResponse) Reset() { *m = GetOperatorResponse{} } +func (m *GetOperatorResponse) String() string { return proto.CompactTextString(m) } +func (*GetOperatorResponse) ProtoMessage() {} +func (*GetOperatorResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_78b27e6f04f44c6e, []int{98} } -func (m *GetDCLocationInfoResponse) XXX_Unmarshal(b []byte) error { +func (m *GetOperatorResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *GetDCLocationInfoResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *GetOperatorResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_GetDCLocationInfoResponse.Marshal(b, m, deterministic) + return xxx_messageInfo_GetOperatorResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -6669,68 +6704,75 @@ func (m *GetDCLocationInfoResponse) XXX_Marshal(b []byte, deterministic bool) ([ return b[:n], nil } } -func (m *GetDCLocationInfoResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetDCLocationInfoResponse.Merge(m, src) +func (m *GetOperatorResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetOperatorResponse.Merge(m, src) } -func (m *GetDCLocationInfoResponse) XXX_Size() int { +func (m *GetOperatorResponse) XXX_Size() int { return m.Size() } -func (m *GetDCLocationInfoResponse) XXX_DiscardUnknown() { - xxx_messageInfo_GetDCLocationInfoResponse.DiscardUnknown(m) +func (m *GetOperatorResponse) XXX_DiscardUnknown() { + xxx_messageInfo_GetOperatorResponse.DiscardUnknown(m) } -var xxx_messageInfo_GetDCLocationInfoResponse proto.InternalMessageInfo +var xxx_messageInfo_GetOperatorResponse proto.InternalMessageInfo -func (m *GetDCLocationInfoResponse) GetHeader() *ResponseHeader { +func (m *GetOperatorResponse) GetHeader() *ResponseHeader { if m != nil { return m.Header } return nil } -func (m *GetDCLocationInfoResponse) GetSuffix() int32 { +func (m *GetOperatorResponse) GetRegionId() uint64 { if m != nil { - return m.Suffix + return m.RegionId } return 0 } -func (m *GetDCLocationInfoResponse) GetMaxTs() *Timestamp { +func (m *GetOperatorResponse) GetDesc() []byte { if m != nil { - return m.MaxTs + return m.Desc } return nil } -type QueryStats struct { - GC uint64 `protobuf:"varint,1,opt,name=GC,proto3" json:"GC,omitempty"` - Get uint64 `protobuf:"varint,2,opt,name=Get,proto3" json:"Get,omitempty"` - Scan uint64 `protobuf:"varint,3,opt,name=Scan,proto3" json:"Scan,omitempty"` - Coprocessor uint64 `protobuf:"varint,4,opt,name=Coprocessor,proto3" json:"Coprocessor,omitempty"` - Delete uint64 `protobuf:"varint,5,opt,name=Delete,proto3" json:"Delete,omitempty"` - DeleteRange uint64 `protobuf:"varint,6,opt,name=DeleteRange,proto3" json:"DeleteRange,omitempty"` - Put uint64 `protobuf:"varint,7,opt,name=Put,proto3" json:"Put,omitempty"` - Prewrite uint64 `protobuf:"varint,8,opt,name=Prewrite,proto3" json:"Prewrite,omitempty"` - AcquirePessimisticLock uint64 `protobuf:"varint,9,opt,name=AcquirePessimisticLock,proto3" json:"AcquirePessimisticLock,omitempty"` - Commit uint64 `protobuf:"varint,10,opt,name=Commit,proto3" json:"Commit,omitempty"` - Rollback uint64 `protobuf:"varint,11,opt,name=Rollback,proto3" json:"Rollback,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` +func (m *GetOperatorResponse) GetStatus() OperatorStatus { + if m != nil { + return m.Status + } + return OperatorStatus_SUCCESS } -func (m *QueryStats) Reset() { *m = QueryStats{} } -func (m *QueryStats) String() string { return proto.CompactTextString(m) } -func (*QueryStats) ProtoMessage() {} -func (*QueryStats) Descriptor() ([]byte, []int) { - return fileDescriptor_78b27e6f04f44c6e, []int{98} +func (m *GetOperatorResponse) GetKind() []byte { + if m != nil { + return m.Kind + } + return nil } -func (m *QueryStats) XXX_Unmarshal(b []byte) error { + +type SyncMaxTSRequest struct { + Header *RequestHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"` + MaxTs *Timestamp `protobuf:"bytes,2,opt,name=max_ts,json=maxTs,proto3" json:"max_ts,omitempty"` + // If skip_check is true, the sync will try to write the max_ts without checking whether it's bigger. + SkipCheck bool `protobuf:"varint,3,opt,name=skip_check,json=skipCheck,proto3" json:"skip_check,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *SyncMaxTSRequest) Reset() { *m = SyncMaxTSRequest{} } +func (m *SyncMaxTSRequest) String() string { return proto.CompactTextString(m) } +func (*SyncMaxTSRequest) ProtoMessage() {} +func (*SyncMaxTSRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_78b27e6f04f44c6e, []int{99} +} +func (m *SyncMaxTSRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *QueryStats) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *SyncMaxTSRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_QueryStats.Marshal(b, m, deterministic) + return xxx_messageInfo_SyncMaxTSRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -6740,116 +6782,123 @@ func (m *QueryStats) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { return b[:n], nil } } -func (m *QueryStats) XXX_Merge(src proto.Message) { - xxx_messageInfo_QueryStats.Merge(m, src) +func (m *SyncMaxTSRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_SyncMaxTSRequest.Merge(m, src) } -func (m *QueryStats) XXX_Size() int { +func (m *SyncMaxTSRequest) XXX_Size() int { return m.Size() } -func (m *QueryStats) XXX_DiscardUnknown() { - xxx_messageInfo_QueryStats.DiscardUnknown(m) +func (m *SyncMaxTSRequest) XXX_DiscardUnknown() { + xxx_messageInfo_SyncMaxTSRequest.DiscardUnknown(m) } -var xxx_messageInfo_QueryStats proto.InternalMessageInfo +var xxx_messageInfo_SyncMaxTSRequest proto.InternalMessageInfo -func (m *QueryStats) GetGC() uint64 { +func (m *SyncMaxTSRequest) GetHeader() *RequestHeader { if m != nil { - return m.GC + return m.Header } - return 0 + return nil } -func (m *QueryStats) GetGet() uint64 { +func (m *SyncMaxTSRequest) GetMaxTs() *Timestamp { if m != nil { - return m.Get + return m.MaxTs } - return 0 + return nil } -func (m *QueryStats) GetScan() uint64 { +func (m *SyncMaxTSRequest) GetSkipCheck() bool { if m != nil { - return m.Scan + return m.SkipCheck } - return 0 + return false } -func (m *QueryStats) GetCoprocessor() uint64 { - if m != nil { - return m.Coprocessor - } - return 0 +type SyncMaxTSResponse struct { + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"` + MaxLocalTs *Timestamp `protobuf:"bytes,2,opt,name=max_local_ts,json=maxLocalTs,proto3" json:"max_local_ts,omitempty"` + SyncedDcs []string `protobuf:"bytes,3,rep,name=synced_dcs,json=syncedDcs,proto3" json:"synced_dcs,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } -func (m *QueryStats) GetDelete() uint64 { - if m != nil { - return m.Delete - } - return 0 +func (m *SyncMaxTSResponse) Reset() { *m = SyncMaxTSResponse{} } +func (m *SyncMaxTSResponse) String() string { return proto.CompactTextString(m) } +func (*SyncMaxTSResponse) ProtoMessage() {} +func (*SyncMaxTSResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_78b27e6f04f44c6e, []int{100} } - -func (m *QueryStats) GetDeleteRange() uint64 { - if m != nil { - return m.DeleteRange - } - return 0 +func (m *SyncMaxTSResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) } - -func (m *QueryStats) GetPut() uint64 { - if m != nil { - return m.Put +func (m *SyncMaxTSResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_SyncMaxTSResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - return 0 } - -func (m *QueryStats) GetPrewrite() uint64 { - if m != nil { - return m.Prewrite - } - return 0 +func (m *SyncMaxTSResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_SyncMaxTSResponse.Merge(m, src) +} +func (m *SyncMaxTSResponse) XXX_Size() int { + return m.Size() +} +func (m *SyncMaxTSResponse) XXX_DiscardUnknown() { + xxx_messageInfo_SyncMaxTSResponse.DiscardUnknown(m) } -func (m *QueryStats) GetAcquirePessimisticLock() uint64 { +var xxx_messageInfo_SyncMaxTSResponse proto.InternalMessageInfo + +func (m *SyncMaxTSResponse) GetHeader() *ResponseHeader { if m != nil { - return m.AcquirePessimisticLock + return m.Header } - return 0 + return nil } -func (m *QueryStats) GetCommit() uint64 { +func (m *SyncMaxTSResponse) GetMaxLocalTs() *Timestamp { if m != nil { - return m.Commit + return m.MaxLocalTs } - return 0 + return nil } -func (m *QueryStats) GetRollback() uint64 { +func (m *SyncMaxTSResponse) GetSyncedDcs() []string { if m != nil { - return m.Rollback + return m.SyncedDcs } - return 0 + return nil } -type ReportBucketsRequest struct { - Header *RequestHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"` - RegionEpoch *metapb.RegionEpoch `protobuf:"bytes,2,opt,name=region_epoch,json=regionEpoch,proto3" json:"region_epoch,omitempty"` - Buckets *metapb.Buckets `protobuf:"bytes,3,opt,name=buckets,proto3" json:"buckets,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` +type SplitRegionsRequest struct { + Header *RequestHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"` + SplitKeys [][]byte `protobuf:"bytes,2,rep,name=split_keys,json=splitKeys,proto3" json:"split_keys,omitempty"` + RetryLimit uint64 `protobuf:"varint,3,opt,name=retry_limit,json=retryLimit,proto3" json:"retry_limit,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } -func (m *ReportBucketsRequest) Reset() { *m = ReportBucketsRequest{} } -func (m *ReportBucketsRequest) String() string { return proto.CompactTextString(m) } -func (*ReportBucketsRequest) ProtoMessage() {} -func (*ReportBucketsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_78b27e6f04f44c6e, []int{99} +func (m *SplitRegionsRequest) Reset() { *m = SplitRegionsRequest{} } +func (m *SplitRegionsRequest) String() string { return proto.CompactTextString(m) } +func (*SplitRegionsRequest) ProtoMessage() {} +func (*SplitRegionsRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_78b27e6f04f44c6e, []int{101} } -func (m *ReportBucketsRequest) XXX_Unmarshal(b []byte) error { +func (m *SplitRegionsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *ReportBucketsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *SplitRegionsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_ReportBucketsRequest.Marshal(b, m, deterministic) + return xxx_messageInfo_SplitRegionsRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -6859,58 +6908,60 @@ func (m *ReportBucketsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte return b[:n], nil } } -func (m *ReportBucketsRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_ReportBucketsRequest.Merge(m, src) +func (m *SplitRegionsRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_SplitRegionsRequest.Merge(m, src) } -func (m *ReportBucketsRequest) XXX_Size() int { +func (m *SplitRegionsRequest) XXX_Size() int { return m.Size() } -func (m *ReportBucketsRequest) XXX_DiscardUnknown() { - xxx_messageInfo_ReportBucketsRequest.DiscardUnknown(m) +func (m *SplitRegionsRequest) XXX_DiscardUnknown() { + xxx_messageInfo_SplitRegionsRequest.DiscardUnknown(m) } -var xxx_messageInfo_ReportBucketsRequest proto.InternalMessageInfo +var xxx_messageInfo_SplitRegionsRequest proto.InternalMessageInfo -func (m *ReportBucketsRequest) GetHeader() *RequestHeader { +func (m *SplitRegionsRequest) GetHeader() *RequestHeader { if m != nil { return m.Header } return nil } -func (m *ReportBucketsRequest) GetRegionEpoch() *metapb.RegionEpoch { +func (m *SplitRegionsRequest) GetSplitKeys() [][]byte { if m != nil { - return m.RegionEpoch + return m.SplitKeys } return nil } -func (m *ReportBucketsRequest) GetBuckets() *metapb.Buckets { +func (m *SplitRegionsRequest) GetRetryLimit() uint64 { if m != nil { - return m.Buckets + return m.RetryLimit } - return nil + return 0 } -type ReportBucketsResponse struct { +type SplitRegionsResponse struct { Header *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"` + FinishedPercentage uint64 `protobuf:"varint,2,opt,name=finished_percentage,json=finishedPercentage,proto3" json:"finished_percentage,omitempty"` + RegionsId []uint64 `protobuf:"varint,3,rep,packed,name=regions_id,json=regionsId,proto3" json:"regions_id,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } -func (m *ReportBucketsResponse) Reset() { *m = ReportBucketsResponse{} } -func (m *ReportBucketsResponse) String() string { return proto.CompactTextString(m) } -func (*ReportBucketsResponse) ProtoMessage() {} -func (*ReportBucketsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_78b27e6f04f44c6e, []int{100} +func (m *SplitRegionsResponse) Reset() { *m = SplitRegionsResponse{} } +func (m *SplitRegionsResponse) String() string { return proto.CompactTextString(m) } +func (*SplitRegionsResponse) ProtoMessage() {} +func (*SplitRegionsResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_78b27e6f04f44c6e, []int{102} } -func (m *ReportBucketsResponse) XXX_Unmarshal(b []byte) error { +func (m *SplitRegionsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *ReportBucketsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *SplitRegionsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_ReportBucketsResponse.Marshal(b, m, deterministic) + return xxx_messageInfo_SplitRegionsResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -6920,46 +6971,61 @@ func (m *ReportBucketsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byt return b[:n], nil } } -func (m *ReportBucketsResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_ReportBucketsResponse.Merge(m, src) +func (m *SplitRegionsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_SplitRegionsResponse.Merge(m, src) } -func (m *ReportBucketsResponse) XXX_Size() int { +func (m *SplitRegionsResponse) XXX_Size() int { return m.Size() } -func (m *ReportBucketsResponse) XXX_DiscardUnknown() { - xxx_messageInfo_ReportBucketsResponse.DiscardUnknown(m) +func (m *SplitRegionsResponse) XXX_DiscardUnknown() { + xxx_messageInfo_SplitRegionsResponse.DiscardUnknown(m) } -var xxx_messageInfo_ReportBucketsResponse proto.InternalMessageInfo +var xxx_messageInfo_SplitRegionsResponse proto.InternalMessageInfo -func (m *ReportBucketsResponse) GetHeader() *ResponseHeader { +func (m *SplitRegionsResponse) GetHeader() *ResponseHeader { if m != nil { return m.Header } return nil } -type ReportMinResolvedTsRequest struct { - Header *RequestHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"` - StoreId uint64 `protobuf:"varint,2,opt,name=store_id,json=storeId,proto3" json:"store_id,omitempty"` - MinResolvedTs uint64 `protobuf:"varint,3,opt,name=min_resolved_ts,json=minResolvedTs,proto3" json:"min_resolved_ts,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *ReportMinResolvedTsRequest) Reset() { *m = ReportMinResolvedTsRequest{} } -func (m *ReportMinResolvedTsRequest) String() string { return proto.CompactTextString(m) } -func (*ReportMinResolvedTsRequest) ProtoMessage() {} -func (*ReportMinResolvedTsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_78b27e6f04f44c6e, []int{101} +func (m *SplitRegionsResponse) GetFinishedPercentage() uint64 { + if m != nil { + return m.FinishedPercentage + } + return 0 } -func (m *ReportMinResolvedTsRequest) XXX_Unmarshal(b []byte) error { + +func (m *SplitRegionsResponse) GetRegionsId() []uint64 { + if m != nil { + return m.RegionsId + } + return nil +} + +type SplitAndScatterRegionsRequest struct { + Header *RequestHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"` + SplitKeys [][]byte `protobuf:"bytes,2,rep,name=split_keys,json=splitKeys,proto3" json:"split_keys,omitempty"` + Group string `protobuf:"bytes,3,opt,name=group,proto3" json:"group,omitempty"` + RetryLimit uint64 `protobuf:"varint,4,opt,name=retry_limit,json=retryLimit,proto3" json:"retry_limit,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *SplitAndScatterRegionsRequest) Reset() { *m = SplitAndScatterRegionsRequest{} } +func (m *SplitAndScatterRegionsRequest) String() string { return proto.CompactTextString(m) } +func (*SplitAndScatterRegionsRequest) ProtoMessage() {} +func (*SplitAndScatterRegionsRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_78b27e6f04f44c6e, []int{103} +} +func (m *SplitAndScatterRegionsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *ReportMinResolvedTsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *SplitAndScatterRegionsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_ReportMinResolvedTsRequest.Marshal(b, m, deterministic) + return xxx_messageInfo_SplitAndScatterRegionsRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -6969,58 +7035,68 @@ func (m *ReportMinResolvedTsRequest) XXX_Marshal(b []byte, deterministic bool) ( return b[:n], nil } } -func (m *ReportMinResolvedTsRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_ReportMinResolvedTsRequest.Merge(m, src) +func (m *SplitAndScatterRegionsRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_SplitAndScatterRegionsRequest.Merge(m, src) } -func (m *ReportMinResolvedTsRequest) XXX_Size() int { +func (m *SplitAndScatterRegionsRequest) XXX_Size() int { return m.Size() } -func (m *ReportMinResolvedTsRequest) XXX_DiscardUnknown() { - xxx_messageInfo_ReportMinResolvedTsRequest.DiscardUnknown(m) +func (m *SplitAndScatterRegionsRequest) XXX_DiscardUnknown() { + xxx_messageInfo_SplitAndScatterRegionsRequest.DiscardUnknown(m) } -var xxx_messageInfo_ReportMinResolvedTsRequest proto.InternalMessageInfo +var xxx_messageInfo_SplitAndScatterRegionsRequest proto.InternalMessageInfo -func (m *ReportMinResolvedTsRequest) GetHeader() *RequestHeader { +func (m *SplitAndScatterRegionsRequest) GetHeader() *RequestHeader { if m != nil { return m.Header } return nil } -func (m *ReportMinResolvedTsRequest) GetStoreId() uint64 { +func (m *SplitAndScatterRegionsRequest) GetSplitKeys() [][]byte { if m != nil { - return m.StoreId + return m.SplitKeys } - return 0 + return nil } -func (m *ReportMinResolvedTsRequest) GetMinResolvedTs() uint64 { +func (m *SplitAndScatterRegionsRequest) GetGroup() string { if m != nil { - return m.MinResolvedTs + return m.Group + } + return "" +} + +func (m *SplitAndScatterRegionsRequest) GetRetryLimit() uint64 { + if m != nil { + return m.RetryLimit } return 0 } -type ReportMinResolvedTsResponse struct { - Header *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` +type SplitAndScatterRegionsResponse struct { + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"` + SplitFinishedPercentage uint64 `protobuf:"varint,2,opt,name=split_finished_percentage,json=splitFinishedPercentage,proto3" json:"split_finished_percentage,omitempty"` + ScatterFinishedPercentage uint64 `protobuf:"varint,3,opt,name=scatter_finished_percentage,json=scatterFinishedPercentage,proto3" json:"scatter_finished_percentage,omitempty"` + RegionsId []uint64 `protobuf:"varint,4,rep,packed,name=regions_id,json=regionsId,proto3" json:"regions_id,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } -func (m *ReportMinResolvedTsResponse) Reset() { *m = ReportMinResolvedTsResponse{} } -func (m *ReportMinResolvedTsResponse) String() string { return proto.CompactTextString(m) } -func (*ReportMinResolvedTsResponse) ProtoMessage() {} -func (*ReportMinResolvedTsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_78b27e6f04f44c6e, []int{102} +func (m *SplitAndScatterRegionsResponse) Reset() { *m = SplitAndScatterRegionsResponse{} } +func (m *SplitAndScatterRegionsResponse) String() string { return proto.CompactTextString(m) } +func (*SplitAndScatterRegionsResponse) ProtoMessage() {} +func (*SplitAndScatterRegionsResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_78b27e6f04f44c6e, []int{104} } -func (m *ReportMinResolvedTsResponse) XXX_Unmarshal(b []byte) error { +func (m *SplitAndScatterRegionsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *ReportMinResolvedTsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *SplitAndScatterRegionsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_ReportMinResolvedTsResponse.Marshal(b, m, deterministic) + return xxx_messageInfo_SplitAndScatterRegionsResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -7030,45 +7106,66 @@ func (m *ReportMinResolvedTsResponse) XXX_Marshal(b []byte, deterministic bool) return b[:n], nil } } -func (m *ReportMinResolvedTsResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_ReportMinResolvedTsResponse.Merge(m, src) +func (m *SplitAndScatterRegionsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_SplitAndScatterRegionsResponse.Merge(m, src) } -func (m *ReportMinResolvedTsResponse) XXX_Size() int { +func (m *SplitAndScatterRegionsResponse) XXX_Size() int { return m.Size() } -func (m *ReportMinResolvedTsResponse) XXX_DiscardUnknown() { - xxx_messageInfo_ReportMinResolvedTsResponse.DiscardUnknown(m) +func (m *SplitAndScatterRegionsResponse) XXX_DiscardUnknown() { + xxx_messageInfo_SplitAndScatterRegionsResponse.DiscardUnknown(m) } -var xxx_messageInfo_ReportMinResolvedTsResponse proto.InternalMessageInfo +var xxx_messageInfo_SplitAndScatterRegionsResponse proto.InternalMessageInfo -func (m *ReportMinResolvedTsResponse) GetHeader() *ResponseHeader { +func (m *SplitAndScatterRegionsResponse) GetHeader() *ResponseHeader { if m != nil { return m.Header } return nil } -type SetExternalTimestampRequest struct { +func (m *SplitAndScatterRegionsResponse) GetSplitFinishedPercentage() uint64 { + if m != nil { + return m.SplitFinishedPercentage + } + return 0 +} + +func (m *SplitAndScatterRegionsResponse) GetScatterFinishedPercentage() uint64 { + if m != nil { + return m.ScatterFinishedPercentage + } + return 0 +} + +func (m *SplitAndScatterRegionsResponse) GetRegionsId() []uint64 { + if m != nil { + return m.RegionsId + } + return nil +} + +type GetDCLocationInfoRequest struct { Header *RequestHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"` - Timestamp uint64 `protobuf:"varint,2,opt,name=timestamp,proto3" json:"timestamp,omitempty"` + DcLocation string `protobuf:"bytes,2,opt,name=dc_location,json=dcLocation,proto3" json:"dc_location,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } -func (m *SetExternalTimestampRequest) Reset() { *m = SetExternalTimestampRequest{} } -func (m *SetExternalTimestampRequest) String() string { return proto.CompactTextString(m) } -func (*SetExternalTimestampRequest) ProtoMessage() {} -func (*SetExternalTimestampRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_78b27e6f04f44c6e, []int{103} +func (m *GetDCLocationInfoRequest) Reset() { *m = GetDCLocationInfoRequest{} } +func (m *GetDCLocationInfoRequest) String() string { return proto.CompactTextString(m) } +func (*GetDCLocationInfoRequest) ProtoMessage() {} +func (*GetDCLocationInfoRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_78b27e6f04f44c6e, []int{105} } -func (m *SetExternalTimestampRequest) XXX_Unmarshal(b []byte) error { +func (m *GetDCLocationInfoRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *SetExternalTimestampRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *GetDCLocationInfoRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_SetExternalTimestampRequest.Marshal(b, m, deterministic) + return xxx_messageInfo_GetDCLocationInfoRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -7078,51 +7175,56 @@ func (m *SetExternalTimestampRequest) XXX_Marshal(b []byte, deterministic bool) return b[:n], nil } } -func (m *SetExternalTimestampRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_SetExternalTimestampRequest.Merge(m, src) +func (m *GetDCLocationInfoRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetDCLocationInfoRequest.Merge(m, src) } -func (m *SetExternalTimestampRequest) XXX_Size() int { +func (m *GetDCLocationInfoRequest) XXX_Size() int { return m.Size() } -func (m *SetExternalTimestampRequest) XXX_DiscardUnknown() { - xxx_messageInfo_SetExternalTimestampRequest.DiscardUnknown(m) +func (m *GetDCLocationInfoRequest) XXX_DiscardUnknown() { + xxx_messageInfo_GetDCLocationInfoRequest.DiscardUnknown(m) } -var xxx_messageInfo_SetExternalTimestampRequest proto.InternalMessageInfo +var xxx_messageInfo_GetDCLocationInfoRequest proto.InternalMessageInfo -func (m *SetExternalTimestampRequest) GetHeader() *RequestHeader { +func (m *GetDCLocationInfoRequest) GetHeader() *RequestHeader { if m != nil { return m.Header } return nil } -func (m *SetExternalTimestampRequest) GetTimestamp() uint64 { +func (m *GetDCLocationInfoRequest) GetDcLocation() string { if m != nil { - return m.Timestamp + return m.DcLocation } - return 0 + return "" } -type SetExternalTimestampResponse struct { - Header *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` +type GetDCLocationInfoResponse struct { + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"` + // suffix sign + Suffix int32 `protobuf:"varint,2,opt,name=suffix,proto3" json:"suffix,omitempty"` + // max_ts will be included into this response if PD leader think the receiver needs, + // which it's set when the number of the max suffix bits changes. + MaxTs *Timestamp `protobuf:"bytes,3,opt,name=max_ts,json=maxTs,proto3" json:"max_ts,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } -func (m *SetExternalTimestampResponse) Reset() { *m = SetExternalTimestampResponse{} } -func (m *SetExternalTimestampResponse) String() string { return proto.CompactTextString(m) } -func (*SetExternalTimestampResponse) ProtoMessage() {} -func (*SetExternalTimestampResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_78b27e6f04f44c6e, []int{104} +func (m *GetDCLocationInfoResponse) Reset() { *m = GetDCLocationInfoResponse{} } +func (m *GetDCLocationInfoResponse) String() string { return proto.CompactTextString(m) } +func (*GetDCLocationInfoResponse) ProtoMessage() {} +func (*GetDCLocationInfoResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_78b27e6f04f44c6e, []int{106} } -func (m *SetExternalTimestampResponse) XXX_Unmarshal(b []byte) error { +func (m *GetDCLocationInfoResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *SetExternalTimestampResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *GetDCLocationInfoResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_SetExternalTimestampResponse.Marshal(b, m, deterministic) + return xxx_messageInfo_GetDCLocationInfoResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -7132,92 +7234,248 @@ func (m *SetExternalTimestampResponse) XXX_Marshal(b []byte, deterministic bool) return b[:n], nil } } -func (m *SetExternalTimestampResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_SetExternalTimestampResponse.Merge(m, src) +func (m *GetDCLocationInfoResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetDCLocationInfoResponse.Merge(m, src) } -func (m *SetExternalTimestampResponse) XXX_Size() int { +func (m *GetDCLocationInfoResponse) XXX_Size() int { return m.Size() } -func (m *SetExternalTimestampResponse) XXX_DiscardUnknown() { - xxx_messageInfo_SetExternalTimestampResponse.DiscardUnknown(m) +func (m *GetDCLocationInfoResponse) XXX_DiscardUnknown() { + xxx_messageInfo_GetDCLocationInfoResponse.DiscardUnknown(m) } -var xxx_messageInfo_SetExternalTimestampResponse proto.InternalMessageInfo +var xxx_messageInfo_GetDCLocationInfoResponse proto.InternalMessageInfo -func (m *SetExternalTimestampResponse) GetHeader() *ResponseHeader { +func (m *GetDCLocationInfoResponse) GetHeader() *ResponseHeader { if m != nil { return m.Header } return nil } -type GetExternalTimestampRequest struct { - Header *RequestHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` +func (m *GetDCLocationInfoResponse) GetSuffix() int32 { + if m != nil { + return m.Suffix + } + return 0 } -func (m *GetExternalTimestampRequest) Reset() { *m = GetExternalTimestampRequest{} } -func (m *GetExternalTimestampRequest) String() string { return proto.CompactTextString(m) } -func (*GetExternalTimestampRequest) ProtoMessage() {} -func (*GetExternalTimestampRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_78b27e6f04f44c6e, []int{105} -} -func (m *GetExternalTimestampRequest) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *GetExternalTimestampRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_GetExternalTimestampRequest.Marshal(b, m, deterministic) - } else { - b = b[:cap(b)] - n, err := m.MarshalToSizedBuffer(b) - if err != nil { - return nil, err - } - return b[:n], nil +func (m *GetDCLocationInfoResponse) GetMaxTs() *Timestamp { + if m != nil { + return m.MaxTs } + return nil } -func (m *GetExternalTimestampRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetExternalTimestampRequest.Merge(m, src) -} -func (m *GetExternalTimestampRequest) XXX_Size() int { + +type QueryStats struct { + GC uint64 `protobuf:"varint,1,opt,name=GC,proto3" json:"GC,omitempty"` + Get uint64 `protobuf:"varint,2,opt,name=Get,proto3" json:"Get,omitempty"` + Scan uint64 `protobuf:"varint,3,opt,name=Scan,proto3" json:"Scan,omitempty"` + Coprocessor uint64 `protobuf:"varint,4,opt,name=Coprocessor,proto3" json:"Coprocessor,omitempty"` + Delete uint64 `protobuf:"varint,5,opt,name=Delete,proto3" json:"Delete,omitempty"` + DeleteRange uint64 `protobuf:"varint,6,opt,name=DeleteRange,proto3" json:"DeleteRange,omitempty"` + Put uint64 `protobuf:"varint,7,opt,name=Put,proto3" json:"Put,omitempty"` + Prewrite uint64 `protobuf:"varint,8,opt,name=Prewrite,proto3" json:"Prewrite,omitempty"` + AcquirePessimisticLock uint64 `protobuf:"varint,9,opt,name=AcquirePessimisticLock,proto3" json:"AcquirePessimisticLock,omitempty"` + Commit uint64 `protobuf:"varint,10,opt,name=Commit,proto3" json:"Commit,omitempty"` + Rollback uint64 `protobuf:"varint,11,opt,name=Rollback,proto3" json:"Rollback,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *QueryStats) Reset() { *m = QueryStats{} } +func (m *QueryStats) String() string { return proto.CompactTextString(m) } +func (*QueryStats) ProtoMessage() {} +func (*QueryStats) Descriptor() ([]byte, []int) { + return fileDescriptor_78b27e6f04f44c6e, []int{107} +} +func (m *QueryStats) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryStats) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryStats.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *QueryStats) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryStats.Merge(m, src) +} +func (m *QueryStats) XXX_Size() int { return m.Size() } -func (m *GetExternalTimestampRequest) XXX_DiscardUnknown() { - xxx_messageInfo_GetExternalTimestampRequest.DiscardUnknown(m) +func (m *QueryStats) XXX_DiscardUnknown() { + xxx_messageInfo_QueryStats.DiscardUnknown(m) } -var xxx_messageInfo_GetExternalTimestampRequest proto.InternalMessageInfo +var xxx_messageInfo_QueryStats proto.InternalMessageInfo -func (m *GetExternalTimestampRequest) GetHeader() *RequestHeader { +func (m *QueryStats) GetGC() uint64 { + if m != nil { + return m.GC + } + return 0 +} + +func (m *QueryStats) GetGet() uint64 { + if m != nil { + return m.Get + } + return 0 +} + +func (m *QueryStats) GetScan() uint64 { + if m != nil { + return m.Scan + } + return 0 +} + +func (m *QueryStats) GetCoprocessor() uint64 { + if m != nil { + return m.Coprocessor + } + return 0 +} + +func (m *QueryStats) GetDelete() uint64 { + if m != nil { + return m.Delete + } + return 0 +} + +func (m *QueryStats) GetDeleteRange() uint64 { + if m != nil { + return m.DeleteRange + } + return 0 +} + +func (m *QueryStats) GetPut() uint64 { + if m != nil { + return m.Put + } + return 0 +} + +func (m *QueryStats) GetPrewrite() uint64 { + if m != nil { + return m.Prewrite + } + return 0 +} + +func (m *QueryStats) GetAcquirePessimisticLock() uint64 { + if m != nil { + return m.AcquirePessimisticLock + } + return 0 +} + +func (m *QueryStats) GetCommit() uint64 { + if m != nil { + return m.Commit + } + return 0 +} + +func (m *QueryStats) GetRollback() uint64 { + if m != nil { + return m.Rollback + } + return 0 +} + +type ReportBucketsRequest struct { + Header *RequestHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"` + RegionEpoch *metapb.RegionEpoch `protobuf:"bytes,2,opt,name=region_epoch,json=regionEpoch,proto3" json:"region_epoch,omitempty"` + Buckets *metapb.Buckets `protobuf:"bytes,3,opt,name=buckets,proto3" json:"buckets,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ReportBucketsRequest) Reset() { *m = ReportBucketsRequest{} } +func (m *ReportBucketsRequest) String() string { return proto.CompactTextString(m) } +func (*ReportBucketsRequest) ProtoMessage() {} +func (*ReportBucketsRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_78b27e6f04f44c6e, []int{108} +} +func (m *ReportBucketsRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ReportBucketsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ReportBucketsRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *ReportBucketsRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ReportBucketsRequest.Merge(m, src) +} +func (m *ReportBucketsRequest) XXX_Size() int { + return m.Size() +} +func (m *ReportBucketsRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ReportBucketsRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_ReportBucketsRequest proto.InternalMessageInfo + +func (m *ReportBucketsRequest) GetHeader() *RequestHeader { if m != nil { return m.Header } return nil } -type GetExternalTimestampResponse struct { +func (m *ReportBucketsRequest) GetRegionEpoch() *metapb.RegionEpoch { + if m != nil { + return m.RegionEpoch + } + return nil +} + +func (m *ReportBucketsRequest) GetBuckets() *metapb.Buckets { + if m != nil { + return m.Buckets + } + return nil +} + +type ReportBucketsResponse struct { Header *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"` - Timestamp uint64 `protobuf:"varint,2,opt,name=timestamp,proto3" json:"timestamp,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` } -func (m *GetExternalTimestampResponse) Reset() { *m = GetExternalTimestampResponse{} } -func (m *GetExternalTimestampResponse) String() string { return proto.CompactTextString(m) } -func (*GetExternalTimestampResponse) ProtoMessage() {} -func (*GetExternalTimestampResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_78b27e6f04f44c6e, []int{106} +func (m *ReportBucketsResponse) Reset() { *m = ReportBucketsResponse{} } +func (m *ReportBucketsResponse) String() string { return proto.CompactTextString(m) } +func (*ReportBucketsResponse) ProtoMessage() {} +func (*ReportBucketsResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_78b27e6f04f44c6e, []int{109} } -func (m *GetExternalTimestampResponse) XXX_Unmarshal(b []byte) error { +func (m *ReportBucketsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *GetExternalTimestampResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *ReportBucketsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_GetExternalTimestampResponse.Marshal(b, m, deterministic) + return xxx_messageInfo_ReportBucketsResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -7227,3591 +7485,2791 @@ func (m *GetExternalTimestampResponse) XXX_Marshal(b []byte, deterministic bool) return b[:n], nil } } -func (m *GetExternalTimestampResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetExternalTimestampResponse.Merge(m, src) +func (m *ReportBucketsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ReportBucketsResponse.Merge(m, src) } -func (m *GetExternalTimestampResponse) XXX_Size() int { +func (m *ReportBucketsResponse) XXX_Size() int { return m.Size() } -func (m *GetExternalTimestampResponse) XXX_DiscardUnknown() { - xxx_messageInfo_GetExternalTimestampResponse.DiscardUnknown(m) +func (m *ReportBucketsResponse) XXX_DiscardUnknown() { + xxx_messageInfo_ReportBucketsResponse.DiscardUnknown(m) } -var xxx_messageInfo_GetExternalTimestampResponse proto.InternalMessageInfo +var xxx_messageInfo_ReportBucketsResponse proto.InternalMessageInfo -func (m *GetExternalTimestampResponse) GetHeader() *ResponseHeader { +func (m *ReportBucketsResponse) GetHeader() *ResponseHeader { if m != nil { return m.Header } return nil } -func (m *GetExternalTimestampResponse) GetTimestamp() uint64 { - if m != nil { - return m.Timestamp +type ReportMinResolvedTsRequest struct { + Header *RequestHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"` + StoreId uint64 `protobuf:"varint,2,opt,name=store_id,json=storeId,proto3" json:"store_id,omitempty"` + MinResolvedTs uint64 `protobuf:"varint,3,opt,name=min_resolved_ts,json=minResolvedTs,proto3" json:"min_resolved_ts,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ReportMinResolvedTsRequest) Reset() { *m = ReportMinResolvedTsRequest{} } +func (m *ReportMinResolvedTsRequest) String() string { return proto.CompactTextString(m) } +func (*ReportMinResolvedTsRequest) ProtoMessage() {} +func (*ReportMinResolvedTsRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_78b27e6f04f44c6e, []int{110} +} +func (m *ReportMinResolvedTsRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ReportMinResolvedTsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ReportMinResolvedTsRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - return 0 +} +func (m *ReportMinResolvedTsRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ReportMinResolvedTsRequest.Merge(m, src) +} +func (m *ReportMinResolvedTsRequest) XXX_Size() int { + return m.Size() +} +func (m *ReportMinResolvedTsRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ReportMinResolvedTsRequest.DiscardUnknown(m) } -func init() { - proto.RegisterEnum("pdpb.EventType", EventType_name, EventType_value) - proto.RegisterEnum("pdpb.ErrorType", ErrorType_name, ErrorType_value) - proto.RegisterEnum("pdpb.ServiceMode", ServiceMode_name, ServiceMode_value) - proto.RegisterEnum("pdpb.CheckPolicy", CheckPolicy_name, CheckPolicy_value) - proto.RegisterEnum("pdpb.OperatorStatus", OperatorStatus_name, OperatorStatus_value) - proto.RegisterEnum("pdpb.QueryKind", QueryKind_name, QueryKind_value) - proto.RegisterType((*WatchGlobalConfigRequest)(nil), "pdpb.WatchGlobalConfigRequest") - proto.RegisterType((*WatchGlobalConfigResponse)(nil), "pdpb.WatchGlobalConfigResponse") - proto.RegisterType((*StoreGlobalConfigRequest)(nil), "pdpb.StoreGlobalConfigRequest") - proto.RegisterType((*StoreGlobalConfigResponse)(nil), "pdpb.StoreGlobalConfigResponse") - proto.RegisterType((*LoadGlobalConfigRequest)(nil), "pdpb.LoadGlobalConfigRequest") - proto.RegisterType((*LoadGlobalConfigResponse)(nil), "pdpb.LoadGlobalConfigResponse") - proto.RegisterType((*GlobalConfigItem)(nil), "pdpb.GlobalConfigItem") - proto.RegisterType((*RequestHeader)(nil), "pdpb.RequestHeader") - proto.RegisterType((*ResponseHeader)(nil), "pdpb.ResponseHeader") - proto.RegisterType((*Error)(nil), "pdpb.Error") - proto.RegisterType((*TsoRequest)(nil), "pdpb.TsoRequest") - proto.RegisterType((*Timestamp)(nil), "pdpb.Timestamp") - proto.RegisterType((*TsoResponse)(nil), "pdpb.TsoResponse") - proto.RegisterType((*BootstrapRequest)(nil), "pdpb.BootstrapRequest") - proto.RegisterType((*BootstrapResponse)(nil), "pdpb.BootstrapResponse") - proto.RegisterType((*IsBootstrappedRequest)(nil), "pdpb.IsBootstrappedRequest") - proto.RegisterType((*IsBootstrappedResponse)(nil), "pdpb.IsBootstrappedResponse") - proto.RegisterType((*AllocIDRequest)(nil), "pdpb.AllocIDRequest") - proto.RegisterType((*AllocIDResponse)(nil), "pdpb.AllocIDResponse") - proto.RegisterType((*IsSnapshotRecoveringRequest)(nil), "pdpb.IsSnapshotRecoveringRequest") - proto.RegisterType((*IsSnapshotRecoveringResponse)(nil), "pdpb.IsSnapshotRecoveringResponse") - proto.RegisterType((*GetStoreRequest)(nil), "pdpb.GetStoreRequest") - proto.RegisterType((*GetStoreResponse)(nil), "pdpb.GetStoreResponse") - proto.RegisterType((*PutStoreRequest)(nil), "pdpb.PutStoreRequest") - proto.RegisterType((*PutStoreResponse)(nil), "pdpb.PutStoreResponse") - proto.RegisterType((*GetAllStoresRequest)(nil), "pdpb.GetAllStoresRequest") - proto.RegisterType((*GetAllStoresResponse)(nil), "pdpb.GetAllStoresResponse") - proto.RegisterType((*GetRegionRequest)(nil), "pdpb.GetRegionRequest") - proto.RegisterType((*GetRegionResponse)(nil), "pdpb.GetRegionResponse") - proto.RegisterType((*GetRegionByIDRequest)(nil), "pdpb.GetRegionByIDRequest") - proto.RegisterType((*ScanRegionsRequest)(nil), "pdpb.ScanRegionsRequest") - proto.RegisterType((*Region)(nil), "pdpb.Region") - proto.RegisterType((*ScanRegionsResponse)(nil), "pdpb.ScanRegionsResponse") - proto.RegisterType((*GetClusterConfigRequest)(nil), "pdpb.GetClusterConfigRequest") - proto.RegisterType((*GetClusterConfigResponse)(nil), "pdpb.GetClusterConfigResponse") - proto.RegisterType((*PutClusterConfigRequest)(nil), "pdpb.PutClusterConfigRequest") - proto.RegisterType((*PutClusterConfigResponse)(nil), "pdpb.PutClusterConfigResponse") - proto.RegisterType((*Member)(nil), "pdpb.Member") - proto.RegisterType((*GetMembersRequest)(nil), "pdpb.GetMembersRequest") - proto.RegisterType((*GetMembersResponse)(nil), "pdpb.GetMembersResponse") - proto.RegisterMapType((map[string]*Member)(nil), "pdpb.GetMembersResponse.TsoAllocatorLeadersEntry") - proto.RegisterType((*GetClusterInfoRequest)(nil), "pdpb.GetClusterInfoRequest") - proto.RegisterType((*GetClusterInfoResponse)(nil), "pdpb.GetClusterInfoResponse") - proto.RegisterType((*PeerStats)(nil), "pdpb.PeerStats") - proto.RegisterType((*RegionHeartbeatRequest)(nil), "pdpb.RegionHeartbeatRequest") - proto.RegisterType((*ChangePeer)(nil), "pdpb.ChangePeer") - proto.RegisterType((*ChangePeerV2)(nil), "pdpb.ChangePeerV2") - proto.RegisterType((*TransferLeader)(nil), "pdpb.TransferLeader") - proto.RegisterType((*Merge)(nil), "pdpb.Merge") - proto.RegisterType((*SplitRegion)(nil), "pdpb.SplitRegion") - proto.RegisterType((*SwitchWitness)(nil), "pdpb.SwitchWitness") - proto.RegisterType((*BatchSwitchWitness)(nil), "pdpb.BatchSwitchWitness") - proto.RegisterType((*RegionHeartbeatResponse)(nil), "pdpb.RegionHeartbeatResponse") - proto.RegisterType((*AskSplitRequest)(nil), "pdpb.AskSplitRequest") - proto.RegisterType((*AskSplitResponse)(nil), "pdpb.AskSplitResponse") - proto.RegisterType((*ReportSplitRequest)(nil), "pdpb.ReportSplitRequest") - proto.RegisterType((*ReportSplitResponse)(nil), "pdpb.ReportSplitResponse") - proto.RegisterType((*AskBatchSplitRequest)(nil), "pdpb.AskBatchSplitRequest") - proto.RegisterType((*SplitID)(nil), "pdpb.SplitID") - proto.RegisterType((*AskBatchSplitResponse)(nil), "pdpb.AskBatchSplitResponse") - proto.RegisterType((*ReportBatchSplitRequest)(nil), "pdpb.ReportBatchSplitRequest") - proto.RegisterType((*ReportBatchSplitResponse)(nil), "pdpb.ReportBatchSplitResponse") - proto.RegisterType((*TimeInterval)(nil), "pdpb.TimeInterval") - proto.RegisterType((*RecordPair)(nil), "pdpb.RecordPair") - proto.RegisterType((*PeerStat)(nil), "pdpb.PeerStat") - proto.RegisterType((*StoreStats)(nil), "pdpb.StoreStats") - proto.RegisterType((*SlowTrend)(nil), "pdpb.SlowTrend") - proto.RegisterType((*SnapshotStat)(nil), "pdpb.SnapshotStat") - proto.RegisterType((*PeerReport)(nil), "pdpb.PeerReport") - proto.RegisterType((*StoreReport)(nil), "pdpb.StoreReport") - proto.RegisterType((*StoreHeartbeatRequest)(nil), "pdpb.StoreHeartbeatRequest") - proto.RegisterType((*DemoteFailedVoters)(nil), "pdpb.DemoteFailedVoters") - proto.RegisterType((*ForceLeader)(nil), "pdpb.ForceLeader") - proto.RegisterType((*RecoveryPlan)(nil), "pdpb.RecoveryPlan") - proto.RegisterType((*AwakenRegions)(nil), "pdpb.AwakenRegions") - proto.RegisterType((*StoreHeartbeatResponse)(nil), "pdpb.StoreHeartbeatResponse") - proto.RegisterType((*ScatterRegionRequest)(nil), "pdpb.ScatterRegionRequest") - proto.RegisterType((*ScatterRegionResponse)(nil), "pdpb.ScatterRegionResponse") - proto.RegisterType((*GetGCSafePointRequest)(nil), "pdpb.GetGCSafePointRequest") - proto.RegisterType((*GetGCSafePointResponse)(nil), "pdpb.GetGCSafePointResponse") - proto.RegisterType((*UpdateGCSafePointRequest)(nil), "pdpb.UpdateGCSafePointRequest") - proto.RegisterType((*UpdateGCSafePointResponse)(nil), "pdpb.UpdateGCSafePointResponse") - proto.RegisterType((*UpdateServiceGCSafePointRequest)(nil), "pdpb.UpdateServiceGCSafePointRequest") - proto.RegisterType((*UpdateServiceGCSafePointResponse)(nil), "pdpb.UpdateServiceGCSafePointResponse") - proto.RegisterType((*RegionStat)(nil), "pdpb.RegionStat") - proto.RegisterType((*SyncRegionRequest)(nil), "pdpb.SyncRegionRequest") - proto.RegisterType((*PeersStats)(nil), "pdpb.PeersStats") - proto.RegisterType((*Peers)(nil), "pdpb.Peers") - proto.RegisterType((*SyncRegionResponse)(nil), "pdpb.SyncRegionResponse") - proto.RegisterType((*GetOperatorRequest)(nil), "pdpb.GetOperatorRequest") - proto.RegisterType((*GetOperatorResponse)(nil), "pdpb.GetOperatorResponse") - proto.RegisterType((*SyncMaxTSRequest)(nil), "pdpb.SyncMaxTSRequest") - proto.RegisterType((*SyncMaxTSResponse)(nil), "pdpb.SyncMaxTSResponse") - proto.RegisterType((*SplitRegionsRequest)(nil), "pdpb.SplitRegionsRequest") - proto.RegisterType((*SplitRegionsResponse)(nil), "pdpb.SplitRegionsResponse") - proto.RegisterType((*SplitAndScatterRegionsRequest)(nil), "pdpb.SplitAndScatterRegionsRequest") - proto.RegisterType((*SplitAndScatterRegionsResponse)(nil), "pdpb.SplitAndScatterRegionsResponse") - proto.RegisterType((*GetDCLocationInfoRequest)(nil), "pdpb.GetDCLocationInfoRequest") - proto.RegisterType((*GetDCLocationInfoResponse)(nil), "pdpb.GetDCLocationInfoResponse") - proto.RegisterType((*QueryStats)(nil), "pdpb.QueryStats") - proto.RegisterType((*ReportBucketsRequest)(nil), "pdpb.ReportBucketsRequest") - proto.RegisterType((*ReportBucketsResponse)(nil), "pdpb.ReportBucketsResponse") - proto.RegisterType((*ReportMinResolvedTsRequest)(nil), "pdpb.ReportMinResolvedTsRequest") - proto.RegisterType((*ReportMinResolvedTsResponse)(nil), "pdpb.ReportMinResolvedTsResponse") - proto.RegisterType((*SetExternalTimestampRequest)(nil), "pdpb.SetExternalTimestampRequest") - proto.RegisterType((*SetExternalTimestampResponse)(nil), "pdpb.SetExternalTimestampResponse") - proto.RegisterType((*GetExternalTimestampRequest)(nil), "pdpb.GetExternalTimestampRequest") - proto.RegisterType((*GetExternalTimestampResponse)(nil), "pdpb.GetExternalTimestampResponse") -} - -func init() { proto.RegisterFile("pdpb.proto", fileDescriptor_78b27e6f04f44c6e) } +var xxx_messageInfo_ReportMinResolvedTsRequest proto.InternalMessageInfo -var fileDescriptor_78b27e6f04f44c6e = []byte{ - // 5654 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x3c, 0x4d, 0x93, 0x23, 0x47, - 0x56, 0x5d, 0x6a, 0x49, 0x2d, 0x3d, 0x7d, 0x74, 0x75, 0x4e, 0xcf, 0xb4, 0x46, 0xf3, 0xe9, 0x1a, - 0xdb, 0x8c, 0x67, 0xbd, 0x63, 0x7b, 0x6c, 0x16, 0x63, 0x58, 0x07, 0x6a, 0x49, 0xd3, 0x96, 0xa7, - 0x3f, 0x44, 0x49, 0x33, 0x5e, 0x13, 0x1b, 0x54, 0x54, 0x57, 0x65, 0x77, 0xd7, 0xb6, 0x54, 0x25, - 0x57, 0x96, 0xba, 0x47, 0x1b, 0x10, 0xc1, 0xc7, 0x02, 0x4b, 0xb0, 0x1b, 0x10, 0xc1, 0xe7, 0x69, - 0x0f, 0x40, 0x00, 0x17, 0x82, 0x1b, 0x01, 0x7f, 0x80, 0xe0, 0xc8, 0x91, 0x13, 0xb1, 0x61, 0x4e, - 0x04, 0xf7, 0xbd, 0xc0, 0x81, 0xc8, 0xaf, 0x52, 0x55, 0xa9, 0xd4, 0x3d, 0x53, 0xb6, 0x89, 0x3d, - 0xa9, 0xf2, 0xbd, 0x97, 0x2f, 0x5f, 0xbe, 0x7c, 0x99, 0xf9, 0xde, 0xcb, 0x4c, 0x01, 0x4c, 0xec, - 0xc9, 0xe1, 0xc3, 0x89, 0xef, 0x05, 0x1e, 0xca, 0xd3, 0xef, 0x66, 0x75, 0x8c, 0x03, 0x53, 0xc2, - 0x9a, 0x35, 0xec, 0x9b, 0x47, 0x41, 0x58, 0xbc, 0x42, 0x4b, 0x06, 0xc1, 0xfe, 0x19, 0xf6, 0x43, - 0x60, 0xc3, 0xc7, 0x93, 0x91, 0x63, 0x99, 0x81, 0xe3, 0xb9, 0xc6, 0xd8, 0xb3, 0x71, 0x88, 0xd9, - 0x3c, 0xf6, 0x8e, 0x3d, 0xf6, 0xf9, 0x16, 0xfd, 0x12, 0xd0, 0x75, 0x7f, 0x4a, 0x02, 0xf6, 0xc9, - 0x01, 0xda, 0x27, 0xd0, 0xf8, 0xc4, 0x0c, 0xac, 0x93, 0x9d, 0x91, 0x77, 0x68, 0x8e, 0xda, 0x9e, - 0x7b, 0xe4, 0x1c, 0xeb, 0xf8, 0xb3, 0x29, 0x26, 0x01, 0xba, 0x03, 0x15, 0x8b, 0x01, 0x8c, 0x89, - 0x19, 0x9c, 0x34, 0x94, 0xbb, 0xca, 0xfd, 0xb2, 0x0e, 0x1c, 0xd4, 0x37, 0x83, 0x13, 0xd4, 0x84, - 0x92, 0x8f, 0xcf, 0x1c, 0xe2, 0x78, 0x6e, 0x23, 0x77, 0x57, 0xb9, 0xbf, 0xaa, 0x87, 0x65, 0xed, - 0xcf, 0x15, 0xb8, 0x9e, 0xc2, 0x99, 0x4c, 0x3c, 0x97, 0x60, 0xf4, 0x36, 0xac, 0x59, 0x27, 0xa6, - 0x7b, 0x8c, 0x49, 0x43, 0xb9, 0xbb, 0x7a, 0xbf, 0xf2, 0xe8, 0xda, 0x43, 0xa6, 0x8d, 0x28, 0x71, - 0x2f, 0xc0, 0x63, 0x5d, 0x92, 0x5d, 0xd4, 0x16, 0x7a, 0x13, 0x8a, 0x27, 0xd8, 0xb4, 0xb1, 0xdf, - 0x58, 0xbd, 0xab, 0xdc, 0xaf, 0x3c, 0xda, 0xe4, 0xcc, 0x64, 0x6b, 0x1f, 0x31, 0x9c, 0x2e, 0x68, - 0xb4, 0x31, 0x34, 0x06, 0x81, 0xe7, 0xe3, 0xb4, 0x2e, 0xbf, 0xbc, 0x5c, 0x09, 0x25, 0xe5, 0x92, - 0x4a, 0xd2, 0x3e, 0x84, 0xeb, 0x29, 0xcd, 0x09, 0x3d, 0xbc, 0x02, 0x05, 0xec, 0xfb, 0x9e, 0xcf, - 0x94, 0x5b, 0x79, 0x54, 0xe1, 0xad, 0x75, 0x29, 0x48, 0xe7, 0x18, 0xad, 0x0f, 0x5b, 0xbb, 0x9e, - 0x69, 0xa7, 0x49, 0xbb, 0x09, 0x05, 0xd7, 0x1c, 0x0b, 0x59, 0xcb, 0x3a, 0x2f, 0x5c, 0x2e, 0x91, - 0x0d, 0x8d, 0x45, 0x8e, 0x42, 0xa0, 0x37, 0xa1, 0xe0, 0x04, 0x78, 0x7c, 0x59, 0xf7, 0x39, 0xd1, - 0x85, 0x06, 0xf0, 0x23, 0x05, 0xd4, 0x64, 0x3d, 0x84, 0x20, 0x4f, 0x85, 0x14, 0xb6, 0xc4, 0xbe, - 0x69, 0x2f, 0xce, 0xcc, 0xd1, 0x14, 0x0b, 0x49, 0x79, 0x61, 0xae, 0x99, 0xd5, 0x65, 0x9a, 0x41, - 0xf7, 0x20, 0x7f, 0xea, 0xb8, 0x76, 0x23, 0x7f, 0x57, 0xb9, 0x5f, 0x7f, 0xb4, 0x2e, 0x28, 0xce, - 0xb0, 0x1b, 0x0c, 0x67, 0x13, 0xac, 0x33, 0x24, 0x6a, 0xc0, 0xda, 0xc4, 0x9c, 0x8d, 0x3c, 0xd3, - 0x6e, 0x14, 0xee, 0x2a, 0xf7, 0xab, 0xba, 0x2c, 0x6a, 0x4f, 0xa0, 0x26, 0x14, 0xc9, 0x0d, 0x04, - 0xdd, 0x02, 0xb0, 0x46, 0x53, 0x12, 0x60, 0xdf, 0x70, 0x6c, 0x26, 0x62, 0x5e, 0x2f, 0x0b, 0x48, - 0xcf, 0x46, 0x37, 0xa0, 0x4c, 0xb0, 0x6b, 0x73, 0x6c, 0x8e, 0x61, 0x4b, 0x1c, 0xd0, 0xb3, 0x35, - 0x1d, 0xea, 0x71, 0x73, 0xbb, 0x8c, 0x5b, 0xd8, 0xbf, 0xdc, 0xd2, 0x91, 0x7f, 0x0c, 0x85, 0xae, - 0xec, 0x68, 0x30, 0x9b, 0x70, 0xad, 0xcd, 0x3b, 0x4a, 0x51, 0xbc, 0xa3, 0x14, 0x49, 0x3b, 0x3a, - 0xc6, 0x84, 0x98, 0xc7, 0x52, 0x91, 0xb2, 0xa8, 0x4d, 0x00, 0x86, 0xc4, 0x93, 0x46, 0xf3, 0xb5, - 0x70, 0xb2, 0x70, 0x9b, 0xbb, 0x22, 0x27, 0x4b, 0x44, 0x15, 0x72, 0xae, 0xd0, 0xb1, 0xb1, 0xbc, - 0xa9, 0x1b, 0x30, 0x96, 0x35, 0x9d, 0x17, 0xa8, 0x85, 0xd9, 0x96, 0x31, 0xf2, 0xf8, 0xba, 0xc3, - 0x46, 0xa8, 0xac, 0x83, 0x6d, 0xed, 0x0a, 0x88, 0x76, 0x08, 0xe5, 0xa1, 0x33, 0xc6, 0x24, 0x30, - 0xc7, 0x13, 0x6a, 0x24, 0x93, 0x93, 0x19, 0x71, 0x2c, 0x73, 0xc4, 0x9a, 0x5c, 0xd5, 0xc3, 0x32, - 0x15, 0x7a, 0xe4, 0x1d, 0x33, 0x14, 0xb7, 0x1f, 0x59, 0xa4, 0x6d, 0x90, 0xe9, 0xd1, 0x91, 0xf3, - 0xdc, 0x38, 0x74, 0x02, 0xc2, 0xda, 0xa8, 0xe9, 0xc0, 0x41, 0xdb, 0x4e, 0x40, 0xb4, 0xdf, 0x50, - 0xa0, 0xc2, 0xba, 0x15, 0x5a, 0x6e, 0xbc, 0x5f, 0x17, 0x2e, 0x02, 0x4b, 0x3a, 0xf6, 0x75, 0x28, - 0x07, 0x52, 0x6e, 0x61, 0x78, 0x42, 0xdb, 0x61, 0x77, 0xf4, 0x39, 0x85, 0xf6, 0x03, 0x05, 0xd4, - 0x6d, 0xcf, 0x0b, 0x48, 0xe0, 0x9b, 0x93, 0x4c, 0xfa, 0xbd, 0x07, 0x05, 0x42, 0x17, 0x07, 0x61, - 0x05, 0xb5, 0x87, 0x62, 0x07, 0x60, 0x2b, 0x86, 0xce, 0x71, 0xe8, 0x75, 0x28, 0xfa, 0xf8, 0x58, - 0x6a, 0xba, 0xf2, 0xa8, 0x2e, 0xa9, 0x74, 0x06, 0xd5, 0x05, 0x96, 0x2e, 0xb9, 0x1b, 0x11, 0x71, - 0x32, 0xe9, 0x65, 0x08, 0x28, 0xba, 0xa5, 0x90, 0xc0, 0x0c, 0xa6, 0x44, 0x48, 0xf7, 0xda, 0xc3, - 0x94, 0xdd, 0x46, 0x9f, 0x83, 0x06, 0x8c, 0x58, 0xdf, 0xf0, 0x93, 0x20, 0xad, 0x03, 0x57, 0x7b, - 0x24, 0x14, 0x6d, 0x82, 0xed, 0x2c, 0xca, 0xd2, 0xbe, 0x03, 0xd7, 0x92, 0x5c, 0x32, 0xf5, 0x51, - 0x83, 0xea, 0x61, 0x84, 0x0b, 0xeb, 0x5d, 0x49, 0x8f, 0xc1, 0xb4, 0x6f, 0x42, 0xbd, 0x35, 0x1a, - 0x79, 0x56, 0xaf, 0x93, 0x49, 0xd4, 0x03, 0x58, 0x0f, 0xab, 0x67, 0x92, 0xb1, 0x0e, 0xb9, 0x70, - 0x95, 0xc9, 0x39, 0xb6, 0xf6, 0x31, 0xdc, 0xe8, 0x91, 0x81, 0x6b, 0x4e, 0xc8, 0x89, 0x17, 0xe8, - 0xd8, 0xf2, 0xce, 0xb0, 0xef, 0xb8, 0xc7, 0x99, 0x84, 0xb3, 0xe1, 0x66, 0x3a, 0xaf, 0x4c, 0x92, - 0x5e, 0x83, 0xe2, 0xd8, 0xf4, 0x4f, 0x43, 0x3d, 0x8a, 0x92, 0xf6, 0x29, 0xac, 0xef, 0xe0, 0x80, - 0x1b, 0x72, 0x96, 0xa9, 0x71, 0x1d, 0x4a, 0xcc, 0xfc, 0xe7, 0xab, 0xed, 0x1a, 0x2b, 0xf7, 0x6c, - 0xed, 0x87, 0x74, 0x6b, 0x09, 0x79, 0x67, 0x92, 0xfa, 0x05, 0x27, 0x5e, 0x81, 0x4e, 0x00, 0x22, - 0xe6, 0x9d, 0xca, 0x39, 0x32, 0x12, 0x6a, 0xd8, 0x44, 0xe7, 0x68, 0xcd, 0x82, 0xf5, 0xfe, 0xf4, - 0x0b, 0x74, 0xf5, 0x45, 0x84, 0xd1, 0xfe, 0x4c, 0x01, 0x75, 0xde, 0xca, 0x4f, 0xd1, 0xe4, 0xfe, - 0x35, 0xb8, 0xb2, 0x83, 0x83, 0xd6, 0x68, 0xc4, 0x44, 0x23, 0x99, 0x34, 0xf0, 0x3e, 0x34, 0xf0, - 0x73, 0x6b, 0x34, 0xb5, 0xb1, 0x11, 0x78, 0xe3, 0x43, 0x12, 0x78, 0x2e, 0x36, 0x58, 0xbf, 0x89, - 0x30, 0xab, 0x6b, 0x02, 0x3f, 0x94, 0x68, 0xde, 0x9a, 0x76, 0x0a, 0x9b, 0xf1, 0xd6, 0x33, 0x69, - 0xe6, 0x35, 0x28, 0x86, 0xad, 0xad, 0x2e, 0x0e, 0x81, 0x40, 0x6a, 0xbf, 0xc9, 0x0d, 0x4f, 0xac, - 0xbb, 0x59, 0x3a, 0x7a, 0x0b, 0x80, 0xaf, 0xd6, 0xc6, 0x29, 0x9e, 0xb1, 0xae, 0x55, 0xf5, 0x32, - 0x87, 0x3c, 0xc1, 0x33, 0xf4, 0x0a, 0x54, 0x5d, 0x8c, 0x6d, 0xe3, 0x70, 0x6a, 0x9d, 0x62, 0x61, - 0x78, 0x25, 0xbd, 0x42, 0x61, 0xdb, 0x1c, 0xa4, 0xfd, 0x55, 0x0e, 0x36, 0x22, 0x32, 0x64, 0xea, - 0xee, 0x7c, 0x47, 0xc9, 0x5d, 0xb4, 0xa3, 0xa0, 0x57, 0xa1, 0x38, 0x8a, 0x3a, 0xd6, 0x55, 0x49, - 0xd7, 0xc7, 0x94, 0x1b, 0xc7, 0xa1, 0x87, 0x00, 0xb6, 0x77, 0xee, 0x1a, 0x13, 0x8c, 0x7d, 0xd2, - 0x28, 0x30, 0x05, 0x8a, 0x6d, 0x93, 0xd2, 0xf1, 0xa9, 0x52, 0xa6, 0x24, 0xb4, 0x48, 0xd0, 0x3b, - 0x50, 0x9b, 0x60, 0xd7, 0x76, 0xdc, 0x63, 0x51, 0xa5, 0xc8, 0xaa, 0xc4, 0x99, 0x57, 0x05, 0x09, - 0xaf, 0xf2, 0x06, 0xac, 0x49, 0x95, 0xac, 0x89, 0x6d, 0x59, 0x10, 0x0b, 0xb5, 0xe8, 0x12, 0xff, - 0x71, 0xbe, 0x94, 0x57, 0x0b, 0xda, 0x6f, 0x2b, 0xcc, 0x2e, 0x78, 0x7f, 0xb6, 0x67, 0xd9, 0x96, - 0x71, 0xea, 0xf2, 0x89, 0xd1, 0x9a, 0xbb, 0x7c, 0x1c, 0xc0, 0x3c, 0xb8, 0x4b, 0xc7, 0xea, 0x87, - 0x0a, 0xa0, 0x81, 0x65, 0xba, 0x5c, 0x0c, 0x92, 0x55, 0x06, 0x12, 0x98, 0x7e, 0x10, 0x31, 0x98, - 0x12, 0x03, 0x50, 0x7b, 0xd9, 0x84, 0xc2, 0xc8, 0x19, 0x3b, 0x01, 0x6b, 0xbc, 0xa0, 0xf3, 0x02, - 0xda, 0x82, 0x35, 0xec, 0xda, 0xac, 0x42, 0x9e, 0x55, 0x28, 0x62, 0xd7, 0x7e, 0x82, 0x67, 0xda, - 0x3f, 0x2b, 0x50, 0xe4, 0xb2, 0x44, 0x4c, 0x40, 0x79, 0x41, 0x13, 0xc8, 0xbd, 0xb0, 0x09, 0xac, - 0xbe, 0xbc, 0x09, 0xe4, 0x2f, 0x33, 0x01, 0xed, 0x5f, 0x14, 0xb8, 0x12, 0xd3, 0x65, 0x26, 0xcb, - 0x7f, 0x07, 0xaa, 0x62, 0x44, 0x69, 0x4b, 0x72, 0xba, 0x27, 0x3b, 0x5f, 0xe1, 0x34, 0x7b, 0x94, - 0x04, 0xbd, 0x0e, 0x6b, 0xbc, 0x97, 0xb2, 0x63, 0x71, 0x29, 0x25, 0x92, 0xd2, 0xf1, 0x6a, 0xf3, - 0xde, 0x08, 0x49, 0x18, 0x4f, 0x89, 0xd4, 0x1e, 0xc3, 0xd6, 0x0e, 0x0e, 0xda, 0x3c, 0x12, 0x88, - 0x07, 0x74, 0x2f, 0xb5, 0x8d, 0x13, 0x68, 0x2c, 0xf2, 0xc9, 0xa4, 0x94, 0x37, 0x60, 0x4d, 0x04, - 0x26, 0x62, 0x90, 0xc3, 0xd9, 0x25, 0xb8, 0xeb, 0x12, 0xaf, 0x7d, 0x06, 0x5b, 0xfd, 0xe9, 0x17, - 0x17, 0xfe, 0x65, 0x9a, 0xfc, 0x08, 0x1a, 0x8b, 0x4d, 0x66, 0xe9, 0xa7, 0xf6, 0xd7, 0x39, 0x28, - 0xee, 0xe1, 0xf1, 0x21, 0xf6, 0x53, 0x03, 0xd1, 0x1b, 0x50, 0x1e, 0x33, 0x6c, 0x64, 0xb6, 0x73, - 0x00, 0x8f, 0xfe, 0xa8, 0xa5, 0x1a, 0x53, 0x7f, 0xc4, 0xed, 0xa0, 0xac, 0x97, 0x28, 0xe0, 0xa9, - 0x3f, 0xe2, 0x21, 0xf7, 0xc8, 0xc1, 0x6e, 0xc0, 0xd1, 0x79, 0x86, 0x06, 0x0e, 0x62, 0x04, 0x3f, - 0x03, 0xeb, 0xdc, 0x4c, 0x8c, 0x89, 0xef, 0x78, 0xbe, 0x13, 0xcc, 0x58, 0x34, 0x5a, 0xd0, 0xeb, - 0x1c, 0xdc, 0x17, 0x50, 0x16, 0x5a, 0xe1, 0xc9, 0xc8, 0x9b, 0xf1, 0xe0, 0xbd, 0x28, 0x42, 0x2b, - 0x06, 0x62, 0x39, 0x97, 0xd7, 0xa0, 0x7e, 0xe8, 0xb8, 0xa6, 0x3f, 0x33, 0xce, 0xb0, 0xcf, 0x02, - 0xef, 0x35, 0x46, 0x53, 0xe3, 0xd0, 0x67, 0x1c, 0x48, 0xbd, 0xa7, 0x63, 0x27, 0x30, 0x4e, 0x4c, - 0x72, 0xd2, 0x28, 0xf1, 0x70, 0xf0, 0xd8, 0x09, 0x3e, 0x32, 0xc9, 0x49, 0x32, 0x7a, 0x2b, 0x2f, - 0x44, 0x6f, 0xbf, 0xc4, 0x36, 0x18, 0xae, 0xa8, 0x4c, 0x6b, 0x96, 0xf6, 0xbf, 0x39, 0x40, 0x51, - 0x16, 0x19, 0x37, 0xa9, 0x35, 0xae, 0x7d, 0x39, 0x4b, 0xc5, 0x7c, 0xe2, 0x5c, 0x75, 0x89, 0x4c, - 0xd9, 0xa4, 0xa2, 0x64, 0x72, 0x85, 0xfa, 0x3a, 0x54, 0x70, 0x60, 0xd9, 0x86, 0x20, 0xcd, 0xa7, - 0x90, 0x02, 0x25, 0xd8, 0xe5, 0xe4, 0x18, 0xae, 0x06, 0xc4, 0x33, 0xcc, 0x11, 0xd3, 0x93, 0xe7, - 0x1b, 0x72, 0x09, 0xe0, 0xdb, 0xdb, 0x3b, 0x22, 0x2f, 0xb2, 0xd0, 0xc7, 0x87, 0x43, 0xe2, 0xb5, - 0x64, 0x25, 0xce, 0x8b, 0x74, 0xdd, 0xc0, 0x9f, 0xe9, 0x57, 0x82, 0x45, 0x4c, 0x73, 0x08, 0x8d, - 0x65, 0x15, 0x90, 0x0a, 0xab, 0x74, 0x05, 0xe7, 0x16, 0x4a, 0x3f, 0x91, 0x16, 0xcd, 0x94, 0x24, - 0xa5, 0xe7, 0xa8, 0x0f, 0x72, 0xef, 0x2b, 0x5a, 0x17, 0xae, 0xce, 0x57, 0x86, 0x9e, 0x7b, 0x14, - 0xc6, 0xfe, 0x2f, 0x37, 0x5d, 0x7e, 0x1d, 0xae, 0x25, 0xd9, 0x64, 0x1a, 0xc8, 0x9f, 0x85, 0x2a, - 0xc1, 0xfe, 0x99, 0x63, 0xe1, 0x3d, 0xcf, 0x16, 0x2e, 0x56, 0xfd, 0xd1, 0x86, 0xf0, 0xa6, 0xe7, - 0x18, 0x3d, 0x46, 0xa6, 0xf5, 0xa1, 0x1c, 0xee, 0x1d, 0xe8, 0x2e, 0xe4, 0xe9, 0x6c, 0x13, 0xed, - 0xc5, 0x57, 0x60, 0x86, 0xa1, 0xdb, 0x31, 0xdb, 0x82, 0x08, 0xb6, 0x3c, 0xd7, 0x26, 0x62, 0x02, - 0x57, 0x28, 0x6c, 0xc0, 0x41, 0xda, 0x4f, 0x0a, 0x70, 0x8d, 0xaf, 0xc6, 0x1f, 0x61, 0xd3, 0x0f, - 0x0e, 0xb1, 0x19, 0x64, 0x5a, 0xbc, 0xbe, 0x4a, 0xf7, 0x29, 0xff, 0xf2, 0x7b, 0x67, 0xe1, 0x52, - 0xf7, 0xe9, 0x1e, 0xd4, 0x0e, 0x67, 0x01, 0x26, 0xc6, 0xb9, 0xef, 0x04, 0x01, 0x76, 0xd9, 0xba, - 0x92, 0xd7, 0xab, 0x0c, 0xf8, 0x09, 0x87, 0x51, 0xd7, 0x94, 0x13, 0xf9, 0xd8, 0xb4, 0xd9, 0xaa, - 0x92, 0xd7, 0xcb, 0x0c, 0xa2, 0x63, 0x93, 0xb9, 0x3b, 0xa7, 0x78, 0x36, 0x67, 0x51, 0xe2, 0xfa, - 0xa5, 0x30, 0xc9, 0xe1, 0x06, 0x94, 0x19, 0x09, 0x63, 0x50, 0xe6, 0x0b, 0x28, 0x05, 0xb0, 0xfa, - 0x6f, 0x80, 0x6a, 0x4e, 0x26, 0xbe, 0xf7, 0xdc, 0x19, 0x9b, 0x01, 0x36, 0x88, 0xf3, 0x5d, 0xdc, - 0x00, 0x46, 0xb3, 0x1e, 0x81, 0x0f, 0x9c, 0xef, 0x62, 0xf4, 0x10, 0x4a, 0x8e, 0x1b, 0x60, 0xff, - 0xcc, 0x1c, 0x35, 0xaa, 0x4c, 0x73, 0x68, 0x9e, 0x85, 0xe9, 0x09, 0x8c, 0x1e, 0xd2, 0x24, 0x59, - 0xd3, 0x26, 0x1b, 0xb5, 0x05, 0xd6, 0x4f, 0xf0, 0x8c, 0xd0, 0x75, 0x3f, 0xc0, 0xfe, 0xb8, 0x51, - 0x67, 0x68, 0xf6, 0x8d, 0x7e, 0x25, 0x35, 0x2c, 0x5a, 0x67, 0x0d, 0x7f, 0x2d, 0x3d, 0x2c, 0xe2, - 0xbe, 0xf7, 0xe5, 0xc1, 0x11, 0x7a, 0x07, 0x2a, 0x9f, 0x4d, 0xb1, 0x3f, 0x33, 0x78, 0x20, 0xa9, - 0x46, 0x03, 0xc9, 0x5f, 0xa6, 0x08, 0x3e, 0xbc, 0xf0, 0x59, 0xf8, 0x4d, 0xb5, 0x68, 0x4d, 0xa6, - 0xc6, 0x94, 0xa5, 0xf2, 0x36, 0xb8, 0x16, 0xad, 0xc9, 0xf4, 0x29, 0x2d, 0xa3, 0x87, 0x70, 0x25, - 0xd6, 0xd5, 0x33, 0xae, 0x48, 0xc4, 0xc8, 0x36, 0xa2, 0xbd, 0x3d, 0xa3, 0xaa, 0xfc, 0x38, 0x5f, - 0xaa, 0xa8, 0x55, 0xed, 0x04, 0xa0, 0xcd, 0xf2, 0xd5, 0xd4, 0x1c, 0x5e, 0x60, 0x2e, 0xbd, 0x0f, - 0x15, 0x9e, 0xdf, 0x36, 0x58, 0xde, 0x31, 0xc7, 0xf2, 0x8e, 0x5b, 0x0f, 0xe5, 0x81, 0x04, 0xdd, - 0x84, 0x39, 0x3f, 0x96, 0x7f, 0x04, 0x2b, 0xfc, 0xd6, 0x3e, 0x80, 0xea, 0xbc, 0xa5, 0x67, 0x8f, - 0xd0, 0x83, 0x64, 0x42, 0x5d, 0xf4, 0x7d, 0x4e, 0x14, 0xa6, 0xd2, 0xb5, 0x67, 0x50, 0x1f, 0xfa, - 0xa6, 0x4b, 0x8e, 0xb0, 0x58, 0x08, 0x5f, 0x40, 0x52, 0x0d, 0x0a, 0x7c, 0x12, 0xe4, 0x52, 0x26, - 0x01, 0x47, 0x69, 0x6f, 0x41, 0x61, 0x0f, 0xfb, 0xc7, 0x2c, 0x91, 0x16, 0x98, 0xfe, 0x31, 0x0e, - 0x96, 0xf9, 0xbc, 0x1c, 0xab, 0xed, 0x42, 0x65, 0x30, 0x19, 0x39, 0x22, 0x7a, 0x40, 0x6f, 0x40, - 0x71, 0xe2, 0x8d, 0x1c, 0x6b, 0x26, 0x12, 0xb0, 0x1b, 0xb2, 0x0b, 0xd8, 0x3a, 0xed, 0x33, 0x84, - 0x2e, 0x08, 0xa8, 0x79, 0x31, 0xeb, 0xa3, 0xd2, 0x54, 0x75, 0xf6, 0xad, 0xed, 0x40, 0x6d, 0x70, - 0xee, 0x04, 0xd6, 0xc9, 0x27, 0x4e, 0xe0, 0x62, 0x42, 0xa8, 0x7b, 0xce, 0x5c, 0x89, 0x30, 0x2d, - 0x5c, 0xa4, 0xc5, 0x9e, 0x4d, 0x67, 0xa0, 0x43, 0x8c, 0x73, 0x4e, 0x26, 0xe2, 0xde, 0xb2, 0x43, - 0x44, 0x3d, 0x6d, 0x08, 0x68, 0xdb, 0x0c, 0xac, 0x93, 0x38, 0xb7, 0x0f, 0x41, 0x25, 0x0c, 0x20, - 0x2b, 0x86, 0xaa, 0x16, 0x6b, 0x58, 0x8c, 0x5c, 0x5f, 0x27, 0xd1, 0x22, 0x26, 0xda, 0x9f, 0xe6, - 0x61, 0x6b, 0x61, 0x51, 0xcc, 0xe8, 0x5b, 0x4b, 0xab, 0x61, 0x83, 0x96, 0x8b, 0xda, 0x7a, 0x64, - 0xbc, 0x85, 0xb9, 0x30, 0x53, 0xfc, 0x26, 0xac, 0x07, 0x62, 0xc8, 0x8d, 0x51, 0xca, 0x11, 0x4e, - 0xdc, 0x1e, 0xf4, 0x7a, 0x10, 0xb7, 0x8f, 0x58, 0x7c, 0x96, 0x4f, 0xc4, 0x67, 0xdf, 0x08, 0x5d, - 0x7d, 0x3c, 0xf1, 0xac, 0x13, 0xe6, 0x70, 0x51, 0xa5, 0xc4, 0xc6, 0xbc, 0x4b, 0x51, 0xd2, 0xdf, - 0x67, 0x05, 0xea, 0x29, 0x70, 0x3b, 0xe0, 0xdd, 0x28, 0xa6, 0xd8, 0x1e, 0x70, 0x82, 0x3e, 0xdf, - 0x77, 0x0a, 0x63, 0x6a, 0x5d, 0x22, 0x30, 0xad, 0xc8, 0x4d, 0xd9, 0x3f, 0xc6, 0x3a, 0xc7, 0xa0, - 0xf7, 0xa0, 0x4a, 0xa8, 0x3d, 0x19, 0x62, 0xd7, 0x28, 0x31, 0x4a, 0xb9, 0x01, 0xce, 0x2d, 0x4d, - 0xaf, 0x90, 0x88, 0xd9, 0xbd, 0x0f, 0xf5, 0x88, 0x3a, 0x8d, 0xb3, 0x47, 0x6c, 0x49, 0x0d, 0xd7, - 0xc2, 0xe8, 0x34, 0xd3, 0xab, 0x56, 0x74, 0xd2, 0xb5, 0x53, 0x4c, 0x02, 0x58, 0xdd, 0x06, 0xaf, - 0xbb, 0x68, 0x46, 0x8b, 0x76, 0x71, 0x04, 0xeb, 0x2d, 0x72, 0x2a, 0xa4, 0xfb, 0xea, 0x36, 0x49, - 0xed, 0x77, 0x15, 0x50, 0xe7, 0x0d, 0x65, 0x4c, 0xe8, 0xd6, 0x5c, 0x7c, 0x6e, 0x24, 0x43, 0xf5, - 0x8a, 0x8b, 0xcf, 0x75, 0x69, 0x0d, 0x77, 0x69, 0xb4, 0x7e, 0x6e, 0x88, 0x89, 0xc7, 0x5d, 0xf8, - 0xbc, 0x0e, 0x2e, 0x3e, 0xef, 0xb3, 0xc9, 0x47, 0xb4, 0x3f, 0x50, 0x00, 0xe9, 0x78, 0xe2, 0xf9, - 0x41, 0xf6, 0x4e, 0x6b, 0x90, 0x1f, 0xe1, 0xa3, 0x60, 0x49, 0x97, 0x19, 0x0e, 0xbd, 0x0a, 0x05, - 0xdf, 0x39, 0x3e, 0x09, 0x96, 0x64, 0xf3, 0x39, 0x52, 0x6b, 0xc3, 0x95, 0x98, 0x30, 0x99, 0x02, - 0x9e, 0x1f, 0x28, 0xb0, 0xd9, 0x22, 0xa7, 0x7c, 0xb8, 0xbf, 0xea, 0x91, 0x64, 0x47, 0x36, 0xcc, - 0xcc, 0xf9, 0xc9, 0x8a, 0x3c, 0xb2, 0xa1, 0xa0, 0x36, 0x85, 0x68, 0x07, 0xb0, 0xc6, 0xa4, 0xe8, - 0x75, 0x16, 0x87, 0x4c, 0xb9, 0x7c, 0xc8, 0x72, 0x0b, 0x43, 0x76, 0x04, 0x57, 0x13, 0xdd, 0xcb, - 0x64, 0x3f, 0x77, 0x60, 0x55, 0xf2, 0xaf, 0x3c, 0xaa, 0x45, 0xa6, 0x65, 0xaf, 0xa3, 0x53, 0x8c, - 0x36, 0xa1, 0x4b, 0x24, 0x1d, 0x8c, 0x2f, 0xa8, 0xc9, 0xfb, 0xf3, 0x14, 0x41, 0x7a, 0xe2, 0x21, - 0x4c, 0x12, 0x7c, 0x04, 0x8d, 0xc5, 0x16, 0x33, 0xd9, 0xc0, 0xb7, 0xa1, 0x1a, 0x75, 0x9b, 0x68, - 0x28, 0xca, 0xf3, 0x49, 0xf3, 0x93, 0x2e, 0xae, 0xfb, 0x3a, 0x03, 0xcf, 0xcf, 0xed, 0xee, 0x41, - 0x0d, 0xbb, 0x76, 0x84, 0x8c, 0xcf, 0xaa, 0x2a, 0x76, 0xed, 0x90, 0x48, 0x7b, 0x0f, 0x40, 0xc7, - 0x96, 0xe7, 0xdb, 0x7d, 0xd3, 0xf1, 0x53, 0x42, 0x96, 0xd8, 0xe1, 0x6e, 0x5e, 0x04, 0x29, 0xda, - 0x7f, 0x28, 0x50, 0x92, 0xbe, 0x6d, 0x7c, 0x11, 0x57, 0x12, 0x8b, 0x38, 0x43, 0x9a, 0xb6, 0x21, - 0x76, 0x55, 0x81, 0x34, 0x6d, 0xe6, 0xcc, 0xb1, 0x64, 0xaa, 0x69, 0x1b, 0xcc, 0x49, 0x65, 0xf6, - 0x96, 0xd7, 0x19, 0xf9, 0x36, 0x05, 0x24, 0x7d, 0xaf, 0xfc, 0x0b, 0xf8, 0x5e, 0xaf, 0x40, 0x55, - 0xf8, 0xb7, 0xbc, 0xc5, 0x02, 0xb7, 0x4a, 0x01, 0x63, 0x8d, 0xde, 0x83, 0x9a, 0x24, 0xe1, 0xed, - 0x0a, 0x5f, 0x5a, 0x00, 0x59, 0xd3, 0xda, 0x3f, 0x94, 0x00, 0xe6, 0xe7, 0x04, 0xb1, 0xb3, 0x0c, - 0x25, 0x76, 0x96, 0x81, 0x9a, 0x50, 0xb2, 0xcc, 0x89, 0x69, 0x39, 0xc1, 0x4c, 0xf6, 0x4f, 0x96, - 0xd1, 0x4d, 0x28, 0x9b, 0x67, 0xa6, 0x33, 0x32, 0x0f, 0x47, 0x58, 0x76, 0x2f, 0x04, 0x50, 0x59, - 0x85, 0xde, 0xf8, 0x7c, 0xcb, 0xb3, 0xf9, 0x26, 0xb6, 0x32, 0x36, 0xe1, 0xd0, 0x9b, 0x80, 0x88, - 0x08, 0x15, 0x88, 0x6b, 0x4e, 0x04, 0x61, 0x81, 0x11, 0xaa, 0x02, 0x33, 0x70, 0xcd, 0x09, 0xa7, - 0x7e, 0x1b, 0x36, 0x7d, 0x6c, 0x61, 0xe7, 0x2c, 0x41, 0x5f, 0x64, 0xf4, 0x28, 0xc4, 0xcd, 0x6b, - 0xdc, 0x02, 0x98, 0xdb, 0x12, 0xdb, 0x00, 0x6b, 0x7a, 0x39, 0x34, 0x23, 0xe1, 0xac, 0x8e, 0x66, - 0x09, 0x7e, 0x25, 0x46, 0xb7, 0x21, 0x51, 0x73, 0x76, 0x5b, 0xb0, 0xe6, 0x10, 0xe3, 0x70, 0x4a, - 0x66, 0x6c, 0xab, 0x2b, 0xe9, 0x45, 0x87, 0x6c, 0x4f, 0xc9, 0x8c, 0x5a, 0xc1, 0x94, 0x60, 0x3b, - 0x1a, 0x34, 0x94, 0x28, 0x80, 0x45, 0x0b, 0x0b, 0xc1, 0x4d, 0x25, 0x25, 0xb8, 0x49, 0x46, 0x2f, - 0xd5, 0xc5, 0xe8, 0x25, 0x1e, 0xff, 0xd4, 0x92, 0xf1, 0x4f, 0x2c, 0xb8, 0xa9, 0x27, 0x82, 0x9b, - 0x68, 0xc4, 0xb2, 0xfe, 0x02, 0x11, 0xcb, 0x5b, 0x00, 0xa1, 0x8f, 0x4f, 0xa3, 0x82, 0x88, 0x67, - 0x3c, 0x9f, 0x4e, 0x7a, 0x59, 0xba, 0xfd, 0x04, 0xbd, 0x07, 0x35, 0x66, 0xea, 0x8e, 0x67, 0xf8, - 0x26, 0xb5, 0xba, 0x8d, 0x25, 0x75, 0x2a, 0x94, 0xac, 0xe7, 0xe9, 0x94, 0x08, 0x7d, 0x03, 0xea, - 0xb4, 0xc3, 0x78, 0x5e, 0x0d, 0x2d, 0xa9, 0xc6, 0xcc, 0x17, 0xcb, 0x7a, 0xef, 0x42, 0xd5, 0x9b, - 0x18, 0x23, 0x33, 0xc0, 0xae, 0xe5, 0x60, 0xd2, 0xb8, 0xb2, 0xac, 0x31, 0x6f, 0xb2, 0x2b, 0x89, - 0xd0, 0xd7, 0x01, 0xd8, 0x52, 0xcd, 0x67, 0xdb, 0xa6, 0x58, 0xdf, 0x62, 0x71, 0xac, 0xce, 0x72, - 0x68, 0x7c, 0x4e, 0x24, 0x66, 0xe7, 0xd5, 0x17, 0x98, 0x9d, 0xd4, 0xdc, 0x46, 0xde, 0xb9, 0x41, - 0x2c, 0xcf, 0xc7, 0x8d, 0x6b, 0x7c, 0x84, 0x28, 0x64, 0x40, 0x01, 0xd4, 0xda, 0x6d, 0x73, 0x6c, - 0x1e, 0x63, 0x5b, 0xec, 0x2b, 0x84, 0xce, 0xb7, 0x2d, 0xb6, 0x6b, 0xa8, 0x02, 0x23, 0xb2, 0xc7, - 0x3d, 0x9b, 0xee, 0x40, 0x0e, 0x31, 0x98, 0x11, 0x72, 0x93, 0x6b, 0xf0, 0xfc, 0xbd, 0x43, 0x5a, - 0x14, 0xc6, 0xec, 0xee, 0xe7, 0xa1, 0x4e, 0xc4, 0x39, 0xa9, 0x10, 0xf3, 0x3a, 0xeb, 0x96, 0x18, - 0x5c, 0x79, 0x86, 0xca, 0xba, 0x56, 0x23, 0x91, 0x12, 0xa1, 0x51, 0x3d, 0x93, 0x35, 0xf0, 0xb1, - 0x6b, 0x37, 0x9a, 0xd1, 0xbb, 0x04, 0x83, 0x91, 0x77, 0x3e, 0xa4, 0x60, 0x2e, 0x3c, 0xfb, 0xd4, - 0xfe, 0x50, 0x81, 0x72, 0x88, 0x60, 0x09, 0x45, 0x73, 0x4a, 0xb0, 0xc1, 0x17, 0x4f, 0xba, 0x66, - 0x28, 0x3a, 0x30, 0xd0, 0x33, 0x76, 0x3d, 0xe6, 0x16, 0xf0, 0x12, 0x1b, 0x56, 0xb6, 0x70, 0x28, - 0x7a, 0x99, 0x41, 0xe8, 0x08, 0xf2, 0xb5, 0x81, 0x4c, 0x47, 0x81, 0x60, 0xb0, 0xca, 0x08, 0x2a, - 0x1c, 0xc6, 0x39, 0xdc, 0x01, 0x51, 0xe4, 0x2c, 0xf2, 0xbc, 0x09, 0x0e, 0xa2, 0x3c, 0xb4, 0x1f, - 0x2b, 0x50, 0x8d, 0xf6, 0xf0, 0xe2, 0x85, 0xfa, 0x11, 0x5c, 0x3d, 0xc6, 0x2e, 0xa6, 0xbc, 0x0c, - 0x7b, 0xea, 0x8b, 0x50, 0x1a, 0x5b, 0x62, 0x51, 0xbb, 0x22, 0x91, 0x1d, 0x81, 0x1b, 0x60, 0x0b, - 0x3d, 0x80, 0x0d, 0xba, 0x08, 0xc5, 0xe9, 0xf9, 0x3a, 0xb7, 0x4e, 0x11, 0x51, 0xda, 0x37, 0x01, - 0x05, 0x5e, 0x60, 0x8e, 0xe2, 0xc4, 0xdc, 0xe7, 0x57, 0x19, 0x26, 0x4a, 0xfd, 0x1a, 0xf0, 0x50, - 0x81, 0xee, 0xa0, 0x7c, 0xd5, 0xe0, 0x2b, 0x79, 0x2d, 0x84, 0xd2, 0xa5, 0x83, 0x76, 0x11, 0x98, - 0x43, 0xcf, 0xb6, 0x5a, 0xf4, 0x8b, 0x00, 0xfc, 0x92, 0x5d, 0x40, 0x35, 0xc2, 0x37, 0xd7, 0x5b, - 0x0f, 0xe3, 0xf7, 0xee, 0x74, 0xf3, 0x28, 0xd8, 0xf5, 0x2c, 0x73, 0x44, 0x55, 0x82, 0xf5, 0x32, - 0xc5, 0xb2, 0x4f, 0xb4, 0x1d, 0xae, 0xc7, 0xbc, 0x3e, 0x77, 0x96, 0xee, 0x24, 0xeb, 0x33, 0x92, - 0x08, 0x07, 0xb1, 0x60, 0x73, 0x1e, 0xaf, 0xc3, 0xba, 0x43, 0x8c, 0x23, 0xcf, 0xb7, 0x70, 0x34, - 0x1e, 0x2a, 0xe9, 0x35, 0x87, 0x3c, 0xa6, 0xd0, 0x5d, 0xe9, 0x48, 0xa8, 0x27, 0x26, 0x31, 0x2c, - 0x6f, 0x3c, 0x76, 0x02, 0x83, 0xc7, 0x1f, 0x79, 0x46, 0x58, 0x3f, 0x31, 0x49, 0x9b, 0x81, 0x59, - 0x08, 0xa2, 0x3d, 0x83, 0x8a, 0x38, 0x32, 0x66, 0x5d, 0x7c, 0x17, 0xaa, 0x6c, 0x92, 0xfa, 0xac, - 0x98, 0x08, 0xca, 0xe7, 0xaa, 0xd0, 0x2b, 0x93, 0xf0, 0x9b, 0x25, 0x4d, 0x48, 0x80, 0xa5, 0x03, - 0xc0, 0xbe, 0xb5, 0xff, 0x51, 0xe0, 0x2a, 0x63, 0xfc, 0x45, 0x53, 0x69, 0xe2, 0x88, 0x3d, 0x77, - 0xe1, 0x11, 0x3b, 0x0b, 0xa1, 0xd8, 0x0e, 0xca, 0x05, 0x17, 0xbe, 0xf3, 0x46, 0x84, 0x5c, 0x0a, - 0x4e, 0x22, 0xbd, 0xfd, 0x04, 0x90, 0xed, 0x1b, 0xe6, 0x34, 0xf0, 0xc8, 0xcc, 0xb5, 0x64, 0x66, - 0x87, 0x3b, 0x02, 0x6f, 0xa4, 0x65, 0x76, 0x18, 0xa7, 0x8e, 0xde, 0x9a, 0x06, 0xde, 0x60, 0xe6, - 0x5a, 0x22, 0xaf, 0xa3, 0xda, 0x7e, 0x4b, 0xf0, 0x10, 0x67, 0xde, 0x36, 0xa0, 0x0e, 0x1e, 0x7b, - 0x01, 0x7e, 0x6c, 0x3a, 0x23, 0x6c, 0x3f, 0xf3, 0x02, 0xec, 0x93, 0x8b, 0x27, 0xc8, 0x3b, 0x50, - 0x3b, 0x62, 0xc4, 0xc6, 0x19, 0xa3, 0x4e, 0xcd, 0x58, 0x54, 0x8f, 0x22, 0xfc, 0xb4, 0x43, 0xa8, - 0x44, 0x07, 0xfd, 0x5e, 0xc8, 0x41, 0x9c, 0x55, 0x2b, 0x6c, 0x69, 0x13, 0x75, 0xf8, 0xf9, 0x37, - 0xdd, 0x73, 0x31, 0xdd, 0x65, 0x62, 0x46, 0x24, 0x7d, 0xe7, 0x0d, 0x86, 0x8a, 0xf0, 0x24, 0xda, - 0xf7, 0x72, 0x50, 0x15, 0x77, 0x40, 0x66, 0xfd, 0x91, 0xe9, 0x52, 0x1f, 0xd5, 0xf2, 0x31, 0xdb, - 0x2c, 0x94, 0x74, 0x1f, 0x55, 0xa0, 0xd1, 0x9b, 0xb0, 0x36, 0x9d, 0xd8, 0x8c, 0x32, 0xd5, 0x9b, - 0xdd, 0xce, 0x35, 0x14, 0x5d, 0x92, 0xa0, 0xdb, 0x00, 0xe1, 0xd1, 0x7e, 0x18, 0x7e, 0xcd, 0x21, - 0xe8, 0x11, 0xac, 0xd9, 0x4c, 0xa5, 0x32, 0x07, 0x2a, 0x62, 0xd5, 0x45, 0x3d, 0xeb, 0x92, 0x90, - 0x5a, 0x45, 0x6c, 0xae, 0x14, 0xa2, 0x56, 0x11, 0xe9, 0xa6, 0x5e, 0x39, 0x8a, 0xe8, 0x51, 0x9a, - 0x73, 0x31, 0x62, 0xce, 0xef, 0x43, 0xad, 0x75, 0x6e, 0x9e, 0x62, 0x79, 0xbc, 0x48, 0xdd, 0x64, - 0xf3, 0xd0, 0xf5, 0xfc, 0xb1, 0x39, 0x8a, 0xab, 0xbb, 0x2e, 0xc1, 0xe2, 0x02, 0xc2, 0x4f, 0x72, - 0x70, 0x2d, 0x39, 0x11, 0x7e, 0x7a, 0x6e, 0x67, 0xd0, 0x7e, 0xc8, 0x6b, 0x88, 0xf2, 0xc0, 0x88, - 0xdf, 0xd7, 0xab, 0x0b, 0xb0, 0x3c, 0x31, 0xfa, 0x00, 0xb6, 0x7c, 0xfc, 0xd9, 0xd4, 0xf1, 0xb1, - 0x61, 0xe3, 0x80, 0xdb, 0x99, 0x98, 0x6c, 0x6c, 0x65, 0x61, 0xa3, 0x79, 0x55, 0x90, 0x74, 0x04, - 0x85, 0x98, 0x67, 0x3f, 0x47, 0xbd, 0x13, 0x6e, 0x43, 0xc6, 0x64, 0x64, 0xba, 0x62, 0x20, 0xd0, - 0xdc, 0x61, 0x90, 0xe6, 0xa5, 0x57, 0xfd, 0xa8, 0xb1, 0x7d, 0x00, 0x75, 0x93, 0xa9, 0x5d, 0xee, - 0xd8, 0x22, 0xdd, 0x22, 0xd6, 0x8c, 0xd8, 0x90, 0xe8, 0x35, 0x33, 0x5a, 0xd4, 0xbe, 0x9f, 0x83, - 0xcd, 0x81, 0x65, 0x06, 0x01, 0x5d, 0xa8, 0x32, 0x5f, 0xc8, 0xb8, 0xb3, 0x70, 0xc4, 0xcf, 0x3a, - 0x3a, 0x9f, 0xb7, 0x2f, 0x78, 0xfb, 0x2e, 0x92, 0xec, 0xcf, 0x5f, 0x90, 0xec, 0xdf, 0x84, 0xc2, - 0xb1, 0xef, 0x4d, 0x27, 0x4c, 0x43, 0x65, 0x9d, 0x17, 0xe6, 0xb7, 0x42, 0x98, 0xc7, 0x52, 0x64, - 0x76, 0x26, 0xc4, 0xa2, 0xae, 0x0a, 0xdb, 0xaa, 0x03, 0x7f, 0x66, 0xf0, 0xb3, 0x7e, 0x9e, 0x9a, - 0x07, 0x06, 0xda, 0xa5, 0x10, 0xed, 0x0c, 0xae, 0x26, 0x34, 0x91, 0xc9, 0x02, 0xdf, 0x82, 0x2b, - 0x47, 0x8e, 0xeb, 0x90, 0x13, 0x6c, 0x1b, 0x13, 0xec, 0x5b, 0xd8, 0x0d, 0xe4, 0x75, 0xd2, 0xbc, - 0x8e, 0x24, 0xaa, 0x1f, 0x62, 0xb4, 0x0e, 0x3b, 0x68, 0xda, 0x69, 0x0f, 0xcc, 0x23, 0xdc, 0xf7, - 0x1c, 0x37, 0xd3, 0x1e, 0xa0, 0x61, 0x76, 0xce, 0x14, 0xe3, 0x92, 0x49, 0x7c, 0xea, 0x1e, 0x9a, - 0x47, 0xd8, 0x98, 0x50, 0x1e, 0x42, 0xea, 0x32, 0x91, 0x4c, 0xb5, 0x23, 0x68, 0x3c, 0x65, 0x6b, - 0xd1, 0x17, 0x94, 0xf7, 0xb2, 0x76, 0x3c, 0xb8, 0x9e, 0xd2, 0x4e, 0xa6, 0x1e, 0xbd, 0x0a, 0x75, - 0x17, 0x9f, 0x1b, 0x0b, 0xad, 0x55, 0x5d, 0x7c, 0x1e, 0xf2, 0xd6, 0x7e, 0xa4, 0xc0, 0x1d, 0xde, - 0xa2, 0x38, 0x4c, 0xfb, 0x32, 0x3a, 0xc8, 0x39, 0xc9, 0x49, 0x51, 0xd5, 0xcb, 0x02, 0xd2, 0xb3, - 0x69, 0x94, 0x3f, 0x1c, 0xee, 0xb2, 0xe9, 0xb0, 0xaa, 0xd3, 0xcf, 0x84, 0x46, 0xf2, 0x49, 0x8d, - 0xfc, 0xad, 0x02, 0x77, 0x97, 0x0b, 0x98, 0x79, 0xac, 0x5f, 0x4a, 0xc4, 0x57, 0xa1, 0x3e, 0x76, - 0x5c, 0x63, 0x41, 0xcc, 0xea, 0xd8, 0x71, 0xe7, 0xaa, 0xfc, 0x23, 0x05, 0x40, 0x0f, 0xfd, 0xb1, - 0xc5, 0xd0, 0x52, 0xb9, 0xf4, 0xdc, 0x2c, 0x77, 0xd9, 0xb9, 0xd9, 0xea, 0x25, 0xe7, 0x66, 0xf9, - 0x78, 0x68, 0xa9, 0xfd, 0x9e, 0x02, 0x1b, 0xd4, 0x17, 0xf9, 0x02, 0x6b, 0xdc, 0xab, 0x50, 0xe4, - 0x87, 0xe5, 0xa9, 0x07, 0xc7, 0x02, 0xc7, 0xd2, 0x77, 0x2c, 0x98, 0x77, 0x5c, 0x1b, 0x3f, 0x17, - 0x72, 0xf2, 0xf8, 0xbe, 0x47, 0x21, 0xda, 0xbb, 0xdc, 0x59, 0x26, 0x3c, 0xc0, 0x79, 0x4d, 0x9e, - 0xbc, 0x28, 0xe9, 0x27, 0x96, 0xe2, 0xf0, 0xe5, 0x6b, 0x50, 0xe0, 0x67, 0x90, 0x5a, 0x9c, 0x3e, - 0xf5, 0xa4, 0xe6, 0x77, 0x56, 0x01, 0x45, 0xfb, 0x9a, 0xc9, 0x34, 0x5e, 0x38, 0xc9, 0x76, 0x69, - 0x8f, 0xa9, 0xb7, 0x1c, 0x71, 0xe9, 0xa5, 0x63, 0xa2, 0x46, 0xef, 0xf5, 0xb0, 0xd8, 0x2f, 0xe2, - 0xc3, 0xd3, 0xe0, 0xb9, 0x2e, 0x2a, 0xc5, 0xef, 0x0c, 0xc4, 0x7b, 0x5c, 0xe3, 0x34, 0xc2, 0x0d, - 0x8b, 0x5e, 0x70, 0x2b, 0x0a, 0x7d, 0x2e, 0xb9, 0xe0, 0x86, 0xde, 0x8a, 0x9d, 0x17, 0xab, 0x49, - 0x07, 0x9e, 0x2c, 0x1c, 0x18, 0xbf, 0x9d, 0x3c, 0x30, 0xe6, 0xb9, 0x83, 0x4a, 0xa4, 0x4e, 0xe2, - 0xae, 0xd5, 0xaf, 0xb2, 0xeb, 0x1b, 0x07, 0x13, 0x1a, 0xb1, 0x79, 0xfe, 0x97, 0x7e, 0x75, 0x4e, - 0xfb, 0x47, 0x85, 0xdd, 0x19, 0x9d, 0x37, 0x90, 0x69, 0xa0, 0x2f, 0xbc, 0x9d, 0x87, 0x20, 0x6f, - 0x63, 0xc2, 0xc3, 0xc9, 0xaa, 0xce, 0xbe, 0x29, 0xfb, 0x48, 0x08, 0x50, 0x97, 0xec, 0xa5, 0x18, - 0xc2, 0x89, 0x12, 0x34, 0xec, 0x2c, 0xcf, 0x71, 0xe5, 0xb3, 0x11, 0xf6, 0xcd, 0x0e, 0x2b, 0xa8, - 0x81, 0xee, 0x99, 0xcf, 0x87, 0x83, 0xac, 0xc9, 0xf4, 0xb1, 0xf9, 0xdc, 0x08, 0x23, 0x9e, 0x85, - 0xf7, 0x05, 0x85, 0xb1, 0xf9, 0x7c, 0xc8, 0x73, 0x1d, 0xa7, 0xce, 0xc4, 0xb0, 0x4e, 0xb0, 0x75, - 0x2a, 0x82, 0xc0, 0x32, 0x85, 0xb0, 0x63, 0x47, 0xed, 0x8f, 0xc5, 0xaa, 0x20, 0x04, 0xc9, 0x7a, - 0x17, 0x8e, 0x8a, 0x32, 0xa2, 0xb1, 0xe8, 0x05, 0x02, 0xc1, 0xd8, 0x7c, 0xce, 0xe2, 0x55, 0x21, - 0xd5, 0xcc, 0xb5, 0xb0, 0x6d, 0xd8, 0x96, 0xbc, 0x06, 0x55, 0xe6, 0x90, 0x8e, 0x45, 0xb4, 0xdf, - 0x52, 0xe0, 0x4a, 0xe4, 0x3c, 0x8b, 0x64, 0xde, 0x7d, 0xd8, 0x31, 0x42, 0xe4, 0x24, 0xb5, 0xcc, - 0x20, 0x2c, 0xff, 0x9a, 0x70, 0x86, 0x56, 0x17, 0x9c, 0xa1, 0x3f, 0x51, 0x60, 0x33, 0x2e, 0xc4, - 0xff, 0x8b, 0x33, 0x94, 0x70, 0xe2, 0x56, 0x13, 0x4e, 0x9c, 0xf6, 0x97, 0x0a, 0xdc, 0x62, 0x62, - 0xb5, 0x5c, 0x3b, 0xe6, 0xac, 0x7d, 0x25, 0x5a, 0x0a, 0xfd, 0xcc, 0xd5, 0xa8, 0x9f, 0x99, 0xd0, - 0x5d, 0x7e, 0x41, 0x77, 0xff, 0xa5, 0xc0, 0xed, 0x65, 0x42, 0x66, 0xd2, 0xe2, 0x07, 0x70, 0x9d, - 0x8b, 0xb9, 0x5c, 0x97, 0x5b, 0x8c, 0xe0, 0xf1, 0xa2, 0x42, 0x3f, 0x84, 0x1b, 0x84, 0xcb, 0x90, - 0x5a, 0x9b, 0x8f, 0xfc, 0x75, 0x41, 0xf2, 0xf8, 0xb2, 0x01, 0xc9, 0x27, 0x07, 0xe4, 0x84, 0xdd, - 0x9f, 0xec, 0xb4, 0xe5, 0xbd, 0xb7, 0xe8, 0x45, 0xa9, 0x97, 0x0c, 0x21, 0x62, 0x17, 0xea, 0x72, - 0x0b, 0x17, 0xea, 0x7e, 0x5f, 0x81, 0xeb, 0x29, 0x4d, 0x65, 0x7d, 0x6e, 0xc1, 0x1f, 0x41, 0xb1, - 0x76, 0x0a, 0xba, 0x28, 0x45, 0xd6, 0x95, 0xd5, 0x8b, 0xd6, 0x15, 0xed, 0x9f, 0x72, 0x00, 0xf3, - 0xf4, 0x2a, 0xaa, 0x43, 0x6e, 0xa7, 0x2d, 0xdc, 0x9a, 0xdc, 0x4e, 0x9b, 0x3a, 0x4e, 0x3b, 0x58, - 0xba, 0x99, 0xf4, 0x93, 0x2e, 0x83, 0x03, 0xcb, 0x94, 0x7e, 0x0b, 0xfb, 0x46, 0x77, 0xa1, 0xd2, - 0xf6, 0x26, 0xbe, 0x67, 0x61, 0x42, 0x3c, 0x5f, 0xd8, 0x51, 0x14, 0x44, 0xc5, 0xec, 0xe0, 0x11, - 0x0e, 0x64, 0xe2, 0x4d, 0x94, 0x68, 0x4d, 0xfe, 0xa5, 0x9b, 0xee, 0x31, 0x16, 0x21, 0x78, 0x14, - 0x44, 0x25, 0xe8, 0x4f, 0x65, 0x90, 0x43, 0x3f, 0x51, 0x13, 0x4a, 0x7d, 0x1f, 0xb3, 0x04, 0xb5, - 0xb8, 0x75, 0x14, 0x96, 0xd1, 0x37, 0xe0, 0x5a, 0xcb, 0x62, 0x21, 0x69, 0x1f, 0x13, 0xe2, 0x8c, - 0x1d, 0x12, 0x38, 0x54, 0xf1, 0xa7, 0xe2, 0xfe, 0xd1, 0x12, 0x2c, 0x95, 0x8f, 0x67, 0xc9, 0xc4, - 0x71, 0x82, 0x28, 0xd1, 0xb6, 0x74, 0x6f, 0x34, 0x3a, 0x34, 0xad, 0x53, 0x71, 0x8e, 0x10, 0x96, - 0xb5, 0xbf, 0x51, 0x60, 0x53, 0x1c, 0xca, 0x89, 0x3d, 0x39, 0x8b, 0xb5, 0x24, 0xaf, 0x25, 0xe4, - 0x5e, 0xf0, 0x5a, 0x42, 0xc4, 0x43, 0x58, 0xbd, 0xf8, 0x0a, 0xbc, 0xd6, 0x85, 0xab, 0x09, 0x39, - 0xb3, 0x9e, 0x1e, 0x37, 0x39, 0x9f, 0x3d, 0x87, 0x3a, 0x63, 0xde, 0xe8, 0x0c, 0xdb, 0x43, 0xf2, - 0x25, 0xbf, 0xe6, 0x41, 0xaf, 0xc3, 0x3a, 0xf5, 0xcc, 0x7d, 0xd1, 0x80, 0x34, 0xe1, 0xbc, 0x5e, - 0x1b, 0x47, 0x9b, 0xd5, 0x9e, 0xc0, 0x8d, 0x54, 0x69, 0x32, 0xf5, 0xed, 0x04, 0x6e, 0x0c, 0x70, - 0xd0, 0x7d, 0x1e, 0x60, 0xdf, 0x35, 0x47, 0xf3, 0x59, 0x92, 0xa5, 0x6f, 0x37, 0xa3, 0xaf, 0x06, - 0x85, 0xff, 0x3f, 0x7f, 0x24, 0xb8, 0x0b, 0x37, 0xd3, 0x5b, 0xca, 0x24, 0xf7, 0xc7, 0x70, 0x63, - 0xe7, 0x4b, 0x92, 0x5b, 0xfb, 0x0e, 0xdc, 0xdc, 0xf9, 0xd2, 0x24, 0xbb, 0x58, 0x0b, 0x0f, 0xee, - 0x42, 0x39, 0x7c, 0x99, 0x8b, 0xd6, 0x60, 0xb5, 0xff, 0x74, 0xa8, 0xae, 0x20, 0x80, 0x62, 0xa7, - 0xbb, 0xdb, 0x1d, 0x76, 0x55, 0xe5, 0xc1, 0xf7, 0x72, 0x50, 0x0e, 0xdf, 0xb4, 0xa2, 0x22, 0xe4, - 0x0e, 0x9e, 0xa8, 0x2b, 0xa8, 0x02, 0x6b, 0x4f, 0xf7, 0x9f, 0xec, 0x1f, 0x7c, 0xb2, 0xaf, 0x2a, - 0x68, 0x13, 0xd4, 0xfd, 0x83, 0xa1, 0xb1, 0x7d, 0x70, 0x30, 0x1c, 0x0c, 0xf5, 0x56, 0xbf, 0xdf, - 0xed, 0xa8, 0x39, 0x74, 0x05, 0xd6, 0x07, 0xc3, 0x03, 0xbd, 0x6b, 0x0c, 0x0f, 0xf6, 0xb6, 0x07, - 0xc3, 0x83, 0xfd, 0xae, 0xba, 0x8a, 0x1a, 0xb0, 0xd9, 0xda, 0xd5, 0xbb, 0xad, 0xce, 0xa7, 0x71, - 0xf2, 0x3c, 0xc5, 0xf4, 0xf6, 0xdb, 0x07, 0x7b, 0xfd, 0xd6, 0xb0, 0xb7, 0xbd, 0xdb, 0x35, 0x9e, - 0x75, 0xf5, 0x41, 0xef, 0x60, 0x5f, 0x2d, 0x50, 0xf6, 0x7a, 0x77, 0xa7, 0x77, 0xb0, 0x6f, 0xd0, - 0x56, 0x1e, 0x1f, 0x3c, 0xdd, 0xef, 0xa8, 0x45, 0x74, 0x03, 0xb6, 0x76, 0x76, 0x0f, 0xb6, 0x5b, - 0xbb, 0x46, 0xfb, 0x60, 0xff, 0x71, 0x6f, 0x27, 0x82, 0x5c, 0xa3, 0x55, 0x3a, 0x4f, 0xfb, 0xbb, - 0xbd, 0x76, 0x6b, 0xd8, 0xed, 0x18, 0xdd, 0xfd, 0xa1, 0xfe, 0xa9, 0x5a, 0xa2, 0x12, 0xb1, 0xcf, - 0x08, 0x69, 0x19, 0x6d, 0x40, 0xad, 0xb7, 0xff, 0xac, 0xb5, 0xdb, 0xeb, 0x18, 0xcf, 0x5a, 0xbb, - 0x4f, 0xbb, 0x2a, 0x20, 0x04, 0xf5, 0x4e, 0x6b, 0xd8, 0x32, 0x98, 0x34, 0xed, 0x61, 0xb7, 0xa3, - 0x56, 0x1e, 0x3c, 0x86, 0x4a, 0xe4, 0x4a, 0x2c, 0x6d, 0x40, 0xf4, 0xdf, 0x18, 0x3c, 0x6b, 0x1b, - 0x7b, 0x07, 0x9d, 0xae, 0xba, 0x82, 0xd6, 0xa1, 0xd2, 0xef, 0xcc, 0x01, 0x0a, 0x52, 0xa1, 0xda, - 0xea, 0xf7, 0xe6, 0x90, 0xdc, 0x83, 0xf7, 0xa0, 0x12, 0xb9, 0xa0, 0x86, 0x4a, 0x90, 0x1f, 0xb4, - 0x5b, 0xfb, 0xbc, 0x6e, 0xab, 0xdf, 0xd7, 0x0f, 0xbe, 0xd5, 0xdb, 0x6b, 0x51, 0xc5, 0xd3, 0x41, - 0x78, 0x3a, 0xe8, 0x3e, 0xe9, 0x7e, 0xaa, 0xe6, 0x1e, 0xf4, 0xa1, 0x1e, 0xf7, 0x86, 0xe9, 0x00, - 0x0c, 0x9e, 0xb6, 0xdb, 0xdd, 0xc1, 0x80, 0x8f, 0xc6, 0xb0, 0xb7, 0xd7, 0x3d, 0x78, 0x3a, 0xe4, - 0xf5, 0xda, 0xad, 0xfd, 0x76, 0x77, 0x57, 0xcd, 0x51, 0x84, 0xde, 0xed, 0xef, 0xb6, 0xda, 0x54, - 0xf7, 0xb4, 0xf0, 0x74, 0x7f, 0xbf, 0xb7, 0xbf, 0xa3, 0xe6, 0x1f, 0xfc, 0xbd, 0x02, 0x65, 0xb6, - 0xdf, 0x3c, 0x71, 0x5c, 0x9b, 0xd6, 0x39, 0x08, 0x4e, 0xb0, 0x4f, 0xd4, 0x15, 0x3a, 0xc4, 0x3b, - 0x6d, 0x55, 0xa1, 0xd6, 0xb0, 0x83, 0x03, 0x35, 0xc7, 0x64, 0xb4, 0x4c, 0x57, 0x5d, 0xa5, 0x32, - 0x46, 0x36, 0x13, 0x35, 0xcf, 0x0c, 0x85, 0xed, 0x11, 0x6a, 0x81, 0x22, 0x23, 0xfb, 0x85, 0x5a, - 0x64, 0xe6, 0x34, 0x0d, 0xd4, 0x35, 0x54, 0x9d, 0x6f, 0x14, 0x6a, 0x09, 0x35, 0x97, 0x6d, 0x0d, - 0x6a, 0x99, 0xc9, 0xce, 0x16, 0x7c, 0x15, 0x68, 0x2d, 0xb9, 0xc4, 0xab, 0x95, 0x47, 0xff, 0xbd, - 0x05, 0xb9, 0x7e, 0x07, 0xed, 0x41, 0x3d, 0x7e, 0xf7, 0x19, 0xdd, 0x08, 0xaf, 0x7c, 0x2f, 0x5e, - 0xac, 0x6e, 0xde, 0x4c, 0x47, 0xf2, 0x89, 0xa2, 0xad, 0xa0, 0x16, 0xc0, 0xfc, 0xae, 0x38, 0xda, - 0x5a, 0xbc, 0x3d, 0xce, 0xd9, 0x34, 0x96, 0x5d, 0x2b, 0xd7, 0x56, 0xd0, 0xdb, 0xb0, 0x3a, 0x24, - 0x1e, 0x12, 0x91, 0xde, 0xfc, 0x41, 0x77, 0x73, 0x23, 0x02, 0x91, 0xd4, 0xf7, 0x95, 0xb7, 0x15, - 0xf4, 0x21, 0x94, 0xc3, 0xd7, 0xb2, 0x48, 0xbc, 0xe4, 0x4f, 0x3e, 0x57, 0x6e, 0x6e, 0x2d, 0xc0, - 0xc3, 0x16, 0xf7, 0xa0, 0x1e, 0x7f, 0x6f, 0x2b, 0x75, 0x90, 0xfa, 0x96, 0x57, 0xea, 0x20, 0xfd, - 0x89, 0xae, 0xb6, 0x82, 0xde, 0x87, 0x35, 0xf1, 0x26, 0x16, 0x89, 0x95, 0x24, 0xfe, 0xc2, 0xb6, - 0x79, 0x35, 0x01, 0x0d, 0x6b, 0x1a, 0xb0, 0x99, 0xf6, 0x60, 0x15, 0xbd, 0x22, 0x5b, 0x5c, 0xfa, - 0x30, 0xb6, 0xa9, 0x5d, 0x44, 0x12, 0x36, 0xf0, 0x0b, 0x50, 0x92, 0xef, 0x49, 0xd1, 0xd5, 0x70, - 0x0c, 0xa2, 0x0f, 0x3a, 0x9b, 0xd7, 0x92, 0xe0, 0x68, 0x65, 0xf9, 0x2e, 0x53, 0x56, 0x4e, 0xbc, - 0x06, 0x95, 0x95, 0x93, 0xcf, 0x37, 0xb5, 0x15, 0xb4, 0x03, 0xd5, 0xe8, 0xf3, 0x45, 0x74, 0x3d, - 0x6c, 0x26, 0xf9, 0xa0, 0xb2, 0xd9, 0x4c, 0x43, 0x45, 0x07, 0x2b, 0x7e, 0x0a, 0x21, 0x07, 0x2b, - 0xf5, 0x90, 0x4e, 0x0e, 0x56, 0xfa, 0xc1, 0x85, 0xb6, 0x82, 0x86, 0xb0, 0x9e, 0xb8, 0x14, 0x8a, - 0x6e, 0x46, 0xd3, 0x1e, 0x0b, 0x0c, 0x6f, 0x2d, 0xc1, 0x26, 0x2d, 0x32, 0x7c, 0x94, 0x87, 0xe6, - 0x1a, 0x8d, 0xa5, 0xb6, 0x9a, 0x5b, 0x0b, 0xf0, 0x50, 0xaa, 0x6d, 0xa8, 0xed, 0xe0, 0xa0, 0xef, - 0xe3, 0xb3, 0xec, 0x3c, 0x1e, 0x33, 0x1e, 0xf3, 0x87, 0x81, 0xa8, 0x99, 0xa0, 0x8d, 0xbc, 0x16, - 0xbc, 0x88, 0x4f, 0x07, 0x2a, 0x91, 0xe7, 0x68, 0x48, 0x4c, 0xdd, 0xc5, 0xd7, 0x7e, 0xcd, 0xeb, - 0x29, 0x98, 0x90, 0xcb, 0x87, 0x50, 0x92, 0x97, 0x1f, 0xa5, 0xf1, 0x24, 0x6e, 0x5d, 0x4a, 0xe3, - 0x49, 0xde, 0x91, 0xd4, 0x56, 0xbf, 0x9f, 0x53, 0xd0, 0x0e, 0x54, 0x22, 0xd7, 0x04, 0xa5, 0x14, - 0x8b, 0xd7, 0x18, 0xa5, 0x14, 0x29, 0x77, 0x0a, 0x39, 0xa3, 0x8f, 0xa1, 0x16, 0xbb, 0x4a, 0x27, - 0xd5, 0x92, 0x76, 0x7d, 0xb0, 0x79, 0x23, 0x15, 0x17, 0x76, 0x6a, 0x00, 0x6a, 0xf2, 0xf2, 0x1a, - 0xba, 0x15, 0x6d, 0x7f, 0x91, 0xe3, 0xed, 0x65, 0xe8, 0x28, 0xd3, 0xe4, 0x73, 0x37, 0xc9, 0x74, - 0xc9, 0x73, 0x3a, 0xc9, 0x74, 0xd9, 0x2b, 0x39, 0xce, 0x34, 0xf9, 0xb6, 0x4c, 0x32, 0x5d, 0xf2, - 0xcc, 0x4d, 0x32, 0x5d, 0xf6, 0x24, 0x4d, 0x5b, 0xa1, 0xaa, 0x8c, 0xc5, 0xce, 0x52, 0x95, 0x69, - 0x87, 0x55, 0x52, 0x95, 0xa9, 0xc7, 0x37, 0x7c, 0x5a, 0xc7, 0xcf, 0x46, 0x22, 0xfb, 0xd0, 0x62, - 0x9a, 0x3f, 0xb2, 0x0f, 0xa5, 0xa4, 0xd8, 0xb5, 0x15, 0xf4, 0x0c, 0x36, 0x16, 0xce, 0x26, 0x90, - 0xe8, 0xd1, 0xb2, 0xc3, 0x91, 0xe6, 0x9d, 0xa5, 0xf8, 0x90, 0xef, 0xa9, 0x3c, 0x5b, 0x59, 0x4c, - 0xf0, 0xa3, 0xd7, 0xa2, 0xd5, 0x97, 0x9e, 0x50, 0x34, 0x5f, 0xbf, 0x8c, 0x2c, 0x32, 0x83, 0x2b, - 0xf3, 0x24, 0x71, 0xb8, 0x9b, 0x2e, 0xe4, 0xc8, 0xe5, 0x6e, 0xba, 0x98, 0x50, 0x16, 0xab, 0x51, - 0x07, 0x2a, 0x91, 0x24, 0x24, 0x9a, 0x6f, 0xbe, 0x89, 0xc4, 0x67, 0xf3, 0x7a, 0x0a, 0x26, 0x32, - 0x83, 0xcb, 0x61, 0x22, 0x4e, 0xae, 0x47, 0xc9, 0x14, 0x61, 0x73, 0x6b, 0x01, 0x1e, 0xdd, 0x01, - 0xa2, 0xd9, 0x2a, 0xb9, 0x03, 0xa4, 0xa4, 0xd1, 0xe4, 0x0e, 0x90, 0x96, 0xdc, 0xd2, 0x56, 0x10, - 0x86, 0x6b, 0xe9, 0xa9, 0x1b, 0x74, 0x2f, 0x52, 0x6f, 0x59, 0xf6, 0xa9, 0xf9, 0xea, 0xc5, 0x44, - 0x51, 0x13, 0x5a, 0xc8, 0x65, 0xa0, 0xf9, 0x4c, 0x4b, 0xcd, 0xa7, 0x48, 0x13, 0x5a, 0x9a, 0x04, - 0xe1, 0x7c, 0x17, 0xfe, 0x27, 0x49, 0xf2, 0x5d, 0xf6, 0x7f, 0x4d, 0x92, 0xef, 0xd2, 0x3f, 0x58, - 0xe2, 0x53, 0x3c, 0xf9, 0x6f, 0x47, 0x72, 0x8a, 0x2f, 0xf9, 0x5f, 0x25, 0x39, 0xc5, 0x97, 0xfd, - 0x49, 0x92, 0xb6, 0x82, 0xbe, 0x05, 0x1b, 0x0b, 0x7f, 0x6e, 0x25, 0x85, 0x5d, 0xf6, 0x7f, 0x5a, - 0x52, 0xd8, 0xa5, 0xff, 0x8a, 0xa5, 0xad, 0xbc, 0xad, 0xa0, 0x5d, 0xa8, 0xc5, 0x62, 0x77, 0xb9, - 0x78, 0xa4, 0x25, 0x1e, 0xe4, 0xe2, 0x91, 0x1a, 0xec, 0x53, 0x23, 0x47, 0xdf, 0x96, 0xb7, 0xc8, - 0xa3, 0x31, 0xf3, 0x00, 0xdd, 0x8d, 0xd6, 0x4b, 0x0b, 0xee, 0x9b, 0xaf, 0x5c, 0x40, 0x11, 0xf5, - 0xcb, 0xd2, 0x42, 0x5b, 0xe9, 0x97, 0x5d, 0x10, 0x60, 0x4b, 0xbf, 0xec, 0xa2, 0xc8, 0x98, 0x37, - 0xb0, 0x73, 0x41, 0x03, 0x3b, 0x97, 0x37, 0xb0, 0x73, 0x61, 0x03, 0xdb, 0xaf, 0xff, 0xfb, 0xdf, - 0x95, 0x94, 0x7f, 0xfd, 0xfc, 0xb6, 0xf2, 0x6f, 0x9f, 0xdf, 0x56, 0x7e, 0xfc, 0xf9, 0x6d, 0xe5, - 0x2f, 0xfe, 0xf3, 0xf6, 0x0a, 0xa8, 0x9e, 0x7f, 0xfc, 0x30, 0x70, 0x4e, 0xcf, 0x1e, 0x9e, 0x9e, - 0xb1, 0xbf, 0x49, 0x3b, 0x2c, 0xb2, 0x9f, 0x77, 0xff, 0x2f, 0x00, 0x00, 0xff, 0xff, 0x30, 0x32, - 0x94, 0xae, 0xb4, 0x4d, 0x00, 0x00, +func (m *ReportMinResolvedTsRequest) GetHeader() *RequestHeader { + if m != nil { + return m.Header + } + return nil } -// Reference imports to suppress errors if they are not otherwise used. -var _ context.Context -var _ grpc.ClientConn - -// This is a compile-time assertion to ensure that this generated file -// is compatible with the grpc package it is being compiled against. -const _ = grpc.SupportPackageIsVersion4 - -// PDClient is the client API for PD service. -// -// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. -type PDClient interface { - // GetClusterInfo get the information of this cluster. It does not require - // the cluster_id in request matchs the id of this cluster. - GetClusterInfo(ctx context.Context, in *GetClusterInfoRequest, opts ...grpc.CallOption) (*GetClusterInfoResponse, error) - // GetMembers get the member list of this cluster. It does not require - // the cluster_id in request matchs the id of this cluster. - GetMembers(ctx context.Context, in *GetMembersRequest, opts ...grpc.CallOption) (*GetMembersResponse, error) - Tso(ctx context.Context, opts ...grpc.CallOption) (PD_TsoClient, error) - Bootstrap(ctx context.Context, in *BootstrapRequest, opts ...grpc.CallOption) (*BootstrapResponse, error) - IsBootstrapped(ctx context.Context, in *IsBootstrappedRequest, opts ...grpc.CallOption) (*IsBootstrappedResponse, error) - AllocID(ctx context.Context, in *AllocIDRequest, opts ...grpc.CallOption) (*AllocIDResponse, error) - IsSnapshotRecovering(ctx context.Context, in *IsSnapshotRecoveringRequest, opts ...grpc.CallOption) (*IsSnapshotRecoveringResponse, error) - GetStore(ctx context.Context, in *GetStoreRequest, opts ...grpc.CallOption) (*GetStoreResponse, error) - PutStore(ctx context.Context, in *PutStoreRequest, opts ...grpc.CallOption) (*PutStoreResponse, error) - GetAllStores(ctx context.Context, in *GetAllStoresRequest, opts ...grpc.CallOption) (*GetAllStoresResponse, error) - StoreHeartbeat(ctx context.Context, in *StoreHeartbeatRequest, opts ...grpc.CallOption) (*StoreHeartbeatResponse, error) - RegionHeartbeat(ctx context.Context, opts ...grpc.CallOption) (PD_RegionHeartbeatClient, error) - GetRegion(ctx context.Context, in *GetRegionRequest, opts ...grpc.CallOption) (*GetRegionResponse, error) - GetPrevRegion(ctx context.Context, in *GetRegionRequest, opts ...grpc.CallOption) (*GetRegionResponse, error) - GetRegionByID(ctx context.Context, in *GetRegionByIDRequest, opts ...grpc.CallOption) (*GetRegionResponse, error) - ScanRegions(ctx context.Context, in *ScanRegionsRequest, opts ...grpc.CallOption) (*ScanRegionsResponse, error) - AskSplit(ctx context.Context, in *AskSplitRequest, opts ...grpc.CallOption) (*AskSplitResponse, error) - ReportSplit(ctx context.Context, in *ReportSplitRequest, opts ...grpc.CallOption) (*ReportSplitResponse, error) - AskBatchSplit(ctx context.Context, in *AskBatchSplitRequest, opts ...grpc.CallOption) (*AskBatchSplitResponse, error) - ReportBatchSplit(ctx context.Context, in *ReportBatchSplitRequest, opts ...grpc.CallOption) (*ReportBatchSplitResponse, error) - GetClusterConfig(ctx context.Context, in *GetClusterConfigRequest, opts ...grpc.CallOption) (*GetClusterConfigResponse, error) - PutClusterConfig(ctx context.Context, in *PutClusterConfigRequest, opts ...grpc.CallOption) (*PutClusterConfigResponse, error) - ScatterRegion(ctx context.Context, in *ScatterRegionRequest, opts ...grpc.CallOption) (*ScatterRegionResponse, error) - GetGCSafePoint(ctx context.Context, in *GetGCSafePointRequest, opts ...grpc.CallOption) (*GetGCSafePointResponse, error) - UpdateGCSafePoint(ctx context.Context, in *UpdateGCSafePointRequest, opts ...grpc.CallOption) (*UpdateGCSafePointResponse, error) - UpdateServiceGCSafePoint(ctx context.Context, in *UpdateServiceGCSafePointRequest, opts ...grpc.CallOption) (*UpdateServiceGCSafePointResponse, error) - SyncRegions(ctx context.Context, opts ...grpc.CallOption) (PD_SyncRegionsClient, error) - GetOperator(ctx context.Context, in *GetOperatorRequest, opts ...grpc.CallOption) (*GetOperatorResponse, error) - SyncMaxTS(ctx context.Context, in *SyncMaxTSRequest, opts ...grpc.CallOption) (*SyncMaxTSResponse, error) - SplitRegions(ctx context.Context, in *SplitRegionsRequest, opts ...grpc.CallOption) (*SplitRegionsResponse, error) - SplitAndScatterRegions(ctx context.Context, in *SplitAndScatterRegionsRequest, opts ...grpc.CallOption) (*SplitAndScatterRegionsResponse, error) - GetDCLocationInfo(ctx context.Context, in *GetDCLocationInfoRequest, opts ...grpc.CallOption) (*GetDCLocationInfoResponse, error) - StoreGlobalConfig(ctx context.Context, in *StoreGlobalConfigRequest, opts ...grpc.CallOption) (*StoreGlobalConfigResponse, error) - LoadGlobalConfig(ctx context.Context, in *LoadGlobalConfigRequest, opts ...grpc.CallOption) (*LoadGlobalConfigResponse, error) - WatchGlobalConfig(ctx context.Context, in *WatchGlobalConfigRequest, opts ...grpc.CallOption) (PD_WatchGlobalConfigClient, error) - ReportBuckets(ctx context.Context, opts ...grpc.CallOption) (PD_ReportBucketsClient, error) - ReportMinResolvedTS(ctx context.Context, in *ReportMinResolvedTsRequest, opts ...grpc.CallOption) (*ReportMinResolvedTsResponse, error) - SetExternalTimestamp(ctx context.Context, in *SetExternalTimestampRequest, opts ...grpc.CallOption) (*SetExternalTimestampResponse, error) - GetExternalTimestamp(ctx context.Context, in *GetExternalTimestampRequest, opts ...grpc.CallOption) (*GetExternalTimestampResponse, error) +func (m *ReportMinResolvedTsRequest) GetStoreId() uint64 { + if m != nil { + return m.StoreId + } + return 0 } -type pDClient struct { - cc *grpc.ClientConn +func (m *ReportMinResolvedTsRequest) GetMinResolvedTs() uint64 { + if m != nil { + return m.MinResolvedTs + } + return 0 } -func NewPDClient(cc *grpc.ClientConn) PDClient { - return &pDClient{cc} +type ReportMinResolvedTsResponse struct { + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } -func (c *pDClient) GetClusterInfo(ctx context.Context, in *GetClusterInfoRequest, opts ...grpc.CallOption) (*GetClusterInfoResponse, error) { - out := new(GetClusterInfoResponse) - err := c.cc.Invoke(ctx, "/pdpb.PD/GetClusterInfo", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil +func (m *ReportMinResolvedTsResponse) Reset() { *m = ReportMinResolvedTsResponse{} } +func (m *ReportMinResolvedTsResponse) String() string { return proto.CompactTextString(m) } +func (*ReportMinResolvedTsResponse) ProtoMessage() {} +func (*ReportMinResolvedTsResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_78b27e6f04f44c6e, []int{111} } - -func (c *pDClient) GetMembers(ctx context.Context, in *GetMembersRequest, opts ...grpc.CallOption) (*GetMembersResponse, error) { - out := new(GetMembersResponse) - err := c.cc.Invoke(ctx, "/pdpb.PD/GetMembers", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil +func (m *ReportMinResolvedTsResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) } - -func (c *pDClient) Tso(ctx context.Context, opts ...grpc.CallOption) (PD_TsoClient, error) { - stream, err := c.cc.NewStream(ctx, &_PD_serviceDesc.Streams[0], "/pdpb.PD/Tso", opts...) - if err != nil { - return nil, err +func (m *ReportMinResolvedTsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ReportMinResolvedTsResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - x := &pDTsoClient{stream} - return x, nil } - -type PD_TsoClient interface { - Send(*TsoRequest) error - Recv() (*TsoResponse, error) - grpc.ClientStream +func (m *ReportMinResolvedTsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ReportMinResolvedTsResponse.Merge(m, src) } - -type pDTsoClient struct { - grpc.ClientStream +func (m *ReportMinResolvedTsResponse) XXX_Size() int { + return m.Size() } - -func (x *pDTsoClient) Send(m *TsoRequest) error { - return x.ClientStream.SendMsg(m) +func (m *ReportMinResolvedTsResponse) XXX_DiscardUnknown() { + xxx_messageInfo_ReportMinResolvedTsResponse.DiscardUnknown(m) } -func (x *pDTsoClient) Recv() (*TsoResponse, error) { - m := new(TsoResponse) - if err := x.ClientStream.RecvMsg(m); err != nil { - return nil, err - } - return m, nil -} +var xxx_messageInfo_ReportMinResolvedTsResponse proto.InternalMessageInfo -func (c *pDClient) Bootstrap(ctx context.Context, in *BootstrapRequest, opts ...grpc.CallOption) (*BootstrapResponse, error) { - out := new(BootstrapResponse) - err := c.cc.Invoke(ctx, "/pdpb.PD/Bootstrap", in, out, opts...) - if err != nil { - return nil, err +func (m *ReportMinResolvedTsResponse) GetHeader() *ResponseHeader { + if m != nil { + return m.Header } - return out, nil + return nil } -func (c *pDClient) IsBootstrapped(ctx context.Context, in *IsBootstrappedRequest, opts ...grpc.CallOption) (*IsBootstrappedResponse, error) { - out := new(IsBootstrappedResponse) - err := c.cc.Invoke(ctx, "/pdpb.PD/IsBootstrapped", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil +type SetExternalTimestampRequest struct { + Header *RequestHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"` + Timestamp uint64 `protobuf:"varint,2,opt,name=timestamp,proto3" json:"timestamp,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } -func (c *pDClient) AllocID(ctx context.Context, in *AllocIDRequest, opts ...grpc.CallOption) (*AllocIDResponse, error) { - out := new(AllocIDResponse) - err := c.cc.Invoke(ctx, "/pdpb.PD/AllocID", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil +func (m *SetExternalTimestampRequest) Reset() { *m = SetExternalTimestampRequest{} } +func (m *SetExternalTimestampRequest) String() string { return proto.CompactTextString(m) } +func (*SetExternalTimestampRequest) ProtoMessage() {} +func (*SetExternalTimestampRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_78b27e6f04f44c6e, []int{112} } - -func (c *pDClient) IsSnapshotRecovering(ctx context.Context, in *IsSnapshotRecoveringRequest, opts ...grpc.CallOption) (*IsSnapshotRecoveringResponse, error) { - out := new(IsSnapshotRecoveringResponse) - err := c.cc.Invoke(ctx, "/pdpb.PD/IsSnapshotRecovering", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil +func (m *SetExternalTimestampRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) } - -func (c *pDClient) GetStore(ctx context.Context, in *GetStoreRequest, opts ...grpc.CallOption) (*GetStoreResponse, error) { - out := new(GetStoreResponse) - err := c.cc.Invoke(ctx, "/pdpb.PD/GetStore", in, out, opts...) - if err != nil { - return nil, err +func (m *SetExternalTimestampRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_SetExternalTimestampRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - return out, nil } - -func (c *pDClient) PutStore(ctx context.Context, in *PutStoreRequest, opts ...grpc.CallOption) (*PutStoreResponse, error) { - out := new(PutStoreResponse) - err := c.cc.Invoke(ctx, "/pdpb.PD/PutStore", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil +func (m *SetExternalTimestampRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_SetExternalTimestampRequest.Merge(m, src) } - -func (c *pDClient) GetAllStores(ctx context.Context, in *GetAllStoresRequest, opts ...grpc.CallOption) (*GetAllStoresResponse, error) { - out := new(GetAllStoresResponse) - err := c.cc.Invoke(ctx, "/pdpb.PD/GetAllStores", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil +func (m *SetExternalTimestampRequest) XXX_Size() int { + return m.Size() +} +func (m *SetExternalTimestampRequest) XXX_DiscardUnknown() { + xxx_messageInfo_SetExternalTimestampRequest.DiscardUnknown(m) } -func (c *pDClient) StoreHeartbeat(ctx context.Context, in *StoreHeartbeatRequest, opts ...grpc.CallOption) (*StoreHeartbeatResponse, error) { - out := new(StoreHeartbeatResponse) - err := c.cc.Invoke(ctx, "/pdpb.PD/StoreHeartbeat", in, out, opts...) - if err != nil { - return nil, err +var xxx_messageInfo_SetExternalTimestampRequest proto.InternalMessageInfo + +func (m *SetExternalTimestampRequest) GetHeader() *RequestHeader { + if m != nil { + return m.Header } - return out, nil + return nil } -func (c *pDClient) RegionHeartbeat(ctx context.Context, opts ...grpc.CallOption) (PD_RegionHeartbeatClient, error) { - stream, err := c.cc.NewStream(ctx, &_PD_serviceDesc.Streams[1], "/pdpb.PD/RegionHeartbeat", opts...) - if err != nil { - return nil, err +func (m *SetExternalTimestampRequest) GetTimestamp() uint64 { + if m != nil { + return m.Timestamp } - x := &pDRegionHeartbeatClient{stream} - return x, nil + return 0 } -type PD_RegionHeartbeatClient interface { - Send(*RegionHeartbeatRequest) error - Recv() (*RegionHeartbeatResponse, error) - grpc.ClientStream +type SetExternalTimestampResponse struct { + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } -type pDRegionHeartbeatClient struct { - grpc.ClientStream +func (m *SetExternalTimestampResponse) Reset() { *m = SetExternalTimestampResponse{} } +func (m *SetExternalTimestampResponse) String() string { return proto.CompactTextString(m) } +func (*SetExternalTimestampResponse) ProtoMessage() {} +func (*SetExternalTimestampResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_78b27e6f04f44c6e, []int{113} } - -func (x *pDRegionHeartbeatClient) Send(m *RegionHeartbeatRequest) error { - return x.ClientStream.SendMsg(m) +func (m *SetExternalTimestampResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) } - -func (x *pDRegionHeartbeatClient) Recv() (*RegionHeartbeatResponse, error) { - m := new(RegionHeartbeatResponse) - if err := x.ClientStream.RecvMsg(m); err != nil { - return nil, err +func (m *SetExternalTimestampResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_SetExternalTimestampResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - return m, nil } - -func (c *pDClient) GetRegion(ctx context.Context, in *GetRegionRequest, opts ...grpc.CallOption) (*GetRegionResponse, error) { - out := new(GetRegionResponse) - err := c.cc.Invoke(ctx, "/pdpb.PD/GetRegion", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil +func (m *SetExternalTimestampResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_SetExternalTimestampResponse.Merge(m, src) } - -func (c *pDClient) GetPrevRegion(ctx context.Context, in *GetRegionRequest, opts ...grpc.CallOption) (*GetRegionResponse, error) { - out := new(GetRegionResponse) - err := c.cc.Invoke(ctx, "/pdpb.PD/GetPrevRegion", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil +func (m *SetExternalTimestampResponse) XXX_Size() int { + return m.Size() } - -func (c *pDClient) GetRegionByID(ctx context.Context, in *GetRegionByIDRequest, opts ...grpc.CallOption) (*GetRegionResponse, error) { - out := new(GetRegionResponse) - err := c.cc.Invoke(ctx, "/pdpb.PD/GetRegionByID", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil +func (m *SetExternalTimestampResponse) XXX_DiscardUnknown() { + xxx_messageInfo_SetExternalTimestampResponse.DiscardUnknown(m) } -func (c *pDClient) ScanRegions(ctx context.Context, in *ScanRegionsRequest, opts ...grpc.CallOption) (*ScanRegionsResponse, error) { - out := new(ScanRegionsResponse) - err := c.cc.Invoke(ctx, "/pdpb.PD/ScanRegions", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil -} +var xxx_messageInfo_SetExternalTimestampResponse proto.InternalMessageInfo -// Deprecated: Do not use. -func (c *pDClient) AskSplit(ctx context.Context, in *AskSplitRequest, opts ...grpc.CallOption) (*AskSplitResponse, error) { - out := new(AskSplitResponse) - err := c.cc.Invoke(ctx, "/pdpb.PD/AskSplit", in, out, opts...) - if err != nil { - return nil, err +func (m *SetExternalTimestampResponse) GetHeader() *ResponseHeader { + if m != nil { + return m.Header } - return out, nil + return nil } -// Deprecated: Do not use. -func (c *pDClient) ReportSplit(ctx context.Context, in *ReportSplitRequest, opts ...grpc.CallOption) (*ReportSplitResponse, error) { - out := new(ReportSplitResponse) - err := c.cc.Invoke(ctx, "/pdpb.PD/ReportSplit", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil +type GetExternalTimestampRequest struct { + Header *RequestHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } -func (c *pDClient) AskBatchSplit(ctx context.Context, in *AskBatchSplitRequest, opts ...grpc.CallOption) (*AskBatchSplitResponse, error) { - out := new(AskBatchSplitResponse) - err := c.cc.Invoke(ctx, "/pdpb.PD/AskBatchSplit", in, out, opts...) - if err != nil { - return nil, err +func (m *GetExternalTimestampRequest) Reset() { *m = GetExternalTimestampRequest{} } +func (m *GetExternalTimestampRequest) String() string { return proto.CompactTextString(m) } +func (*GetExternalTimestampRequest) ProtoMessage() {} +func (*GetExternalTimestampRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_78b27e6f04f44c6e, []int{114} +} +func (m *GetExternalTimestampRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GetExternalTimestampRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GetExternalTimestampRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - return out, nil +} +func (m *GetExternalTimestampRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetExternalTimestampRequest.Merge(m, src) +} +func (m *GetExternalTimestampRequest) XXX_Size() int { + return m.Size() +} +func (m *GetExternalTimestampRequest) XXX_DiscardUnknown() { + xxx_messageInfo_GetExternalTimestampRequest.DiscardUnknown(m) } -func (c *pDClient) ReportBatchSplit(ctx context.Context, in *ReportBatchSplitRequest, opts ...grpc.CallOption) (*ReportBatchSplitResponse, error) { - out := new(ReportBatchSplitResponse) - err := c.cc.Invoke(ctx, "/pdpb.PD/ReportBatchSplit", in, out, opts...) - if err != nil { - return nil, err +var xxx_messageInfo_GetExternalTimestampRequest proto.InternalMessageInfo + +func (m *GetExternalTimestampRequest) GetHeader() *RequestHeader { + if m != nil { + return m.Header } - return out, nil + return nil } -func (c *pDClient) GetClusterConfig(ctx context.Context, in *GetClusterConfigRequest, opts ...grpc.CallOption) (*GetClusterConfigResponse, error) { - out := new(GetClusterConfigResponse) - err := c.cc.Invoke(ctx, "/pdpb.PD/GetClusterConfig", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil -} - -func (c *pDClient) PutClusterConfig(ctx context.Context, in *PutClusterConfigRequest, opts ...grpc.CallOption) (*PutClusterConfigResponse, error) { - out := new(PutClusterConfigResponse) - err := c.cc.Invoke(ctx, "/pdpb.PD/PutClusterConfig", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil -} - -func (c *pDClient) ScatterRegion(ctx context.Context, in *ScatterRegionRequest, opts ...grpc.CallOption) (*ScatterRegionResponse, error) { - out := new(ScatterRegionResponse) - err := c.cc.Invoke(ctx, "/pdpb.PD/ScatterRegion", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil +type GetExternalTimestampResponse struct { + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"` + Timestamp uint64 `protobuf:"varint,2,opt,name=timestamp,proto3" json:"timestamp,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } -func (c *pDClient) GetGCSafePoint(ctx context.Context, in *GetGCSafePointRequest, opts ...grpc.CallOption) (*GetGCSafePointResponse, error) { - out := new(GetGCSafePointResponse) - err := c.cc.Invoke(ctx, "/pdpb.PD/GetGCSafePoint", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil +func (m *GetExternalTimestampResponse) Reset() { *m = GetExternalTimestampResponse{} } +func (m *GetExternalTimestampResponse) String() string { return proto.CompactTextString(m) } +func (*GetExternalTimestampResponse) ProtoMessage() {} +func (*GetExternalTimestampResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_78b27e6f04f44c6e, []int{115} } - -func (c *pDClient) UpdateGCSafePoint(ctx context.Context, in *UpdateGCSafePointRequest, opts ...grpc.CallOption) (*UpdateGCSafePointResponse, error) { - out := new(UpdateGCSafePointResponse) - err := c.cc.Invoke(ctx, "/pdpb.PD/UpdateGCSafePoint", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil +func (m *GetExternalTimestampResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) } - -func (c *pDClient) UpdateServiceGCSafePoint(ctx context.Context, in *UpdateServiceGCSafePointRequest, opts ...grpc.CallOption) (*UpdateServiceGCSafePointResponse, error) { - out := new(UpdateServiceGCSafePointResponse) - err := c.cc.Invoke(ctx, "/pdpb.PD/UpdateServiceGCSafePoint", in, out, opts...) - if err != nil { - return nil, err +func (m *GetExternalTimestampResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GetExternalTimestampResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - return out, nil } - -func (c *pDClient) SyncRegions(ctx context.Context, opts ...grpc.CallOption) (PD_SyncRegionsClient, error) { - stream, err := c.cc.NewStream(ctx, &_PD_serviceDesc.Streams[2], "/pdpb.PD/SyncRegions", opts...) - if err != nil { - return nil, err - } - x := &pDSyncRegionsClient{stream} - return x, nil +func (m *GetExternalTimestampResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetExternalTimestampResponse.Merge(m, src) } - -type PD_SyncRegionsClient interface { - Send(*SyncRegionRequest) error - Recv() (*SyncRegionResponse, error) - grpc.ClientStream +func (m *GetExternalTimestampResponse) XXX_Size() int { + return m.Size() } - -type pDSyncRegionsClient struct { - grpc.ClientStream +func (m *GetExternalTimestampResponse) XXX_DiscardUnknown() { + xxx_messageInfo_GetExternalTimestampResponse.DiscardUnknown(m) } -func (x *pDSyncRegionsClient) Send(m *SyncRegionRequest) error { - return x.ClientStream.SendMsg(m) -} +var xxx_messageInfo_GetExternalTimestampResponse proto.InternalMessageInfo -func (x *pDSyncRegionsClient) Recv() (*SyncRegionResponse, error) { - m := new(SyncRegionResponse) - if err := x.ClientStream.RecvMsg(m); err != nil { - return nil, err +func (m *GetExternalTimestampResponse) GetHeader() *ResponseHeader { + if m != nil { + return m.Header } - return m, nil + return nil } -func (c *pDClient) GetOperator(ctx context.Context, in *GetOperatorRequest, opts ...grpc.CallOption) (*GetOperatorResponse, error) { - out := new(GetOperatorResponse) - err := c.cc.Invoke(ctx, "/pdpb.PD/GetOperator", in, out, opts...) - if err != nil { - return nil, err +func (m *GetExternalTimestampResponse) GetTimestamp() uint64 { + if m != nil { + return m.Timestamp } - return out, nil + return 0 } -func (c *pDClient) SyncMaxTS(ctx context.Context, in *SyncMaxTSRequest, opts ...grpc.CallOption) (*SyncMaxTSResponse, error) { - out := new(SyncMaxTSResponse) - err := c.cc.Invoke(ctx, "/pdpb.PD/SyncMaxTS", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil +type GetMinTSRequest struct { + Header *RequestHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } -func (c *pDClient) SplitRegions(ctx context.Context, in *SplitRegionsRequest, opts ...grpc.CallOption) (*SplitRegionsResponse, error) { - out := new(SplitRegionsResponse) - err := c.cc.Invoke(ctx, "/pdpb.PD/SplitRegions", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil +func (m *GetMinTSRequest) Reset() { *m = GetMinTSRequest{} } +func (m *GetMinTSRequest) String() string { return proto.CompactTextString(m) } +func (*GetMinTSRequest) ProtoMessage() {} +func (*GetMinTSRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_78b27e6f04f44c6e, []int{116} } - -func (c *pDClient) SplitAndScatterRegions(ctx context.Context, in *SplitAndScatterRegionsRequest, opts ...grpc.CallOption) (*SplitAndScatterRegionsResponse, error) { - out := new(SplitAndScatterRegionsResponse) - err := c.cc.Invoke(ctx, "/pdpb.PD/SplitAndScatterRegions", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil +func (m *GetMinTSRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) } - -func (c *pDClient) GetDCLocationInfo(ctx context.Context, in *GetDCLocationInfoRequest, opts ...grpc.CallOption) (*GetDCLocationInfoResponse, error) { - out := new(GetDCLocationInfoResponse) - err := c.cc.Invoke(ctx, "/pdpb.PD/GetDCLocationInfo", in, out, opts...) - if err != nil { - return nil, err +func (m *GetMinTSRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GetMinTSRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - return out, nil } - -func (c *pDClient) StoreGlobalConfig(ctx context.Context, in *StoreGlobalConfigRequest, opts ...grpc.CallOption) (*StoreGlobalConfigResponse, error) { - out := new(StoreGlobalConfigResponse) - err := c.cc.Invoke(ctx, "/pdpb.PD/StoreGlobalConfig", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil +func (m *GetMinTSRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetMinTSRequest.Merge(m, src) } - -func (c *pDClient) LoadGlobalConfig(ctx context.Context, in *LoadGlobalConfigRequest, opts ...grpc.CallOption) (*LoadGlobalConfigResponse, error) { - out := new(LoadGlobalConfigResponse) - err := c.cc.Invoke(ctx, "/pdpb.PD/LoadGlobalConfig", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil +func (m *GetMinTSRequest) XXX_Size() int { + return m.Size() +} +func (m *GetMinTSRequest) XXX_DiscardUnknown() { + xxx_messageInfo_GetMinTSRequest.DiscardUnknown(m) } -func (c *pDClient) WatchGlobalConfig(ctx context.Context, in *WatchGlobalConfigRequest, opts ...grpc.CallOption) (PD_WatchGlobalConfigClient, error) { - stream, err := c.cc.NewStream(ctx, &_PD_serviceDesc.Streams[3], "/pdpb.PD/WatchGlobalConfig", opts...) - if err != nil { - return nil, err - } - x := &pDWatchGlobalConfigClient{stream} - if err := x.ClientStream.SendMsg(in); err != nil { - return nil, err - } - if err := x.ClientStream.CloseSend(); err != nil { - return nil, err +var xxx_messageInfo_GetMinTSRequest proto.InternalMessageInfo + +func (m *GetMinTSRequest) GetHeader() *RequestHeader { + if m != nil { + return m.Header } - return x, nil + return nil } -type PD_WatchGlobalConfigClient interface { - Recv() (*WatchGlobalConfigResponse, error) - grpc.ClientStream +type GetMinTSResponse struct { + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"` + Timestamp *Timestamp `protobuf:"bytes,2,opt,name=timestamp,proto3" json:"timestamp,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } -type pDWatchGlobalConfigClient struct { - grpc.ClientStream +func (m *GetMinTSResponse) Reset() { *m = GetMinTSResponse{} } +func (m *GetMinTSResponse) String() string { return proto.CompactTextString(m) } +func (*GetMinTSResponse) ProtoMessage() {} +func (*GetMinTSResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_78b27e6f04f44c6e, []int{117} } - -func (x *pDWatchGlobalConfigClient) Recv() (*WatchGlobalConfigResponse, error) { - m := new(WatchGlobalConfigResponse) - if err := x.ClientStream.RecvMsg(m); err != nil { - return nil, err - } - return m, nil +func (m *GetMinTSResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) } - -func (c *pDClient) ReportBuckets(ctx context.Context, opts ...grpc.CallOption) (PD_ReportBucketsClient, error) { - stream, err := c.cc.NewStream(ctx, &_PD_serviceDesc.Streams[4], "/pdpb.PD/ReportBuckets", opts...) - if err != nil { - return nil, err +func (m *GetMinTSResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GetMinTSResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - x := &pDReportBucketsClient{stream} - return x, nil } - -type PD_ReportBucketsClient interface { - Send(*ReportBucketsRequest) error - CloseAndRecv() (*ReportBucketsResponse, error) - grpc.ClientStream +func (m *GetMinTSResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetMinTSResponse.Merge(m, src) } - -type pDReportBucketsClient struct { - grpc.ClientStream +func (m *GetMinTSResponse) XXX_Size() int { + return m.Size() } - -func (x *pDReportBucketsClient) Send(m *ReportBucketsRequest) error { - return x.ClientStream.SendMsg(m) +func (m *GetMinTSResponse) XXX_DiscardUnknown() { + xxx_messageInfo_GetMinTSResponse.DiscardUnknown(m) } -func (x *pDReportBucketsClient) CloseAndRecv() (*ReportBucketsResponse, error) { - if err := x.ClientStream.CloseSend(); err != nil { - return nil, err - } - m := new(ReportBucketsResponse) - if err := x.ClientStream.RecvMsg(m); err != nil { - return nil, err +var xxx_messageInfo_GetMinTSResponse proto.InternalMessageInfo + +func (m *GetMinTSResponse) GetHeader() *ResponseHeader { + if m != nil { + return m.Header } - return m, nil + return nil } -func (c *pDClient) ReportMinResolvedTS(ctx context.Context, in *ReportMinResolvedTsRequest, opts ...grpc.CallOption) (*ReportMinResolvedTsResponse, error) { - out := new(ReportMinResolvedTsResponse) - err := c.cc.Invoke(ctx, "/pdpb.PD/ReportMinResolvedTS", in, out, opts...) - if err != nil { - return nil, err +func (m *GetMinTSResponse) GetTimestamp() *Timestamp { + if m != nil { + return m.Timestamp } - return out, nil + return nil } -func (c *pDClient) SetExternalTimestamp(ctx context.Context, in *SetExternalTimestampRequest, opts ...grpc.CallOption) (*SetExternalTimestampResponse, error) { - out := new(SetExternalTimestampResponse) - err := c.cc.Invoke(ctx, "/pdpb.PD/SetExternalTimestamp", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil +func init() { + proto.RegisterEnum("pdpb.EventType", EventType_name, EventType_value) + proto.RegisterEnum("pdpb.ErrorType", ErrorType_name, ErrorType_value) + proto.RegisterEnum("pdpb.ServiceMode", ServiceMode_name, ServiceMode_value) + proto.RegisterEnum("pdpb.CheckPolicy", CheckPolicy_name, CheckPolicy_value) + proto.RegisterEnum("pdpb.OperatorStatus", OperatorStatus_name, OperatorStatus_value) + proto.RegisterEnum("pdpb.QueryKind", QueryKind_name, QueryKind_value) + proto.RegisterType((*WatchGlobalConfigRequest)(nil), "pdpb.WatchGlobalConfigRequest") + proto.RegisterType((*WatchGlobalConfigResponse)(nil), "pdpb.WatchGlobalConfigResponse") + proto.RegisterType((*StoreGlobalConfigRequest)(nil), "pdpb.StoreGlobalConfigRequest") + proto.RegisterType((*StoreGlobalConfigResponse)(nil), "pdpb.StoreGlobalConfigResponse") + proto.RegisterType((*LoadGlobalConfigRequest)(nil), "pdpb.LoadGlobalConfigRequest") + proto.RegisterType((*LoadGlobalConfigResponse)(nil), "pdpb.LoadGlobalConfigResponse") + proto.RegisterType((*GlobalConfigItem)(nil), "pdpb.GlobalConfigItem") + proto.RegisterType((*RequestHeader)(nil), "pdpb.RequestHeader") + proto.RegisterType((*ResponseHeader)(nil), "pdpb.ResponseHeader") + proto.RegisterType((*Error)(nil), "pdpb.Error") + proto.RegisterType((*TsoRequest)(nil), "pdpb.TsoRequest") + proto.RegisterType((*Timestamp)(nil), "pdpb.Timestamp") + proto.RegisterType((*TsoResponse)(nil), "pdpb.TsoResponse") + proto.RegisterType((*BootstrapRequest)(nil), "pdpb.BootstrapRequest") + proto.RegisterType((*BootstrapResponse)(nil), "pdpb.BootstrapResponse") + proto.RegisterType((*IsBootstrappedRequest)(nil), "pdpb.IsBootstrappedRequest") + proto.RegisterType((*IsBootstrappedResponse)(nil), "pdpb.IsBootstrappedResponse") + proto.RegisterType((*AllocIDRequest)(nil), "pdpb.AllocIDRequest") + proto.RegisterType((*AllocIDResponse)(nil), "pdpb.AllocIDResponse") + proto.RegisterType((*IsSnapshotRecoveringRequest)(nil), "pdpb.IsSnapshotRecoveringRequest") + proto.RegisterType((*IsSnapshotRecoveringResponse)(nil), "pdpb.IsSnapshotRecoveringResponse") + proto.RegisterType((*GetStoreRequest)(nil), "pdpb.GetStoreRequest") + proto.RegisterType((*GetStoreResponse)(nil), "pdpb.GetStoreResponse") + proto.RegisterType((*PutStoreRequest)(nil), "pdpb.PutStoreRequest") + proto.RegisterType((*PutStoreResponse)(nil), "pdpb.PutStoreResponse") + proto.RegisterType((*GetAllStoresRequest)(nil), "pdpb.GetAllStoresRequest") + proto.RegisterType((*GetAllStoresResponse)(nil), "pdpb.GetAllStoresResponse") + proto.RegisterType((*GetRegionRequest)(nil), "pdpb.GetRegionRequest") + proto.RegisterType((*GetRegionResponse)(nil), "pdpb.GetRegionResponse") + proto.RegisterType((*GetRegionByIDRequest)(nil), "pdpb.GetRegionByIDRequest") + proto.RegisterType((*ScanRegionsRequest)(nil), "pdpb.ScanRegionsRequest") + proto.RegisterType((*Region)(nil), "pdpb.Region") + proto.RegisterType((*ScanRegionsResponse)(nil), "pdpb.ScanRegionsResponse") + proto.RegisterType((*GetClusterConfigRequest)(nil), "pdpb.GetClusterConfigRequest") + proto.RegisterType((*GetClusterConfigResponse)(nil), "pdpb.GetClusterConfigResponse") + proto.RegisterType((*PutClusterConfigRequest)(nil), "pdpb.PutClusterConfigRequest") + proto.RegisterType((*PutClusterConfigResponse)(nil), "pdpb.PutClusterConfigResponse") + proto.RegisterType((*Member)(nil), "pdpb.Member") + proto.RegisterType((*GetMembersRequest)(nil), "pdpb.GetMembersRequest") + proto.RegisterType((*GetMembersResponse)(nil), "pdpb.GetMembersResponse") + proto.RegisterMapType((map[string]*Member)(nil), "pdpb.GetMembersResponse.TsoAllocatorLeadersEntry") + proto.RegisterType((*GetClusterInfoRequest)(nil), "pdpb.GetClusterInfoRequest") + proto.RegisterType((*GetClusterInfoResponse)(nil), "pdpb.GetClusterInfoResponse") + proto.RegisterType((*PeerStats)(nil), "pdpb.PeerStats") + proto.RegisterType((*RegionHeartbeatRequest)(nil), "pdpb.RegionHeartbeatRequest") + proto.RegisterType((*ChangePeer)(nil), "pdpb.ChangePeer") + proto.RegisterType((*ChangePeerV2)(nil), "pdpb.ChangePeerV2") + proto.RegisterType((*TransferLeader)(nil), "pdpb.TransferLeader") + proto.RegisterType((*Merge)(nil), "pdpb.Merge") + proto.RegisterType((*SplitRegion)(nil), "pdpb.SplitRegion") + proto.RegisterType((*SwitchWitness)(nil), "pdpb.SwitchWitness") + proto.RegisterType((*BatchSwitchWitness)(nil), "pdpb.BatchSwitchWitness") + proto.RegisterType((*RegionHeartbeatResponse)(nil), "pdpb.RegionHeartbeatResponse") + proto.RegisterType((*AskSplitRequest)(nil), "pdpb.AskSplitRequest") + proto.RegisterType((*AskSplitResponse)(nil), "pdpb.AskSplitResponse") + proto.RegisterType((*ReportSplitRequest)(nil), "pdpb.ReportSplitRequest") + proto.RegisterType((*ReportSplitResponse)(nil), "pdpb.ReportSplitResponse") + proto.RegisterType((*AskBatchSplitRequest)(nil), "pdpb.AskBatchSplitRequest") + proto.RegisterType((*SplitID)(nil), "pdpb.SplitID") + proto.RegisterType((*AskBatchSplitResponse)(nil), "pdpb.AskBatchSplitResponse") + proto.RegisterType((*ReportBatchSplitRequest)(nil), "pdpb.ReportBatchSplitRequest") + proto.RegisterType((*ReportBatchSplitResponse)(nil), "pdpb.ReportBatchSplitResponse") + proto.RegisterType((*TimeInterval)(nil), "pdpb.TimeInterval") + proto.RegisterType((*RecordPair)(nil), "pdpb.RecordPair") + proto.RegisterType((*PeerStat)(nil), "pdpb.PeerStat") + proto.RegisterType((*StoreStats)(nil), "pdpb.StoreStats") + proto.RegisterType((*SlowTrend)(nil), "pdpb.SlowTrend") + proto.RegisterType((*SnapshotStat)(nil), "pdpb.SnapshotStat") + proto.RegisterType((*PeerReport)(nil), "pdpb.PeerReport") + proto.RegisterType((*StoreReport)(nil), "pdpb.StoreReport") + proto.RegisterType((*StoreHeartbeatRequest)(nil), "pdpb.StoreHeartbeatRequest") + proto.RegisterType((*DemoteFailedVoters)(nil), "pdpb.DemoteFailedVoters") + proto.RegisterType((*ForceLeader)(nil), "pdpb.ForceLeader") + proto.RegisterType((*RecoveryPlan)(nil), "pdpb.RecoveryPlan") + proto.RegisterType((*AwakenRegions)(nil), "pdpb.AwakenRegions") + proto.RegisterType((*StoreHeartbeatResponse)(nil), "pdpb.StoreHeartbeatResponse") + proto.RegisterType((*ScatterRegionRequest)(nil), "pdpb.ScatterRegionRequest") + proto.RegisterType((*ScatterRegionResponse)(nil), "pdpb.ScatterRegionResponse") + proto.RegisterType((*GetGCSafePointRequest)(nil), "pdpb.GetGCSafePointRequest") + proto.RegisterType((*GetGCSafePointResponse)(nil), "pdpb.GetGCSafePointResponse") + proto.RegisterType((*UpdateGCSafePointRequest)(nil), "pdpb.UpdateGCSafePointRequest") + proto.RegisterType((*UpdateGCSafePointResponse)(nil), "pdpb.UpdateGCSafePointResponse") + proto.RegisterType((*UpdateServiceGCSafePointRequest)(nil), "pdpb.UpdateServiceGCSafePointRequest") + proto.RegisterType((*UpdateServiceGCSafePointResponse)(nil), "pdpb.UpdateServiceGCSafePointResponse") + proto.RegisterType((*GetGCSafePointV2Request)(nil), "pdpb.GetGCSafePointV2Request") + proto.RegisterType((*GetGCSafePointV2Response)(nil), "pdpb.GetGCSafePointV2Response") + proto.RegisterType((*WatchGCSafePointV2Request)(nil), "pdpb.WatchGCSafePointV2Request") + proto.RegisterType((*SafePointEvent)(nil), "pdpb.SafePointEvent") + proto.RegisterType((*WatchGCSafePointV2Response)(nil), "pdpb.WatchGCSafePointV2Response") + proto.RegisterType((*UpdateGCSafePointV2Request)(nil), "pdpb.UpdateGCSafePointV2Request") + proto.RegisterType((*UpdateGCSafePointV2Response)(nil), "pdpb.UpdateGCSafePointV2Response") + proto.RegisterType((*UpdateServiceSafePointV2Request)(nil), "pdpb.UpdateServiceSafePointV2Request") + proto.RegisterType((*UpdateServiceSafePointV2Response)(nil), "pdpb.UpdateServiceSafePointV2Response") + proto.RegisterType((*RegionStat)(nil), "pdpb.RegionStat") + proto.RegisterType((*SyncRegionRequest)(nil), "pdpb.SyncRegionRequest") + proto.RegisterType((*PeersStats)(nil), "pdpb.PeersStats") + proto.RegisterType((*Peers)(nil), "pdpb.Peers") + proto.RegisterType((*SyncRegionResponse)(nil), "pdpb.SyncRegionResponse") + proto.RegisterType((*GetOperatorRequest)(nil), "pdpb.GetOperatorRequest") + proto.RegisterType((*GetOperatorResponse)(nil), "pdpb.GetOperatorResponse") + proto.RegisterType((*SyncMaxTSRequest)(nil), "pdpb.SyncMaxTSRequest") + proto.RegisterType((*SyncMaxTSResponse)(nil), "pdpb.SyncMaxTSResponse") + proto.RegisterType((*SplitRegionsRequest)(nil), "pdpb.SplitRegionsRequest") + proto.RegisterType((*SplitRegionsResponse)(nil), "pdpb.SplitRegionsResponse") + proto.RegisterType((*SplitAndScatterRegionsRequest)(nil), "pdpb.SplitAndScatterRegionsRequest") + proto.RegisterType((*SplitAndScatterRegionsResponse)(nil), "pdpb.SplitAndScatterRegionsResponse") + proto.RegisterType((*GetDCLocationInfoRequest)(nil), "pdpb.GetDCLocationInfoRequest") + proto.RegisterType((*GetDCLocationInfoResponse)(nil), "pdpb.GetDCLocationInfoResponse") + proto.RegisterType((*QueryStats)(nil), "pdpb.QueryStats") + proto.RegisterType((*ReportBucketsRequest)(nil), "pdpb.ReportBucketsRequest") + proto.RegisterType((*ReportBucketsResponse)(nil), "pdpb.ReportBucketsResponse") + proto.RegisterType((*ReportMinResolvedTsRequest)(nil), "pdpb.ReportMinResolvedTsRequest") + proto.RegisterType((*ReportMinResolvedTsResponse)(nil), "pdpb.ReportMinResolvedTsResponse") + proto.RegisterType((*SetExternalTimestampRequest)(nil), "pdpb.SetExternalTimestampRequest") + proto.RegisterType((*SetExternalTimestampResponse)(nil), "pdpb.SetExternalTimestampResponse") + proto.RegisterType((*GetExternalTimestampRequest)(nil), "pdpb.GetExternalTimestampRequest") + proto.RegisterType((*GetExternalTimestampResponse)(nil), "pdpb.GetExternalTimestampResponse") + proto.RegisterType((*GetMinTSRequest)(nil), "pdpb.GetMinTSRequest") + proto.RegisterType((*GetMinTSResponse)(nil), "pdpb.GetMinTSResponse") } -func (c *pDClient) GetExternalTimestamp(ctx context.Context, in *GetExternalTimestampRequest, opts ...grpc.CallOption) (*GetExternalTimestampResponse, error) { - out := new(GetExternalTimestampResponse) - err := c.cc.Invoke(ctx, "/pdpb.PD/GetExternalTimestamp", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil +func init() { proto.RegisterFile("pdpb.proto", fileDescriptor_78b27e6f04f44c6e) } + +var fileDescriptor_78b27e6f04f44c6e = []byte{ + // 5931 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x7c, 0x4b, 0x73, 0xe3, 0x48, + 0x72, 0xb0, 0xc0, 0x87, 0x44, 0x26, 0x1f, 0xa2, 0xaa, 0xd5, 0x2d, 0x36, 0xd5, 0x0f, 0x0d, 0x7a, + 0xa6, 0xbf, 0x9e, 0xde, 0x99, 0x9e, 0x19, 0xcd, 0x7c, 0xeb, 0xf1, 0xd8, 0x3b, 0x61, 0x4a, 0x64, + 0x6b, 0x38, 0xad, 0x07, 0x0d, 0xb2, 0x7b, 0x76, 0xec, 0x0d, 0x23, 0x20, 0xa0, 0x24, 0x61, 0x45, + 0x02, 0x1c, 0x14, 0x28, 0x35, 0x37, 0xec, 0x08, 0x3f, 0xd6, 0xf6, 0x6e, 0x78, 0x37, 0xec, 0x08, + 0xaf, 0x1f, 0xa7, 0x3d, 0xf8, 0x7d, 0x71, 0xf8, 0xe6, 0xb0, 0x4f, 0xbe, 0x39, 0x7c, 0xf4, 0xd1, + 0x27, 0xc7, 0xc6, 0xfa, 0xe4, 0x3f, 0xb0, 0x17, 0xfb, 0xe0, 0xa8, 0x17, 0x08, 0x80, 0xa0, 0xa4, + 0x46, 0x4f, 0x6f, 0xec, 0x89, 0x40, 0x66, 0x56, 0x56, 0x56, 0x56, 0x56, 0x56, 0x66, 0x56, 0x81, + 0x00, 0x23, 0x6b, 0x74, 0xf8, 0x68, 0xe4, 0xb9, 0xbe, 0x8b, 0x72, 0xf4, 0xb9, 0x51, 0x1e, 0x62, + 0xdf, 0x90, 0xb0, 0x46, 0x05, 0x7b, 0xc6, 0x91, 0x1f, 0xbc, 0x5e, 0xa3, 0x6f, 0x3a, 0xc1, 0xde, + 0x19, 0xf6, 0x02, 0x60, 0xdd, 0xc3, 0xa3, 0x81, 0x6d, 0x1a, 0xbe, 0xed, 0x3a, 0xfa, 0xd0, 0xb5, + 0x70, 0x80, 0x59, 0x3d, 0x76, 0x8f, 0x5d, 0xf6, 0xf8, 0x0e, 0x7d, 0x12, 0xd0, 0x65, 0x6f, 0x4c, + 0x7c, 0xf6, 0xc8, 0x01, 0xea, 0x67, 0x50, 0xff, 0xcc, 0xf0, 0xcd, 0x93, 0x9d, 0x81, 0x7b, 0x68, + 0x0c, 0xb6, 0x5d, 0xe7, 0xc8, 0x3e, 0xd6, 0xf0, 0x17, 0x63, 0x4c, 0x7c, 0x74, 0x17, 0x4a, 0x26, + 0x03, 0xe8, 0x23, 0xc3, 0x3f, 0xa9, 0x2b, 0x1b, 0xca, 0x83, 0xa2, 0x06, 0x1c, 0xd4, 0x35, 0xfc, + 0x13, 0xd4, 0x80, 0x82, 0x87, 0xcf, 0x6c, 0x62, 0xbb, 0x4e, 0x3d, 0xb3, 0xa1, 0x3c, 0xc8, 0x6a, + 0xc1, 0xbb, 0xfa, 0x67, 0x0a, 0xdc, 0x4c, 0xe0, 0x4c, 0x46, 0xae, 0x43, 0x30, 0x7a, 0x17, 0x96, + 0xcc, 0x13, 0xc3, 0x39, 0xc6, 0xa4, 0xae, 0x6c, 0x64, 0x1f, 0x94, 0x36, 0x6f, 0x3c, 0x62, 0xda, + 0x08, 0x13, 0x77, 0x7c, 0x3c, 0xd4, 0x24, 0xd9, 0x45, 0x7d, 0xa1, 0xb7, 0x60, 0xf1, 0x04, 0x1b, + 0x16, 0xf6, 0xea, 0xd9, 0x0d, 0xe5, 0x41, 0x69, 0x73, 0x95, 0x33, 0x93, 0xbd, 0x7d, 0xc2, 0x70, + 0x9a, 0xa0, 0x51, 0x87, 0x50, 0xef, 0xf9, 0xae, 0x87, 0x93, 0x86, 0xfc, 0xe2, 0x72, 0xc5, 0x94, + 0x94, 0x89, 0x2b, 0x49, 0xfd, 0x18, 0x6e, 0x26, 0x74, 0x27, 0xf4, 0xf0, 0x1a, 0xe4, 0xb1, 0xe7, + 0xb9, 0x1e, 0x53, 0x6e, 0x69, 0xb3, 0xc4, 0x7b, 0x6b, 0x53, 0x90, 0xc6, 0x31, 0x6a, 0x17, 0xd6, + 0x76, 0x5d, 0xc3, 0x4a, 0x92, 0x76, 0x15, 0xf2, 0x8e, 0x31, 0x14, 0xb2, 0x16, 0x35, 0xfe, 0x72, + 0xb9, 0x44, 0x16, 0xd4, 0x67, 0x39, 0x0a, 0x81, 0xde, 0x82, 0xbc, 0xed, 0xe3, 0xe1, 0x65, 0xc3, + 0xe7, 0x44, 0x17, 0x1a, 0xc0, 0x0f, 0x15, 0xa8, 0xc5, 0xdb, 0x21, 0x04, 0x39, 0x2a, 0xa4, 0xb0, + 0x25, 0xf6, 0x4c, 0x47, 0x71, 0x66, 0x0c, 0xc6, 0x58, 0x48, 0xca, 0x5f, 0xa6, 0x9a, 0xc9, 0xce, + 0xd3, 0x0c, 0xba, 0x07, 0xb9, 0x53, 0xdb, 0xb1, 0xea, 0xb9, 0x0d, 0xe5, 0x41, 0x75, 0x73, 0x59, + 0x50, 0x9c, 0x61, 0xc7, 0xef, 0x4f, 0x46, 0x58, 0x63, 0x48, 0x54, 0x87, 0xa5, 0x91, 0x31, 0x19, + 0xb8, 0x86, 0x55, 0xcf, 0x6f, 0x28, 0x0f, 0xca, 0x9a, 0x7c, 0x55, 0x9f, 0x40, 0x45, 0x28, 0x92, + 0x1b, 0x08, 0xba, 0x0d, 0x60, 0x0e, 0xc6, 0xc4, 0xc7, 0x9e, 0x6e, 0x5b, 0x4c, 0xc4, 0x9c, 0x56, + 0x14, 0x90, 0x8e, 0x85, 0xd6, 0xa1, 0x48, 0xb0, 0x63, 0x71, 0x6c, 0x86, 0x61, 0x0b, 0x1c, 0xd0, + 0xb1, 0x54, 0x0d, 0xaa, 0x51, 0x73, 0xbb, 0x8c, 0x5b, 0x30, 0xbe, 0xcc, 0xdc, 0x99, 0x7f, 0x0c, + 0xf9, 0xb6, 0x1c, 0xa8, 0x3f, 0x19, 0x71, 0xad, 0x4d, 0x07, 0x4a, 0x51, 0x7c, 0xa0, 0x14, 0x49, + 0x07, 0x3a, 0xc4, 0x84, 0x18, 0xc7, 0x52, 0x91, 0xf2, 0x55, 0x1d, 0x01, 0xf4, 0x89, 0x2b, 0x8d, + 0xe6, 0x2b, 0xc1, 0x62, 0xe1, 0x36, 0x77, 0x4d, 0x2e, 0x96, 0x90, 0x2a, 0xe4, 0x5a, 0xa1, 0x73, + 0x63, 0xba, 0x63, 0xc7, 0x67, 0x2c, 0x2b, 0x1a, 0x7f, 0xa1, 0x16, 0x66, 0x99, 0xfa, 0xc0, 0xe5, + 0x7e, 0x87, 0xcd, 0x50, 0x51, 0x03, 0xcb, 0xdc, 0x15, 0x10, 0xf5, 0x10, 0x8a, 0x7d, 0x7b, 0x88, + 0x89, 0x6f, 0x0c, 0x47, 0xd4, 0x48, 0x46, 0x27, 0x13, 0x62, 0x9b, 0xc6, 0x80, 0x75, 0x99, 0xd5, + 0x82, 0x77, 0x2a, 0xf4, 0xc0, 0x3d, 0x66, 0x28, 0x6e, 0x3f, 0xf2, 0x95, 0xf6, 0x41, 0xc6, 0x47, + 0x47, 0xf6, 0x73, 0xfd, 0xd0, 0xf6, 0x09, 0xeb, 0xa3, 0xa2, 0x01, 0x07, 0x6d, 0xd9, 0x3e, 0x51, + 0x7f, 0x53, 0x81, 0x12, 0x1b, 0x56, 0x60, 0xb9, 0xd1, 0x71, 0x5d, 0xe8, 0x04, 0xe6, 0x0c, 0xec, + 0x6d, 0x28, 0xfa, 0x52, 0x6e, 0x61, 0x78, 0x42, 0xdb, 0xc1, 0x70, 0xb4, 0x29, 0x85, 0xfa, 0x3d, + 0x05, 0x6a, 0x5b, 0xae, 0xeb, 0x13, 0xdf, 0x33, 0x46, 0xa9, 0xf4, 0x7b, 0x0f, 0xf2, 0x84, 0x3a, + 0x07, 0x61, 0x05, 0x95, 0x47, 0x62, 0x07, 0x60, 0x1e, 0x43, 0xe3, 0x38, 0x74, 0x1f, 0x16, 0x3d, + 0x7c, 0x2c, 0x35, 0x5d, 0xda, 0xac, 0x4a, 0x2a, 0x8d, 0x41, 0x35, 0x81, 0xa5, 0x2e, 0x77, 0x25, + 0x24, 0x4e, 0x2a, 0xbd, 0xf4, 0x01, 0x85, 0xb7, 0x14, 0xe2, 0x1b, 0xfe, 0x98, 0x08, 0xe9, 0xde, + 0x78, 0x94, 0xb0, 0xdb, 0x68, 0x53, 0x50, 0x8f, 0x11, 0x6b, 0x2b, 0x5e, 0x1c, 0xa4, 0xb6, 0xe0, + 0x7a, 0x87, 0x04, 0xa2, 0x8d, 0xb0, 0x95, 0x46, 0x59, 0xea, 0x37, 0xe1, 0x46, 0x9c, 0x4b, 0xaa, + 0x31, 0xaa, 0x50, 0x3e, 0x0c, 0x71, 0x61, 0xa3, 0x2b, 0x68, 0x11, 0x98, 0xfa, 0x35, 0xa8, 0x36, + 0x07, 0x03, 0xd7, 0xec, 0xb4, 0x52, 0x89, 0x7a, 0x00, 0xcb, 0x41, 0xf3, 0x54, 0x32, 0x56, 0x21, + 0x13, 0x78, 0x99, 0x8c, 0x6d, 0xa9, 0x9f, 0xc2, 0x7a, 0x87, 0xf4, 0x1c, 0x63, 0x44, 0x4e, 0x5c, + 0x5f, 0xc3, 0xa6, 0x7b, 0x86, 0x3d, 0xdb, 0x39, 0x4e, 0x25, 0x9c, 0x05, 0xb7, 0x92, 0x79, 0xa5, + 0x92, 0xf4, 0x06, 0x2c, 0x0e, 0x0d, 0xef, 0x34, 0xd0, 0xa3, 0x78, 0x53, 0x3f, 0x87, 0xe5, 0x1d, + 0xec, 0x73, 0x43, 0x4e, 0xb3, 0x34, 0x6e, 0x42, 0x81, 0x99, 0xff, 0xd4, 0xdb, 0x2e, 0xb1, 0xf7, + 0x8e, 0xa5, 0x7e, 0x9f, 0x6e, 0x2d, 0x01, 0xef, 0x54, 0x52, 0x5f, 0x71, 0xe1, 0xe5, 0xe9, 0x02, + 0x20, 0x62, 0xdd, 0xd5, 0x38, 0x47, 0x46, 0x42, 0x0d, 0x9b, 0x68, 0x1c, 0xad, 0x9a, 0xb0, 0xdc, + 0x1d, 0xbf, 0xc4, 0x50, 0xaf, 0x22, 0x8c, 0xfa, 0xa7, 0x0a, 0xd4, 0xa6, 0xbd, 0xfc, 0x0c, 0x2d, + 0xee, 0x5f, 0x87, 0x6b, 0x3b, 0xd8, 0x6f, 0x0e, 0x06, 0x4c, 0x34, 0x92, 0x4a, 0x03, 0x1f, 0x42, + 0x1d, 0x3f, 0x37, 0x07, 0x63, 0x0b, 0xeb, 0xbe, 0x3b, 0x3c, 0x24, 0xbe, 0xeb, 0x60, 0x9d, 0x8d, + 0x9b, 0x08, 0xb3, 0xba, 0x21, 0xf0, 0x7d, 0x89, 0xe6, 0xbd, 0xa9, 0xa7, 0xb0, 0x1a, 0xed, 0x3d, + 0x95, 0x66, 0xde, 0x80, 0xc5, 0xa0, 0xb7, 0xec, 0xec, 0x14, 0x08, 0xa4, 0xfa, 0x5b, 0xdc, 0xf0, + 0x84, 0xdf, 0x4d, 0x33, 0xd0, 0xdb, 0x00, 0xdc, 0x5b, 0xeb, 0xa7, 0x78, 0xc2, 0x86, 0x56, 0xd6, + 0x8a, 0x1c, 0xf2, 0x04, 0x4f, 0xd0, 0x6b, 0x50, 0x76, 0x30, 0xb6, 0xf4, 0xc3, 0xb1, 0x79, 0x8a, + 0x85, 0xe1, 0x15, 0xb4, 0x12, 0x85, 0x6d, 0x71, 0x90, 0xfa, 0x97, 0x19, 0x58, 0x09, 0xc9, 0x90, + 0x6a, 0xb8, 0xd3, 0x1d, 0x25, 0x73, 0xd1, 0x8e, 0x82, 0x5e, 0x87, 0xc5, 0x41, 0x38, 0xb0, 0x2e, + 0x4b, 0xba, 0x2e, 0xa6, 0xdc, 0x38, 0x0e, 0x3d, 0x02, 0xb0, 0xdc, 0x73, 0x47, 0x1f, 0x61, 0xec, + 0x91, 0x7a, 0x9e, 0x29, 0x50, 0x6c, 0x9b, 0x94, 0x8e, 0x2f, 0x95, 0x22, 0x25, 0xa1, 0xaf, 0x04, + 0xbd, 0x07, 0x95, 0x11, 0x76, 0x2c, 0xdb, 0x39, 0x16, 0x4d, 0x16, 0x59, 0x93, 0x28, 0xf3, 0xb2, + 0x20, 0xe1, 0x4d, 0xde, 0x84, 0x25, 0xa9, 0x92, 0x25, 0xb1, 0x2d, 0x0b, 0x62, 0xa1, 0x16, 0x4d, + 0xe2, 0x3f, 0xcd, 0x15, 0x72, 0xb5, 0xbc, 0xfa, 0x3b, 0x0a, 0xb3, 0x0b, 0x3e, 0x9e, 0xad, 0x49, + 0x3a, 0x37, 0x4e, 0x43, 0x3e, 0x31, 0x5b, 0xd3, 0x90, 0x8f, 0x03, 0x58, 0x04, 0x77, 0xe9, 0x5c, + 0x7d, 0x5f, 0x01, 0xd4, 0x33, 0x0d, 0x87, 0x8b, 0x41, 0xd2, 0xca, 0x40, 0x7c, 0xc3, 0xf3, 0x43, + 0x06, 0x53, 0x60, 0x00, 0x6a, 0x2f, 0xab, 0x90, 0x1f, 0xd8, 0x43, 0xdb, 0x67, 0x9d, 0xe7, 0x35, + 0xfe, 0x82, 0xd6, 0x60, 0x09, 0x3b, 0x16, 0x6b, 0x90, 0x63, 0x0d, 0x16, 0xb1, 0x63, 0x3d, 0xc1, + 0x13, 0xf5, 0x9f, 0x15, 0x58, 0xe4, 0xb2, 0x84, 0x4c, 0x40, 0xb9, 0xa2, 0x09, 0x64, 0xae, 0x6c, + 0x02, 0xd9, 0x17, 0x37, 0x81, 0xdc, 0x65, 0x26, 0xa0, 0xfe, 0xab, 0x02, 0xd7, 0x22, 0xba, 0x4c, + 0x65, 0xf9, 0xef, 0x41, 0x59, 0xcc, 0x28, 0xed, 0x49, 0x2e, 0xf7, 0xf8, 0xe0, 0x4b, 0x9c, 0x66, + 0x8f, 0x92, 0xa0, 0xfb, 0xb0, 0xc4, 0x47, 0x29, 0x07, 0x16, 0x95, 0x52, 0x22, 0x29, 0x1d, 0x6f, + 0x36, 0x1d, 0x8d, 0x90, 0x84, 0xf1, 0x94, 0x48, 0xf5, 0x31, 0xac, 0xed, 0x60, 0x7f, 0x9b, 0x67, + 0x02, 0xd1, 0x84, 0xee, 0x85, 0xb6, 0x71, 0x02, 0xf5, 0x59, 0x3e, 0xa9, 0x94, 0xf2, 0x26, 0x2c, + 0x89, 0xc4, 0x44, 0x4c, 0x72, 0xb0, 0xba, 0x04, 0x77, 0x4d, 0xe2, 0xd5, 0x2f, 0x60, 0xad, 0x3b, + 0x7e, 0x79, 0xe1, 0x5f, 0xa4, 0xcb, 0x4f, 0xa0, 0x3e, 0xdb, 0x65, 0x9a, 0x71, 0xaa, 0x7f, 0x95, + 0x81, 0xc5, 0x3d, 0x3c, 0x3c, 0xc4, 0x5e, 0x62, 0x22, 0xba, 0x0e, 0xc5, 0x21, 0xc3, 0x86, 0x56, + 0x3b, 0x07, 0xf0, 0xec, 0x8f, 0x5a, 0xaa, 0x3e, 0xf6, 0x06, 0xdc, 0x0e, 0x8a, 0x5a, 0x81, 0x02, + 0x9e, 0x7a, 0x03, 0x9e, 0x72, 0x0f, 0x6c, 0xec, 0xf8, 0x1c, 0x9d, 0x63, 0x68, 0xe0, 0x20, 0x46, + 0xf0, 0xff, 0x60, 0x99, 0x9b, 0x89, 0x3e, 0xf2, 0x6c, 0xd7, 0xb3, 0xfd, 0x09, 0xcb, 0x46, 0xf3, + 0x5a, 0x95, 0x83, 0xbb, 0x02, 0xca, 0x52, 0x2b, 0x3c, 0x1a, 0xb8, 0x13, 0x9e, 0xbc, 0x2f, 0x8a, + 0xd4, 0x8a, 0x81, 0x58, 0xcd, 0xe5, 0x0d, 0xa8, 0x1e, 0xda, 0x8e, 0xe1, 0x4d, 0xf4, 0x33, 0xec, + 0xb1, 0xc4, 0x7b, 0x89, 0xd1, 0x54, 0x38, 0xf4, 0x19, 0x07, 0xd2, 0xe8, 0xe9, 0xd8, 0xf6, 0xf5, + 0x13, 0x83, 0x9c, 0xd4, 0x0b, 0x3c, 0x1d, 0x3c, 0xb6, 0xfd, 0x4f, 0x0c, 0x72, 0x12, 0xcf, 0xde, + 0x8a, 0x33, 0xd9, 0xdb, 0x2f, 0xb1, 0x0d, 0x86, 0x2b, 0x2a, 0x95, 0xcf, 0x52, 0xff, 0x37, 0x03, + 0x28, 0xcc, 0x22, 0xe5, 0x26, 0xb5, 0xc4, 0xb5, 0x2f, 0x57, 0xa9, 0x58, 0x4f, 0x9c, 0xab, 0x26, + 0x91, 0x09, 0x9b, 0x54, 0x98, 0x4c, 0x7a, 0xa8, 0xb7, 0xa1, 0x84, 0x7d, 0xd3, 0xd2, 0x05, 0x69, + 0x2e, 0x81, 0x14, 0x28, 0xc1, 0x2e, 0x27, 0xc7, 0x70, 0xdd, 0x27, 0xae, 0x6e, 0x0c, 0x98, 0x9e, + 0x5c, 0x4f, 0x97, 0x2e, 0x80, 0x6f, 0x6f, 0xef, 0x89, 0xba, 0xc8, 0xcc, 0x18, 0x1f, 0xf5, 0x89, + 0xdb, 0x94, 0x8d, 0x38, 0x2f, 0xd2, 0x76, 0x7c, 0x6f, 0xa2, 0x5d, 0xf3, 0x67, 0x31, 0x8d, 0x3e, + 0xd4, 0xe7, 0x35, 0x40, 0x35, 0xc8, 0x52, 0x0f, 0xce, 0x2d, 0x94, 0x3e, 0x22, 0x35, 0x5c, 0x29, + 0x89, 0x4b, 0xcf, 0x51, 0x1f, 0x65, 0x3e, 0x54, 0xd4, 0x36, 0x5c, 0x9f, 0x7a, 0x86, 0x8e, 0x73, + 0x14, 0xe4, 0xfe, 0x2f, 0xb6, 0x5c, 0x7e, 0x03, 0x6e, 0xc4, 0xd9, 0xa4, 0x9a, 0xc8, 0xff, 0x0f, + 0x65, 0x82, 0xbd, 0x33, 0xdb, 0xc4, 0x7b, 0xae, 0x25, 0x42, 0xac, 0xea, 0xe6, 0x8a, 0x88, 0xa6, + 0xa7, 0x18, 0x2d, 0x42, 0xa6, 0x76, 0xa1, 0x18, 0xec, 0x1d, 0x68, 0x03, 0x72, 0x74, 0xb5, 0x89, + 0xfe, 0xa2, 0x1e, 0x98, 0x61, 0xe8, 0x76, 0xcc, 0xb6, 0x20, 0x82, 0x4d, 0xd7, 0xb1, 0x88, 0x58, + 0xc0, 0x25, 0x0a, 0xeb, 0x71, 0x90, 0xfa, 0x93, 0x3c, 0xdc, 0xe0, 0xde, 0xf8, 0x13, 0x6c, 0x78, + 0xfe, 0x21, 0x36, 0xfc, 0x54, 0xce, 0xeb, 0x55, 0x86, 0x4f, 0xb9, 0x17, 0xdf, 0x3b, 0xf3, 0x97, + 0x86, 0x4f, 0xf7, 0xa0, 0x72, 0x38, 0xf1, 0x31, 0xd1, 0xcf, 0x3d, 0xdb, 0xf7, 0xb1, 0xc3, 0xfc, + 0x4a, 0x4e, 0x2b, 0x33, 0xe0, 0x67, 0x1c, 0x46, 0x43, 0x53, 0x4e, 0xe4, 0x61, 0xc3, 0x62, 0x5e, + 0x25, 0xa7, 0x15, 0x19, 0x44, 0xc3, 0x06, 0x0b, 0x77, 0x4e, 0xf1, 0x64, 0xca, 0xa2, 0xc0, 0xf5, + 0x4b, 0x61, 0x92, 0xc3, 0x3a, 0x14, 0x19, 0x09, 0x63, 0x50, 0xe4, 0x0e, 0x94, 0x02, 0x58, 0xfb, + 0x37, 0xa1, 0x66, 0x8c, 0x46, 0x9e, 0xfb, 0xdc, 0x1e, 0x1a, 0x3e, 0xd6, 0x89, 0xfd, 0x2d, 0x5c, + 0x07, 0x46, 0xb3, 0x1c, 0x82, 0xf7, 0xec, 0x6f, 0x61, 0xf4, 0x08, 0x0a, 0xb6, 0xe3, 0x63, 0xef, + 0xcc, 0x18, 0xd4, 0xcb, 0x4c, 0x73, 0x68, 0x5a, 0x85, 0xe9, 0x08, 0x8c, 0x16, 0xd0, 0xc4, 0x59, + 0xd3, 0x2e, 0xeb, 0x95, 0x19, 0xd6, 0x4f, 0xf0, 0x84, 0x50, 0xbf, 0xef, 0x63, 0x6f, 0x58, 0xaf, + 0x32, 0x34, 0x7b, 0x46, 0xbf, 0x92, 0x98, 0x16, 0x2d, 0xb3, 0x8e, 0xbf, 0x92, 0x9c, 0x16, 0xf1, + 0xd8, 0xfb, 0xf2, 0xe4, 0x08, 0xbd, 0x07, 0xa5, 0x2f, 0xc6, 0xd8, 0x9b, 0xe8, 0x3c, 0x91, 0xac, + 0x85, 0x13, 0xc9, 0x5f, 0xa6, 0x08, 0x3e, 0xbd, 0xf0, 0x45, 0xf0, 0x4c, 0xb5, 0x68, 0x8e, 0xc6, + 0xfa, 0x98, 0x95, 0xf2, 0x56, 0xb8, 0x16, 0xcd, 0xd1, 0xf8, 0x29, 0x7d, 0x47, 0x8f, 0xe0, 0x5a, + 0x64, 0xa8, 0x67, 0x5c, 0x91, 0x88, 0x91, 0xad, 0x84, 0x47, 0x7b, 0x46, 0x55, 0xf9, 0x69, 0xae, + 0x50, 0xaa, 0x95, 0xd5, 0x13, 0x80, 0x6d, 0x56, 0xaf, 0xa6, 0xe6, 0x70, 0x85, 0xb5, 0xf4, 0x21, + 0x94, 0x78, 0x7d, 0x5b, 0x67, 0x75, 0xc7, 0x0c, 0xab, 0x3b, 0xae, 0x3d, 0x92, 0x07, 0x12, 0x74, + 0x13, 0xe6, 0xfc, 0x58, 0xfd, 0x11, 0xcc, 0xe0, 0x59, 0xfd, 0x08, 0xca, 0xd3, 0x9e, 0x9e, 0x6d, + 0xa2, 0x87, 0xf1, 0x82, 0xba, 0x18, 0xfb, 0x94, 0x28, 0x28, 0xa5, 0xab, 0xcf, 0xa0, 0xda, 0xf7, + 0x0c, 0x87, 0x1c, 0x61, 0xe1, 0x08, 0xaf, 0x20, 0xa9, 0x0a, 0x79, 0xbe, 0x08, 0x32, 0x09, 0x8b, + 0x80, 0xa3, 0xd4, 0x77, 0x20, 0xbf, 0x87, 0xbd, 0x63, 0x56, 0x48, 0xf3, 0x0d, 0xef, 0x18, 0xfb, + 0xf3, 0x62, 0x5e, 0x8e, 0x55, 0x77, 0xa1, 0xd4, 0x1b, 0x0d, 0x6c, 0x91, 0x3d, 0xa0, 0x37, 0x61, + 0x71, 0xe4, 0x0e, 0x6c, 0x73, 0x22, 0x0a, 0xb0, 0x2b, 0x72, 0x08, 0xd8, 0x3c, 0xed, 0x32, 0x84, + 0x26, 0x08, 0xa8, 0x79, 0x31, 0xeb, 0xa3, 0xd2, 0x94, 0x35, 0xf6, 0xac, 0xee, 0x40, 0xa5, 0x77, + 0x6e, 0xfb, 0xe6, 0xc9, 0x67, 0xb6, 0xef, 0x60, 0x42, 0x68, 0x78, 0xce, 0x42, 0x89, 0xa0, 0x2c, + 0xbc, 0x48, 0x5f, 0x3b, 0x16, 0x5d, 0x81, 0x36, 0xd1, 0xcf, 0x39, 0x99, 0xc8, 0x7b, 0x8b, 0x36, + 0x11, 0xed, 0xd4, 0x3e, 0xa0, 0x2d, 0xc3, 0x37, 0x4f, 0xa2, 0xdc, 0x3e, 0x86, 0x1a, 0x61, 0x00, + 0xd9, 0x30, 0x50, 0xb5, 0xf0, 0x61, 0x11, 0x72, 0x6d, 0x99, 0x84, 0x5f, 0x31, 0x51, 0xff, 0x24, + 0x07, 0x6b, 0x33, 0x4e, 0x31, 0x65, 0x6c, 0x2d, 0xad, 0x86, 0x4d, 0x5a, 0x26, 0x6c, 0xeb, 0xa1, + 0xf9, 0x16, 0xe6, 0xc2, 0x4c, 0xf1, 0x6b, 0xb0, 0xec, 0x8b, 0x29, 0xd7, 0x07, 0x09, 0x47, 0x38, + 0x51, 0x7b, 0xd0, 0xaa, 0x7e, 0xd4, 0x3e, 0x22, 0xf9, 0x59, 0x2e, 0x96, 0x9f, 0x7d, 0x35, 0x08, + 0xf5, 0xf1, 0xc8, 0x35, 0x4f, 0x58, 0xc0, 0x45, 0x95, 0x12, 0x99, 0xf3, 0x36, 0x45, 0xc9, 0x78, + 0x9f, 0xbd, 0xd0, 0x48, 0x81, 0xdb, 0x01, 0x1f, 0xc6, 0x62, 0x82, 0xed, 0x01, 0x27, 0xe8, 0xf2, + 0x7d, 0x27, 0x3f, 0xa4, 0xd6, 0x25, 0x12, 0xd3, 0x92, 0xdc, 0x94, 0xbd, 0x63, 0xac, 0x71, 0x0c, + 0xfa, 0x00, 0xca, 0x84, 0xda, 0x93, 0x2e, 0x76, 0x8d, 0x02, 0xa3, 0x94, 0x1b, 0xe0, 0xd4, 0xd2, + 0xb4, 0x12, 0x09, 0x99, 0xdd, 0x87, 0x50, 0x0d, 0xa9, 0x53, 0x3f, 0xdb, 0x64, 0x2e, 0x35, 0xf0, + 0x85, 0xe1, 0x65, 0xa6, 0x95, 0xcd, 0xf0, 0xa2, 0xdb, 0x4e, 0x30, 0x09, 0x60, 0x6d, 0xeb, 0xbc, + 0xed, 0xac, 0x19, 0xcd, 0xda, 0xc5, 0x11, 0x2c, 0x37, 0xc9, 0xa9, 0x90, 0xee, 0xd5, 0x6d, 0x92, + 0xea, 0xef, 0x29, 0x50, 0x9b, 0x76, 0x94, 0xb2, 0xa0, 0x5b, 0x71, 0xf0, 0xb9, 0x1e, 0x4f, 0xd5, + 0x4b, 0x0e, 0x3e, 0xd7, 0xa4, 0x35, 0x6c, 0xd0, 0x6c, 0xfd, 0x5c, 0x17, 0x0b, 0x8f, 0x87, 0xf0, + 0x39, 0x0d, 0x1c, 0x7c, 0xde, 0x65, 0x8b, 0x8f, 0xa8, 0x7f, 0xa0, 0x00, 0xd2, 0xf0, 0xc8, 0xf5, + 0xfc, 0xf4, 0x83, 0x56, 0x21, 0x37, 0xc0, 0x47, 0xfe, 0x9c, 0x21, 0x33, 0x1c, 0x7a, 0x1d, 0xf2, + 0x9e, 0x7d, 0x7c, 0xe2, 0xcf, 0xa9, 0xe6, 0x73, 0xa4, 0xba, 0x0d, 0xd7, 0x22, 0xc2, 0xa4, 0x4a, + 0x78, 0xbe, 0xa7, 0xc0, 0x6a, 0x93, 0x9c, 0xf2, 0xe9, 0x7e, 0xd5, 0x33, 0xc9, 0x8e, 0x6c, 0x98, + 0x99, 0xf3, 0x93, 0x15, 0x79, 0x64, 0x43, 0x41, 0xdb, 0x14, 0xa2, 0x1e, 0xc0, 0x12, 0x93, 0xa2, + 0xd3, 0x9a, 0x9d, 0x32, 0xe5, 0xf2, 0x29, 0xcb, 0xcc, 0x4c, 0xd9, 0x11, 0x5c, 0x8f, 0x0d, 0x2f, + 0x95, 0xfd, 0xdc, 0x85, 0xac, 0xe4, 0x5f, 0xda, 0xac, 0x84, 0x96, 0x65, 0xa7, 0xa5, 0x51, 0x8c, + 0x3a, 0xa2, 0x2e, 0x92, 0x4e, 0xc6, 0x4b, 0x6a, 0xf2, 0xc1, 0xb4, 0x44, 0x90, 0x5c, 0x78, 0x08, + 0x8a, 0x04, 0x9f, 0x40, 0x7d, 0xb6, 0xc7, 0x54, 0x36, 0xf0, 0x0d, 0x28, 0x87, 0xc3, 0x26, 0x9a, + 0x8a, 0xf2, 0x7a, 0xd2, 0xf4, 0xa4, 0x8b, 0xeb, 0xbe, 0xca, 0xc0, 0xd3, 0x73, 0xbb, 0x7b, 0x50, + 0xc1, 0x8e, 0x15, 0x22, 0xe3, 0xab, 0xaa, 0x8c, 0x1d, 0x2b, 0x20, 0x52, 0x3f, 0x00, 0xd0, 0xb0, + 0xe9, 0x7a, 0x56, 0xd7, 0xb0, 0xbd, 0x84, 0x94, 0x25, 0x72, 0xb8, 0x9b, 0x13, 0x49, 0x8a, 0xfa, + 0x9f, 0x0a, 0x14, 0x64, 0x6c, 0x1b, 0x75, 0xe2, 0x4a, 0xcc, 0x89, 0x33, 0xa4, 0x61, 0xe9, 0x62, + 0x57, 0x15, 0x48, 0xc3, 0x62, 0xc1, 0x1c, 0x2b, 0xa6, 0x1a, 0x96, 0xce, 0x82, 0x54, 0x66, 0x6f, + 0x39, 0x8d, 0x91, 0x6f, 0x51, 0x40, 0x3c, 0xf6, 0xca, 0x5d, 0x21, 0xf6, 0x7a, 0x0d, 0xca, 0x22, + 0xbe, 0xe5, 0x3d, 0xe6, 0xb9, 0x55, 0x0a, 0x18, 0xeb, 0xf4, 0x1e, 0x54, 0x24, 0x09, 0xef, 0x57, + 0xc4, 0xd2, 0x02, 0xc8, 0xba, 0x56, 0xff, 0xa1, 0x00, 0x30, 0x3d, 0x27, 0x88, 0x9c, 0x65, 0x28, + 0x91, 0xb3, 0x0c, 0xd4, 0x80, 0x82, 0x69, 0x8c, 0x0c, 0xd3, 0xf6, 0x27, 0x72, 0x7c, 0xf2, 0x1d, + 0xdd, 0x82, 0xa2, 0x71, 0x66, 0xd8, 0x03, 0xe3, 0x70, 0x80, 0xe5, 0xf0, 0x02, 0x00, 0x95, 0x55, + 0xe8, 0x8d, 0xaf, 0xb7, 0x1c, 0x5b, 0x6f, 0x62, 0x2b, 0x63, 0x0b, 0x0e, 0xbd, 0x05, 0x88, 0x88, + 0x54, 0x81, 0x38, 0xc6, 0x48, 0x10, 0xe6, 0x19, 0x61, 0x4d, 0x60, 0x7a, 0x8e, 0x31, 0xe2, 0xd4, + 0xef, 0xc2, 0xaa, 0x87, 0x4d, 0x6c, 0x9f, 0xc5, 0xe8, 0x17, 0x19, 0x3d, 0x0a, 0x70, 0xd3, 0x16, + 0xb7, 0x01, 0xa6, 0xb6, 0xc4, 0x36, 0xc0, 0x8a, 0x56, 0x0c, 0xcc, 0x48, 0x04, 0xab, 0x83, 0x49, + 0x8c, 0x5f, 0x81, 0xd1, 0xad, 0x48, 0xd4, 0x94, 0xdd, 0x1a, 0x2c, 0xd9, 0x44, 0x3f, 0x1c, 0x93, + 0x09, 0xdb, 0xea, 0x0a, 0xda, 0xa2, 0x4d, 0xb6, 0xc6, 0x64, 0x42, 0xad, 0x60, 0x4c, 0xb0, 0x15, + 0x4e, 0x1a, 0x0a, 0x14, 0xc0, 0xb2, 0x85, 0x99, 0xe4, 0xa6, 0x94, 0x90, 0xdc, 0xc4, 0xb3, 0x97, + 0xf2, 0x6c, 0xf6, 0x12, 0xcd, 0x7f, 0x2a, 0xf1, 0xfc, 0x27, 0x92, 0xdc, 0x54, 0x63, 0xc9, 0x4d, + 0x38, 0x63, 0x59, 0xbe, 0x42, 0xc6, 0xf2, 0x0e, 0x40, 0x10, 0xe3, 0xd3, 0xac, 0x20, 0x14, 0x19, + 0x4f, 0x97, 0x93, 0x56, 0x94, 0x61, 0x3f, 0x41, 0x1f, 0x40, 0x85, 0x99, 0xba, 0xed, 0xea, 0x9e, + 0x41, 0xad, 0x6e, 0x65, 0x4e, 0x9b, 0x12, 0x25, 0xeb, 0xb8, 0x1a, 0x25, 0x42, 0x5f, 0x85, 0x2a, + 0x1d, 0x30, 0x9e, 0x36, 0x43, 0x73, 0x9a, 0x31, 0xf3, 0xc5, 0xb2, 0xdd, 0xfb, 0x50, 0x76, 0x47, + 0xfa, 0xc0, 0xf0, 0xb1, 0x63, 0xda, 0x98, 0xd4, 0xaf, 0xcd, 0xeb, 0xcc, 0x1d, 0xed, 0x4a, 0x22, + 0xf4, 0x36, 0x00, 0x73, 0xd5, 0x7c, 0xb5, 0xad, 0x0a, 0xff, 0x16, 0xc9, 0x63, 0x35, 0x56, 0x43, + 0xe3, 0x6b, 0x22, 0xb6, 0x3a, 0xaf, 0x5f, 0x61, 0x75, 0x52, 0x73, 0x1b, 0xb8, 0xe7, 0x3a, 0x31, + 0x5d, 0x0f, 0xd7, 0x6f, 0xf0, 0x19, 0xa2, 0x90, 0x1e, 0x05, 0x50, 0x6b, 0xb7, 0x8c, 0xa1, 0x71, + 0x8c, 0x2d, 0xb1, 0xaf, 0x10, 0xba, 0xde, 0xd6, 0xd8, 0xae, 0x51, 0x13, 0x18, 0x51, 0x3d, 0xee, + 0x58, 0x74, 0x07, 0xb2, 0x89, 0xce, 0x8c, 0x90, 0x9b, 0x5c, 0x9d, 0xd7, 0xef, 0x6d, 0xd2, 0xa4, + 0x30, 0x66, 0x77, 0x3f, 0x0f, 0x55, 0x22, 0xce, 0x49, 0x85, 0x98, 0x37, 0xd9, 0xb0, 0xc4, 0xe4, + 0xca, 0x33, 0x54, 0x36, 0xb4, 0x0a, 0x09, 0xbd, 0x11, 0x9a, 0xd5, 0x33, 0x59, 0x7d, 0x0f, 0x3b, + 0x56, 0xbd, 0x11, 0xbe, 0x4b, 0xd0, 0x1b, 0xb8, 0xe7, 0x7d, 0x0a, 0xe6, 0xc2, 0xb3, 0x47, 0xf5, + 0x0f, 0x15, 0x28, 0x06, 0x08, 0x56, 0x50, 0x34, 0xc6, 0x04, 0xeb, 0xdc, 0x79, 0x52, 0x9f, 0xa1, + 0x68, 0xc0, 0x40, 0xcf, 0xd8, 0xf5, 0x98, 0xdb, 0xc0, 0xdf, 0xd8, 0xb4, 0x32, 0xc7, 0xa1, 0x68, + 0x45, 0x06, 0xa1, 0x33, 0xc8, 0x7d, 0x03, 0x19, 0x0f, 0x7c, 0xc1, 0x20, 0xcb, 0x08, 0x4a, 0x1c, + 0xc6, 0x39, 0xdc, 0x05, 0xf1, 0xca, 0x59, 0xe4, 0x78, 0x17, 0x1c, 0x44, 0x79, 0xa8, 0x3f, 0x52, + 0xa0, 0x1c, 0x1e, 0xe1, 0xc5, 0x8e, 0x7a, 0x13, 0xae, 0x1f, 0x63, 0x07, 0x53, 0x5e, 0xba, 0x35, + 0xf6, 0x44, 0x2a, 0x8d, 0x4d, 0xe1, 0xd4, 0xae, 0x49, 0x64, 0x4b, 0xe0, 0x7a, 0xd8, 0x44, 0x0f, + 0x61, 0x85, 0x3a, 0xa1, 0x28, 0x3d, 0xf7, 0x73, 0xcb, 0x14, 0x11, 0xa6, 0x7d, 0x0b, 0x90, 0xef, + 0xfa, 0xc6, 0x20, 0x4a, 0xcc, 0x63, 0xfe, 0x1a, 0xc3, 0x84, 0xa9, 0xdf, 0x00, 0x9e, 0x2a, 0xd0, + 0x1d, 0x94, 0x7b, 0x0d, 0xee, 0xc9, 0x2b, 0x01, 0x94, 0xba, 0x0e, 0x3a, 0x44, 0x60, 0x01, 0x3d, + 0xdb, 0x6a, 0xd1, 0x2f, 0x02, 0xf0, 0x4b, 0x76, 0x3e, 0xd5, 0x08, 0xdf, 0x5c, 0x6f, 0x3f, 0x8a, + 0xde, 0xbb, 0xd3, 0x8c, 0x23, 0x7f, 0xd7, 0x35, 0x8d, 0x01, 0x55, 0x09, 0xd6, 0x8a, 0x14, 0xcb, + 0x1e, 0xd1, 0x56, 0xe0, 0x8f, 0x79, 0x7b, 0x1e, 0x2c, 0xdd, 0x8d, 0xb7, 0x67, 0x24, 0x21, 0x0e, + 0xc2, 0x61, 0x73, 0x1e, 0xf7, 0x61, 0xd9, 0x26, 0xfa, 0x91, 0xeb, 0x99, 0x38, 0x9c, 0x0f, 0x15, + 0xb4, 0x8a, 0x4d, 0x1e, 0x53, 0xe8, 0xae, 0x0c, 0x24, 0x6a, 0x27, 0x06, 0xd1, 0x4d, 0x77, 0x38, + 0xb4, 0x7d, 0x9d, 0xe7, 0x1f, 0x39, 0x46, 0x58, 0x3d, 0x31, 0xc8, 0x36, 0x03, 0xb3, 0x14, 0x44, + 0x7d, 0x06, 0x25, 0x71, 0x64, 0xcc, 0x86, 0xf8, 0x3e, 0x94, 0xd9, 0x22, 0xf5, 0xd8, 0x6b, 0x2c, + 0x29, 0x9f, 0xaa, 0x42, 0x2b, 0x8d, 0x82, 0x67, 0x56, 0x34, 0x21, 0x3e, 0x96, 0x01, 0x00, 0x7b, + 0x56, 0xff, 0x47, 0x81, 0xeb, 0x8c, 0xf1, 0xcb, 0x96, 0xd2, 0xc4, 0x11, 0x7b, 0xe6, 0xc2, 0x23, + 0x76, 0x96, 0x42, 0xb1, 0x1d, 0x94, 0x0b, 0x2e, 0x62, 0xe7, 0x95, 0x10, 0xb9, 0x14, 0x9c, 0x84, + 0x46, 0xfb, 0x19, 0x20, 0xcb, 0xd3, 0x8d, 0xb1, 0xef, 0x92, 0x89, 0x63, 0xca, 0xca, 0x0e, 0x0f, + 0x04, 0xde, 0x4c, 0xaa, 0xec, 0x30, 0x4e, 0x2d, 0xad, 0x39, 0xf6, 0xdd, 0xde, 0xc4, 0x31, 0x45, + 0x5d, 0xa7, 0x66, 0x79, 0x4d, 0xc1, 0x43, 0x9c, 0x79, 0x5b, 0x80, 0x5a, 0x78, 0xe8, 0xfa, 0xf8, + 0xb1, 0x61, 0x0f, 0xb0, 0xf5, 0xcc, 0xf5, 0xb1, 0x47, 0x2e, 0x5e, 0x20, 0xef, 0x41, 0xe5, 0x88, + 0x11, 0xeb, 0x67, 0x8c, 0x3a, 0xb1, 0x62, 0x51, 0x3e, 0x0a, 0xf1, 0x53, 0x0f, 0xa1, 0x14, 0x9e, + 0xf4, 0x7b, 0x01, 0x07, 0x71, 0x56, 0xad, 0x30, 0xd7, 0x26, 0xda, 0xf0, 0xf3, 0x6f, 0xba, 0xe7, + 0x62, 0xba, 0xcb, 0x44, 0x8c, 0x48, 0xc6, 0xce, 0x2b, 0x0c, 0x15, 0xe2, 0x49, 0xd4, 0x6f, 0x67, + 0xa0, 0x2c, 0xee, 0x80, 0x4c, 0xba, 0x03, 0xc3, 0xa1, 0x31, 0xaa, 0xe9, 0x61, 0xb6, 0x59, 0x28, + 0xc9, 0x31, 0xaa, 0x40, 0xa3, 0xb7, 0x60, 0x69, 0x3c, 0xb2, 0x18, 0x65, 0x62, 0x34, 0xbb, 0x95, + 0xa9, 0x2b, 0x9a, 0x24, 0x41, 0x77, 0x00, 0x82, 0xa3, 0xfd, 0x20, 0xfd, 0x9a, 0x42, 0xd0, 0x26, + 0x2c, 0x59, 0x4c, 0xa5, 0xb2, 0x06, 0x2a, 0x72, 0xd5, 0x59, 0x3d, 0x6b, 0x92, 0x90, 0x5a, 0x45, + 0x64, 0xad, 0xe4, 0xc3, 0x56, 0x11, 0x1a, 0xa6, 0x56, 0x3a, 0x0a, 0xe9, 0x51, 0x9a, 0xf3, 0x62, + 0xc8, 0x9c, 0x3f, 0x84, 0x4a, 0xf3, 0xdc, 0x38, 0xc5, 0xf2, 0x78, 0x91, 0x86, 0xc9, 0xc6, 0xa1, + 0xe3, 0x7a, 0x43, 0x63, 0x10, 0x55, 0x77, 0x55, 0x82, 0xc5, 0x05, 0x84, 0x9f, 0x64, 0xe0, 0x46, + 0x7c, 0x21, 0xfc, 0xec, 0xdc, 0xce, 0xa0, 0xe3, 0x90, 0xd7, 0x10, 0xe5, 0x81, 0x11, 0xbf, 0xaf, + 0x57, 0x15, 0x60, 0x79, 0x62, 0xf4, 0x11, 0xac, 0x79, 0xf8, 0x8b, 0xb1, 0xed, 0x61, 0xdd, 0xc2, + 0x3e, 0xb7, 0x33, 0xb1, 0xd8, 0x98, 0x67, 0x61, 0xb3, 0x79, 0x5d, 0x90, 0xb4, 0x04, 0x85, 0x58, + 0x67, 0x3f, 0x47, 0xa3, 0x13, 0x6e, 0x43, 0xfa, 0x68, 0x60, 0x38, 0x62, 0x22, 0xd0, 0x34, 0x60, + 0x90, 0xe6, 0xa5, 0x95, 0xbd, 0xb0, 0xb1, 0x7d, 0x04, 0x55, 0x83, 0xa9, 0x5d, 0xee, 0xd8, 0xa2, + 0xdc, 0x22, 0x7c, 0x46, 0x64, 0x4a, 0xb4, 0x8a, 0x11, 0x7e, 0x55, 0xbf, 0x93, 0x81, 0xd5, 0x9e, + 0x69, 0xf8, 0x3e, 0x75, 0x54, 0xa9, 0x2f, 0x64, 0xdc, 0x9d, 0x39, 0xe2, 0x67, 0x03, 0x9d, 0xae, + 0xdb, 0x2b, 0xde, 0xbe, 0x0b, 0x15, 0xfb, 0x73, 0x17, 0x14, 0xfb, 0x57, 0x21, 0x7f, 0xec, 0xb9, + 0xe3, 0x11, 0xd3, 0x50, 0x51, 0xe3, 0x2f, 0xd3, 0x5b, 0x21, 0x2c, 0x62, 0x59, 0x64, 0x76, 0x26, + 0xc4, 0xa2, 0xa1, 0x0a, 0xdb, 0xaa, 0x7d, 0x6f, 0xa2, 0xf3, 0xb3, 0x7e, 0x5e, 0x9a, 0x07, 0x06, + 0xda, 0xa5, 0x10, 0xf5, 0x0c, 0xae, 0xc7, 0x34, 0x91, 0xca, 0x02, 0xdf, 0x81, 0x6b, 0x47, 0xb6, + 0x63, 0x93, 0x13, 0x6c, 0xe9, 0x23, 0xec, 0x99, 0xd8, 0xf1, 0xe5, 0x75, 0xd2, 0x9c, 0x86, 0x24, + 0xaa, 0x1b, 0x60, 0xd4, 0x16, 0x3b, 0x68, 0xda, 0xd9, 0xee, 0x19, 0x47, 0xb8, 0xeb, 0xda, 0x4e, + 0xaa, 0x3d, 0x40, 0xc5, 0xec, 0x9c, 0x29, 0xc2, 0x25, 0x95, 0xf8, 0x34, 0x3c, 0x34, 0x8e, 0xb0, + 0x3e, 0xa2, 0x3c, 0x84, 0xd4, 0x45, 0x22, 0x99, 0xaa, 0x47, 0x50, 0x7f, 0xca, 0x7c, 0xd1, 0x4b, + 0xca, 0x7b, 0x59, 0x3f, 0x2e, 0xdc, 0x4c, 0xe8, 0x27, 0xd5, 0x88, 0x5e, 0x87, 0xaa, 0x83, 0xcf, + 0xf5, 0x99, 0xde, 0xca, 0x0e, 0x3e, 0x0f, 0x78, 0xab, 0x3f, 0x54, 0xe0, 0x2e, 0xef, 0x51, 0x1c, + 0xa6, 0x7d, 0x19, 0x03, 0xe4, 0x9c, 0xe4, 0xa2, 0x28, 0x6b, 0x45, 0x01, 0xe9, 0x58, 0x34, 0xcb, + 0xef, 0xf7, 0x77, 0xd9, 0x72, 0xc8, 0x6a, 0xf4, 0x31, 0xa6, 0x91, 0x5c, 0x5c, 0x23, 0x7f, 0xab, + 0xc0, 0xc6, 0x7c, 0x01, 0x53, 0xcf, 0xf5, 0x0b, 0x89, 0xf8, 0x3a, 0x54, 0x87, 0xb6, 0xa3, 0xcf, + 0x88, 0x59, 0x1e, 0xda, 0xce, 0x54, 0x95, 0xc7, 0xec, 0x6e, 0x46, 0x48, 0xbc, 0x67, 0x9b, 0x29, + 0xbd, 0x0a, 0x4b, 0x2d, 0x47, 0xc6, 0x54, 0xbe, 0x8a, 0x06, 0x12, 0xd4, 0xb1, 0xd4, 0x63, 0x76, + 0x79, 0x23, 0xd6, 0xd1, 0xab, 0xb0, 0x7a, 0x4b, 0x7e, 0x86, 0xf1, 0xd2, 0x63, 0xba, 0xe8, 0xb2, + 0xff, 0x18, 0xaa, 0x01, 0x7b, 0x76, 0x03, 0x3f, 0xae, 0x01, 0x25, 0xae, 0x81, 0x4b, 0xe4, 0x0e, + 0xee, 0xbc, 0x67, 0xe7, 0x5c, 0xee, 0xa7, 0x48, 0xf5, 0x07, 0x0a, 0x34, 0x92, 0x46, 0x97, 0x4a, + 0x91, 0x6f, 0xc1, 0x22, 0xa6, 0xfc, 0x65, 0x34, 0x23, 0xa8, 0xa3, 0xe3, 0xd2, 0x04, 0x4d, 0x44, + 0x1b, 0xd9, 0x98, 0x36, 0xbe, 0xab, 0x40, 0x63, 0xc6, 0x05, 0xbc, 0x22, 0x4b, 0x8a, 0xe9, 0x31, + 0x1b, 0x9f, 0xff, 0x2f, 0x60, 0x3d, 0x51, 0x94, 0x57, 0xe8, 0x8f, 0xfe, 0x25, 0xee, 0x8f, 0x7e, + 0x2a, 0x3a, 0x98, 0x7a, 0x83, 0x6c, 0xdc, 0x1b, 0x5c, 0xec, 0x9e, 0xa8, 0xb3, 0xf0, 0xfd, 0x01, + 0xdb, 0x91, 0xb3, 0x1a, 0x7d, 0x9c, 0x75, 0x58, 0x5f, 0xce, 0x32, 0xbd, 0xd8, 0x61, 0x51, 0x19, + 0xb2, 0x81, 0x0c, 0x57, 0x74, 0x58, 0x7f, 0xa4, 0x00, 0x68, 0x41, 0x02, 0x39, 0x5b, 0x0b, 0x53, + 0x2e, 0x3d, 0xe8, 0xcf, 0x5c, 0x76, 0xd0, 0x9f, 0xbd, 0xe4, 0xa0, 0x3f, 0x17, 0xad, 0x85, 0xa9, + 0xbf, 0xaf, 0xc0, 0x0a, 0x4d, 0x9e, 0x5e, 0x22, 0x28, 0x7b, 0x1d, 0x16, 0xf9, 0xed, 0x9e, 0xc4, + 0x9b, 0x2e, 0x02, 0xc7, 0xce, 0x1b, 0x58, 0xf5, 0xd1, 0x76, 0x2c, 0xfc, 0x5c, 0xc8, 0xc9, 0x0b, + 0x92, 0x1d, 0x0a, 0x51, 0xdf, 0xe7, 0xd9, 0x3d, 0xe1, 0x15, 0x99, 0x37, 0xe4, 0x51, 0xb1, 0x92, + 0x7c, 0xc5, 0x42, 0x9c, 0x16, 0x7f, 0x05, 0xf2, 0xfc, 0xd2, 0x84, 0x1a, 0xa5, 0x4f, 0x3c, 0x5a, + 0xfe, 0xdd, 0x2c, 0xa0, 0xf0, 0x58, 0x53, 0x99, 0xc6, 0x95, 0x4f, 0x05, 0x2e, 0x1d, 0x31, 0x4d, + 0xef, 0x43, 0x35, 0x08, 0x99, 0x49, 0xd5, 0xc2, 0x17, 0x11, 0x59, 0xb1, 0x2a, 0x54, 0x74, 0x20, + 0xe8, 0x7d, 0xa8, 0x8a, 0x46, 0xd1, 0x4b, 0x4e, 0xd1, 0x11, 0x57, 0x38, 0x8d, 0xc8, 0x1b, 0xc3, + 0x37, 0x72, 0x17, 0x85, 0x3e, 0xe7, 0xdc, 0xc8, 0x45, 0xef, 0x44, 0x2e, 0xb8, 0xd4, 0xe2, 0x15, + 0x07, 0x32, 0x73, 0xc3, 0xe5, 0xdd, 0xf8, 0x0d, 0x17, 0x5e, 0xec, 0x2c, 0x85, 0xda, 0xc4, 0x2e, + 0x87, 0xfe, 0x1a, 0xbb, 0x6f, 0x76, 0x30, 0xc2, 0x9e, 0xe1, 0xbb, 0xde, 0x97, 0x7e, 0xd7, 0x57, + 0xfd, 0x47, 0x85, 0x5d, 0x72, 0x9f, 0x76, 0x90, 0x6a, 0xa2, 0x2f, 0xbc, 0x4e, 0x8c, 0x20, 0x67, + 0x61, 0x62, 0x0a, 0xef, 0xc5, 0x9e, 0x29, 0xfb, 0x50, 0xcd, 0xa2, 0x2a, 0xd9, 0x4b, 0x31, 0x44, + 0xd6, 0x27, 0x68, 0xd8, 0xe5, 0x03, 0xdb, 0x91, 0xdf, 0xb9, 0xb1, 0x67, 0x76, 0xba, 0x4a, 0x0d, + 0x74, 0xcf, 0x78, 0xde, 0xef, 0xa5, 0x3d, 0xfd, 0x1b, 0x1a, 0xcf, 0xf5, 0xa0, 0x44, 0x33, 0xf3, + 0x41, 0x54, 0x7e, 0x68, 0x3c, 0xef, 0xf3, 0xe2, 0xec, 0xa9, 0x3d, 0xd2, 0xcd, 0x13, 0x6c, 0x9e, + 0x8a, 0xaa, 0x55, 0x91, 0x42, 0xd8, 0x3d, 0x09, 0xf5, 0x8f, 0x85, 0x57, 0x10, 0x82, 0xa4, 0xbd, + 0xbc, 0x4b, 0x45, 0x19, 0xb8, 0xa6, 0x31, 0xb8, 0x40, 0x20, 0x18, 0x1a, 0xcf, 0x59, 0x81, 0x4d, + 0x48, 0x35, 0x71, 0x4c, 0x6c, 0xe9, 0x96, 0x29, 0xef, 0x6d, 0x16, 0x39, 0xa4, 0x65, 0x12, 0xf5, + 0xb7, 0x15, 0xb8, 0x16, 0x3a, 0x80, 0x27, 0xa9, 0xc3, 0x65, 0x76, 0xee, 0x19, 0xba, 0xfa, 0x51, + 0x64, 0x10, 0x76, 0x60, 0x14, 0xcb, 0xde, 0xb2, 0x33, 0xd9, 0xdb, 0x0f, 0x14, 0x58, 0x8d, 0x0a, + 0xf1, 0x53, 0xc9, 0xde, 0x62, 0x59, 0x67, 0x36, 0x96, 0x75, 0xaa, 0x7f, 0xa1, 0xc0, 0x6d, 0x26, + 0x56, 0xd3, 0xb1, 0x22, 0xd9, 0xe5, 0x2b, 0xd1, 0x52, 0x90, 0x18, 0x67, 0xc3, 0x89, 0x71, 0x4c, + 0x77, 0xb9, 0x19, 0xdd, 0xfd, 0xb7, 0x02, 0x77, 0xe6, 0x09, 0x99, 0x4a, 0x8b, 0x1f, 0xc1, 0x4d, + 0x2e, 0xe6, 0x7c, 0x5d, 0xae, 0x31, 0x82, 0xc7, 0xb3, 0x0a, 0xfd, 0x18, 0xd6, 0x09, 0x97, 0x21, + 0xb1, 0x35, 0x9f, 0xf9, 0x9b, 0x82, 0xe4, 0xf1, 0x65, 0x13, 0x92, 0x8b, 0x4f, 0xc8, 0x09, 0xcb, + 0x19, 0x5a, 0xdb, 0xf2, 0xa2, 0x6e, 0xf8, 0x66, 0xe7, 0x8b, 0xc6, 0x53, 0xe1, 0x1b, 0xc0, 0x99, + 0x99, 0x1b, 0xc0, 0xdf, 0x55, 0xe0, 0x66, 0x42, 0x57, 0x69, 0xbf, 0x0f, 0xe3, 0x5f, 0x6d, 0xb2, + 0x7e, 0xf2, 0x9a, 0x78, 0x0b, 0xf9, 0x95, 0xec, 0x45, 0x7e, 0x45, 0xfd, 0xa7, 0x0c, 0xc0, 0xf4, + 0x3c, 0x08, 0x55, 0x21, 0xb3, 0xb3, 0x2d, 0xc2, 0x9a, 0xcc, 0xce, 0x36, 0x0d, 0x9c, 0x76, 0xb0, + 0x8c, 0x43, 0xe9, 0x23, 0x75, 0x83, 0x3d, 0xd3, 0x90, 0x71, 0x0b, 0x7b, 0x46, 0x1b, 0x50, 0xda, + 0x76, 0x47, 0x9e, 0x6b, 0x62, 0x42, 0x5c, 0x4f, 0xd8, 0x51, 0x18, 0x44, 0xc5, 0x6c, 0xe1, 0x01, + 0xf6, 0xe5, 0x49, 0x81, 0x78, 0xa3, 0x2d, 0xf9, 0x93, 0x66, 0x38, 0xc7, 0x58, 0xd4, 0x0c, 0xc3, + 0x20, 0x2a, 0x41, 0x77, 0x2c, 0xab, 0x32, 0xf4, 0x91, 0xe6, 0x06, 0x5d, 0x0f, 0xb3, 0x13, 0x35, + 0x71, 0x4d, 0x32, 0x78, 0x47, 0x5f, 0x85, 0x1b, 0x4d, 0x93, 0xd5, 0xd0, 0xba, 0x98, 0x10, 0x7b, + 0x68, 0x13, 0xdf, 0xa6, 0x8a, 0x3f, 0x15, 0x17, 0x26, 0xe7, 0x60, 0xa9, 0x7c, 0xbc, 0xac, 0x2f, + 0xce, 0x3f, 0xc5, 0x1b, 0xed, 0x4b, 0x73, 0x07, 0x83, 0x43, 0xc3, 0x3c, 0x15, 0x07, 0x9f, 0xc1, + 0xbb, 0xfa, 0x37, 0x0a, 0xac, 0x8a, 0x5b, 0x04, 0x62, 0x4f, 0x4e, 0x63, 0x2d, 0xf1, 0x7b, 0x54, + 0x99, 0x2b, 0xde, 0xa3, 0x0a, 0x45, 0x08, 0xd9, 0x8b, 0xbf, 0xd9, 0x51, 0xdb, 0x70, 0x3d, 0x26, + 0x67, 0xda, 0xeb, 0x2e, 0x0d, 0xce, 0x67, 0xcf, 0xa6, 0xc1, 0x98, 0x3b, 0x38, 0xc3, 0x56, 0x9f, + 0x7c, 0xc9, 0x9f, 0x1f, 0xa2, 0xfb, 0xb0, 0x4c, 0x23, 0x73, 0x4f, 0x74, 0x20, 0x4d, 0x38, 0xa7, + 0x55, 0x86, 0xe1, 0x6e, 0xd5, 0x27, 0xb0, 0x9e, 0x28, 0x4d, 0xaa, 0xb1, 0x9d, 0xc0, 0x7a, 0x0f, + 0xfb, 0xed, 0xe7, 0x3e, 0xf6, 0x1c, 0x63, 0x30, 0x5d, 0x25, 0x69, 0xc6, 0x76, 0x2b, 0xfc, 0x99, + 0xb3, 0x88, 0xff, 0xa7, 0x5f, 0x35, 0xef, 0xc2, 0xad, 0xe4, 0x9e, 0x52, 0xc9, 0xfd, 0x29, 0xac, + 0xef, 0x7c, 0x49, 0x72, 0xab, 0xdf, 0x84, 0x5b, 0x3b, 0x5f, 0x9a, 0x64, 0x97, 0x68, 0xe1, 0x63, + 0xf6, 0xf9, 0xea, 0x9e, 0xed, 0xa4, 0x0b, 0x9b, 0x54, 0x97, 0x7d, 0x29, 0x28, 0xda, 0xa7, 0x92, + 0xef, 0xed, 0xb8, 0x7c, 0x17, 0x7e, 0x8c, 0xfe, 0x70, 0x03, 0x8a, 0x41, 0x79, 0x04, 0x2d, 0x41, + 0xb6, 0xfb, 0xb4, 0x5f, 0x5b, 0x40, 0x00, 0x8b, 0xad, 0xf6, 0x6e, 0xbb, 0xdf, 0xae, 0x29, 0x0f, + 0xbf, 0x9d, 0x81, 0x62, 0xf0, 0xaf, 0x01, 0x68, 0x11, 0x32, 0x07, 0x4f, 0x6a, 0x0b, 0xa8, 0x04, + 0x4b, 0x4f, 0xf7, 0x9f, 0xec, 0x1f, 0x7c, 0xb6, 0x5f, 0x53, 0xd0, 0x2a, 0xd4, 0xf6, 0x0f, 0xfa, + 0xfa, 0xd6, 0xc1, 0x41, 0xbf, 0xd7, 0xd7, 0x9a, 0xdd, 0x6e, 0xbb, 0x55, 0xcb, 0xa0, 0x6b, 0xb0, + 0xdc, 0xeb, 0x1f, 0x68, 0x6d, 0xbd, 0x7f, 0xb0, 0xb7, 0xd5, 0xeb, 0x1f, 0xec, 0xb7, 0x6b, 0x59, + 0x54, 0x87, 0xd5, 0xe6, 0xae, 0xd6, 0x6e, 0xb6, 0x3e, 0x8f, 0x92, 0xe7, 0x28, 0xa6, 0xb3, 0xbf, + 0x7d, 0xb0, 0xd7, 0x6d, 0xf6, 0x3b, 0x5b, 0xbb, 0x6d, 0xfd, 0x59, 0x5b, 0xeb, 0x75, 0x0e, 0xf6, + 0x6b, 0x79, 0xca, 0x5e, 0x6b, 0xef, 0x74, 0x0e, 0xf6, 0x75, 0xda, 0xcb, 0xe3, 0x83, 0xa7, 0xfb, + 0xad, 0xda, 0x22, 0x5a, 0x87, 0xb5, 0x9d, 0xdd, 0x83, 0xad, 0xe6, 0xae, 0xbe, 0x7d, 0xb0, 0xff, + 0xb8, 0xb3, 0x13, 0x42, 0x2e, 0xd1, 0x26, 0xad, 0xa7, 0xdd, 0xdd, 0xce, 0x76, 0xb3, 0xdf, 0x6e, + 0xe9, 0xed, 0xfd, 0xbe, 0xf6, 0x79, 0xad, 0x40, 0x25, 0x62, 0x8f, 0x21, 0xd2, 0x22, 0x5a, 0x81, + 0x4a, 0x67, 0xff, 0x59, 0x73, 0xb7, 0xd3, 0xd2, 0x9f, 0x35, 0x77, 0x9f, 0xb6, 0x6b, 0x80, 0x10, + 0x54, 0x5b, 0xcd, 0x7e, 0x53, 0x67, 0xd2, 0x6c, 0xf7, 0xdb, 0xad, 0x5a, 0xe9, 0xe1, 0x63, 0x28, + 0x85, 0x3e, 0x3a, 0xa0, 0x1d, 0x88, 0xf1, 0xeb, 0xbd, 0x67, 0xdb, 0xfa, 0xde, 0x41, 0xab, 0x5d, + 0x5b, 0x40, 0xcb, 0x50, 0xea, 0xb6, 0xa6, 0x00, 0x05, 0xd5, 0xa0, 0xdc, 0xec, 0x76, 0xa6, 0x90, + 0xcc, 0xc3, 0x0f, 0xa0, 0x14, 0xba, 0x02, 0x8c, 0x0a, 0x90, 0xeb, 0x6d, 0x37, 0xf7, 0x79, 0xdb, + 0x66, 0xb7, 0xab, 0x1d, 0x7c, 0xbd, 0xb3, 0xd7, 0xa4, 0x8a, 0xa7, 0x93, 0xf0, 0xb4, 0xd7, 0x7e, + 0xd2, 0xfe, 0xbc, 0x96, 0x79, 0xd8, 0x85, 0x6a, 0x34, 0x7c, 0xa7, 0x13, 0xd0, 0x7b, 0xba, 0xbd, + 0xdd, 0xee, 0xf5, 0xf8, 0x6c, 0xf4, 0x3b, 0x7b, 0xed, 0x83, 0xa7, 0x7d, 0xde, 0x6e, 0xbb, 0xb9, + 0xbf, 0xdd, 0xde, 0xad, 0x65, 0x28, 0x42, 0x6b, 0x77, 0x77, 0x9b, 0xdb, 0x54, 0xf7, 0xf4, 0xe5, + 0xe9, 0xfe, 0x7e, 0x67, 0x7f, 0xa7, 0x96, 0x7b, 0xf8, 0xf7, 0x0a, 0x14, 0xd9, 0x06, 0xf9, 0xc4, + 0x76, 0x2c, 0xda, 0xe6, 0xc0, 0x3f, 0xc1, 0x1e, 0xa9, 0x2d, 0xd0, 0x29, 0xde, 0xd9, 0xae, 0x29, + 0xd4, 0x1a, 0x76, 0xb0, 0x5f, 0xcb, 0x30, 0x19, 0x4d, 0xc3, 0xa9, 0x65, 0xa9, 0x8c, 0xa1, 0xdd, + 0xaf, 0x96, 0x63, 0x86, 0xc2, 0x36, 0xb5, 0x5a, 0x9e, 0x22, 0x43, 0x1b, 0x5c, 0x6d, 0x91, 0x99, + 0xd3, 0xd8, 0xaf, 0x2d, 0xa1, 0xf2, 0x74, 0x67, 0xab, 0x15, 0x50, 0x63, 0xde, 0x5e, 0x56, 0x2b, + 0x32, 0xd9, 0xd9, 0x0e, 0x55, 0x03, 0xda, 0x4a, 0xee, 0x49, 0xb5, 0xd2, 0xe6, 0x5f, 0xaf, 0x43, + 0xa6, 0xdb, 0x42, 0x7b, 0x50, 0x8d, 0x7e, 0x5d, 0x82, 0xd6, 0x83, 0x8f, 0x6a, 0x66, 0x3f, 0x5d, + 0x69, 0xdc, 0x4a, 0x46, 0xf2, 0x95, 0xa3, 0x2e, 0xa0, 0x26, 0xc0, 0xf4, 0x6b, 0x1c, 0xb4, 0x36, + 0xfb, 0x7d, 0x0e, 0x67, 0x53, 0x9f, 0xf7, 0xe1, 0x8e, 0xba, 0x80, 0xde, 0x85, 0x6c, 0x9f, 0xb8, + 0x48, 0xa4, 0xa6, 0xd3, 0xbf, 0xcc, 0x68, 0xac, 0x84, 0x20, 0x92, 0xfa, 0x81, 0xf2, 0xae, 0x82, + 0x3e, 0x86, 0x62, 0xf0, 0x7f, 0x04, 0x48, 0xfc, 0x57, 0x4a, 0xfc, 0x0f, 0x21, 0x1a, 0x6b, 0x33, + 0xf0, 0xa0, 0xc7, 0x3d, 0xa8, 0x46, 0xff, 0xd1, 0x40, 0xea, 0x20, 0xf1, 0xdf, 0x12, 0xa4, 0x0e, + 0x92, 0xff, 0x04, 0x41, 0x5d, 0x40, 0x1f, 0xc2, 0x92, 0xf8, 0xd7, 0x01, 0x24, 0x5c, 0x4b, 0xf4, + 0x3f, 0x0c, 0x1a, 0xd7, 0x63, 0xd0, 0xa0, 0xa5, 0x0e, 0xab, 0x49, 0x7f, 0x09, 0x80, 0x5e, 0x93, + 0x3d, 0xce, 0xfd, 0xeb, 0x81, 0x86, 0x7a, 0x11, 0x49, 0xd0, 0xc1, 0x2f, 0x40, 0x41, 0x7e, 0xb1, + 0x8f, 0xae, 0x07, 0x73, 0x10, 0xfe, 0x64, 0xbe, 0x71, 0x23, 0x0e, 0x0e, 0x37, 0x96, 0x5f, 0xbe, + 0xcb, 0xc6, 0xb1, 0xef, 0xed, 0x65, 0xe3, 0xf8, 0x07, 0xf2, 0xea, 0x02, 0xda, 0x81, 0x72, 0xf8, + 0x03, 0x71, 0x74, 0x33, 0xe8, 0x26, 0xfe, 0xc9, 0x7a, 0xa3, 0x91, 0x84, 0x0a, 0x4f, 0x56, 0xf4, + 0x9c, 0x57, 0x4e, 0x56, 0xe2, 0x35, 0x08, 0x39, 0x59, 0xc9, 0x47, 0xc3, 0xea, 0x02, 0xea, 0xc3, + 0x72, 0xec, 0xda, 0x3d, 0xba, 0x15, 0xae, 0xd3, 0xcc, 0x30, 0xbc, 0x3d, 0x07, 0x1b, 0xb7, 0xc8, + 0xe0, 0xb3, 0x67, 0x34, 0xd5, 0x68, 0xa4, 0x16, 0xd7, 0x58, 0x9b, 0x81, 0x07, 0x52, 0x6d, 0x41, + 0x65, 0x07, 0xfb, 0x5d, 0x0f, 0x9f, 0xa5, 0xe7, 0xf1, 0x98, 0xf1, 0x98, 0x7e, 0x7a, 0x8d, 0x1a, + 0x31, 0xda, 0xd0, 0xf7, 0xd8, 0x17, 0xf1, 0x69, 0x41, 0x29, 0xf4, 0xc1, 0x2f, 0x12, 0x4b, 0x77, + 0xf6, 0x7b, 0xea, 0xc6, 0xcd, 0x04, 0x4c, 0xc0, 0xe5, 0x63, 0x28, 0xc8, 0xeb, 0xe5, 0xd2, 0x78, + 0x62, 0xf7, 0xda, 0xa5, 0xf1, 0xc4, 0x6f, 0xa1, 0xab, 0xd9, 0xef, 0x64, 0x14, 0xb4, 0x03, 0xa5, + 0xd0, 0x45, 0x6c, 0x29, 0xc5, 0xec, 0x45, 0x71, 0x29, 0x45, 0xc2, 0xad, 0x6d, 0xce, 0xe8, 0x53, + 0xa8, 0x44, 0x2e, 0x2b, 0x4b, 0xb5, 0x24, 0x5d, 0xd0, 0x6e, 0xac, 0x27, 0xe2, 0x82, 0x41, 0xf5, + 0xa0, 0x16, 0xbf, 0x1e, 0x8c, 0x6e, 0x87, 0xfb, 0x9f, 0xe5, 0x78, 0x67, 0x1e, 0x3a, 0xcc, 0x34, + 0xfe, 0x41, 0xb1, 0x64, 0x3a, 0xe7, 0x83, 0x65, 0xc9, 0x74, 0xde, 0x77, 0xc8, 0x9c, 0x69, 0xfc, + 0xeb, 0x5d, 0xc9, 0x74, 0xce, 0x87, 0xc4, 0x92, 0xe9, 0xbc, 0x8f, 0x7e, 0xd5, 0x05, 0xaa, 0xca, + 0x48, 0xb2, 0x2f, 0x55, 0x99, 0x74, 0x1d, 0x40, 0xaa, 0x32, 0xf1, 0x80, 0x9c, 0x2f, 0xeb, 0xe8, + 0x49, 0x5c, 0x68, 0x1f, 0x9a, 0x3d, 0x48, 0x0d, 0xed, 0x43, 0x09, 0x87, 0x98, 0xea, 0x02, 0x7a, + 0x06, 0x2b, 0x33, 0xe7, 0x2d, 0x48, 0x8c, 0x68, 0xde, 0xf1, 0x73, 0xe3, 0xee, 0x5c, 0x7c, 0xc0, + 0xf7, 0x54, 0x9e, 0x5e, 0xcf, 0x1e, 0xa1, 0xa2, 0x37, 0xc2, 0xcd, 0xe7, 0x9e, 0x01, 0x37, 0xee, + 0x5f, 0x46, 0x16, 0xb3, 0x84, 0xc8, 0x89, 0x51, 0xc8, 0x12, 0x92, 0x0e, 0xb5, 0x42, 0x96, 0x90, + 0x78, 0xd0, 0xa4, 0x2e, 0xa0, 0x5f, 0x05, 0x34, 0x7b, 0x56, 0x87, 0xc4, 0xd0, 0xe7, 0x9e, 0x51, + 0x36, 0x36, 0xe6, 0x13, 0x48, 0xd6, 0xef, 0x2a, 0xe8, 0x1b, 0x70, 0x2d, 0xe1, 0x98, 0x0b, 0x6d, + 0xcc, 0x51, 0xec, 0x94, 0xfd, 0x6b, 0x17, 0x50, 0xcc, 0x55, 0x7e, 0xb8, 0x8b, 0x24, 0xe5, 0x27, + 0xf4, 0x73, 0xff, 0x32, 0xb2, 0x90, 0xfb, 0x2c, 0x4d, 0x8f, 0x14, 0x82, 0x50, 0x66, 0xe6, 0x44, + 0x45, 0x86, 0x32, 0xb3, 0xc7, 0x0f, 0x62, 0x2b, 0x68, 0x41, 0x29, 0x54, 0xb2, 0x46, 0xd3, 0xc8, + 0x27, 0x56, 0x26, 0x6f, 0xdc, 0x4c, 0xc0, 0x84, 0xdc, 0x67, 0x31, 0x28, 0xdb, 0xca, 0xcd, 0x20, + 0x5e, 0x50, 0x6e, 0xac, 0xcd, 0xc0, 0xc3, 0xdb, 0x6f, 0xb8, 0xb6, 0x29, 0xb7, 0xdf, 0x84, 0xa2, + 0xab, 0xdc, 0x7e, 0x93, 0x4a, 0xa1, 0xea, 0x02, 0xc2, 0x70, 0x23, 0xb9, 0xd0, 0x87, 0xee, 0x85, + 0xda, 0xcd, 0xab, 0x55, 0x36, 0x5e, 0xbf, 0x98, 0x28, 0xbc, 0x7e, 0x67, 0x2a, 0x5f, 0x68, 0x6a, + 0xdc, 0x89, 0xd5, 0x37, 0xb9, 0x7e, 0xe7, 0x96, 0xcc, 0x38, 0xdf, 0x99, 0xbf, 0x01, 0x94, 0x7c, + 0xe7, 0xfd, 0x1d, 0xa1, 0xe4, 0x3b, 0xf7, 0xff, 0x03, 0xf9, 0x52, 0x8d, 0xff, 0x99, 0x9f, 0x5c, + 0xaa, 0x73, 0xfe, 0x36, 0x50, 0x2e, 0xd5, 0x79, 0xff, 0x01, 0xa8, 0x2e, 0xa0, 0xaf, 0xc3, 0xca, + 0xcc, 0x7f, 0x37, 0x4a, 0x61, 0xe7, 0xfd, 0x5d, 0x64, 0xe3, 0xee, 0x5c, 0x7c, 0x68, 0x9d, 0xee, + 0x42, 0x25, 0x52, 0xe9, 0x91, 0x9e, 0x3b, 0xa9, 0x4c, 0x25, 0x3d, 0x77, 0x62, 0x69, 0x88, 0x1a, + 0x39, 0x5d, 0xf5, 0xb3, 0x15, 0x96, 0x9e, 0x5c, 0xf5, 0xf3, 0x4b, 0x41, 0x72, 0xd5, 0x5f, 0x50, + 0x9e, 0xe1, 0x41, 0x71, 0x52, 0x21, 0x44, 0x06, 0xc5, 0x17, 0x94, 0x63, 0x64, 0x50, 0x7c, 0x51, + 0x1d, 0x85, 0x77, 0xb0, 0x73, 0x41, 0x07, 0x3b, 0x97, 0x77, 0xb0, 0x73, 0x71, 0x07, 0x3c, 0xea, + 0x66, 0x45, 0x88, 0x50, 0xd4, 0x1d, 0x2e, 0x6a, 0x84, 0xa2, 0xee, 0x48, 0xad, 0x42, 0x5d, 0xd8, + 0xba, 0xff, 0x1f, 0x7f, 0x57, 0x50, 0xfe, 0xed, 0xc7, 0x77, 0x94, 0x7f, 0xff, 0xf1, 0x1d, 0xe5, + 0x47, 0x3f, 0xbe, 0xa3, 0xfc, 0xf9, 0x7f, 0xdd, 0x59, 0x80, 0x9a, 0xeb, 0x1d, 0x3f, 0xf2, 0xed, + 0xd3, 0xb3, 0x47, 0xa7, 0x67, 0xec, 0x2f, 0x44, 0x0f, 0x17, 0xd9, 0xcf, 0xfb, 0xff, 0x17, 0x00, + 0x00, 0xff, 0xff, 0x69, 0x26, 0x93, 0x5a, 0xd0, 0x54, 0x00, 0x00, } -// PDServer is the server API for PD service. -type PDServer interface { +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpc.ClientConn + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion4 + +// PDClient is the client API for PD service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type PDClient interface { // GetClusterInfo get the information of this cluster. It does not require // the cluster_id in request matchs the id of this cluster. - GetClusterInfo(context.Context, *GetClusterInfoRequest) (*GetClusterInfoResponse, error) + GetClusterInfo(ctx context.Context, in *GetClusterInfoRequest, opts ...grpc.CallOption) (*GetClusterInfoResponse, error) // GetMembers get the member list of this cluster. It does not require // the cluster_id in request matchs the id of this cluster. - GetMembers(context.Context, *GetMembersRequest) (*GetMembersResponse, error) - Tso(PD_TsoServer) error - Bootstrap(context.Context, *BootstrapRequest) (*BootstrapResponse, error) - IsBootstrapped(context.Context, *IsBootstrappedRequest) (*IsBootstrappedResponse, error) - AllocID(context.Context, *AllocIDRequest) (*AllocIDResponse, error) - IsSnapshotRecovering(context.Context, *IsSnapshotRecoveringRequest) (*IsSnapshotRecoveringResponse, error) - GetStore(context.Context, *GetStoreRequest) (*GetStoreResponse, error) - PutStore(context.Context, *PutStoreRequest) (*PutStoreResponse, error) - GetAllStores(context.Context, *GetAllStoresRequest) (*GetAllStoresResponse, error) - StoreHeartbeat(context.Context, *StoreHeartbeatRequest) (*StoreHeartbeatResponse, error) - RegionHeartbeat(PD_RegionHeartbeatServer) error - GetRegion(context.Context, *GetRegionRequest) (*GetRegionResponse, error) - GetPrevRegion(context.Context, *GetRegionRequest) (*GetRegionResponse, error) - GetRegionByID(context.Context, *GetRegionByIDRequest) (*GetRegionResponse, error) - ScanRegions(context.Context, *ScanRegionsRequest) (*ScanRegionsResponse, error) - AskSplit(context.Context, *AskSplitRequest) (*AskSplitResponse, error) - ReportSplit(context.Context, *ReportSplitRequest) (*ReportSplitResponse, error) - AskBatchSplit(context.Context, *AskBatchSplitRequest) (*AskBatchSplitResponse, error) - ReportBatchSplit(context.Context, *ReportBatchSplitRequest) (*ReportBatchSplitResponse, error) - GetClusterConfig(context.Context, *GetClusterConfigRequest) (*GetClusterConfigResponse, error) - PutClusterConfig(context.Context, *PutClusterConfigRequest) (*PutClusterConfigResponse, error) - ScatterRegion(context.Context, *ScatterRegionRequest) (*ScatterRegionResponse, error) - GetGCSafePoint(context.Context, *GetGCSafePointRequest) (*GetGCSafePointResponse, error) - UpdateGCSafePoint(context.Context, *UpdateGCSafePointRequest) (*UpdateGCSafePointResponse, error) - UpdateServiceGCSafePoint(context.Context, *UpdateServiceGCSafePointRequest) (*UpdateServiceGCSafePointResponse, error) - SyncRegions(PD_SyncRegionsServer) error - GetOperator(context.Context, *GetOperatorRequest) (*GetOperatorResponse, error) - SyncMaxTS(context.Context, *SyncMaxTSRequest) (*SyncMaxTSResponse, error) - SplitRegions(context.Context, *SplitRegionsRequest) (*SplitRegionsResponse, error) - SplitAndScatterRegions(context.Context, *SplitAndScatterRegionsRequest) (*SplitAndScatterRegionsResponse, error) - GetDCLocationInfo(context.Context, *GetDCLocationInfoRequest) (*GetDCLocationInfoResponse, error) - StoreGlobalConfig(context.Context, *StoreGlobalConfigRequest) (*StoreGlobalConfigResponse, error) - LoadGlobalConfig(context.Context, *LoadGlobalConfigRequest) (*LoadGlobalConfigResponse, error) - WatchGlobalConfig(*WatchGlobalConfigRequest, PD_WatchGlobalConfigServer) error - ReportBuckets(PD_ReportBucketsServer) error - ReportMinResolvedTS(context.Context, *ReportMinResolvedTsRequest) (*ReportMinResolvedTsResponse, error) - SetExternalTimestamp(context.Context, *SetExternalTimestampRequest) (*SetExternalTimestampResponse, error) - GetExternalTimestamp(context.Context, *GetExternalTimestampRequest) (*GetExternalTimestampResponse, error) + GetMembers(ctx context.Context, in *GetMembersRequest, opts ...grpc.CallOption) (*GetMembersResponse, error) + Tso(ctx context.Context, opts ...grpc.CallOption) (PD_TsoClient, error) + Bootstrap(ctx context.Context, in *BootstrapRequest, opts ...grpc.CallOption) (*BootstrapResponse, error) + IsBootstrapped(ctx context.Context, in *IsBootstrappedRequest, opts ...grpc.CallOption) (*IsBootstrappedResponse, error) + AllocID(ctx context.Context, in *AllocIDRequest, opts ...grpc.CallOption) (*AllocIDResponse, error) + IsSnapshotRecovering(ctx context.Context, in *IsSnapshotRecoveringRequest, opts ...grpc.CallOption) (*IsSnapshotRecoveringResponse, error) + GetStore(ctx context.Context, in *GetStoreRequest, opts ...grpc.CallOption) (*GetStoreResponse, error) + PutStore(ctx context.Context, in *PutStoreRequest, opts ...grpc.CallOption) (*PutStoreResponse, error) + GetAllStores(ctx context.Context, in *GetAllStoresRequest, opts ...grpc.CallOption) (*GetAllStoresResponse, error) + StoreHeartbeat(ctx context.Context, in *StoreHeartbeatRequest, opts ...grpc.CallOption) (*StoreHeartbeatResponse, error) + RegionHeartbeat(ctx context.Context, opts ...grpc.CallOption) (PD_RegionHeartbeatClient, error) + GetRegion(ctx context.Context, in *GetRegionRequest, opts ...grpc.CallOption) (*GetRegionResponse, error) + GetPrevRegion(ctx context.Context, in *GetRegionRequest, opts ...grpc.CallOption) (*GetRegionResponse, error) + GetRegionByID(ctx context.Context, in *GetRegionByIDRequest, opts ...grpc.CallOption) (*GetRegionResponse, error) + ScanRegions(ctx context.Context, in *ScanRegionsRequest, opts ...grpc.CallOption) (*ScanRegionsResponse, error) + AskSplit(ctx context.Context, in *AskSplitRequest, opts ...grpc.CallOption) (*AskSplitResponse, error) + ReportSplit(ctx context.Context, in *ReportSplitRequest, opts ...grpc.CallOption) (*ReportSplitResponse, error) + AskBatchSplit(ctx context.Context, in *AskBatchSplitRequest, opts ...grpc.CallOption) (*AskBatchSplitResponse, error) + ReportBatchSplit(ctx context.Context, in *ReportBatchSplitRequest, opts ...grpc.CallOption) (*ReportBatchSplitResponse, error) + GetClusterConfig(ctx context.Context, in *GetClusterConfigRequest, opts ...grpc.CallOption) (*GetClusterConfigResponse, error) + PutClusterConfig(ctx context.Context, in *PutClusterConfigRequest, opts ...grpc.CallOption) (*PutClusterConfigResponse, error) + ScatterRegion(ctx context.Context, in *ScatterRegionRequest, opts ...grpc.CallOption) (*ScatterRegionResponse, error) + GetGCSafePoint(ctx context.Context, in *GetGCSafePointRequest, opts ...grpc.CallOption) (*GetGCSafePointResponse, error) + UpdateGCSafePoint(ctx context.Context, in *UpdateGCSafePointRequest, opts ...grpc.CallOption) (*UpdateGCSafePointResponse, error) + UpdateServiceGCSafePoint(ctx context.Context, in *UpdateServiceGCSafePointRequest, opts ...grpc.CallOption) (*UpdateServiceGCSafePointResponse, error) + GetGCSafePointV2(ctx context.Context, in *GetGCSafePointV2Request, opts ...grpc.CallOption) (*GetGCSafePointV2Response, error) + WatchGCSafePointV2(ctx context.Context, in *WatchGCSafePointV2Request, opts ...grpc.CallOption) (PD_WatchGCSafePointV2Client, error) + UpdateGCSafePointV2(ctx context.Context, in *UpdateGCSafePointV2Request, opts ...grpc.CallOption) (*UpdateGCSafePointV2Response, error) + UpdateServiceSafePointV2(ctx context.Context, in *UpdateServiceSafePointV2Request, opts ...grpc.CallOption) (*UpdateServiceSafePointV2Response, error) + SyncRegions(ctx context.Context, opts ...grpc.CallOption) (PD_SyncRegionsClient, error) + GetOperator(ctx context.Context, in *GetOperatorRequest, opts ...grpc.CallOption) (*GetOperatorResponse, error) + SyncMaxTS(ctx context.Context, in *SyncMaxTSRequest, opts ...grpc.CallOption) (*SyncMaxTSResponse, error) + SplitRegions(ctx context.Context, in *SplitRegionsRequest, opts ...grpc.CallOption) (*SplitRegionsResponse, error) + SplitAndScatterRegions(ctx context.Context, in *SplitAndScatterRegionsRequest, opts ...grpc.CallOption) (*SplitAndScatterRegionsResponse, error) + GetDCLocationInfo(ctx context.Context, in *GetDCLocationInfoRequest, opts ...grpc.CallOption) (*GetDCLocationInfoResponse, error) + StoreGlobalConfig(ctx context.Context, in *StoreGlobalConfigRequest, opts ...grpc.CallOption) (*StoreGlobalConfigResponse, error) + LoadGlobalConfig(ctx context.Context, in *LoadGlobalConfigRequest, opts ...grpc.CallOption) (*LoadGlobalConfigResponse, error) + WatchGlobalConfig(ctx context.Context, in *WatchGlobalConfigRequest, opts ...grpc.CallOption) (PD_WatchGlobalConfigClient, error) + ReportBuckets(ctx context.Context, opts ...grpc.CallOption) (PD_ReportBucketsClient, error) + ReportMinResolvedTS(ctx context.Context, in *ReportMinResolvedTsRequest, opts ...grpc.CallOption) (*ReportMinResolvedTsResponse, error) + SetExternalTimestamp(ctx context.Context, in *SetExternalTimestampRequest, opts ...grpc.CallOption) (*SetExternalTimestampResponse, error) + GetExternalTimestamp(ctx context.Context, in *GetExternalTimestampRequest, opts ...grpc.CallOption) (*GetExternalTimestampResponse, error) + // Get the minimum timestamp across all keyspace groups from API server + // TODO: Currently, we need to ask API server to get the minimum timestamp. + // Once we support service discovery, we can remove it. + GetMinTS(ctx context.Context, in *GetMinTSRequest, opts ...grpc.CallOption) (*GetMinTSResponse, error) } -// UnimplementedPDServer can be embedded to have forward compatible implementations. -type UnimplementedPDServer struct { +type pDClient struct { + cc *grpc.ClientConn } -func (*UnimplementedPDServer) GetClusterInfo(ctx context.Context, req *GetClusterInfoRequest) (*GetClusterInfoResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method GetClusterInfo not implemented") +func NewPDClient(cc *grpc.ClientConn) PDClient { + return &pDClient{cc} } -func (*UnimplementedPDServer) GetMembers(ctx context.Context, req *GetMembersRequest) (*GetMembersResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method GetMembers not implemented") + +func (c *pDClient) GetClusterInfo(ctx context.Context, in *GetClusterInfoRequest, opts ...grpc.CallOption) (*GetClusterInfoResponse, error) { + out := new(GetClusterInfoResponse) + err := c.cc.Invoke(ctx, "/pdpb.PD/GetClusterInfo", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil } -func (*UnimplementedPDServer) Tso(srv PD_TsoServer) error { - return status.Errorf(codes.Unimplemented, "method Tso not implemented") + +func (c *pDClient) GetMembers(ctx context.Context, in *GetMembersRequest, opts ...grpc.CallOption) (*GetMembersResponse, error) { + out := new(GetMembersResponse) + err := c.cc.Invoke(ctx, "/pdpb.PD/GetMembers", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil } -func (*UnimplementedPDServer) Bootstrap(ctx context.Context, req *BootstrapRequest) (*BootstrapResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method Bootstrap not implemented") + +func (c *pDClient) Tso(ctx context.Context, opts ...grpc.CallOption) (PD_TsoClient, error) { + stream, err := c.cc.NewStream(ctx, &_PD_serviceDesc.Streams[0], "/pdpb.PD/Tso", opts...) + if err != nil { + return nil, err + } + x := &pDTsoClient{stream} + return x, nil } -func (*UnimplementedPDServer) IsBootstrapped(ctx context.Context, req *IsBootstrappedRequest) (*IsBootstrappedResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method IsBootstrapped not implemented") -} -func (*UnimplementedPDServer) AllocID(ctx context.Context, req *AllocIDRequest) (*AllocIDResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method AllocID not implemented") -} -func (*UnimplementedPDServer) IsSnapshotRecovering(ctx context.Context, req *IsSnapshotRecoveringRequest) (*IsSnapshotRecoveringResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method IsSnapshotRecovering not implemented") -} -func (*UnimplementedPDServer) GetStore(ctx context.Context, req *GetStoreRequest) (*GetStoreResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method GetStore not implemented") -} -func (*UnimplementedPDServer) PutStore(ctx context.Context, req *PutStoreRequest) (*PutStoreResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method PutStore not implemented") -} -func (*UnimplementedPDServer) GetAllStores(ctx context.Context, req *GetAllStoresRequest) (*GetAllStoresResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method GetAllStores not implemented") -} -func (*UnimplementedPDServer) StoreHeartbeat(ctx context.Context, req *StoreHeartbeatRequest) (*StoreHeartbeatResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method StoreHeartbeat not implemented") -} -func (*UnimplementedPDServer) RegionHeartbeat(srv PD_RegionHeartbeatServer) error { - return status.Errorf(codes.Unimplemented, "method RegionHeartbeat not implemented") -} -func (*UnimplementedPDServer) GetRegion(ctx context.Context, req *GetRegionRequest) (*GetRegionResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method GetRegion not implemented") -} -func (*UnimplementedPDServer) GetPrevRegion(ctx context.Context, req *GetRegionRequest) (*GetRegionResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method GetPrevRegion not implemented") -} -func (*UnimplementedPDServer) GetRegionByID(ctx context.Context, req *GetRegionByIDRequest) (*GetRegionResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method GetRegionByID not implemented") -} -func (*UnimplementedPDServer) ScanRegions(ctx context.Context, req *ScanRegionsRequest) (*ScanRegionsResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method ScanRegions not implemented") -} -func (*UnimplementedPDServer) AskSplit(ctx context.Context, req *AskSplitRequest) (*AskSplitResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method AskSplit not implemented") -} -func (*UnimplementedPDServer) ReportSplit(ctx context.Context, req *ReportSplitRequest) (*ReportSplitResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method ReportSplit not implemented") -} -func (*UnimplementedPDServer) AskBatchSplit(ctx context.Context, req *AskBatchSplitRequest) (*AskBatchSplitResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method AskBatchSplit not implemented") -} -func (*UnimplementedPDServer) ReportBatchSplit(ctx context.Context, req *ReportBatchSplitRequest) (*ReportBatchSplitResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method ReportBatchSplit not implemented") -} -func (*UnimplementedPDServer) GetClusterConfig(ctx context.Context, req *GetClusterConfigRequest) (*GetClusterConfigResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method GetClusterConfig not implemented") -} -func (*UnimplementedPDServer) PutClusterConfig(ctx context.Context, req *PutClusterConfigRequest) (*PutClusterConfigResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method PutClusterConfig not implemented") -} -func (*UnimplementedPDServer) ScatterRegion(ctx context.Context, req *ScatterRegionRequest) (*ScatterRegionResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method ScatterRegion not implemented") -} -func (*UnimplementedPDServer) GetGCSafePoint(ctx context.Context, req *GetGCSafePointRequest) (*GetGCSafePointResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method GetGCSafePoint not implemented") -} -func (*UnimplementedPDServer) UpdateGCSafePoint(ctx context.Context, req *UpdateGCSafePointRequest) (*UpdateGCSafePointResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method UpdateGCSafePoint not implemented") -} -func (*UnimplementedPDServer) UpdateServiceGCSafePoint(ctx context.Context, req *UpdateServiceGCSafePointRequest) (*UpdateServiceGCSafePointResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method UpdateServiceGCSafePoint not implemented") -} -func (*UnimplementedPDServer) SyncRegions(srv PD_SyncRegionsServer) error { - return status.Errorf(codes.Unimplemented, "method SyncRegions not implemented") -} -func (*UnimplementedPDServer) GetOperator(ctx context.Context, req *GetOperatorRequest) (*GetOperatorResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method GetOperator not implemented") -} -func (*UnimplementedPDServer) SyncMaxTS(ctx context.Context, req *SyncMaxTSRequest) (*SyncMaxTSResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method SyncMaxTS not implemented") -} -func (*UnimplementedPDServer) SplitRegions(ctx context.Context, req *SplitRegionsRequest) (*SplitRegionsResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method SplitRegions not implemented") -} -func (*UnimplementedPDServer) SplitAndScatterRegions(ctx context.Context, req *SplitAndScatterRegionsRequest) (*SplitAndScatterRegionsResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method SplitAndScatterRegions not implemented") -} -func (*UnimplementedPDServer) GetDCLocationInfo(ctx context.Context, req *GetDCLocationInfoRequest) (*GetDCLocationInfoResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method GetDCLocationInfo not implemented") -} -func (*UnimplementedPDServer) StoreGlobalConfig(ctx context.Context, req *StoreGlobalConfigRequest) (*StoreGlobalConfigResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method StoreGlobalConfig not implemented") -} -func (*UnimplementedPDServer) LoadGlobalConfig(ctx context.Context, req *LoadGlobalConfigRequest) (*LoadGlobalConfigResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method LoadGlobalConfig not implemented") -} -func (*UnimplementedPDServer) WatchGlobalConfig(req *WatchGlobalConfigRequest, srv PD_WatchGlobalConfigServer) error { - return status.Errorf(codes.Unimplemented, "method WatchGlobalConfig not implemented") -} -func (*UnimplementedPDServer) ReportBuckets(srv PD_ReportBucketsServer) error { - return status.Errorf(codes.Unimplemented, "method ReportBuckets not implemented") -} -func (*UnimplementedPDServer) ReportMinResolvedTS(ctx context.Context, req *ReportMinResolvedTsRequest) (*ReportMinResolvedTsResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method ReportMinResolvedTS not implemented") -} -func (*UnimplementedPDServer) SetExternalTimestamp(ctx context.Context, req *SetExternalTimestampRequest) (*SetExternalTimestampResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method SetExternalTimestamp not implemented") + +type PD_TsoClient interface { + Send(*TsoRequest) error + Recv() (*TsoResponse, error) + grpc.ClientStream } -func (*UnimplementedPDServer) GetExternalTimestamp(ctx context.Context, req *GetExternalTimestampRequest) (*GetExternalTimestampResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method GetExternalTimestamp not implemented") + +type pDTsoClient struct { + grpc.ClientStream } -func RegisterPDServer(s *grpc.Server, srv PDServer) { - s.RegisterService(&_PD_serviceDesc, srv) +func (x *pDTsoClient) Send(m *TsoRequest) error { + return x.ClientStream.SendMsg(m) } -func _PD_GetClusterInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(GetClusterInfoRequest) - if err := dec(in); err != nil { +func (x *pDTsoClient) Recv() (*TsoResponse, error) { + m := new(TsoResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err } - if interceptor == nil { - return srv.(PDServer).GetClusterInfo(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/pdpb.PD/GetClusterInfo", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(PDServer).GetClusterInfo(ctx, req.(*GetClusterInfoRequest)) - } - return interceptor(ctx, in, info, handler) + return m, nil } -func _PD_GetMembers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(GetMembersRequest) - if err := dec(in); err != nil { +func (c *pDClient) Bootstrap(ctx context.Context, in *BootstrapRequest, opts ...grpc.CallOption) (*BootstrapResponse, error) { + out := new(BootstrapResponse) + err := c.cc.Invoke(ctx, "/pdpb.PD/Bootstrap", in, out, opts...) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(PDServer).GetMembers(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/pdpb.PD/GetMembers", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(PDServer).GetMembers(ctx, req.(*GetMembersRequest)) - } - return interceptor(ctx, in, info, handler) + return out, nil } -func _PD_Tso_Handler(srv interface{}, stream grpc.ServerStream) error { - return srv.(PDServer).Tso(&pDTsoServer{stream}) +func (c *pDClient) IsBootstrapped(ctx context.Context, in *IsBootstrappedRequest, opts ...grpc.CallOption) (*IsBootstrappedResponse, error) { + out := new(IsBootstrappedResponse) + err := c.cc.Invoke(ctx, "/pdpb.PD/IsBootstrapped", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil } -type PD_TsoServer interface { - Send(*TsoResponse) error - Recv() (*TsoRequest, error) - grpc.ServerStream +func (c *pDClient) AllocID(ctx context.Context, in *AllocIDRequest, opts ...grpc.CallOption) (*AllocIDResponse, error) { + out := new(AllocIDResponse) + err := c.cc.Invoke(ctx, "/pdpb.PD/AllocID", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil } -type pDTsoServer struct { - grpc.ServerStream +func (c *pDClient) IsSnapshotRecovering(ctx context.Context, in *IsSnapshotRecoveringRequest, opts ...grpc.CallOption) (*IsSnapshotRecoveringResponse, error) { + out := new(IsSnapshotRecoveringResponse) + err := c.cc.Invoke(ctx, "/pdpb.PD/IsSnapshotRecovering", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil } -func (x *pDTsoServer) Send(m *TsoResponse) error { - return x.ServerStream.SendMsg(m) +func (c *pDClient) GetStore(ctx context.Context, in *GetStoreRequest, opts ...grpc.CallOption) (*GetStoreResponse, error) { + out := new(GetStoreResponse) + err := c.cc.Invoke(ctx, "/pdpb.PD/GetStore", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil } -func (x *pDTsoServer) Recv() (*TsoRequest, error) { - m := new(TsoRequest) - if err := x.ServerStream.RecvMsg(m); err != nil { +func (c *pDClient) PutStore(ctx context.Context, in *PutStoreRequest, opts ...grpc.CallOption) (*PutStoreResponse, error) { + out := new(PutStoreResponse) + err := c.cc.Invoke(ctx, "/pdpb.PD/PutStore", in, out, opts...) + if err != nil { return nil, err } - return m, nil + return out, nil } -func _PD_Bootstrap_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(BootstrapRequest) - if err := dec(in); err != nil { +func (c *pDClient) GetAllStores(ctx context.Context, in *GetAllStoresRequest, opts ...grpc.CallOption) (*GetAllStoresResponse, error) { + out := new(GetAllStoresResponse) + err := c.cc.Invoke(ctx, "/pdpb.PD/GetAllStores", in, out, opts...) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(PDServer).Bootstrap(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/pdpb.PD/Bootstrap", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(PDServer).Bootstrap(ctx, req.(*BootstrapRequest)) - } - return interceptor(ctx, in, info, handler) + return out, nil } -func _PD_IsBootstrapped_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(IsBootstrappedRequest) - if err := dec(in); err != nil { +func (c *pDClient) StoreHeartbeat(ctx context.Context, in *StoreHeartbeatRequest, opts ...grpc.CallOption) (*StoreHeartbeatResponse, error) { + out := new(StoreHeartbeatResponse) + err := c.cc.Invoke(ctx, "/pdpb.PD/StoreHeartbeat", in, out, opts...) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(PDServer).IsBootstrapped(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/pdpb.PD/IsBootstrapped", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(PDServer).IsBootstrapped(ctx, req.(*IsBootstrappedRequest)) - } - return interceptor(ctx, in, info, handler) + return out, nil } -func _PD_AllocID_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(AllocIDRequest) - if err := dec(in); err != nil { +func (c *pDClient) RegionHeartbeat(ctx context.Context, opts ...grpc.CallOption) (PD_RegionHeartbeatClient, error) { + stream, err := c.cc.NewStream(ctx, &_PD_serviceDesc.Streams[1], "/pdpb.PD/RegionHeartbeat", opts...) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(PDServer).AllocID(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/pdpb.PD/AllocID", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(PDServer).AllocID(ctx, req.(*AllocIDRequest)) - } - return interceptor(ctx, in, info, handler) + x := &pDRegionHeartbeatClient{stream} + return x, nil } -func _PD_IsSnapshotRecovering_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(IsSnapshotRecoveringRequest) - if err := dec(in); err != nil { +type PD_RegionHeartbeatClient interface { + Send(*RegionHeartbeatRequest) error + Recv() (*RegionHeartbeatResponse, error) + grpc.ClientStream +} + +type pDRegionHeartbeatClient struct { + grpc.ClientStream +} + +func (x *pDRegionHeartbeatClient) Send(m *RegionHeartbeatRequest) error { + return x.ClientStream.SendMsg(m) +} + +func (x *pDRegionHeartbeatClient) Recv() (*RegionHeartbeatResponse, error) { + m := new(RegionHeartbeatResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err } - if interceptor == nil { - return srv.(PDServer).IsSnapshotRecovering(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/pdpb.PD/IsSnapshotRecovering", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(PDServer).IsSnapshotRecovering(ctx, req.(*IsSnapshotRecoveringRequest)) - } - return interceptor(ctx, in, info, handler) + return m, nil } -func _PD_GetStore_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(GetStoreRequest) - if err := dec(in); err != nil { +func (c *pDClient) GetRegion(ctx context.Context, in *GetRegionRequest, opts ...grpc.CallOption) (*GetRegionResponse, error) { + out := new(GetRegionResponse) + err := c.cc.Invoke(ctx, "/pdpb.PD/GetRegion", in, out, opts...) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(PDServer).GetStore(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/pdpb.PD/GetStore", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(PDServer).GetStore(ctx, req.(*GetStoreRequest)) - } - return interceptor(ctx, in, info, handler) + return out, nil } -func _PD_PutStore_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(PutStoreRequest) - if err := dec(in); err != nil { +func (c *pDClient) GetPrevRegion(ctx context.Context, in *GetRegionRequest, opts ...grpc.CallOption) (*GetRegionResponse, error) { + out := new(GetRegionResponse) + err := c.cc.Invoke(ctx, "/pdpb.PD/GetPrevRegion", in, out, opts...) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(PDServer).PutStore(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/pdpb.PD/PutStore", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(PDServer).PutStore(ctx, req.(*PutStoreRequest)) - } - return interceptor(ctx, in, info, handler) + return out, nil } -func _PD_GetAllStores_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(GetAllStoresRequest) - if err := dec(in); err != nil { +func (c *pDClient) GetRegionByID(ctx context.Context, in *GetRegionByIDRequest, opts ...grpc.CallOption) (*GetRegionResponse, error) { + out := new(GetRegionResponse) + err := c.cc.Invoke(ctx, "/pdpb.PD/GetRegionByID", in, out, opts...) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(PDServer).GetAllStores(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/pdpb.PD/GetAllStores", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(PDServer).GetAllStores(ctx, req.(*GetAllStoresRequest)) - } - return interceptor(ctx, in, info, handler) + return out, nil } -func _PD_StoreHeartbeat_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(StoreHeartbeatRequest) - if err := dec(in); err != nil { +func (c *pDClient) ScanRegions(ctx context.Context, in *ScanRegionsRequest, opts ...grpc.CallOption) (*ScanRegionsResponse, error) { + out := new(ScanRegionsResponse) + err := c.cc.Invoke(ctx, "/pdpb.PD/ScanRegions", in, out, opts...) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(PDServer).StoreHeartbeat(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/pdpb.PD/StoreHeartbeat", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(PDServer).StoreHeartbeat(ctx, req.(*StoreHeartbeatRequest)) - } - return interceptor(ctx, in, info, handler) + return out, nil } -func _PD_RegionHeartbeat_Handler(srv interface{}, stream grpc.ServerStream) error { - return srv.(PDServer).RegionHeartbeat(&pDRegionHeartbeatServer{stream}) +// Deprecated: Do not use. +func (c *pDClient) AskSplit(ctx context.Context, in *AskSplitRequest, opts ...grpc.CallOption) (*AskSplitResponse, error) { + out := new(AskSplitResponse) + err := c.cc.Invoke(ctx, "/pdpb.PD/AskSplit", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil } -type PD_RegionHeartbeatServer interface { - Send(*RegionHeartbeatResponse) error - Recv() (*RegionHeartbeatRequest, error) - grpc.ServerStream +// Deprecated: Do not use. +func (c *pDClient) ReportSplit(ctx context.Context, in *ReportSplitRequest, opts ...grpc.CallOption) (*ReportSplitResponse, error) { + out := new(ReportSplitResponse) + err := c.cc.Invoke(ctx, "/pdpb.PD/ReportSplit", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil } -type pDRegionHeartbeatServer struct { - grpc.ServerStream +func (c *pDClient) AskBatchSplit(ctx context.Context, in *AskBatchSplitRequest, opts ...grpc.CallOption) (*AskBatchSplitResponse, error) { + out := new(AskBatchSplitResponse) + err := c.cc.Invoke(ctx, "/pdpb.PD/AskBatchSplit", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil } -func (x *pDRegionHeartbeatServer) Send(m *RegionHeartbeatResponse) error { - return x.ServerStream.SendMsg(m) +func (c *pDClient) ReportBatchSplit(ctx context.Context, in *ReportBatchSplitRequest, opts ...grpc.CallOption) (*ReportBatchSplitResponse, error) { + out := new(ReportBatchSplitResponse) + err := c.cc.Invoke(ctx, "/pdpb.PD/ReportBatchSplit", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil } -func (x *pDRegionHeartbeatServer) Recv() (*RegionHeartbeatRequest, error) { - m := new(RegionHeartbeatRequest) - if err := x.ServerStream.RecvMsg(m); err != nil { +func (c *pDClient) GetClusterConfig(ctx context.Context, in *GetClusterConfigRequest, opts ...grpc.CallOption) (*GetClusterConfigResponse, error) { + out := new(GetClusterConfigResponse) + err := c.cc.Invoke(ctx, "/pdpb.PD/GetClusterConfig", in, out, opts...) + if err != nil { return nil, err } - return m, nil + return out, nil } -func _PD_GetRegion_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(GetRegionRequest) - if err := dec(in); err != nil { +func (c *pDClient) PutClusterConfig(ctx context.Context, in *PutClusterConfigRequest, opts ...grpc.CallOption) (*PutClusterConfigResponse, error) { + out := new(PutClusterConfigResponse) + err := c.cc.Invoke(ctx, "/pdpb.PD/PutClusterConfig", in, out, opts...) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(PDServer).GetRegion(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/pdpb.PD/GetRegion", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(PDServer).GetRegion(ctx, req.(*GetRegionRequest)) - } - return interceptor(ctx, in, info, handler) + return out, nil } -func _PD_GetPrevRegion_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(GetRegionRequest) - if err := dec(in); err != nil { +func (c *pDClient) ScatterRegion(ctx context.Context, in *ScatterRegionRequest, opts ...grpc.CallOption) (*ScatterRegionResponse, error) { + out := new(ScatterRegionResponse) + err := c.cc.Invoke(ctx, "/pdpb.PD/ScatterRegion", in, out, opts...) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(PDServer).GetPrevRegion(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/pdpb.PD/GetPrevRegion", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(PDServer).GetPrevRegion(ctx, req.(*GetRegionRequest)) - } - return interceptor(ctx, in, info, handler) + return out, nil } -func _PD_GetRegionByID_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(GetRegionByIDRequest) - if err := dec(in); err != nil { +func (c *pDClient) GetGCSafePoint(ctx context.Context, in *GetGCSafePointRequest, opts ...grpc.CallOption) (*GetGCSafePointResponse, error) { + out := new(GetGCSafePointResponse) + err := c.cc.Invoke(ctx, "/pdpb.PD/GetGCSafePoint", in, out, opts...) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(PDServer).GetRegionByID(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/pdpb.PD/GetRegionByID", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(PDServer).GetRegionByID(ctx, req.(*GetRegionByIDRequest)) - } - return interceptor(ctx, in, info, handler) + return out, nil } -func _PD_ScanRegions_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(ScanRegionsRequest) - if err := dec(in); err != nil { +func (c *pDClient) UpdateGCSafePoint(ctx context.Context, in *UpdateGCSafePointRequest, opts ...grpc.CallOption) (*UpdateGCSafePointResponse, error) { + out := new(UpdateGCSafePointResponse) + err := c.cc.Invoke(ctx, "/pdpb.PD/UpdateGCSafePoint", in, out, opts...) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(PDServer).ScanRegions(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/pdpb.PD/ScanRegions", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(PDServer).ScanRegions(ctx, req.(*ScanRegionsRequest)) - } - return interceptor(ctx, in, info, handler) + return out, nil } -func _PD_AskSplit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(AskSplitRequest) - if err := dec(in); err != nil { +func (c *pDClient) UpdateServiceGCSafePoint(ctx context.Context, in *UpdateServiceGCSafePointRequest, opts ...grpc.CallOption) (*UpdateServiceGCSafePointResponse, error) { + out := new(UpdateServiceGCSafePointResponse) + err := c.cc.Invoke(ctx, "/pdpb.PD/UpdateServiceGCSafePoint", in, out, opts...) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(PDServer).AskSplit(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/pdpb.PD/AskSplit", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(PDServer).AskSplit(ctx, req.(*AskSplitRequest)) - } - return interceptor(ctx, in, info, handler) + return out, nil } -func _PD_ReportSplit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(ReportSplitRequest) - if err := dec(in); err != nil { +func (c *pDClient) GetGCSafePointV2(ctx context.Context, in *GetGCSafePointV2Request, opts ...grpc.CallOption) (*GetGCSafePointV2Response, error) { + out := new(GetGCSafePointV2Response) + err := c.cc.Invoke(ctx, "/pdpb.PD/GetGCSafePointV2", in, out, opts...) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(PDServer).ReportSplit(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/pdpb.PD/ReportSplit", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(PDServer).ReportSplit(ctx, req.(*ReportSplitRequest)) - } - return interceptor(ctx, in, info, handler) + return out, nil } -func _PD_AskBatchSplit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(AskBatchSplitRequest) - if err := dec(in); err != nil { +func (c *pDClient) WatchGCSafePointV2(ctx context.Context, in *WatchGCSafePointV2Request, opts ...grpc.CallOption) (PD_WatchGCSafePointV2Client, error) { + stream, err := c.cc.NewStream(ctx, &_PD_serviceDesc.Streams[2], "/pdpb.PD/WatchGCSafePointV2", opts...) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(PDServer).AskBatchSplit(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/pdpb.PD/AskBatchSplit", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(PDServer).AskBatchSplit(ctx, req.(*AskBatchSplitRequest)) - } - return interceptor(ctx, in, info, handler) -} - -func _PD_ReportBatchSplit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(ReportBatchSplitRequest) - if err := dec(in); err != nil { + x := &pDWatchGCSafePointV2Client{stream} + if err := x.ClientStream.SendMsg(in); err != nil { return nil, err } - if interceptor == nil { - return srv.(PDServer).ReportBatchSplit(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/pdpb.PD/ReportBatchSplit", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(PDServer).ReportBatchSplit(ctx, req.(*ReportBatchSplitRequest)) + if err := x.ClientStream.CloseSend(); err != nil { + return nil, err } - return interceptor(ctx, in, info, handler) + return x, nil } -func _PD_GetClusterConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(GetClusterConfigRequest) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(PDServer).GetClusterConfig(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/pdpb.PD/GetClusterConfig", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(PDServer).GetClusterConfig(ctx, req.(*GetClusterConfigRequest)) - } - return interceptor(ctx, in, info, handler) +type PD_WatchGCSafePointV2Client interface { + Recv() (*WatchGCSafePointV2Response, error) + grpc.ClientStream } -func _PD_PutClusterConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(PutClusterConfigRequest) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(PDServer).PutClusterConfig(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/pdpb.PD/PutClusterConfig", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(PDServer).PutClusterConfig(ctx, req.(*PutClusterConfigRequest)) - } - return interceptor(ctx, in, info, handler) +type pDWatchGCSafePointV2Client struct { + grpc.ClientStream } -func _PD_ScatterRegion_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(ScatterRegionRequest) - if err := dec(in); err != nil { +func (x *pDWatchGCSafePointV2Client) Recv() (*WatchGCSafePointV2Response, error) { + m := new(WatchGCSafePointV2Response) + if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err } - if interceptor == nil { - return srv.(PDServer).ScatterRegion(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/pdpb.PD/ScatterRegion", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(PDServer).ScatterRegion(ctx, req.(*ScatterRegionRequest)) - } - return interceptor(ctx, in, info, handler) + return m, nil } -func _PD_GetGCSafePoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(GetGCSafePointRequest) - if err := dec(in); err != nil { +func (c *pDClient) UpdateGCSafePointV2(ctx context.Context, in *UpdateGCSafePointV2Request, opts ...grpc.CallOption) (*UpdateGCSafePointV2Response, error) { + out := new(UpdateGCSafePointV2Response) + err := c.cc.Invoke(ctx, "/pdpb.PD/UpdateGCSafePointV2", in, out, opts...) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(PDServer).GetGCSafePoint(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/pdpb.PD/GetGCSafePoint", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(PDServer).GetGCSafePoint(ctx, req.(*GetGCSafePointRequest)) - } - return interceptor(ctx, in, info, handler) + return out, nil } -func _PD_UpdateGCSafePoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(UpdateGCSafePointRequest) - if err := dec(in); err != nil { +func (c *pDClient) UpdateServiceSafePointV2(ctx context.Context, in *UpdateServiceSafePointV2Request, opts ...grpc.CallOption) (*UpdateServiceSafePointV2Response, error) { + out := new(UpdateServiceSafePointV2Response) + err := c.cc.Invoke(ctx, "/pdpb.PD/UpdateServiceSafePointV2", in, out, opts...) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(PDServer).UpdateGCSafePoint(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/pdpb.PD/UpdateGCSafePoint", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(PDServer).UpdateGCSafePoint(ctx, req.(*UpdateGCSafePointRequest)) - } - return interceptor(ctx, in, info, handler) + return out, nil } -func _PD_UpdateServiceGCSafePoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(UpdateServiceGCSafePointRequest) - if err := dec(in); err != nil { +func (c *pDClient) SyncRegions(ctx context.Context, opts ...grpc.CallOption) (PD_SyncRegionsClient, error) { + stream, err := c.cc.NewStream(ctx, &_PD_serviceDesc.Streams[3], "/pdpb.PD/SyncRegions", opts...) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(PDServer).UpdateServiceGCSafePoint(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/pdpb.PD/UpdateServiceGCSafePoint", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(PDServer).UpdateServiceGCSafePoint(ctx, req.(*UpdateServiceGCSafePointRequest)) - } - return interceptor(ctx, in, info, handler) -} - -func _PD_SyncRegions_Handler(srv interface{}, stream grpc.ServerStream) error { - return srv.(PDServer).SyncRegions(&pDSyncRegionsServer{stream}) + x := &pDSyncRegionsClient{stream} + return x, nil } -type PD_SyncRegionsServer interface { - Send(*SyncRegionResponse) error - Recv() (*SyncRegionRequest, error) - grpc.ServerStream +type PD_SyncRegionsClient interface { + Send(*SyncRegionRequest) error + Recv() (*SyncRegionResponse, error) + grpc.ClientStream } -type pDSyncRegionsServer struct { - grpc.ServerStream +type pDSyncRegionsClient struct { + grpc.ClientStream } -func (x *pDSyncRegionsServer) Send(m *SyncRegionResponse) error { - return x.ServerStream.SendMsg(m) +func (x *pDSyncRegionsClient) Send(m *SyncRegionRequest) error { + return x.ClientStream.SendMsg(m) } -func (x *pDSyncRegionsServer) Recv() (*SyncRegionRequest, error) { - m := new(SyncRegionRequest) - if err := x.ServerStream.RecvMsg(m); err != nil { +func (x *pDSyncRegionsClient) Recv() (*SyncRegionResponse, error) { + m := new(SyncRegionResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err } return m, nil } -func _PD_GetOperator_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(GetOperatorRequest) - if err := dec(in); err != nil { +func (c *pDClient) GetOperator(ctx context.Context, in *GetOperatorRequest, opts ...grpc.CallOption) (*GetOperatorResponse, error) { + out := new(GetOperatorResponse) + err := c.cc.Invoke(ctx, "/pdpb.PD/GetOperator", in, out, opts...) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(PDServer).GetOperator(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/pdpb.PD/GetOperator", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(PDServer).GetOperator(ctx, req.(*GetOperatorRequest)) - } - return interceptor(ctx, in, info, handler) + return out, nil } -func _PD_SyncMaxTS_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(SyncMaxTSRequest) - if err := dec(in); err != nil { +func (c *pDClient) SyncMaxTS(ctx context.Context, in *SyncMaxTSRequest, opts ...grpc.CallOption) (*SyncMaxTSResponse, error) { + out := new(SyncMaxTSResponse) + err := c.cc.Invoke(ctx, "/pdpb.PD/SyncMaxTS", in, out, opts...) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(PDServer).SyncMaxTS(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/pdpb.PD/SyncMaxTS", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(PDServer).SyncMaxTS(ctx, req.(*SyncMaxTSRequest)) - } - return interceptor(ctx, in, info, handler) + return out, nil } -func _PD_SplitRegions_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(SplitRegionsRequest) - if err := dec(in); err != nil { +func (c *pDClient) SplitRegions(ctx context.Context, in *SplitRegionsRequest, opts ...grpc.CallOption) (*SplitRegionsResponse, error) { + out := new(SplitRegionsResponse) + err := c.cc.Invoke(ctx, "/pdpb.PD/SplitRegions", in, out, opts...) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(PDServer).SplitRegions(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/pdpb.PD/SplitRegions", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(PDServer).SplitRegions(ctx, req.(*SplitRegionsRequest)) - } - return interceptor(ctx, in, info, handler) + return out, nil } -func _PD_SplitAndScatterRegions_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(SplitAndScatterRegionsRequest) - if err := dec(in); err != nil { +func (c *pDClient) SplitAndScatterRegions(ctx context.Context, in *SplitAndScatterRegionsRequest, opts ...grpc.CallOption) (*SplitAndScatterRegionsResponse, error) { + out := new(SplitAndScatterRegionsResponse) + err := c.cc.Invoke(ctx, "/pdpb.PD/SplitAndScatterRegions", in, out, opts...) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(PDServer).SplitAndScatterRegions(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/pdpb.PD/SplitAndScatterRegions", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(PDServer).SplitAndScatterRegions(ctx, req.(*SplitAndScatterRegionsRequest)) - } - return interceptor(ctx, in, info, handler) + return out, nil } -func _PD_GetDCLocationInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(GetDCLocationInfoRequest) - if err := dec(in); err != nil { +func (c *pDClient) GetDCLocationInfo(ctx context.Context, in *GetDCLocationInfoRequest, opts ...grpc.CallOption) (*GetDCLocationInfoResponse, error) { + out := new(GetDCLocationInfoResponse) + err := c.cc.Invoke(ctx, "/pdpb.PD/GetDCLocationInfo", in, out, opts...) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(PDServer).GetDCLocationInfo(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/pdpb.PD/GetDCLocationInfo", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(PDServer).GetDCLocationInfo(ctx, req.(*GetDCLocationInfoRequest)) - } - return interceptor(ctx, in, info, handler) + return out, nil } -func _PD_StoreGlobalConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(StoreGlobalConfigRequest) - if err := dec(in); err != nil { +func (c *pDClient) StoreGlobalConfig(ctx context.Context, in *StoreGlobalConfigRequest, opts ...grpc.CallOption) (*StoreGlobalConfigResponse, error) { + out := new(StoreGlobalConfigResponse) + err := c.cc.Invoke(ctx, "/pdpb.PD/StoreGlobalConfig", in, out, opts...) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(PDServer).StoreGlobalConfig(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/pdpb.PD/StoreGlobalConfig", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(PDServer).StoreGlobalConfig(ctx, req.(*StoreGlobalConfigRequest)) - } - return interceptor(ctx, in, info, handler) + return out, nil } -func _PD_LoadGlobalConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(LoadGlobalConfigRequest) - if err := dec(in); err != nil { +func (c *pDClient) LoadGlobalConfig(ctx context.Context, in *LoadGlobalConfigRequest, opts ...grpc.CallOption) (*LoadGlobalConfigResponse, error) { + out := new(LoadGlobalConfigResponse) + err := c.cc.Invoke(ctx, "/pdpb.PD/LoadGlobalConfig", in, out, opts...) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(PDServer).LoadGlobalConfig(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/pdpb.PD/LoadGlobalConfig", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(PDServer).LoadGlobalConfig(ctx, req.(*LoadGlobalConfigRequest)) - } - return interceptor(ctx, in, info, handler) + return out, nil } -func _PD_WatchGlobalConfig_Handler(srv interface{}, stream grpc.ServerStream) error { - m := new(WatchGlobalConfigRequest) - if err := stream.RecvMsg(m); err != nil { - return err +func (c *pDClient) WatchGlobalConfig(ctx context.Context, in *WatchGlobalConfigRequest, opts ...grpc.CallOption) (PD_WatchGlobalConfigClient, error) { + stream, err := c.cc.NewStream(ctx, &_PD_serviceDesc.Streams[4], "/pdpb.PD/WatchGlobalConfig", opts...) + if err != nil { + return nil, err } - return srv.(PDServer).WatchGlobalConfig(m, &pDWatchGlobalConfigServer{stream}) + x := &pDWatchGlobalConfigClient{stream} + if err := x.ClientStream.SendMsg(in); err != nil { + return nil, err + } + if err := x.ClientStream.CloseSend(); err != nil { + return nil, err + } + return x, nil } -type PD_WatchGlobalConfigServer interface { - Send(*WatchGlobalConfigResponse) error - grpc.ServerStream +type PD_WatchGlobalConfigClient interface { + Recv() (*WatchGlobalConfigResponse, error) + grpc.ClientStream } -type pDWatchGlobalConfigServer struct { - grpc.ServerStream +type pDWatchGlobalConfigClient struct { + grpc.ClientStream } -func (x *pDWatchGlobalConfigServer) Send(m *WatchGlobalConfigResponse) error { - return x.ServerStream.SendMsg(m) +func (x *pDWatchGlobalConfigClient) Recv() (*WatchGlobalConfigResponse, error) { + m := new(WatchGlobalConfigResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil } -func _PD_ReportBuckets_Handler(srv interface{}, stream grpc.ServerStream) error { - return srv.(PDServer).ReportBuckets(&pDReportBucketsServer{stream}) +func (c *pDClient) ReportBuckets(ctx context.Context, opts ...grpc.CallOption) (PD_ReportBucketsClient, error) { + stream, err := c.cc.NewStream(ctx, &_PD_serviceDesc.Streams[5], "/pdpb.PD/ReportBuckets", opts...) + if err != nil { + return nil, err + } + x := &pDReportBucketsClient{stream} + return x, nil } -type PD_ReportBucketsServer interface { - SendAndClose(*ReportBucketsResponse) error - Recv() (*ReportBucketsRequest, error) - grpc.ServerStream +type PD_ReportBucketsClient interface { + Send(*ReportBucketsRequest) error + CloseAndRecv() (*ReportBucketsResponse, error) + grpc.ClientStream } -type pDReportBucketsServer struct { - grpc.ServerStream +type pDReportBucketsClient struct { + grpc.ClientStream } -func (x *pDReportBucketsServer) SendAndClose(m *ReportBucketsResponse) error { - return x.ServerStream.SendMsg(m) +func (x *pDReportBucketsClient) Send(m *ReportBucketsRequest) error { + return x.ClientStream.SendMsg(m) } -func (x *pDReportBucketsServer) Recv() (*ReportBucketsRequest, error) { - m := new(ReportBucketsRequest) - if err := x.ServerStream.RecvMsg(m); err != nil { +func (x *pDReportBucketsClient) CloseAndRecv() (*ReportBucketsResponse, error) { + if err := x.ClientStream.CloseSend(); err != nil { + return nil, err + } + m := new(ReportBucketsResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err } return m, nil } -func _PD_ReportMinResolvedTS_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(ReportMinResolvedTsRequest) - if err := dec(in); err != nil { +func (c *pDClient) ReportMinResolvedTS(ctx context.Context, in *ReportMinResolvedTsRequest, opts ...grpc.CallOption) (*ReportMinResolvedTsResponse, error) { + out := new(ReportMinResolvedTsResponse) + err := c.cc.Invoke(ctx, "/pdpb.PD/ReportMinResolvedTS", in, out, opts...) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(PDServer).ReportMinResolvedTS(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/pdpb.PD/ReportMinResolvedTS", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(PDServer).ReportMinResolvedTS(ctx, req.(*ReportMinResolvedTsRequest)) - } - return interceptor(ctx, in, info, handler) + return out, nil } -func _PD_SetExternalTimestamp_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(SetExternalTimestampRequest) - if err := dec(in); err != nil { +func (c *pDClient) SetExternalTimestamp(ctx context.Context, in *SetExternalTimestampRequest, opts ...grpc.CallOption) (*SetExternalTimestampResponse, error) { + out := new(SetExternalTimestampResponse) + err := c.cc.Invoke(ctx, "/pdpb.PD/SetExternalTimestamp", in, out, opts...) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(PDServer).SetExternalTimestamp(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/pdpb.PD/SetExternalTimestamp", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(PDServer).SetExternalTimestamp(ctx, req.(*SetExternalTimestampRequest)) - } - return interceptor(ctx, in, info, handler) + return out, nil } -func _PD_GetExternalTimestamp_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(GetExternalTimestampRequest) - if err := dec(in); err != nil { +func (c *pDClient) GetExternalTimestamp(ctx context.Context, in *GetExternalTimestampRequest, opts ...grpc.CallOption) (*GetExternalTimestampResponse, error) { + out := new(GetExternalTimestampResponse) + err := c.cc.Invoke(ctx, "/pdpb.PD/GetExternalTimestamp", in, out, opts...) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(PDServer).GetExternalTimestamp(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/pdpb.PD/GetExternalTimestamp", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(PDServer).GetExternalTimestamp(ctx, req.(*GetExternalTimestampRequest)) + return out, nil +} + +func (c *pDClient) GetMinTS(ctx context.Context, in *GetMinTSRequest, opts ...grpc.CallOption) (*GetMinTSResponse, error) { + out := new(GetMinTSResponse) + err := c.cc.Invoke(ctx, "/pdpb.PD/GetMinTS", in, out, opts...) + if err != nil { + return nil, err } - return interceptor(ctx, in, info, handler) + return out, nil } -var _PD_serviceDesc = grpc.ServiceDesc{ - ServiceName: "pdpb.PD", - HandlerType: (*PDServer)(nil), - Methods: []grpc.MethodDesc{ - { - MethodName: "GetClusterInfo", - Handler: _PD_GetClusterInfo_Handler, - }, - { - MethodName: "GetMembers", - Handler: _PD_GetMembers_Handler, - }, - { - MethodName: "Bootstrap", - Handler: _PD_Bootstrap_Handler, - }, - { - MethodName: "IsBootstrapped", - Handler: _PD_IsBootstrapped_Handler, - }, - { - MethodName: "AllocID", - Handler: _PD_AllocID_Handler, - }, - { - MethodName: "IsSnapshotRecovering", - Handler: _PD_IsSnapshotRecovering_Handler, - }, - { - MethodName: "GetStore", - Handler: _PD_GetStore_Handler, - }, - { - MethodName: "PutStore", - Handler: _PD_PutStore_Handler, - }, - { - MethodName: "GetAllStores", - Handler: _PD_GetAllStores_Handler, - }, - { - MethodName: "StoreHeartbeat", - Handler: _PD_StoreHeartbeat_Handler, - }, - { - MethodName: "GetRegion", - Handler: _PD_GetRegion_Handler, - }, - { - MethodName: "GetPrevRegion", - Handler: _PD_GetPrevRegion_Handler, - }, - { - MethodName: "GetRegionByID", - Handler: _PD_GetRegionByID_Handler, - }, - { - MethodName: "ScanRegions", - Handler: _PD_ScanRegions_Handler, - }, - { - MethodName: "AskSplit", - Handler: _PD_AskSplit_Handler, - }, - { - MethodName: "ReportSplit", - Handler: _PD_ReportSplit_Handler, - }, - { - MethodName: "AskBatchSplit", - Handler: _PD_AskBatchSplit_Handler, - }, - { - MethodName: "ReportBatchSplit", - Handler: _PD_ReportBatchSplit_Handler, - }, - { - MethodName: "GetClusterConfig", - Handler: _PD_GetClusterConfig_Handler, - }, - { - MethodName: "PutClusterConfig", - Handler: _PD_PutClusterConfig_Handler, - }, - { - MethodName: "ScatterRegion", - Handler: _PD_ScatterRegion_Handler, - }, - { - MethodName: "GetGCSafePoint", - Handler: _PD_GetGCSafePoint_Handler, - }, - { - MethodName: "UpdateGCSafePoint", - Handler: _PD_UpdateGCSafePoint_Handler, - }, - { - MethodName: "UpdateServiceGCSafePoint", - Handler: _PD_UpdateServiceGCSafePoint_Handler, - }, - { - MethodName: "GetOperator", - Handler: _PD_GetOperator_Handler, - }, - { - MethodName: "SyncMaxTS", - Handler: _PD_SyncMaxTS_Handler, - }, - { - MethodName: "SplitRegions", - Handler: _PD_SplitRegions_Handler, - }, - { - MethodName: "SplitAndScatterRegions", - Handler: _PD_SplitAndScatterRegions_Handler, - }, - { - MethodName: "GetDCLocationInfo", - Handler: _PD_GetDCLocationInfo_Handler, - }, - { - MethodName: "StoreGlobalConfig", - Handler: _PD_StoreGlobalConfig_Handler, - }, - { - MethodName: "LoadGlobalConfig", - Handler: _PD_LoadGlobalConfig_Handler, - }, - { - MethodName: "ReportMinResolvedTS", - Handler: _PD_ReportMinResolvedTS_Handler, - }, - { - MethodName: "SetExternalTimestamp", - Handler: _PD_SetExternalTimestamp_Handler, - }, - { - MethodName: "GetExternalTimestamp", - Handler: _PD_GetExternalTimestamp_Handler, - }, - }, - Streams: []grpc.StreamDesc{ - { - StreamName: "Tso", - Handler: _PD_Tso_Handler, - ServerStreams: true, - ClientStreams: true, - }, - { - StreamName: "RegionHeartbeat", - Handler: _PD_RegionHeartbeat_Handler, - ServerStreams: true, - ClientStreams: true, - }, - { - StreamName: "SyncRegions", - Handler: _PD_SyncRegions_Handler, - ServerStreams: true, - ClientStreams: true, - }, - { - StreamName: "WatchGlobalConfig", - Handler: _PD_WatchGlobalConfig_Handler, - ServerStreams: true, - }, - { - StreamName: "ReportBuckets", - Handler: _PD_ReportBuckets_Handler, - ClientStreams: true, - }, - }, - Metadata: "pdpb.proto", +// PDServer is the server API for PD service. +type PDServer interface { + // GetClusterInfo get the information of this cluster. It does not require + // the cluster_id in request matchs the id of this cluster. + GetClusterInfo(context.Context, *GetClusterInfoRequest) (*GetClusterInfoResponse, error) + // GetMembers get the member list of this cluster. It does not require + // the cluster_id in request matchs the id of this cluster. + GetMembers(context.Context, *GetMembersRequest) (*GetMembersResponse, error) + Tso(PD_TsoServer) error + Bootstrap(context.Context, *BootstrapRequest) (*BootstrapResponse, error) + IsBootstrapped(context.Context, *IsBootstrappedRequest) (*IsBootstrappedResponse, error) + AllocID(context.Context, *AllocIDRequest) (*AllocIDResponse, error) + IsSnapshotRecovering(context.Context, *IsSnapshotRecoveringRequest) (*IsSnapshotRecoveringResponse, error) + GetStore(context.Context, *GetStoreRequest) (*GetStoreResponse, error) + PutStore(context.Context, *PutStoreRequest) (*PutStoreResponse, error) + GetAllStores(context.Context, *GetAllStoresRequest) (*GetAllStoresResponse, error) + StoreHeartbeat(context.Context, *StoreHeartbeatRequest) (*StoreHeartbeatResponse, error) + RegionHeartbeat(PD_RegionHeartbeatServer) error + GetRegion(context.Context, *GetRegionRequest) (*GetRegionResponse, error) + GetPrevRegion(context.Context, *GetRegionRequest) (*GetRegionResponse, error) + GetRegionByID(context.Context, *GetRegionByIDRequest) (*GetRegionResponse, error) + ScanRegions(context.Context, *ScanRegionsRequest) (*ScanRegionsResponse, error) + AskSplit(context.Context, *AskSplitRequest) (*AskSplitResponse, error) + ReportSplit(context.Context, *ReportSplitRequest) (*ReportSplitResponse, error) + AskBatchSplit(context.Context, *AskBatchSplitRequest) (*AskBatchSplitResponse, error) + ReportBatchSplit(context.Context, *ReportBatchSplitRequest) (*ReportBatchSplitResponse, error) + GetClusterConfig(context.Context, *GetClusterConfigRequest) (*GetClusterConfigResponse, error) + PutClusterConfig(context.Context, *PutClusterConfigRequest) (*PutClusterConfigResponse, error) + ScatterRegion(context.Context, *ScatterRegionRequest) (*ScatterRegionResponse, error) + GetGCSafePoint(context.Context, *GetGCSafePointRequest) (*GetGCSafePointResponse, error) + UpdateGCSafePoint(context.Context, *UpdateGCSafePointRequest) (*UpdateGCSafePointResponse, error) + UpdateServiceGCSafePoint(context.Context, *UpdateServiceGCSafePointRequest) (*UpdateServiceGCSafePointResponse, error) + GetGCSafePointV2(context.Context, *GetGCSafePointV2Request) (*GetGCSafePointV2Response, error) + WatchGCSafePointV2(*WatchGCSafePointV2Request, PD_WatchGCSafePointV2Server) error + UpdateGCSafePointV2(context.Context, *UpdateGCSafePointV2Request) (*UpdateGCSafePointV2Response, error) + UpdateServiceSafePointV2(context.Context, *UpdateServiceSafePointV2Request) (*UpdateServiceSafePointV2Response, error) + SyncRegions(PD_SyncRegionsServer) error + GetOperator(context.Context, *GetOperatorRequest) (*GetOperatorResponse, error) + SyncMaxTS(context.Context, *SyncMaxTSRequest) (*SyncMaxTSResponse, error) + SplitRegions(context.Context, *SplitRegionsRequest) (*SplitRegionsResponse, error) + SplitAndScatterRegions(context.Context, *SplitAndScatterRegionsRequest) (*SplitAndScatterRegionsResponse, error) + GetDCLocationInfo(context.Context, *GetDCLocationInfoRequest) (*GetDCLocationInfoResponse, error) + StoreGlobalConfig(context.Context, *StoreGlobalConfigRequest) (*StoreGlobalConfigResponse, error) + LoadGlobalConfig(context.Context, *LoadGlobalConfigRequest) (*LoadGlobalConfigResponse, error) + WatchGlobalConfig(*WatchGlobalConfigRequest, PD_WatchGlobalConfigServer) error + ReportBuckets(PD_ReportBucketsServer) error + ReportMinResolvedTS(context.Context, *ReportMinResolvedTsRequest) (*ReportMinResolvedTsResponse, error) + SetExternalTimestamp(context.Context, *SetExternalTimestampRequest) (*SetExternalTimestampResponse, error) + GetExternalTimestamp(context.Context, *GetExternalTimestampRequest) (*GetExternalTimestampResponse, error) + // Get the minimum timestamp across all keyspace groups from API server + // TODO: Currently, we need to ask API server to get the minimum timestamp. + // Once we support service discovery, we can remove it. + GetMinTS(context.Context, *GetMinTSRequest) (*GetMinTSResponse, error) } -func (m *WatchGlobalConfigRequest) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil +// UnimplementedPDServer can be embedded to have forward compatible implementations. +type UnimplementedPDServer struct { } -func (m *WatchGlobalConfigRequest) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func (*UnimplementedPDServer) GetClusterInfo(ctx context.Context, req *GetClusterInfoRequest) (*GetClusterInfoResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetClusterInfo not implemented") } - -func (m *WatchGlobalConfigRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.XXX_unrecognized != nil { - i -= len(m.XXX_unrecognized) - copy(dAtA[i:], m.XXX_unrecognized) - } - if m.Revision != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.Revision)) - i-- - dAtA[i] = 0x10 - } - if len(m.ConfigPath) > 0 { - i -= len(m.ConfigPath) - copy(dAtA[i:], m.ConfigPath) - i = encodeVarintPdpb(dAtA, i, uint64(len(m.ConfigPath))) - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil +func (*UnimplementedPDServer) GetMembers(ctx context.Context, req *GetMembersRequest) (*GetMembersResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetMembers not implemented") } - -func (m *WatchGlobalConfigResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil +func (*UnimplementedPDServer) Tso(srv PD_TsoServer) error { + return status.Errorf(codes.Unimplemented, "method Tso not implemented") } - -func (m *WatchGlobalConfigResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func (*UnimplementedPDServer) Bootstrap(ctx context.Context, req *BootstrapRequest) (*BootstrapResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Bootstrap not implemented") } - -func (m *WatchGlobalConfigResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.XXX_unrecognized != nil { - i -= len(m.XXX_unrecognized) - copy(dAtA[i:], m.XXX_unrecognized) - } - if m.Header != nil { - { - size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a - } - if m.Revision != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.Revision)) - i-- - dAtA[i] = 0x10 - } - if len(m.Changes) > 0 { - for iNdEx := len(m.Changes) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.Changes[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - } - return len(dAtA) - i, nil +func (*UnimplementedPDServer) IsBootstrapped(ctx context.Context, req *IsBootstrappedRequest) (*IsBootstrappedResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method IsBootstrapped not implemented") } - -func (m *StoreGlobalConfigRequest) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil +func (*UnimplementedPDServer) AllocID(ctx context.Context, req *AllocIDRequest) (*AllocIDResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method AllocID not implemented") } - -func (m *StoreGlobalConfigRequest) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func (*UnimplementedPDServer) IsSnapshotRecovering(ctx context.Context, req *IsSnapshotRecoveringRequest) (*IsSnapshotRecoveringResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method IsSnapshotRecovering not implemented") +} +func (*UnimplementedPDServer) GetStore(ctx context.Context, req *GetStoreRequest) (*GetStoreResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetStore not implemented") +} +func (*UnimplementedPDServer) PutStore(ctx context.Context, req *PutStoreRequest) (*PutStoreResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method PutStore not implemented") +} +func (*UnimplementedPDServer) GetAllStores(ctx context.Context, req *GetAllStoresRequest) (*GetAllStoresResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetAllStores not implemented") +} +func (*UnimplementedPDServer) StoreHeartbeat(ctx context.Context, req *StoreHeartbeatRequest) (*StoreHeartbeatResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method StoreHeartbeat not implemented") +} +func (*UnimplementedPDServer) RegionHeartbeat(srv PD_RegionHeartbeatServer) error { + return status.Errorf(codes.Unimplemented, "method RegionHeartbeat not implemented") +} +func (*UnimplementedPDServer) GetRegion(ctx context.Context, req *GetRegionRequest) (*GetRegionResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetRegion not implemented") +} +func (*UnimplementedPDServer) GetPrevRegion(ctx context.Context, req *GetRegionRequest) (*GetRegionResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetPrevRegion not implemented") +} +func (*UnimplementedPDServer) GetRegionByID(ctx context.Context, req *GetRegionByIDRequest) (*GetRegionResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetRegionByID not implemented") +} +func (*UnimplementedPDServer) ScanRegions(ctx context.Context, req *ScanRegionsRequest) (*ScanRegionsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ScanRegions not implemented") +} +func (*UnimplementedPDServer) AskSplit(ctx context.Context, req *AskSplitRequest) (*AskSplitResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method AskSplit not implemented") +} +func (*UnimplementedPDServer) ReportSplit(ctx context.Context, req *ReportSplitRequest) (*ReportSplitResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ReportSplit not implemented") +} +func (*UnimplementedPDServer) AskBatchSplit(ctx context.Context, req *AskBatchSplitRequest) (*AskBatchSplitResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method AskBatchSplit not implemented") +} +func (*UnimplementedPDServer) ReportBatchSplit(ctx context.Context, req *ReportBatchSplitRequest) (*ReportBatchSplitResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ReportBatchSplit not implemented") +} +func (*UnimplementedPDServer) GetClusterConfig(ctx context.Context, req *GetClusterConfigRequest) (*GetClusterConfigResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetClusterConfig not implemented") +} +func (*UnimplementedPDServer) PutClusterConfig(ctx context.Context, req *PutClusterConfigRequest) (*PutClusterConfigResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method PutClusterConfig not implemented") +} +func (*UnimplementedPDServer) ScatterRegion(ctx context.Context, req *ScatterRegionRequest) (*ScatterRegionResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ScatterRegion not implemented") +} +func (*UnimplementedPDServer) GetGCSafePoint(ctx context.Context, req *GetGCSafePointRequest) (*GetGCSafePointResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetGCSafePoint not implemented") +} +func (*UnimplementedPDServer) UpdateGCSafePoint(ctx context.Context, req *UpdateGCSafePointRequest) (*UpdateGCSafePointResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method UpdateGCSafePoint not implemented") +} +func (*UnimplementedPDServer) UpdateServiceGCSafePoint(ctx context.Context, req *UpdateServiceGCSafePointRequest) (*UpdateServiceGCSafePointResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method UpdateServiceGCSafePoint not implemented") +} +func (*UnimplementedPDServer) GetGCSafePointV2(ctx context.Context, req *GetGCSafePointV2Request) (*GetGCSafePointV2Response, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetGCSafePointV2 not implemented") +} +func (*UnimplementedPDServer) WatchGCSafePointV2(req *WatchGCSafePointV2Request, srv PD_WatchGCSafePointV2Server) error { + return status.Errorf(codes.Unimplemented, "method WatchGCSafePointV2 not implemented") +} +func (*UnimplementedPDServer) UpdateGCSafePointV2(ctx context.Context, req *UpdateGCSafePointV2Request) (*UpdateGCSafePointV2Response, error) { + return nil, status.Errorf(codes.Unimplemented, "method UpdateGCSafePointV2 not implemented") +} +func (*UnimplementedPDServer) UpdateServiceSafePointV2(ctx context.Context, req *UpdateServiceSafePointV2Request) (*UpdateServiceSafePointV2Response, error) { + return nil, status.Errorf(codes.Unimplemented, "method UpdateServiceSafePointV2 not implemented") +} +func (*UnimplementedPDServer) SyncRegions(srv PD_SyncRegionsServer) error { + return status.Errorf(codes.Unimplemented, "method SyncRegions not implemented") +} +func (*UnimplementedPDServer) GetOperator(ctx context.Context, req *GetOperatorRequest) (*GetOperatorResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetOperator not implemented") +} +func (*UnimplementedPDServer) SyncMaxTS(ctx context.Context, req *SyncMaxTSRequest) (*SyncMaxTSResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method SyncMaxTS not implemented") +} +func (*UnimplementedPDServer) SplitRegions(ctx context.Context, req *SplitRegionsRequest) (*SplitRegionsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method SplitRegions not implemented") +} +func (*UnimplementedPDServer) SplitAndScatterRegions(ctx context.Context, req *SplitAndScatterRegionsRequest) (*SplitAndScatterRegionsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method SplitAndScatterRegions not implemented") +} +func (*UnimplementedPDServer) GetDCLocationInfo(ctx context.Context, req *GetDCLocationInfoRequest) (*GetDCLocationInfoResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetDCLocationInfo not implemented") +} +func (*UnimplementedPDServer) StoreGlobalConfig(ctx context.Context, req *StoreGlobalConfigRequest) (*StoreGlobalConfigResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method StoreGlobalConfig not implemented") +} +func (*UnimplementedPDServer) LoadGlobalConfig(ctx context.Context, req *LoadGlobalConfigRequest) (*LoadGlobalConfigResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method LoadGlobalConfig not implemented") +} +func (*UnimplementedPDServer) WatchGlobalConfig(req *WatchGlobalConfigRequest, srv PD_WatchGlobalConfigServer) error { + return status.Errorf(codes.Unimplemented, "method WatchGlobalConfig not implemented") +} +func (*UnimplementedPDServer) ReportBuckets(srv PD_ReportBucketsServer) error { + return status.Errorf(codes.Unimplemented, "method ReportBuckets not implemented") +} +func (*UnimplementedPDServer) ReportMinResolvedTS(ctx context.Context, req *ReportMinResolvedTsRequest) (*ReportMinResolvedTsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ReportMinResolvedTS not implemented") +} +func (*UnimplementedPDServer) SetExternalTimestamp(ctx context.Context, req *SetExternalTimestampRequest) (*SetExternalTimestampResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method SetExternalTimestamp not implemented") +} +func (*UnimplementedPDServer) GetExternalTimestamp(ctx context.Context, req *GetExternalTimestampRequest) (*GetExternalTimestampResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetExternalTimestamp not implemented") +} +func (*UnimplementedPDServer) GetMinTS(ctx context.Context, req *GetMinTSRequest) (*GetMinTSResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetMinTS not implemented") } -func (m *StoreGlobalConfigRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.XXX_unrecognized != nil { - i -= len(m.XXX_unrecognized) - copy(dAtA[i:], m.XXX_unrecognized) +func RegisterPDServer(s *grpc.Server, srv PDServer) { + s.RegisterService(&_PD_serviceDesc, srv) +} + +func _PD_GetClusterInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetClusterInfoRequest) + if err := dec(in); err != nil { + return nil, err } - if len(m.ConfigPath) > 0 { - i -= len(m.ConfigPath) - copy(dAtA[i:], m.ConfigPath) - i = encodeVarintPdpb(dAtA, i, uint64(len(m.ConfigPath))) - i-- - dAtA[i] = 0x12 + if interceptor == nil { + return srv.(PDServer).GetClusterInfo(ctx, in) } - if len(m.Changes) > 0 { - for iNdEx := len(m.Changes) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.Changes[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/pdpb.PD/GetClusterInfo", } - return len(dAtA) - i, nil + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(PDServer).GetClusterInfo(ctx, req.(*GetClusterInfoRequest)) + } + return interceptor(ctx, in, info, handler) } -func (m *StoreGlobalConfigResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { +func _PD_GetMembers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetMembersRequest) + if err := dec(in); err != nil { return nil, err } - return dAtA[:n], nil + if interceptor == nil { + return srv.(PDServer).GetMembers(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/pdpb.PD/GetMembers", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(PDServer).GetMembers(ctx, req.(*GetMembersRequest)) + } + return interceptor(ctx, in, info, handler) } -func (m *StoreGlobalConfigResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func _PD_Tso_Handler(srv interface{}, stream grpc.ServerStream) error { + return srv.(PDServer).Tso(&pDTsoServer{stream}) } -func (m *StoreGlobalConfigResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.XXX_unrecognized != nil { - i -= len(m.XXX_unrecognized) - copy(dAtA[i:], m.XXX_unrecognized) - } - if m.Error != nil { - { - size, err := m.Error.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil +type PD_TsoServer interface { + Send(*TsoResponse) error + Recv() (*TsoRequest, error) + grpc.ServerStream } -func (m *LoadGlobalConfigRequest) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil +type pDTsoServer struct { + grpc.ServerStream } -func (m *LoadGlobalConfigRequest) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func (x *pDTsoServer) Send(m *TsoResponse) error { + return x.ServerStream.SendMsg(m) } -func (m *LoadGlobalConfigRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.XXX_unrecognized != nil { - i -= len(m.XXX_unrecognized) - copy(dAtA[i:], m.XXX_unrecognized) - } - if len(m.ConfigPath) > 0 { - i -= len(m.ConfigPath) - copy(dAtA[i:], m.ConfigPath) - i = encodeVarintPdpb(dAtA, i, uint64(len(m.ConfigPath))) - i-- - dAtA[i] = 0x12 - } - if len(m.Names) > 0 { - for iNdEx := len(m.Names) - 1; iNdEx >= 0; iNdEx-- { - i -= len(m.Names[iNdEx]) - copy(dAtA[i:], m.Names[iNdEx]) - i = encodeVarintPdpb(dAtA, i, uint64(len(m.Names[iNdEx]))) - i-- - dAtA[i] = 0xa - } +func (x *pDTsoServer) Recv() (*TsoRequest, error) { + m := new(TsoRequest) + if err := x.ServerStream.RecvMsg(m); err != nil { + return nil, err } - return len(dAtA) - i, nil + return m, nil } -func (m *LoadGlobalConfigResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { +func _PD_Bootstrap_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(BootstrapRequest) + if err := dec(in); err != nil { return nil, err } - return dAtA[:n], nil -} - -func (m *LoadGlobalConfigResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *LoadGlobalConfigResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.XXX_unrecognized != nil { - i -= len(m.XXX_unrecognized) - copy(dAtA[i:], m.XXX_unrecognized) + if interceptor == nil { + return srv.(PDServer).Bootstrap(ctx, in) } - if m.Revision != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.Revision)) - i-- - dAtA[i] = 0x10 + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/pdpb.PD/Bootstrap", } - if len(m.Items) > 0 { - for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(PDServer).Bootstrap(ctx, req.(*BootstrapRequest)) } - return len(dAtA) - i, nil + return interceptor(ctx, in, info, handler) } -func (m *GlobalConfigItem) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { +func _PD_IsBootstrapped_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(IsBootstrappedRequest) + if err := dec(in); err != nil { return nil, err } - return dAtA[:n], nil -} - -func (m *GlobalConfigItem) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *GlobalConfigItem) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.XXX_unrecognized != nil { - i -= len(m.XXX_unrecognized) - copy(dAtA[i:], m.XXX_unrecognized) + if interceptor == nil { + return srv.(PDServer).IsBootstrapped(ctx, in) } - if len(m.Payload) > 0 { - i -= len(m.Payload) - copy(dAtA[i:], m.Payload) - i = encodeVarintPdpb(dAtA, i, uint64(len(m.Payload))) - i-- - dAtA[i] = 0x2a + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/pdpb.PD/IsBootstrapped", } - if m.Kind != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.Kind)) - i-- - dAtA[i] = 0x20 + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(PDServer).IsBootstrapped(ctx, req.(*IsBootstrappedRequest)) } - if m.Error != nil { - { - size, err := m.Error.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a + return interceptor(ctx, in, info, handler) +} + +func _PD_AllocID_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(AllocIDRequest) + if err := dec(in); err != nil { + return nil, err } - if len(m.Value) > 0 { - i -= len(m.Value) - copy(dAtA[i:], m.Value) - i = encodeVarintPdpb(dAtA, i, uint64(len(m.Value))) - i-- - dAtA[i] = 0x12 + if interceptor == nil { + return srv.(PDServer).AllocID(ctx, in) } - if len(m.Name) > 0 { - i -= len(m.Name) - copy(dAtA[i:], m.Name) - i = encodeVarintPdpb(dAtA, i, uint64(len(m.Name))) - i-- - dAtA[i] = 0xa + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/pdpb.PD/AllocID", } - return len(dAtA) - i, nil + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(PDServer).AllocID(ctx, req.(*AllocIDRequest)) + } + return interceptor(ctx, in, info, handler) } -func (m *RequestHeader) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { +func _PD_IsSnapshotRecovering_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(IsSnapshotRecoveringRequest) + if err := dec(in); err != nil { return nil, err } - return dAtA[:n], nil -} - -func (m *RequestHeader) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *RequestHeader) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.XXX_unrecognized != nil { - i -= len(m.XXX_unrecognized) - copy(dAtA[i:], m.XXX_unrecognized) + if interceptor == nil { + return srv.(PDServer).IsSnapshotRecovering(ctx, in) } - if m.SenderId != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.SenderId)) - i-- - dAtA[i] = 0x10 + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/pdpb.PD/IsSnapshotRecovering", } - if m.ClusterId != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.ClusterId)) - i-- - dAtA[i] = 0x8 + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(PDServer).IsSnapshotRecovering(ctx, req.(*IsSnapshotRecoveringRequest)) } - return len(dAtA) - i, nil + return interceptor(ctx, in, info, handler) } -func (m *ResponseHeader) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { +func _PD_GetStore_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetStoreRequest) + if err := dec(in); err != nil { return nil, err } - return dAtA[:n], nil + if interceptor == nil { + return srv.(PDServer).GetStore(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/pdpb.PD/GetStore", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(PDServer).GetStore(ctx, req.(*GetStoreRequest)) + } + return interceptor(ctx, in, info, handler) } -func (m *ResponseHeader) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func _PD_PutStore_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(PutStoreRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(PDServer).PutStore(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/pdpb.PD/PutStore", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(PDServer).PutStore(ctx, req.(*PutStoreRequest)) + } + return interceptor(ctx, in, info, handler) } -func (m *ResponseHeader) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.XXX_unrecognized != nil { - i -= len(m.XXX_unrecognized) - copy(dAtA[i:], m.XXX_unrecognized) +func _PD_GetAllStores_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetAllStoresRequest) + if err := dec(in); err != nil { + return nil, err } - if m.Error != nil { - { - size, err := m.Error.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 + if interceptor == nil { + return srv.(PDServer).GetAllStores(ctx, in) } - if m.ClusterId != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.ClusterId)) - i-- - dAtA[i] = 0x8 + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/pdpb.PD/GetAllStores", } - return len(dAtA) - i, nil + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(PDServer).GetAllStores(ctx, req.(*GetAllStoresRequest)) + } + return interceptor(ctx, in, info, handler) } -func (m *Error) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { +func _PD_StoreHeartbeat_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(StoreHeartbeatRequest) + if err := dec(in); err != nil { return nil, err } - return dAtA[:n], nil + if interceptor == nil { + return srv.(PDServer).StoreHeartbeat(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/pdpb.PD/StoreHeartbeat", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(PDServer).StoreHeartbeat(ctx, req.(*StoreHeartbeatRequest)) + } + return interceptor(ctx, in, info, handler) } -func (m *Error) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func _PD_RegionHeartbeat_Handler(srv interface{}, stream grpc.ServerStream) error { + return srv.(PDServer).RegionHeartbeat(&pDRegionHeartbeatServer{stream}) } -func (m *Error) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.XXX_unrecognized != nil { - i -= len(m.XXX_unrecognized) - copy(dAtA[i:], m.XXX_unrecognized) - } - if len(m.Message) > 0 { - i -= len(m.Message) - copy(dAtA[i:], m.Message) - i = encodeVarintPdpb(dAtA, i, uint64(len(m.Message))) - i-- - dAtA[i] = 0x12 - } - if m.Type != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.Type)) - i-- - dAtA[i] = 0x8 - } - return len(dAtA) - i, nil +type PD_RegionHeartbeatServer interface { + Send(*RegionHeartbeatResponse) error + Recv() (*RegionHeartbeatRequest, error) + grpc.ServerStream } -func (m *TsoRequest) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil +type pDRegionHeartbeatServer struct { + grpc.ServerStream } -func (m *TsoRequest) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func (x *pDRegionHeartbeatServer) Send(m *RegionHeartbeatResponse) error { + return x.ServerStream.SendMsg(m) } -func (m *TsoRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.XXX_unrecognized != nil { - i -= len(m.XXX_unrecognized) - copy(dAtA[i:], m.XXX_unrecognized) +func (x *pDRegionHeartbeatServer) Recv() (*RegionHeartbeatRequest, error) { + m := new(RegionHeartbeatRequest) + if err := x.ServerStream.RecvMsg(m); err != nil { + return nil, err } - if len(m.DcLocation) > 0 { - i -= len(m.DcLocation) - copy(dAtA[i:], m.DcLocation) - i = encodeVarintPdpb(dAtA, i, uint64(len(m.DcLocation))) - i-- - dAtA[i] = 0x1a + return m, nil +} + +func _PD_GetRegion_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetRegionRequest) + if err := dec(in); err != nil { + return nil, err } - if m.Count != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.Count)) - i-- - dAtA[i] = 0x10 + if interceptor == nil { + return srv.(PDServer).GetRegion(ctx, in) } - if m.Header != nil { - { - size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/pdpb.PD/GetRegion", } - return len(dAtA) - i, nil + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(PDServer).GetRegion(ctx, req.(*GetRegionRequest)) + } + return interceptor(ctx, in, info, handler) } -func (m *Timestamp) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { +func _PD_GetPrevRegion_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetRegionRequest) + if err := dec(in); err != nil { return nil, err } - return dAtA[:n], nil -} - -func (m *Timestamp) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) + if interceptor == nil { + return srv.(PDServer).GetPrevRegion(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/pdpb.PD/GetPrevRegion", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(PDServer).GetPrevRegion(ctx, req.(*GetRegionRequest)) + } + return interceptor(ctx, in, info, handler) } -func (m *Timestamp) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.XXX_unrecognized != nil { - i -= len(m.XXX_unrecognized) - copy(dAtA[i:], m.XXX_unrecognized) +func _PD_GetRegionByID_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetRegionByIDRequest) + if err := dec(in); err != nil { + return nil, err } - if m.SuffixBits != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.SuffixBits)) - i-- - dAtA[i] = 0x18 + if interceptor == nil { + return srv.(PDServer).GetRegionByID(ctx, in) } - if m.Logical != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.Logical)) - i-- - dAtA[i] = 0x10 + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/pdpb.PD/GetRegionByID", } - if m.Physical != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.Physical)) - i-- - dAtA[i] = 0x8 + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(PDServer).GetRegionByID(ctx, req.(*GetRegionByIDRequest)) } - return len(dAtA) - i, nil + return interceptor(ctx, in, info, handler) } -func (m *TsoResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { +func _PD_ScanRegions_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ScanRegionsRequest) + if err := dec(in); err != nil { return nil, err } - return dAtA[:n], nil -} - -func (m *TsoResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) + if interceptor == nil { + return srv.(PDServer).ScanRegions(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/pdpb.PD/ScanRegions", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(PDServer).ScanRegions(ctx, req.(*ScanRegionsRequest)) + } + return interceptor(ctx, in, info, handler) } -func (m *TsoResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.XXX_unrecognized != nil { - i -= len(m.XXX_unrecognized) - copy(dAtA[i:], m.XXX_unrecognized) +func _PD_AskSplit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(AskSplitRequest) + if err := dec(in); err != nil { + return nil, err } - if m.Timestamp != nil { - { - size, err := m.Timestamp.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a + if interceptor == nil { + return srv.(PDServer).AskSplit(ctx, in) } - if m.Count != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.Count)) - i-- - dAtA[i] = 0x10 + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/pdpb.PD/AskSplit", } - if m.Header != nil { - { - size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(PDServer).AskSplit(ctx, req.(*AskSplitRequest)) } - return len(dAtA) - i, nil + return interceptor(ctx, in, info, handler) } -func (m *BootstrapRequest) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { +func _PD_ReportSplit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ReportSplitRequest) + if err := dec(in); err != nil { return nil, err } - return dAtA[:n], nil -} - -func (m *BootstrapRequest) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) + if interceptor == nil { + return srv.(PDServer).ReportSplit(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/pdpb.PD/ReportSplit", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(PDServer).ReportSplit(ctx, req.(*ReportSplitRequest)) + } + return interceptor(ctx, in, info, handler) } -func (m *BootstrapRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.XXX_unrecognized != nil { - i -= len(m.XXX_unrecognized) - copy(dAtA[i:], m.XXX_unrecognized) +func _PD_AskBatchSplit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(AskBatchSplitRequest) + if err := dec(in); err != nil { + return nil, err } - if m.Region != nil { - { - size, err := m.Region.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a + if interceptor == nil { + return srv.(PDServer).AskBatchSplit(ctx, in) } - if m.Store != nil { - { - size, err := m.Store.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/pdpb.PD/AskBatchSplit", } - if m.Header != nil { - { - size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(PDServer).AskBatchSplit(ctx, req.(*AskBatchSplitRequest)) } - return len(dAtA) - i, nil + return interceptor(ctx, in, info, handler) } -func (m *BootstrapResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { +func _PD_ReportBatchSplit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ReportBatchSplitRequest) + if err := dec(in); err != nil { return nil, err } - return dAtA[:n], nil -} - -func (m *BootstrapResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *BootstrapResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.XXX_unrecognized != nil { - i -= len(m.XXX_unrecognized) - copy(dAtA[i:], m.XXX_unrecognized) + if interceptor == nil { + return srv.(PDServer).ReportBatchSplit(ctx, in) } - if m.ReplicationStatus != nil { - { - size, err := m.ReplicationStatus.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/pdpb.PD/ReportBatchSplit", } - if m.Header != nil { - { - size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(PDServer).ReportBatchSplit(ctx, req.(*ReportBatchSplitRequest)) } - return len(dAtA) - i, nil + return interceptor(ctx, in, info, handler) } -func (m *IsBootstrappedRequest) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { +func _PD_GetClusterConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetClusterConfigRequest) + if err := dec(in); err != nil { return nil, err } - return dAtA[:n], nil -} - -func (m *IsBootstrappedRequest) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *IsBootstrappedRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.XXX_unrecognized != nil { - i -= len(m.XXX_unrecognized) - copy(dAtA[i:], m.XXX_unrecognized) + if interceptor == nil { + return srv.(PDServer).GetClusterConfig(ctx, in) } - if m.Header != nil { - { - size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/pdpb.PD/GetClusterConfig", } - return len(dAtA) - i, nil + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(PDServer).GetClusterConfig(ctx, req.(*GetClusterConfigRequest)) + } + return interceptor(ctx, in, info, handler) } -func (m *IsBootstrappedResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { +func _PD_PutClusterConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(PutClusterConfigRequest) + if err := dec(in); err != nil { return nil, err } - return dAtA[:n], nil -} - -func (m *IsBootstrappedResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *IsBootstrappedResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.XXX_unrecognized != nil { - i -= len(m.XXX_unrecognized) - copy(dAtA[i:], m.XXX_unrecognized) + if interceptor == nil { + return srv.(PDServer).PutClusterConfig(ctx, in) } - if m.Bootstrapped { - i-- - if m.Bootstrapped { - dAtA[i] = 1 - } else { - dAtA[i] = 0 - } - i-- - dAtA[i] = 0x10 + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/pdpb.PD/PutClusterConfig", } - if m.Header != nil { - { - size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(PDServer).PutClusterConfig(ctx, req.(*PutClusterConfigRequest)) } - return len(dAtA) - i, nil + return interceptor(ctx, in, info, handler) } -func (m *AllocIDRequest) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { +func _PD_ScatterRegion_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ScatterRegionRequest) + if err := dec(in); err != nil { return nil, err } - return dAtA[:n], nil -} - -func (m *AllocIDRequest) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *AllocIDRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.XXX_unrecognized != nil { - i -= len(m.XXX_unrecognized) - copy(dAtA[i:], m.XXX_unrecognized) + if interceptor == nil { + return srv.(PDServer).ScatterRegion(ctx, in) } - if m.Header != nil { - { - size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/pdpb.PD/ScatterRegion", } - return len(dAtA) - i, nil + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(PDServer).ScatterRegion(ctx, req.(*ScatterRegionRequest)) + } + return interceptor(ctx, in, info, handler) } -func (m *AllocIDResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { +func _PD_GetGCSafePoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetGCSafePointRequest) + if err := dec(in); err != nil { return nil, err } - return dAtA[:n], nil -} - -func (m *AllocIDResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *AllocIDResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.XXX_unrecognized != nil { - i -= len(m.XXX_unrecognized) - copy(dAtA[i:], m.XXX_unrecognized) + if interceptor == nil { + return srv.(PDServer).GetGCSafePoint(ctx, in) } - if m.Id != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.Id)) - i-- - dAtA[i] = 0x10 + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/pdpb.PD/GetGCSafePoint", } - if m.Header != nil { - { - size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(PDServer).GetGCSafePoint(ctx, req.(*GetGCSafePointRequest)) } - return len(dAtA) - i, nil + return interceptor(ctx, in, info, handler) } -func (m *IsSnapshotRecoveringRequest) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { +func _PD_UpdateGCSafePoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(UpdateGCSafePointRequest) + if err := dec(in); err != nil { return nil, err } - return dAtA[:n], nil + if interceptor == nil { + return srv.(PDServer).UpdateGCSafePoint(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/pdpb.PD/UpdateGCSafePoint", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(PDServer).UpdateGCSafePoint(ctx, req.(*UpdateGCSafePointRequest)) + } + return interceptor(ctx, in, info, handler) } -func (m *IsSnapshotRecoveringRequest) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func _PD_UpdateServiceGCSafePoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(UpdateServiceGCSafePointRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(PDServer).UpdateServiceGCSafePoint(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/pdpb.PD/UpdateServiceGCSafePoint", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(PDServer).UpdateServiceGCSafePoint(ctx, req.(*UpdateServiceGCSafePointRequest)) + } + return interceptor(ctx, in, info, handler) } -func (m *IsSnapshotRecoveringRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.XXX_unrecognized != nil { - i -= len(m.XXX_unrecognized) - copy(dAtA[i:], m.XXX_unrecognized) +func _PD_GetGCSafePointV2_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetGCSafePointV2Request) + if err := dec(in); err != nil { + return nil, err } - if m.Header != nil { - { - size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa + if interceptor == nil { + return srv.(PDServer).GetGCSafePointV2(ctx, in) } - return len(dAtA) - i, nil + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/pdpb.PD/GetGCSafePointV2", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(PDServer).GetGCSafePointV2(ctx, req.(*GetGCSafePointV2Request)) + } + return interceptor(ctx, in, info, handler) } -func (m *IsSnapshotRecoveringResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err +func _PD_WatchGCSafePointV2_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(WatchGCSafePointV2Request) + if err := stream.RecvMsg(m); err != nil { + return err } - return dAtA[:n], nil + return srv.(PDServer).WatchGCSafePointV2(m, &pDWatchGCSafePointV2Server{stream}) } -func (m *IsSnapshotRecoveringResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +type PD_WatchGCSafePointV2Server interface { + Send(*WatchGCSafePointV2Response) error + grpc.ServerStream } -func (m *IsSnapshotRecoveringResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.XXX_unrecognized != nil { - i -= len(m.XXX_unrecognized) - copy(dAtA[i:], m.XXX_unrecognized) +type pDWatchGCSafePointV2Server struct { + grpc.ServerStream +} + +func (x *pDWatchGCSafePointV2Server) Send(m *WatchGCSafePointV2Response) error { + return x.ServerStream.SendMsg(m) +} + +func _PD_UpdateGCSafePointV2_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(UpdateGCSafePointV2Request) + if err := dec(in); err != nil { + return nil, err } - if m.Marked { - i-- - if m.Marked { - dAtA[i] = 1 - } else { - dAtA[i] = 0 - } - i-- - dAtA[i] = 0x10 + if interceptor == nil { + return srv.(PDServer).UpdateGCSafePointV2(ctx, in) } - if m.Header != nil { - { - size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/pdpb.PD/UpdateGCSafePointV2", } - return len(dAtA) - i, nil + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(PDServer).UpdateGCSafePointV2(ctx, req.(*UpdateGCSafePointV2Request)) + } + return interceptor(ctx, in, info, handler) } -func (m *GetStoreRequest) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { +func _PD_UpdateServiceSafePointV2_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(UpdateServiceSafePointV2Request) + if err := dec(in); err != nil { return nil, err } - return dAtA[:n], nil + if interceptor == nil { + return srv.(PDServer).UpdateServiceSafePointV2(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/pdpb.PD/UpdateServiceSafePointV2", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(PDServer).UpdateServiceSafePointV2(ctx, req.(*UpdateServiceSafePointV2Request)) + } + return interceptor(ctx, in, info, handler) } -func (m *GetStoreRequest) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func _PD_SyncRegions_Handler(srv interface{}, stream grpc.ServerStream) error { + return srv.(PDServer).SyncRegions(&pDSyncRegionsServer{stream}) } -func (m *GetStoreRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.XXX_unrecognized != nil { - i -= len(m.XXX_unrecognized) - copy(dAtA[i:], m.XXX_unrecognized) - } - if m.StoreId != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.StoreId)) - i-- - dAtA[i] = 0x10 - } - if m.Header != nil { - { - size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil +type PD_SyncRegionsServer interface { + Send(*SyncRegionResponse) error + Recv() (*SyncRegionRequest, error) + grpc.ServerStream } -func (m *GetStoreResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { +type pDSyncRegionsServer struct { + grpc.ServerStream +} + +func (x *pDSyncRegionsServer) Send(m *SyncRegionResponse) error { + return x.ServerStream.SendMsg(m) +} + +func (x *pDSyncRegionsServer) Recv() (*SyncRegionRequest, error) { + m := new(SyncRegionRequest) + if err := x.ServerStream.RecvMsg(m); err != nil { return nil, err } - return dAtA[:n], nil + return m, nil } -func (m *GetStoreResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func _PD_GetOperator_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetOperatorRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(PDServer).GetOperator(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/pdpb.PD/GetOperator", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(PDServer).GetOperator(ctx, req.(*GetOperatorRequest)) + } + return interceptor(ctx, in, info, handler) } -func (m *GetStoreResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.XXX_unrecognized != nil { - i -= len(m.XXX_unrecognized) - copy(dAtA[i:], m.XXX_unrecognized) +func _PD_SyncMaxTS_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(SyncMaxTSRequest) + if err := dec(in); err != nil { + return nil, err } - if m.Stats != nil { - { - size, err := m.Stats.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a + if interceptor == nil { + return srv.(PDServer).SyncMaxTS(ctx, in) } - if m.Store != nil { - { - size, err := m.Store.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/pdpb.PD/SyncMaxTS", } - if m.Header != nil { - { - size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(PDServer).SyncMaxTS(ctx, req.(*SyncMaxTSRequest)) } - return len(dAtA) - i, nil + return interceptor(ctx, in, info, handler) } -func (m *PutStoreRequest) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { +func _PD_SplitRegions_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(SplitRegionsRequest) + if err := dec(in); err != nil { return nil, err } - return dAtA[:n], nil -} - -func (m *PutStoreRequest) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *PutStoreRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.XXX_unrecognized != nil { - i -= len(m.XXX_unrecognized) - copy(dAtA[i:], m.XXX_unrecognized) + if interceptor == nil { + return srv.(PDServer).SplitRegions(ctx, in) } - if m.Store != nil { - { - size, err := m.Store.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/pdpb.PD/SplitRegions", } - if m.Header != nil { - { - size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(PDServer).SplitRegions(ctx, req.(*SplitRegionsRequest)) } - return len(dAtA) - i, nil + return interceptor(ctx, in, info, handler) } -func (m *PutStoreResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { +func _PD_SplitAndScatterRegions_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(SplitAndScatterRegionsRequest) + if err := dec(in); err != nil { return nil, err } - return dAtA[:n], nil -} - -func (m *PutStoreResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *PutStoreResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.XXX_unrecognized != nil { - i -= len(m.XXX_unrecognized) - copy(dAtA[i:], m.XXX_unrecognized) + if interceptor == nil { + return srv.(PDServer).SplitAndScatterRegions(ctx, in) } - if m.ReplicationStatus != nil { - { - size, err := m.ReplicationStatus.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/pdpb.PD/SplitAndScatterRegions", } - if m.Header != nil { - { - size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(PDServer).SplitAndScatterRegions(ctx, req.(*SplitAndScatterRegionsRequest)) } - return len(dAtA) - i, nil + return interceptor(ctx, in, info, handler) } -func (m *GetAllStoresRequest) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { +func _PD_GetDCLocationInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetDCLocationInfoRequest) + if err := dec(in); err != nil { return nil, err } - return dAtA[:n], nil + if interceptor == nil { + return srv.(PDServer).GetDCLocationInfo(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/pdpb.PD/GetDCLocationInfo", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(PDServer).GetDCLocationInfo(ctx, req.(*GetDCLocationInfoRequest)) + } + return interceptor(ctx, in, info, handler) } -func (m *GetAllStoresRequest) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func _PD_StoreGlobalConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(StoreGlobalConfigRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(PDServer).StoreGlobalConfig(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/pdpb.PD/StoreGlobalConfig", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(PDServer).StoreGlobalConfig(ctx, req.(*StoreGlobalConfigRequest)) + } + return interceptor(ctx, in, info, handler) } -func (m *GetAllStoresRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.XXX_unrecognized != nil { - i -= len(m.XXX_unrecognized) - copy(dAtA[i:], m.XXX_unrecognized) +func _PD_LoadGlobalConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(LoadGlobalConfigRequest) + if err := dec(in); err != nil { + return nil, err } - if m.ExcludeTombstoneStores { - i-- - if m.ExcludeTombstoneStores { - dAtA[i] = 1 - } else { - dAtA[i] = 0 - } - i-- - dAtA[i] = 0x10 + if interceptor == nil { + return srv.(PDServer).LoadGlobalConfig(ctx, in) } - if m.Header != nil { - { - size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/pdpb.PD/LoadGlobalConfig", } - return len(dAtA) - i, nil + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(PDServer).LoadGlobalConfig(ctx, req.(*LoadGlobalConfigRequest)) + } + return interceptor(ctx, in, info, handler) } -func (m *GetAllStoresResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err +func _PD_WatchGlobalConfig_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(WatchGlobalConfigRequest) + if err := stream.RecvMsg(m); err != nil { + return err } - return dAtA[:n], nil + return srv.(PDServer).WatchGlobalConfig(m, &pDWatchGlobalConfigServer{stream}) } -func (m *GetAllStoresResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +type PD_WatchGlobalConfigServer interface { + Send(*WatchGlobalConfigResponse) error + grpc.ServerStream } -func (m *GetAllStoresResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.XXX_unrecognized != nil { - i -= len(m.XXX_unrecognized) - copy(dAtA[i:], m.XXX_unrecognized) - } - if len(m.Stores) > 0 { - for iNdEx := len(m.Stores) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.Stores[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - } - if m.Header != nil { - { - size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil +type pDWatchGlobalConfigServer struct { + grpc.ServerStream } -func (m *GetRegionRequest) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil +func (x *pDWatchGlobalConfigServer) Send(m *WatchGlobalConfigResponse) error { + return x.ServerStream.SendMsg(m) } -func (m *GetRegionRequest) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func _PD_ReportBuckets_Handler(srv interface{}, stream grpc.ServerStream) error { + return srv.(PDServer).ReportBuckets(&pDReportBucketsServer{stream}) } -func (m *GetRegionRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.XXX_unrecognized != nil { - i -= len(m.XXX_unrecognized) - copy(dAtA[i:], m.XXX_unrecognized) - } - if m.NeedBuckets { - i-- - if m.NeedBuckets { - dAtA[i] = 1 - } else { - dAtA[i] = 0 - } - i-- - dAtA[i] = 0x18 - } - if len(m.RegionKey) > 0 { - i -= len(m.RegionKey) - copy(dAtA[i:], m.RegionKey) - i = encodeVarintPdpb(dAtA, i, uint64(len(m.RegionKey))) - i-- - dAtA[i] = 0x12 - } - if m.Header != nil { - { - size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil +type PD_ReportBucketsServer interface { + SendAndClose(*ReportBucketsResponse) error + Recv() (*ReportBucketsRequest, error) + grpc.ServerStream } -func (m *GetRegionResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { +type pDReportBucketsServer struct { + grpc.ServerStream +} + +func (x *pDReportBucketsServer) SendAndClose(m *ReportBucketsResponse) error { + return x.ServerStream.SendMsg(m) +} + +func (x *pDReportBucketsServer) Recv() (*ReportBucketsRequest, error) { + m := new(ReportBucketsRequest) + if err := x.ServerStream.RecvMsg(m); err != nil { return nil, err } - return dAtA[:n], nil + return m, nil } -func (m *GetRegionResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func _PD_ReportMinResolvedTS_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ReportMinResolvedTsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(PDServer).ReportMinResolvedTS(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/pdpb.PD/ReportMinResolvedTS", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(PDServer).ReportMinResolvedTS(ctx, req.(*ReportMinResolvedTsRequest)) + } + return interceptor(ctx, in, info, handler) } -func (m *GetRegionResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.XXX_unrecognized != nil { - i -= len(m.XXX_unrecognized) - copy(dAtA[i:], m.XXX_unrecognized) +func _PD_SetExternalTimestamp_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(SetExternalTimestampRequest) + if err := dec(in); err != nil { + return nil, err } - if m.Buckets != nil { - { - size, err := m.Buckets.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x3a + if interceptor == nil { + return srv.(PDServer).SetExternalTimestamp(ctx, in) } - if len(m.PendingPeers) > 0 { - for iNdEx := len(m.PendingPeers) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.PendingPeers[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x32 - } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/pdpb.PD/SetExternalTimestamp", } - if len(m.DownPeers) > 0 { - for iNdEx := len(m.DownPeers) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.DownPeers[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x2a - } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(PDServer).SetExternalTimestamp(ctx, req.(*SetExternalTimestampRequest)) } - if m.Leader != nil { - { - size, err := m.Leader.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a + return interceptor(ctx, in, info, handler) +} + +func _PD_GetExternalTimestamp_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetExternalTimestampRequest) + if err := dec(in); err != nil { + return nil, err } - if m.Region != nil { - { - size, err := m.Region.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 + if interceptor == nil { + return srv.(PDServer).GetExternalTimestamp(ctx, in) } - if m.Header != nil { - { - size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/pdpb.PD/GetExternalTimestamp", } - return len(dAtA) - i, nil + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(PDServer).GetExternalTimestamp(ctx, req.(*GetExternalTimestampRequest)) + } + return interceptor(ctx, in, info, handler) } -func (m *GetRegionByIDRequest) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { +func _PD_GetMinTS_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetMinTSRequest) + if err := dec(in); err != nil { return nil, err } - return dAtA[:n], nil + if interceptor == nil { + return srv.(PDServer).GetMinTS(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/pdpb.PD/GetMinTS", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(PDServer).GetMinTS(ctx, req.(*GetMinTSRequest)) + } + return interceptor(ctx, in, info, handler) } -func (m *GetRegionByIDRequest) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() +var _PD_serviceDesc = grpc.ServiceDesc{ + ServiceName: "pdpb.PD", + HandlerType: (*PDServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "GetClusterInfo", + Handler: _PD_GetClusterInfo_Handler, + }, + { + MethodName: "GetMembers", + Handler: _PD_GetMembers_Handler, + }, + { + MethodName: "Bootstrap", + Handler: _PD_Bootstrap_Handler, + }, + { + MethodName: "IsBootstrapped", + Handler: _PD_IsBootstrapped_Handler, + }, + { + MethodName: "AllocID", + Handler: _PD_AllocID_Handler, + }, + { + MethodName: "IsSnapshotRecovering", + Handler: _PD_IsSnapshotRecovering_Handler, + }, + { + MethodName: "GetStore", + Handler: _PD_GetStore_Handler, + }, + { + MethodName: "PutStore", + Handler: _PD_PutStore_Handler, + }, + { + MethodName: "GetAllStores", + Handler: _PD_GetAllStores_Handler, + }, + { + MethodName: "StoreHeartbeat", + Handler: _PD_StoreHeartbeat_Handler, + }, + { + MethodName: "GetRegion", + Handler: _PD_GetRegion_Handler, + }, + { + MethodName: "GetPrevRegion", + Handler: _PD_GetPrevRegion_Handler, + }, + { + MethodName: "GetRegionByID", + Handler: _PD_GetRegionByID_Handler, + }, + { + MethodName: "ScanRegions", + Handler: _PD_ScanRegions_Handler, + }, + { + MethodName: "AskSplit", + Handler: _PD_AskSplit_Handler, + }, + { + MethodName: "ReportSplit", + Handler: _PD_ReportSplit_Handler, + }, + { + MethodName: "AskBatchSplit", + Handler: _PD_AskBatchSplit_Handler, + }, + { + MethodName: "ReportBatchSplit", + Handler: _PD_ReportBatchSplit_Handler, + }, + { + MethodName: "GetClusterConfig", + Handler: _PD_GetClusterConfig_Handler, + }, + { + MethodName: "PutClusterConfig", + Handler: _PD_PutClusterConfig_Handler, + }, + { + MethodName: "ScatterRegion", + Handler: _PD_ScatterRegion_Handler, + }, + { + MethodName: "GetGCSafePoint", + Handler: _PD_GetGCSafePoint_Handler, + }, + { + MethodName: "UpdateGCSafePoint", + Handler: _PD_UpdateGCSafePoint_Handler, + }, + { + MethodName: "UpdateServiceGCSafePoint", + Handler: _PD_UpdateServiceGCSafePoint_Handler, + }, + { + MethodName: "GetGCSafePointV2", + Handler: _PD_GetGCSafePointV2_Handler, + }, + { + MethodName: "UpdateGCSafePointV2", + Handler: _PD_UpdateGCSafePointV2_Handler, + }, + { + MethodName: "UpdateServiceSafePointV2", + Handler: _PD_UpdateServiceSafePointV2_Handler, + }, + { + MethodName: "GetOperator", + Handler: _PD_GetOperator_Handler, + }, + { + MethodName: "SyncMaxTS", + Handler: _PD_SyncMaxTS_Handler, + }, + { + MethodName: "SplitRegions", + Handler: _PD_SplitRegions_Handler, + }, + { + MethodName: "SplitAndScatterRegions", + Handler: _PD_SplitAndScatterRegions_Handler, + }, + { + MethodName: "GetDCLocationInfo", + Handler: _PD_GetDCLocationInfo_Handler, + }, + { + MethodName: "StoreGlobalConfig", + Handler: _PD_StoreGlobalConfig_Handler, + }, + { + MethodName: "LoadGlobalConfig", + Handler: _PD_LoadGlobalConfig_Handler, + }, + { + MethodName: "ReportMinResolvedTS", + Handler: _PD_ReportMinResolvedTS_Handler, + }, + { + MethodName: "SetExternalTimestamp", + Handler: _PD_SetExternalTimestamp_Handler, + }, + { + MethodName: "GetExternalTimestamp", + Handler: _PD_GetExternalTimestamp_Handler, + }, + { + MethodName: "GetMinTS", + Handler: _PD_GetMinTS_Handler, + }, + }, + Streams: []grpc.StreamDesc{ + { + StreamName: "Tso", + Handler: _PD_Tso_Handler, + ServerStreams: true, + ClientStreams: true, + }, + { + StreamName: "RegionHeartbeat", + Handler: _PD_RegionHeartbeat_Handler, + ServerStreams: true, + ClientStreams: true, + }, + { + StreamName: "WatchGCSafePointV2", + Handler: _PD_WatchGCSafePointV2_Handler, + ServerStreams: true, + }, + { + StreamName: "SyncRegions", + Handler: _PD_SyncRegions_Handler, + ServerStreams: true, + ClientStreams: true, + }, + { + StreamName: "WatchGlobalConfig", + Handler: _PD_WatchGlobalConfig_Handler, + ServerStreams: true, + }, + { + StreamName: "ReportBuckets", + Handler: _PD_ReportBuckets_Handler, + ClientStreams: true, + }, + }, + Metadata: "pdpb.proto", +} + +func (m *WatchGlobalConfigRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *WatchGlobalConfigRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *GetRegionByIDRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *WatchGlobalConfigRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -10820,37 +10278,22 @@ func (m *GetRegionByIDRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if m.NeedBuckets { - i-- - if m.NeedBuckets { - dAtA[i] = 1 - } else { - dAtA[i] = 0 - } - i-- - dAtA[i] = 0x18 - } - if m.RegionId != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.RegionId)) + if m.Revision != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.Revision)) i-- dAtA[i] = 0x10 } - if m.Header != nil { - { - size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } + if len(m.ConfigPath) > 0 { + i -= len(m.ConfigPath) + copy(dAtA[i:], m.ConfigPath) + i = encodeVarintPdpb(dAtA, i, uint64(len(m.ConfigPath))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *ScanRegionsRequest) Marshal() (dAtA []byte, err error) { +func (m *WatchGlobalConfigResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -10860,12 +10303,12 @@ func (m *ScanRegionsRequest) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *ScanRegionsRequest) MarshalTo(dAtA []byte) (int, error) { +func (m *WatchGlobalConfigResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ScanRegionsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *WatchGlobalConfigResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -10874,25 +10317,6 @@ func (m *ScanRegionsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if len(m.EndKey) > 0 { - i -= len(m.EndKey) - copy(dAtA[i:], m.EndKey) - i = encodeVarintPdpb(dAtA, i, uint64(len(m.EndKey))) - i-- - dAtA[i] = 0x22 - } - if m.Limit != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.Limit)) - i-- - dAtA[i] = 0x18 - } - if len(m.StartKey) > 0 { - i -= len(m.StartKey) - copy(dAtA[i:], m.StartKey) - i = encodeVarintPdpb(dAtA, i, uint64(len(m.StartKey))) - i-- - dAtA[i] = 0x12 - } if m.Header != nil { { size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) @@ -10903,53 +10327,17 @@ func (m *ScanRegionsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i = encodeVarintPdpb(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0xa + dAtA[i] = 0x1a } - return len(dAtA) - i, nil -} - -func (m *Region) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil -} - -func (m *Region) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *Region) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.XXX_unrecognized != nil { - i -= len(m.XXX_unrecognized) - copy(dAtA[i:], m.XXX_unrecognized) - } - if len(m.PendingPeers) > 0 { - for iNdEx := len(m.PendingPeers) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.PendingPeers[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x22 - } + if m.Revision != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.Revision)) + i-- + dAtA[i] = 0x10 } - if len(m.DownPeers) > 0 { - for iNdEx := len(m.DownPeers) - 1; iNdEx >= 0; iNdEx-- { + if len(m.Changes) > 0 { + for iNdEx := len(m.Changes) - 1; iNdEx >= 0; iNdEx-- { { - size, err := m.DownPeers[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Changes[iNdEx].MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -10957,37 +10345,13 @@ func (m *Region) MarshalToSizedBuffer(dAtA []byte) (int, error) { i = encodeVarintPdpb(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0x1a - } - } - if m.Leader != nil { - { - size, err := m.Leader.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - if m.Region != nil { - { - size, err := m.Region.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) + dAtA[i] = 0xa } - i-- - dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *ScanRegionsResponse) Marshal() (dAtA []byte, err error) { +func (m *StoreGlobalConfigRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -10997,12 +10361,12 @@ func (m *ScanRegionsResponse) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *ScanRegionsResponse) MarshalTo(dAtA []byte) (int, error) { +func (m *StoreGlobalConfigRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ScanRegionsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *StoreGlobalConfigRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -11011,38 +10375,17 @@ func (m *ScanRegionsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if len(m.Regions) > 0 { - for iNdEx := len(m.Regions) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.Regions[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x22 - } - } - if len(m.Leaders) > 0 { - for iNdEx := len(m.Leaders) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.Leaders[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a - } + if len(m.ConfigPath) > 0 { + i -= len(m.ConfigPath) + copy(dAtA[i:], m.ConfigPath) + i = encodeVarintPdpb(dAtA, i, uint64(len(m.ConfigPath))) + i-- + dAtA[i] = 0x12 } - if len(m.RegionMetas) > 0 { - for iNdEx := len(m.RegionMetas) - 1; iNdEx >= 0; iNdEx-- { + if len(m.Changes) > 0 { + for iNdEx := len(m.Changes) - 1; iNdEx >= 0; iNdEx-- { { - size, err := m.RegionMetas[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Changes[iNdEx].MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -11050,25 +10393,13 @@ func (m *ScanRegionsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i = encodeVarintPdpb(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0x12 - } - } - if m.Header != nil { - { - size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) + dAtA[i] = 0xa } - i-- - dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *GetClusterConfigRequest) Marshal() (dAtA []byte, err error) { +func (m *StoreGlobalConfigResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -11078,12 +10409,12 @@ func (m *GetClusterConfigRequest) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *GetClusterConfigRequest) MarshalTo(dAtA []byte) (int, error) { +func (m *StoreGlobalConfigResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *GetClusterConfigRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *StoreGlobalConfigResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -11092,9 +10423,9 @@ func (m *GetClusterConfigRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if m.Header != nil { + if m.Error != nil { { - size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Error.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -11107,7 +10438,7 @@ func (m *GetClusterConfigRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) return len(dAtA) - i, nil } -func (m *GetClusterConfigResponse) Marshal() (dAtA []byte, err error) { +func (m *LoadGlobalConfigRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -11117,12 +10448,12 @@ func (m *GetClusterConfigResponse) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *GetClusterConfigResponse) MarshalTo(dAtA []byte) (int, error) { +func (m *LoadGlobalConfigRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *GetClusterConfigResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *LoadGlobalConfigRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -11131,34 +10462,26 @@ func (m *GetClusterConfigResponse) MarshalToSizedBuffer(dAtA []byte) (int, error i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if m.Cluster != nil { - { - size, err := m.Cluster.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } + if len(m.ConfigPath) > 0 { + i -= len(m.ConfigPath) + copy(dAtA[i:], m.ConfigPath) + i = encodeVarintPdpb(dAtA, i, uint64(len(m.ConfigPath))) i-- dAtA[i] = 0x12 } - if m.Header != nil { - { - size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) + if len(m.Names) > 0 { + for iNdEx := len(m.Names) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Names[iNdEx]) + copy(dAtA[i:], m.Names[iNdEx]) + i = encodeVarintPdpb(dAtA, i, uint64(len(m.Names[iNdEx]))) + i-- + dAtA[i] = 0xa } - i-- - dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *PutClusterConfigRequest) Marshal() (dAtA []byte, err error) { +func (m *LoadGlobalConfigResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -11168,12 +10491,12 @@ func (m *PutClusterConfigRequest) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *PutClusterConfigRequest) MarshalTo(dAtA []byte) (int, error) { +func (m *LoadGlobalConfigResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *PutClusterConfigRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *LoadGlobalConfigResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -11182,34 +10505,29 @@ func (m *PutClusterConfigRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if m.Cluster != nil { - { - size, err := m.Cluster.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } + if m.Revision != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.Revision)) i-- - dAtA[i] = 0x12 + dAtA[i] = 0x10 } - if m.Header != nil { - { - size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err + if len(m.Items) > 0 { + for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa } - i-- - dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *PutClusterConfigResponse) Marshal() (dAtA []byte, err error) { +func (m *GlobalConfigItem) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -11219,12 +10537,12 @@ func (m *PutClusterConfigResponse) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *PutClusterConfigResponse) MarshalTo(dAtA []byte) (int, error) { +func (m *GlobalConfigItem) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *PutClusterConfigResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *GlobalConfigItem) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -11233,9 +10551,21 @@ func (m *PutClusterConfigResponse) MarshalToSizedBuffer(dAtA []byte) (int, error i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if m.Header != nil { + if len(m.Payload) > 0 { + i -= len(m.Payload) + copy(dAtA[i:], m.Payload) + i = encodeVarintPdpb(dAtA, i, uint64(len(m.Payload))) + i-- + dAtA[i] = 0x2a + } + if m.Kind != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.Kind)) + i-- + dAtA[i] = 0x20 + } + if m.Error != nil { { - size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Error.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -11243,12 +10573,26 @@ func (m *PutClusterConfigResponse) MarshalToSizedBuffer(dAtA []byte) (int, error i = encodeVarintPdpb(dAtA, i, uint64(size)) } i-- + dAtA[i] = 0x1a + } + if len(m.Value) > 0 { + i -= len(m.Value) + copy(dAtA[i:], m.Value) + i = encodeVarintPdpb(dAtA, i, uint64(len(m.Value))) + i-- + dAtA[i] = 0x12 + } + if len(m.Name) > 0 { + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintPdpb(dAtA, i, uint64(len(m.Name))) + i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *Member) Marshal() (dAtA []byte, err error) { +func (m *RequestHeader) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -11258,12 +10602,12 @@ func (m *Member) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *Member) MarshalTo(dAtA []byte) (int, error) { +func (m *RequestHeader) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *Member) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *RequestHeader) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -11272,73 +10616,20 @@ func (m *Member) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if len(m.DcLocation) > 0 { - i -= len(m.DcLocation) - copy(dAtA[i:], m.DcLocation) - i = encodeVarintPdpb(dAtA, i, uint64(len(m.DcLocation))) - i-- - dAtA[i] = 0x4a - } - if len(m.GitHash) > 0 { - i -= len(m.GitHash) - copy(dAtA[i:], m.GitHash) - i = encodeVarintPdpb(dAtA, i, uint64(len(m.GitHash))) - i-- - dAtA[i] = 0x42 - } - if len(m.BinaryVersion) > 0 { - i -= len(m.BinaryVersion) - copy(dAtA[i:], m.BinaryVersion) - i = encodeVarintPdpb(dAtA, i, uint64(len(m.BinaryVersion))) - i-- - dAtA[i] = 0x3a - } - if len(m.DeployPath) > 0 { - i -= len(m.DeployPath) - copy(dAtA[i:], m.DeployPath) - i = encodeVarintPdpb(dAtA, i, uint64(len(m.DeployPath))) - i-- - dAtA[i] = 0x32 - } - if m.LeaderPriority != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.LeaderPriority)) - i-- - dAtA[i] = 0x28 - } - if len(m.ClientUrls) > 0 { - for iNdEx := len(m.ClientUrls) - 1; iNdEx >= 0; iNdEx-- { - i -= len(m.ClientUrls[iNdEx]) - copy(dAtA[i:], m.ClientUrls[iNdEx]) - i = encodeVarintPdpb(dAtA, i, uint64(len(m.ClientUrls[iNdEx]))) - i-- - dAtA[i] = 0x22 - } - } - if len(m.PeerUrls) > 0 { - for iNdEx := len(m.PeerUrls) - 1; iNdEx >= 0; iNdEx-- { - i -= len(m.PeerUrls[iNdEx]) - copy(dAtA[i:], m.PeerUrls[iNdEx]) - i = encodeVarintPdpb(dAtA, i, uint64(len(m.PeerUrls[iNdEx]))) - i-- - dAtA[i] = 0x1a - } - } - if m.MemberId != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.MemberId)) + if m.SenderId != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.SenderId)) i-- dAtA[i] = 0x10 } - if len(m.Name) > 0 { - i -= len(m.Name) - copy(dAtA[i:], m.Name) - i = encodeVarintPdpb(dAtA, i, uint64(len(m.Name))) + if m.ClusterId != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.ClusterId)) i-- - dAtA[i] = 0xa + dAtA[i] = 0x8 } return len(dAtA) - i, nil } -func (m *GetMembersRequest) Marshal() (dAtA []byte, err error) { +func (m *ResponseHeader) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -11348,12 +10639,12 @@ func (m *GetMembersRequest) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *GetMembersRequest) MarshalTo(dAtA []byte) (int, error) { +func (m *ResponseHeader) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *GetMembersRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ResponseHeader) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -11362,9 +10653,9 @@ func (m *GetMembersRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if m.Header != nil { + if m.Error != nil { { - size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Error.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -11372,12 +10663,17 @@ func (m *GetMembersRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i = encodeVarintPdpb(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0xa + dAtA[i] = 0x12 + } + if m.ClusterId != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.ClusterId)) + i-- + dAtA[i] = 0x8 } return len(dAtA) - i, nil } -func (m *GetMembersResponse) Marshal() (dAtA []byte, err error) { +func (m *Error) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -11387,12 +10683,12 @@ func (m *GetMembersResponse) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *GetMembersResponse) MarshalTo(dAtA []byte) (int, error) { +func (m *Error) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *GetMembersResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *Error) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -11401,86 +10697,22 @@ func (m *GetMembersResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if len(m.TsoAllocatorLeaders) > 0 { - for k := range m.TsoAllocatorLeaders { - v := m.TsoAllocatorLeaders[k] - baseI := i - if v != nil { - { - size, err := v.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - i -= len(k) - copy(dAtA[i:], k) - i = encodeVarintPdpb(dAtA, i, uint64(len(k))) - i-- - dAtA[i] = 0xa - i = encodeVarintPdpb(dAtA, i, uint64(baseI-i)) - i-- - dAtA[i] = 0x2a - } - } - if m.EtcdLeader != nil { - { - size, err := m.EtcdLeader.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x22 - } - if m.Leader != nil { - { - size, err := m.Leader.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } + if len(m.Message) > 0 { + i -= len(m.Message) + copy(dAtA[i:], m.Message) + i = encodeVarintPdpb(dAtA, i, uint64(len(m.Message))) i-- - dAtA[i] = 0x1a - } - if len(m.Members) > 0 { - for iNdEx := len(m.Members) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.Members[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } + dAtA[i] = 0x12 } - if m.Header != nil { - { - size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } + if m.Type != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.Type)) i-- - dAtA[i] = 0xa + dAtA[i] = 0x8 } return len(dAtA) - i, nil } -func (m *GetClusterInfoRequest) Marshal() (dAtA []byte, err error) { +func (m *TsoRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -11490,12 +10722,12 @@ func (m *GetClusterInfoRequest) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *GetClusterInfoRequest) MarshalTo(dAtA []byte) (int, error) { +func (m *TsoRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *GetClusterInfoRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *TsoRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -11504,6 +10736,18 @@ func (m *GetClusterInfoRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } + if len(m.DcLocation) > 0 { + i -= len(m.DcLocation) + copy(dAtA[i:], m.DcLocation) + i = encodeVarintPdpb(dAtA, i, uint64(len(m.DcLocation))) + i-- + dAtA[i] = 0x1a + } + if m.Count != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.Count)) + i-- + dAtA[i] = 0x10 + } if m.Header != nil { { size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) @@ -11519,7 +10763,7 @@ func (m *GetClusterInfoRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *GetClusterInfoResponse) Marshal() (dAtA []byte, err error) { +func (m *Timestamp) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -11529,12 +10773,12 @@ func (m *GetClusterInfoResponse) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *GetClusterInfoResponse) MarshalTo(dAtA []byte) (int, error) { +func (m *Timestamp) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *GetClusterInfoResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *Timestamp) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -11543,40 +10787,25 @@ func (m *GetClusterInfoResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if len(m.ServiceModes) > 0 { - dAtA52 := make([]byte, len(m.ServiceModes)*10) - var j51 int - for _, num := range m.ServiceModes { - for num >= 1<<7 { - dAtA52[j51] = uint8(uint64(num)&0x7f | 0x80) - num >>= 7 - j51++ - } - dAtA52[j51] = uint8(num) - j51++ - } - i -= j51 - copy(dAtA[i:], dAtA52[:j51]) - i = encodeVarintPdpb(dAtA, i, uint64(j51)) + if m.SuffixBits != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.SuffixBits)) i-- - dAtA[i] = 0x12 + dAtA[i] = 0x18 } - if m.Header != nil { - { - size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } + if m.Logical != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.Logical)) i-- - dAtA[i] = 0xa + dAtA[i] = 0x10 + } + if m.Physical != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.Physical)) + i-- + dAtA[i] = 0x8 } return len(dAtA) - i, nil } -func (m *PeerStats) Marshal() (dAtA []byte, err error) { +func (m *TsoResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -11586,12 +10815,12 @@ func (m *PeerStats) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *PeerStats) MarshalTo(dAtA []byte) (int, error) { +func (m *TsoResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *PeerStats) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *TsoResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -11600,14 +10829,26 @@ func (m *PeerStats) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if m.DownSeconds != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.DownSeconds)) + if m.Timestamp != nil { + { + size, err := m.Timestamp.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.Count != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.Count)) i-- dAtA[i] = 0x10 } - if m.Peer != nil { + if m.Header != nil { { - size, err := m.Peer.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -11620,7 +10861,7 @@ func (m *PeerStats) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *RegionHeartbeatRequest) Marshal() (dAtA []byte, err error) { +func (m *BootstrapRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -11630,12 +10871,12 @@ func (m *RegionHeartbeatRequest) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *RegionHeartbeatRequest) MarshalTo(dAtA []byte) (int, error) { +func (m *BootstrapRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *RegionHeartbeatRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *BootstrapRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -11644,124 +10885,9 @@ func (m *RegionHeartbeatRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if m.ApproximateKvSize != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.ApproximateKvSize)) - i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0x90 - } - if m.CpuUsage != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.CpuUsage)) - i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0x88 - } - if m.QueryStats != nil { - { - size, err := m.QueryStats.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0x82 - } - if m.ReplicationStatus != nil { - { - size, err := m.ReplicationStatus.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x7a - } - if m.Term != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.Term)) - i-- - dAtA[i] = 0x70 - } - if m.ApproximateKeys != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.ApproximateKeys)) - i-- - dAtA[i] = 0x68 - } - if m.Interval != nil { - { - size, err := m.Interval.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x62 - } - if m.ApproximateSize != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.ApproximateSize)) - i-- - dAtA[i] = 0x50 - } - if m.KeysRead != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.KeysRead)) - i-- - dAtA[i] = 0x48 - } - if m.KeysWritten != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.KeysWritten)) - i-- - dAtA[i] = 0x40 - } - if m.BytesRead != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.BytesRead)) - i-- - dAtA[i] = 0x38 - } - if m.BytesWritten != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.BytesWritten)) - i-- - dAtA[i] = 0x30 - } - if len(m.PendingPeers) > 0 { - for iNdEx := len(m.PendingPeers) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.PendingPeers[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x2a - } - } - if len(m.DownPeers) > 0 { - for iNdEx := len(m.DownPeers) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.DownPeers[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x22 - } - } - if m.Leader != nil { + if m.Region != nil { { - size, err := m.Leader.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Region.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -11771,9 +10897,9 @@ func (m *RegionHeartbeatRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) i-- dAtA[i] = 0x1a } - if m.Region != nil { + if m.Store != nil { { - size, err := m.Region.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Store.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -11798,7 +10924,7 @@ func (m *RegionHeartbeatRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) return len(dAtA) - i, nil } -func (m *ChangePeer) Marshal() (dAtA []byte, err error) { +func (m *BootstrapResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -11808,12 +10934,12 @@ func (m *ChangePeer) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *ChangePeer) MarshalTo(dAtA []byte) (int, error) { +func (m *BootstrapResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ChangePeer) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *BootstrapResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -11822,14 +10948,21 @@ func (m *ChangePeer) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if m.ChangeType != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.ChangeType)) + if m.ReplicationStatus != nil { + { + size, err := m.ReplicationStatus.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } i-- - dAtA[i] = 0x10 + dAtA[i] = 0x12 } - if m.Peer != nil { + if m.Header != nil { { - size, err := m.Peer.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -11842,7 +10975,7 @@ func (m *ChangePeer) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *ChangePeerV2) Marshal() (dAtA []byte, err error) { +func (m *IsBootstrappedRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -11852,12 +10985,12 @@ func (m *ChangePeerV2) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *ChangePeerV2) MarshalTo(dAtA []byte) (int, error) { +func (m *IsBootstrappedRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ChangePeerV2) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *IsBootstrappedRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -11866,24 +10999,22 @@ func (m *ChangePeerV2) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if len(m.Changes) > 0 { - for iNdEx := len(m.Changes) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.Changes[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) + if m.Header != nil { + { + size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err } - i-- - dAtA[i] = 0xa + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) } + i-- + dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *TransferLeader) Marshal() (dAtA []byte, err error) { +func (m *IsBootstrappedResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -11893,12 +11024,12 @@ func (m *TransferLeader) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *TransferLeader) MarshalTo(dAtA []byte) (int, error) { +func (m *IsBootstrappedResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *TransferLeader) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *IsBootstrappedResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -11907,23 +11038,19 @@ func (m *TransferLeader) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if len(m.Peers) > 0 { - for iNdEx := len(m.Peers) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.Peers[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 + if m.Bootstrapped { + i-- + if m.Bootstrapped { + dAtA[i] = 1 + } else { + dAtA[i] = 0 } + i-- + dAtA[i] = 0x10 } - if m.Peer != nil { + if m.Header != nil { { - size, err := m.Peer.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -11936,7 +11063,7 @@ func (m *TransferLeader) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *Merge) Marshal() (dAtA []byte, err error) { +func (m *AllocIDRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -11946,12 +11073,12 @@ func (m *Merge) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *Merge) MarshalTo(dAtA []byte) (int, error) { +func (m *AllocIDRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *Merge) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *AllocIDRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -11960,9 +11087,9 @@ func (m *Merge) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if m.Target != nil { + if m.Header != nil { { - size, err := m.Target.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -11975,7 +11102,7 @@ func (m *Merge) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *SplitRegion) Marshal() (dAtA []byte, err error) { +func (m *AllocIDResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -11985,12 +11112,12 @@ func (m *SplitRegion) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *SplitRegion) MarshalTo(dAtA []byte) (int, error) { +func (m *AllocIDResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *SplitRegion) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *AllocIDResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -11999,24 +11126,27 @@ func (m *SplitRegion) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if len(m.Keys) > 0 { - for iNdEx := len(m.Keys) - 1; iNdEx >= 0; iNdEx-- { - i -= len(m.Keys[iNdEx]) - copy(dAtA[i:], m.Keys[iNdEx]) - i = encodeVarintPdpb(dAtA, i, uint64(len(m.Keys[iNdEx]))) - i-- - dAtA[i] = 0x12 - } + if m.Id != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.Id)) + i-- + dAtA[i] = 0x10 } - if m.Policy != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.Policy)) + if m.Header != nil { + { + size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } i-- - dAtA[i] = 0x8 + dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *SwitchWitness) Marshal() (dAtA []byte, err error) { +func (m *IsSnapshotRecoveringRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -12026,12 +11156,12 @@ func (m *SwitchWitness) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *SwitchWitness) MarshalTo(dAtA []byte) (int, error) { +func (m *IsSnapshotRecoveringRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *SwitchWitness) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *IsSnapshotRecoveringRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -12040,25 +11170,22 @@ func (m *SwitchWitness) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if m.IsWitness { - i-- - if m.IsWitness { - dAtA[i] = 1 - } else { - dAtA[i] = 0 + if m.Header != nil { + { + size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0x10 - } - if m.PeerId != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.PeerId)) - i-- - dAtA[i] = 0x8 + dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *BatchSwitchWitness) Marshal() (dAtA []byte, err error) { +func (m *IsSnapshotRecoveringResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -12068,12 +11195,12 @@ func (m *BatchSwitchWitness) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *BatchSwitchWitness) MarshalTo(dAtA []byte) (int, error) { +func (m *IsSnapshotRecoveringResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *BatchSwitchWitness) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *IsSnapshotRecoveringResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -12082,24 +11209,32 @@ func (m *BatchSwitchWitness) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if len(m.SwitchWitnesses) > 0 { - for iNdEx := len(m.SwitchWitnesses) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.SwitchWitnesses[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) + if m.Marked { + i-- + if m.Marked { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x10 + } + if m.Header != nil { + { + size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err } - i-- - dAtA[i] = 0xa + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) } + i-- + dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *RegionHeartbeatResponse) Marshal() (dAtA []byte, err error) { +func (m *GetStoreRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -12109,12 +11244,12 @@ func (m *RegionHeartbeatResponse) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *RegionHeartbeatResponse) MarshalTo(dAtA []byte) (int, error) { +func (m *GetStoreRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *RegionHeartbeatResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *GetStoreRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -12123,57 +11258,14 @@ func (m *RegionHeartbeatResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if m.SwitchWitnesses != nil { - { - size, err := m.SwitchWitnesses.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x52 - } - if m.ChangePeerV2 != nil { - { - size, err := m.ChangePeerV2.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x4a - } - if m.SplitRegion != nil { - { - size, err := m.SplitRegion.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x42 - } - if m.Merge != nil { - { - size, err := m.Merge.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } + if m.StoreId != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.StoreId)) i-- - dAtA[i] = 0x3a + dAtA[i] = 0x10 } - if m.TargetPeer != nil { + if m.Header != nil { { - size, err := m.TargetPeer.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -12181,28 +11273,38 @@ func (m *RegionHeartbeatResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) i = encodeVarintPdpb(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0x32 + dAtA[i] = 0xa } - if m.RegionEpoch != nil { - { - size, err := m.RegionEpoch.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x2a + return len(dAtA) - i, nil +} + +func (m *GetStoreResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - if m.RegionId != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.RegionId)) - i-- - dAtA[i] = 0x20 + return dAtA[:n], nil +} + +func (m *GetStoreResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GetStoreResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - if m.TransferLeader != nil { + if m.Stats != nil { { - size, err := m.TransferLeader.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Stats.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -12212,9 +11314,9 @@ func (m *RegionHeartbeatResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) i-- dAtA[i] = 0x1a } - if m.ChangePeer != nil { + if m.Store != nil { { - size, err := m.ChangePeer.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Store.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -12239,7 +11341,7 @@ func (m *RegionHeartbeatResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) return len(dAtA) - i, nil } -func (m *AskSplitRequest) Marshal() (dAtA []byte, err error) { +func (m *PutStoreRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -12249,12 +11351,12 @@ func (m *AskSplitRequest) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *AskSplitRequest) MarshalTo(dAtA []byte) (int, error) { +func (m *PutStoreRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *AskSplitRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *PutStoreRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -12263,9 +11365,9 @@ func (m *AskSplitRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if m.Region != nil { + if m.Store != nil { { - size, err := m.Region.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Store.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -12290,7 +11392,7 @@ func (m *AskSplitRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *AskSplitResponse) Marshal() (dAtA []byte, err error) { +func (m *PutStoreResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -12300,12 +11402,12 @@ func (m *AskSplitResponse) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *AskSplitResponse) MarshalTo(dAtA []byte) (int, error) { +func (m *PutStoreResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *AskSplitResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *PutStoreResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -12314,28 +11416,17 @@ func (m *AskSplitResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if len(m.NewPeerIds) > 0 { - dAtA76 := make([]byte, len(m.NewPeerIds)*10) - var j75 int - for _, num := range m.NewPeerIds { - for num >= 1<<7 { - dAtA76[j75] = uint8(uint64(num)&0x7f | 0x80) - num >>= 7 - j75++ + if m.ReplicationStatus != nil { + { + size, err := m.ReplicationStatus.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err } - dAtA76[j75] = uint8(num) - j75++ + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) } - i -= j75 - copy(dAtA[i:], dAtA76[:j75]) - i = encodeVarintPdpb(dAtA, i, uint64(j75)) - i-- - dAtA[i] = 0x1a - } - if m.NewRegionId != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.NewRegionId)) i-- - dAtA[i] = 0x10 + dAtA[i] = 0x12 } if m.Header != nil { { @@ -12352,7 +11443,7 @@ func (m *AskSplitResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *ReportSplitRequest) Marshal() (dAtA []byte, err error) { +func (m *GetAllStoresRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -12362,12 +11453,12 @@ func (m *ReportSplitRequest) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *ReportSplitRequest) MarshalTo(dAtA []byte) (int, error) { +func (m *GetAllStoresRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ReportSplitRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *GetAllStoresRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -12376,29 +11467,15 @@ func (m *ReportSplitRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if m.Right != nil { - { - size, err := m.Right.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } + if m.ExcludeTombstoneStores { i-- - dAtA[i] = 0x1a - } - if m.Left != nil { - { - size, err := m.Left.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) + if m.ExcludeTombstoneStores { + dAtA[i] = 1 + } else { + dAtA[i] = 0 } i-- - dAtA[i] = 0x12 + dAtA[i] = 0x10 } if m.Header != nil { { @@ -12415,7 +11492,7 @@ func (m *ReportSplitRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *ReportSplitResponse) Marshal() (dAtA []byte, err error) { +func (m *GetAllStoresResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -12425,12 +11502,12 @@ func (m *ReportSplitResponse) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *ReportSplitResponse) MarshalTo(dAtA []byte) (int, error) { +func (m *GetAllStoresResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ReportSplitResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *GetAllStoresResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -12439,22 +11516,36 @@ func (m *ReportSplitResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if m.Header != nil { - { - size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- + if len(m.Stores) > 0 { + for iNdEx := len(m.Stores) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Stores[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + } + if m.Header != nil { + { + size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *AskBatchSplitRequest) Marshal() (dAtA []byte, err error) { +func (m *GetRegionRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -12464,12 +11555,12 @@ func (m *AskBatchSplitRequest) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *AskBatchSplitRequest) MarshalTo(dAtA []byte) (int, error) { +func (m *GetRegionRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *AskBatchSplitRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *GetRegionRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -12478,20 +11569,20 @@ func (m *AskBatchSplitRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if m.SplitCount != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.SplitCount)) + if m.NeedBuckets { + i-- + if m.NeedBuckets { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } i-- dAtA[i] = 0x18 } - if m.Region != nil { - { - size, err := m.Region.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } + if len(m.RegionKey) > 0 { + i -= len(m.RegionKey) + copy(dAtA[i:], m.RegionKey) + i = encodeVarintPdpb(dAtA, i, uint64(len(m.RegionKey))) i-- dAtA[i] = 0x12 } @@ -12510,7 +11601,7 @@ func (m *AskBatchSplitRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *SplitID) Marshal() (dAtA []byte, err error) { +func (m *GetRegionResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -12520,12 +11611,12 @@ func (m *SplitID) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *SplitID) MarshalTo(dAtA []byte) (int, error) { +func (m *GetRegionResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *SplitID) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *GetRegionResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -12534,60 +11625,36 @@ func (m *SplitID) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if len(m.NewPeerIds) > 0 { - dAtA85 := make([]byte, len(m.NewPeerIds)*10) - var j84 int - for _, num := range m.NewPeerIds { - for num >= 1<<7 { - dAtA85[j84] = uint8(uint64(num)&0x7f | 0x80) - num >>= 7 - j84++ + if m.Buckets != nil { + { + size, err := m.Buckets.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err } - dAtA85[j84] = uint8(num) - j84++ + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) } - i -= j84 - copy(dAtA[i:], dAtA85[:j84]) - i = encodeVarintPdpb(dAtA, i, uint64(j84)) - i-- - dAtA[i] = 0x12 - } - if m.NewRegionId != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.NewRegionId)) i-- - dAtA[i] = 0x8 - } - return len(dAtA) - i, nil -} - -func (m *AskBatchSplitResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err + dAtA[i] = 0x3a } - return dAtA[:n], nil -} - -func (m *AskBatchSplitResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *AskBatchSplitResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.XXX_unrecognized != nil { - i -= len(m.XXX_unrecognized) - copy(dAtA[i:], m.XXX_unrecognized) + if len(m.PendingPeers) > 0 { + for iNdEx := len(m.PendingPeers) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.PendingPeers[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x32 + } } - if len(m.Ids) > 0 { - for iNdEx := len(m.Ids) - 1; iNdEx >= 0; iNdEx-- { + if len(m.DownPeers) > 0 { + for iNdEx := len(m.DownPeers) - 1; iNdEx >= 0; iNdEx-- { { - size, err := m.Ids[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + size, err := m.DownPeers[iNdEx].MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -12595,12 +11662,12 @@ func (m *AskBatchSplitResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i = encodeVarintPdpb(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0x12 + dAtA[i] = 0x2a } } - if m.Header != nil { + if m.Leader != nil { { - size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Leader.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -12608,48 +11675,19 @@ func (m *AskBatchSplitResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i = encodeVarintPdpb(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *ReportBatchSplitRequest) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil -} - -func (m *ReportBatchSplitRequest) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *ReportBatchSplitRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.XXX_unrecognized != nil { - i -= len(m.XXX_unrecognized) - copy(dAtA[i:], m.XXX_unrecognized) + dAtA[i] = 0x1a } - if len(m.Regions) > 0 { - for iNdEx := len(m.Regions) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.Regions[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) + if m.Region != nil { + { + size, err := m.Region.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err } - i-- - dAtA[i] = 0x12 + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) } + i-- + dAtA[i] = 0x12 } if m.Header != nil { { @@ -12666,7 +11704,7 @@ func (m *ReportBatchSplitRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) return len(dAtA) - i, nil } -func (m *ReportBatchSplitResponse) Marshal() (dAtA []byte, err error) { +func (m *GetRegionByIDRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -12676,12 +11714,12 @@ func (m *ReportBatchSplitResponse) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *ReportBatchSplitResponse) MarshalTo(dAtA []byte) (int, error) { +func (m *GetRegionByIDRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ReportBatchSplitResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *GetRegionByIDRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -12690,6 +11728,21 @@ func (m *ReportBatchSplitResponse) MarshalToSizedBuffer(dAtA []byte) (int, error i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } + if m.NeedBuckets { + i-- + if m.NeedBuckets { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x18 + } + if m.RegionId != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.RegionId)) + i-- + dAtA[i] = 0x10 + } if m.Header != nil { { size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) @@ -12705,7 +11758,7 @@ func (m *ReportBatchSplitResponse) MarshalToSizedBuffer(dAtA []byte) (int, error return len(dAtA) - i, nil } -func (m *TimeInterval) Marshal() (dAtA []byte, err error) { +func (m *ScanRegionsRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -12715,12 +11768,12 @@ func (m *TimeInterval) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *TimeInterval) MarshalTo(dAtA []byte) (int, error) { +func (m *ScanRegionsRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *TimeInterval) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ScanRegionsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -12729,20 +11782,41 @@ func (m *TimeInterval) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if m.EndTimestamp != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.EndTimestamp)) + if len(m.EndKey) > 0 { + i -= len(m.EndKey) + copy(dAtA[i:], m.EndKey) + i = encodeVarintPdpb(dAtA, i, uint64(len(m.EndKey))) i-- - dAtA[i] = 0x10 + dAtA[i] = 0x22 } - if m.StartTimestamp != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.StartTimestamp)) + if m.Limit != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.Limit)) i-- - dAtA[i] = 0x8 + dAtA[i] = 0x18 + } + if len(m.StartKey) > 0 { + i -= len(m.StartKey) + copy(dAtA[i:], m.StartKey) + i = encodeVarintPdpb(dAtA, i, uint64(len(m.StartKey))) + i-- + dAtA[i] = 0x12 + } + if m.Header != nil { + { + size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *RecordPair) Marshal() (dAtA []byte, err error) { +func (m *Region) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -12752,12 +11826,12 @@ func (m *RecordPair) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *RecordPair) MarshalTo(dAtA []byte) (int, error) { +func (m *Region) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *RecordPair) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *Region) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -12766,22 +11840,62 @@ func (m *RecordPair) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if m.Value != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.Value)) - i-- - dAtA[i] = 0x10 - } - if len(m.Key) > 0 { - i -= len(m.Key) - copy(dAtA[i:], m.Key) - i = encodeVarintPdpb(dAtA, i, uint64(len(m.Key))) + if len(m.PendingPeers) > 0 { + for iNdEx := len(m.PendingPeers) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.PendingPeers[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + } + if len(m.DownPeers) > 0 { + for iNdEx := len(m.DownPeers) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.DownPeers[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + } + if m.Leader != nil { + { + size, err := m.Leader.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.Region != nil { + { + size, err := m.Region.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *PeerStat) Marshal() (dAtA []byte, err error) { +func (m *ScanRegionsResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -12791,12 +11905,12 @@ func (m *PeerStat) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *PeerStat) MarshalTo(dAtA []byte) (int, error) { +func (m *ScanRegionsResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *PeerStat) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ScanRegionsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -12805,19 +11919,51 @@ func (m *PeerStat) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if m.WrittenBytes != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.WrittenBytes)) - i-- - dAtA[i] = 0x30 + if len(m.Regions) > 0 { + for iNdEx := len(m.Regions) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Regions[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } } - if m.WrittenKeys != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.WrittenKeys)) - i-- - dAtA[i] = 0x28 + if len(m.Leaders) > 0 { + for iNdEx := len(m.Leaders) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Leaders[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } } - if m.QueryStats != nil { + if len(m.RegionMetas) > 0 { + for iNdEx := len(m.RegionMetas) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.RegionMetas[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + } + if m.Header != nil { { - size, err := m.QueryStats.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -12825,27 +11971,12 @@ func (m *PeerStat) MarshalToSizedBuffer(dAtA []byte) (int, error) { i = encodeVarintPdpb(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0x22 - } - if m.ReadBytes != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.ReadBytes)) - i-- - dAtA[i] = 0x18 - } - if m.ReadKeys != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.ReadKeys)) - i-- - dAtA[i] = 0x10 - } - if m.RegionId != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.RegionId)) - i-- - dAtA[i] = 0x8 + dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *StoreStats) Marshal() (dAtA []byte, err error) { +func (m *GetClusterConfigRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -12855,12 +11986,12 @@ func (m *StoreStats) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *StoreStats) MarshalTo(dAtA []byte) (int, error) { +func (m *GetClusterConfigRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *StoreStats) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *GetClusterConfigRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -12869,9 +12000,9 @@ func (m *StoreStats) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if m.SlowTrend != nil { + if m.Header != nil { { - size, err := m.SlowTrend.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -12879,68 +12010,50 @@ func (m *StoreStats) MarshalToSizedBuffer(dAtA []byte) (int, error) { i = encodeVarintPdpb(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0xd2 + dAtA[i] = 0xa } - if len(m.SnapshotStats) > 0 { - for iNdEx := len(m.SnapshotStats) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.SnapshotStats[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0xca - } + return len(dAtA) - i, nil +} + +func (m *GetClusterConfigResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - if m.IsApplyBusy { - i-- - if m.IsApplyBusy { - dAtA[i] = 1 - } else { - dAtA[i] = 0 - } - i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0xc0 + return dAtA[:n], nil +} + +func (m *GetClusterConfigResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GetClusterConfigResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - if len(m.DamagedRegionsId) > 0 { - dAtA92 := make([]byte, len(m.DamagedRegionsId)*10) - var j91 int - for _, num := range m.DamagedRegionsId { - for num >= 1<<7 { - dAtA92[j91] = uint8(uint64(num)&0x7f | 0x80) - num >>= 7 - j91++ + if m.Cluster != nil { + { + size, err := m.Cluster.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err } - dAtA92[j91] = uint8(num) - j91++ + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) } - i -= j91 - copy(dAtA[i:], dAtA92[:j91]) - i = encodeVarintPdpb(dAtA, i, uint64(j91)) - i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0xba - } - if m.SlowScore != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.SlowScore)) i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0xb0 + dAtA[i] = 0x12 } - if m.QueryStats != nil { + if m.Header != nil { { - size, err := m.QueryStats.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -12948,93 +12061,38 @@ func (m *StoreStats) MarshalToSizedBuffer(dAtA []byte) (int, error) { i = encodeVarintPdpb(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0xaa + dAtA[i] = 0xa } - if len(m.PeerStats) > 0 { - for iNdEx := len(m.PeerStats) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.PeerStats[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0xa2 - } + return len(dAtA) - i, nil +} + +func (m *PutClusterConfigRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - if len(m.OpLatencies) > 0 { - for iNdEx := len(m.OpLatencies) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.OpLatencies[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0x9a - } - } - if len(m.WriteIoRates) > 0 { - for iNdEx := len(m.WriteIoRates) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.WriteIoRates[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0x92 - } - } - if len(m.ReadIoRates) > 0 { - for iNdEx := len(m.ReadIoRates) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.ReadIoRates[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0x8a - } - } - if len(m.CpuUsages) > 0 { - for iNdEx := len(m.CpuUsages) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.CpuUsages[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0x82 - } + return dAtA[:n], nil +} + +func (m *PutClusterConfigRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *PutClusterConfigRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - if m.Interval != nil { + if m.Cluster != nil { { - size, err := m.Interval.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Cluster.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -13042,87 +12100,24 @@ func (m *StoreStats) MarshalToSizedBuffer(dAtA []byte) (int, error) { i = encodeVarintPdpb(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0x7a - } - if m.KeysRead != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.KeysRead)) - i-- - dAtA[i] = 0x70 - } - if m.BytesRead != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.BytesRead)) - i-- - dAtA[i] = 0x68 - } - if m.KeysWritten != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.KeysWritten)) - i-- - dAtA[i] = 0x60 - } - if m.BytesWritten != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.BytesWritten)) - i-- - dAtA[i] = 0x58 - } - if m.UsedSize != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.UsedSize)) - i-- - dAtA[i] = 0x50 + dAtA[i] = 0x12 } - if m.IsBusy { - i-- - if m.IsBusy { - dAtA[i] = 1 - } else { - dAtA[i] = 0 + if m.Header != nil { + { + size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0x48 - } - if m.ApplyingSnapCount != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.ApplyingSnapCount)) - i-- - dAtA[i] = 0x40 - } - if m.StartTime != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.StartTime)) - i-- - dAtA[i] = 0x38 - } - if m.ReceivingSnapCount != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.ReceivingSnapCount)) - i-- - dAtA[i] = 0x30 - } - if m.SendingSnapCount != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.SendingSnapCount)) - i-- - dAtA[i] = 0x28 - } - if m.RegionCount != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.RegionCount)) - i-- - dAtA[i] = 0x20 - } - if m.Available != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.Available)) - i-- - dAtA[i] = 0x18 - } - if m.Capacity != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.Capacity)) - i-- - dAtA[i] = 0x10 - } - if m.StoreId != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.StoreId)) - i-- - dAtA[i] = 0x8 + dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *SlowTrend) Marshal() (dAtA []byte, err error) { +func (m *PutClusterConfigResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -13132,12 +12127,12 @@ func (m *SlowTrend) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *SlowTrend) MarshalTo(dAtA []byte) (int, error) { +func (m *PutClusterConfigResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *SlowTrend) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *PutClusterConfigResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -13146,34 +12141,22 @@ func (m *SlowTrend) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if m.ResultRate != 0 { - i -= 8 - encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.ResultRate)))) - i-- - dAtA[i] = 0x21 - } - if m.ResultValue != 0 { - i -= 8 - encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.ResultValue)))) - i-- - dAtA[i] = 0x19 - } - if m.CauseRate != 0 { - i -= 8 - encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.CauseRate)))) - i-- - dAtA[i] = 0x11 - } - if m.CauseValue != 0 { - i -= 8 - encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.CauseValue)))) + if m.Header != nil { + { + size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } i-- - dAtA[i] = 0x9 + dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *SnapshotStat) Marshal() (dAtA []byte, err error) { +func (m *Member) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -13183,12 +12166,12 @@ func (m *SnapshotStat) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *SnapshotStat) MarshalTo(dAtA []byte) (int, error) { +func (m *Member) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *SnapshotStat) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *Member) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -13197,106 +12180,73 @@ func (m *SnapshotStat) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if m.TransportSize != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.TransportSize)) + if len(m.DcLocation) > 0 { + i -= len(m.DcLocation) + copy(dAtA[i:], m.DcLocation) + i = encodeVarintPdpb(dAtA, i, uint64(len(m.DcLocation))) i-- - dAtA[i] = 0x28 + dAtA[i] = 0x4a } - if m.TotalDurationSec != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.TotalDurationSec)) + if len(m.GitHash) > 0 { + i -= len(m.GitHash) + copy(dAtA[i:], m.GitHash) + i = encodeVarintPdpb(dAtA, i, uint64(len(m.GitHash))) i-- - dAtA[i] = 0x20 + dAtA[i] = 0x42 } - if m.SendDurationSec != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.SendDurationSec)) + if len(m.BinaryVersion) > 0 { + i -= len(m.BinaryVersion) + copy(dAtA[i:], m.BinaryVersion) + i = encodeVarintPdpb(dAtA, i, uint64(len(m.BinaryVersion))) i-- - dAtA[i] = 0x18 + dAtA[i] = 0x3a } - if m.GenerateDurationSec != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.GenerateDurationSec)) + if len(m.DeployPath) > 0 { + i -= len(m.DeployPath) + copy(dAtA[i:], m.DeployPath) + i = encodeVarintPdpb(dAtA, i, uint64(len(m.DeployPath))) i-- - dAtA[i] = 0x10 + dAtA[i] = 0x32 } - if m.RegionId != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.RegionId)) + if m.LeaderPriority != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.LeaderPriority)) i-- - dAtA[i] = 0x8 + dAtA[i] = 0x28 } - return len(dAtA) - i, nil -} - -func (m *PeerReport) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil -} - -func (m *PeerReport) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *PeerReport) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.XXX_unrecognized != nil { - i -= len(m.XXX_unrecognized) - copy(dAtA[i:], m.XXX_unrecognized) - } - if m.HasCommitMerge { - i-- - if m.HasCommitMerge { - dAtA[i] = 1 - } else { - dAtA[i] = 0 + if len(m.ClientUrls) > 0 { + for iNdEx := len(m.ClientUrls) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.ClientUrls[iNdEx]) + copy(dAtA[i:], m.ClientUrls[iNdEx]) + i = encodeVarintPdpb(dAtA, i, uint64(len(m.ClientUrls[iNdEx]))) + i-- + dAtA[i] = 0x22 } - i-- - dAtA[i] = 0x20 } - if m.IsForceLeader { - i-- - if m.IsForceLeader { - dAtA[i] = 1 - } else { - dAtA[i] = 0 + if len(m.PeerUrls) > 0 { + for iNdEx := len(m.PeerUrls) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.PeerUrls[iNdEx]) + copy(dAtA[i:], m.PeerUrls[iNdEx]) + i = encodeVarintPdpb(dAtA, i, uint64(len(m.PeerUrls[iNdEx]))) + i-- + dAtA[i] = 0x1a } - i-- - dAtA[i] = 0x18 } - if m.RegionState != nil { - { - size, err := m.RegionState.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } + if m.MemberId != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.MemberId)) i-- - dAtA[i] = 0x12 + dAtA[i] = 0x10 } - if m.RaftState != nil { - { - size, err := m.RaftState.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } + if len(m.Name) > 0 { + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintPdpb(dAtA, i, uint64(len(m.Name))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *StoreReport) Marshal() (dAtA []byte, err error) { +func (m *GetMembersRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -13306,12 +12256,12 @@ func (m *StoreReport) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *StoreReport) MarshalTo(dAtA []byte) (int, error) { +func (m *GetMembersRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *StoreReport) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *GetMembersRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -13320,29 +12270,22 @@ func (m *StoreReport) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if m.Step != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.Step)) - i-- - dAtA[i] = 0x10 - } - if len(m.PeerReports) > 0 { - for iNdEx := len(m.PeerReports) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.PeerReports[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) + if m.Header != nil { + { + size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err } - i-- - dAtA[i] = 0xa + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) } + i-- + dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *StoreHeartbeatRequest) Marshal() (dAtA []byte, err error) { +func (m *GetMembersResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -13352,12 +12295,12 @@ func (m *StoreHeartbeatRequest) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *StoreHeartbeatRequest) MarshalTo(dAtA []byte) (int, error) { +func (m *GetMembersResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *StoreHeartbeatRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *GetMembersResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -13366,9 +12309,35 @@ func (m *StoreHeartbeatRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if m.DrAutosyncStatus != nil { + if len(m.TsoAllocatorLeaders) > 0 { + for k := range m.TsoAllocatorLeaders { + v := m.TsoAllocatorLeaders[k] + baseI := i + if v != nil { + { + size, err := v.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + i -= len(k) + copy(dAtA[i:], k) + i = encodeVarintPdpb(dAtA, i, uint64(len(k))) + i-- + dAtA[i] = 0xa + i = encodeVarintPdpb(dAtA, i, uint64(baseI-i)) + i-- + dAtA[i] = 0x2a + } + } + if m.EtcdLeader != nil { { - size, err := m.DrAutosyncStatus.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.EtcdLeader.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -13378,9 +12347,9 @@ func (m *StoreHeartbeatRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i-- dAtA[i] = 0x22 } - if m.StoreReport != nil { + if m.Leader != nil { { - size, err := m.StoreReport.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Leader.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -13390,17 +12359,19 @@ func (m *StoreHeartbeatRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i-- dAtA[i] = 0x1a } - if m.Stats != nil { - { - size, err := m.Stats.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err + if len(m.Members) > 0 { + for iNdEx := len(m.Members) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Members[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 } - i-- - dAtA[i] = 0x12 } if m.Header != nil { { @@ -13417,7 +12388,7 @@ func (m *StoreHeartbeatRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *DemoteFailedVoters) Marshal() (dAtA []byte, err error) { +func (m *GetClusterInfoRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -13427,12 +12398,12 @@ func (m *DemoteFailedVoters) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *DemoteFailedVoters) MarshalTo(dAtA []byte) (int, error) { +func (m *GetClusterInfoRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *DemoteFailedVoters) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *GetClusterInfoRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -13441,29 +12412,22 @@ func (m *DemoteFailedVoters) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if len(m.FailedVoters) > 0 { - for iNdEx := len(m.FailedVoters) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.FailedVoters[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) + if m.Header != nil { + { + size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err } - i-- - dAtA[i] = 0x12 + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) } - } - if m.RegionId != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.RegionId)) i-- - dAtA[i] = 0x8 + dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *ForceLeader) Marshal() (dAtA []byte, err error) { +func (m *GetClusterInfoResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -13473,12 +12437,12 @@ func (m *ForceLeader) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *ForceLeader) MarshalTo(dAtA []byte) (int, error) { +func (m *GetClusterInfoResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ForceLeader) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *GetClusterInfoResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -13487,46 +12451,40 @@ func (m *ForceLeader) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if len(m.EnterForceLeaders) > 0 { - dAtA102 := make([]byte, len(m.EnterForceLeaders)*10) - var j101 int - for _, num := range m.EnterForceLeaders { + if len(m.ServiceModes) > 0 { + dAtA52 := make([]byte, len(m.ServiceModes)*10) + var j51 int + for _, num := range m.ServiceModes { for num >= 1<<7 { - dAtA102[j101] = uint8(uint64(num)&0x7f | 0x80) + dAtA52[j51] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 - j101++ + j51++ } - dAtA102[j101] = uint8(num) - j101++ + dAtA52[j51] = uint8(num) + j51++ } - i -= j101 - copy(dAtA[i:], dAtA102[:j101]) - i = encodeVarintPdpb(dAtA, i, uint64(j101)) + i -= j51 + copy(dAtA[i:], dAtA52[:j51]) + i = encodeVarintPdpb(dAtA, i, uint64(j51)) i-- dAtA[i] = 0x12 } - if len(m.FailedStores) > 0 { - dAtA104 := make([]byte, len(m.FailedStores)*10) - var j103 int - for _, num := range m.FailedStores { - for num >= 1<<7 { - dAtA104[j103] = uint8(uint64(num)&0x7f | 0x80) - num >>= 7 - j103++ + if m.Header != nil { + { + size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err } - dAtA104[j103] = uint8(num) - j103++ + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) } - i -= j103 - copy(dAtA[i:], dAtA104[:j103]) - i = encodeVarintPdpb(dAtA, i, uint64(j103)) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *RecoveryPlan) Marshal() (dAtA []byte, err error) { +func (m *PeerStats) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -13536,12 +12494,12 @@ func (m *RecoveryPlan) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *RecoveryPlan) MarshalTo(dAtA []byte) (int, error) { +func (m *PeerStats) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *RecoveryPlan) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *PeerStats) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -13550,14 +12508,14 @@ func (m *RecoveryPlan) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if m.Step != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.Step)) + if m.DownSeconds != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.DownSeconds)) i-- - dAtA[i] = 0x30 + dAtA[i] = 0x10 } - if m.ForceLeader != nil { + if m.Peer != nil { { - size, err := m.ForceLeader.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Peer.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -13565,72 +12523,12 @@ func (m *RecoveryPlan) MarshalToSizedBuffer(dAtA []byte) (int, error) { i = encodeVarintPdpb(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0x2a - } - if len(m.Demotes) > 0 { - for iNdEx := len(m.Demotes) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.Demotes[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x22 - } - } - if len(m.Tombstones) > 0 { - dAtA107 := make([]byte, len(m.Tombstones)*10) - var j106 int - for _, num := range m.Tombstones { - for num >= 1<<7 { - dAtA107[j106] = uint8(uint64(num)&0x7f | 0x80) - num >>= 7 - j106++ - } - dAtA107[j106] = uint8(num) - j106++ - } - i -= j106 - copy(dAtA[i:], dAtA107[:j106]) - i = encodeVarintPdpb(dAtA, i, uint64(j106)) - i-- - dAtA[i] = 0x1a - } - if len(m.Updates) > 0 { - for iNdEx := len(m.Updates) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.Updates[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - } - if len(m.Creates) > 0 { - for iNdEx := len(m.Creates) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.Creates[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } + dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *AwakenRegions) Marshal() (dAtA []byte, err error) { +func (m *RegionHeartbeatRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -13640,12 +12538,12 @@ func (m *AwakenRegions) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *AwakenRegions) MarshalTo(dAtA []byte) (int, error) { +func (m *RegionHeartbeatRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *AwakenRegions) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *RegionHeartbeatRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -13654,54 +12552,23 @@ func (m *AwakenRegions) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if len(m.AbnormalStores) > 0 { - dAtA109 := make([]byte, len(m.AbnormalStores)*10) - var j108 int - for _, num := range m.AbnormalStores { - for num >= 1<<7 { - dAtA109[j108] = uint8(uint64(num)&0x7f | 0x80) - num >>= 7 - j108++ - } - dAtA109[j108] = uint8(num) - j108++ - } - i -= j108 - copy(dAtA[i:], dAtA109[:j108]) - i = encodeVarintPdpb(dAtA, i, uint64(j108)) + if m.ApproximateKvSize != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.ApproximateKvSize)) i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *StoreHeartbeatResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x90 } - return dAtA[:n], nil -} - -func (m *StoreHeartbeatResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *StoreHeartbeatResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.XXX_unrecognized != nil { - i -= len(m.XXX_unrecognized) - copy(dAtA[i:], m.XXX_unrecognized) + if m.CpuUsage != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.CpuUsage)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x88 } - if m.AwakenRegions != nil { + if m.QueryStats != nil { { - size, err := m.AwakenRegions.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.QueryStats.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -13709,11 +12576,13 @@ func (m *StoreHeartbeatResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) i = encodeVarintPdpb(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0x32 + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x82 } - if m.RecoveryPlan != nil { + if m.ReplicationStatus != nil { { - size, err := m.RecoveryPlan.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.ReplicationStatus.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -13721,28 +12590,98 @@ func (m *StoreHeartbeatResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) i = encodeVarintPdpb(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0x2a + dAtA[i] = 0x7a } - if m.RequireDetailedReport { + if m.Term != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.Term)) i-- - if m.RequireDetailedReport { - dAtA[i] = 1 - } else { - dAtA[i] = 0 + dAtA[i] = 0x70 + } + if m.ApproximateKeys != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.ApproximateKeys)) + i-- + dAtA[i] = 0x68 + } + if m.Interval != nil { + { + size, err := m.Interval.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0x20 + dAtA[i] = 0x62 } - if len(m.ClusterVersion) > 0 { - i -= len(m.ClusterVersion) - copy(dAtA[i:], m.ClusterVersion) - i = encodeVarintPdpb(dAtA, i, uint64(len(m.ClusterVersion))) + if m.ApproximateSize != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.ApproximateSize)) + i-- + dAtA[i] = 0x50 + } + if m.KeysRead != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.KeysRead)) + i-- + dAtA[i] = 0x48 + } + if m.KeysWritten != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.KeysWritten)) + i-- + dAtA[i] = 0x40 + } + if m.BytesRead != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.BytesRead)) + i-- + dAtA[i] = 0x38 + } + if m.BytesWritten != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.BytesWritten)) + i-- + dAtA[i] = 0x30 + } + if len(m.PendingPeers) > 0 { + for iNdEx := len(m.PendingPeers) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.PendingPeers[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + } + } + if len(m.DownPeers) > 0 { + for iNdEx := len(m.DownPeers) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.DownPeers[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + } + if m.Leader != nil { + { + size, err := m.Leader.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } i-- dAtA[i] = 0x1a } - if m.ReplicationStatus != nil { + if m.Region != nil { { - size, err := m.ReplicationStatus.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Region.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -13767,7 +12706,7 @@ func (m *StoreHeartbeatResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) return len(dAtA) - i, nil } -func (m *ScatterRegionRequest) Marshal() (dAtA []byte, err error) { +func (m *ChangePeer) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -13777,12 +12716,12 @@ func (m *ScatterRegionRequest) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *ScatterRegionRequest) MarshalTo(dAtA []byte) (int, error) { +func (m *ChangePeer) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ScatterRegionRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ChangePeer) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -13791,68 +12730,14 @@ func (m *ScatterRegionRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if m.RetryLimit != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.RetryLimit)) + if m.ChangeType != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.ChangeType)) i-- - dAtA[i] = 0x38 + dAtA[i] = 0x10 } - if len(m.RegionsId) > 0 { - dAtA115 := make([]byte, len(m.RegionsId)*10) - var j114 int - for _, num := range m.RegionsId { - for num >= 1<<7 { - dAtA115[j114] = uint8(uint64(num)&0x7f | 0x80) - num >>= 7 - j114++ - } - dAtA115[j114] = uint8(num) - j114++ - } - i -= j114 - copy(dAtA[i:], dAtA115[:j114]) - i = encodeVarintPdpb(dAtA, i, uint64(j114)) - i-- - dAtA[i] = 0x32 - } - if len(m.Group) > 0 { - i -= len(m.Group) - copy(dAtA[i:], m.Group) - i = encodeVarintPdpb(dAtA, i, uint64(len(m.Group))) - i-- - dAtA[i] = 0x2a - } - if m.Leader != nil { - { - size, err := m.Leader.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x22 - } - if m.Region != nil { - { - size, err := m.Region.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a - } - if m.RegionId != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.RegionId)) - i-- - dAtA[i] = 0x10 - } - if m.Header != nil { + if m.Peer != nil { { - size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Peer.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -13865,7 +12750,7 @@ func (m *ScatterRegionRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *ScatterRegionResponse) Marshal() (dAtA []byte, err error) { +func (m *ChangePeerV2) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -13875,12 +12760,12 @@ func (m *ScatterRegionResponse) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *ScatterRegionResponse) MarshalTo(dAtA []byte) (int, error) { +func (m *ChangePeerV2) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ScatterRegionResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ChangePeerV2) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -13889,27 +12774,24 @@ func (m *ScatterRegionResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if m.FinishedPercentage != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.FinishedPercentage)) - i-- - dAtA[i] = 0x10 - } - if m.Header != nil { - { - size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err + if len(m.Changes) > 0 { + for iNdEx := len(m.Changes) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Changes[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa } - i-- - dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *GetGCSafePointRequest) Marshal() (dAtA []byte, err error) { +func (m *TransferLeader) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -13919,12 +12801,12 @@ func (m *GetGCSafePointRequest) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *GetGCSafePointRequest) MarshalTo(dAtA []byte) (int, error) { +func (m *TransferLeader) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *GetGCSafePointRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *TransferLeader) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -13933,9 +12815,23 @@ func (m *GetGCSafePointRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if m.Header != nil { + if len(m.Peers) > 0 { + for iNdEx := len(m.Peers) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Peers[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + } + if m.Peer != nil { { - size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Peer.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -13948,7 +12844,7 @@ func (m *GetGCSafePointRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *GetGCSafePointResponse) Marshal() (dAtA []byte, err error) { +func (m *Merge) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -13958,12 +12854,12 @@ func (m *GetGCSafePointResponse) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *GetGCSafePointResponse) MarshalTo(dAtA []byte) (int, error) { +func (m *Merge) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *GetGCSafePointResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *Merge) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -13972,14 +12868,9 @@ func (m *GetGCSafePointResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if m.SafePoint != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.SafePoint)) - i-- - dAtA[i] = 0x10 - } - if m.Header != nil { + if m.Target != nil { { - size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Target.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -13992,7 +12883,7 @@ func (m *GetGCSafePointResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) return len(dAtA) - i, nil } -func (m *UpdateGCSafePointRequest) Marshal() (dAtA []byte, err error) { +func (m *SplitRegion) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -14002,12 +12893,12 @@ func (m *UpdateGCSafePointRequest) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *UpdateGCSafePointRequest) MarshalTo(dAtA []byte) (int, error) { +func (m *SplitRegion) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *UpdateGCSafePointRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *SplitRegion) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -14016,27 +12907,24 @@ func (m *UpdateGCSafePointRequest) MarshalToSizedBuffer(dAtA []byte) (int, error i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if m.SafePoint != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.SafePoint)) - i-- - dAtA[i] = 0x10 - } - if m.Header != nil { - { - size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) + if len(m.Keys) > 0 { + for iNdEx := len(m.Keys) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Keys[iNdEx]) + copy(dAtA[i:], m.Keys[iNdEx]) + i = encodeVarintPdpb(dAtA, i, uint64(len(m.Keys[iNdEx]))) + i-- + dAtA[i] = 0x12 } + } + if m.Policy != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.Policy)) i-- - dAtA[i] = 0xa + dAtA[i] = 0x8 } return len(dAtA) - i, nil } -func (m *UpdateGCSafePointResponse) Marshal() (dAtA []byte, err error) { +func (m *SwitchWitness) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -14046,12 +12934,12 @@ func (m *UpdateGCSafePointResponse) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *UpdateGCSafePointResponse) MarshalTo(dAtA []byte) (int, error) { +func (m *SwitchWitness) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *UpdateGCSafePointResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *SwitchWitness) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -14060,27 +12948,25 @@ func (m *UpdateGCSafePointResponse) MarshalToSizedBuffer(dAtA []byte) (int, erro i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if m.NewSafePoint != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.NewSafePoint)) + if m.IsWitness { + i-- + if m.IsWitness { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } i-- dAtA[i] = 0x10 } - if m.Header != nil { - { - size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } + if m.PeerId != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.PeerId)) i-- - dAtA[i] = 0xa + dAtA[i] = 0x8 } return len(dAtA) - i, nil } -func (m *UpdateServiceGCSafePointRequest) Marshal() (dAtA []byte, err error) { +func (m *BatchSwitchWitness) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -14090,12 +12976,12 @@ func (m *UpdateServiceGCSafePointRequest) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *UpdateServiceGCSafePointRequest) MarshalTo(dAtA []byte) (int, error) { +func (m *BatchSwitchWitness) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *UpdateServiceGCSafePointRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *BatchSwitchWitness) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -14104,39 +12990,24 @@ func (m *UpdateServiceGCSafePointRequest) MarshalToSizedBuffer(dAtA []byte) (int i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if m.SafePoint != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.SafePoint)) - i-- - dAtA[i] = 0x20 - } - if m.TTL != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.TTL)) - i-- - dAtA[i] = 0x18 - } - if len(m.ServiceId) > 0 { - i -= len(m.ServiceId) - copy(dAtA[i:], m.ServiceId) - i = encodeVarintPdpb(dAtA, i, uint64(len(m.ServiceId))) - i-- - dAtA[i] = 0x12 - } - if m.Header != nil { - { - size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err + if len(m.SwitchWitnesses) > 0 { + for iNdEx := len(m.SwitchWitnesses) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.SwitchWitnesses[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa } - i-- - dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *UpdateServiceGCSafePointResponse) Marshal() (dAtA []byte, err error) { +func (m *RegionHeartbeatResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -14146,12 +13017,12 @@ func (m *UpdateServiceGCSafePointResponse) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *UpdateServiceGCSafePointResponse) MarshalTo(dAtA []byte) (int, error) { +func (m *RegionHeartbeatResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *UpdateServiceGCSafePointResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *RegionHeartbeatResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -14160,26 +13031,21 @@ func (m *UpdateServiceGCSafePointResponse) MarshalToSizedBuffer(dAtA []byte) (in i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if m.MinSafePoint != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.MinSafePoint)) - i-- - dAtA[i] = 0x20 - } - if m.TTL != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.TTL)) - i-- - dAtA[i] = 0x18 - } - if len(m.ServiceId) > 0 { - i -= len(m.ServiceId) - copy(dAtA[i:], m.ServiceId) - i = encodeVarintPdpb(dAtA, i, uint64(len(m.ServiceId))) + if m.SwitchWitnesses != nil { + { + size, err := m.SwitchWitnesses.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } i-- - dAtA[i] = 0x12 + dAtA[i] = 0x52 } - if m.Header != nil { + if m.ChangePeerV2 != nil { { - size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.ChangePeerV2.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -14187,12 +13053,101 @@ func (m *UpdateServiceGCSafePointResponse) MarshalToSizedBuffer(dAtA []byte) (in i = encodeVarintPdpb(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0xa + dAtA[i] = 0x4a } - return len(dAtA) - i, nil + if m.SplitRegion != nil { + { + size, err := m.SplitRegion.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x42 + } + if m.Merge != nil { + { + size, err := m.Merge.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x3a + } + if m.TargetPeer != nil { + { + size, err := m.TargetPeer.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x32 + } + if m.RegionEpoch != nil { + { + size, err := m.RegionEpoch.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + } + if m.RegionId != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.RegionId)) + i-- + dAtA[i] = 0x20 + } + if m.TransferLeader != nil { + { + size, err := m.TransferLeader.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.ChangePeer != nil { + { + size, err := m.ChangePeer.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.Header != nil { + { + size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil } -func (m *RegionStat) Marshal() (dAtA []byte, err error) { +func (m *AskSplitRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -14202,12 +13157,12 @@ func (m *RegionStat) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *RegionStat) MarshalTo(dAtA []byte) (int, error) { +func (m *AskSplitRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *RegionStat) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *AskSplitRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -14216,30 +13171,34 @@ func (m *RegionStat) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if m.KeysRead != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.KeysRead)) - i-- - dAtA[i] = 0x20 - } - if m.KeysWritten != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.KeysWritten)) - i-- - dAtA[i] = 0x18 - } - if m.BytesRead != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.BytesRead)) + if m.Region != nil { + { + size, err := m.Region.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } i-- - dAtA[i] = 0x10 + dAtA[i] = 0x12 } - if m.BytesWritten != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.BytesWritten)) + if m.Header != nil { + { + size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } i-- - dAtA[i] = 0x8 + dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *SyncRegionRequest) Marshal() (dAtA []byte, err error) { +func (m *AskSplitResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -14249,12 +13208,12 @@ func (m *SyncRegionRequest) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *SyncRegionRequest) MarshalTo(dAtA []byte) (int, error) { +func (m *AskSplitResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *SyncRegionRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *AskSplitResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -14263,22 +13222,28 @@ func (m *SyncRegionRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if m.StartIndex != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.StartIndex)) - i-- - dAtA[i] = 0x18 - } - if m.Member != nil { - { - size, err := m.Member.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err + if len(m.NewPeerIds) > 0 { + dAtA76 := make([]byte, len(m.NewPeerIds)*10) + var j75 int + for _, num := range m.NewPeerIds { + for num >= 1<<7 { + dAtA76[j75] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j75++ } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) + dAtA76[j75] = uint8(num) + j75++ } + i -= j75 + copy(dAtA[i:], dAtA76[:j75]) + i = encodeVarintPdpb(dAtA, i, uint64(j75)) i-- - dAtA[i] = 0x12 + dAtA[i] = 0x1a + } + if m.NewRegionId != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.NewRegionId)) + i-- + dAtA[i] = 0x10 } if m.Header != nil { { @@ -14295,7 +13260,7 @@ func (m *SyncRegionRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *PeersStats) Marshal() (dAtA []byte, err error) { +func (m *ReportSplitRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -14305,12 +13270,12 @@ func (m *PeersStats) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *PeersStats) MarshalTo(dAtA []byte) (int, error) { +func (m *ReportSplitRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *PeersStats) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ReportSplitRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -14319,24 +13284,46 @@ func (m *PeersStats) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if len(m.Peers) > 0 { - for iNdEx := len(m.Peers) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.Peers[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) + if m.Right != nil { + { + size, err := m.Right.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err } - i-- - dAtA[i] = 0xa + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.Left != nil { + { + size, err := m.Left.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.Header != nil { + { + size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) } + i-- + dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *Peers) Marshal() (dAtA []byte, err error) { +func (m *ReportSplitResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -14346,12 +13333,12 @@ func (m *Peers) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *Peers) MarshalTo(dAtA []byte) (int, error) { +func (m *ReportSplitResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *Peers) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ReportSplitResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -14360,24 +13347,22 @@ func (m *Peers) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if len(m.Peers) > 0 { - for iNdEx := len(m.Peers) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.Peers[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) + if m.Header != nil { + { + size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err } - i-- - dAtA[i] = 0xa + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) } + i-- + dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *SyncRegionResponse) Marshal() (dAtA []byte, err error) { +func (m *AskBatchSplitRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -14387,12 +13372,12 @@ func (m *SyncRegionResponse) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *SyncRegionResponse) MarshalTo(dAtA []byte) (int, error) { +func (m *AskBatchSplitRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *SyncRegionResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *AskBatchSplitRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -14401,98 +13386,22 @@ func (m *SyncRegionResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if len(m.PendingPeers) > 0 { - for iNdEx := len(m.PendingPeers) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.PendingPeers[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0x8a - } - } - if len(m.DownPeers) > 0 { - for iNdEx := len(m.DownPeers) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.DownPeers[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0x82 - } - } - if len(m.Buckets) > 0 { - for iNdEx := len(m.Buckets) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.Buckets[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x32 - } - } - if len(m.RegionLeaders) > 0 { - for iNdEx := len(m.RegionLeaders) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.RegionLeaders[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x2a - } - } - if len(m.RegionStats) > 0 { - for iNdEx := len(m.RegionStats) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.RegionStats[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x22 - } - } - if m.StartIndex != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.StartIndex)) + if m.SplitCount != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.SplitCount)) i-- dAtA[i] = 0x18 } - if len(m.Regions) > 0 { - for iNdEx := len(m.Regions) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.Regions[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) + if m.Region != nil { + { + size, err := m.Region.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err } - i-- - dAtA[i] = 0x12 + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) } + i-- + dAtA[i] = 0x12 } if m.Header != nil { { @@ -14509,7 +13418,7 @@ func (m *SyncRegionResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *GetOperatorRequest) Marshal() (dAtA []byte, err error) { +func (m *SplitID) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -14519,12 +13428,12 @@ func (m *GetOperatorRequest) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *GetOperatorRequest) MarshalTo(dAtA []byte) (int, error) { +func (m *SplitID) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *GetOperatorRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *SplitID) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -14533,27 +13442,33 @@ func (m *GetOperatorRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if m.RegionId != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.RegionId)) - i-- - dAtA[i] = 0x10 - } - if m.Header != nil { - { - size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err + if len(m.NewPeerIds) > 0 { + dAtA85 := make([]byte, len(m.NewPeerIds)*10) + var j84 int + for _, num := range m.NewPeerIds { + for num >= 1<<7 { + dAtA85[j84] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j84++ } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) + dAtA85[j84] = uint8(num) + j84++ } + i -= j84 + copy(dAtA[i:], dAtA85[:j84]) + i = encodeVarintPdpb(dAtA, i, uint64(j84)) i-- - dAtA[i] = 0xa + dAtA[i] = 0x12 + } + if m.NewRegionId != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.NewRegionId)) + i-- + dAtA[i] = 0x8 } return len(dAtA) - i, nil } -func (m *GetOperatorResponse) Marshal() (dAtA []byte, err error) { +func (m *AskBatchSplitResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -14563,12 +13478,12 @@ func (m *GetOperatorResponse) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *GetOperatorResponse) MarshalTo(dAtA []byte) (int, error) { +func (m *AskBatchSplitResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *GetOperatorResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *AskBatchSplitResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -14577,29 +13492,19 @@ func (m *GetOperatorResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if len(m.Kind) > 0 { - i -= len(m.Kind) - copy(dAtA[i:], m.Kind) - i = encodeVarintPdpb(dAtA, i, uint64(len(m.Kind))) - i-- - dAtA[i] = 0x2a - } - if m.Status != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.Status)) - i-- - dAtA[i] = 0x20 - } - if len(m.Desc) > 0 { - i -= len(m.Desc) - copy(dAtA[i:], m.Desc) - i = encodeVarintPdpb(dAtA, i, uint64(len(m.Desc))) - i-- - dAtA[i] = 0x1a - } - if m.RegionId != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.RegionId)) - i-- - dAtA[i] = 0x10 + if len(m.Ids) > 0 { + for iNdEx := len(m.Ids) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Ids[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } } if m.Header != nil { { @@ -14616,7 +13521,7 @@ func (m *GetOperatorResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *SyncMaxTSRequest) Marshal() (dAtA []byte, err error) { +func (m *ReportBatchSplitRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -14626,12 +13531,12 @@ func (m *SyncMaxTSRequest) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *SyncMaxTSRequest) MarshalTo(dAtA []byte) (int, error) { +func (m *ReportBatchSplitRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *SyncMaxTSRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ReportBatchSplitRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -14640,27 +13545,19 @@ func (m *SyncMaxTSRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if m.SkipCheck { - i-- - if m.SkipCheck { - dAtA[i] = 1 - } else { - dAtA[i] = 0 - } - i-- - dAtA[i] = 0x18 - } - if m.MaxTs != nil { - { - size, err := m.MaxTs.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err + if len(m.Regions) > 0 { + for iNdEx := len(m.Regions) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Regions[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 } - i-- - dAtA[i] = 0x12 } if m.Header != nil { { @@ -14677,7 +13574,7 @@ func (m *SyncMaxTSRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *SyncMaxTSResponse) Marshal() (dAtA []byte, err error) { +func (m *ReportBatchSplitResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -14687,12 +13584,12 @@ func (m *SyncMaxTSResponse) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *SyncMaxTSResponse) MarshalTo(dAtA []byte) (int, error) { +func (m *ReportBatchSplitResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *SyncMaxTSResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ReportBatchSplitResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -14701,27 +13598,6 @@ func (m *SyncMaxTSResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if len(m.SyncedDcs) > 0 { - for iNdEx := len(m.SyncedDcs) - 1; iNdEx >= 0; iNdEx-- { - i -= len(m.SyncedDcs[iNdEx]) - copy(dAtA[i:], m.SyncedDcs[iNdEx]) - i = encodeVarintPdpb(dAtA, i, uint64(len(m.SyncedDcs[iNdEx]))) - i-- - dAtA[i] = 0x1a - } - } - if m.MaxLocalTs != nil { - { - size, err := m.MaxLocalTs.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } if m.Header != nil { { size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) @@ -14737,7 +13613,7 @@ func (m *SyncMaxTSResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *SplitRegionsRequest) Marshal() (dAtA []byte, err error) { +func (m *TimeInterval) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -14747,12 +13623,12 @@ func (m *SplitRegionsRequest) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *SplitRegionsRequest) MarshalTo(dAtA []byte) (int, error) { +func (m *TimeInterval) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *SplitRegionsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *TimeInterval) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -14761,36 +13637,20 @@ func (m *SplitRegionsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if m.RetryLimit != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.RetryLimit)) + if m.EndTimestamp != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.EndTimestamp)) i-- - dAtA[i] = 0x18 + dAtA[i] = 0x10 } - if len(m.SplitKeys) > 0 { - for iNdEx := len(m.SplitKeys) - 1; iNdEx >= 0; iNdEx-- { - i -= len(m.SplitKeys[iNdEx]) - copy(dAtA[i:], m.SplitKeys[iNdEx]) - i = encodeVarintPdpb(dAtA, i, uint64(len(m.SplitKeys[iNdEx]))) - i-- - dAtA[i] = 0x12 - } - } - if m.Header != nil { - { - size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } + if m.StartTimestamp != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.StartTimestamp)) i-- - dAtA[i] = 0xa + dAtA[i] = 0x8 } return len(dAtA) - i, nil } -func (m *SplitRegionsResponse) Marshal() (dAtA []byte, err error) { +func (m *RecordPair) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -14800,12 +13660,12 @@ func (m *SplitRegionsResponse) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *SplitRegionsResponse) MarshalTo(dAtA []byte) (int, error) { +func (m *RecordPair) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *SplitRegionsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *RecordPair) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -14814,45 +13674,22 @@ func (m *SplitRegionsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if len(m.RegionsId) > 0 { - dAtA137 := make([]byte, len(m.RegionsId)*10) - var j136 int - for _, num := range m.RegionsId { - for num >= 1<<7 { - dAtA137[j136] = uint8(uint64(num)&0x7f | 0x80) - num >>= 7 - j136++ - } - dAtA137[j136] = uint8(num) - j136++ - } - i -= j136 - copy(dAtA[i:], dAtA137[:j136]) - i = encodeVarintPdpb(dAtA, i, uint64(j136)) - i-- - dAtA[i] = 0x1a - } - if m.FinishedPercentage != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.FinishedPercentage)) + if m.Value != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.Value)) i-- dAtA[i] = 0x10 } - if m.Header != nil { - { - size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } + if len(m.Key) > 0 { + i -= len(m.Key) + copy(dAtA[i:], m.Key) + i = encodeVarintPdpb(dAtA, i, uint64(len(m.Key))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *SplitAndScatterRegionsRequest) Marshal() (dAtA []byte, err error) { +func (m *PeerStat) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -14862,12 +13699,12 @@ func (m *SplitAndScatterRegionsRequest) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *SplitAndScatterRegionsRequest) MarshalTo(dAtA []byte) (int, error) { +func (m *PeerStat) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *SplitAndScatterRegionsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *PeerStat) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -14876,30 +13713,19 @@ func (m *SplitAndScatterRegionsRequest) MarshalToSizedBuffer(dAtA []byte) (int, i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if m.RetryLimit != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.RetryLimit)) + if m.WrittenBytes != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.WrittenBytes)) i-- - dAtA[i] = 0x20 + dAtA[i] = 0x30 } - if len(m.Group) > 0 { - i -= len(m.Group) - copy(dAtA[i:], m.Group) - i = encodeVarintPdpb(dAtA, i, uint64(len(m.Group))) + if m.WrittenKeys != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.WrittenKeys)) i-- - dAtA[i] = 0x1a - } - if len(m.SplitKeys) > 0 { - for iNdEx := len(m.SplitKeys) - 1; iNdEx >= 0; iNdEx-- { - i -= len(m.SplitKeys[iNdEx]) - copy(dAtA[i:], m.SplitKeys[iNdEx]) - i = encodeVarintPdpb(dAtA, i, uint64(len(m.SplitKeys[iNdEx]))) - i-- - dAtA[i] = 0x12 - } + dAtA[i] = 0x28 } - if m.Header != nil { + if m.QueryStats != nil { { - size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.QueryStats.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -14907,79 +13733,27 @@ func (m *SplitAndScatterRegionsRequest) MarshalToSizedBuffer(dAtA []byte) (int, i = encodeVarintPdpb(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *SplitAndScatterRegionsResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil -} - -func (m *SplitAndScatterRegionsResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *SplitAndScatterRegionsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.XXX_unrecognized != nil { - i -= len(m.XXX_unrecognized) - copy(dAtA[i:], m.XXX_unrecognized) - } - if len(m.RegionsId) > 0 { - dAtA141 := make([]byte, len(m.RegionsId)*10) - var j140 int - for _, num := range m.RegionsId { - for num >= 1<<7 { - dAtA141[j140] = uint8(uint64(num)&0x7f | 0x80) - num >>= 7 - j140++ - } - dAtA141[j140] = uint8(num) - j140++ - } - i -= j140 - copy(dAtA[i:], dAtA141[:j140]) - i = encodeVarintPdpb(dAtA, i, uint64(j140)) - i-- dAtA[i] = 0x22 } - if m.ScatterFinishedPercentage != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.ScatterFinishedPercentage)) + if m.ReadBytes != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.ReadBytes)) i-- dAtA[i] = 0x18 } - if m.SplitFinishedPercentage != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.SplitFinishedPercentage)) + if m.ReadKeys != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.ReadKeys)) i-- dAtA[i] = 0x10 } - if m.Header != nil { - { - size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } + if m.RegionId != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.RegionId)) i-- - dAtA[i] = 0xa + dAtA[i] = 0x8 } return len(dAtA) - i, nil } -func (m *GetDCLocationInfoRequest) Marshal() (dAtA []byte, err error) { +func (m *StoreStats) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -14989,12 +13763,12 @@ func (m *GetDCLocationInfoRequest) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *GetDCLocationInfoRequest) MarshalTo(dAtA []byte) (int, error) { +func (m *StoreStats) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *GetDCLocationInfoRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *StoreStats) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -15003,16 +13777,9 @@ func (m *GetDCLocationInfoRequest) MarshalToSizedBuffer(dAtA []byte) (int, error i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if len(m.DcLocation) > 0 { - i -= len(m.DcLocation) - copy(dAtA[i:], m.DcLocation) - i = encodeVarintPdpb(dAtA, i, uint64(len(m.DcLocation))) - i-- - dAtA[i] = 0x12 - } - if m.Header != nil { + if m.SlowTrend != nil { { - size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.SlowTrend.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -15020,55 +13787,68 @@ func (m *GetDCLocationInfoRequest) MarshalToSizedBuffer(dAtA []byte) (int, error i = encodeVarintPdpb(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0xa + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xd2 } - return len(dAtA) - i, nil -} - -func (m *GetDCLocationInfoResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err + if len(m.SnapshotStats) > 0 { + for iNdEx := len(m.SnapshotStats) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.SnapshotStats[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xca + } } - return dAtA[:n], nil -} - -func (m *GetDCLocationInfoResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *GetDCLocationInfoResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.XXX_unrecognized != nil { - i -= len(m.XXX_unrecognized) - copy(dAtA[i:], m.XXX_unrecognized) + if m.IsApplyBusy { + i-- + if m.IsApplyBusy { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xc0 } - if m.MaxTs != nil { - { - size, err := m.MaxTs.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err + if len(m.DamagedRegionsId) > 0 { + dAtA92 := make([]byte, len(m.DamagedRegionsId)*10) + var j91 int + for _, num := range m.DamagedRegionsId { + for num >= 1<<7 { + dAtA92[j91] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j91++ } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) + dAtA92[j91] = uint8(num) + j91++ } + i -= j91 + copy(dAtA[i:], dAtA92[:j91]) + i = encodeVarintPdpb(dAtA, i, uint64(j91)) i-- - dAtA[i] = 0x1a + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xba } - if m.Suffix != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.Suffix)) + if m.SlowScore != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.SlowScore)) i-- - dAtA[i] = 0x10 + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xb0 } - if m.Header != nil { + if m.QueryStats != nil { { - size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.QueryStats.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -15076,94 +13856,181 @@ func (m *GetDCLocationInfoResponse) MarshalToSizedBuffer(dAtA []byte) (int, erro i = encodeVarintPdpb(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0xa + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xaa } - return len(dAtA) - i, nil -} - -func (m *QueryStats) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err + if len(m.PeerStats) > 0 { + for iNdEx := len(m.PeerStats) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.PeerStats[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xa2 + } } - return dAtA[:n], nil -} - -func (m *QueryStats) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *QueryStats) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.XXX_unrecognized != nil { - i -= len(m.XXX_unrecognized) - copy(dAtA[i:], m.XXX_unrecognized) + if len(m.OpLatencies) > 0 { + for iNdEx := len(m.OpLatencies) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.OpLatencies[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x9a + } } - if m.Rollback != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.Rollback)) + if len(m.WriteIoRates) > 0 { + for iNdEx := len(m.WriteIoRates) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.WriteIoRates[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x92 + } + } + if len(m.ReadIoRates) > 0 { + for iNdEx := len(m.ReadIoRates) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.ReadIoRates[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x8a + } + } + if len(m.CpuUsages) > 0 { + for iNdEx := len(m.CpuUsages) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.CpuUsages[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x82 + } + } + if m.Interval != nil { + { + size, err := m.Interval.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x7a + } + if m.KeysRead != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.KeysRead)) + i-- + dAtA[i] = 0x70 + } + if m.BytesRead != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.BytesRead)) + i-- + dAtA[i] = 0x68 + } + if m.KeysWritten != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.KeysWritten)) + i-- + dAtA[i] = 0x60 + } + if m.BytesWritten != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.BytesWritten)) i-- dAtA[i] = 0x58 } - if m.Commit != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.Commit)) + if m.UsedSize != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.UsedSize)) i-- dAtA[i] = 0x50 } - if m.AcquirePessimisticLock != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.AcquirePessimisticLock)) + if m.IsBusy { + i-- + if m.IsBusy { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } i-- dAtA[i] = 0x48 } - if m.Prewrite != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.Prewrite)) + if m.ApplyingSnapCount != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.ApplyingSnapCount)) i-- dAtA[i] = 0x40 } - if m.Put != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.Put)) + if m.StartTime != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.StartTime)) i-- dAtA[i] = 0x38 } - if m.DeleteRange != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.DeleteRange)) + if m.ReceivingSnapCount != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.ReceivingSnapCount)) i-- dAtA[i] = 0x30 } - if m.Delete != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.Delete)) + if m.SendingSnapCount != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.SendingSnapCount)) i-- dAtA[i] = 0x28 } - if m.Coprocessor != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.Coprocessor)) + if m.RegionCount != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.RegionCount)) i-- dAtA[i] = 0x20 } - if m.Scan != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.Scan)) + if m.Available != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.Available)) i-- dAtA[i] = 0x18 } - if m.Get != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.Get)) + if m.Capacity != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.Capacity)) i-- dAtA[i] = 0x10 } - if m.GC != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.GC)) + if m.StoreId != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.StoreId)) i-- dAtA[i] = 0x8 } return len(dAtA) - i, nil } -func (m *ReportBucketsRequest) Marshal() (dAtA []byte, err error) { +func (m *SlowTrend) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -15173,12 +14040,12 @@ func (m *ReportBucketsRequest) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *ReportBucketsRequest) MarshalTo(dAtA []byte) (int, error) { +func (m *SlowTrend) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ReportBucketsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *SlowTrend) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -15187,46 +14054,34 @@ func (m *ReportBucketsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if m.Buckets != nil { - { - size, err := m.Buckets.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } + if m.ResultRate != 0 { + i -= 8 + encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.ResultRate)))) i-- - dAtA[i] = 0x1a + dAtA[i] = 0x21 } - if m.RegionEpoch != nil { - { - size, err := m.RegionEpoch.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } + if m.ResultValue != 0 { + i -= 8 + encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.ResultValue)))) i-- - dAtA[i] = 0x12 + dAtA[i] = 0x19 } - if m.Header != nil { - { - size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } + if m.CauseRate != 0 { + i -= 8 + encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.CauseRate)))) i-- - dAtA[i] = 0xa + dAtA[i] = 0x11 + } + if m.CauseValue != 0 { + i -= 8 + encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.CauseValue)))) + i-- + dAtA[i] = 0x9 } return len(dAtA) - i, nil } -func (m *ReportBucketsResponse) Marshal() (dAtA []byte, err error) { +func (m *SnapshotStat) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -15236,12 +14091,12 @@ func (m *ReportBucketsResponse) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *ReportBucketsResponse) MarshalTo(dAtA []byte) (int, error) { +func (m *SnapshotStat) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ReportBucketsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *SnapshotStat) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -15250,37 +14105,50 @@ func (m *ReportBucketsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if m.Header != nil { - { - size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) - } + if m.TransportSize != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.TransportSize)) i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *ReportMinResolvedTsRequest) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err + dAtA[i] = 0x28 } - return dAtA[:n], nil + if m.TotalDurationSec != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.TotalDurationSec)) + i-- + dAtA[i] = 0x20 + } + if m.SendDurationSec != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.SendDurationSec)) + i-- + dAtA[i] = 0x18 + } + if m.GenerateDurationSec != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.GenerateDurationSec)) + i-- + dAtA[i] = 0x10 + } + if m.RegionId != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.RegionId)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil } -func (m *ReportMinResolvedTsRequest) MarshalTo(dAtA []byte) (int, error) { +func (m *PeerReport) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *PeerReport) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ReportMinResolvedTsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *PeerReport) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -15289,19 +14157,41 @@ func (m *ReportMinResolvedTsRequest) MarshalToSizedBuffer(dAtA []byte) (int, err i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if m.MinResolvedTs != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.MinResolvedTs)) + if m.HasCommitMerge { + i-- + if m.HasCommitMerge { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x20 + } + if m.IsForceLeader { + i-- + if m.IsForceLeader { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } i-- dAtA[i] = 0x18 } - if m.StoreId != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.StoreId)) + if m.RegionState != nil { + { + size, err := m.RegionState.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } i-- - dAtA[i] = 0x10 + dAtA[i] = 0x12 } - if m.Header != nil { + if m.RaftState != nil { { - size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.RaftState.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -15314,7 +14204,7 @@ func (m *ReportMinResolvedTsRequest) MarshalToSizedBuffer(dAtA []byte) (int, err return len(dAtA) - i, nil } -func (m *ReportMinResolvedTsResponse) Marshal() (dAtA []byte, err error) { +func (m *StoreReport) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -15324,12 +14214,12 @@ func (m *ReportMinResolvedTsResponse) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *ReportMinResolvedTsResponse) MarshalTo(dAtA []byte) (int, error) { +func (m *StoreReport) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ReportMinResolvedTsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *StoreReport) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -15338,22 +14228,29 @@ func (m *ReportMinResolvedTsResponse) MarshalToSizedBuffer(dAtA []byte) (int, er i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if m.Header != nil { - { - size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err + if m.Step != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.Step)) + i-- + dAtA[i] = 0x10 + } + if len(m.PeerReports) > 0 { + for iNdEx := len(m.PeerReports) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.PeerReports[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0xa } - i-- - dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *SetExternalTimestampRequest) Marshal() (dAtA []byte, err error) { +func (m *StoreHeartbeatRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -15363,12 +14260,12 @@ func (m *SetExternalTimestampRequest) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *SetExternalTimestampRequest) MarshalTo(dAtA []byte) (int, error) { +func (m *StoreHeartbeatRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *SetExternalTimestampRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *StoreHeartbeatRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -15377,10 +14274,41 @@ func (m *SetExternalTimestampRequest) MarshalToSizedBuffer(dAtA []byte) (int, er i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if m.Timestamp != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.Timestamp)) + if m.DrAutosyncStatus != nil { + { + size, err := m.DrAutosyncStatus.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } i-- - dAtA[i] = 0x10 + dAtA[i] = 0x22 + } + if m.StoreReport != nil { + { + size, err := m.StoreReport.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.Stats != nil { + { + size, err := m.Stats.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 } if m.Header != nil { { @@ -15397,7 +14325,7 @@ func (m *SetExternalTimestampRequest) MarshalToSizedBuffer(dAtA []byte) (int, er return len(dAtA) - i, nil } -func (m *SetExternalTimestampResponse) Marshal() (dAtA []byte, err error) { +func (m *DemoteFailedVoters) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -15407,12 +14335,12 @@ func (m *SetExternalTimestampResponse) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *SetExternalTimestampResponse) MarshalTo(dAtA []byte) (int, error) { +func (m *DemoteFailedVoters) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *SetExternalTimestampResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *DemoteFailedVoters) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -15421,22 +14349,29 @@ func (m *SetExternalTimestampResponse) MarshalToSizedBuffer(dAtA []byte) (int, e i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if m.Header != nil { - { - size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err + if len(m.FailedVoters) > 0 { + for iNdEx := len(m.FailedVoters) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.FailedVoters[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 } + } + if m.RegionId != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.RegionId)) i-- - dAtA[i] = 0xa + dAtA[i] = 0x8 } return len(dAtA) - i, nil } -func (m *GetExternalTimestampRequest) Marshal() (dAtA []byte, err error) { +func (m *ForceLeader) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -15446,12 +14381,12 @@ func (m *GetExternalTimestampRequest) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *GetExternalTimestampRequest) MarshalTo(dAtA []byte) (int, error) { +func (m *ForceLeader) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *GetExternalTimestampRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ForceLeader) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -15460,22 +14395,46 @@ func (m *GetExternalTimestampRequest) MarshalToSizedBuffer(dAtA []byte) (int, er i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if m.Header != nil { - { - size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err + if len(m.EnterForceLeaders) > 0 { + dAtA102 := make([]byte, len(m.EnterForceLeaders)*10) + var j101 int + for _, num := range m.EnterForceLeaders { + for num >= 1<<7 { + dAtA102[j101] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j101++ } - i -= size - i = encodeVarintPdpb(dAtA, i, uint64(size)) + dAtA102[j101] = uint8(num) + j101++ + } + i -= j101 + copy(dAtA[i:], dAtA102[:j101]) + i = encodeVarintPdpb(dAtA, i, uint64(j101)) + i-- + dAtA[i] = 0x12 + } + if len(m.FailedStores) > 0 { + dAtA104 := make([]byte, len(m.FailedStores)*10) + var j103 int + for _, num := range m.FailedStores { + for num >= 1<<7 { + dAtA104[j103] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j103++ + } + dAtA104[j103] = uint8(num) + j103++ } + i -= j103 + copy(dAtA[i:], dAtA104[:j103]) + i = encodeVarintPdpb(dAtA, i, uint64(j103)) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *GetExternalTimestampResponse) Marshal() (dAtA []byte, err error) { +func (m *RecoveryPlan) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -15485,12 +14444,12 @@ func (m *GetExternalTimestampResponse) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *GetExternalTimestampResponse) MarshalTo(dAtA []byte) (int, error) { +func (m *RecoveryPlan) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *GetExternalTimestampResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *RecoveryPlan) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -15499,14 +14458,14 @@ func (m *GetExternalTimestampResponse) MarshalToSizedBuffer(dAtA []byte) (int, e i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if m.Timestamp != 0 { - i = encodeVarintPdpb(dAtA, i, uint64(m.Timestamp)) + if m.Step != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.Step)) i-- - dAtA[i] = 0x10 + dAtA[i] = 0x30 } - if m.Header != nil { + if m.ForceLeader != nil { { - size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.ForceLeader.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -15514,1789 +14473,2515 @@ func (m *GetExternalTimestampResponse) MarshalToSizedBuffer(dAtA []byte) (int, e i = encodeVarintPdpb(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func encodeVarintPdpb(dAtA []byte, offset int, v uint64) int { - offset -= sovPdpb(v) - base := offset - for v >= 1<<7 { - dAtA[offset] = uint8(v&0x7f | 0x80) - v >>= 7 - offset++ - } - dAtA[offset] = uint8(v) - return base -} -func (m *WatchGlobalConfigRequest) Size() (n int) { - if m == nil { - return 0 + dAtA[i] = 0x2a } - var l int - _ = l - l = len(m.ConfigPath) - if l > 0 { - n += 1 + l + sovPdpb(uint64(l)) - } - if m.Revision != 0 { - n += 1 + sovPdpb(uint64(m.Revision)) - } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) - } - return n -} - -func (m *WatchGlobalConfigResponse) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if len(m.Changes) > 0 { - for _, e := range m.Changes { - l = e.Size() - n += 1 + l + sovPdpb(uint64(l)) + if len(m.Demotes) > 0 { + for iNdEx := len(m.Demotes) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Demotes[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 } } - if m.Revision != 0 { - n += 1 + sovPdpb(uint64(m.Revision)) + if len(m.Tombstones) > 0 { + dAtA107 := make([]byte, len(m.Tombstones)*10) + var j106 int + for _, num := range m.Tombstones { + for num >= 1<<7 { + dAtA107[j106] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j106++ + } + dAtA107[j106] = uint8(num) + j106++ + } + i -= j106 + copy(dAtA[i:], dAtA107[:j106]) + i = encodeVarintPdpb(dAtA, i, uint64(j106)) + i-- + dAtA[i] = 0x1a } - if m.Header != nil { - l = m.Header.Size() - n += 1 + l + sovPdpb(uint64(l)) + if len(m.Updates) > 0 { + for iNdEx := len(m.Updates) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Updates[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + if len(m.Creates) > 0 { + for iNdEx := len(m.Creates) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Creates[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } } - return n + return len(dAtA) - i, nil } -func (m *StoreGlobalConfigRequest) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if len(m.Changes) > 0 { - for _, e := range m.Changes { - l = e.Size() - n += 1 + l + sovPdpb(uint64(l)) - } - } - l = len(m.ConfigPath) - if l > 0 { - n += 1 + l + sovPdpb(uint64(l)) - } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) +func (m *AwakenRegions) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - return n + return dAtA[:n], nil } -func (m *StoreGlobalConfigResponse) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Error != nil { - l = m.Error.Size() - n += 1 + l + sovPdpb(uint64(l)) - } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) - } - return n +func (m *AwakenRegions) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *LoadGlobalConfigRequest) Size() (n int) { - if m == nil { - return 0 - } +func (m *AwakenRegions) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if len(m.Names) > 0 { - for _, s := range m.Names { - l = len(s) - n += 1 + l + sovPdpb(uint64(l)) - } - } - l = len(m.ConfigPath) - if l > 0 { - n += 1 + l + sovPdpb(uint64(l)) - } if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) - } - return n -} - -func (m *LoadGlobalConfigResponse) Size() (n int) { - if m == nil { - return 0 + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - var l int - _ = l - if len(m.Items) > 0 { - for _, e := range m.Items { - l = e.Size() - n += 1 + l + sovPdpb(uint64(l)) + if len(m.AbnormalStores) > 0 { + dAtA109 := make([]byte, len(m.AbnormalStores)*10) + var j108 int + for _, num := range m.AbnormalStores { + for num >= 1<<7 { + dAtA109[j108] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j108++ + } + dAtA109[j108] = uint8(num) + j108++ } + i -= j108 + copy(dAtA[i:], dAtA109[:j108]) + i = encodeVarintPdpb(dAtA, i, uint64(j108)) + i-- + dAtA[i] = 0xa } - if m.Revision != 0 { - n += 1 + sovPdpb(uint64(m.Revision)) - } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) - } - return n + return len(dAtA) - i, nil } -func (m *GlobalConfigItem) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Name) - if l > 0 { - n += 1 + l + sovPdpb(uint64(l)) - } - l = len(m.Value) - if l > 0 { - n += 1 + l + sovPdpb(uint64(l)) - } - if m.Error != nil { - l = m.Error.Size() - n += 1 + l + sovPdpb(uint64(l)) - } - if m.Kind != 0 { - n += 1 + sovPdpb(uint64(m.Kind)) - } - l = len(m.Payload) - if l > 0 { - n += 1 + l + sovPdpb(uint64(l)) - } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) +func (m *StoreHeartbeatResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - return n + return dAtA[:n], nil } -func (m *RequestHeader) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.ClusterId != 0 { - n += 1 + sovPdpb(uint64(m.ClusterId)) - } - if m.SenderId != 0 { - n += 1 + sovPdpb(uint64(m.SenderId)) - } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) - } - return n +func (m *StoreHeartbeatResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ResponseHeader) Size() (n int) { - if m == nil { - return 0 - } +func (m *StoreHeartbeatResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.ClusterId != 0 { - n += 1 + sovPdpb(uint64(m.ClusterId)) - } - if m.Error != nil { - l = m.Error.Size() - n += 1 + l + sovPdpb(uint64(l)) - } if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - return n -} - -func (m *Error) Size() (n int) { - if m == nil { - return 0 + if m.AwakenRegions != nil { + { + size, err := m.AwakenRegions.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x32 } - var l int - _ = l - if m.Type != 0 { - n += 1 + sovPdpb(uint64(m.Type)) + if m.RecoveryPlan != nil { + { + size, err := m.RecoveryPlan.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a } - l = len(m.Message) - if l > 0 { - n += 1 + l + sovPdpb(uint64(l)) + if m.RequireDetailedReport { + i-- + if m.RequireDetailedReport { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x20 } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + if len(m.ClusterVersion) > 0 { + i -= len(m.ClusterVersion) + copy(dAtA[i:], m.ClusterVersion) + i = encodeVarintPdpb(dAtA, i, uint64(len(m.ClusterVersion))) + i-- + dAtA[i] = 0x1a } - return n + if m.ReplicationStatus != nil { + { + size, err := m.ReplicationStatus.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.Header != nil { + { + size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil } -func (m *TsoRequest) Size() (n int) { - if m == nil { - return 0 +func (m *ScatterRegionRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *ScatterRegionRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ScatterRegionRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.Header != nil { - l = m.Header.Size() - n += 1 + l + sovPdpb(uint64(l)) - } - if m.Count != 0 { - n += 1 + sovPdpb(uint64(m.Count)) + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - l = len(m.DcLocation) - if l > 0 { - n += 1 + l + sovPdpb(uint64(l)) + if m.RetryLimit != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.RetryLimit)) + i-- + dAtA[i] = 0x38 } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + if len(m.RegionsId) > 0 { + dAtA115 := make([]byte, len(m.RegionsId)*10) + var j114 int + for _, num := range m.RegionsId { + for num >= 1<<7 { + dAtA115[j114] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j114++ + } + dAtA115[j114] = uint8(num) + j114++ + } + i -= j114 + copy(dAtA[i:], dAtA115[:j114]) + i = encodeVarintPdpb(dAtA, i, uint64(j114)) + i-- + dAtA[i] = 0x32 } - return n -} - -func (m *Timestamp) Size() (n int) { - if m == nil { - return 0 + if len(m.Group) > 0 { + i -= len(m.Group) + copy(dAtA[i:], m.Group) + i = encodeVarintPdpb(dAtA, i, uint64(len(m.Group))) + i-- + dAtA[i] = 0x2a } - var l int - _ = l - if m.Physical != 0 { - n += 1 + sovPdpb(uint64(m.Physical)) + if m.Leader != nil { + { + size, err := m.Leader.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 } - if m.Logical != 0 { - n += 1 + sovPdpb(uint64(m.Logical)) + if m.Region != nil { + { + size, err := m.Region.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a } - if m.SuffixBits != 0 { - n += 1 + sovPdpb(uint64(m.SuffixBits)) + if m.RegionId != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.RegionId)) + i-- + dAtA[i] = 0x10 } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + if m.Header != nil { + { + size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa } - return n + return len(dAtA) - i, nil } -func (m *TsoResponse) Size() (n int) { - if m == nil { - return 0 +func (m *ScatterRegionResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *ScatterRegionResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ScatterRegionResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.Header != nil { - l = m.Header.Size() - n += 1 + l + sovPdpb(uint64(l)) - } - if m.Count != 0 { - n += 1 + sovPdpb(uint64(m.Count)) + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - if m.Timestamp != nil { - l = m.Timestamp.Size() - n += 1 + l + sovPdpb(uint64(l)) + if m.FinishedPercentage != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.FinishedPercentage)) + i-- + dAtA[i] = 0x10 } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + if m.Header != nil { + { + size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa } - return n + return len(dAtA) - i, nil } -func (m *BootstrapRequest) Size() (n int) { - if m == nil { - return 0 +func (m *GetGCSafePointRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *GetGCSafePointRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GetGCSafePointRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.Header != nil { - l = m.Header.Size() - n += 1 + l + sovPdpb(uint64(l)) - } - if m.Store != nil { - l = m.Store.Size() - n += 1 + l + sovPdpb(uint64(l)) - } - if m.Region != nil { - l = m.Region.Size() - n += 1 + l + sovPdpb(uint64(l)) - } if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - return n + if m.Header != nil { + { + size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil } -func (m *BootstrapResponse) Size() (n int) { - if m == nil { - return 0 +func (m *GetGCSafePointResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *GetGCSafePointResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GetGCSafePointResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.Header != nil { - l = m.Header.Size() - n += 1 + l + sovPdpb(uint64(l)) - } - if m.ReplicationStatus != nil { - l = m.ReplicationStatus.Size() - n += 1 + l + sovPdpb(uint64(l)) - } if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - return n -} - -func (m *IsBootstrappedRequest) Size() (n int) { - if m == nil { - return 0 + if m.SafePoint != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.SafePoint)) + i-- + dAtA[i] = 0x10 } - var l int - _ = l if m.Header != nil { - l = m.Header.Size() - n += 1 + l + sovPdpb(uint64(l)) - } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + { + size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa } - return n + return len(dAtA) - i, nil } -func (m *IsBootstrappedResponse) Size() (n int) { - if m == nil { - return 0 +func (m *UpdateGCSafePointRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *UpdateGCSafePointRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *UpdateGCSafePointRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.Header != nil { - l = m.Header.Size() - n += 1 + l + sovPdpb(uint64(l)) - } - if m.Bootstrapped { - n += 2 - } if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - return n -} - -func (m *AllocIDRequest) Size() (n int) { - if m == nil { - return 0 + if m.SafePoint != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.SafePoint)) + i-- + dAtA[i] = 0x10 } - var l int - _ = l if m.Header != nil { - l = m.Header.Size() - n += 1 + l + sovPdpb(uint64(l)) - } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + { + size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa } - return n + return len(dAtA) - i, nil } -func (m *AllocIDResponse) Size() (n int) { - if m == nil { - return 0 +func (m *UpdateGCSafePointResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *UpdateGCSafePointResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *UpdateGCSafePointResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.Header != nil { - l = m.Header.Size() - n += 1 + l + sovPdpb(uint64(l)) - } - if m.Id != 0 { - n += 1 + sovPdpb(uint64(m.Id)) - } if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - return n -} - -func (m *IsSnapshotRecoveringRequest) Size() (n int) { - if m == nil { - return 0 + if m.NewSafePoint != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.NewSafePoint)) + i-- + dAtA[i] = 0x10 } - var l int - _ = l if m.Header != nil { - l = m.Header.Size() - n += 1 + l + sovPdpb(uint64(l)) - } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + { + size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa } - return n + return len(dAtA) - i, nil } -func (m *IsSnapshotRecoveringResponse) Size() (n int) { - if m == nil { - return 0 +func (m *UpdateServiceGCSafePointRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *UpdateServiceGCSafePointRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *UpdateServiceGCSafePointRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.Header != nil { - l = m.Header.Size() - n += 1 + l + sovPdpb(uint64(l)) + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - if m.Marked { - n += 2 + if m.SafePoint != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.SafePoint)) + i-- + dAtA[i] = 0x20 } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + if m.TTL != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.TTL)) + i-- + dAtA[i] = 0x18 } - return n -} - -func (m *GetStoreRequest) Size() (n int) { - if m == nil { - return 0 + if len(m.ServiceId) > 0 { + i -= len(m.ServiceId) + copy(dAtA[i:], m.ServiceId) + i = encodeVarintPdpb(dAtA, i, uint64(len(m.ServiceId))) + i-- + dAtA[i] = 0x12 } - var l int - _ = l if m.Header != nil { - l = m.Header.Size() - n += 1 + l + sovPdpb(uint64(l)) - } - if m.StoreId != 0 { - n += 1 + sovPdpb(uint64(m.StoreId)) - } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + { + size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa } - return n + return len(dAtA) - i, nil } -func (m *GetStoreResponse) Size() (n int) { - if m == nil { - return 0 +func (m *UpdateServiceGCSafePointResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *UpdateServiceGCSafePointResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *UpdateServiceGCSafePointResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.Header != nil { - l = m.Header.Size() - n += 1 + l + sovPdpb(uint64(l)) + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - if m.Store != nil { - l = m.Store.Size() - n += 1 + l + sovPdpb(uint64(l)) + if m.MinSafePoint != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.MinSafePoint)) + i-- + dAtA[i] = 0x20 } - if m.Stats != nil { - l = m.Stats.Size() - n += 1 + l + sovPdpb(uint64(l)) + if m.TTL != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.TTL)) + i-- + dAtA[i] = 0x18 } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + if len(m.ServiceId) > 0 { + i -= len(m.ServiceId) + copy(dAtA[i:], m.ServiceId) + i = encodeVarintPdpb(dAtA, i, uint64(len(m.ServiceId))) + i-- + dAtA[i] = 0x12 } - return n + if m.Header != nil { + { + size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil } -func (m *PutStoreRequest) Size() (n int) { - if m == nil { - return 0 +func (m *GetGCSafePointV2Request) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *GetGCSafePointV2Request) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GetGCSafePointV2Request) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.Header != nil { - l = m.Header.Size() - n += 1 + l + sovPdpb(uint64(l)) + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - if m.Store != nil { - l = m.Store.Size() - n += 1 + l + sovPdpb(uint64(l)) + if m.KeyspaceId != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.KeyspaceId)) + i-- + dAtA[i] = 0x10 } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + if m.Header != nil { + { + size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa } - return n + return len(dAtA) - i, nil } -func (m *PutStoreResponse) Size() (n int) { - if m == nil { - return 0 +func (m *GetGCSafePointV2Response) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *GetGCSafePointV2Response) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GetGCSafePointV2Response) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.Header != nil { - l = m.Header.Size() - n += 1 + l + sovPdpb(uint64(l)) + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - if m.ReplicationStatus != nil { - l = m.ReplicationStatus.Size() - n += 1 + l + sovPdpb(uint64(l)) + if m.SafePoint != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.SafePoint)) + i-- + dAtA[i] = 0x10 } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + if m.Header != nil { + { + size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa } - return n + return len(dAtA) - i, nil } -func (m *GetAllStoresRequest) Size() (n int) { - if m == nil { - return 0 +func (m *WatchGCSafePointV2Request) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *WatchGCSafePointV2Request) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *WatchGCSafePointV2Request) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.Header != nil { - l = m.Header.Size() - n += 1 + l + sovPdpb(uint64(l)) - } - if m.ExcludeTombstoneStores { - n += 2 - } if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - return n -} - -func (m *GetAllStoresResponse) Size() (n int) { - if m == nil { - return 0 + if m.Revision != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.Revision)) + i-- + dAtA[i] = 0x10 } - var l int - _ = l if m.Header != nil { - l = m.Header.Size() - n += 1 + l + sovPdpb(uint64(l)) - } - if len(m.Stores) > 0 { - for _, e := range m.Stores { - l = e.Size() - n += 1 + l + sovPdpb(uint64(l)) + { + size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) } + i-- + dAtA[i] = 0xa } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) - } - return n + return len(dAtA) - i, nil } -func (m *GetRegionRequest) Size() (n int) { - if m == nil { - return 0 +func (m *SafePointEvent) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - var l int - _ = l - if m.Header != nil { - l = m.Header.Size() - n += 1 + l + sovPdpb(uint64(l)) + return dAtA[:n], nil +} + +func (m *SafePointEvent) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SafePointEvent) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - l = len(m.RegionKey) - if l > 0 { - n += 1 + l + sovPdpb(uint64(l)) + if m.Type != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.Type)) + i-- + dAtA[i] = 0x18 } - if m.NeedBuckets { - n += 2 + if m.SafePoint != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.SafePoint)) + i-- + dAtA[i] = 0x10 } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + if m.KeyspaceId != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.KeyspaceId)) + i-- + dAtA[i] = 0x8 } - return n + return len(dAtA) - i, nil } -func (m *GetRegionResponse) Size() (n int) { - if m == nil { - return 0 +func (m *WatchGCSafePointV2Response) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *WatchGCSafePointV2Response) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *WatchGCSafePointV2Response) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.Header != nil { - l = m.Header.Size() - n += 1 + l + sovPdpb(uint64(l)) - } - if m.Region != nil { - l = m.Region.Size() - n += 1 + l + sovPdpb(uint64(l)) + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - if m.Leader != nil { - l = m.Leader.Size() - n += 1 + l + sovPdpb(uint64(l)) + if m.Revision != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.Revision)) + i-- + dAtA[i] = 0x18 } - if len(m.DownPeers) > 0 { - for _, e := range m.DownPeers { - l = e.Size() - n += 1 + l + sovPdpb(uint64(l)) + if len(m.Events) > 0 { + for iNdEx := len(m.Events) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Events[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 } } - if len(m.PendingPeers) > 0 { - for _, e := range m.PendingPeers { - l = e.Size() - n += 1 + l + sovPdpb(uint64(l)) + if m.Header != nil { + { + size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) } + i-- + dAtA[i] = 0xa } - if m.Buckets != nil { - l = m.Buckets.Size() - n += 1 + l + sovPdpb(uint64(l)) - } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) - } - return n + return len(dAtA) - i, nil } -func (m *GetRegionByIDRequest) Size() (n int) { - if m == nil { - return 0 +func (m *UpdateGCSafePointV2Request) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *UpdateGCSafePointV2Request) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *UpdateGCSafePointV2Request) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.Header != nil { - l = m.Header.Size() - n += 1 + l + sovPdpb(uint64(l)) + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - if m.RegionId != 0 { - n += 1 + sovPdpb(uint64(m.RegionId)) + if m.SafePoint != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.SafePoint)) + i-- + dAtA[i] = 0x18 } - if m.NeedBuckets { - n += 2 + if m.KeyspaceId != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.KeyspaceId)) + i-- + dAtA[i] = 0x10 } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + if m.Header != nil { + { + size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa } - return n + return len(dAtA) - i, nil } -func (m *ScanRegionsRequest) Size() (n int) { - if m == nil { - return 0 +func (m *UpdateGCSafePointV2Response) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *UpdateGCSafePointV2Response) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *UpdateGCSafePointV2Response) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.Header != nil { - l = m.Header.Size() - n += 1 + l + sovPdpb(uint64(l)) - } - l = len(m.StartKey) - if l > 0 { - n += 1 + l + sovPdpb(uint64(l)) - } - if m.Limit != 0 { - n += 1 + sovPdpb(uint64(m.Limit)) + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - l = len(m.EndKey) - if l > 0 { - n += 1 + l + sovPdpb(uint64(l)) + if m.NewSafePoint != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.NewSafePoint)) + i-- + dAtA[i] = 0x10 } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + if m.Header != nil { + { + size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa } - return n + return len(dAtA) - i, nil } -func (m *Region) Size() (n int) { - if m == nil { - return 0 +func (m *UpdateServiceSafePointV2Request) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *UpdateServiceSafePointV2Request) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *UpdateServiceSafePointV2Request) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.Region != nil { - l = m.Region.Size() - n += 1 + l + sovPdpb(uint64(l)) + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - if m.Leader != nil { - l = m.Leader.Size() - n += 1 + l + sovPdpb(uint64(l)) + if m.Ttl != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.Ttl)) + i-- + dAtA[i] = 0x28 } - if len(m.DownPeers) > 0 { - for _, e := range m.DownPeers { - l = e.Size() - n += 1 + l + sovPdpb(uint64(l)) - } + if m.SafePoint != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.SafePoint)) + i-- + dAtA[i] = 0x20 } - if len(m.PendingPeers) > 0 { - for _, e := range m.PendingPeers { - l = e.Size() - n += 1 + l + sovPdpb(uint64(l)) - } + if len(m.ServiceId) > 0 { + i -= len(m.ServiceId) + copy(dAtA[i:], m.ServiceId) + i = encodeVarintPdpb(dAtA, i, uint64(len(m.ServiceId))) + i-- + dAtA[i] = 0x1a } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + if m.KeyspaceId != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.KeyspaceId)) + i-- + dAtA[i] = 0x10 } - return n + if m.Header != nil { + { + size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil } -func (m *ScanRegionsResponse) Size() (n int) { - if m == nil { - return 0 +func (m *UpdateServiceSafePointV2Response) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *UpdateServiceSafePointV2Response) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *UpdateServiceSafePointV2Response) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.Header != nil { - l = m.Header.Size() - n += 1 + l + sovPdpb(uint64(l)) + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - if len(m.RegionMetas) > 0 { - for _, e := range m.RegionMetas { - l = e.Size() - n += 1 + l + sovPdpb(uint64(l)) - } + if m.MinSafePoint != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.MinSafePoint)) + i-- + dAtA[i] = 0x20 } - if len(m.Leaders) > 0 { - for _, e := range m.Leaders { - l = e.Size() - n += 1 + l + sovPdpb(uint64(l)) - } + if m.Ttl != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.Ttl)) + i-- + dAtA[i] = 0x18 } - if len(m.Regions) > 0 { - for _, e := range m.Regions { - l = e.Size() - n += 1 + l + sovPdpb(uint64(l)) - } + if len(m.ServiceId) > 0 { + i -= len(m.ServiceId) + copy(dAtA[i:], m.ServiceId) + i = encodeVarintPdpb(dAtA, i, uint64(len(m.ServiceId))) + i-- + dAtA[i] = 0x12 } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + if m.Header != nil { + { + size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa } - return n + return len(dAtA) - i, nil } -func (m *GetClusterConfigRequest) Size() (n int) { - if m == nil { - return 0 +func (m *RegionStat) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *RegionStat) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *RegionStat) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.Header != nil { - l = m.Header.Size() - n += 1 + l + sovPdpb(uint64(l)) - } if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - return n -} - -func (m *GetClusterConfigResponse) Size() (n int) { - if m == nil { - return 0 + if m.KeysRead != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.KeysRead)) + i-- + dAtA[i] = 0x20 } - var l int - _ = l - if m.Header != nil { - l = m.Header.Size() - n += 1 + l + sovPdpb(uint64(l)) + if m.KeysWritten != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.KeysWritten)) + i-- + dAtA[i] = 0x18 } - if m.Cluster != nil { - l = m.Cluster.Size() - n += 1 + l + sovPdpb(uint64(l)) + if m.BytesRead != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.BytesRead)) + i-- + dAtA[i] = 0x10 } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + if m.BytesWritten != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.BytesWritten)) + i-- + dAtA[i] = 0x8 } - return n + return len(dAtA) - i, nil } -func (m *PutClusterConfigRequest) Size() (n int) { - if m == nil { - return 0 +func (m *SyncRegionRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *SyncRegionRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SyncRegionRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.Header != nil { - l = m.Header.Size() - n += 1 + l + sovPdpb(uint64(l)) + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - if m.Cluster != nil { - l = m.Cluster.Size() - n += 1 + l + sovPdpb(uint64(l)) + if m.StartIndex != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.StartIndex)) + i-- + dAtA[i] = 0x18 } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + if m.Member != nil { + { + size, err := m.Member.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 } - return n + if m.Header != nil { + { + size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil } -func (m *PutClusterConfigResponse) Size() (n int) { - if m == nil { - return 0 +func (m *PeersStats) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *PeersStats) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *PeersStats) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.Header != nil { - l = m.Header.Size() - n += 1 + l + sovPdpb(uint64(l)) - } if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - return n + if len(m.Peers) > 0 { + for iNdEx := len(m.Peers) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Peers[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil } -func (m *Member) Size() (n int) { - if m == nil { - return 0 +func (m *Peers) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - var l int - _ = l - l = len(m.Name) - if l > 0 { - n += 1 + l + sovPdpb(uint64(l)) - } - if m.MemberId != 0 { - n += 1 + sovPdpb(uint64(m.MemberId)) - } - if len(m.PeerUrls) > 0 { - for _, s := range m.PeerUrls { - l = len(s) - n += 1 + l + sovPdpb(uint64(l)) - } - } - if len(m.ClientUrls) > 0 { - for _, s := range m.ClientUrls { - l = len(s) - n += 1 + l + sovPdpb(uint64(l)) - } - } - if m.LeaderPriority != 0 { - n += 1 + sovPdpb(uint64(m.LeaderPriority)) - } - l = len(m.DeployPath) - if l > 0 { - n += 1 + l + sovPdpb(uint64(l)) - } - l = len(m.BinaryVersion) - if l > 0 { - n += 1 + l + sovPdpb(uint64(l)) - } - l = len(m.GitHash) - if l > 0 { - n += 1 + l + sovPdpb(uint64(l)) - } - l = len(m.DcLocation) - if l > 0 { - n += 1 + l + sovPdpb(uint64(l)) - } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) - } - return n + return dAtA[:n], nil } -func (m *GetMembersRequest) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Header != nil { - l = m.Header.Size() - n += 1 + l + sovPdpb(uint64(l)) - } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) - } - return n +func (m *Peers) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *GetMembersResponse) Size() (n int) { - if m == nil { - return 0 - } +func (m *Peers) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.Header != nil { - l = m.Header.Size() - n += 1 + l + sovPdpb(uint64(l)) - } - if len(m.Members) > 0 { - for _, e := range m.Members { - l = e.Size() - n += 1 + l + sovPdpb(uint64(l)) - } - } - if m.Leader != nil { - l = m.Leader.Size() - n += 1 + l + sovPdpb(uint64(l)) - } - if m.EtcdLeader != nil { - l = m.EtcdLeader.Size() - n += 1 + l + sovPdpb(uint64(l)) + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - if len(m.TsoAllocatorLeaders) > 0 { - for k, v := range m.TsoAllocatorLeaders { - _ = k - _ = v - l = 0 - if v != nil { - l = v.Size() - l += 1 + sovPdpb(uint64(l)) + if len(m.Peers) > 0 { + for iNdEx := len(m.Peers) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Peers[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) } - mapEntrySize := 1 + len(k) + sovPdpb(uint64(len(k))) + l - n += mapEntrySize + 1 + sovPdpb(uint64(mapEntrySize)) + i-- + dAtA[i] = 0xa } } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) - } - return n + return len(dAtA) - i, nil } -func (m *GetClusterInfoRequest) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Header != nil { - l = m.Header.Size() - n += 1 + l + sovPdpb(uint64(l)) - } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) +func (m *SyncRegionResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - return n + return dAtA[:n], nil } -func (m *GetClusterInfoResponse) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Header != nil { - l = m.Header.Size() - n += 1 + l + sovPdpb(uint64(l)) - } - if len(m.ServiceModes) > 0 { - l = 0 - for _, e := range m.ServiceModes { - l += sovPdpb(uint64(e)) - } - n += 1 + sovPdpb(uint64(l)) + l - } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) - } - return n +func (m *SyncRegionResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *PeerStats) Size() (n int) { - if m == nil { - return 0 - } +func (m *SyncRegionResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.Peer != nil { - l = m.Peer.Size() - n += 1 + l + sovPdpb(uint64(l)) - } - if m.DownSeconds != 0 { - n += 1 + sovPdpb(uint64(m.DownSeconds)) - } if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) - } - return n -} - -func (m *RegionHeartbeatRequest) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Header != nil { - l = m.Header.Size() - n += 1 + l + sovPdpb(uint64(l)) - } - if m.Region != nil { - l = m.Region.Size() - n += 1 + l + sovPdpb(uint64(l)) + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - if m.Leader != nil { - l = m.Leader.Size() - n += 1 + l + sovPdpb(uint64(l)) + if len(m.PendingPeers) > 0 { + for iNdEx := len(m.PendingPeers) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.PendingPeers[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x8a + } } if len(m.DownPeers) > 0 { - for _, e := range m.DownPeers { - l = e.Size() - n += 1 + l + sovPdpb(uint64(l)) + for iNdEx := len(m.DownPeers) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.DownPeers[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x82 } } - if len(m.PendingPeers) > 0 { - for _, e := range m.PendingPeers { - l = e.Size() - n += 1 + l + sovPdpb(uint64(l)) + if len(m.Buckets) > 0 { + for iNdEx := len(m.Buckets) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Buckets[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x32 } } - if m.BytesWritten != 0 { - n += 1 + sovPdpb(uint64(m.BytesWritten)) + if len(m.RegionLeaders) > 0 { + for iNdEx := len(m.RegionLeaders) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.RegionLeaders[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + } } - if m.BytesRead != 0 { - n += 1 + sovPdpb(uint64(m.BytesRead)) - } - if m.KeysWritten != 0 { - n += 1 + sovPdpb(uint64(m.KeysWritten)) - } - if m.KeysRead != 0 { - n += 1 + sovPdpb(uint64(m.KeysRead)) - } - if m.ApproximateSize != 0 { - n += 1 + sovPdpb(uint64(m.ApproximateSize)) - } - if m.Interval != nil { - l = m.Interval.Size() - n += 1 + l + sovPdpb(uint64(l)) - } - if m.ApproximateKeys != 0 { - n += 1 + sovPdpb(uint64(m.ApproximateKeys)) - } - if m.Term != 0 { - n += 1 + sovPdpb(uint64(m.Term)) - } - if m.ReplicationStatus != nil { - l = m.ReplicationStatus.Size() - n += 1 + l + sovPdpb(uint64(l)) - } - if m.QueryStats != nil { - l = m.QueryStats.Size() - n += 2 + l + sovPdpb(uint64(l)) + if len(m.RegionStats) > 0 { + for iNdEx := len(m.RegionStats) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.RegionStats[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } } - if m.CpuUsage != 0 { - n += 2 + sovPdpb(uint64(m.CpuUsage)) + if m.StartIndex != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.StartIndex)) + i-- + dAtA[i] = 0x18 } - if m.ApproximateKvSize != 0 { - n += 2 + sovPdpb(uint64(m.ApproximateKvSize)) + if len(m.Regions) > 0 { + for iNdEx := len(m.Regions) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Regions[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + if m.Header != nil { + { + size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa } - return n + return len(dAtA) - i, nil } -func (m *ChangePeer) Size() (n int) { - if m == nil { - return 0 +func (m *GetOperatorRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *GetOperatorRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GetOperatorRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.Peer != nil { - l = m.Peer.Size() - n += 1 + l + sovPdpb(uint64(l)) - } - if m.ChangeType != 0 { - n += 1 + sovPdpb(uint64(m.ChangeType)) - } if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - return n -} - -func (m *ChangePeerV2) Size() (n int) { - if m == nil { - return 0 + if m.RegionId != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.RegionId)) + i-- + dAtA[i] = 0x10 } - var l int - _ = l - if len(m.Changes) > 0 { - for _, e := range m.Changes { - l = e.Size() - n += 1 + l + sovPdpb(uint64(l)) + if m.Header != nil { + { + size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) } + i-- + dAtA[i] = 0xa } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) - } - return n + return len(dAtA) - i, nil } -func (m *TransferLeader) Size() (n int) { - if m == nil { - return 0 +func (m *GetOperatorResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *GetOperatorResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GetOperatorResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.Peer != nil { - l = m.Peer.Size() - n += 1 + l + sovPdpb(uint64(l)) + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - if len(m.Peers) > 0 { - for _, e := range m.Peers { - l = e.Size() - n += 1 + l + sovPdpb(uint64(l)) - } + if len(m.Kind) > 0 { + i -= len(m.Kind) + copy(dAtA[i:], m.Kind) + i = encodeVarintPdpb(dAtA, i, uint64(len(m.Kind))) + i-- + dAtA[i] = 0x2a } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + if m.Status != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.Status)) + i-- + dAtA[i] = 0x20 } - return n -} - -func (m *Merge) Size() (n int) { - if m == nil { - return 0 + if len(m.Desc) > 0 { + i -= len(m.Desc) + copy(dAtA[i:], m.Desc) + i = encodeVarintPdpb(dAtA, i, uint64(len(m.Desc))) + i-- + dAtA[i] = 0x1a } - var l int - _ = l - if m.Target != nil { - l = m.Target.Size() - n += 1 + l + sovPdpb(uint64(l)) + if m.RegionId != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.RegionId)) + i-- + dAtA[i] = 0x10 } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + if m.Header != nil { + { + size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa } - return n + return len(dAtA) - i, nil } -func (m *SplitRegion) Size() (n int) { - if m == nil { - return 0 +func (m *SyncMaxTSRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *SyncMaxTSRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SyncMaxTSRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.Policy != 0 { - n += 1 + sovPdpb(uint64(m.Policy)) + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - if len(m.Keys) > 0 { - for _, b := range m.Keys { - l = len(b) - n += 1 + l + sovPdpb(uint64(l)) + if m.SkipCheck { + i-- + if m.SkipCheck { + dAtA[i] = 1 + } else { + dAtA[i] = 0 } + i-- + dAtA[i] = 0x18 } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) - } - return n -} - -func (m *SwitchWitness) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.PeerId != 0 { - n += 1 + sovPdpb(uint64(m.PeerId)) - } - if m.IsWitness { - n += 2 + if m.MaxTs != nil { + { + size, err := m.MaxTs.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + if m.Header != nil { + { + size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa } - return n + return len(dAtA) - i, nil } -func (m *BatchSwitchWitness) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if len(m.SwitchWitnesses) > 0 { - for _, e := range m.SwitchWitnesses { - l = e.Size() - n += 1 + l + sovPdpb(uint64(l)) - } - } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) +func (m *SyncMaxTSResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - return n + return dAtA[:n], nil } -func (m *RegionHeartbeatResponse) Size() (n int) { - if m == nil { - return 0 - } +func (m *SyncMaxTSResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SyncMaxTSResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.Header != nil { - l = m.Header.Size() - n += 1 + l + sovPdpb(uint64(l)) - } - if m.ChangePeer != nil { - l = m.ChangePeer.Size() - n += 1 + l + sovPdpb(uint64(l)) - } - if m.TransferLeader != nil { - l = m.TransferLeader.Size() - n += 1 + l + sovPdpb(uint64(l)) - } - if m.RegionId != 0 { - n += 1 + sovPdpb(uint64(m.RegionId)) - } - if m.RegionEpoch != nil { - l = m.RegionEpoch.Size() - n += 1 + l + sovPdpb(uint64(l)) - } - if m.TargetPeer != nil { - l = m.TargetPeer.Size() - n += 1 + l + sovPdpb(uint64(l)) - } - if m.Merge != nil { - l = m.Merge.Size() - n += 1 + l + sovPdpb(uint64(l)) - } - if m.SplitRegion != nil { - l = m.SplitRegion.Size() - n += 1 + l + sovPdpb(uint64(l)) + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - if m.ChangePeerV2 != nil { - l = m.ChangePeerV2.Size() - n += 1 + l + sovPdpb(uint64(l)) + if len(m.SyncedDcs) > 0 { + for iNdEx := len(m.SyncedDcs) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.SyncedDcs[iNdEx]) + copy(dAtA[i:], m.SyncedDcs[iNdEx]) + i = encodeVarintPdpb(dAtA, i, uint64(len(m.SyncedDcs[iNdEx]))) + i-- + dAtA[i] = 0x1a + } } - if m.SwitchWitnesses != nil { - l = m.SwitchWitnesses.Size() - n += 1 + l + sovPdpb(uint64(l)) + if m.MaxLocalTs != nil { + { + size, err := m.MaxLocalTs.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + if m.Header != nil { + { + size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa } - return n + return len(dAtA) - i, nil } -func (m *AskSplitRequest) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Header != nil { - l = m.Header.Size() - n += 1 + l + sovPdpb(uint64(l)) - } - if m.Region != nil { - l = m.Region.Size() - n += 1 + l + sovPdpb(uint64(l)) - } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) +func (m *SplitRegionsRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - return n + return dAtA[:n], nil } -func (m *AskSplitResponse) Size() (n int) { - if m == nil { - return 0 - } +func (m *SplitRegionsRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SplitRegionsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.Header != nil { - l = m.Header.Size() - n += 1 + l + sovPdpb(uint64(l)) + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - if m.NewRegionId != 0 { - n += 1 + sovPdpb(uint64(m.NewRegionId)) + if m.RetryLimit != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.RetryLimit)) + i-- + dAtA[i] = 0x18 } - if len(m.NewPeerIds) > 0 { - l = 0 - for _, e := range m.NewPeerIds { - l += sovPdpb(uint64(e)) + if len(m.SplitKeys) > 0 { + for iNdEx := len(m.SplitKeys) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.SplitKeys[iNdEx]) + copy(dAtA[i:], m.SplitKeys[iNdEx]) + i = encodeVarintPdpb(dAtA, i, uint64(len(m.SplitKeys[iNdEx]))) + i-- + dAtA[i] = 0x12 } - n += 1 + sovPdpb(uint64(l)) + l } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + if m.Header != nil { + { + size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa } - return n + return len(dAtA) - i, nil } -func (m *ReportSplitRequest) Size() (n int) { - if m == nil { - return 0 +func (m *SplitRegionsResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *SplitRegionsResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SplitRegionsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.Header != nil { - l = m.Header.Size() - n += 1 + l + sovPdpb(uint64(l)) - } - if m.Left != nil { - l = m.Left.Size() - n += 1 + l + sovPdpb(uint64(l)) - } - if m.Right != nil { - l = m.Right.Size() - n += 1 + l + sovPdpb(uint64(l)) - } if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) - } - return n -} - -func (m *ReportSplitResponse) Size() (n int) { - if m == nil { - return 0 + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - var l int - _ = l - if m.Header != nil { - l = m.Header.Size() - n += 1 + l + sovPdpb(uint64(l)) + if len(m.RegionsId) > 0 { + dAtA145 := make([]byte, len(m.RegionsId)*10) + var j144 int + for _, num := range m.RegionsId { + for num >= 1<<7 { + dAtA145[j144] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j144++ + } + dAtA145[j144] = uint8(num) + j144++ + } + i -= j144 + copy(dAtA[i:], dAtA145[:j144]) + i = encodeVarintPdpb(dAtA, i, uint64(j144)) + i-- + dAtA[i] = 0x1a } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + if m.FinishedPercentage != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.FinishedPercentage)) + i-- + dAtA[i] = 0x10 } - return n + if m.Header != nil { + { + size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil } -func (m *AskBatchSplitRequest) Size() (n int) { - if m == nil { - return 0 +func (m *SplitAndScatterRegionsRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *SplitAndScatterRegionsRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SplitAndScatterRegionsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.Header != nil { - l = m.Header.Size() - n += 1 + l + sovPdpb(uint64(l)) - } - if m.Region != nil { - l = m.Region.Size() - n += 1 + l + sovPdpb(uint64(l)) - } - if m.SplitCount != 0 { - n += 1 + sovPdpb(uint64(m.SplitCount)) - } if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - return n -} - -func (m *SplitID) Size() (n int) { - if m == nil { - return 0 + if m.RetryLimit != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.RetryLimit)) + i-- + dAtA[i] = 0x20 } - var l int - _ = l - if m.NewRegionId != 0 { - n += 1 + sovPdpb(uint64(m.NewRegionId)) + if len(m.Group) > 0 { + i -= len(m.Group) + copy(dAtA[i:], m.Group) + i = encodeVarintPdpb(dAtA, i, uint64(len(m.Group))) + i-- + dAtA[i] = 0x1a } - if len(m.NewPeerIds) > 0 { - l = 0 - for _, e := range m.NewPeerIds { - l += sovPdpb(uint64(e)) + if len(m.SplitKeys) > 0 { + for iNdEx := len(m.SplitKeys) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.SplitKeys[iNdEx]) + copy(dAtA[i:], m.SplitKeys[iNdEx]) + i = encodeVarintPdpb(dAtA, i, uint64(len(m.SplitKeys[iNdEx]))) + i-- + dAtA[i] = 0x12 } - n += 1 + sovPdpb(uint64(l)) + l } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + if m.Header != nil { + { + size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa } - return n + return len(dAtA) - i, nil } -func (m *AskBatchSplitResponse) Size() (n int) { - if m == nil { - return 0 +func (m *SplitAndScatterRegionsResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *SplitAndScatterRegionsResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SplitAndScatterRegionsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.Header != nil { - l = m.Header.Size() - n += 1 + l + sovPdpb(uint64(l)) + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - if len(m.Ids) > 0 { - for _, e := range m.Ids { - l = e.Size() - n += 1 + l + sovPdpb(uint64(l)) + if len(m.RegionsId) > 0 { + dAtA149 := make([]byte, len(m.RegionsId)*10) + var j148 int + for _, num := range m.RegionsId { + for num >= 1<<7 { + dAtA149[j148] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j148++ + } + dAtA149[j148] = uint8(num) + j148++ } + i -= j148 + copy(dAtA[i:], dAtA149[:j148]) + i = encodeVarintPdpb(dAtA, i, uint64(j148)) + i-- + dAtA[i] = 0x22 } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + if m.ScatterFinishedPercentage != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.ScatterFinishedPercentage)) + i-- + dAtA[i] = 0x18 } - return n -} - -func (m *ReportBatchSplitRequest) Size() (n int) { - if m == nil { - return 0 + if m.SplitFinishedPercentage != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.SplitFinishedPercentage)) + i-- + dAtA[i] = 0x10 } - var l int - _ = l if m.Header != nil { - l = m.Header.Size() - n += 1 + l + sovPdpb(uint64(l)) - } - if len(m.Regions) > 0 { - for _, e := range m.Regions { - l = e.Size() - n += 1 + l + sovPdpb(uint64(l)) + { + size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) } + i-- + dAtA[i] = 0xa } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) - } - return n + return len(dAtA) - i, nil } -func (m *ReportBatchSplitResponse) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Header != nil { - l = m.Header.Size() - n += 1 + l + sovPdpb(uint64(l)) - } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) +func (m *GetDCLocationInfoRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - return n + return dAtA[:n], nil } -func (m *TimeInterval) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.StartTimestamp != 0 { - n += 1 + sovPdpb(uint64(m.StartTimestamp)) - } - if m.EndTimestamp != 0 { - n += 1 + sovPdpb(uint64(m.EndTimestamp)) - } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) - } - return n +func (m *GetDCLocationInfoRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *RecordPair) Size() (n int) { - if m == nil { - return 0 - } +func (m *GetDCLocationInfoRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - l = len(m.Key) - if l > 0 { - n += 1 + l + sovPdpb(uint64(l)) - } - if m.Value != 0 { - n += 1 + sovPdpb(uint64(m.Value)) - } if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - return n -} + if len(m.DcLocation) > 0 { + i -= len(m.DcLocation) + copy(dAtA[i:], m.DcLocation) + i = encodeVarintPdpb(dAtA, i, uint64(len(m.DcLocation))) + i-- + dAtA[i] = 0x12 + } + if m.Header != nil { + { + size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} -func (m *PeerStat) Size() (n int) { - if m == nil { - return 0 +func (m *GetDCLocationInfoResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *GetDCLocationInfoResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GetDCLocationInfoResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.RegionId != 0 { - n += 1 + sovPdpb(uint64(m.RegionId)) - } - if m.ReadKeys != 0 { - n += 1 + sovPdpb(uint64(m.ReadKeys)) - } - if m.ReadBytes != 0 { - n += 1 + sovPdpb(uint64(m.ReadBytes)) - } - if m.QueryStats != nil { - l = m.QueryStats.Size() - n += 1 + l + sovPdpb(uint64(l)) + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - if m.WrittenKeys != 0 { - n += 1 + sovPdpb(uint64(m.WrittenKeys)) + if m.MaxTs != nil { + { + size, err := m.MaxTs.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a } - if m.WrittenBytes != 0 { - n += 1 + sovPdpb(uint64(m.WrittenBytes)) + if m.Suffix != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.Suffix)) + i-- + dAtA[i] = 0x10 } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + if m.Header != nil { + { + size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa } - return n + return len(dAtA) - i, nil } -func (m *StoreStats) Size() (n int) { - if m == nil { - return 0 +func (m *QueryStats) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *QueryStats) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryStats) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.StoreId != 0 { - n += 1 + sovPdpb(uint64(m.StoreId)) - } - if m.Capacity != 0 { - n += 1 + sovPdpb(uint64(m.Capacity)) + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - if m.Available != 0 { - n += 1 + sovPdpb(uint64(m.Available)) + if m.Rollback != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.Rollback)) + i-- + dAtA[i] = 0x58 } - if m.RegionCount != 0 { - n += 1 + sovPdpb(uint64(m.RegionCount)) + if m.Commit != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.Commit)) + i-- + dAtA[i] = 0x50 } - if m.SendingSnapCount != 0 { - n += 1 + sovPdpb(uint64(m.SendingSnapCount)) + if m.AcquirePessimisticLock != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.AcquirePessimisticLock)) + i-- + dAtA[i] = 0x48 } - if m.ReceivingSnapCount != 0 { - n += 1 + sovPdpb(uint64(m.ReceivingSnapCount)) + if m.Prewrite != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.Prewrite)) + i-- + dAtA[i] = 0x40 } - if m.StartTime != 0 { - n += 1 + sovPdpb(uint64(m.StartTime)) + if m.Put != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.Put)) + i-- + dAtA[i] = 0x38 } - if m.ApplyingSnapCount != 0 { - n += 1 + sovPdpb(uint64(m.ApplyingSnapCount)) + if m.DeleteRange != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.DeleteRange)) + i-- + dAtA[i] = 0x30 } - if m.IsBusy { - n += 2 + if m.Delete != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.Delete)) + i-- + dAtA[i] = 0x28 } - if m.UsedSize != 0 { - n += 1 + sovPdpb(uint64(m.UsedSize)) + if m.Coprocessor != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.Coprocessor)) + i-- + dAtA[i] = 0x20 } - if m.BytesWritten != 0 { - n += 1 + sovPdpb(uint64(m.BytesWritten)) + if m.Scan != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.Scan)) + i-- + dAtA[i] = 0x18 } - if m.KeysWritten != 0 { - n += 1 + sovPdpb(uint64(m.KeysWritten)) + if m.Get != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.Get)) + i-- + dAtA[i] = 0x10 } - if m.BytesRead != 0 { - n += 1 + sovPdpb(uint64(m.BytesRead)) + if m.GC != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.GC)) + i-- + dAtA[i] = 0x8 } - if m.KeysRead != 0 { - n += 1 + sovPdpb(uint64(m.KeysRead)) + return len(dAtA) - i, nil +} + +func (m *ReportBucketsRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - if m.Interval != nil { - l = m.Interval.Size() - n += 1 + l + sovPdpb(uint64(l)) + return dAtA[:n], nil +} + +func (m *ReportBucketsRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ReportBucketsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - if len(m.CpuUsages) > 0 { - for _, e := range m.CpuUsages { - l = e.Size() - n += 2 + l + sovPdpb(uint64(l)) + if m.Buckets != nil { + { + size, err := m.Buckets.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) } + i-- + dAtA[i] = 0x1a } - if len(m.ReadIoRates) > 0 { - for _, e := range m.ReadIoRates { - l = e.Size() - n += 2 + l + sovPdpb(uint64(l)) + if m.RegionEpoch != nil { + { + size, err := m.RegionEpoch.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) } + i-- + dAtA[i] = 0x12 } - if len(m.WriteIoRates) > 0 { - for _, e := range m.WriteIoRates { - l = e.Size() - n += 2 + l + sovPdpb(uint64(l)) + if m.Header != nil { + { + size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) } + i-- + dAtA[i] = 0xa } - if len(m.OpLatencies) > 0 { - for _, e := range m.OpLatencies { - l = e.Size() - n += 2 + l + sovPdpb(uint64(l)) - } - } - if len(m.PeerStats) > 0 { - for _, e := range m.PeerStats { - l = e.Size() - n += 2 + l + sovPdpb(uint64(l)) - } - } - if m.QueryStats != nil { - l = m.QueryStats.Size() - n += 2 + l + sovPdpb(uint64(l)) - } - if m.SlowScore != 0 { - n += 2 + sovPdpb(uint64(m.SlowScore)) - } - if len(m.DamagedRegionsId) > 0 { - l = 0 - for _, e := range m.DamagedRegionsId { - l += sovPdpb(uint64(e)) - } - n += 2 + sovPdpb(uint64(l)) + l - } - if m.IsApplyBusy { - n += 3 - } - if len(m.SnapshotStats) > 0 { - for _, e := range m.SnapshotStats { - l = e.Size() - n += 2 + l + sovPdpb(uint64(l)) - } - } - if m.SlowTrend != nil { - l = m.SlowTrend.Size() - n += 2 + l + sovPdpb(uint64(l)) - } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) - } - return n + return len(dAtA) - i, nil } -func (m *SlowTrend) Size() (n int) { - if m == nil { - return 0 +func (m *ReportBucketsResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *ReportBucketsResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ReportBucketsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.CauseValue != 0 { - n += 9 - } - if m.CauseRate != 0 { - n += 9 - } - if m.ResultValue != 0 { - n += 9 - } - if m.ResultRate != 0 { - n += 9 - } if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - return n + if m.Header != nil { + { + size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil } -func (m *SnapshotStat) Size() (n int) { - if m == nil { - return 0 +func (m *ReportMinResolvedTsRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *ReportMinResolvedTsRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ReportMinResolvedTsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.RegionId != 0 { - n += 1 + sovPdpb(uint64(m.RegionId)) - } - if m.GenerateDurationSec != 0 { - n += 1 + sovPdpb(uint64(m.GenerateDurationSec)) - } - if m.SendDurationSec != 0 { - n += 1 + sovPdpb(uint64(m.SendDurationSec)) + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - if m.TotalDurationSec != 0 { - n += 1 + sovPdpb(uint64(m.TotalDurationSec)) + if m.MinResolvedTs != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.MinResolvedTs)) + i-- + dAtA[i] = 0x18 } - if m.TransportSize != 0 { - n += 1 + sovPdpb(uint64(m.TransportSize)) + if m.StoreId != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.StoreId)) + i-- + dAtA[i] = 0x10 } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + if m.Header != nil { + { + size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa } - return n + return len(dAtA) - i, nil } -func (m *PeerReport) Size() (n int) { - if m == nil { - return 0 +func (m *ReportMinResolvedTsResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *ReportMinResolvedTsResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ReportMinResolvedTsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.RaftState != nil { - l = m.RaftState.Size() - n += 1 + l + sovPdpb(uint64(l)) - } - if m.RegionState != nil { - l = m.RegionState.Size() - n += 1 + l + sovPdpb(uint64(l)) - } - if m.IsForceLeader { - n += 2 - } - if m.HasCommitMerge { - n += 2 - } if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - return n + if m.Header != nil { + { + size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil } -func (m *StoreReport) Size() (n int) { - if m == nil { - return 0 +func (m *SetExternalTimestampRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *SetExternalTimestampRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SetExternalTimestampRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if len(m.PeerReports) > 0 { - for _, e := range m.PeerReports { - l = e.Size() - n += 1 + l + sovPdpb(uint64(l)) - } + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - if m.Step != 0 { - n += 1 + sovPdpb(uint64(m.Step)) + if m.Timestamp != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.Timestamp)) + i-- + dAtA[i] = 0x10 } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + if m.Header != nil { + { + size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa } - return n + return len(dAtA) - i, nil } -func (m *StoreHeartbeatRequest) Size() (n int) { - if m == nil { - return 0 - } - var l int +func (m *SetExternalTimestampResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SetExternalTimestampResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SetExternalTimestampResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } if m.Header != nil { - l = m.Header.Size() - n += 1 + l + sovPdpb(uint64(l)) + { + size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa } - if m.Stats != nil { - l = m.Stats.Size() - n += 1 + l + sovPdpb(uint64(l)) + return len(dAtA) - i, nil +} + +func (m *GetExternalTimestampRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - if m.StoreReport != nil { - l = m.StoreReport.Size() - n += 1 + l + sovPdpb(uint64(l)) + return dAtA[:n], nil +} + +func (m *GetExternalTimestampRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GetExternalTimestampRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - if m.DrAutosyncStatus != nil { - l = m.DrAutosyncStatus.Size() - n += 1 + l + sovPdpb(uint64(l)) + if m.Header != nil { + { + size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa } + return len(dAtA) - i, nil +} + +func (m *GetExternalTimestampResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *GetExternalTimestampResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GetExternalTimestampResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - return n + if m.Timestamp != 0 { + i = encodeVarintPdpb(dAtA, i, uint64(m.Timestamp)) + i-- + dAtA[i] = 0x10 + } + if m.Header != nil { + { + size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil } -func (m *DemoteFailedVoters) Size() (n int) { - if m == nil { - return 0 +func (m *GetMinTSRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *GetMinTSRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GetMinTSRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.RegionId != 0 { - n += 1 + sovPdpb(uint64(m.RegionId)) + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - if len(m.FailedVoters) > 0 { - for _, e := range m.FailedVoters { - l = e.Size() - n += 1 + l + sovPdpb(uint64(l)) + if m.Header != nil { + { + size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *GetMinTSResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } + return dAtA[:n], nil +} + +func (m *GetMinTSResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GetMinTSResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - return n + if m.Timestamp != nil { + { + size, err := m.Timestamp.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.Header != nil { + { + size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPdpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil } -func (m *ForceLeader) Size() (n int) { +func encodeVarintPdpb(dAtA []byte, offset int, v uint64) int { + offset -= sovPdpb(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *WatchGlobalConfigRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l - if len(m.FailedStores) > 0 { - l = 0 - for _, e := range m.FailedStores { - l += sovPdpb(uint64(e)) - } - n += 1 + sovPdpb(uint64(l)) + l + l = len(m.ConfigPath) + if l > 0 { + n += 1 + l + sovPdpb(uint64(l)) } - if len(m.EnterForceLeaders) > 0 { - l = 0 - for _, e := range m.EnterForceLeaders { - l += sovPdpb(uint64(e)) - } - n += 1 + sovPdpb(uint64(l)) + l + if m.Revision != 0 { + n += 1 + sovPdpb(uint64(m.Revision)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) @@ -17304,62 +16989,62 @@ func (m *ForceLeader) Size() (n int) { return n } -func (m *RecoveryPlan) Size() (n int) { +func (m *WatchGlobalConfigResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l - if len(m.Creates) > 0 { - for _, e := range m.Creates { + if len(m.Changes) > 0 { + for _, e := range m.Changes { l = e.Size() n += 1 + l + sovPdpb(uint64(l)) } } - if len(m.Updates) > 0 { - for _, e := range m.Updates { - l = e.Size() - n += 1 + l + sovPdpb(uint64(l)) - } + if m.Revision != 0 { + n += 1 + sovPdpb(uint64(m.Revision)) } - if len(m.Tombstones) > 0 { - l = 0 - for _, e := range m.Tombstones { - l += sovPdpb(uint64(e)) - } - n += 1 + sovPdpb(uint64(l)) + l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) } - if len(m.Demotes) > 0 { - for _, e := range m.Demotes { + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *StoreGlobalConfigRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Changes) > 0 { + for _, e := range m.Changes { l = e.Size() n += 1 + l + sovPdpb(uint64(l)) } } - if m.ForceLeader != nil { - l = m.ForceLeader.Size() + l = len(m.ConfigPath) + if l > 0 { n += 1 + l + sovPdpb(uint64(l)) } - if m.Step != 0 { - n += 1 + sovPdpb(uint64(m.Step)) - } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } -func (m *AwakenRegions) Size() (n int) { +func (m *StoreGlobalConfigResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l - if len(m.AbnormalStores) > 0 { - l = 0 - for _, e := range m.AbnormalStores { - l += sovPdpb(uint64(e)) - } - n += 1 + sovPdpb(uint64(l)) + l + if m.Error != nil { + l = m.Error.Size() + n += 1 + l + sovPdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) @@ -17367,34 +17052,42 @@ func (m *AwakenRegions) Size() (n int) { return n } -func (m *StoreHeartbeatResponse) Size() (n int) { +func (m *LoadGlobalConfigRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.Header != nil { - l = m.Header.Size() - n += 1 + l + sovPdpb(uint64(l)) - } - if m.ReplicationStatus != nil { - l = m.ReplicationStatus.Size() - n += 1 + l + sovPdpb(uint64(l)) + if len(m.Names) > 0 { + for _, s := range m.Names { + l = len(s) + n += 1 + l + sovPdpb(uint64(l)) + } } - l = len(m.ClusterVersion) + l = len(m.ConfigPath) if l > 0 { n += 1 + l + sovPdpb(uint64(l)) } - if m.RequireDetailedReport { - n += 2 + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) } - if m.RecoveryPlan != nil { - l = m.RecoveryPlan.Size() - n += 1 + l + sovPdpb(uint64(l)) + return n +} + +func (m *LoadGlobalConfigResponse) Size() (n int) { + if m == nil { + return 0 } - if m.AwakenRegions != nil { - l = m.AwakenRegions.Size() - n += 1 + l + sovPdpb(uint64(l)) + var l int + _ = l + if len(m.Items) > 0 { + for _, e := range m.Items { + l = e.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + } + if m.Revision != 0 { + n += 1 + sovPdpb(uint64(m.Revision)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) @@ -17402,59 +17095,48 @@ func (m *StoreHeartbeatResponse) Size() (n int) { return n } -func (m *ScatterRegionRequest) Size() (n int) { +func (m *GlobalConfigItem) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.Header != nil { - l = m.Header.Size() + l = len(m.Name) + if l > 0 { n += 1 + l + sovPdpb(uint64(l)) } - if m.RegionId != 0 { - n += 1 + sovPdpb(uint64(m.RegionId)) - } - if m.Region != nil { - l = m.Region.Size() + l = len(m.Value) + if l > 0 { n += 1 + l + sovPdpb(uint64(l)) } - if m.Leader != nil { - l = m.Leader.Size() + if m.Error != nil { + l = m.Error.Size() n += 1 + l + sovPdpb(uint64(l)) } - l = len(m.Group) + if m.Kind != 0 { + n += 1 + sovPdpb(uint64(m.Kind)) + } + l = len(m.Payload) if l > 0 { n += 1 + l + sovPdpb(uint64(l)) } - if len(m.RegionsId) > 0 { - l = 0 - for _, e := range m.RegionsId { - l += sovPdpb(uint64(e)) - } - n += 1 + sovPdpb(uint64(l)) + l - } - if m.RetryLimit != 0 { - n += 1 + sovPdpb(uint64(m.RetryLimit)) - } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } -func (m *ScatterRegionResponse) Size() (n int) { +func (m *RequestHeader) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.Header != nil { - l = m.Header.Size() - n += 1 + l + sovPdpb(uint64(l)) + if m.ClusterId != 0 { + n += 1 + sovPdpb(uint64(m.ClusterId)) } - if m.FinishedPercentage != 0 { - n += 1 + sovPdpb(uint64(m.FinishedPercentage)) + if m.SenderId != 0 { + n += 1 + sovPdpb(uint64(m.SenderId)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) @@ -17462,14 +17144,17 @@ func (m *ScatterRegionResponse) Size() (n int) { return n } -func (m *GetGCSafePointRequest) Size() (n int) { +func (m *ResponseHeader) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.Header != nil { - l = m.Header.Size() + if m.ClusterId != 0 { + n += 1 + sovPdpb(uint64(m.ClusterId)) + } + if m.Error != nil { + l = m.Error.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.XXX_unrecognized != nil { @@ -17478,18 +17163,18 @@ func (m *GetGCSafePointRequest) Size() (n int) { return n } -func (m *GetGCSafePointResponse) Size() (n int) { +func (m *Error) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.Header != nil { - l = m.Header.Size() - n += 1 + l + sovPdpb(uint64(l)) + if m.Type != 0 { + n += 1 + sovPdpb(uint64(m.Type)) } - if m.SafePoint != 0 { - n += 1 + sovPdpb(uint64(m.SafePoint)) + l = len(m.Message) + if l > 0 { + n += 1 + l + sovPdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) @@ -17497,7 +17182,7 @@ func (m *GetGCSafePointResponse) Size() (n int) { return n } -func (m *UpdateGCSafePointRequest) Size() (n int) { +func (m *TsoRequest) Size() (n int) { if m == nil { return 0 } @@ -17507,8 +17192,12 @@ func (m *UpdateGCSafePointRequest) Size() (n int) { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } - if m.SafePoint != 0 { - n += 1 + sovPdpb(uint64(m.SafePoint)) + if m.Count != 0 { + n += 1 + sovPdpb(uint64(m.Count)) + } + l = len(m.DcLocation) + if l > 0 { + n += 1 + l + sovPdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) @@ -17516,18 +17205,20 @@ func (m *UpdateGCSafePointRequest) Size() (n int) { return n } -func (m *UpdateGCSafePointResponse) Size() (n int) { +func (m *Timestamp) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.Header != nil { - l = m.Header.Size() - n += 1 + l + sovPdpb(uint64(l)) + if m.Physical != 0 { + n += 1 + sovPdpb(uint64(m.Physical)) } - if m.NewSafePoint != 0 { - n += 1 + sovPdpb(uint64(m.NewSafePoint)) + if m.Logical != 0 { + n += 1 + sovPdpb(uint64(m.Logical)) + } + if m.SuffixBits != 0 { + n += 1 + sovPdpb(uint64(m.SuffixBits)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) @@ -17535,7 +17226,7 @@ func (m *UpdateGCSafePointResponse) Size() (n int) { return n } -func (m *UpdateServiceGCSafePointRequest) Size() (n int) { +func (m *TsoResponse) Size() (n int) { if m == nil { return 0 } @@ -17545,15 +17236,12 @@ func (m *UpdateServiceGCSafePointRequest) Size() (n int) { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } - l = len(m.ServiceId) - if l > 0 { - n += 1 + l + sovPdpb(uint64(l)) - } - if m.TTL != 0 { - n += 1 + sovPdpb(uint64(m.TTL)) + if m.Count != 0 { + n += 1 + sovPdpb(uint64(m.Count)) } - if m.SafePoint != 0 { - n += 1 + sovPdpb(uint64(m.SafePoint)) + if m.Timestamp != nil { + l = m.Timestamp.Size() + n += 1 + l + sovPdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) @@ -17561,7 +17249,7 @@ func (m *UpdateServiceGCSafePointRequest) Size() (n int) { return n } -func (m *UpdateServiceGCSafePointResponse) Size() (n int) { +func (m *BootstrapRequest) Size() (n int) { if m == nil { return 0 } @@ -17571,15 +17259,13 @@ func (m *UpdateServiceGCSafePointResponse) Size() (n int) { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } - l = len(m.ServiceId) - if l > 0 { + if m.Store != nil { + l = m.Store.Size() n += 1 + l + sovPdpb(uint64(l)) } - if m.TTL != 0 { - n += 1 + sovPdpb(uint64(m.TTL)) - } - if m.MinSafePoint != 0 { - n += 1 + sovPdpb(uint64(m.MinSafePoint)) + if m.Region != nil { + l = m.Region.Size() + n += 1 + l + sovPdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) @@ -17587,23 +17273,19 @@ func (m *UpdateServiceGCSafePointResponse) Size() (n int) { return n } -func (m *RegionStat) Size() (n int) { +func (m *BootstrapResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.BytesWritten != 0 { - n += 1 + sovPdpb(uint64(m.BytesWritten)) - } - if m.BytesRead != 0 { - n += 1 + sovPdpb(uint64(m.BytesRead)) - } - if m.KeysWritten != 0 { - n += 1 + sovPdpb(uint64(m.KeysWritten)) + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) } - if m.KeysRead != 0 { - n += 1 + sovPdpb(uint64(m.KeysRead)) + if m.ReplicationStatus != nil { + l = m.ReplicationStatus.Size() + n += 1 + l + sovPdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) @@ -17611,7 +17293,7 @@ func (m *RegionStat) Size() (n int) { return n } -func (m *SyncRegionRequest) Size() (n int) { +func (m *IsBootstrappedRequest) Size() (n int) { if m == nil { return 0 } @@ -17621,30 +17303,24 @@ func (m *SyncRegionRequest) Size() (n int) { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } - if m.Member != nil { - l = m.Member.Size() - n += 1 + l + sovPdpb(uint64(l)) - } - if m.StartIndex != 0 { - n += 1 + sovPdpb(uint64(m.StartIndex)) - } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } -func (m *PeersStats) Size() (n int) { +func (m *IsBootstrappedResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l - if len(m.Peers) > 0 { - for _, e := range m.Peers { - l = e.Size() - n += 1 + l + sovPdpb(uint64(l)) - } + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.Bootstrapped { + n += 2 } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) @@ -17652,17 +17328,15 @@ func (m *PeersStats) Size() (n int) { return n } -func (m *Peers) Size() (n int) { +func (m *AllocIDRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l - if len(m.Peers) > 0 { - for _, e := range m.Peers { - l = e.Size() - n += 1 + l + sovPdpb(uint64(l)) - } + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) @@ -17670,7 +17344,7 @@ func (m *Peers) Size() (n int) { return n } -func (m *SyncRegionResponse) Size() (n int) { +func (m *AllocIDResponse) Size() (n int) { if m == nil { return 0 } @@ -17680,44 +17354,8 @@ func (m *SyncRegionResponse) Size() (n int) { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } - if len(m.Regions) > 0 { - for _, e := range m.Regions { - l = e.Size() - n += 1 + l + sovPdpb(uint64(l)) - } - } - if m.StartIndex != 0 { - n += 1 + sovPdpb(uint64(m.StartIndex)) - } - if len(m.RegionStats) > 0 { - for _, e := range m.RegionStats { - l = e.Size() - n += 1 + l + sovPdpb(uint64(l)) - } - } - if len(m.RegionLeaders) > 0 { - for _, e := range m.RegionLeaders { - l = e.Size() - n += 1 + l + sovPdpb(uint64(l)) - } - } - if len(m.Buckets) > 0 { - for _, e := range m.Buckets { - l = e.Size() - n += 1 + l + sovPdpb(uint64(l)) - } - } - if len(m.DownPeers) > 0 { - for _, e := range m.DownPeers { - l = e.Size() - n += 2 + l + sovPdpb(uint64(l)) - } - } - if len(m.PendingPeers) > 0 { - for _, e := range m.PendingPeers { - l = e.Size() - n += 2 + l + sovPdpb(uint64(l)) - } + if m.Id != 0 { + n += 1 + sovPdpb(uint64(m.Id)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) @@ -17725,7 +17363,7 @@ func (m *SyncRegionResponse) Size() (n int) { return n } -func (m *GetOperatorRequest) Size() (n int) { +func (m *IsSnapshotRecoveringRequest) Size() (n int) { if m == nil { return 0 } @@ -17735,16 +17373,13 @@ func (m *GetOperatorRequest) Size() (n int) { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } - if m.RegionId != 0 { - n += 1 + sovPdpb(uint64(m.RegionId)) - } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } -func (m *GetOperatorResponse) Size() (n int) { +func (m *IsSnapshotRecoveringResponse) Size() (n int) { if m == nil { return 0 } @@ -17754,19 +17389,8 @@ func (m *GetOperatorResponse) Size() (n int) { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } - if m.RegionId != 0 { - n += 1 + sovPdpb(uint64(m.RegionId)) - } - l = len(m.Desc) - if l > 0 { - n += 1 + l + sovPdpb(uint64(l)) - } - if m.Status != 0 { - n += 1 + sovPdpb(uint64(m.Status)) - } - l = len(m.Kind) - if l > 0 { - n += 1 + l + sovPdpb(uint64(l)) + if m.Marked { + n += 2 } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) @@ -17774,7 +17398,7 @@ func (m *GetOperatorResponse) Size() (n int) { return n } -func (m *SyncMaxTSRequest) Size() (n int) { +func (m *GetStoreRequest) Size() (n int) { if m == nil { return 0 } @@ -17784,12 +17408,8 @@ func (m *SyncMaxTSRequest) Size() (n int) { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } - if m.MaxTs != nil { - l = m.MaxTs.Size() - n += 1 + l + sovPdpb(uint64(l)) - } - if m.SkipCheck { - n += 2 + if m.StoreId != 0 { + n += 1 + sovPdpb(uint64(m.StoreId)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) @@ -17797,7 +17417,7 @@ func (m *SyncMaxTSRequest) Size() (n int) { return n } -func (m *SyncMaxTSResponse) Size() (n int) { +func (m *GetStoreResponse) Size() (n int) { if m == nil { return 0 } @@ -17807,15 +17427,13 @@ func (m *SyncMaxTSResponse) Size() (n int) { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } - if m.MaxLocalTs != nil { - l = m.MaxLocalTs.Size() + if m.Store != nil { + l = m.Store.Size() n += 1 + l + sovPdpb(uint64(l)) } - if len(m.SyncedDcs) > 0 { - for _, s := range m.SyncedDcs { - l = len(s) - n += 1 + l + sovPdpb(uint64(l)) - } + if m.Stats != nil { + l = m.Stats.Size() + n += 1 + l + sovPdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) @@ -17823,7 +17441,7 @@ func (m *SyncMaxTSResponse) Size() (n int) { return n } -func (m *SplitRegionsRequest) Size() (n int) { +func (m *PutStoreRequest) Size() (n int) { if m == nil { return 0 } @@ -17833,14 +17451,9 @@ func (m *SplitRegionsRequest) Size() (n int) { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } - if len(m.SplitKeys) > 0 { - for _, b := range m.SplitKeys { - l = len(b) - n += 1 + l + sovPdpb(uint64(l)) - } - } - if m.RetryLimit != 0 { - n += 1 + sovPdpb(uint64(m.RetryLimit)) + if m.Store != nil { + l = m.Store.Size() + n += 1 + l + sovPdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) @@ -17848,7 +17461,7 @@ func (m *SplitRegionsRequest) Size() (n int) { return n } -func (m *SplitRegionsResponse) Size() (n int) { +func (m *PutStoreResponse) Size() (n int) { if m == nil { return 0 } @@ -17858,15 +17471,9 @@ func (m *SplitRegionsResponse) Size() (n int) { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } - if m.FinishedPercentage != 0 { - n += 1 + sovPdpb(uint64(m.FinishedPercentage)) - } - if len(m.RegionsId) > 0 { - l = 0 - for _, e := range m.RegionsId { - l += sovPdpb(uint64(e)) - } - n += 1 + sovPdpb(uint64(l)) + l + if m.ReplicationStatus != nil { + l = m.ReplicationStatus.Size() + n += 1 + l + sovPdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) @@ -17874,7 +17481,7 @@ func (m *SplitRegionsResponse) Size() (n int) { return n } -func (m *SplitAndScatterRegionsRequest) Size() (n int) { +func (m *GetAllStoresRequest) Size() (n int) { if m == nil { return 0 } @@ -17884,18 +17491,8 @@ func (m *SplitAndScatterRegionsRequest) Size() (n int) { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } - if len(m.SplitKeys) > 0 { - for _, b := range m.SplitKeys { - l = len(b) - n += 1 + l + sovPdpb(uint64(l)) - } - } - l = len(m.Group) - if l > 0 { - n += 1 + l + sovPdpb(uint64(l)) - } - if m.RetryLimit != 0 { - n += 1 + sovPdpb(uint64(m.RetryLimit)) + if m.ExcludeTombstoneStores { + n += 2 } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) @@ -17903,7 +17500,7 @@ func (m *SplitAndScatterRegionsRequest) Size() (n int) { return n } -func (m *SplitAndScatterRegionsResponse) Size() (n int) { +func (m *GetAllStoresResponse) Size() (n int) { if m == nil { return 0 } @@ -17913,18 +17510,11 @@ func (m *SplitAndScatterRegionsResponse) Size() (n int) { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } - if m.SplitFinishedPercentage != 0 { - n += 1 + sovPdpb(uint64(m.SplitFinishedPercentage)) - } - if m.ScatterFinishedPercentage != 0 { - n += 1 + sovPdpb(uint64(m.ScatterFinishedPercentage)) - } - if len(m.RegionsId) > 0 { - l = 0 - for _, e := range m.RegionsId { - l += sovPdpb(uint64(e)) + if len(m.Stores) > 0 { + for _, e := range m.Stores { + l = e.Size() + n += 1 + l + sovPdpb(uint64(l)) } - n += 1 + sovPdpb(uint64(l)) + l } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) @@ -17932,7 +17522,7 @@ func (m *SplitAndScatterRegionsResponse) Size() (n int) { return n } -func (m *GetDCLocationInfoRequest) Size() (n int) { +func (m *GetRegionRequest) Size() (n int) { if m == nil { return 0 } @@ -17942,17 +17532,20 @@ func (m *GetDCLocationInfoRequest) Size() (n int) { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } - l = len(m.DcLocation) + l = len(m.RegionKey) if l > 0 { n += 1 + l + sovPdpb(uint64(l)) } + if m.NeedBuckets { + n += 2 + } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } -func (m *GetDCLocationInfoResponse) Size() (n int) { +func (m *GetRegionResponse) Size() (n int) { if m == nil { return 0 } @@ -17962,11 +17555,28 @@ func (m *GetDCLocationInfoResponse) Size() (n int) { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } - if m.Suffix != 0 { - n += 1 + sovPdpb(uint64(m.Suffix)) + if m.Region != nil { + l = m.Region.Size() + n += 1 + l + sovPdpb(uint64(l)) } - if m.MaxTs != nil { - l = m.MaxTs.Size() + if m.Leader != nil { + l = m.Leader.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if len(m.DownPeers) > 0 { + for _, e := range m.DownPeers { + l = e.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + } + if len(m.PendingPeers) > 0 { + for _, e := range m.PendingPeers { + l = e.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + } + if m.Buckets != nil { + l = m.Buckets.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.XXX_unrecognized != nil { @@ -17975,44 +17585,21 @@ func (m *GetDCLocationInfoResponse) Size() (n int) { return n } -func (m *QueryStats) Size() (n int) { +func (m *GetRegionByIDRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.GC != 0 { - n += 1 + sovPdpb(uint64(m.GC)) - } - if m.Get != 0 { - n += 1 + sovPdpb(uint64(m.Get)) - } - if m.Scan != 0 { - n += 1 + sovPdpb(uint64(m.Scan)) - } - if m.Coprocessor != 0 { - n += 1 + sovPdpb(uint64(m.Coprocessor)) - } - if m.Delete != 0 { - n += 1 + sovPdpb(uint64(m.Delete)) - } - if m.DeleteRange != 0 { - n += 1 + sovPdpb(uint64(m.DeleteRange)) - } - if m.Put != 0 { - n += 1 + sovPdpb(uint64(m.Put)) - } - if m.Prewrite != 0 { - n += 1 + sovPdpb(uint64(m.Prewrite)) - } - if m.AcquirePessimisticLock != 0 { - n += 1 + sovPdpb(uint64(m.AcquirePessimisticLock)) + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) } - if m.Commit != 0 { - n += 1 + sovPdpb(uint64(m.Commit)) + if m.RegionId != 0 { + n += 1 + sovPdpb(uint64(m.RegionId)) } - if m.Rollback != 0 { - n += 1 + sovPdpb(uint64(m.Rollback)) + if m.NeedBuckets { + n += 2 } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) @@ -18020,7 +17607,7 @@ func (m *QueryStats) Size() (n int) { return n } -func (m *ReportBucketsRequest) Size() (n int) { +func (m *ScanRegionsRequest) Size() (n int) { if m == nil { return 0 } @@ -18030,12 +17617,15 @@ func (m *ReportBucketsRequest) Size() (n int) { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } - if m.RegionEpoch != nil { - l = m.RegionEpoch.Size() + l = len(m.StartKey) + if l > 0 { n += 1 + l + sovPdpb(uint64(l)) } - if m.Buckets != nil { - l = m.Buckets.Size() + if m.Limit != 0 { + n += 1 + sovPdpb(uint64(m.Limit)) + } + l = len(m.EndKey) + if l > 0 { n += 1 + l + sovPdpb(uint64(l)) } if m.XXX_unrecognized != nil { @@ -18044,23 +17634,39 @@ func (m *ReportBucketsRequest) Size() (n int) { return n } -func (m *ReportBucketsResponse) Size() (n int) { +func (m *Region) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.Header != nil { - l = m.Header.Size() + if m.Region != nil { + l = m.Region.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.Leader != nil { + l = m.Leader.Size() n += 1 + l + sovPdpb(uint64(l)) } + if len(m.DownPeers) > 0 { + for _, e := range m.DownPeers { + l = e.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + } + if len(m.PendingPeers) > 0 { + for _, e := range m.PendingPeers { + l = e.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } -func (m *ReportMinResolvedTsRequest) Size() (n int) { +func (m *ScanRegionsResponse) Size() (n int) { if m == nil { return 0 } @@ -18070,11 +17676,23 @@ func (m *ReportMinResolvedTsRequest) Size() (n int) { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } - if m.StoreId != 0 { - n += 1 + sovPdpb(uint64(m.StoreId)) - } - if m.MinResolvedTs != 0 { - n += 1 + sovPdpb(uint64(m.MinResolvedTs)) + if len(m.RegionMetas) > 0 { + for _, e := range m.RegionMetas { + l = e.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + } + if len(m.Leaders) > 0 { + for _, e := range m.Leaders { + l = e.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + } + if len(m.Regions) > 0 { + for _, e := range m.Regions { + l = e.Size() + n += 1 + l + sovPdpb(uint64(l)) + } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) @@ -18082,7 +17700,7 @@ func (m *ReportMinResolvedTsRequest) Size() (n int) { return n } -func (m *ReportMinResolvedTsResponse) Size() (n int) { +func (m *GetClusterConfigRequest) Size() (n int) { if m == nil { return 0 } @@ -18098,7 +17716,7 @@ func (m *ReportMinResolvedTsResponse) Size() (n int) { return n } -func (m *SetExternalTimestampRequest) Size() (n int) { +func (m *GetClusterConfigResponse) Size() (n int) { if m == nil { return 0 } @@ -18108,8 +17726,9 @@ func (m *SetExternalTimestampRequest) Size() (n int) { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } - if m.Timestamp != 0 { - n += 1 + sovPdpb(uint64(m.Timestamp)) + if m.Cluster != nil { + l = m.Cluster.Size() + n += 1 + l + sovPdpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) @@ -18117,7 +17736,27 @@ func (m *SetExternalTimestampRequest) Size() (n int) { return n } -func (m *SetExternalTimestampResponse) Size() (n int) { +func (m *PutClusterConfigRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.Cluster != nil { + l = m.Cluster.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *PutClusterConfigResponse) Size() (n int) { if m == nil { return 0 } @@ -18133,7 +17772,132 @@ func (m *SetExternalTimestampResponse) Size() (n int) { return n } -func (m *GetExternalTimestampRequest) Size() (n int) { +func (m *Member) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Name) + if l > 0 { + n += 1 + l + sovPdpb(uint64(l)) + } + if m.MemberId != 0 { + n += 1 + sovPdpb(uint64(m.MemberId)) + } + if len(m.PeerUrls) > 0 { + for _, s := range m.PeerUrls { + l = len(s) + n += 1 + l + sovPdpb(uint64(l)) + } + } + if len(m.ClientUrls) > 0 { + for _, s := range m.ClientUrls { + l = len(s) + n += 1 + l + sovPdpb(uint64(l)) + } + } + if m.LeaderPriority != 0 { + n += 1 + sovPdpb(uint64(m.LeaderPriority)) + } + l = len(m.DeployPath) + if l > 0 { + n += 1 + l + sovPdpb(uint64(l)) + } + l = len(m.BinaryVersion) + if l > 0 { + n += 1 + l + sovPdpb(uint64(l)) + } + l = len(m.GitHash) + if l > 0 { + n += 1 + l + sovPdpb(uint64(l)) + } + l = len(m.DcLocation) + if l > 0 { + n += 1 + l + sovPdpb(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *GetMembersRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *GetMembersResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if len(m.Members) > 0 { + for _, e := range m.Members { + l = e.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + } + if m.Leader != nil { + l = m.Leader.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.EtcdLeader != nil { + l = m.EtcdLeader.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if len(m.TsoAllocatorLeaders) > 0 { + for k, v := range m.TsoAllocatorLeaders { + _ = k + _ = v + l = 0 + if v != nil { + l = v.Size() + l += 1 + sovPdpb(uint64(l)) + } + mapEntrySize := 1 + len(k) + sovPdpb(uint64(len(k))) + l + n += mapEntrySize + 1 + sovPdpb(uint64(mapEntrySize)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *GetClusterInfoRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *GetClusterInfoResponse) Size() (n int) { if m == nil { return 0 } @@ -18143,38 +17907,3115 @@ func (m *GetExternalTimestampRequest) Size() (n int) { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } + if len(m.ServiceModes) > 0 { + l = 0 + for _, e := range m.ServiceModes { + l += sovPdpb(uint64(e)) + } + n += 1 + sovPdpb(uint64(l)) + l + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *PeerStats) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Peer != nil { + l = m.Peer.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.DownSeconds != 0 { + n += 1 + sovPdpb(uint64(m.DownSeconds)) + } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } - return n -} + return n +} + +func (m *RegionHeartbeatRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.Region != nil { + l = m.Region.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.Leader != nil { + l = m.Leader.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if len(m.DownPeers) > 0 { + for _, e := range m.DownPeers { + l = e.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + } + if len(m.PendingPeers) > 0 { + for _, e := range m.PendingPeers { + l = e.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + } + if m.BytesWritten != 0 { + n += 1 + sovPdpb(uint64(m.BytesWritten)) + } + if m.BytesRead != 0 { + n += 1 + sovPdpb(uint64(m.BytesRead)) + } + if m.KeysWritten != 0 { + n += 1 + sovPdpb(uint64(m.KeysWritten)) + } + if m.KeysRead != 0 { + n += 1 + sovPdpb(uint64(m.KeysRead)) + } + if m.ApproximateSize != 0 { + n += 1 + sovPdpb(uint64(m.ApproximateSize)) + } + if m.Interval != nil { + l = m.Interval.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.ApproximateKeys != 0 { + n += 1 + sovPdpb(uint64(m.ApproximateKeys)) + } + if m.Term != 0 { + n += 1 + sovPdpb(uint64(m.Term)) + } + if m.ReplicationStatus != nil { + l = m.ReplicationStatus.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.QueryStats != nil { + l = m.QueryStats.Size() + n += 2 + l + sovPdpb(uint64(l)) + } + if m.CpuUsage != 0 { + n += 2 + sovPdpb(uint64(m.CpuUsage)) + } + if m.ApproximateKvSize != 0 { + n += 2 + sovPdpb(uint64(m.ApproximateKvSize)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *ChangePeer) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Peer != nil { + l = m.Peer.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.ChangeType != 0 { + n += 1 + sovPdpb(uint64(m.ChangeType)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *ChangePeerV2) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Changes) > 0 { + for _, e := range m.Changes { + l = e.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *TransferLeader) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Peer != nil { + l = m.Peer.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if len(m.Peers) > 0 { + for _, e := range m.Peers { + l = e.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *Merge) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Target != nil { + l = m.Target.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *SplitRegion) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Policy != 0 { + n += 1 + sovPdpb(uint64(m.Policy)) + } + if len(m.Keys) > 0 { + for _, b := range m.Keys { + l = len(b) + n += 1 + l + sovPdpb(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *SwitchWitness) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.PeerId != 0 { + n += 1 + sovPdpb(uint64(m.PeerId)) + } + if m.IsWitness { + n += 2 + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *BatchSwitchWitness) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.SwitchWitnesses) > 0 { + for _, e := range m.SwitchWitnesses { + l = e.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *RegionHeartbeatResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.ChangePeer != nil { + l = m.ChangePeer.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.TransferLeader != nil { + l = m.TransferLeader.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.RegionId != 0 { + n += 1 + sovPdpb(uint64(m.RegionId)) + } + if m.RegionEpoch != nil { + l = m.RegionEpoch.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.TargetPeer != nil { + l = m.TargetPeer.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.Merge != nil { + l = m.Merge.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.SplitRegion != nil { + l = m.SplitRegion.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.ChangePeerV2 != nil { + l = m.ChangePeerV2.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.SwitchWitnesses != nil { + l = m.SwitchWitnesses.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *AskSplitRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.Region != nil { + l = m.Region.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *AskSplitResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.NewRegionId != 0 { + n += 1 + sovPdpb(uint64(m.NewRegionId)) + } + if len(m.NewPeerIds) > 0 { + l = 0 + for _, e := range m.NewPeerIds { + l += sovPdpb(uint64(e)) + } + n += 1 + sovPdpb(uint64(l)) + l + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *ReportSplitRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.Left != nil { + l = m.Left.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.Right != nil { + l = m.Right.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *ReportSplitResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *AskBatchSplitRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.Region != nil { + l = m.Region.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.SplitCount != 0 { + n += 1 + sovPdpb(uint64(m.SplitCount)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *SplitID) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.NewRegionId != 0 { + n += 1 + sovPdpb(uint64(m.NewRegionId)) + } + if len(m.NewPeerIds) > 0 { + l = 0 + for _, e := range m.NewPeerIds { + l += sovPdpb(uint64(e)) + } + n += 1 + sovPdpb(uint64(l)) + l + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *AskBatchSplitResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if len(m.Ids) > 0 { + for _, e := range m.Ids { + l = e.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *ReportBatchSplitRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if len(m.Regions) > 0 { + for _, e := range m.Regions { + l = e.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *ReportBatchSplitResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *TimeInterval) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.StartTimestamp != 0 { + n += 1 + sovPdpb(uint64(m.StartTimestamp)) + } + if m.EndTimestamp != 0 { + n += 1 + sovPdpb(uint64(m.EndTimestamp)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *RecordPair) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Key) + if l > 0 { + n += 1 + l + sovPdpb(uint64(l)) + } + if m.Value != 0 { + n += 1 + sovPdpb(uint64(m.Value)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *PeerStat) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.RegionId != 0 { + n += 1 + sovPdpb(uint64(m.RegionId)) + } + if m.ReadKeys != 0 { + n += 1 + sovPdpb(uint64(m.ReadKeys)) + } + if m.ReadBytes != 0 { + n += 1 + sovPdpb(uint64(m.ReadBytes)) + } + if m.QueryStats != nil { + l = m.QueryStats.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.WrittenKeys != 0 { + n += 1 + sovPdpb(uint64(m.WrittenKeys)) + } + if m.WrittenBytes != 0 { + n += 1 + sovPdpb(uint64(m.WrittenBytes)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *StoreStats) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.StoreId != 0 { + n += 1 + sovPdpb(uint64(m.StoreId)) + } + if m.Capacity != 0 { + n += 1 + sovPdpb(uint64(m.Capacity)) + } + if m.Available != 0 { + n += 1 + sovPdpb(uint64(m.Available)) + } + if m.RegionCount != 0 { + n += 1 + sovPdpb(uint64(m.RegionCount)) + } + if m.SendingSnapCount != 0 { + n += 1 + sovPdpb(uint64(m.SendingSnapCount)) + } + if m.ReceivingSnapCount != 0 { + n += 1 + sovPdpb(uint64(m.ReceivingSnapCount)) + } + if m.StartTime != 0 { + n += 1 + sovPdpb(uint64(m.StartTime)) + } + if m.ApplyingSnapCount != 0 { + n += 1 + sovPdpb(uint64(m.ApplyingSnapCount)) + } + if m.IsBusy { + n += 2 + } + if m.UsedSize != 0 { + n += 1 + sovPdpb(uint64(m.UsedSize)) + } + if m.BytesWritten != 0 { + n += 1 + sovPdpb(uint64(m.BytesWritten)) + } + if m.KeysWritten != 0 { + n += 1 + sovPdpb(uint64(m.KeysWritten)) + } + if m.BytesRead != 0 { + n += 1 + sovPdpb(uint64(m.BytesRead)) + } + if m.KeysRead != 0 { + n += 1 + sovPdpb(uint64(m.KeysRead)) + } + if m.Interval != nil { + l = m.Interval.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if len(m.CpuUsages) > 0 { + for _, e := range m.CpuUsages { + l = e.Size() + n += 2 + l + sovPdpb(uint64(l)) + } + } + if len(m.ReadIoRates) > 0 { + for _, e := range m.ReadIoRates { + l = e.Size() + n += 2 + l + sovPdpb(uint64(l)) + } + } + if len(m.WriteIoRates) > 0 { + for _, e := range m.WriteIoRates { + l = e.Size() + n += 2 + l + sovPdpb(uint64(l)) + } + } + if len(m.OpLatencies) > 0 { + for _, e := range m.OpLatencies { + l = e.Size() + n += 2 + l + sovPdpb(uint64(l)) + } + } + if len(m.PeerStats) > 0 { + for _, e := range m.PeerStats { + l = e.Size() + n += 2 + l + sovPdpb(uint64(l)) + } + } + if m.QueryStats != nil { + l = m.QueryStats.Size() + n += 2 + l + sovPdpb(uint64(l)) + } + if m.SlowScore != 0 { + n += 2 + sovPdpb(uint64(m.SlowScore)) + } + if len(m.DamagedRegionsId) > 0 { + l = 0 + for _, e := range m.DamagedRegionsId { + l += sovPdpb(uint64(e)) + } + n += 2 + sovPdpb(uint64(l)) + l + } + if m.IsApplyBusy { + n += 3 + } + if len(m.SnapshotStats) > 0 { + for _, e := range m.SnapshotStats { + l = e.Size() + n += 2 + l + sovPdpb(uint64(l)) + } + } + if m.SlowTrend != nil { + l = m.SlowTrend.Size() + n += 2 + l + sovPdpb(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *SlowTrend) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.CauseValue != 0 { + n += 9 + } + if m.CauseRate != 0 { + n += 9 + } + if m.ResultValue != 0 { + n += 9 + } + if m.ResultRate != 0 { + n += 9 + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *SnapshotStat) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.RegionId != 0 { + n += 1 + sovPdpb(uint64(m.RegionId)) + } + if m.GenerateDurationSec != 0 { + n += 1 + sovPdpb(uint64(m.GenerateDurationSec)) + } + if m.SendDurationSec != 0 { + n += 1 + sovPdpb(uint64(m.SendDurationSec)) + } + if m.TotalDurationSec != 0 { + n += 1 + sovPdpb(uint64(m.TotalDurationSec)) + } + if m.TransportSize != 0 { + n += 1 + sovPdpb(uint64(m.TransportSize)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *PeerReport) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.RaftState != nil { + l = m.RaftState.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.RegionState != nil { + l = m.RegionState.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.IsForceLeader { + n += 2 + } + if m.HasCommitMerge { + n += 2 + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *StoreReport) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.PeerReports) > 0 { + for _, e := range m.PeerReports { + l = e.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + } + if m.Step != 0 { + n += 1 + sovPdpb(uint64(m.Step)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *StoreHeartbeatRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.Stats != nil { + l = m.Stats.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.StoreReport != nil { + l = m.StoreReport.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.DrAutosyncStatus != nil { + l = m.DrAutosyncStatus.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *DemoteFailedVoters) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.RegionId != 0 { + n += 1 + sovPdpb(uint64(m.RegionId)) + } + if len(m.FailedVoters) > 0 { + for _, e := range m.FailedVoters { + l = e.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *ForceLeader) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.FailedStores) > 0 { + l = 0 + for _, e := range m.FailedStores { + l += sovPdpb(uint64(e)) + } + n += 1 + sovPdpb(uint64(l)) + l + } + if len(m.EnterForceLeaders) > 0 { + l = 0 + for _, e := range m.EnterForceLeaders { + l += sovPdpb(uint64(e)) + } + n += 1 + sovPdpb(uint64(l)) + l + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *RecoveryPlan) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Creates) > 0 { + for _, e := range m.Creates { + l = e.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + } + if len(m.Updates) > 0 { + for _, e := range m.Updates { + l = e.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + } + if len(m.Tombstones) > 0 { + l = 0 + for _, e := range m.Tombstones { + l += sovPdpb(uint64(e)) + } + n += 1 + sovPdpb(uint64(l)) + l + } + if len(m.Demotes) > 0 { + for _, e := range m.Demotes { + l = e.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + } + if m.ForceLeader != nil { + l = m.ForceLeader.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.Step != 0 { + n += 1 + sovPdpb(uint64(m.Step)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *AwakenRegions) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.AbnormalStores) > 0 { + l = 0 + for _, e := range m.AbnormalStores { + l += sovPdpb(uint64(e)) + } + n += 1 + sovPdpb(uint64(l)) + l + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *StoreHeartbeatResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.ReplicationStatus != nil { + l = m.ReplicationStatus.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + l = len(m.ClusterVersion) + if l > 0 { + n += 1 + l + sovPdpb(uint64(l)) + } + if m.RequireDetailedReport { + n += 2 + } + if m.RecoveryPlan != nil { + l = m.RecoveryPlan.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.AwakenRegions != nil { + l = m.AwakenRegions.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *ScatterRegionRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.RegionId != 0 { + n += 1 + sovPdpb(uint64(m.RegionId)) + } + if m.Region != nil { + l = m.Region.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.Leader != nil { + l = m.Leader.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + l = len(m.Group) + if l > 0 { + n += 1 + l + sovPdpb(uint64(l)) + } + if len(m.RegionsId) > 0 { + l = 0 + for _, e := range m.RegionsId { + l += sovPdpb(uint64(e)) + } + n += 1 + sovPdpb(uint64(l)) + l + } + if m.RetryLimit != 0 { + n += 1 + sovPdpb(uint64(m.RetryLimit)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *ScatterRegionResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.FinishedPercentage != 0 { + n += 1 + sovPdpb(uint64(m.FinishedPercentage)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *GetGCSafePointRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *GetGCSafePointResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.SafePoint != 0 { + n += 1 + sovPdpb(uint64(m.SafePoint)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *UpdateGCSafePointRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.SafePoint != 0 { + n += 1 + sovPdpb(uint64(m.SafePoint)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *UpdateGCSafePointResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.NewSafePoint != 0 { + n += 1 + sovPdpb(uint64(m.NewSafePoint)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *UpdateServiceGCSafePointRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + l = len(m.ServiceId) + if l > 0 { + n += 1 + l + sovPdpb(uint64(l)) + } + if m.TTL != 0 { + n += 1 + sovPdpb(uint64(m.TTL)) + } + if m.SafePoint != 0 { + n += 1 + sovPdpb(uint64(m.SafePoint)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *UpdateServiceGCSafePointResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + l = len(m.ServiceId) + if l > 0 { + n += 1 + l + sovPdpb(uint64(l)) + } + if m.TTL != 0 { + n += 1 + sovPdpb(uint64(m.TTL)) + } + if m.MinSafePoint != 0 { + n += 1 + sovPdpb(uint64(m.MinSafePoint)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *GetGCSafePointV2Request) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.KeyspaceId != 0 { + n += 1 + sovPdpb(uint64(m.KeyspaceId)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *GetGCSafePointV2Response) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.SafePoint != 0 { + n += 1 + sovPdpb(uint64(m.SafePoint)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *WatchGCSafePointV2Request) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.Revision != 0 { + n += 1 + sovPdpb(uint64(m.Revision)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *SafePointEvent) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.KeyspaceId != 0 { + n += 1 + sovPdpb(uint64(m.KeyspaceId)) + } + if m.SafePoint != 0 { + n += 1 + sovPdpb(uint64(m.SafePoint)) + } + if m.Type != 0 { + n += 1 + sovPdpb(uint64(m.Type)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *WatchGCSafePointV2Response) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if len(m.Events) > 0 { + for _, e := range m.Events { + l = e.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + } + if m.Revision != 0 { + n += 1 + sovPdpb(uint64(m.Revision)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *UpdateGCSafePointV2Request) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.KeyspaceId != 0 { + n += 1 + sovPdpb(uint64(m.KeyspaceId)) + } + if m.SafePoint != 0 { + n += 1 + sovPdpb(uint64(m.SafePoint)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *UpdateGCSafePointV2Response) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.NewSafePoint != 0 { + n += 1 + sovPdpb(uint64(m.NewSafePoint)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *UpdateServiceSafePointV2Request) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.KeyspaceId != 0 { + n += 1 + sovPdpb(uint64(m.KeyspaceId)) + } + l = len(m.ServiceId) + if l > 0 { + n += 1 + l + sovPdpb(uint64(l)) + } + if m.SafePoint != 0 { + n += 1 + sovPdpb(uint64(m.SafePoint)) + } + if m.Ttl != 0 { + n += 1 + sovPdpb(uint64(m.Ttl)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *UpdateServiceSafePointV2Response) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + l = len(m.ServiceId) + if l > 0 { + n += 1 + l + sovPdpb(uint64(l)) + } + if m.Ttl != 0 { + n += 1 + sovPdpb(uint64(m.Ttl)) + } + if m.MinSafePoint != 0 { + n += 1 + sovPdpb(uint64(m.MinSafePoint)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *RegionStat) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.BytesWritten != 0 { + n += 1 + sovPdpb(uint64(m.BytesWritten)) + } + if m.BytesRead != 0 { + n += 1 + sovPdpb(uint64(m.BytesRead)) + } + if m.KeysWritten != 0 { + n += 1 + sovPdpb(uint64(m.KeysWritten)) + } + if m.KeysRead != 0 { + n += 1 + sovPdpb(uint64(m.KeysRead)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *SyncRegionRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.Member != nil { + l = m.Member.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.StartIndex != 0 { + n += 1 + sovPdpb(uint64(m.StartIndex)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *PeersStats) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Peers) > 0 { + for _, e := range m.Peers { + l = e.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *Peers) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Peers) > 0 { + for _, e := range m.Peers { + l = e.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *SyncRegionResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if len(m.Regions) > 0 { + for _, e := range m.Regions { + l = e.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + } + if m.StartIndex != 0 { + n += 1 + sovPdpb(uint64(m.StartIndex)) + } + if len(m.RegionStats) > 0 { + for _, e := range m.RegionStats { + l = e.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + } + if len(m.RegionLeaders) > 0 { + for _, e := range m.RegionLeaders { + l = e.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + } + if len(m.Buckets) > 0 { + for _, e := range m.Buckets { + l = e.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + } + if len(m.DownPeers) > 0 { + for _, e := range m.DownPeers { + l = e.Size() + n += 2 + l + sovPdpb(uint64(l)) + } + } + if len(m.PendingPeers) > 0 { + for _, e := range m.PendingPeers { + l = e.Size() + n += 2 + l + sovPdpb(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *GetOperatorRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.RegionId != 0 { + n += 1 + sovPdpb(uint64(m.RegionId)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *GetOperatorResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.RegionId != 0 { + n += 1 + sovPdpb(uint64(m.RegionId)) + } + l = len(m.Desc) + if l > 0 { + n += 1 + l + sovPdpb(uint64(l)) + } + if m.Status != 0 { + n += 1 + sovPdpb(uint64(m.Status)) + } + l = len(m.Kind) + if l > 0 { + n += 1 + l + sovPdpb(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *SyncMaxTSRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.MaxTs != nil { + l = m.MaxTs.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.SkipCheck { + n += 2 + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *SyncMaxTSResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.MaxLocalTs != nil { + l = m.MaxLocalTs.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if len(m.SyncedDcs) > 0 { + for _, s := range m.SyncedDcs { + l = len(s) + n += 1 + l + sovPdpb(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *SplitRegionsRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if len(m.SplitKeys) > 0 { + for _, b := range m.SplitKeys { + l = len(b) + n += 1 + l + sovPdpb(uint64(l)) + } + } + if m.RetryLimit != 0 { + n += 1 + sovPdpb(uint64(m.RetryLimit)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *SplitRegionsResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.FinishedPercentage != 0 { + n += 1 + sovPdpb(uint64(m.FinishedPercentage)) + } + if len(m.RegionsId) > 0 { + l = 0 + for _, e := range m.RegionsId { + l += sovPdpb(uint64(e)) + } + n += 1 + sovPdpb(uint64(l)) + l + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *SplitAndScatterRegionsRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if len(m.SplitKeys) > 0 { + for _, b := range m.SplitKeys { + l = len(b) + n += 1 + l + sovPdpb(uint64(l)) + } + } + l = len(m.Group) + if l > 0 { + n += 1 + l + sovPdpb(uint64(l)) + } + if m.RetryLimit != 0 { + n += 1 + sovPdpb(uint64(m.RetryLimit)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *SplitAndScatterRegionsResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.SplitFinishedPercentage != 0 { + n += 1 + sovPdpb(uint64(m.SplitFinishedPercentage)) + } + if m.ScatterFinishedPercentage != 0 { + n += 1 + sovPdpb(uint64(m.ScatterFinishedPercentage)) + } + if len(m.RegionsId) > 0 { + l = 0 + for _, e := range m.RegionsId { + l += sovPdpb(uint64(e)) + } + n += 1 + sovPdpb(uint64(l)) + l + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *GetDCLocationInfoRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + l = len(m.DcLocation) + if l > 0 { + n += 1 + l + sovPdpb(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *GetDCLocationInfoResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.Suffix != 0 { + n += 1 + sovPdpb(uint64(m.Suffix)) + } + if m.MaxTs != nil { + l = m.MaxTs.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *QueryStats) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.GC != 0 { + n += 1 + sovPdpb(uint64(m.GC)) + } + if m.Get != 0 { + n += 1 + sovPdpb(uint64(m.Get)) + } + if m.Scan != 0 { + n += 1 + sovPdpb(uint64(m.Scan)) + } + if m.Coprocessor != 0 { + n += 1 + sovPdpb(uint64(m.Coprocessor)) + } + if m.Delete != 0 { + n += 1 + sovPdpb(uint64(m.Delete)) + } + if m.DeleteRange != 0 { + n += 1 + sovPdpb(uint64(m.DeleteRange)) + } + if m.Put != 0 { + n += 1 + sovPdpb(uint64(m.Put)) + } + if m.Prewrite != 0 { + n += 1 + sovPdpb(uint64(m.Prewrite)) + } + if m.AcquirePessimisticLock != 0 { + n += 1 + sovPdpb(uint64(m.AcquirePessimisticLock)) + } + if m.Commit != 0 { + n += 1 + sovPdpb(uint64(m.Commit)) + } + if m.Rollback != 0 { + n += 1 + sovPdpb(uint64(m.Rollback)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *ReportBucketsRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.RegionEpoch != nil { + l = m.RegionEpoch.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.Buckets != nil { + l = m.Buckets.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *ReportBucketsResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *ReportMinResolvedTsRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.StoreId != 0 { + n += 1 + sovPdpb(uint64(m.StoreId)) + } + if m.MinResolvedTs != 0 { + n += 1 + sovPdpb(uint64(m.MinResolvedTs)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *ReportMinResolvedTsResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *SetExternalTimestampRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.Timestamp != 0 { + n += 1 + sovPdpb(uint64(m.Timestamp)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *SetExternalTimestampResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *GetExternalTimestampRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *GetExternalTimestampResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.Timestamp != 0 { + n += 1 + sovPdpb(uint64(m.Timestamp)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *GetMinTSRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *GetMinTSResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.Timestamp != nil { + l = m.Timestamp.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func sovPdpb(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozPdpb(x uint64) (n int) { + return sovPdpb(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *WatchGlobalConfigRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: WatchGlobalConfigRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: WatchGlobalConfigRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ConfigPath", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthPdpb + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthPdpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ConfigPath = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Revision", wireType) + } + m.Revision = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Revision |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipPdpb(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthPdpb + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *WatchGlobalConfigResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: WatchGlobalConfigResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: WatchGlobalConfigResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Changes", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthPdpb + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthPdpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Changes = append(m.Changes, &GlobalConfigItem{}) + if err := m.Changes[len(m.Changes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Revision", wireType) + } + m.Revision = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Revision |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthPdpb + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthPdpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Header == nil { + m.Header = &ResponseHeader{} + } + if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipPdpb(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthPdpb + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *StoreGlobalConfigRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: StoreGlobalConfigRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: StoreGlobalConfigRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Changes", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthPdpb + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthPdpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Changes = append(m.Changes, &GlobalConfigItem{}) + if err := m.Changes[len(m.Changes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ConfigPath", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthPdpb + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthPdpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ConfigPath = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipPdpb(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthPdpb + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *StoreGlobalConfigResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: StoreGlobalConfigResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: StoreGlobalConfigResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthPdpb + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthPdpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Error == nil { + m.Error = &Error{} + } + if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipPdpb(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthPdpb + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *LoadGlobalConfigRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: LoadGlobalConfigRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: LoadGlobalConfigRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Names", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthPdpb + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthPdpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Names = append(m.Names, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ConfigPath", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthPdpb + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthPdpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ConfigPath = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipPdpb(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthPdpb + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *LoadGlobalConfigResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: LoadGlobalConfigResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: LoadGlobalConfigResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthPdpb + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthPdpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Items = append(m.Items, &GlobalConfigItem{}) + if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Revision", wireType) + } + m.Revision = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Revision |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipPdpb(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthPdpb + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *GlobalConfigItem) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: GlobalConfigItem: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GlobalConfigItem: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthPdpb + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthPdpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthPdpb + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthPdpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Value = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthPdpb + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthPdpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Error == nil { + m.Error = &Error{} + } + if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType) + } + m.Kind = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Kind |= EventType(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Payload", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthPdpb + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthPdpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Payload = append(m.Payload[:0], dAtA[iNdEx:postIndex]...) + if m.Payload == nil { + m.Payload = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipPdpb(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthPdpb + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *RequestHeader) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: RequestHeader: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RequestHeader: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ClusterId", wireType) + } + m.ClusterId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ClusterId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field SenderId", wireType) + } + m.SenderId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.SenderId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipPdpb(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthPdpb + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ResponseHeader) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ResponseHeader: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ResponseHeader: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ClusterId", wireType) + } + m.ClusterId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ClusterId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthPdpb + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthPdpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Error == nil { + m.Error = &Error{} + } + if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipPdpb(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthPdpb + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Error) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Error: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) + } + m.Type = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Type |= ErrorType(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthPdpb + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthPdpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Message = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipPdpb(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthPdpb + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } -func (m *GetExternalTimestampResponse) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Header != nil { - l = m.Header.Size() - n += 1 + l + sovPdpb(uint64(l)) - } - if m.Timestamp != 0 { - n += 1 + sovPdpb(uint64(m.Timestamp)) - } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + if iNdEx > l { + return io.ErrUnexpectedEOF } - return n -} - -func sovPdpb(x uint64) (n int) { - return (math_bits.Len64(x|1) + 6) / 7 -} -func sozPdpb(x uint64) (n int) { - return sovPdpb(uint64((x << 1) ^ uint64((int64(x) >> 63)))) + return nil } -func (m *WatchGlobalConfigRequest) Unmarshal(dAtA []byte) error { +func (m *TsoRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -18197,15 +21038,70 @@ func (m *WatchGlobalConfigRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: WatchGlobalConfigRequest: wiretype end group for non-group") + return fmt.Errorf("proto: TsoRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: WatchGlobalConfigRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: TsoRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ConfigPath", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthPdpb + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthPdpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Header == nil { + m.Header = &RequestHeader{} + } + if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Count", wireType) + } + m.Count = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Count |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DcLocation", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -18233,13 +21129,83 @@ func (m *WatchGlobalConfigRequest) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.ConfigPath = string(dAtA[iNdEx:postIndex]) + m.DcLocation = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipPdpb(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthPdpb + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Timestamp) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Timestamp: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Timestamp: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Physical", wireType) + } + m.Physical = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Physical |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } case 2: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Revision", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Logical", wireType) } - m.Revision = 0 + m.Logical = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -18249,7 +21215,26 @@ func (m *WatchGlobalConfigRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Revision |= int64(b&0x7F) << shift + m.Logical |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field SuffixBits", wireType) + } + m.SuffixBits = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.SuffixBits |= uint32(b&0x7F) << shift if b < 0x80 { break } @@ -18276,7 +21261,7 @@ func (m *WatchGlobalConfigRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *WatchGlobalConfigResponse) Unmarshal(dAtA []byte) error { +func (m *TsoResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -18299,15 +21284,15 @@ func (m *WatchGlobalConfigResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: WatchGlobalConfigResponse: wiretype end group for non-group") + return fmt.Errorf("proto: TsoResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: WatchGlobalConfigResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: TsoResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Changes", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -18334,16 +21319,18 @@ func (m *WatchGlobalConfigResponse) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Changes = append(m.Changes, &GlobalConfigItem{}) - if err := m.Changes[len(m.Changes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if m.Header == nil { + m.Header = &ResponseHeader{} + } + if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Revision", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Count", wireType) } - m.Revision = 0 + m.Count = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -18353,14 +21340,14 @@ func (m *WatchGlobalConfigResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Revision |= int64(b&0x7F) << shift + m.Count |= uint32(b&0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -18387,10 +21374,10 @@ func (m *WatchGlobalConfigResponse) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Header == nil { - m.Header = &ResponseHeader{} + if m.Timestamp == nil { + m.Timestamp = &Timestamp{} } - if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Timestamp.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -18416,7 +21403,7 @@ func (m *WatchGlobalConfigResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *StoreGlobalConfigRequest) Unmarshal(dAtA []byte) error { +func (m *BootstrapRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -18439,15 +21426,15 @@ func (m *StoreGlobalConfigRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: StoreGlobalConfigRequest: wiretype end group for non-group") + return fmt.Errorf("proto: BootstrapRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: StoreGlobalConfigRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: BootstrapRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Changes", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -18474,16 +21461,18 @@ func (m *StoreGlobalConfigRequest) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Changes = append(m.Changes, &GlobalConfigItem{}) - if err := m.Changes[len(m.Changes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if m.Header == nil { + m.Header = &RequestHeader{} + } + if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ConfigPath", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Store", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -18493,78 +21482,31 @@ func (m *StoreGlobalConfigRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + if msglen < 0 { return ErrInvalidLengthPdpb } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthPdpb } if postIndex > l { return io.ErrUnexpectedEOF } - m.ConfigPath = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipPdpb(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthPdpb - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *StoreGlobalConfigResponse) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF + if m.Store == nil { + m.Store = &metapb.Store{} } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break + if err := m.Store.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: StoreGlobalConfigResponse: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: StoreGlobalConfigResponse: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + iNdEx = postIndex + case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Region", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -18591,10 +21533,10 @@ func (m *StoreGlobalConfigResponse) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Error == nil { - m.Error = &Error{} + if m.Region == nil { + m.Region = &metapb.Region{} } - if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Region.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -18620,7 +21562,7 @@ func (m *StoreGlobalConfigResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *LoadGlobalConfigRequest) Unmarshal(dAtA []byte) error { +func (m *BootstrapResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -18643,17 +21585,17 @@ func (m *LoadGlobalConfigRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: LoadGlobalConfigRequest: wiretype end group for non-group") + return fmt.Errorf("proto: BootstrapResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: LoadGlobalConfigRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: BootstrapResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Names", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -18663,29 +21605,33 @@ func (m *LoadGlobalConfigRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + if msglen < 0 { return ErrInvalidLengthPdpb } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthPdpb } if postIndex > l { return io.ErrUnexpectedEOF } - m.Names = append(m.Names, string(dAtA[iNdEx:postIndex])) + if m.Header == nil { + m.Header = &ResponseHeader{} + } + if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ConfigPath", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ReplicationStatus", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -18695,23 +21641,27 @@ func (m *LoadGlobalConfigRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + if msglen < 0 { return ErrInvalidLengthPdpb } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthPdpb } if postIndex > l { return io.ErrUnexpectedEOF } - m.ConfigPath = string(dAtA[iNdEx:postIndex]) + if m.ReplicationStatus == nil { + m.ReplicationStatus = &replication_modepb.ReplicationStatus{} + } + if err := m.ReplicationStatus.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } iNdEx = postIndex default: iNdEx = preIndex @@ -18735,7 +21685,7 @@ func (m *LoadGlobalConfigRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *LoadGlobalConfigResponse) Unmarshal(dAtA []byte) error { +func (m *IsBootstrappedRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -18758,15 +21708,15 @@ func (m *LoadGlobalConfigResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: LoadGlobalConfigResponse: wiretype end group for non-group") + return fmt.Errorf("proto: IsBootstrappedRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: LoadGlobalConfigResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: IsBootstrappedRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -18793,30 +21743,13 @@ func (m *LoadGlobalConfigResponse) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Items = append(m.Items, &GlobalConfigItem{}) - if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if m.Header == nil { + m.Header = &RequestHeader{} + } + if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Revision", wireType) - } - m.Revision = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.Revision |= int64(b&0x7F) << shift - if b < 0x80 { - break - } - } default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) @@ -18839,7 +21772,7 @@ func (m *LoadGlobalConfigResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *GlobalConfigItem) Unmarshal(dAtA []byte) error { +func (m *IsBootstrappedResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -18862,79 +21795,15 @@ func (m *GlobalConfigItem) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: GlobalConfigItem: wiretype end group for non-group") + return fmt.Errorf("proto: IsBootstrappedResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: GlobalConfigItem: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: IsBootstrappedResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - stringLen |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthPdpb - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthPdpb - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Name = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - stringLen |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthPdpb - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthPdpb - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Value = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -18961,18 +21830,18 @@ func (m *GlobalConfigItem) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Error == nil { - m.Error = &Error{} + if m.Header == nil { + m.Header = &ResponseHeader{} } - if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 4: + case 2: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Bootstrapped", wireType) } - m.Kind = 0 + var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -18982,16 +21851,68 @@ func (m *GlobalConfigItem) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Kind |= EventType(b&0x7F) << shift + v |= int(b&0x7F) << shift if b < 0x80 { break } } - case 5: + m.Bootstrapped = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := skipPdpb(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthPdpb + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AllocIDRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AllocIDRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AllocIDRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Payload", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } - var byteLen int + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -19001,24 +21922,26 @@ func (m *GlobalConfigItem) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= int(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { + if msglen < 0 { return ErrInvalidLengthPdpb } - postIndex := iNdEx + byteLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthPdpb } if postIndex > l { return io.ErrUnexpectedEOF } - m.Payload = append(m.Payload[:0], dAtA[iNdEx:postIndex]...) - if m.Payload == nil { - m.Payload = []byte{} + if m.Header == nil { + m.Header = &RequestHeader{} + } + if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } iNdEx = postIndex default: @@ -19043,7 +21966,7 @@ func (m *GlobalConfigItem) Unmarshal(dAtA []byte) error { } return nil } -func (m *RequestHeader) Unmarshal(dAtA []byte) error { +func (m *AllocIDResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -19066,17 +21989,17 @@ func (m *RequestHeader) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: RequestHeader: wiretype end group for non-group") + return fmt.Errorf("proto: AllocIDResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: RequestHeader: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: AllocIDResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field ClusterId", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } - m.ClusterId = 0 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -19086,16 +22009,33 @@ func (m *RequestHeader) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.ClusterId |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } + if msglen < 0 { + return ErrInvalidLengthPdpb + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthPdpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Header == nil { + m.Header = &ResponseHeader{} + } + if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex case 2: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field SenderId", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) } - m.SenderId = 0 + m.Id = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -19105,7 +22045,7 @@ func (m *RequestHeader) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.SenderId |= uint64(b&0x7F) << shift + m.Id |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -19132,7 +22072,7 @@ func (m *RequestHeader) Unmarshal(dAtA []byte) error { } return nil } -func (m *ResponseHeader) Unmarshal(dAtA []byte) error { +func (m *IsSnapshotRecoveringRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -19155,34 +22095,15 @@ func (m *ResponseHeader) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: ResponseHeader: wiretype end group for non-group") + return fmt.Errorf("proto: IsSnapshotRecoveringRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: ResponseHeader: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: IsSnapshotRecoveringRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field ClusterId", wireType) - } - m.ClusterId = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.ClusterId |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -19209,10 +22130,10 @@ func (m *ResponseHeader) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Error == nil { - m.Error = &Error{} + if m.Header == nil { + m.Header = &RequestHeader{} } - if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -19238,7 +22159,7 @@ func (m *ResponseHeader) Unmarshal(dAtA []byte) error { } return nil } -func (m *Error) Unmarshal(dAtA []byte) error { +func (m *IsSnapshotRecoveringResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -19261,17 +22182,17 @@ func (m *Error) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: Error: wiretype end group for non-group") + return fmt.Errorf("proto: IsSnapshotRecoveringResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: IsSnapshotRecoveringResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } - m.Type = 0 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -19281,16 +22202,33 @@ func (m *Error) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Type |= ErrorType(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } + if msglen < 0 { + return ErrInvalidLengthPdpb + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthPdpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Header == nil { + m.Header = &ResponseHeader{} + } + if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Marked", wireType) } - var stringLen uint64 + var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -19300,24 +22238,12 @@ func (m *Error) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + v |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthPdpb - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthPdpb - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Message = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex + m.Marked = bool(v != 0) default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) @@ -19340,7 +22266,7 @@ func (m *Error) Unmarshal(dAtA []byte) error { } return nil } -func (m *TsoRequest) Unmarshal(dAtA []byte) error { +func (m *GetStoreRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -19363,10 +22289,10 @@ func (m *TsoRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: TsoRequest: wiretype end group for non-group") + return fmt.Errorf("proto: GetStoreRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: TsoRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: GetStoreRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -19407,55 +22333,23 @@ func (m *TsoRequest) Unmarshal(dAtA []byte) error { iNdEx = postIndex case 2: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Count", wireType) - } - m.Count = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.Count |= uint32(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field DcLocation", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field StoreId", wireType) } - var stringLen uint64 + m.StoreId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - stringLen |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthPdpb - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthPdpb - } - if postIndex > l { - return io.ErrUnexpectedEOF + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.StoreId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } } - m.DcLocation = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) @@ -19478,7 +22372,7 @@ func (m *TsoRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *Timestamp) Unmarshal(dAtA []byte) error { +func (m *GetStoreResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -19501,17 +22395,17 @@ func (m *Timestamp) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: Timestamp: wiretype end group for non-group") + return fmt.Errorf("proto: GetStoreResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: Timestamp: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: GetStoreResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Physical", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } - m.Physical = 0 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -19521,16 +22415,33 @@ func (m *Timestamp) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Physical |= int64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } + if msglen < 0 { + return ErrInvalidLengthPdpb + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthPdpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Header == nil { + m.Header = &ResponseHeader{} + } + if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Logical", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Store", wireType) } - m.Logical = 0 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -19540,16 +22451,33 @@ func (m *Timestamp) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Logical |= int64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } + if msglen < 0 { + return ErrInvalidLengthPdpb + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthPdpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Store == nil { + m.Store = &metapb.Store{} + } + if err := m.Store.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex case 3: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field SuffixBits", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Stats", wireType) } - m.SuffixBits = 0 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -19559,11 +22487,28 @@ func (m *Timestamp) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.SuffixBits |= uint32(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } + if msglen < 0 { + return ErrInvalidLengthPdpb + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthPdpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Stats == nil { + m.Stats = &StoreStats{} + } + if err := m.Stats.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) @@ -19586,7 +22531,7 @@ func (m *Timestamp) Unmarshal(dAtA []byte) error { } return nil } -func (m *TsoResponse) Unmarshal(dAtA []byte) error { +func (m *PutStoreRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -19609,10 +22554,10 @@ func (m *TsoResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: TsoResponse: wiretype end group for non-group") + return fmt.Errorf("proto: PutStoreRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: TsoResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: PutStoreRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -19645,34 +22590,15 @@ func (m *TsoResponse) Unmarshal(dAtA []byte) error { return io.ErrUnexpectedEOF } if m.Header == nil { - m.Header = &ResponseHeader{} + m.Header = &RequestHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Count", wireType) - } - m.Count = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.Count |= uint32(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Store", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -19699,10 +22625,10 @@ func (m *TsoResponse) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Timestamp == nil { - m.Timestamp = &Timestamp{} + if m.Store == nil { + m.Store = &metapb.Store{} } - if err := m.Timestamp.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Store.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -19728,7 +22654,7 @@ func (m *TsoResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *BootstrapRequest) Unmarshal(dAtA []byte) error { +func (m *PutStoreResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -19751,10 +22677,10 @@ func (m *BootstrapRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: BootstrapRequest: wiretype end group for non-group") + return fmt.Errorf("proto: PutStoreResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: BootstrapRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: PutStoreResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -19787,7 +22713,7 @@ func (m *BootstrapRequest) Unmarshal(dAtA []byte) error { return io.ErrUnexpectedEOF } if m.Header == nil { - m.Header = &RequestHeader{} + m.Header = &ResponseHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err @@ -19795,43 +22721,7 @@ func (m *BootstrapRequest) Unmarshal(dAtA []byte) error { iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Store", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthPdpb - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthPdpb - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Store == nil { - m.Store = &metapb.Store{} - } - if err := m.Store.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Region", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ReplicationStatus", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -19858,10 +22748,10 @@ func (m *BootstrapRequest) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Region == nil { - m.Region = &metapb.Region{} + if m.ReplicationStatus == nil { + m.ReplicationStatus = &replication_modepb.ReplicationStatus{} } - if err := m.Region.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.ReplicationStatus.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -19887,7 +22777,7 @@ func (m *BootstrapRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *BootstrapResponse) Unmarshal(dAtA []byte) error { +func (m *GetAllStoresRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -19910,10 +22800,10 @@ func (m *BootstrapResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: BootstrapResponse: wiretype end group for non-group") + return fmt.Errorf("proto: GetAllStoresRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: BootstrapResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: GetAllStoresRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -19946,17 +22836,17 @@ func (m *BootstrapResponse) Unmarshal(dAtA []byte) error { return io.ErrUnexpectedEOF } if m.Header == nil { - m.Header = &ResponseHeader{} + m.Header = &RequestHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ReplicationStatus", wireType) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ExcludeTombstoneStores", wireType) } - var msglen int + var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -19966,28 +22856,12 @@ func (m *BootstrapResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + v |= int(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { - return ErrInvalidLengthPdpb - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthPdpb - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.ReplicationStatus == nil { - m.ReplicationStatus = &replication_modepb.ReplicationStatus{} - } - if err := m.ReplicationStatus.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex + m.ExcludeTombstoneStores = bool(v != 0) default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) @@ -20010,7 +22884,7 @@ func (m *BootstrapResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *IsBootstrappedRequest) Unmarshal(dAtA []byte) error { +func (m *GetAllStoresResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -20029,19 +22903,55 @@ func (m *IsBootstrappedRequest) Unmarshal(dAtA []byte) error { if b < 0x80 { break } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: IsBootstrappedRequest: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: IsBootstrappedRequest: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: GetAllStoresResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GetAllStoresResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthPdpb + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthPdpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Header == nil { + m.Header = &ResponseHeader{} + } + if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Stores", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -20068,10 +22978,8 @@ func (m *IsBootstrappedRequest) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Header == nil { - m.Header = &RequestHeader{} - } - if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.Stores = append(m.Stores, &metapb.Store{}) + if err := m.Stores[len(m.Stores)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -20097,7 +23005,7 @@ func (m *IsBootstrappedRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *IsBootstrappedResponse) Unmarshal(dAtA []byte) error { +func (m *GetRegionRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -20120,10 +23028,10 @@ func (m *IsBootstrappedResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: IsBootstrappedResponse: wiretype end group for non-group") + return fmt.Errorf("proto: GetRegionRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: IsBootstrappedResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: GetRegionRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -20156,15 +23064,49 @@ func (m *IsBootstrappedResponse) Unmarshal(dAtA []byte) error { return io.ErrUnexpectedEOF } if m.Header == nil { - m.Header = &ResponseHeader{} + m.Header = &RequestHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RegionKey", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthPdpb + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthPdpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.RegionKey = append(m.RegionKey[:0], dAtA[iNdEx:postIndex]...) + if m.RegionKey == nil { + m.RegionKey = []byte{} + } + iNdEx = postIndex + case 3: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Bootstrapped", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field NeedBuckets", wireType) } var v int for shift := uint(0); ; shift += 7 { @@ -20181,7 +23123,7 @@ func (m *IsBootstrappedResponse) Unmarshal(dAtA []byte) error { break } } - m.Bootstrapped = bool(v != 0) + m.NeedBuckets = bool(v != 0) default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) @@ -20204,7 +23146,7 @@ func (m *IsBootstrappedResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *AllocIDRequest) Unmarshal(dAtA []byte) error { +func (m *GetRegionResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -20227,10 +23169,10 @@ func (m *AllocIDRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: AllocIDRequest: wiretype end group for non-group") + return fmt.Errorf("proto: GetRegionResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: AllocIDRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: GetRegionResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -20263,66 +23205,51 @@ func (m *AllocIDRequest) Unmarshal(dAtA []byte) error { return io.ErrUnexpectedEOF } if m.Header == nil { - m.Header = &RequestHeader{} + m.Header = &ResponseHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipPdpb(dAtA[iNdEx:]) - if err != nil { - return err + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Region", wireType) } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthPdpb + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF + if msglen < 0 { + return ErrInvalidLengthPdpb } - m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *AllocIDResponse) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthPdpb } - if iNdEx >= l { + if postIndex > l { return io.ErrUnexpectedEOF } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break + if m.Region == nil { + m.Region = &metapb.Region{} } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: AllocIDResponse: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: AllocIDResponse: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + if err := m.Region.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Leader", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -20349,18 +23276,18 @@ func (m *AllocIDResponse) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Header == nil { - m.Header = &ResponseHeader{} + if m.Leader == nil { + m.Leader = &metapb.Peer{} } - if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Leader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DownPeers", wireType) } - m.Id = 0 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -20370,65 +23297,63 @@ func (m *AllocIDResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Id |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - default: - iNdEx = preIndex - skippy, err := skipPdpb(dAtA[iNdEx:]) - if err != nil { - return err + if msglen < 0 { + return ErrInvalidLengthPdpb } - if (skippy < 0) || (iNdEx+skippy) < 0 { + postIndex := iNdEx + msglen + if postIndex < 0 { return ErrInvalidLengthPdpb } - if (iNdEx + skippy) > l { + if postIndex > l { return io.ErrUnexpectedEOF } - m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *IsSnapshotRecoveringRequest) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb + m.DownPeers = append(m.DownPeers, &PeerStats{}) + if err := m.DownPeers[len(m.DownPeers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } - if iNdEx >= l { + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PendingPeers", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthPdpb + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthPdpb + } + if postIndex > l { return io.ErrUnexpectedEOF } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break + m.PendingPeers = append(m.PendingPeers, &metapb.Peer{}) + if err := m.PendingPeers[len(m.PendingPeers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: IsSnapshotRecoveringRequest: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: IsSnapshotRecoveringRequest: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + iNdEx = postIndex + case 7: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Buckets", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -20455,10 +23380,10 @@ func (m *IsSnapshotRecoveringRequest) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Header == nil { - m.Header = &RequestHeader{} + if m.Buckets == nil { + m.Buckets = &metapb.Buckets{} } - if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Buckets.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -20484,7 +23409,7 @@ func (m *IsSnapshotRecoveringRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *IsSnapshotRecoveringResponse) Unmarshal(dAtA []byte) error { +func (m *GetRegionByIDRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -20507,10 +23432,10 @@ func (m *IsSnapshotRecoveringResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: IsSnapshotRecoveringResponse: wiretype end group for non-group") + return fmt.Errorf("proto: GetRegionByIDRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: IsSnapshotRecoveringResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: GetRegionByIDRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -20543,7 +23468,7 @@ func (m *IsSnapshotRecoveringResponse) Unmarshal(dAtA []byte) error { return io.ErrUnexpectedEOF } if m.Header == nil { - m.Header = &ResponseHeader{} + m.Header = &RequestHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err @@ -20551,7 +23476,26 @@ func (m *IsSnapshotRecoveringResponse) Unmarshal(dAtA []byte) error { iNdEx = postIndex case 2: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Marked", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field RegionId", wireType) + } + m.RegionId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.RegionId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field NeedBuckets", wireType) } var v int for shift := uint(0); ; shift += 7 { @@ -20568,7 +23512,7 @@ func (m *IsSnapshotRecoveringResponse) Unmarshal(dAtA []byte) error { break } } - m.Marked = bool(v != 0) + m.NeedBuckets = bool(v != 0) default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) @@ -20591,7 +23535,7 @@ func (m *IsSnapshotRecoveringResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *GetStoreRequest) Unmarshal(dAtA []byte) error { +func (m *ScanRegionsRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -20614,10 +23558,10 @@ func (m *GetStoreRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: GetStoreRequest: wiretype end group for non-group") + return fmt.Errorf("proto: ScanRegionsRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: GetStoreRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: ScanRegionsRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -20657,10 +23601,44 @@ func (m *GetStoreRequest) Unmarshal(dAtA []byte) error { } iNdEx = postIndex case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StartKey", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthPdpb + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthPdpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.StartKey = append(m.StartKey[:0], dAtA[iNdEx:postIndex]...) + if m.StartKey == nil { + m.StartKey = []byte{} + } + iNdEx = postIndex + case 3: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field StoreId", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType) } - m.StoreId = 0 + m.Limit = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -20670,11 +23648,45 @@ func (m *GetStoreRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.StoreId |= uint64(b&0x7F) << shift + m.Limit |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EndKey", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } + if byteLen < 0 { + return ErrInvalidLengthPdpb + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthPdpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.EndKey = append(m.EndKey[:0], dAtA[iNdEx:postIndex]...) + if m.EndKey == nil { + m.EndKey = []byte{} + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) @@ -20697,7 +23709,7 @@ func (m *GetStoreRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *GetStoreResponse) Unmarshal(dAtA []byte) error { +func (m *Region) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -20720,15 +23732,15 @@ func (m *GetStoreResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: GetStoreResponse: wiretype end group for non-group") + return fmt.Errorf("proto: Region: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: GetStoreResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: Region: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Region", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -20755,16 +23767,16 @@ func (m *GetStoreResponse) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Header == nil { - m.Header = &ResponseHeader{} + if m.Region == nil { + m.Region = &metapb.Region{} } - if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Region.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Store", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Leader", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -20791,16 +23803,16 @@ func (m *GetStoreResponse) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Store == nil { - m.Store = &metapb.Store{} + if m.Leader == nil { + m.Leader = &metapb.Peer{} } - if err := m.Store.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Leader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Stats", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field DownPeers", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -20827,10 +23839,42 @@ func (m *GetStoreResponse) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Stats == nil { - m.Stats = &StoreStats{} + m.DownPeers = append(m.DownPeers, &PeerStats{}) + if err := m.DownPeers[len(m.DownPeers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } - if err := m.Stats.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PendingPeers", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthPdpb + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthPdpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.PendingPeers = append(m.PendingPeers, &metapb.Peer{}) + if err := m.PendingPeers[len(m.PendingPeers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -20856,7 +23900,7 @@ func (m *GetStoreResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *PutStoreRequest) Unmarshal(dAtA []byte) error { +func (m *ScanRegionsResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -20879,10 +23923,10 @@ func (m *PutStoreRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: PutStoreRequest: wiretype end group for non-group") + return fmt.Errorf("proto: ScanRegionsResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: PutStoreRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: ScanRegionsResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -20915,15 +23959,83 @@ func (m *PutStoreRequest) Unmarshal(dAtA []byte) error { return io.ErrUnexpectedEOF } if m.Header == nil { - m.Header = &RequestHeader{} + m.Header = &ResponseHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 2: + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RegionMetas", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthPdpb + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthPdpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.RegionMetas = append(m.RegionMetas, &metapb.Region{}) + if err := m.RegionMetas[len(m.RegionMetas)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Leaders", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthPdpb + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthPdpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Leaders = append(m.Leaders, &metapb.Peer{}) + if err := m.Leaders[len(m.Leaders)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Store", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Regions", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -20950,10 +24062,8 @@ func (m *PutStoreRequest) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Store == nil { - m.Store = &metapb.Store{} - } - if err := m.Store.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.Regions = append(m.Regions, &Region{}) + if err := m.Regions[len(m.Regions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -20979,7 +24089,7 @@ func (m *PutStoreRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *PutStoreResponse) Unmarshal(dAtA []byte) error { +func (m *GetClusterConfigRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -21002,10 +24112,10 @@ func (m *PutStoreResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: PutStoreResponse: wiretype end group for non-group") + return fmt.Errorf("proto: GetClusterConfigRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: PutStoreResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: GetClusterConfigRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -21038,48 +24148,12 @@ func (m *PutStoreResponse) Unmarshal(dAtA []byte) error { return io.ErrUnexpectedEOF } if m.Header == nil { - m.Header = &ResponseHeader{} + m.Header = &RequestHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ReplicationStatus", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthPdpb - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthPdpb - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.ReplicationStatus == nil { - m.ReplicationStatus = &replication_modepb.ReplicationStatus{} - } - if err := m.ReplicationStatus.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) @@ -21102,7 +24176,7 @@ func (m *PutStoreResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *GetAllStoresRequest) Unmarshal(dAtA []byte) error { +func (m *GetClusterConfigResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -21125,10 +24199,10 @@ func (m *GetAllStoresRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: GetAllStoresRequest: wiretype end group for non-group") + return fmt.Errorf("proto: GetClusterConfigResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: GetAllStoresRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: GetClusterConfigResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -21161,17 +24235,17 @@ func (m *GetAllStoresRequest) Unmarshal(dAtA []byte) error { return io.ErrUnexpectedEOF } if m.Header == nil { - m.Header = &RequestHeader{} + m.Header = &ResponseHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field ExcludeTombstoneStores", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Cluster", wireType) } - var v int + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -21181,12 +24255,28 @@ func (m *GetAllStoresRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - v |= int(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - m.ExcludeTombstoneStores = bool(v != 0) + if msglen < 0 { + return ErrInvalidLengthPdpb + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthPdpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Cluster == nil { + m.Cluster = &metapb.Cluster{} + } + if err := m.Cluster.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) @@ -21209,7 +24299,7 @@ func (m *GetAllStoresRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *GetAllStoresResponse) Unmarshal(dAtA []byte) error { +func (m *PutClusterConfigRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -21232,10 +24322,10 @@ func (m *GetAllStoresResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: GetAllStoresResponse: wiretype end group for non-group") + return fmt.Errorf("proto: PutClusterConfigRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: GetAllStoresResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: PutClusterConfigRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -21268,7 +24358,7 @@ func (m *GetAllStoresResponse) Unmarshal(dAtA []byte) error { return io.ErrUnexpectedEOF } if m.Header == nil { - m.Header = &ResponseHeader{} + m.Header = &RequestHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err @@ -21276,7 +24366,7 @@ func (m *GetAllStoresResponse) Unmarshal(dAtA []byte) error { iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Stores", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Cluster", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -21303,8 +24393,10 @@ func (m *GetAllStoresResponse) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Stores = append(m.Stores, &metapb.Store{}) - if err := m.Stores[len(m.Stores)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if m.Cluster == nil { + m.Cluster = &metapb.Cluster{} + } + if err := m.Cluster.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -21330,7 +24422,7 @@ func (m *GetAllStoresResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *GetRegionRequest) Unmarshal(dAtA []byte) error { +func (m *PutClusterConfigResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -21353,10 +24445,10 @@ func (m *GetRegionRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: GetRegionRequest: wiretype end group for non-group") + return fmt.Errorf("proto: PutClusterConfigResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: GetRegionRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: PutClusterConfigResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -21389,66 +24481,12 @@ func (m *GetRegionRequest) Unmarshal(dAtA []byte) error { return io.ErrUnexpectedEOF } if m.Header == nil { - m.Header = &RequestHeader{} + m.Header = &ResponseHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field RegionKey", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthPdpb - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthPdpb - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.RegionKey = append(m.RegionKey[:0], dAtA[iNdEx:postIndex]...) - if m.RegionKey == nil { - m.RegionKey = []byte{} - } - iNdEx = postIndex - case 3: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field NeedBuckets", wireType) - } - var v int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - v |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - m.NeedBuckets = bool(v != 0) default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) @@ -21471,7 +24509,7 @@ func (m *GetRegionRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *GetRegionResponse) Unmarshal(dAtA []byte) error { +func (m *Member) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -21494,17 +24532,17 @@ func (m *GetRegionResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: GetRegionResponse: wiretype end group for non-group") + return fmt.Errorf("proto: Member: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: GetRegionResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: Member: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -21514,33 +24552,48 @@ func (m *GetRegionResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return ErrInvalidLengthPdpb } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthPdpb } if postIndex > l { return io.ErrUnexpectedEOF } - if m.Header == nil { - m.Header = &ResponseHeader{} - } - if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.Name = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MemberId", wireType) + } + m.MemberId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.MemberId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Region", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field PeerUrls", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -21550,33 +24603,29 @@ func (m *GetRegionResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return ErrInvalidLengthPdpb } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthPdpb } if postIndex > l { return io.ErrUnexpectedEOF } - if m.Region == nil { - m.Region = &metapb.Region{} - } - if err := m.Region.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.PeerUrls = append(m.PeerUrls, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex - case 3: + case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Leader", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ClientUrls", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -21586,33 +24635,29 @@ func (m *GetRegionResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return ErrInvalidLengthPdpb } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthPdpb } if postIndex > l { return io.ErrUnexpectedEOF } - if m.Leader == nil { - m.Leader = &metapb.Peer{} - } - if err := m.Leader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.ClientUrls = append(m.ClientUrls, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex case 5: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field DownPeers", wireType) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field LeaderPriority", wireType) } - var msglen int + m.LeaderPriority = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -21622,31 +24667,16 @@ func (m *GetRegionResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + m.LeaderPriority |= int32(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { - return ErrInvalidLengthPdpb - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthPdpb - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.DownPeers = append(m.DownPeers, &PeerStats{}) - if err := m.DownPeers[len(m.DownPeers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex case 6: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field PendingPeers", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field DeployPath", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -21656,31 +24686,29 @@ func (m *GetRegionResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return ErrInvalidLengthPdpb } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthPdpb } if postIndex > l { return io.ErrUnexpectedEOF } - m.PendingPeers = append(m.PendingPeers, &metapb.Peer{}) - if err := m.PendingPeers[len(m.PendingPeers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.DeployPath = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 7: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Buckets", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field BinaryVersion", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -21690,84 +24718,29 @@ func (m *GetRegionResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return ErrInvalidLengthPdpb } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthPdpb } if postIndex > l { return io.ErrUnexpectedEOF } - if m.Buckets == nil { - m.Buckets = &metapb.Buckets{} - } - if err := m.Buckets.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.BinaryVersion = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipPdpb(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthPdpb - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *GetRegionByIDRequest) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: GetRegionByIDRequest: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: GetRegionByIDRequest: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + case 8: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field GitHash", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -21777,33 +24750,29 @@ func (m *GetRegionByIDRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return ErrInvalidLengthPdpb } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthPdpb } if postIndex > l { return io.ErrUnexpectedEOF } - if m.Header == nil { - m.Header = &RequestHeader{} - } - if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.GitHash = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field RegionId", wireType) + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DcLocation", wireType) } - m.RegionId = 0 + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -21813,31 +24782,24 @@ func (m *GetRegionByIDRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.RegionId |= uint64(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - case 3: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field NeedBuckets", wireType) + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthPdpb } - var v int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - v |= int(b&0x7F) << shift - if b < 0x80 { - break - } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthPdpb } - m.NeedBuckets = bool(v != 0) + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DcLocation = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) @@ -21860,7 +24822,7 @@ func (m *GetRegionByIDRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *ScanRegionsRequest) Unmarshal(dAtA []byte) error { +func (m *GetMembersRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -21883,10 +24845,10 @@ func (m *ScanRegionsRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: ScanRegionsRequest: wiretype end group for non-group") + return fmt.Errorf("proto: GetMembersRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: ScanRegionsRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: GetMembersRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -21903,113 +24865,26 @@ func (m *ScanRegionsRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthPdpb - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthPdpb - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Header == nil { - m.Header = &RequestHeader{} - } - if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field StartKey", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthPdpb - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthPdpb - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.StartKey = append(m.StartKey[:0], dAtA[iNdEx:postIndex]...) - if m.StartKey == nil { - m.StartKey = []byte{} - } - iNdEx = postIndex - case 3: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType) - } - m.Limit = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.Limit |= int32(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 4: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field EndKey", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { + if msglen < 0 { return ErrInvalidLengthPdpb } - postIndex := iNdEx + byteLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthPdpb } if postIndex > l { return io.ErrUnexpectedEOF } - m.EndKey = append(m.EndKey[:0], dAtA[iNdEx:postIndex]...) - if m.EndKey == nil { - m.EndKey = []byte{} + if m.Header == nil { + m.Header = &RequestHeader{} + } + if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } iNdEx = postIndex default: @@ -22034,7 +24909,7 @@ func (m *ScanRegionsRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *Region) Unmarshal(dAtA []byte) error { +func (m *GetMembersResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -22057,15 +24932,15 @@ func (m *Region) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: Region: wiretype end group for non-group") + return fmt.Errorf("proto: GetMembersResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: Region: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: GetMembersResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Region", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -22092,16 +24967,16 @@ func (m *Region) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Region == nil { - m.Region = &metapb.Region{} + if m.Header == nil { + m.Header = &ResponseHeader{} } - if err := m.Region.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Leader", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Members", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -22128,16 +25003,14 @@ func (m *Region) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Leader == nil { - m.Leader = &metapb.Peer{} - } - if err := m.Leader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.Members = append(m.Members, &Member{}) + if err := m.Members[len(m.Members)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field DownPeers", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Leader", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -22164,99 +25037,16 @@ func (m *Region) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.DownPeers = append(m.DownPeers, &PeerStats{}) - if err := m.DownPeers[len(m.DownPeers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 4: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field PendingPeers", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthPdpb - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthPdpb - } - if postIndex > l { - return io.ErrUnexpectedEOF + if m.Leader == nil { + m.Leader = &Member{} } - m.PendingPeers = append(m.PendingPeers, &metapb.Peer{}) - if err := m.PendingPeers[len(m.PendingPeers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Leader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipPdpb(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthPdpb - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *ScanRegionsResponse) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: ScanRegionsResponse: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: ScanRegionsResponse: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field EtcdLeader", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -22283,16 +25073,16 @@ func (m *ScanRegionsResponse) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Header == nil { - m.Header = &ResponseHeader{} + if m.EtcdLeader == nil { + m.EtcdLeader = &Member{} } - if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.EtcdLeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 2: + case 5: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field RegionMetas", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field TsoAllocatorLeaders", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -22319,48 +25109,160 @@ func (m *ScanRegionsResponse) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.RegionMetas = append(m.RegionMetas, &metapb.Region{}) - if err := m.RegionMetas[len(m.RegionMetas)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Leaders", wireType) + if m.TsoAllocatorLeaders == nil { + m.TsoAllocatorLeaders = make(map[string]*Member) } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF + var mapkey string + var mapvalue *Member + for iNdEx < postIndex { + entryPreIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break + fieldNum := int32(wire >> 3) + if fieldNum == 1 { + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapkey |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthPdpb + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey < 0 { + return ErrInvalidLengthPdpb + } + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + } else if fieldNum == 2 { + var mapmsglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + mapmsglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if mapmsglen < 0 { + return ErrInvalidLengthPdpb + } + postmsgIndex := iNdEx + mapmsglen + if postmsgIndex < 0 { + return ErrInvalidLengthPdpb + } + if postmsgIndex > l { + return io.ErrUnexpectedEOF + } + mapvalue = &Member{} + if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil { + return err + } + iNdEx = postmsgIndex + } else { + iNdEx = entryPreIndex + skippy, err := skipPdpb(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthPdpb + } + if (iNdEx + skippy) > postIndex { + return io.ErrUnexpectedEOF + } + iNdEx += skippy } } - if msglen < 0 { + m.TsoAllocatorLeaders[mapkey] = mapvalue + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipPdpb(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthPdpb } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthPdpb + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF } - if postIndex > l { + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *GetClusterInfoRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { return io.ErrUnexpectedEOF } - m.Leaders = append(m.Leaders, &metapb.Peer{}) - if err := m.Leaders[len(m.Leaders)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break } - iNdEx = postIndex - case 4: + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: GetClusterInfoRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GetClusterInfoRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Regions", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -22387,8 +25289,10 @@ func (m *ScanRegionsResponse) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Regions = append(m.Regions, &Region{}) - if err := m.Regions[len(m.Regions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if m.Header == nil { + m.Header = &ResponseHeader{} + } + if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -22414,7 +25318,7 @@ func (m *ScanRegionsResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *GetClusterConfigRequest) Unmarshal(dAtA []byte) error { +func (m *GetClusterInfoResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -22437,10 +25341,10 @@ func (m *GetClusterConfigRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: GetClusterConfigRequest: wiretype end group for non-group") + return fmt.Errorf("proto: GetClusterInfoResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: GetClusterConfigRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: GetClusterInfoResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -22473,12 +25377,81 @@ func (m *GetClusterConfigRequest) Unmarshal(dAtA []byte) error { return io.ErrUnexpectedEOF } if m.Header == nil { - m.Header = &RequestHeader{} + m.Header = &ResponseHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex + case 2: + if wireType == 0 { + var v ServiceMode + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= ServiceMode(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.ServiceModes = append(m.ServiceModes, v) + } else if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + packedLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthPdpb + } + postIndex := iNdEx + packedLen + if postIndex < 0 { + return ErrInvalidLengthPdpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + var elementCount int + if elementCount != 0 && len(m.ServiceModes) == 0 { + m.ServiceModes = make([]ServiceMode, 0, elementCount) + } + for iNdEx < postIndex { + var v ServiceMode + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= ServiceMode(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.ServiceModes = append(m.ServiceModes, v) + } + } else { + return fmt.Errorf("proto: wrong wireType = %d for field ServiceModes", wireType) + } default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) @@ -22501,7 +25474,7 @@ func (m *GetClusterConfigRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *GetClusterConfigResponse) Unmarshal(dAtA []byte) error { +func (m *PeerStats) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -22524,15 +25497,15 @@ func (m *GetClusterConfigResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: GetClusterConfigResponse: wiretype end group for non-group") + return fmt.Errorf("proto: PeerStats: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: GetClusterConfigResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: PeerStats: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Peer", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -22559,18 +25532,18 @@ func (m *GetClusterConfigResponse) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Header == nil { - m.Header = &ResponseHeader{} + if m.Peer == nil { + m.Peer = &metapb.Peer{} } - if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Peer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Cluster", wireType) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field DownSeconds", wireType) } - var msglen int + m.DownSeconds = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -22580,28 +25553,11 @@ func (m *GetClusterConfigResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + m.DownSeconds |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { - return ErrInvalidLengthPdpb - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthPdpb - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Cluster == nil { - m.Cluster = &metapb.Cluster{} - } - if err := m.Cluster.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) @@ -22624,7 +25580,7 @@ func (m *GetClusterConfigResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *PutClusterConfigRequest) Unmarshal(dAtA []byte) error { +func (m *RegionHeartbeatRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -22647,15 +25603,87 @@ func (m *PutClusterConfigRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: PutClusterConfigRequest: wiretype end group for non-group") + return fmt.Errorf("proto: RegionHeartbeatRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: PutClusterConfigRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: RegionHeartbeatRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthPdpb + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthPdpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Header == nil { + m.Header = &RequestHeader{} + } + if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Region", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthPdpb + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthPdpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Region == nil { + m.Region = &metapb.Region{} + } + if err := m.Region.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Leader", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -22682,16 +25710,16 @@ func (m *PutClusterConfigRequest) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Header == nil { - m.Header = &RequestHeader{} + if m.Leader == nil { + m.Leader = &metapb.Peer{} } - if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Leader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 2: + case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Cluster", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field DownPeers", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -22718,67 +25746,14 @@ func (m *PutClusterConfigRequest) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Cluster == nil { - m.Cluster = &metapb.Cluster{} - } - if err := m.Cluster.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.DownPeers = append(m.DownPeers, &PeerStats{}) + if err := m.DownPeers[len(m.DownPeers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipPdpb(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthPdpb - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *PutClusterConfigResponse) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: PutClusterConfigResponse: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: PutClusterConfigResponse: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + case 5: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field PendingPeers", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -22805,69 +25780,54 @@ func (m *PutClusterConfigResponse) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Header == nil { - m.Header = &ResponseHeader{} - } - if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.PendingPeers = append(m.PendingPeers, &metapb.Peer{}) + if err := m.PendingPeers[len(m.PendingPeers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipPdpb(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthPdpb - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field BytesWritten", wireType) } - m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *Member) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb + m.BytesWritten = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.BytesWritten |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } } - if iNdEx >= l { - return io.ErrUnexpectedEOF + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field BytesRead", wireType) } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break + m.BytesRead = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.BytesRead |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: Member: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: Member: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field KeysWritten", wireType) } - var stringLen uint64 + m.KeysWritten = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -22877,29 +25837,35 @@ func (m *Member) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + m.KeysWritten |= uint64(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthPdpb - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthPdpb + case 9: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field KeysRead", wireType) } - if postIndex > l { - return io.ErrUnexpectedEOF + m.KeysRead = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.KeysRead |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } } - m.Name = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 2: + case 10: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field MemberId", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ApproximateSize", wireType) } - m.MemberId = 0 + m.ApproximateSize = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -22909,16 +25875,16 @@ func (m *Member) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.MemberId |= uint64(b&0x7F) << shift + m.ApproximateSize |= uint64(b&0x7F) << shift if b < 0x80 { break } } - case 3: + case 12: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field PeerUrls", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Interval", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -22928,29 +25894,33 @@ func (m *Member) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + if msglen < 0 { return ErrInvalidLengthPdpb } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthPdpb } if postIndex > l { return io.ErrUnexpectedEOF } - m.PeerUrls = append(m.PeerUrls, string(dAtA[iNdEx:postIndex])) + if m.Interval == nil { + m.Interval = &TimeInterval{} + } + if err := m.Interval.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } iNdEx = postIndex - case 4: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ClientUrls", wireType) + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ApproximateKeys", wireType) } - var stringLen uint64 + m.ApproximateKeys = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -22960,29 +25930,16 @@ func (m *Member) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + m.ApproximateKeys |= uint64(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthPdpb - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthPdpb - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.ClientUrls = append(m.ClientUrls, string(dAtA[iNdEx:postIndex])) - iNdEx = postIndex - case 5: + case 14: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field LeaderPriority", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Term", wireType) } - m.LeaderPriority = 0 + m.Term = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -22992,16 +25949,16 @@ func (m *Member) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.LeaderPriority |= int32(b&0x7F) << shift + m.Term |= uint64(b&0x7F) << shift if b < 0x80 { break } } - case 6: + case 15: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field DeployPath", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ReplicationStatus", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -23011,29 +25968,33 @@ func (m *Member) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + if msglen < 0 { return ErrInvalidLengthPdpb } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthPdpb } if postIndex > l { return io.ErrUnexpectedEOF } - m.DeployPath = string(dAtA[iNdEx:postIndex]) + if m.ReplicationStatus == nil { + m.ReplicationStatus = &replication_modepb.RegionReplicationStatus{} + } + if err := m.ReplicationStatus.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } iNdEx = postIndex - case 7: + case 16: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field BinaryVersion", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field QueryStats", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -23043,29 +26004,33 @@ func (m *Member) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + if msglen < 0 { return ErrInvalidLengthPdpb } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthPdpb } if postIndex > l { return io.ErrUnexpectedEOF } - m.BinaryVersion = string(dAtA[iNdEx:postIndex]) + if m.QueryStats == nil { + m.QueryStats = &QueryStats{} + } + if err := m.QueryStats.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } iNdEx = postIndex - case 8: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field GitHash", wireType) + case 17: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CpuUsage", wireType) } - var stringLen uint64 + m.CpuUsage = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -23075,29 +26040,16 @@ func (m *Member) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + m.CpuUsage |= uint64(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthPdpb - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthPdpb - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.GitHash = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 9: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field DcLocation", wireType) + case 18: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ApproximateKvSize", wireType) } - var stringLen uint64 + m.ApproximateKvSize = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -23107,24 +26059,11 @@ func (m *Member) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + m.ApproximateKvSize |= uint64(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthPdpb - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthPdpb - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.DcLocation = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) @@ -23147,7 +26086,7 @@ func (m *Member) Unmarshal(dAtA []byte) error { } return nil } -func (m *GetMembersRequest) Unmarshal(dAtA []byte) error { +func (m *ChangePeer) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -23170,15 +26109,15 @@ func (m *GetMembersRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: GetMembersRequest: wiretype end group for non-group") + return fmt.Errorf("proto: ChangePeer: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: GetMembersRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: ChangePeer: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Peer", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -23205,13 +26144,32 @@ func (m *GetMembersRequest) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Header == nil { - m.Header = &RequestHeader{} + if m.Peer == nil { + m.Peer = &metapb.Peer{} } - if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Peer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ChangeType", wireType) + } + m.ChangeType = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ChangeType |= eraftpb.ConfChangeType(b&0x7F) << shift + if b < 0x80 { + break + } + } default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) @@ -23234,7 +26192,7 @@ func (m *GetMembersRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *GetMembersResponse) Unmarshal(dAtA []byte) error { +func (m *ChangePeerV2) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -23257,15 +26215,15 @@ func (m *GetMembersResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: GetMembersResponse: wiretype end group for non-group") + return fmt.Errorf("proto: ChangePeerV2: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: GetMembersResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: ChangePeerV2: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Changes", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -23292,16 +26250,65 @@ func (m *GetMembersResponse) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Header == nil { - m.Header = &ResponseHeader{} - } - if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.Changes = append(m.Changes, &ChangePeer{}) + if err := m.Changes[len(m.Changes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 2: + default: + iNdEx = preIndex + skippy, err := skipPdpb(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthPdpb + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *TransferLeader) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: TransferLeader: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: TransferLeader: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Members", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Peer", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -23328,14 +26335,16 @@ func (m *GetMembersResponse) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Members = append(m.Members, &Member{}) - if err := m.Members[len(m.Members)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if m.Peer == nil { + m.Peer = &metapb.Peer{} + } + if err := m.Peer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 3: + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Leader", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Peers", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -23362,52 +26371,65 @@ func (m *GetMembersResponse) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Leader == nil { - m.Leader = &Member{} - } - if err := m.Leader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.Peers = append(m.Peers, &metapb.Peer{}) + if err := m.Peers[len(m.Peers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 4: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field EtcdLeader", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } + default: + iNdEx = preIndex + skippy, err := skipPdpb(dAtA[iNdEx:]) + if err != nil { + return err } - if msglen < 0 { + if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthPdpb } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthPdpb + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Merge) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb } - if postIndex > l { + if iNdEx >= l { return io.ErrUnexpectedEOF } - if m.EtcdLeader == nil { - m.EtcdLeader = &Member{} - } - if err := m.EtcdLeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break } - iNdEx = postIndex - case 5: + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Merge: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Merge: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field TsoAllocatorLeaders", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -23434,105 +26456,12 @@ func (m *GetMembersResponse) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.TsoAllocatorLeaders == nil { - m.TsoAllocatorLeaders = make(map[string]*Member) + if m.Target == nil { + m.Target = &metapb.Region{} } - var mapkey string - var mapvalue *Member - for iNdEx < postIndex { - entryPreIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - fieldNum := int32(wire >> 3) - if fieldNum == 1 { - var stringLenmapkey uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - stringLenmapkey |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - intStringLenmapkey := int(stringLenmapkey) - if intStringLenmapkey < 0 { - return ErrInvalidLengthPdpb - } - postStringIndexmapkey := iNdEx + intStringLenmapkey - if postStringIndexmapkey < 0 { - return ErrInvalidLengthPdpb - } - if postStringIndexmapkey > l { - return io.ErrUnexpectedEOF - } - mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) - iNdEx = postStringIndexmapkey - } else if fieldNum == 2 { - var mapmsglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - mapmsglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if mapmsglen < 0 { - return ErrInvalidLengthPdpb - } - postmsgIndex := iNdEx + mapmsglen - if postmsgIndex < 0 { - return ErrInvalidLengthPdpb - } - if postmsgIndex > l { - return io.ErrUnexpectedEOF - } - mapvalue = &Member{} - if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil { - return err - } - iNdEx = postmsgIndex - } else { - iNdEx = entryPreIndex - skippy, err := skipPdpb(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthPdpb - } - if (iNdEx + skippy) > postIndex { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } + if err := m.Target.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } - m.TsoAllocatorLeaders[mapkey] = mapvalue iNdEx = postIndex default: iNdEx = preIndex @@ -23556,7 +26485,7 @@ func (m *GetMembersResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *GetClusterInfoRequest) Unmarshal(dAtA []byte) error { +func (m *SplitRegion) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -23579,17 +26508,36 @@ func (m *GetClusterInfoRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: GetClusterInfoRequest: wiretype end group for non-group") + return fmt.Errorf("proto: SplitRegion: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: GetClusterInfoRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: SplitRegion: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Policy", wireType) + } + m.Policy = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Policy |= CheckPolicy(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Keys", wireType) } - var msglen int + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -23599,27 +26547,23 @@ func (m *GetClusterInfoRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + if byteLen < 0 { return ErrInvalidLengthPdpb } - postIndex := iNdEx + msglen + postIndex := iNdEx + byteLen if postIndex < 0 { return ErrInvalidLengthPdpb } if postIndex > l { return io.ErrUnexpectedEOF } - if m.Header == nil { - m.Header = &ResponseHeader{} - } - if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.Keys = append(m.Keys, make([]byte, postIndex-iNdEx)) + copy(m.Keys[len(m.Keys)-1], dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex @@ -23643,7 +26587,7 @@ func (m *GetClusterInfoRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *GetClusterInfoResponse) Unmarshal(dAtA []byte) error { +func (m *SwitchWitness) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -23666,17 +26610,17 @@ func (m *GetClusterInfoResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: GetClusterInfoResponse: wiretype end group for non-group") + return fmt.Errorf("proto: SwitchWitness: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: GetClusterInfoResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: SwitchWitness: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field PeerId", wireType) } - var msglen int + m.PeerId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -23686,97 +26630,31 @@ func (m *GetClusterInfoResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + m.PeerId |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { - return ErrInvalidLengthPdpb - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthPdpb - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Header == nil { - m.Header = &ResponseHeader{} - } - if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex case 2: - if wireType == 0 { - var v ServiceMode - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - v |= ServiceMode(b&0x7F) << shift - if b < 0x80 { - break - } - } - m.ServiceModes = append(m.ServiceModes, v) - } else if wireType == 2 { - var packedLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - packedLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if packedLen < 0 { - return ErrInvalidLengthPdpb - } - postIndex := iNdEx + packedLen - if postIndex < 0 { - return ErrInvalidLengthPdpb - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - var elementCount int - if elementCount != 0 && len(m.ServiceModes) == 0 { - m.ServiceModes = make([]ServiceMode, 0, elementCount) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field IsWitness", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb } - for iNdEx < postIndex { - var v ServiceMode - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - v |= ServiceMode(b&0x7F) << shift - if b < 0x80 { - break - } - } - m.ServiceModes = append(m.ServiceModes, v) + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break } - } else { - return fmt.Errorf("proto: wrong wireType = %d for field ServiceModes", wireType) } + m.IsWitness = bool(v != 0) default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) @@ -23799,7 +26677,7 @@ func (m *GetClusterInfoResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *PeerStats) Unmarshal(dAtA []byte) error { +func (m *BatchSwitchWitness) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -23822,15 +26700,15 @@ func (m *PeerStats) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: PeerStats: wiretype end group for non-group") + return fmt.Errorf("proto: BatchSwitchWitness: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: PeerStats: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: BatchSwitchWitness: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Peer", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field SwitchWitnesses", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -23857,32 +26735,11 @@ func (m *PeerStats) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Peer == nil { - m.Peer = &metapb.Peer{} - } - if err := m.Peer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.SwitchWitnesses = append(m.SwitchWitnesses, &SwitchWitness{}) + if err := m.SwitchWitnesses[len(m.SwitchWitnesses)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field DownSeconds", wireType) - } - m.DownSeconds = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.DownSeconds |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) @@ -23905,7 +26762,7 @@ func (m *PeerStats) Unmarshal(dAtA []byte) error { } return nil } -func (m *RegionHeartbeatRequest) Unmarshal(dAtA []byte) error { +func (m *RegionHeartbeatResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -23928,10 +26785,10 @@ func (m *RegionHeartbeatRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: RegionHeartbeatRequest: wiretype end group for non-group") + return fmt.Errorf("proto: RegionHeartbeatResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: RegionHeartbeatRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: RegionHeartbeatResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -23964,7 +26821,7 @@ func (m *RegionHeartbeatRequest) Unmarshal(dAtA []byte) error { return io.ErrUnexpectedEOF } if m.Header == nil { - m.Header = &RequestHeader{} + m.Header = &ResponseHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err @@ -23972,7 +26829,7 @@ func (m *RegionHeartbeatRequest) Unmarshal(dAtA []byte) error { iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Region", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ChangePeer", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -23999,16 +26856,16 @@ func (m *RegionHeartbeatRequest) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Region == nil { - m.Region = &metapb.Region{} + if m.ChangePeer == nil { + m.ChangePeer = &ChangePeer{} } - if err := m.Region.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.ChangePeer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Leader", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field TransferLeader", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -24035,18 +26892,18 @@ func (m *RegionHeartbeatRequest) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Leader == nil { - m.Leader = &metapb.Peer{} + if m.TransferLeader == nil { + m.TransferLeader = &TransferLeader{} } - if err := m.Leader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.TransferLeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 4: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field DownPeers", wireType) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field RegionId", wireType) } - var msglen int + m.RegionId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -24056,29 +26913,14 @@ func (m *RegionHeartbeatRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + m.RegionId |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { - return ErrInvalidLengthPdpb - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthPdpb - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.DownPeers = append(m.DownPeers, &PeerStats{}) - if err := m.DownPeers[len(m.DownPeers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex case 5: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field PendingPeers", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field RegionEpoch", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -24105,35 +26947,18 @@ func (m *RegionHeartbeatRequest) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.PendingPeers = append(m.PendingPeers, &metapb.Peer{}) - if err := m.PendingPeers[len(m.PendingPeers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if m.RegionEpoch == nil { + m.RegionEpoch = &metapb.RegionEpoch{} + } + if err := m.RegionEpoch.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 6: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field BytesWritten", wireType) - } - m.BytesWritten = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.BytesWritten |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 7: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field BytesRead", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TargetPeer", wireType) } - m.BytesRead = 0 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -24143,71 +26968,31 @@ func (m *RegionHeartbeatRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.BytesRead |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - case 8: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field KeysWritten", wireType) - } - m.KeysWritten = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.KeysWritten |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } + if msglen < 0 { + return ErrInvalidLengthPdpb } - case 9: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field KeysRead", wireType) + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthPdpb } - m.KeysRead = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.KeysRead |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } + if postIndex > l { + return io.ErrUnexpectedEOF } - case 10: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field ApproximateSize", wireType) + if m.TargetPeer == nil { + m.TargetPeer = &metapb.Peer{} } - m.ApproximateSize = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.ApproximateSize |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } + if err := m.TargetPeer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } - case 12: + iNdEx = postIndex + case 7: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Interval", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Merge", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -24234,54 +27019,16 @@ func (m *RegionHeartbeatRequest) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Interval == nil { - m.Interval = &TimeInterval{} + if m.Merge == nil { + m.Merge = &Merge{} } - if err := m.Interval.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Merge.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 13: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field ApproximateKeys", wireType) - } - m.ApproximateKeys = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.ApproximateKeys |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 14: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Term", wireType) - } - m.Term = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.Term |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 15: + case 8: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ReplicationStatus", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field SplitRegion", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -24308,16 +27055,16 @@ func (m *RegionHeartbeatRequest) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.ReplicationStatus == nil { - m.ReplicationStatus = &replication_modepb.RegionReplicationStatus{} + if m.SplitRegion == nil { + m.SplitRegion = &SplitRegion{} } - if err := m.ReplicationStatus.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.SplitRegion.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 16: + case 9: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field QueryStats", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ChangePeerV2", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -24344,18 +27091,18 @@ func (m *RegionHeartbeatRequest) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.QueryStats == nil { - m.QueryStats = &QueryStats{} + if m.ChangePeerV2 == nil { + m.ChangePeerV2 = &ChangePeerV2{} } - if err := m.QueryStats.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.ChangePeerV2.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 17: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field CpuUsage", wireType) + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SwitchWitnesses", wireType) } - m.CpuUsage = 0 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -24365,30 +27112,28 @@ func (m *RegionHeartbeatRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.CpuUsage |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - case 18: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field ApproximateKvSize", wireType) + if msglen < 0 { + return ErrInvalidLengthPdpb } - m.ApproximateKvSize = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.ApproximateKvSize |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthPdpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SwitchWitnesses == nil { + m.SwitchWitnesses = &BatchSwitchWitness{} + } + if err := m.SwitchWitnesses.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) @@ -24411,7 +27156,7 @@ func (m *RegionHeartbeatRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *ChangePeer) Unmarshal(dAtA []byte) error { +func (m *AskSplitRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -24434,15 +27179,15 @@ func (m *ChangePeer) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: ChangePeer: wiretype end group for non-group") + return fmt.Errorf("proto: AskSplitRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: ChangePeer: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: AskSplitRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Peer", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -24469,18 +27214,18 @@ func (m *ChangePeer) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Peer == nil { - m.Peer = &metapb.Peer{} + if m.Header == nil { + m.Header = &RequestHeader{} } - if err := m.Peer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field ChangeType", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Region", wireType) } - m.ChangeType = 0 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -24490,11 +27235,28 @@ func (m *ChangePeer) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.ChangeType |= eraftpb.ConfChangeType(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } + if msglen < 0 { + return ErrInvalidLengthPdpb + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthPdpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Region == nil { + m.Region = &metapb.Region{} + } + if err := m.Region.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) @@ -24517,7 +27279,7 @@ func (m *ChangePeer) Unmarshal(dAtA []byte) error { } return nil } -func (m *ChangePeerV2) Unmarshal(dAtA []byte) error { +func (m *AskSplitResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -24540,15 +27302,15 @@ func (m *ChangePeerV2) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: ChangePeerV2: wiretype end group for non-group") + return fmt.Errorf("proto: AskSplitResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: ChangePeerV2: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: AskSplitResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Changes", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -24575,11 +27337,108 @@ func (m *ChangePeerV2) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Changes = append(m.Changes, &ChangePeer{}) - if err := m.Changes[len(m.Changes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if m.Header == nil { + m.Header = &ResponseHeader{} + } + if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field NewRegionId", wireType) + } + m.NewRegionId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.NewRegionId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType == 0 { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.NewPeerIds = append(m.NewPeerIds, v) + } else if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + packedLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthPdpb + } + postIndex := iNdEx + packedLen + if postIndex < 0 { + return ErrInvalidLengthPdpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + var elementCount int + var count int + for _, integer := range dAtA[iNdEx:postIndex] { + if integer < 128 { + count++ + } + } + elementCount = count + if elementCount != 0 && len(m.NewPeerIds) == 0 { + m.NewPeerIds = make([]uint64, 0, elementCount) + } + for iNdEx < postIndex { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.NewPeerIds = append(m.NewPeerIds, v) + } + } else { + return fmt.Errorf("proto: wrong wireType = %d for field NewPeerIds", wireType) + } default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) @@ -24602,7 +27461,7 @@ func (m *ChangePeerV2) Unmarshal(dAtA []byte) error { } return nil } -func (m *TransferLeader) Unmarshal(dAtA []byte) error { +func (m *ReportSplitRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -24612,28 +27471,64 @@ func (m *TransferLeader) Unmarshal(dAtA []byte) error { if shift >= 64 { return ErrIntOverflowPdpb } - if iNdEx >= l { + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ReportSplitRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ReportSplitRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthPdpb + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthPdpb + } + if postIndex > l { return io.ErrUnexpectedEOF } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break + if m.Header == nil { + m.Header = &RequestHeader{} } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: TransferLeader: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: TransferLeader: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Peer", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Left", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -24660,16 +27555,16 @@ func (m *TransferLeader) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Peer == nil { - m.Peer = &metapb.Peer{} + if m.Left == nil { + m.Left = &metapb.Region{} } - if err := m.Peer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Left.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 2: + case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Peers", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Right", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -24696,8 +27591,10 @@ func (m *TransferLeader) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Peers = append(m.Peers, &metapb.Peer{}) - if err := m.Peers[len(m.Peers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if m.Right == nil { + m.Right = &metapb.Region{} + } + if err := m.Right.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -24723,7 +27620,7 @@ func (m *TransferLeader) Unmarshal(dAtA []byte) error { } return nil } -func (m *Merge) Unmarshal(dAtA []byte) error { +func (m *ReportSplitResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -24746,15 +27643,15 @@ func (m *Merge) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: Merge: wiretype end group for non-group") + return fmt.Errorf("proto: ReportSplitResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: Merge: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: ReportSplitResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -24781,10 +27678,10 @@ func (m *Merge) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Target == nil { - m.Target = &metapb.Region{} + if m.Header == nil { + m.Header = &ResponseHeader{} } - if err := m.Target.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -24810,7 +27707,7 @@ func (m *Merge) Unmarshal(dAtA []byte) error { } return nil } -func (m *SplitRegion) Unmarshal(dAtA []byte) error { +func (m *AskBatchSplitRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -24833,17 +27730,17 @@ func (m *SplitRegion) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: SplitRegion: wiretype end group for non-group") + return fmt.Errorf("proto: AskBatchSplitRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: SplitRegion: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: AskBatchSplitRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Policy", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } - m.Policy = 0 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -24853,16 +27750,33 @@ func (m *SplitRegion) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Policy |= CheckPolicy(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } + if msglen < 0 { + return ErrInvalidLengthPdpb + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthPdpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Header == nil { + m.Header = &RequestHeader{} + } + if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Keys", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Region", wireType) } - var byteLen int + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -24872,99 +27786,33 @@ func (m *SplitRegion) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= int(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { + if msglen < 0 { return ErrInvalidLengthPdpb } - postIndex := iNdEx + byteLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthPdpb } if postIndex > l { return io.ErrUnexpectedEOF } - m.Keys = append(m.Keys, make([]byte, postIndex-iNdEx)) - copy(m.Keys[len(m.Keys)-1], dAtA[iNdEx:postIndex]) - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipPdpb(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthPdpb - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *SwitchWitness) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: SwitchWitness: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: SwitchWitness: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field PeerId", wireType) + if m.Region == nil { + m.Region = &metapb.Region{} } - m.PeerId = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.PeerId |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } + if err := m.Region.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } - case 2: + iNdEx = postIndex + case 3: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field IsWitness", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field SplitCount", wireType) } - var v int + m.SplitCount = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -24974,12 +27822,11 @@ func (m *SwitchWitness) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - v |= int(b&0x7F) << shift + m.SplitCount |= uint32(b&0x7F) << shift if b < 0x80 { break } } - m.IsWitness = bool(v != 0) default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) @@ -25002,7 +27849,7 @@ func (m *SwitchWitness) Unmarshal(dAtA []byte) error { } return nil } -func (m *BatchSwitchWitness) Unmarshal(dAtA []byte) error { +func (m *SplitID) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -25025,17 +27872,17 @@ func (m *BatchSwitchWitness) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: BatchSwitchWitness: wiretype end group for non-group") + return fmt.Errorf("proto: SplitID: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: BatchSwitchWitness: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: SplitID: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field SwitchWitnesses", wireType) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field NewRegionId", wireType) } - var msglen int + m.NewRegionId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -25045,26 +27892,87 @@ func (m *BatchSwitchWitness) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + m.NewRegionId |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { - return ErrInvalidLengthPdpb - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthPdpb - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.SwitchWitnesses = append(m.SwitchWitnesses, &SwitchWitness{}) - if err := m.SwitchWitnesses[len(m.SwitchWitnesses)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex + case 2: + if wireType == 0 { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.NewPeerIds = append(m.NewPeerIds, v) + } else if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + packedLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthPdpb + } + postIndex := iNdEx + packedLen + if postIndex < 0 { + return ErrInvalidLengthPdpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + var elementCount int + var count int + for _, integer := range dAtA[iNdEx:postIndex] { + if integer < 128 { + count++ + } + } + elementCount = count + if elementCount != 0 && len(m.NewPeerIds) == 0 { + m.NewPeerIds = make([]uint64, 0, elementCount) + } + for iNdEx < postIndex { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.NewPeerIds = append(m.NewPeerIds, v) + } + } else { + return fmt.Errorf("proto: wrong wireType = %d for field NewPeerIds", wireType) + } default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) @@ -25087,7 +27995,7 @@ func (m *BatchSwitchWitness) Unmarshal(dAtA []byte) error { } return nil } -func (m *RegionHeartbeatResponse) Unmarshal(dAtA []byte) error { +func (m *AskBatchSplitResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -25110,10 +28018,10 @@ func (m *RegionHeartbeatResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: RegionHeartbeatResponse: wiretype end group for non-group") + return fmt.Errorf("proto: AskBatchSplitResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: RegionHeartbeatResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: AskBatchSplitResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -25154,7 +28062,7 @@ func (m *RegionHeartbeatResponse) Unmarshal(dAtA []byte) error { iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ChangePeer", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Ids", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -25181,107 +28089,65 @@ func (m *RegionHeartbeatResponse) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.ChangePeer == nil { - m.ChangePeer = &ChangePeer{} - } - if err := m.ChangePeer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.Ids = append(m.Ids, &SplitID{}) + if err := m.Ids[len(m.Ids)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field TransferLeader", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthPdpb + default: + iNdEx = preIndex + skippy, err := skipPdpb(dAtA[iNdEx:]) + if err != nil { + return err } - postIndex := iNdEx + msglen - if postIndex < 0 { + if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthPdpb } - if postIndex > l { + if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } - if m.TransferLeader == nil { - m.TransferLeader = &TransferLeader{} - } - if err := m.TransferLeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 4: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field RegionId", wireType) - } - m.RegionId = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.RegionId |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 5: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field RegionEpoch", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthPdpb - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthPdpb + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ReportBatchSplitRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb } - if postIndex > l { + if iNdEx >= l { return io.ErrUnexpectedEOF } - if m.RegionEpoch == nil { - m.RegionEpoch = &metapb.RegionEpoch{} - } - if err := m.RegionEpoch.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break } - iNdEx = postIndex - case 6: + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ReportBatchSplitRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ReportBatchSplitRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field TargetPeer", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -25308,16 +28174,16 @@ func (m *RegionHeartbeatResponse) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.TargetPeer == nil { - m.TargetPeer = &metapb.Peer{} + if m.Header == nil { + m.Header = &RequestHeader{} } - if err := m.TargetPeer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 7: + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Merge", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Regions", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -25344,88 +28210,65 @@ func (m *RegionHeartbeatResponse) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Merge == nil { - m.Merge = &Merge{} - } - if err := m.Merge.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.Regions = append(m.Regions, &metapb.Region{}) + if err := m.Regions[len(m.Regions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 8: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field SplitRegion", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthPdpb + default: + iNdEx = preIndex + skippy, err := skipPdpb(dAtA[iNdEx:]) + if err != nil { + return err } - postIndex := iNdEx + msglen - if postIndex < 0 { + if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthPdpb } - if postIndex > l { + if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } - if m.SplitRegion == nil { - m.SplitRegion = &SplitRegion{} - } - if err := m.SplitRegion.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 9: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ChangePeerV2", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthPdpb - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthPdpb + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ReportBatchSplitResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb } - if postIndex > l { + if iNdEx >= l { return io.ErrUnexpectedEOF } - if m.ChangePeerV2 == nil { - m.ChangePeerV2 = &ChangePeerV2{} - } - if err := m.ChangePeerV2.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break } - iNdEx = postIndex - case 10: + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ReportBatchSplitResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ReportBatchSplitResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field SwitchWitnesses", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -25452,10 +28295,10 @@ func (m *RegionHeartbeatResponse) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.SwitchWitnesses == nil { - m.SwitchWitnesses = &BatchSwitchWitness{} + if m.Header == nil { + m.Header = &ResponseHeader{} } - if err := m.SwitchWitnesses.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -25481,7 +28324,7 @@ func (m *RegionHeartbeatResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *AskSplitRequest) Unmarshal(dAtA []byte) error { +func (m *TimeInterval) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -25504,17 +28347,17 @@ func (m *AskSplitRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: AskSplitRequest: wiretype end group for non-group") + return fmt.Errorf("proto: TimeInterval: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: AskSplitRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: TimeInterval: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field StartTimestamp", wireType) } - var msglen int + m.StartTimestamp = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -25524,33 +28367,16 @@ func (m *AskSplitRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + m.StartTimestamp |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { - return ErrInvalidLengthPdpb - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthPdpb - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Header == nil { - m.Header = &RequestHeader{} - } - if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Region", wireType) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field EndTimestamp", wireType) } - var msglen int + m.EndTimestamp = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -25560,28 +28386,11 @@ func (m *AskSplitRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + m.EndTimestamp |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { - return ErrInvalidLengthPdpb - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthPdpb - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Region == nil { - m.Region = &metapb.Region{} - } - if err := m.Region.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) @@ -25604,7 +28413,7 @@ func (m *AskSplitRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *AskSplitResponse) Unmarshal(dAtA []byte) error { +func (m *RecordPair) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -25627,17 +28436,17 @@ func (m *AskSplitResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: AskSplitResponse: wiretype end group for non-group") + return fmt.Errorf("proto: RecordPair: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: AskSplitResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: RecordPair: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -25647,33 +28456,29 @@ func (m *AskSplitResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return ErrInvalidLengthPdpb } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthPdpb } if postIndex > l { return io.ErrUnexpectedEOF } - if m.Header == nil { - m.Header = &ResponseHeader{} - } - if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.Key = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field NewRegionId", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) } - m.NewRegionId = 0 + m.Value = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -25683,87 +28488,11 @@ func (m *AskSplitResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.NewRegionId |= uint64(b&0x7F) << shift + m.Value |= uint64(b&0x7F) << shift if b < 0x80 { break } } - case 3: - if wireType == 0 { - var v uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - v |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - m.NewPeerIds = append(m.NewPeerIds, v) - } else if wireType == 2 { - var packedLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - packedLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if packedLen < 0 { - return ErrInvalidLengthPdpb - } - postIndex := iNdEx + packedLen - if postIndex < 0 { - return ErrInvalidLengthPdpb - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - var elementCount int - var count int - for _, integer := range dAtA[iNdEx:postIndex] { - if integer < 128 { - count++ - } - } - elementCount = count - if elementCount != 0 && len(m.NewPeerIds) == 0 { - m.NewPeerIds = make([]uint64, 0, elementCount) - } - for iNdEx < postIndex { - var v uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - v |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - m.NewPeerIds = append(m.NewPeerIds, v) - } - } else { - return fmt.Errorf("proto: wrong wireType = %d for field NewPeerIds", wireType) - } default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) @@ -25786,7 +28515,7 @@ func (m *AskSplitResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *ReportSplitRequest) Unmarshal(dAtA []byte) error { +func (m *PeerStat) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -25809,17 +28538,55 @@ func (m *ReportSplitRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: ReportSplitRequest: wiretype end group for non-group") + return fmt.Errorf("proto: PeerStat: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: ReportSplitRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: PeerStat: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field RegionId", wireType) + } + m.RegionId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.RegionId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ReadKeys", wireType) + } + m.ReadKeys = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ReadKeys |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ReadBytes", wireType) } - var msglen int + m.ReadBytes = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -25829,31 +28596,14 @@ func (m *ReportSplitRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + m.ReadBytes |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { - return ErrInvalidLengthPdpb - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthPdpb - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Header == nil { - m.Header = &RequestHeader{} - } - if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: + case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Left", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field QueryStats", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -25880,18 +28630,18 @@ func (m *ReportSplitRequest) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Left == nil { - m.Left = &metapb.Region{} + if m.QueryStats == nil { + m.QueryStats = &QueryStats{} } - if err := m.Left.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.QueryStats.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Right", wireType) + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field WrittenKeys", wireType) } - var msglen int + m.WrittenKeys = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -25901,28 +28651,30 @@ func (m *ReportSplitRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + m.WrittenKeys |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { - return ErrInvalidLengthPdpb - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthPdpb - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Right == nil { - m.Right = &metapb.Region{} + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field WrittenBytes", wireType) } - if err := m.Right.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + m.WrittenBytes = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.WrittenBytes |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } } - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) @@ -25945,7 +28697,7 @@ func (m *ReportSplitRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *ReportSplitResponse) Unmarshal(dAtA []byte) error { +func (m *StoreStats) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -25968,17 +28720,17 @@ func (m *ReportSplitResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: ReportSplitResponse: wiretype end group for non-group") + return fmt.Errorf("proto: StoreStats: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: ReportSplitResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: StoreStats: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field StoreId", wireType) } - var msglen int + m.StoreId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -25988,84 +28740,130 @@ func (m *ReportSplitResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + m.StoreId |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { - return ErrInvalidLengthPdpb + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Capacity", wireType) } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthPdpb + m.Capacity = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Capacity |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } } - if postIndex > l { - return io.ErrUnexpectedEOF + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Available", wireType) } - if m.Header == nil { - m.Header = &ResponseHeader{} + m.Available = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Available |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } } - if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field RegionCount", wireType) } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipPdpb(dAtA[iNdEx:]) - if err != nil { - return err + m.RegionCount = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.RegionCount |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthPdpb + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field SendingSnapCount", wireType) } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF + m.SendingSnapCount = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.SendingSnapCount |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } } - m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *AskBatchSplitRequest) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ReceivingSnapCount", wireType) } - if iNdEx >= l { - return io.ErrUnexpectedEOF + m.ReceivingSnapCount = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ReceivingSnapCount |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field StartTime", wireType) } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: AskBatchSplitRequest: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: AskBatchSplitRequest: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + m.StartTime = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.StartTime |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ApplyingSnapCount", wireType) } - var msglen int + m.ApplyingSnapCount = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -26075,33 +28873,16 @@ func (m *AskBatchSplitRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + m.ApplyingSnapCount |= uint32(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { - return ErrInvalidLengthPdpb - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthPdpb - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Header == nil { - m.Header = &RequestHeader{} - } - if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Region", wireType) + case 9: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field IsBusy", wireType) } - var msglen int + var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -26111,33 +28892,17 @@ func (m *AskBatchSplitRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + v |= int(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { - return ErrInvalidLengthPdpb - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthPdpb - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Region == nil { - m.Region = &metapb.Region{} - } - if err := m.Region.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 3: + m.IsBusy = bool(v != 0) + case 10: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field SplitCount", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field UsedSize", wireType) } - m.SplitCount = 0 + m.UsedSize = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -26147,67 +28912,16 @@ func (m *AskBatchSplitRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.SplitCount |= uint32(b&0x7F) << shift + m.UsedSize |= uint64(b&0x7F) << shift if b < 0x80 { break } } - default: - iNdEx = preIndex - skippy, err := skipPdpb(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthPdpb - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *SplitID) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: SplitID: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: SplitID: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + case 11: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field NewRegionId", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field BytesWritten", wireType) } - m.NewRegionId = 0 + m.BytesWritten = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -26217,143 +28931,35 @@ func (m *SplitID) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.NewRegionId |= uint64(b&0x7F) << shift + m.BytesWritten |= uint64(b&0x7F) << shift if b < 0x80 { break } } - case 2: - if wireType == 0 { - var v uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - v |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - m.NewPeerIds = append(m.NewPeerIds, v) - } else if wireType == 2 { - var packedLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - packedLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if packedLen < 0 { - return ErrInvalidLengthPdpb - } - postIndex := iNdEx + packedLen - if postIndex < 0 { - return ErrInvalidLengthPdpb + case 12: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field KeysWritten", wireType) + } + m.KeysWritten = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb } - if postIndex > l { + if iNdEx >= l { return io.ErrUnexpectedEOF } - var elementCount int - var count int - for _, integer := range dAtA[iNdEx:postIndex] { - if integer < 128 { - count++ - } - } - elementCount = count - if elementCount != 0 && len(m.NewPeerIds) == 0 { - m.NewPeerIds = make([]uint64, 0, elementCount) - } - for iNdEx < postIndex { - var v uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - v |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - m.NewPeerIds = append(m.NewPeerIds, v) - } - } else { - return fmt.Errorf("proto: wrong wireType = %d for field NewPeerIds", wireType) - } - default: - iNdEx = preIndex - skippy, err := skipPdpb(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthPdpb - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *AskBatchSplitResponse) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: AskBatchSplitResponse: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: AskBatchSplitResponse: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + b := dAtA[iNdEx] + iNdEx++ + m.KeysWritten |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } } - var msglen int + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field BytesRead", wireType) + } + m.BytesRead = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -26363,31 +28969,33 @@ func (m *AskBatchSplitResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + m.BytesRead |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { - return ErrInvalidLengthPdpb - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthPdpb - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Header == nil { - m.Header = &ResponseHeader{} + case 14: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field KeysRead", wireType) } - if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + m.KeysRead = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.KeysRead |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } } - iNdEx = postIndex - case 2: + case 15: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Ids", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Interval", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -26414,65 +29022,16 @@ func (m *AskBatchSplitResponse) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Ids = append(m.Ids, &SplitID{}) - if err := m.Ids[len(m.Ids)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + if m.Interval == nil { + m.Interval = &TimeInterval{} } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipPdpb(dAtA[iNdEx:]) - if err != nil { + if err := m.Interval.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthPdpb - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *ReportBatchSplitRequest) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: ReportBatchSplitRequest: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: ReportBatchSplitRequest: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + iNdEx = postIndex + case 16: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field CpuUsages", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -26499,16 +29058,14 @@ func (m *ReportBatchSplitRequest) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Header == nil { - m.Header = &RequestHeader{} - } - if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.CpuUsages = append(m.CpuUsages, &RecordPair{}) + if err := m.CpuUsages[len(m.CpuUsages)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 2: + case 17: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Regions", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ReadIoRates", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -26535,65 +29092,14 @@ func (m *ReportBatchSplitRequest) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Regions = append(m.Regions, &metapb.Region{}) - if err := m.Regions[len(m.Regions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.ReadIoRates = append(m.ReadIoRates, &RecordPair{}) + if err := m.ReadIoRates[len(m.ReadIoRates)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipPdpb(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthPdpb - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *ReportBatchSplitResponse) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: ReportBatchSplitResponse: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: ReportBatchSplitResponse: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + case 18: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field WriteIoRates", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -26620,88 +29126,16 @@ func (m *ReportBatchSplitResponse) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Header == nil { - m.Header = &ResponseHeader{} - } - if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipPdpb(dAtA[iNdEx:]) - if err != nil { + m.WriteIoRates = append(m.WriteIoRates, &RecordPair{}) + if err := m.WriteIoRates[len(m.WriteIoRates)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthPdpb - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *TimeInterval) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: TimeInterval: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: TimeInterval: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field StartTimestamp", wireType) - } - m.StartTimestamp = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.StartTimestamp |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field EndTimestamp", wireType) + iNdEx = postIndex + case 19: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field OpLatencies", wireType) } - m.EndTimestamp = 0 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -26711,67 +29145,31 @@ func (m *TimeInterval) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.EndTimestamp |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - default: - iNdEx = preIndex - skippy, err := skipPdpb(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { + if msglen < 0 { return ErrInvalidLengthPdpb } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *RecordPair) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthPdpb } - if iNdEx >= l { + if postIndex > l { return io.ErrUnexpectedEOF } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break + m.OpLatencies = append(m.OpLatencies, &RecordPair{}) + if err := m.OpLatencies[len(m.OpLatencies)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: RecordPair: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: RecordPair: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + iNdEx = postIndex + case 20: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field PeerStats", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -26781,29 +29179,31 @@ func (m *RecordPair) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + if msglen < 0 { return ErrInvalidLengthPdpb } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthPdpb } if postIndex > l { return io.ErrUnexpectedEOF } - m.Key = string(dAtA[iNdEx:postIndex]) + m.PeerStats = append(m.PeerStats, &PeerStat{}) + if err := m.PeerStats[len(m.PeerStats)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } iNdEx = postIndex - case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + case 21: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field QueryStats", wireType) } - m.Value = 0 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -26813,67 +29213,33 @@ func (m *RecordPair) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Value |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - default: - iNdEx = preIndex - skippy, err := skipPdpb(dAtA[iNdEx:]) - if err != nil { - return err + if msglen < 0 { + return ErrInvalidLengthPdpb } - if (skippy < 0) || (iNdEx+skippy) < 0 { + postIndex := iNdEx + msglen + if postIndex < 0 { return ErrInvalidLengthPdpb } - if (iNdEx + skippy) > l { + if postIndex > l { return io.ErrUnexpectedEOF } - m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *PeerStat) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF + if m.QueryStats == nil { + m.QueryStats = &QueryStats{} } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break + if err := m.QueryStats.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: PeerStat: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: PeerStat: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + iNdEx = postIndex + case 22: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field RegionId", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field SlowScore", wireType) } - m.RegionId = 0 + m.SlowScore = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -26883,35 +29249,92 @@ func (m *PeerStat) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.RegionId |= uint64(b&0x7F) << shift + m.SlowScore |= uint64(b&0x7F) << shift if b < 0x80 { break } } - case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field ReadKeys", wireType) - } - m.ReadKeys = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb + case 23: + if wireType == 0 { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } } - if iNdEx >= l { + m.DamagedRegionsId = append(m.DamagedRegionsId, v) + } else if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + packedLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthPdpb + } + postIndex := iNdEx + packedLen + if postIndex < 0 { + return ErrInvalidLengthPdpb + } + if postIndex > l { return io.ErrUnexpectedEOF } - b := dAtA[iNdEx] - iNdEx++ - m.ReadKeys |= uint64(b&0x7F) << shift - if b < 0x80 { - break + var elementCount int + var count int + for _, integer := range dAtA[iNdEx:postIndex] { + if integer < 128 { + count++ + } + } + elementCount = count + if elementCount != 0 && len(m.DamagedRegionsId) == 0 { + m.DamagedRegionsId = make([]uint64, 0, elementCount) + } + for iNdEx < postIndex { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.DamagedRegionsId = append(m.DamagedRegionsId, v) } + } else { + return fmt.Errorf("proto: wrong wireType = %d for field DamagedRegionsId", wireType) } - case 3: + case 24: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field ReadBytes", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field IsApplyBusy", wireType) } - m.ReadBytes = 0 + var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -26921,14 +29344,15 @@ func (m *PeerStat) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.ReadBytes |= uint64(b&0x7F) << shift + v |= int(b&0x7F) << shift if b < 0x80 { break } } - case 4: + m.IsApplyBusy = bool(v != 0) + case 25: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field QueryStats", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field SnapshotStats", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -26955,18 +29379,16 @@ func (m *PeerStat) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.QueryStats == nil { - m.QueryStats = &QueryStats{} - } - if err := m.QueryStats.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.SnapshotStats = append(m.SnapshotStats, &SnapshotStat{}) + if err := m.SnapshotStats[len(m.SnapshotStats)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 5: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field WrittenKeys", wireType) + case 26: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SlowTrend", wireType) } - m.WrittenKeys = 0 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -26976,30 +29398,28 @@ func (m *PeerStat) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.WrittenKeys |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - case 6: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field WrittenBytes", wireType) + if msglen < 0 { + return ErrInvalidLengthPdpb } - m.WrittenBytes = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.WrittenBytes |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthPdpb } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SlowTrend == nil { + m.SlowTrend = &SlowTrend{} + } + if err := m.SlowTrend.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) @@ -27022,7 +29442,7 @@ func (m *PeerStat) Unmarshal(dAtA []byte) error { } return nil } -func (m *StoreStats) Unmarshal(dAtA []byte) error { +func (m *SlowTrend) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -27045,169 +29465,112 @@ func (m *StoreStats) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: StoreStats: wiretype end group for non-group") + return fmt.Errorf("proto: SlowTrend: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: StoreStats: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: SlowTrend: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field StoreId", wireType) + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field CauseValue", wireType) } - m.StoreId = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.StoreId |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF } + v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) + iNdEx += 8 + m.CauseValue = float64(math.Float64frombits(v)) case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Capacity", wireType) + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field CauseRate", wireType) } - m.Capacity = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.Capacity |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF } + v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) + iNdEx += 8 + m.CauseRate = float64(math.Float64frombits(v)) case 3: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Available", wireType) + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field ResultValue", wireType) } - m.Available = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.Available |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF } + v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) + iNdEx += 8 + m.ResultValue = float64(math.Float64frombits(v)) case 4: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field RegionCount", wireType) - } - m.RegionCount = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.RegionCount |= uint32(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 5: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field SendingSnapCount", wireType) + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field ResultRate", wireType) } - m.SendingSnapCount = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.SendingSnapCount |= uint32(b&0x7F) << shift - if b < 0x80 { - break - } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF } - case 6: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field ReceivingSnapCount", wireType) + v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) + iNdEx += 8 + m.ResultRate = float64(math.Float64frombits(v)) + default: + iNdEx = preIndex + skippy, err := skipPdpb(dAtA[iNdEx:]) + if err != nil { + return err } - m.ReceivingSnapCount = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.ReceivingSnapCount |= uint32(b&0x7F) << shift - if b < 0x80 { - break - } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthPdpb } - case 7: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field StartTime", wireType) + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF } - m.StartTime = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.StartTime |= uint32(b&0x7F) << shift - if b < 0x80 { - break - } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SnapshotStat) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb } - case 8: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field ApplyingSnapCount", wireType) + if iNdEx >= l { + return io.ErrUnexpectedEOF } - m.ApplyingSnapCount = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.ApplyingSnapCount |= uint32(b&0x7F) << shift - if b < 0x80 { - break - } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break } - case 9: + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: SnapshotStat: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SnapshotStat: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field IsBusy", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field RegionId", wireType) } - var v int + m.RegionId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -27217,17 +29580,16 @@ func (m *StoreStats) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - v |= int(b&0x7F) << shift + m.RegionId |= uint64(b&0x7F) << shift if b < 0x80 { break } } - m.IsBusy = bool(v != 0) - case 10: + case 2: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field UsedSize", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field GenerateDurationSec", wireType) } - m.UsedSize = 0 + m.GenerateDurationSec = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -27237,16 +29599,16 @@ func (m *StoreStats) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.UsedSize |= uint64(b&0x7F) << shift + m.GenerateDurationSec |= uint64(b&0x7F) << shift if b < 0x80 { break } } - case 11: + case 3: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field BytesWritten", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field SendDurationSec", wireType) } - m.BytesWritten = 0 + m.SendDurationSec = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -27256,16 +29618,16 @@ func (m *StoreStats) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.BytesWritten |= uint64(b&0x7F) << shift + m.SendDurationSec |= uint64(b&0x7F) << shift if b < 0x80 { break } } - case 12: + case 4: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field KeysWritten", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field TotalDurationSec", wireType) } - m.KeysWritten = 0 + m.TotalDurationSec = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -27275,16 +29637,16 @@ func (m *StoreStats) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.KeysWritten |= uint64(b&0x7F) << shift + m.TotalDurationSec |= uint64(b&0x7F) << shift if b < 0x80 { break } } - case 13: + case 5: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field BytesRead", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field TransportSize", wireType) } - m.BytesRead = 0 + m.TransportSize = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -27294,33 +29656,65 @@ func (m *StoreStats) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.BytesRead |= uint64(b&0x7F) << shift + m.TransportSize |= uint64(b&0x7F) << shift if b < 0x80 { break } } - case 14: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field KeysRead", wireType) + default: + iNdEx = preIndex + skippy, err := skipPdpb(dAtA[iNdEx:]) + if err != nil { + return err } - m.KeysRead = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.KeysRead |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthPdpb } - case 15: + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *PeerReport) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: PeerReport: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: PeerReport: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Interval", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field RaftState", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -27347,16 +29741,16 @@ func (m *StoreStats) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Interval == nil { - m.Interval = &TimeInterval{} + if m.RaftState == nil { + m.RaftState = &raft_serverpb.RaftLocalState{} } - if err := m.Interval.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.RaftState.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 16: + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field CpuUsages", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field RegionState", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -27383,16 +29777,18 @@ func (m *StoreStats) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.CpuUsages = append(m.CpuUsages, &RecordPair{}) - if err := m.CpuUsages[len(m.CpuUsages)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if m.RegionState == nil { + m.RegionState = &raft_serverpb.RegionLocalState{} + } + if err := m.RegionState.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 17: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ReadIoRates", wireType) + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field IsForceLeader", wireType) } - var msglen int + var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -27402,29 +29798,86 @@ func (m *StoreStats) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + v |= int(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { - return ErrInvalidLengthPdpb + m.IsForceLeader = bool(v != 0) + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field HasCommitMerge", wireType) } - postIndex := iNdEx + msglen - if postIndex < 0 { + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.HasCommitMerge = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := skipPdpb(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthPdpb } - if postIndex > l { + if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } - m.ReadIoRates = append(m.ReadIoRates, &RecordPair{}) - if err := m.ReadIoRates[len(m.ReadIoRates)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *StoreReport) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb } - iNdEx = postIndex - case 18: + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: StoreReport: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: StoreReport: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field WriteIoRates", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field PeerReports", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -27451,16 +29904,16 @@ func (m *StoreStats) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.WriteIoRates = append(m.WriteIoRates, &RecordPair{}) - if err := m.WriteIoRates[len(m.WriteIoRates)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.PeerReports = append(m.PeerReports, &PeerReport{}) + if err := m.PeerReports[len(m.PeerReports)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 19: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field OpLatencies", wireType) + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Step", wireType) } - var msglen int + m.Step = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -27470,29 +29923,65 @@ func (m *StoreStats) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + m.Step |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { - return ErrInvalidLengthPdpb + default: + iNdEx = preIndex + skippy, err := skipPdpb(dAtA[iNdEx:]) + if err != nil { + return err } - postIndex := iNdEx + msglen - if postIndex < 0 { + if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthPdpb } - if postIndex > l { + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *StoreHeartbeatRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { return io.ErrUnexpectedEOF } - m.OpLatencies = append(m.OpLatencies, &RecordPair{}) - if err := m.OpLatencies[len(m.OpLatencies)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break } - iNdEx = postIndex - case 20: + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: StoreHeartbeatRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: StoreHeartbeatRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field PeerStats", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -27519,14 +30008,16 @@ func (m *StoreStats) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.PeerStats = append(m.PeerStats, &PeerStat{}) - if err := m.PeerStats[len(m.PeerStats)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if m.Header == nil { + m.Header = &RequestHeader{} + } + if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 21: + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field QueryStats", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Stats", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -27553,131 +30044,16 @@ func (m *StoreStats) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.QueryStats == nil { - m.QueryStats = &QueryStats{} + if m.Stats == nil { + m.Stats = &StoreStats{} } - if err := m.QueryStats.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Stats.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 22: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field SlowScore", wireType) - } - m.SlowScore = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.SlowScore |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 23: - if wireType == 0 { - var v uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - v |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - m.DamagedRegionsId = append(m.DamagedRegionsId, v) - } else if wireType == 2 { - var packedLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - packedLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if packedLen < 0 { - return ErrInvalidLengthPdpb - } - postIndex := iNdEx + packedLen - if postIndex < 0 { - return ErrInvalidLengthPdpb - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - var elementCount int - var count int - for _, integer := range dAtA[iNdEx:postIndex] { - if integer < 128 { - count++ - } - } - elementCount = count - if elementCount != 0 && len(m.DamagedRegionsId) == 0 { - m.DamagedRegionsId = make([]uint64, 0, elementCount) - } - for iNdEx < postIndex { - var v uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - v |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - m.DamagedRegionsId = append(m.DamagedRegionsId, v) - } - } else { - return fmt.Errorf("proto: wrong wireType = %d for field DamagedRegionsId", wireType) - } - case 24: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field IsApplyBusy", wireType) - } - var v int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - v |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - m.IsApplyBusy = bool(v != 0) - case 25: + case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field SnapshotStats", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field StoreReport", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -27704,14 +30080,16 @@ func (m *StoreStats) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.SnapshotStats = append(m.SnapshotStats, &SnapshotStat{}) - if err := m.SnapshotStats[len(m.SnapshotStats)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if m.StoreReport == nil { + m.StoreReport = &StoreReport{} + } + if err := m.StoreReport.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 26: + case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field SlowTrend", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field DrAutosyncStatus", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -27738,10 +30116,10 @@ func (m *StoreStats) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.SlowTrend == nil { - m.SlowTrend = &SlowTrend{} + if m.DrAutosyncStatus == nil { + m.DrAutosyncStatus = &replication_modepb.StoreDRAutoSyncStatus{} } - if err := m.SlowTrend.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.DrAutosyncStatus.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -27767,7 +30145,7 @@ func (m *StoreStats) Unmarshal(dAtA []byte) error { } return nil } -func (m *SlowTrend) Unmarshal(dAtA []byte) error { +func (m *DemoteFailedVoters) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -27790,56 +30168,65 @@ func (m *SlowTrend) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: SlowTrend: wiretype end group for non-group") + return fmt.Errorf("proto: DemoteFailedVoters: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: SlowTrend: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: DemoteFailedVoters: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 1 { - return fmt.Errorf("proto: wrong wireType = %d for field CauseValue", wireType) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field RegionId", wireType) } - var v uint64 - if (iNdEx + 8) > l { - return io.ErrUnexpectedEOF + m.RegionId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.RegionId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } } - v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) - iNdEx += 8 - m.CauseValue = float64(math.Float64frombits(v)) case 2: - if wireType != 1 { - return fmt.Errorf("proto: wrong wireType = %d for field CauseRate", wireType) - } - var v uint64 - if (iNdEx + 8) > l { - return io.ErrUnexpectedEOF + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FailedVoters", wireType) } - v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) - iNdEx += 8 - m.CauseRate = float64(math.Float64frombits(v)) - case 3: - if wireType != 1 { - return fmt.Errorf("proto: wrong wireType = %d for field ResultValue", wireType) + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } } - var v uint64 - if (iNdEx + 8) > l { - return io.ErrUnexpectedEOF + if msglen < 0 { + return ErrInvalidLengthPdpb } - v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) - iNdEx += 8 - m.ResultValue = float64(math.Float64frombits(v)) - case 4: - if wireType != 1 { - return fmt.Errorf("proto: wrong wireType = %d for field ResultRate", wireType) + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthPdpb } - var v uint64 - if (iNdEx + 8) > l { + if postIndex > l { return io.ErrUnexpectedEOF } - v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) - iNdEx += 8 - m.ResultRate = float64(math.Float64frombits(v)) + m.FailedVoters = append(m.FailedVoters, &metapb.Peer{}) + if err := m.FailedVoters[len(m.FailedVoters)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) @@ -27862,7 +30249,7 @@ func (m *SlowTrend) Unmarshal(dAtA []byte) error { } return nil } -func (m *SnapshotStat) Unmarshal(dAtA []byte) error { +func (m *ForceLeader) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -27885,106 +30272,163 @@ func (m *SnapshotStat) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: SnapshotStat: wiretype end group for non-group") + return fmt.Errorf("proto: ForceLeader: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: SnapshotStat: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: ForceLeader: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field RegionId", wireType) - } - m.RegionId = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb + if wireType == 0 { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } } - if iNdEx >= l { - return io.ErrUnexpectedEOF + m.FailedStores = append(m.FailedStores, v) + } else if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + packedLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } } - b := dAtA[iNdEx] - iNdEx++ - m.RegionId |= uint64(b&0x7F) << shift - if b < 0x80 { - break + if packedLen < 0 { + return ErrInvalidLengthPdpb } - } - case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field GenerateDurationSec", wireType) - } - m.GenerateDurationSec = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb + postIndex := iNdEx + packedLen + if postIndex < 0 { + return ErrInvalidLengthPdpb } - if iNdEx >= l { + if postIndex > l { return io.ErrUnexpectedEOF } - b := dAtA[iNdEx] - iNdEx++ - m.GenerateDurationSec |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 3: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field SendDurationSec", wireType) - } - m.SendDurationSec = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb + var elementCount int + var count int + for _, integer := range dAtA[iNdEx:postIndex] { + if integer < 128 { + count++ + } } - if iNdEx >= l { - return io.ErrUnexpectedEOF + elementCount = count + if elementCount != 0 && len(m.FailedStores) == 0 { + m.FailedStores = make([]uint64, 0, elementCount) } - b := dAtA[iNdEx] - iNdEx++ - m.SendDurationSec |= uint64(b&0x7F) << shift - if b < 0x80 { - break + for iNdEx < postIndex { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.FailedStores = append(m.FailedStores, v) } + } else { + return fmt.Errorf("proto: wrong wireType = %d for field FailedStores", wireType) } - case 4: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field TotalDurationSec", wireType) - } - m.TotalDurationSec = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb + case 2: + if wireType == 0 { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } } - if iNdEx >= l { - return io.ErrUnexpectedEOF + m.EnterForceLeaders = append(m.EnterForceLeaders, v) + } else if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + packedLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } } - b := dAtA[iNdEx] - iNdEx++ - m.TotalDurationSec |= uint64(b&0x7F) << shift - if b < 0x80 { - break + if packedLen < 0 { + return ErrInvalidLengthPdpb } - } - case 5: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field TransportSize", wireType) - } - m.TransportSize = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb + postIndex := iNdEx + packedLen + if postIndex < 0 { + return ErrInvalidLengthPdpb } - if iNdEx >= l { + if postIndex > l { return io.ErrUnexpectedEOF } - b := dAtA[iNdEx] - iNdEx++ - m.TransportSize |= uint64(b&0x7F) << shift - if b < 0x80 { - break + var elementCount int + var count int + for _, integer := range dAtA[iNdEx:postIndex] { + if integer < 128 { + count++ + } + } + elementCount = count + if elementCount != 0 && len(m.EnterForceLeaders) == 0 { + m.EnterForceLeaders = make([]uint64, 0, elementCount) + } + for iNdEx < postIndex { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.EnterForceLeaders = append(m.EnterForceLeaders, v) } + } else { + return fmt.Errorf("proto: wrong wireType = %d for field EnterForceLeaders", wireType) } default: iNdEx = preIndex @@ -28008,7 +30452,7 @@ func (m *SnapshotStat) Unmarshal(dAtA []byte) error { } return nil } -func (m *PeerReport) Unmarshal(dAtA []byte) error { +func (m *RecoveryPlan) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -28031,15 +30475,49 @@ func (m *PeerReport) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: PeerReport: wiretype end group for non-group") + return fmt.Errorf("proto: RecoveryPlan: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: PeerReport: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: RecoveryPlan: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field RaftState", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Creates", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthPdpb + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthPdpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Creates = append(m.Creates, &metapb.Region{}) + if err := m.Creates[len(m.Creates)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Updates", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -28066,16 +30544,90 @@ func (m *PeerReport) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.RaftState == nil { - m.RaftState = &raft_serverpb.RaftLocalState{} - } - if err := m.RaftState.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.Updates = append(m.Updates, &metapb.Region{}) + if err := m.Updates[len(m.Updates)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 2: + case 3: + if wireType == 0 { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Tombstones = append(m.Tombstones, v) + } else if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + packedLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthPdpb + } + postIndex := iNdEx + packedLen + if postIndex < 0 { + return ErrInvalidLengthPdpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + var elementCount int + var count int + for _, integer := range dAtA[iNdEx:postIndex] { + if integer < 128 { + count++ + } + } + elementCount = count + if elementCount != 0 && len(m.Tombstones) == 0 { + m.Tombstones = make([]uint64, 0, elementCount) + } + for iNdEx < postIndex { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Tombstones = append(m.Tombstones, v) + } + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Tombstones", wireType) + } + case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field RegionState", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Demotes", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -28102,18 +30654,16 @@ func (m *PeerReport) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.RegionState == nil { - m.RegionState = &raft_serverpb.RegionLocalState{} - } - if err := m.RegionState.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.Demotes = append(m.Demotes, &DemoteFailedVoters{}) + if err := m.Demotes[len(m.Demotes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 3: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field IsForceLeader", wireType) + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ForceLeader", wireType) } - var v int + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -28123,17 +30673,33 @@ func (m *PeerReport) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - v |= int(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - m.IsForceLeader = bool(v != 0) - case 4: + if msglen < 0 { + return ErrInvalidLengthPdpb + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthPdpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ForceLeader == nil { + m.ForceLeader = &ForceLeader{} + } + if err := m.ForceLeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field HasCommitMerge", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Step", wireType) } - var v int + m.Step = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -28143,12 +30709,11 @@ func (m *PeerReport) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - v |= int(b&0x7F) << shift + m.Step |= uint64(b&0x7F) << shift if b < 0x80 { break } } - m.HasCommitMerge = bool(v != 0) default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) @@ -28171,7 +30736,7 @@ func (m *PeerReport) Unmarshal(dAtA []byte) error { } return nil } -func (m *StoreReport) Unmarshal(dAtA []byte) error { +func (m *AwakenRegions) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -28194,64 +30759,87 @@ func (m *StoreReport) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: StoreReport: wiretype end group for non-group") + return fmt.Errorf("proto: AwakenRegions: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: StoreReport: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: AwakenRegions: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field PeerReports", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb + if wireType == 0 { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } } - if iNdEx >= l { - return io.ErrUnexpectedEOF + m.AbnormalStores = append(m.AbnormalStores, v) + } else if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + packedLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break + if packedLen < 0 { + return ErrInvalidLengthPdpb } - } - if msglen < 0 { - return ErrInvalidLengthPdpb - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthPdpb - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.PeerReports = append(m.PeerReports, &PeerReport{}) - if err := m.PeerReports[len(m.PeerReports)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Step", wireType) - } - m.Step = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb + postIndex := iNdEx + packedLen + if postIndex < 0 { + return ErrInvalidLengthPdpb } - if iNdEx >= l { + if postIndex > l { return io.ErrUnexpectedEOF } - b := dAtA[iNdEx] - iNdEx++ - m.Step |= uint64(b&0x7F) << shift - if b < 0x80 { - break + var elementCount int + var count int + for _, integer := range dAtA[iNdEx:postIndex] { + if integer < 128 { + count++ + } + } + elementCount = count + if elementCount != 0 && len(m.AbnormalStores) == 0 { + m.AbnormalStores = make([]uint64, 0, elementCount) + } + for iNdEx < postIndex { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.AbnormalStores = append(m.AbnormalStores, v) } + } else { + return fmt.Errorf("proto: wrong wireType = %d for field AbnormalStores", wireType) } default: iNdEx = preIndex @@ -28275,7 +30863,7 @@ func (m *StoreReport) Unmarshal(dAtA []byte) error { } return nil } -func (m *StoreHeartbeatRequest) Unmarshal(dAtA []byte) error { +func (m *StoreHeartbeatResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -28298,10 +30886,10 @@ func (m *StoreHeartbeatRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: StoreHeartbeatRequest: wiretype end group for non-group") + return fmt.Errorf("proto: StoreHeartbeatResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: StoreHeartbeatRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: StoreHeartbeatResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -28334,7 +30922,7 @@ func (m *StoreHeartbeatRequest) Unmarshal(dAtA []byte) error { return io.ErrUnexpectedEOF } if m.Header == nil { - m.Header = &RequestHeader{} + m.Header = &ResponseHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err @@ -28342,7 +30930,7 @@ func (m *StoreHeartbeatRequest) Unmarshal(dAtA []byte) error { iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Stats", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ReplicationStatus", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -28369,16 +30957,68 @@ func (m *StoreHeartbeatRequest) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Stats == nil { - m.Stats = &StoreStats{} + if m.ReplicationStatus == nil { + m.ReplicationStatus = &replication_modepb.ReplicationStatus{} } - if err := m.Stats.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.ReplicationStatus.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field StoreReport", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ClusterVersion", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthPdpb + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthPdpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ClusterVersion = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field RequireDetailedReport", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.RequireDetailedReport = bool(v != 0) + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RecoveryPlan", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -28405,16 +31045,16 @@ func (m *StoreHeartbeatRequest) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.StoreReport == nil { - m.StoreReport = &StoreReport{} + if m.RecoveryPlan == nil { + m.RecoveryPlan = &RecoveryPlan{} } - if err := m.StoreReport.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.RecoveryPlan.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 4: + case 6: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field DrAutosyncStatus", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field AwakenRegions", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -28441,10 +31081,10 @@ func (m *StoreHeartbeatRequest) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.DrAutosyncStatus == nil { - m.DrAutosyncStatus = &replication_modepb.StoreDRAutoSyncStatus{} + if m.AwakenRegions == nil { + m.AwakenRegions = &AwakenRegions{} } - if err := m.DrAutosyncStatus.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.AwakenRegions.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -28470,7 +31110,7 @@ func (m *StoreHeartbeatRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *DemoteFailedVoters) Unmarshal(dAtA []byte) error { +func (m *ScatterRegionRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -28493,13 +31133,49 @@ func (m *DemoteFailedVoters) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: DemoteFailedVoters: wiretype end group for non-group") + return fmt.Errorf("proto: ScatterRegionRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: DemoteFailedVoters: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: ScatterRegionRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthPdpb + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthPdpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Header == nil { + m.Header = &RequestHeader{} + } + if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field RegionId", wireType) } @@ -28518,9 +31194,9 @@ func (m *DemoteFailedVoters) Unmarshal(dAtA []byte) error { break } } - case 2: + case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field FailedVoters", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Region", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -28547,139 +31223,82 @@ func (m *DemoteFailedVoters) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.FailedVoters = append(m.FailedVoters, &metapb.Peer{}) - if err := m.FailedVoters[len(m.FailedVoters)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if m.Region == nil { + m.Region = &metapb.Region{} + } + if err := m.Region.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipPdpb(dAtA[iNdEx:]) - if err != nil { - return err + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Leader", wireType) } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthPdpb + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF + if msglen < 0 { + return ErrInvalidLengthPdpb } - m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *ForceLeader) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthPdpb } - if iNdEx >= l { + if postIndex > l { return io.ErrUnexpectedEOF } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break + if m.Leader == nil { + m.Leader = &metapb.Peer{} } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: ForceLeader: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: ForceLeader: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType == 0 { - var v uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - v |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - m.FailedStores = append(m.FailedStores, v) - } else if wireType == 2 { - var packedLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - packedLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if packedLen < 0 { - return ErrInvalidLengthPdpb - } - postIndex := iNdEx + packedLen - if postIndex < 0 { - return ErrInvalidLengthPdpb + if err := m.Leader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Group", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb } - if postIndex > l { + if iNdEx >= l { return io.ErrUnexpectedEOF } - var elementCount int - var count int - for _, integer := range dAtA[iNdEx:postIndex] { - if integer < 128 { - count++ - } - } - elementCount = count - if elementCount != 0 && len(m.FailedStores) == 0 { - m.FailedStores = make([]uint64, 0, elementCount) - } - for iNdEx < postIndex { - var v uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - v |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - m.FailedStores = append(m.FailedStores, v) + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break } - } else { - return fmt.Errorf("proto: wrong wireType = %d for field FailedStores", wireType) } - case 2: + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthPdpb + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthPdpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Group = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: if wireType == 0 { var v uint64 for shift := uint(0); ; shift += 7 { @@ -28696,7 +31315,7 @@ func (m *ForceLeader) Unmarshal(dAtA []byte) error { break } } - m.EnterForceLeaders = append(m.EnterForceLeaders, v) + m.RegionsId = append(m.RegionsId, v) } else if wireType == 2 { var packedLen int for shift := uint(0); ; shift += 7 { @@ -28731,8 +31350,8 @@ func (m *ForceLeader) Unmarshal(dAtA []byte) error { } } elementCount = count - if elementCount != 0 && len(m.EnterForceLeaders) == 0 { - m.EnterForceLeaders = make([]uint64, 0, elementCount) + if elementCount != 0 && len(m.RegionsId) == 0 { + m.RegionsId = make([]uint64, 0, elementCount) } for iNdEx < postIndex { var v uint64 @@ -28750,10 +31369,29 @@ func (m *ForceLeader) Unmarshal(dAtA []byte) error { break } } - m.EnterForceLeaders = append(m.EnterForceLeaders, v) + m.RegionsId = append(m.RegionsId, v) } } else { - return fmt.Errorf("proto: wrong wireType = %d for field EnterForceLeaders", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field RegionsId", wireType) + } + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field RetryLimit", wireType) + } + m.RetryLimit = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.RetryLimit |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } } default: iNdEx = preIndex @@ -28777,7 +31415,7 @@ func (m *ForceLeader) Unmarshal(dAtA []byte) error { } return nil } -func (m *RecoveryPlan) Unmarshal(dAtA []byte) error { +func (m *ScatterRegionResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -28800,15 +31438,15 @@ func (m *RecoveryPlan) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: RecoveryPlan: wiretype end group for non-group") + return fmt.Errorf("proto: ScatterRegionResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: RecoveryPlan: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: ScatterRegionResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Creates", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -28835,14 +31473,86 @@ func (m *RecoveryPlan) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Creates = append(m.Creates, &metapb.Region{}) - if err := m.Creates[len(m.Creates)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if m.Header == nil { + m.Header = &ResponseHeader{} + } + if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FinishedPercentage", wireType) + } + m.FinishedPercentage = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.FinishedPercentage |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipPdpb(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthPdpb + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *GetGCSafePointRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: GetGCSafePointRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GetGCSafePointRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Updates", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -28869,90 +31579,67 @@ func (m *RecoveryPlan) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Updates = append(m.Updates, &metapb.Region{}) - if err := m.Updates[len(m.Updates)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 3: - if wireType == 0 { - var v uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - v |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - m.Tombstones = append(m.Tombstones, v) - } else if wireType == 2 { - var packedLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - packedLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if packedLen < 0 { - return ErrInvalidLengthPdpb - } - postIndex := iNdEx + packedLen - if postIndex < 0 { - return ErrInvalidLengthPdpb - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - var elementCount int - var count int - for _, integer := range dAtA[iNdEx:postIndex] { - if integer < 128 { - count++ - } - } - elementCount = count - if elementCount != 0 && len(m.Tombstones) == 0 { - m.Tombstones = make([]uint64, 0, elementCount) - } - for iNdEx < postIndex { - var v uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - v |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - m.Tombstones = append(m.Tombstones, v) - } - } else { - return fmt.Errorf("proto: wrong wireType = %d for field Tombstones", wireType) + if m.Header == nil { + m.Header = &RequestHeader{} } - case 4: + if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipPdpb(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthPdpb + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *GetGCSafePointResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: GetGCSafePointResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GetGCSafePointResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Demotes", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -28979,14 +31666,86 @@ func (m *RecoveryPlan) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Demotes = append(m.Demotes, &DemoteFailedVoters{}) - if err := m.Demotes[len(m.Demotes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if m.Header == nil { + m.Header = &ResponseHeader{} + } + if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 5: + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field SafePoint", wireType) + } + m.SafePoint = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.SafePoint |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipPdpb(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthPdpb + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *UpdateGCSafePointRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: UpdateGCSafePointRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: UpdateGCSafePointRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ForceLeader", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -29013,18 +31772,18 @@ func (m *RecoveryPlan) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.ForceLeader == nil { - m.ForceLeader = &ForceLeader{} + if m.Header == nil { + m.Header = &RequestHeader{} } - if err := m.ForceLeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 6: + case 2: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Step", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field SafePoint", wireType) } - m.Step = 0 + m.SafePoint = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -29034,7 +31793,7 @@ func (m *RecoveryPlan) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Step |= uint64(b&0x7F) << shift + m.SafePoint |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -29061,7 +31820,7 @@ func (m *RecoveryPlan) Unmarshal(dAtA []byte) error { } return nil } -func (m *AwakenRegions) Unmarshal(dAtA []byte) error { +func (m *UpdateGCSafePointResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -29084,87 +31843,66 @@ func (m *AwakenRegions) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: AwakenRegions: wiretype end group for non-group") + return fmt.Errorf("proto: UpdateGCSafePointResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: AwakenRegions: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: UpdateGCSafePointResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType == 0 { - var v uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - v |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - m.AbnormalStores = append(m.AbnormalStores, v) - } else if wireType == 2 { - var packedLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - packedLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if packedLen < 0 { - return ErrInvalidLengthPdpb - } - postIndex := iNdEx + packedLen - if postIndex < 0 { - return ErrInvalidLengthPdpb + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb } - if postIndex > l { + if iNdEx >= l { return io.ErrUnexpectedEOF } - var elementCount int - var count int - for _, integer := range dAtA[iNdEx:postIndex] { - if integer < 128 { - count++ - } - } - elementCount = count - if elementCount != 0 && len(m.AbnormalStores) == 0 { - m.AbnormalStores = make([]uint64, 0, elementCount) + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break } - for iNdEx < postIndex { - var v uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - v |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - m.AbnormalStores = append(m.AbnormalStores, v) + } + if msglen < 0 { + return ErrInvalidLengthPdpb + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthPdpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Header == nil { + m.Header = &ResponseHeader{} + } + if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field NewSafePoint", wireType) + } + m.NewSafePoint = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.NewSafePoint |= uint64(b&0x7F) << shift + if b < 0x80 { + break } - } else { - return fmt.Errorf("proto: wrong wireType = %d for field AbnormalStores", wireType) } default: iNdEx = preIndex @@ -29188,7 +31926,7 @@ func (m *AwakenRegions) Unmarshal(dAtA []byte) error { } return nil } -func (m *StoreHeartbeatResponse) Unmarshal(dAtA []byte) error { +func (m *UpdateServiceGCSafePointRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -29211,10 +31949,10 @@ func (m *StoreHeartbeatResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: StoreHeartbeatResponse: wiretype end group for non-group") + return fmt.Errorf("proto: UpdateServiceGCSafePointRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: StoreHeartbeatResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: UpdateServiceGCSafePointRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -29247,7 +31985,7 @@ func (m *StoreHeartbeatResponse) Unmarshal(dAtA []byte) error { return io.ErrUnexpectedEOF } if m.Header == nil { - m.Header = &ResponseHeader{} + m.Header = &RequestHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err @@ -29255,9 +31993,9 @@ func (m *StoreHeartbeatResponse) Unmarshal(dAtA []byte) error { iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ReplicationStatus", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ServiceId", wireType) } - var msglen int + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -29267,33 +32005,31 @@ func (m *StoreHeartbeatResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + if byteLen < 0 { return ErrInvalidLengthPdpb } - postIndex := iNdEx + msglen + postIndex := iNdEx + byteLen if postIndex < 0 { return ErrInvalidLengthPdpb } if postIndex > l { return io.ErrUnexpectedEOF } - if m.ReplicationStatus == nil { - m.ReplicationStatus = &replication_modepb.ReplicationStatus{} - } - if err := m.ReplicationStatus.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + m.ServiceId = append(m.ServiceId[:0], dAtA[iNdEx:postIndex]...) + if m.ServiceId == nil { + m.ServiceId = []byte{} } iNdEx = postIndex case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ClusterVersion", wireType) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field TTL", wireType) } - var stringLen uint64 + m.TTL = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -29303,29 +32039,16 @@ func (m *StoreHeartbeatResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + m.TTL |= int64(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthPdpb - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthPdpb - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.ClusterVersion = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex case 4: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field RequireDetailedReport", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field SafePoint", wireType) } - var v int + m.SafePoint = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -29335,15 +32058,65 @@ func (m *StoreHeartbeatResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - v |= int(b&0x7F) << shift + m.SafePoint |= uint64(b&0x7F) << shift if b < 0x80 { break } } - m.RequireDetailedReport = bool(v != 0) - case 5: + default: + iNdEx = preIndex + skippy, err := skipPdpb(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthPdpb + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *UpdateServiceGCSafePointResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: UpdateServiceGCSafePointResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: UpdateServiceGCSafePointResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field RecoveryPlan", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -29370,18 +32143,18 @@ func (m *StoreHeartbeatResponse) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.RecoveryPlan == nil { - m.RecoveryPlan = &RecoveryPlan{} + if m.Header == nil { + m.Header = &ResponseHeader{} } - if err := m.RecoveryPlan.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 6: + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field AwakenRegions", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ServiceId", wireType) } - var msglen int + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -29391,28 +32164,64 @@ func (m *StoreHeartbeatResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + if byteLen < 0 { return ErrInvalidLengthPdpb } - postIndex := iNdEx + msglen + postIndex := iNdEx + byteLen if postIndex < 0 { return ErrInvalidLengthPdpb } if postIndex > l { return io.ErrUnexpectedEOF } - if m.AwakenRegions == nil { - m.AwakenRegions = &AwakenRegions{} - } - if err := m.AwakenRegions.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + m.ServiceId = append(m.ServiceId[:0], dAtA[iNdEx:postIndex]...) + if m.ServiceId == nil { + m.ServiceId = []byte{} } iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field TTL", wireType) + } + m.TTL = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.TTL |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MinSafePoint", wireType) + } + m.MinSafePoint = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.MinSafePoint |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) @@ -29435,7 +32244,7 @@ func (m *StoreHeartbeatResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *ScatterRegionRequest) Unmarshal(dAtA []byte) error { +func (m *GetGCSafePointV2Request) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -29458,10 +32267,10 @@ func (m *ScatterRegionRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: ScatterRegionRequest: wiretype end group for non-group") + return fmt.Errorf("proto: GetGCSafePointV2Request: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: ScatterRegionRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: GetGCSafePointV2Request: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -29502,28 +32311,9 @@ func (m *ScatterRegionRequest) Unmarshal(dAtA []byte) error { iNdEx = postIndex case 2: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field RegionId", wireType) - } - m.RegionId = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.RegionId |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Region", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field KeyspaceId", wireType) } - var msglen int + m.KeyspaceId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -29533,31 +32323,65 @@ func (m *ScatterRegionRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + m.KeyspaceId |= uint32(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { - return ErrInvalidLengthPdpb + default: + iNdEx = preIndex + skippy, err := skipPdpb(dAtA[iNdEx:]) + if err != nil { + return err } - postIndex := iNdEx + msglen - if postIndex < 0 { + if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthPdpb } - if postIndex > l { + if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } - if m.Region == nil { - m.Region = &metapb.Region{} + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *GetGCSafePointV2Response) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb } - if err := m.Region.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break } - iNdEx = postIndex - case 4: + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: GetGCSafePointV2Response: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GetGCSafePointV2Response: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Leader", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -29584,126 +32408,18 @@ func (m *ScatterRegionRequest) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Leader == nil { - m.Leader = &metapb.Peer{} + if m.Header == nil { + m.Header = &ResponseHeader{} } - if err := m.Leader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 5: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Group", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - stringLen |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthPdpb - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthPdpb - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Group = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 6: - if wireType == 0 { - var v uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - v |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - m.RegionsId = append(m.RegionsId, v) - } else if wireType == 2 { - var packedLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - packedLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if packedLen < 0 { - return ErrInvalidLengthPdpb - } - postIndex := iNdEx + packedLen - if postIndex < 0 { - return ErrInvalidLengthPdpb - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - var elementCount int - var count int - for _, integer := range dAtA[iNdEx:postIndex] { - if integer < 128 { - count++ - } - } - elementCount = count - if elementCount != 0 && len(m.RegionsId) == 0 { - m.RegionsId = make([]uint64, 0, elementCount) - } - for iNdEx < postIndex { - var v uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - v |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - m.RegionsId = append(m.RegionsId, v) - } - } else { - return fmt.Errorf("proto: wrong wireType = %d for field RegionsId", wireType) - } - case 7: + case 2: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field RetryLimit", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field SafePoint", wireType) } - m.RetryLimit = 0 + m.SafePoint = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -29713,7 +32429,7 @@ func (m *ScatterRegionRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.RetryLimit |= uint64(b&0x7F) << shift + m.SafePoint |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -29740,7 +32456,7 @@ func (m *ScatterRegionRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *ScatterRegionResponse) Unmarshal(dAtA []byte) error { +func (m *WatchGCSafePointV2Request) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -29763,10 +32479,10 @@ func (m *ScatterRegionResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: ScatterRegionResponse: wiretype end group for non-group") + return fmt.Errorf("proto: WatchGCSafePointV2Request: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: ScatterRegionResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: WatchGCSafePointV2Request: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -29799,7 +32515,7 @@ func (m *ScatterRegionResponse) Unmarshal(dAtA []byte) error { return io.ErrUnexpectedEOF } if m.Header == nil { - m.Header = &ResponseHeader{} + m.Header = &RequestHeader{} } if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err @@ -29807,9 +32523,9 @@ func (m *ScatterRegionResponse) Unmarshal(dAtA []byte) error { iNdEx = postIndex case 2: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field FinishedPercentage", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Revision", wireType) } - m.FinishedPercentage = 0 + m.Revision = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -29819,7 +32535,7 @@ func (m *ScatterRegionResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.FinishedPercentage |= uint64(b&0x7F) << shift + m.Revision |= int64(b&0x7F) << shift if b < 0x80 { break } @@ -29846,7 +32562,7 @@ func (m *ScatterRegionResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *GetGCSafePointRequest) Unmarshal(dAtA []byte) error { +func (m *SafePointEvent) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -29869,17 +32585,17 @@ func (m *GetGCSafePointRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: GetGCSafePointRequest: wiretype end group for non-group") + return fmt.Errorf("proto: SafePointEvent: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: GetGCSafePointRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: SafePointEvent: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field KeyspaceId", wireType) } - var msglen int + m.KeyspaceId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -29889,28 +32605,49 @@ func (m *GetGCSafePointRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + m.KeyspaceId |= uint32(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { - return ErrInvalidLengthPdpb - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthPdpb + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field SafePoint", wireType) } - if postIndex > l { - return io.ErrUnexpectedEOF + m.SafePoint = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.SafePoint |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } } - if m.Header == nil { - m.Header = &RequestHeader{} + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) } - if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + m.Type = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Type |= EventType(b&0x7F) << shift + if b < 0x80 { + break + } } - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipPdpb(dAtA[iNdEx:]) @@ -29933,7 +32670,7 @@ func (m *GetGCSafePointRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *GetGCSafePointResponse) Unmarshal(dAtA []byte) error { +func (m *WatchGCSafePointV2Response) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -29956,10 +32693,10 @@ func (m *GetGCSafePointResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: GetGCSafePointResponse: wiretype end group for non-group") + return fmt.Errorf("proto: WatchGCSafePointV2Response: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: GetGCSafePointResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: WatchGCSafePointV2Response: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -29999,10 +32736,44 @@ func (m *GetGCSafePointResponse) Unmarshal(dAtA []byte) error { } iNdEx = postIndex case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Events", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthPdpb + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthPdpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Events = append(m.Events, &SafePointEvent{}) + if err := m.Events[len(m.Events)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field SafePoint", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Revision", wireType) } - m.SafePoint = 0 + m.Revision = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -30012,7 +32783,7 @@ func (m *GetGCSafePointResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.SafePoint |= uint64(b&0x7F) << shift + m.Revision |= int64(b&0x7F) << shift if b < 0x80 { break } @@ -30039,7 +32810,7 @@ func (m *GetGCSafePointResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *UpdateGCSafePointRequest) Unmarshal(dAtA []byte) error { +func (m *UpdateGCSafePointV2Request) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -30062,10 +32833,10 @@ func (m *UpdateGCSafePointRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: UpdateGCSafePointRequest: wiretype end group for non-group") + return fmt.Errorf("proto: UpdateGCSafePointV2Request: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: UpdateGCSafePointRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: UpdateGCSafePointV2Request: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -30103,8 +32874,27 @@ func (m *UpdateGCSafePointRequest) Unmarshal(dAtA []byte) error { if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - iNdEx = postIndex - case 2: + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field KeyspaceId", wireType) + } + m.KeyspaceId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.KeyspaceId |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field SafePoint", wireType) } @@ -30145,7 +32935,7 @@ func (m *UpdateGCSafePointRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *UpdateGCSafePointResponse) Unmarshal(dAtA []byte) error { +func (m *UpdateGCSafePointV2Response) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -30168,10 +32958,10 @@ func (m *UpdateGCSafePointResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: UpdateGCSafePointResponse: wiretype end group for non-group") + return fmt.Errorf("proto: UpdateGCSafePointV2Response: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: UpdateGCSafePointResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: UpdateGCSafePointV2Response: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -30251,7 +33041,7 @@ func (m *UpdateGCSafePointResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *UpdateServiceGCSafePointRequest) Unmarshal(dAtA []byte) error { +func (m *UpdateServiceSafePointV2Request) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -30274,10 +33064,10 @@ func (m *UpdateServiceGCSafePointRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: UpdateServiceGCSafePointRequest: wiretype end group for non-group") + return fmt.Errorf("proto: UpdateServiceSafePointV2Request: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: UpdateServiceGCSafePointRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: UpdateServiceSafePointV2Request: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -30317,6 +33107,25 @@ func (m *UpdateServiceGCSafePointRequest) Unmarshal(dAtA []byte) error { } iNdEx = postIndex case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field KeyspaceId", wireType) + } + m.KeyspaceId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.KeyspaceId |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ServiceId", wireType) } @@ -30350,11 +33159,11 @@ func (m *UpdateServiceGCSafePointRequest) Unmarshal(dAtA []byte) error { m.ServiceId = []byte{} } iNdEx = postIndex - case 3: + case 4: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field TTL", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field SafePoint", wireType) } - m.TTL = 0 + m.SafePoint = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -30364,16 +33173,16 @@ func (m *UpdateServiceGCSafePointRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.TTL |= int64(b&0x7F) << shift + m.SafePoint |= uint64(b&0x7F) << shift if b < 0x80 { break } } - case 4: + case 5: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field SafePoint", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Ttl", wireType) } - m.SafePoint = 0 + m.Ttl = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -30383,7 +33192,7 @@ func (m *UpdateServiceGCSafePointRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.SafePoint |= uint64(b&0x7F) << shift + m.Ttl |= int64(b&0x7F) << shift if b < 0x80 { break } @@ -30410,7 +33219,7 @@ func (m *UpdateServiceGCSafePointRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *UpdateServiceGCSafePointResponse) Unmarshal(dAtA []byte) error { +func (m *UpdateServiceSafePointV2Response) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -30433,10 +33242,10 @@ func (m *UpdateServiceGCSafePointResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: UpdateServiceGCSafePointResponse: wiretype end group for non-group") + return fmt.Errorf("proto: UpdateServiceSafePointV2Response: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: UpdateServiceGCSafePointResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: UpdateServiceSafePointV2Response: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -30511,9 +33320,9 @@ func (m *UpdateServiceGCSafePointResponse) Unmarshal(dAtA []byte) error { iNdEx = postIndex case 3: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field TTL", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Ttl", wireType) } - m.TTL = 0 + m.Ttl = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowPdpb @@ -30523,7 +33332,7 @@ func (m *UpdateServiceGCSafePointResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.TTL |= int64(b&0x7F) << shift + m.Ttl |= int64(b&0x7F) << shift if b < 0x80 { break } @@ -33971,6 +36780,216 @@ func (m *GetExternalTimestampResponse) Unmarshal(dAtA []byte) error { } return nil } +func (m *GetMinTSRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: GetMinTSRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GetMinTSRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthPdpb + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthPdpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Header == nil { + m.Header = &RequestHeader{} + } + if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipPdpb(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthPdpb + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *GetMinTSResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: GetMinTSResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GetMinTSResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthPdpb + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthPdpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Header == nil { + m.Header = &ResponseHeader{} + } + if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthPdpb + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthPdpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Timestamp == nil { + m.Timestamp = &Timestamp{} + } + if err := m.Timestamp.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipPdpb(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthPdpb + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func skipPdpb(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/pkg/resource_manager/resource_manager.pb.go b/pkg/resource_manager/resource_manager.pb.go index 5bc977e00..38f07b5ad 100644 --- a/pkg/resource_manager/resource_manager.pb.go +++ b/pkg/resource_manager/resource_manager.pb.go @@ -107,6 +107,59 @@ func (GroupMode) EnumDescriptor() ([]byte, []int) { return fileDescriptor_7048dd9233ee965d, []int{2} } +type RunawayAction int32 + +const ( + RunawayAction_DryRun RunawayAction = 0 + RunawayAction_CoolDown RunawayAction = 1 + RunawayAction_Kill RunawayAction = 2 +) + +var RunawayAction_name = map[int32]string{ + 0: "DryRun", + 1: "CoolDown", + 2: "Kill", +} + +var RunawayAction_value = map[string]int32{ + "DryRun": 0, + "CoolDown": 1, + "Kill": 2, +} + +func (x RunawayAction) String() string { + return proto.EnumName(RunawayAction_name, int32(x)) +} + +func (RunawayAction) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_7048dd9233ee965d, []int{3} +} + +type RunawayWatchType int32 + +const ( + RunawayWatchType_Exact RunawayWatchType = 0 + RunawayWatchType_Similar RunawayWatchType = 1 +) + +var RunawayWatchType_name = map[int32]string{ + 0: "Exact", + 1: "Similar", +} + +var RunawayWatchType_value = map[string]int32{ + "Exact": 0, + "Similar": 1, +} + +func (x RunawayWatchType) String() string { + return proto.EnumName(RunawayWatchType_name, int32(x)) +} + +func (RunawayWatchType) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_7048dd9233ee965d, []int{4} +} + type ListResourceGroupsRequest struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` @@ -1237,10 +1290,12 @@ type ResourceGroup struct { // Used in Raw mode, group settings with CPU/IO etc resource unit. RawResourceSettings *GroupRawResourceSettings `protobuf:"bytes,4,opt,name=raw_resource_settings,json=rawResourceSettings,proto3" json:"raw_resource_settings,omitempty"` // The task scheduling priority - Priority uint32 `protobuf:"varint,5,opt,name=priority,proto3" json:"priority,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + Priority uint32 `protobuf:"varint,5,opt,name=priority,proto3" json:"priority,omitempty"` + // Runaway queries settings + RunawaySettings *RunawaySettings `protobuf:"bytes,6,opt,name=runaway_settings,json=runawaySettings,proto3" json:"runaway_settings,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } func (m *ResourceGroup) Reset() { *m = ResourceGroup{} } @@ -1311,6 +1366,13 @@ func (m *ResourceGroup) GetPriority() uint32 { return 0 } +func (m *ResourceGroup) GetRunawaySettings() *RunawaySettings { + if m != nil { + return m.RunawaySettings + } + return nil +} + type GroupRequestUnitSettings struct { RU *TokenBucket `protobuf:"bytes,1,opt,name=r_u,json=rU,proto3" json:"r_u,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` @@ -1587,10 +1649,178 @@ func (m *Error) GetMessage() string { return "" } +type RunawayRule struct { + ExecElapsedTimeMs uint64 `protobuf:"varint,1,opt,name=exec_elapsed_time_ms,json=execElapsedTimeMs,proto3" json:"exec_elapsed_time_ms,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RunawayRule) Reset() { *m = RunawayRule{} } +func (m *RunawayRule) String() string { return proto.CompactTextString(m) } +func (*RunawayRule) ProtoMessage() {} +func (*RunawayRule) Descriptor() ([]byte, []int) { + return fileDescriptor_7048dd9233ee965d, []int{23} +} +func (m *RunawayRule) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RunawayRule) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RunawayRule.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *RunawayRule) XXX_Merge(src proto.Message) { + xxx_messageInfo_RunawayRule.Merge(m, src) +} +func (m *RunawayRule) XXX_Size() int { + return m.Size() +} +func (m *RunawayRule) XXX_DiscardUnknown() { + xxx_messageInfo_RunawayRule.DiscardUnknown(m) +} + +var xxx_messageInfo_RunawayRule proto.InternalMessageInfo + +func (m *RunawayRule) GetExecElapsedTimeMs() uint64 { + if m != nil { + return m.ExecElapsedTimeMs + } + return 0 +} + +type RunawayWatch struct { + // how long would the watch last + LastDurationMs uint64 `protobuf:"varint,1,opt,name=last_duration_ms,json=lastDurationMs,proto3" json:"last_duration_ms,omitempty"` + Type RunawayWatchType `protobuf:"varint,2,opt,name=type,proto3,enum=resource_manager.RunawayWatchType" json:"type,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RunawayWatch) Reset() { *m = RunawayWatch{} } +func (m *RunawayWatch) String() string { return proto.CompactTextString(m) } +func (*RunawayWatch) ProtoMessage() {} +func (*RunawayWatch) Descriptor() ([]byte, []int) { + return fileDescriptor_7048dd9233ee965d, []int{24} +} +func (m *RunawayWatch) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RunawayWatch) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RunawayWatch.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *RunawayWatch) XXX_Merge(src proto.Message) { + xxx_messageInfo_RunawayWatch.Merge(m, src) +} +func (m *RunawayWatch) XXX_Size() int { + return m.Size() +} +func (m *RunawayWatch) XXX_DiscardUnknown() { + xxx_messageInfo_RunawayWatch.DiscardUnknown(m) +} + +var xxx_messageInfo_RunawayWatch proto.InternalMessageInfo + +func (m *RunawayWatch) GetLastDurationMs() uint64 { + if m != nil { + return m.LastDurationMs + } + return 0 +} + +func (m *RunawayWatch) GetType() RunawayWatchType { + if m != nil { + return m.Type + } + return RunawayWatchType_Exact +} + +type RunawaySettings struct { + Rule *RunawayRule `protobuf:"bytes,1,opt,name=rule,proto3" json:"rule,omitempty"` + Action RunawayAction `protobuf:"varint,2,opt,name=action,proto3,enum=resource_manager.RunawayAction" json:"action,omitempty"` + Watch *RunawayWatch `protobuf:"bytes,3,opt,name=watch,proto3" json:"watch,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RunawaySettings) Reset() { *m = RunawaySettings{} } +func (m *RunawaySettings) String() string { return proto.CompactTextString(m) } +func (*RunawaySettings) ProtoMessage() {} +func (*RunawaySettings) Descriptor() ([]byte, []int) { + return fileDescriptor_7048dd9233ee965d, []int{25} +} +func (m *RunawaySettings) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RunawaySettings) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RunawaySettings.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *RunawaySettings) XXX_Merge(src proto.Message) { + xxx_messageInfo_RunawaySettings.Merge(m, src) +} +func (m *RunawaySettings) XXX_Size() int { + return m.Size() +} +func (m *RunawaySettings) XXX_DiscardUnknown() { + xxx_messageInfo_RunawaySettings.DiscardUnknown(m) +} + +var xxx_messageInfo_RunawaySettings proto.InternalMessageInfo + +func (m *RunawaySettings) GetRule() *RunawayRule { + if m != nil { + return m.Rule + } + return nil +} + +func (m *RunawaySettings) GetAction() RunawayAction { + if m != nil { + return m.Action + } + return RunawayAction_DryRun +} + +func (m *RunawaySettings) GetWatch() *RunawayWatch { + if m != nil { + return m.Watch + } + return nil +} + func init() { proto.RegisterEnum("resource_manager.RequestUnitType", RequestUnitType_name, RequestUnitType_value) proto.RegisterEnum("resource_manager.RawResourceType", RawResourceType_name, RawResourceType_value) proto.RegisterEnum("resource_manager.GroupMode", GroupMode_name, GroupMode_value) + proto.RegisterEnum("resource_manager.RunawayAction", RunawayAction_name, RunawayAction_value) + proto.RegisterEnum("resource_manager.RunawayWatchType", RunawayWatchType_name, RunawayWatchType_value) proto.RegisterType((*ListResourceGroupsRequest)(nil), "resource_manager.ListResourceGroupsRequest") proto.RegisterType((*ListResourceGroupsResponse)(nil), "resource_manager.ListResourceGroupsResponse") proto.RegisterType((*GetResourceGroupRequest)(nil), "resource_manager.GetResourceGroupRequest") @@ -1616,99 +1846,115 @@ func init() { proto.RegisterType((*TokenBucket)(nil), "resource_manager.TokenBucket") proto.RegisterType((*TokenLimitSettings)(nil), "resource_manager.TokenLimitSettings") proto.RegisterType((*Error)(nil), "resource_manager.Error") + proto.RegisterType((*RunawayRule)(nil), "resource_manager.RunawayRule") + proto.RegisterType((*RunawayWatch)(nil), "resource_manager.RunawayWatch") + proto.RegisterType((*RunawaySettings)(nil), "resource_manager.RunawaySettings") } func init() { proto.RegisterFile("resource_manager.proto", fileDescriptor_7048dd9233ee965d) } var fileDescriptor_7048dd9233ee965d = []byte{ - // 1387 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x58, 0xcf, 0x73, 0xdb, 0xc4, - 0x17, 0xb7, 0xfc, 0xdb, 0xcf, 0xdf, 0x24, 0xce, 0x26, 0x69, 0x5c, 0x67, 0x9a, 0xb6, 0x9a, 0x2f, - 0x9d, 0x34, 0xa5, 0x49, 0x09, 0x53, 0xca, 0x0c, 0x97, 0x36, 0x29, 0xb4, 0x81, 0xa4, 0xcd, 0x6c, - 0xea, 0xe1, 0x44, 0x85, 0x62, 0x6f, 0x3d, 0xc2, 0xb6, 0x56, 0x5e, 0xad, 0xe2, 0xfa, 0xc6, 0x0c, - 0x9c, 0xf8, 0x0b, 0x38, 0x71, 0xe2, 0xc0, 0x70, 0xe2, 0x0c, 0xc3, 0x8d, 0x03, 0x47, 0x8e, 0x1c, - 0x99, 0xf2, 0x8f, 0x30, 0xbb, 0x2b, 0xc9, 0x52, 0x25, 0xc7, 0x4e, 0xa6, 0x03, 0x37, 0xed, 0xfb, - 0xf1, 0x79, 0x9f, 0xf7, 0xf6, 0xbd, 0xf5, 0xae, 0xe1, 0x12, 0x23, 0x2e, 0xf5, 0x58, 0x8b, 0x18, - 0x7d, 0xd3, 0x36, 0x3b, 0x84, 0x6d, 0x39, 0x8c, 0x72, 0x8a, 0x6a, 0xaf, 0xcb, 0x1b, 0xcb, 0x1d, - 0xda, 0xa1, 0x52, 0xb9, 0x2d, 0xbe, 0x94, 0x5d, 0x63, 0x81, 0x79, 0x2e, 0x97, 0x9f, 0x4a, 0xa0, - 0xaf, 0xc1, 0xe5, 0x03, 0xcb, 0xe5, 0xd8, 0x77, 0x7f, 0xc4, 0xa8, 0xe7, 0xb8, 0x98, 0x0c, 0x3c, - 0xe2, 0x72, 0xfd, 0x6b, 0x0d, 0x1a, 0x69, 0x5a, 0xd7, 0xa1, 0xb6, 0x4b, 0xd0, 0x6d, 0x28, 0x10, - 0xc6, 0x28, 0xab, 0x6b, 0xd7, 0xb4, 0x8d, 0xea, 0xce, 0xea, 0x56, 0x82, 0xdc, 0x87, 0x42, 0x8d, - 0x95, 0x15, 0xba, 0x07, 0xc5, 0x8e, 0x04, 0xa8, 0x67, 0xaf, 0xe5, 0x36, 0xaa, 0x3b, 0x57, 0x93, - 0xf6, 0xb1, 0x40, 0xd8, 0x37, 0xd7, 0xf7, 0x61, 0xf5, 0x11, 0x89, 0x93, 0xf0, 0x19, 0xa2, 0x2d, - 0x58, 0x0a, 0x41, 0xa4, 0xb5, 0x61, 0x9b, 0x7d, 0x22, 0x09, 0x55, 0xf0, 0x22, 0x8b, 0xba, 0x3c, - 0x31, 0xfb, 0x44, 0xff, 0x52, 0x83, 0x7a, 0x12, 0xeb, 0x62, 0xf9, 0xdc, 0x85, 0x82, 0x0c, 0x59, - 0xcf, 0x4a, 0xf3, 0xa9, 0xe9, 0x28, 0x6b, 0xfd, 0x00, 0x1a, 0x0f, 0x49, 0x8f, 0x70, 0xf2, 0x46, - 0x12, 0xfa, 0x1c, 0xd6, 0x52, 0xd1, 0x2e, 0x96, 0x12, 0x82, 0xfc, 0x09, 0x6d, 0x8f, 0x64, 0x46, - 0x15, 0x2c, 0xbf, 0xf5, 0x23, 0x58, 0x3d, 0xf2, 0xd2, 0xab, 0x1f, 0x56, 0x40, 0x3b, 0x57, 0x05, - 0x3e, 0x83, 0x7a, 0x12, 0xf1, 0xcd, 0x11, 0xfe, 0x59, 0x83, 0xa5, 0x67, 0xb4, 0x4b, 0xec, 0x5d, - 0xaf, 0xd5, 0x25, 0x3c, 0xe8, 0x66, 0x74, 0x1f, 0xca, 0x4c, 0x7d, 0xba, 0x75, 0x4d, 0x76, 0xe0, - 0xff, 0x93, 0xe8, 0x11, 0x47, 0xdf, 0x0f, 0x87, 0x5e, 0xe8, 0x1e, 0xd4, 0xb9, 0xc9, 0x3a, 0x84, - 0x1b, 0xbe, 0xc8, 0x70, 0x08, 0xb3, 0x68, 0xdb, 0xe8, 0xbb, 0x92, 0x41, 0x1e, 0xaf, 0x28, 0xbd, - 0xef, 0x7a, 0x24, 0xb5, 0x87, 0x2e, 0xda, 0x80, 0x5a, 0xab, 0x67, 0x11, 0x9b, 0x1b, 0x9e, 0x6d, - 0x0d, 0x3c, 0x62, 0x58, 0xed, 0x7a, 0x4e, 0x3a, 0xcc, 0x2b, 0x79, 0x53, 0x8a, 0xf7, 0xdb, 0xfa, - 0xf7, 0x79, 0x40, 0x49, 0x0e, 0xe7, 0x6d, 0x0b, 0xf4, 0x09, 0x94, 0x99, 0x67, 0x58, 0x9c, 0xf8, - 0xcc, 0xaa, 0x3b, 0x5b, 0xb3, 0xe4, 0xba, 0x15, 0xe4, 0xdc, 0x7c, 0x9c, 0xc1, 0x25, 0xe6, 0xed, - 0x0b, 0x00, 0xd4, 0x01, 0xc4, 0xcc, 0xa1, 0x11, 0xfa, 0x2b, 0xd8, 0x9c, 0x84, 0xbd, 0x77, 0x2e, - 0x58, 0x73, 0x18, 0xec, 0xfa, 0xe3, 0x0c, 0xae, 0xb1, 0xf1, 0x52, 0x05, 0x3a, 0x81, 0xf5, 0x16, - 0xb5, 0x5d, 0xaf, 0xef, 0x70, 0x8b, 0xda, 0x86, 0x6b, 0xd9, 0x2d, 0x62, 0xf4, 0x4c, 0x37, 0xac, - 0x77, 0x3d, 0x2f, 0x83, 0x5e, 0x49, 0x06, 0xdd, 0x1b, 0xfb, 0xe1, 0xb5, 0x08, 0xc8, 0xb1, 0xc0, - 0x38, 0x30, 0xdd, 0x80, 0x4a, 0xe3, 0x09, 0x54, 0xc2, 0x24, 0xd1, 0x03, 0xa8, 0x06, 0x3b, 0xc9, - 0x0c, 0xcf, 0xef, 0x8a, 0xeb, 0x69, 0x6d, 0x2c, 0x8d, 0x9a, 0xb6, 0xc5, 0x05, 0x53, 0x5c, 0x61, - 0x01, 0x44, 0xc3, 0x02, 0x94, 0xcc, 0x0e, 0x1d, 0xc3, 0x72, 0x08, 0x1c, 0x29, 0xdd, 0x19, 0x11, - 0xe2, 0xb5, 0xc0, 0x88, 0x25, 0x40, 0x77, 0x2b, 0x50, 0xf2, 0xa5, 0xfa, 0x37, 0x1a, 0x2c, 0xc7, - 0x7b, 0xfc, 0x62, 0xf3, 0xb3, 0x07, 0x15, 0xe6, 0xbb, 0x06, 0xc7, 0xf2, 0x5b, 0x53, 0x76, 0x54, - 0x59, 0xe3, 0xb1, 0x9f, 0xfe, 0x55, 0x36, 0x36, 0x70, 0x21, 0x97, 0xf3, 0x36, 0xed, 0x31, 0xa0, - 0x0e, 0x33, 0x6d, 0x4e, 0xda, 0x62, 0x37, 0x0c, 0x2e, 0x20, 0x03, 0x56, 0x37, 0x92, 0xac, 0x1e, - 0x29, 0x5b, 0xdc, 0x8c, 0xc6, 0x5e, 0xe8, 0xc4, 0xa4, 0xa2, 0x79, 0x57, 0x43, 0xd0, 0x00, 0xc1, - 0x47, 0xce, 0x49, 0xe4, 0xed, 0xc9, 0xc8, 0xe3, 0xda, 0x47, 0x43, 0xac, 0x04, 0x21, 0xa2, 0x3a, - 0x57, 0xff, 0x45, 0x83, 0xe5, 0x34, 0x4a, 0xe8, 0x2e, 0xe4, 0xf9, 0xc8, 0x51, 0x79, 0xcf, 0x4f, - 0xe9, 0xae, 0x67, 0x23, 0x87, 0x60, 0x69, 0x8e, 0x1e, 0xc2, 0x7c, 0x40, 0x3c, 0xac, 0xc4, 0x84, - 0xe6, 0x8f, 0xb2, 0x9b, 0xf3, 0x9d, 0xfc, 0xf4, 0x6f, 0xc0, 0x02, 0x67, 0x56, 0xab, 0xdb, 0x23, - 0x06, 0xb7, 0xfa, 0xc4, 0xf0, 0x07, 0x37, 0x87, 0xe7, 0x7c, 0xf1, 0x33, 0xab, 0x4f, 0x0e, 0x5d, - 0xfd, 0x37, 0x0d, 0xae, 0x9c, 0x99, 0xf6, 0x0c, 0x69, 0x44, 0xfc, 0xfe, 0xab, 0x34, 0x7e, 0xcc, - 0x42, 0x35, 0x72, 0x14, 0x20, 0x04, 0x05, 0xe6, 0x8f, 0xb6, 0xb6, 0xa1, 0xe1, 0x1c, 0xc3, 0x4d, - 0x21, 0x1b, 0x4a, 0x59, 0x56, 0xc9, 0x86, 0xb8, 0x89, 0xae, 0x00, 0x30, 0x62, 0xb6, 0x8d, 0x93, - 0x11, 0x27, 0x0a, 0x5a, 0x13, 0x1d, 0x6e, 0xb6, 0x77, 0x85, 0x00, 0x5d, 0x85, 0xea, 0x90, 0x59, - 0x9c, 0xf8, 0xfa, 0xbc, 0xd4, 0x83, 0x14, 0x29, 0x83, 0x9b, 0xb0, 0xc8, 0x29, 0x37, 0x7b, 0x46, - 0xcb, 0xf1, 0x42, 0x86, 0x05, 0x69, 0x36, 0x2f, 0x15, 0x7b, 0x8e, 0xa7, 0x28, 0xa2, 0x3b, 0xb0, - 0xe2, 0x0e, 0x7a, 0x46, 0xcf, 0x1c, 0x11, 0x16, 0x33, 0x2f, 0x4a, 0xf3, 0x45, 0x77, 0xd0, 0x3b, - 0x10, 0xba, 0xb1, 0xc7, 0x4d, 0x58, 0xec, 0x9e, 0x1a, 0x92, 0x1f, 0x73, 0x5a, 0x46, 0x8b, 0x7a, - 0x36, 0xaf, 0x97, 0x14, 0x78, 0xf7, 0x14, 0x13, 0xb3, 0x8d, 0x9d, 0xd6, 0x9e, 0x90, 0xa2, 0x5b, - 0x80, 0xba, 0xa7, 0x86, 0xe2, 0x3a, 0xb6, 0x2d, 0x4b, 0xdb, 0x85, 0xee, 0xe9, 0xa7, 0x42, 0x11, - 0x18, 0xeb, 0xcf, 0x61, 0xe1, 0xb5, 0x83, 0xed, 0xa2, 0xbd, 0xba, 0x0c, 0x85, 0x53, 0xb3, 0xe7, - 0x11, 0xbf, 0xa4, 0x6a, 0x21, 0xf1, 0xe3, 0xc7, 0xda, 0x45, 0x9b, 0x28, 0x1d, 0xff, 0xbb, 0x2c, - 0xcc, 0xc5, 0x6e, 0x11, 0xe2, 0x3a, 0x10, 0x39, 0x62, 0xe4, 0x37, 0xda, 0x86, 0x7c, 0x9f, 0xb6, - 0x95, 0xeb, 0xfc, 0xce, 0x5a, 0xda, 0xb4, 0x53, 0xcf, 0x39, 0xa4, 0x6d, 0x82, 0xa5, 0x21, 0x3a, - 0x80, 0xff, 0x89, 0xe3, 0xc7, 0x25, 0x9c, 0x5b, 0x76, 0x27, 0xf8, 0xa1, 0xdb, 0x9c, 0xe0, 0x18, - 0x29, 0xc8, 0xb1, 0xef, 0x81, 0x81, 0x35, 0x83, 0x6f, 0xf4, 0x1c, 0x56, 0x62, 0x3f, 0x9e, 0x21, - 0x6c, 0xfe, 0x6c, 0xd8, 0x71, 0x1d, 0x42, 0xd8, 0x25, 0x96, 0x14, 0xa2, 0x06, 0x94, 0x1d, 0x66, - 0x51, 0x66, 0xf1, 0x91, 0x6c, 0xb8, 0x39, 0x1c, 0xae, 0xf5, 0x8f, 0xa1, 0x3e, 0x89, 0x23, 0xda, - 0x82, 0x5c, 0x30, 0x17, 0x53, 0x87, 0x31, 0xcb, 0x9a, 0xfa, 0xaf, 0x5a, 0x00, 0x96, 0x42, 0x62, - 0x1b, 0x72, 0x2d, 0x67, 0x46, 0x30, 0x61, 0x89, 0xde, 0x83, 0x92, 0x45, 0x65, 0x4b, 0xcf, 0x76, - 0x1c, 0x14, 0x2d, 0x2a, 0xfa, 0x1c, 0xbd, 0x0f, 0x65, 0x8b, 0xaa, 0xfe, 0xf6, 0xf7, 0x65, 0x8a, - 0x63, 0xc9, 0xa2, 0xb2, 0xe9, 0xf5, 0x0e, 0x54, 0xa3, 0xa7, 0xd9, 0x7d, 0x28, 0x87, 0x3b, 0xa1, - 0x68, 0x4f, 0xba, 0x0c, 0x1e, 0x58, 0xfd, 0xc8, 0xd6, 0x86, 0x5e, 0xe8, 0x12, 0x14, 0x23, 0x07, - 0x9a, 0x86, 0xfd, 0x95, 0x3e, 0xf0, 0x2f, 0x70, 0x31, 0x3f, 0xb4, 0x06, 0x95, 0x17, 0x56, 0xaf, - 0x67, 0x30, 0x93, 0xab, 0xf6, 0xcc, 0xe3, 0xb2, 0x10, 0x60, 0x93, 0x13, 0x71, 0xbc, 0x9c, 0x78, - 0xcc, 0xe5, 0x46, 0x4f, 0xf8, 0x48, 0xbc, 0x1c, 0x06, 0x29, 0x92, 0x28, 0xe2, 0x78, 0xea, 0x9b, - 0x2f, 0xc7, 0xbf, 0x5b, 0xf2, 0x78, 0xea, 0x9b, 0x2f, 0xfd, 0x9f, 0x9e, 0xeb, 0x50, 0x90, 0xbf, - 0xea, 0xa8, 0x0e, 0xa5, 0x3e, 0x71, 0x5d, 0xb3, 0x13, 0x8c, 0x40, 0xb0, 0xdc, 0xbc, 0x1c, 0x9b, - 0x75, 0x31, 0x5a, 0xa8, 0x08, 0x59, 0xdc, 0xac, 0x65, 0x36, 0x3f, 0x88, 0x8d, 0xa9, 0x54, 0x95, - 0x20, 0xb7, 0x77, 0xd4, 0xac, 0x65, 0xd0, 0x3c, 0xc0, 0xfe, 0x53, 0x51, 0xf9, 0x8f, 0x7a, 0x74, - 0x58, 0xd3, 0xd0, 0x02, 0x54, 0xf7, 0x9f, 0xca, 0x82, 0x4a, 0x41, 0x76, 0xf3, 0x1d, 0xa8, 0x84, - 0xf3, 0x83, 0xaa, 0x50, 0x6a, 0xda, 0x5d, 0x9b, 0x0e, 0xed, 0x5a, 0x06, 0x01, 0x14, 0x71, 0x53, - 0x88, 0x6b, 0x9a, 0x50, 0x60, 0x73, 0x28, 0x17, 0xd9, 0x9d, 0x9f, 0x0a, 0x82, 0x8b, 0x8a, 0x76, - 0xa8, 0x2a, 0x8d, 0x06, 0x80, 0x92, 0x0f, 0x4d, 0x74, 0x2b, 0xb9, 0x25, 0x13, 0x1f, 0xab, 0x8d, - 0xb7, 0x67, 0x33, 0x56, 0x77, 0x13, 0x3d, 0x83, 0xba, 0x50, 0x7b, 0xfd, 0x25, 0x88, 0x6e, 0xa6, - 0x4c, 0x63, 0xfa, 0xcb, 0xb3, 0xb1, 0x39, 0x8b, 0x69, 0x34, 0xd8, 0x83, 0x76, 0x7b, 0x6a, 0xb0, - 0x09, 0x0f, 0xad, 0xb4, 0x60, 0x93, 0x5e, 0x50, 0x7a, 0x06, 0xd9, 0xb0, 0x74, 0x48, 0xdb, 0xd6, - 0x8b, 0xd1, 0xbf, 0x14, 0x8f, 0xc3, 0x52, 0xca, 0x1b, 0x14, 0xa5, 0x6c, 0xc8, 0xe4, 0x87, 0x6f, - 0xe3, 0xf6, 0x8c, 0xd6, 0x61, 0xd4, 0x2f, 0x60, 0xe9, 0x41, 0x6b, 0xe0, 0x59, 0x2c, 0x7a, 0x4b, - 0x71, 0xd1, 0xd9, 0xd7, 0xd7, 0xb0, 0x5b, 0x6e, 0x4c, 0x33, 0x0b, 0xe2, 0x6c, 0x68, 0x77, 0xb4, - 0xdd, 0xe5, 0x3f, 0x7f, 0x28, 0x6b, 0xbf, 0xbf, 0x5a, 0xd7, 0xfe, 0x78, 0xb5, 0xae, 0xfd, 0xf5, - 0x6a, 0x5d, 0xfb, 0xf6, 0xef, 0xf5, 0xcc, 0x49, 0x51, 0xfe, 0x85, 0xf2, 0xee, 0x3f, 0x01, 0x00, - 0x00, 0xff, 0xff, 0x26, 0xf4, 0xa4, 0xf3, 0x95, 0x11, 0x00, 0x00, + // 1593 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x58, 0x4b, 0x6f, 0xdb, 0x56, + 0x16, 0x16, 0xf5, 0xd6, 0x51, 0x6c, 0xc9, 0xd7, 0x76, 0xac, 0xc8, 0x88, 0x93, 0x10, 0x33, 0x81, + 0xa3, 0x4c, 0xec, 0xc4, 0x99, 0x24, 0x03, 0x0c, 0x30, 0x88, 0x1f, 0x99, 0xc4, 0x13, 0x3b, 0x31, + 0xae, 0x23, 0x64, 0x35, 0xe1, 0xd0, 0xd4, 0x8d, 0x86, 0x23, 0x8a, 0xa4, 0x2f, 0x2f, 0x2d, 0x6b, + 0x37, 0xc0, 0xcc, 0xaa, 0xbf, 0xa0, 0x3f, 0xa0, 0x8b, 0xa2, 0xab, 0x02, 0xdd, 0xb5, 0xe8, 0xae, + 0x8b, 0x2e, 0xbb, 0xec, 0xb2, 0x48, 0xb7, 0xfd, 0x11, 0xc5, 0x7d, 0x90, 0xa2, 0x2c, 0xc9, 0x2f, + 0x04, 0xed, 0x8e, 0x3c, 0xe7, 0x3b, 0xdf, 0x79, 0xf0, 0x9c, 0xc3, 0x4b, 0xc2, 0x55, 0x4a, 0x02, + 0x2f, 0xa4, 0x16, 0x31, 0xba, 0xa6, 0x6b, 0xb6, 0x09, 0x5d, 0xf1, 0xa9, 0xc7, 0x3c, 0x54, 0x3d, + 0x29, 0xaf, 0xcf, 0xb5, 0xbd, 0xb6, 0x27, 0x94, 0xab, 0xfc, 0x4a, 0xe2, 0xea, 0x15, 0x1a, 0x06, + 0x4c, 0x5c, 0x4a, 0x81, 0xbe, 0x08, 0xd7, 0x76, 0xec, 0x80, 0x61, 0x65, 0xfe, 0x9c, 0x7a, 0xa1, + 0x1f, 0x60, 0x72, 0x18, 0x92, 0x80, 0xe9, 0xff, 0xd7, 0xa0, 0x3e, 0x4e, 0x1b, 0xf8, 0x9e, 0x1b, + 0x10, 0x74, 0x0f, 0x72, 0x84, 0x52, 0x8f, 0xd6, 0xb4, 0x9b, 0xda, 0x72, 0x79, 0x6d, 0x61, 0x65, + 0x24, 0xb8, 0x67, 0x5c, 0x8d, 0x25, 0x0a, 0x3d, 0x81, 0x7c, 0x5b, 0x10, 0xd4, 0xd2, 0x37, 0x33, + 0xcb, 0xe5, 0xb5, 0x1b, 0xa3, 0xf8, 0x21, 0x47, 0x58, 0xc1, 0xf5, 0x6d, 0x58, 0x78, 0x4e, 0x86, + 0x83, 0x50, 0x11, 0xa2, 0x15, 0x98, 0x8d, 0x49, 0x04, 0xda, 0x70, 0xcd, 0x2e, 0x11, 0x01, 0x95, + 0xf0, 0x0c, 0x4d, 0x9a, 0xbc, 0x32, 0xbb, 0x44, 0xff, 0xaf, 0x06, 0xb5, 0x51, 0xae, 0xcb, 0xe5, + 0xf3, 0x08, 0x72, 0xc2, 0x65, 0x2d, 0x2d, 0xe0, 0x67, 0xa6, 0x23, 0xd1, 0xfa, 0x0e, 0xd4, 0xb7, + 0x88, 0x43, 0x18, 0xf9, 0x28, 0x09, 0xfd, 0x0b, 0x16, 0xc7, 0xb2, 0x5d, 0x2e, 0x25, 0x04, 0xd9, + 0x03, 0xaf, 0xd5, 0x17, 0x19, 0x95, 0xb0, 0xb8, 0xd6, 0xf7, 0x60, 0x61, 0x2f, 0x1c, 0x5f, 0xfd, + 0xb8, 0x02, 0xda, 0x85, 0x2a, 0xf0, 0x4f, 0xa8, 0x8d, 0x32, 0x7e, 0xbc, 0x80, 0xbf, 0xd6, 0x60, + 0xf6, 0x8d, 0xd7, 0x21, 0xee, 0x46, 0x68, 0x75, 0x08, 0x8b, 0xba, 0x19, 0x3d, 0x85, 0x22, 0x95, + 0x97, 0x41, 0x4d, 0x13, 0x1d, 0xf8, 0x87, 0x51, 0xf6, 0x84, 0xa1, 0xb2, 0xc3, 0xb1, 0x15, 0x7a, + 0x02, 0x35, 0x66, 0xd2, 0x36, 0x61, 0x86, 0x12, 0x19, 0x3e, 0xa1, 0xb6, 0xd7, 0x32, 0xba, 0x81, + 0x88, 0x20, 0x8b, 0xe7, 0xa5, 0x5e, 0x99, 0xee, 0x09, 0xed, 0x6e, 0x80, 0x96, 0xa1, 0x6a, 0x39, + 0x36, 0x71, 0x99, 0x11, 0xba, 0xf6, 0x61, 0x48, 0x0c, 0xbb, 0x55, 0xcb, 0x08, 0x83, 0x69, 0x29, + 0x6f, 0x0a, 0xf1, 0x76, 0x4b, 0xff, 0x2c, 0x0b, 0x68, 0x34, 0x86, 0x8b, 0xb6, 0x05, 0x7a, 0x09, + 0x45, 0x1a, 0x1a, 0x36, 0x23, 0x2a, 0xb2, 0xf2, 0xda, 0xca, 0x79, 0x72, 0x5d, 0x89, 0x72, 0x6e, + 0xbe, 0x48, 0xe1, 0x02, 0x0d, 0xb7, 0x39, 0x01, 0x6a, 0x03, 0xa2, 0x66, 0xcf, 0x88, 0xed, 0x25, + 0x6d, 0x46, 0xd0, 0x3e, 0xb9, 0x10, 0xad, 0xd9, 0x8b, 0x9e, 0xfa, 0x8b, 0x14, 0xae, 0xd2, 0xc1, + 0xad, 0x74, 0x74, 0x00, 0x4b, 0x96, 0xe7, 0x06, 0x61, 0xd7, 0x67, 0xb6, 0xe7, 0x1a, 0x81, 0xed, + 0x5a, 0xc4, 0x70, 0xcc, 0x20, 0xae, 0x77, 0x2d, 0x2b, 0x9c, 0x5e, 0x1f, 0x75, 0xba, 0x39, 0xb0, + 0xc3, 0x8b, 0x09, 0x92, 0x7d, 0xce, 0xb1, 0x63, 0x06, 0x51, 0x28, 0xf5, 0x57, 0x50, 0x8a, 0x93, + 0x44, 0xeb, 0x50, 0x8e, 0x9e, 0x24, 0x35, 0x42, 0xd5, 0x15, 0xb7, 0xc6, 0xb5, 0xb1, 0x00, 0x35, + 0x5d, 0x9b, 0xf1, 0x48, 0x71, 0x89, 0x46, 0x14, 0x75, 0x1b, 0xd0, 0x68, 0x76, 0x68, 0x1f, 0xe6, + 0x62, 0xe2, 0x44, 0xe9, 0x4e, 0xf1, 0x30, 0x5c, 0x0b, 0x8c, 0xe8, 0x08, 0xe9, 0x46, 0x09, 0x0a, + 0x4a, 0xaa, 0x7f, 0xa2, 0xc1, 0xdc, 0x70, 0x8f, 0x5f, 0x6e, 0x7e, 0x36, 0xa1, 0x44, 0x95, 0x69, + 0xb4, 0x96, 0xff, 0x78, 0xc6, 0x13, 0x95, 0x68, 0x3c, 0xb0, 0xd3, 0xff, 0x97, 0x1e, 0x1a, 0xb8, + 0x38, 0x96, 0x8b, 0x36, 0xed, 0x3e, 0xa0, 0x36, 0x35, 0x5d, 0x46, 0x5a, 0xfc, 0x69, 0x18, 0x8c, + 0x53, 0x46, 0x51, 0xdd, 0x1e, 0x8d, 0xea, 0xb9, 0xc4, 0xe2, 0x66, 0xd2, 0x77, 0xa5, 0x3d, 0x24, + 0xe5, 0xcd, 0xbb, 0x10, 0x93, 0x46, 0x0c, 0x8a, 0x39, 0x23, 0x98, 0x57, 0x27, 0x33, 0x0f, 0x6a, + 0x9f, 0x74, 0x31, 0x1f, 0xb9, 0x48, 0xea, 0x02, 0xfd, 0x1b, 0x0d, 0xe6, 0xc6, 0x85, 0x84, 0x1e, + 0x41, 0x96, 0xf5, 0x7d, 0x99, 0xf7, 0xf4, 0x19, 0xdd, 0xf5, 0xa6, 0xef, 0x13, 0x2c, 0xe0, 0x68, + 0x0b, 0xa6, 0xa3, 0xc0, 0xe3, 0x4a, 0x4c, 0x68, 0xfe, 0x64, 0x74, 0x53, 0xca, 0x48, 0xa5, 0x7f, + 0x1b, 0x2a, 0x8c, 0xda, 0x56, 0xc7, 0x21, 0x06, 0xb3, 0xbb, 0xc4, 0x50, 0x83, 0x9b, 0xc1, 0x53, + 0x4a, 0xfc, 0xc6, 0xee, 0x92, 0xdd, 0x40, 0xff, 0x4e, 0x83, 0xeb, 0xa7, 0xa6, 0x7d, 0x8e, 0x34, + 0x12, 0x76, 0xbf, 0x57, 0x1a, 0x5f, 0xa4, 0xa1, 0x9c, 0x58, 0x05, 0x08, 0x41, 0x8e, 0xaa, 0xd1, + 0xd6, 0x96, 0x35, 0x9c, 0xa1, 0xb8, 0xc9, 0x65, 0x3d, 0x21, 0x4b, 0x4b, 0x59, 0x0f, 0x37, 0xd1, + 0x75, 0x00, 0x4a, 0xcc, 0x96, 0x71, 0xd0, 0x67, 0x44, 0x52, 0x6b, 0xbc, 0xc3, 0xcd, 0xd6, 0x06, + 0x17, 0xa0, 0x1b, 0x50, 0xee, 0x51, 0x9b, 0x11, 0xa5, 0xcf, 0x0a, 0x3d, 0x08, 0x91, 0x04, 0xdc, + 0x81, 0x19, 0xe6, 0x31, 0xd3, 0x31, 0x2c, 0x3f, 0x8c, 0x23, 0xcc, 0x09, 0xd8, 0xb4, 0x50, 0x6c, + 0xfa, 0xa1, 0x0c, 0x11, 0xdd, 0x87, 0xf9, 0xe0, 0xd0, 0x31, 0x1c, 0xb3, 0x4f, 0xe8, 0x10, 0x3c, + 0x2f, 0xe0, 0x33, 0xc1, 0xa1, 0xb3, 0xc3, 0x75, 0x03, 0x8b, 0x3b, 0x30, 0xd3, 0x39, 0x32, 0x44, + 0x7c, 0xd4, 0xb7, 0x0c, 0xcb, 0x0b, 0x5d, 0x56, 0x2b, 0x48, 0xf2, 0xce, 0x11, 0x26, 0x66, 0x0b, + 0xfb, 0xd6, 0x26, 0x97, 0xa2, 0xbb, 0x80, 0x3a, 0x47, 0x86, 0x8c, 0x75, 0x80, 0x2d, 0x0a, 0x6c, + 0xa5, 0x73, 0xf4, 0x96, 0x2b, 0x22, 0xb0, 0xfe, 0x0e, 0x2a, 0x27, 0x16, 0xdb, 0x65, 0x7b, 0x75, + 0x0e, 0x72, 0x47, 0xa6, 0x13, 0x12, 0x55, 0x52, 0x79, 0x23, 0xf8, 0x87, 0xd7, 0xda, 0x65, 0x9b, + 0x68, 0x3c, 0xff, 0x2f, 0x69, 0x98, 0x1a, 0x3a, 0x45, 0xf0, 0xe3, 0x40, 0x62, 0xc5, 0x88, 0x6b, + 0xb4, 0x0a, 0xd9, 0xae, 0xd7, 0x92, 0xa6, 0xd3, 0x6b, 0x8b, 0xe3, 0xa6, 0xdd, 0x0b, 0xfd, 0x5d, + 0xaf, 0x45, 0xb0, 0x00, 0xa2, 0x1d, 0xb8, 0xc2, 0xd7, 0x4f, 0x40, 0x18, 0xb3, 0xdd, 0x76, 0xf4, + 0xa2, 0x6b, 0x4c, 0x30, 0x4c, 0x14, 0x64, 0x5f, 0x59, 0x60, 0xa0, 0xcd, 0xe8, 0x1a, 0xbd, 0x83, + 0xf9, 0xa1, 0x97, 0x67, 0x4c, 0x9b, 0x3d, 0x9d, 0x76, 0x50, 0x87, 0x98, 0x76, 0x96, 0x8e, 0x0a, + 0x51, 0x1d, 0x8a, 0x3e, 0xb5, 0x3d, 0x6a, 0xb3, 0xbe, 0x68, 0xb8, 0x29, 0x1c, 0xdf, 0xa3, 0x1d, + 0xa8, 0xd2, 0xd0, 0x35, 0x7b, 0x66, 0x7f, 0xe0, 0x36, 0x2f, 0xdc, 0x8e, 0xab, 0xbc, 0x44, 0xc6, + 0xde, 0x2a, 0x74, 0x58, 0xa0, 0xff, 0x03, 0x6a, 0x93, 0x32, 0x46, 0x2b, 0x90, 0x89, 0xa6, 0xec, + 0xcc, 0xd1, 0x4e, 0xd3, 0xa6, 0xfe, 0xad, 0x16, 0x91, 0x8d, 0x49, 0x69, 0x15, 0x32, 0x96, 0x7f, + 0x4e, 0x32, 0x8e, 0x44, 0x8f, 0xa1, 0x60, 0x7b, 0x62, 0x40, 0xce, 0xb7, 0x5c, 0xf2, 0xb6, 0xc7, + 0xa7, 0x06, 0xfd, 0x05, 0x8a, 0xb6, 0x27, 0xa7, 0x45, 0x3d, 0xe5, 0x33, 0x0c, 0x0b, 0xb6, 0x27, + 0x46, 0x48, 0x6f, 0x43, 0x39, 0xb9, 0x1b, 0x9f, 0x42, 0x31, 0x2e, 0xb0, 0x0c, 0x7b, 0xd2, 0xd1, + 0x72, 0xc7, 0xee, 0x26, 0x1a, 0x25, 0xb6, 0x42, 0x57, 0x21, 0x9f, 0x58, 0x8f, 0x1a, 0x56, 0x77, + 0xfa, 0xa1, 0x3a, 0x0e, 0x0e, 0xd9, 0xa1, 0x45, 0x28, 0xbd, 0xb7, 0x1d, 0xc7, 0xa0, 0x26, 0x93, + 0xcd, 0x9e, 0xc5, 0x45, 0x2e, 0xc0, 0x26, 0x23, 0x7c, 0x59, 0x1d, 0x84, 0x34, 0x60, 0x86, 0xc3, + 0x6d, 0x04, 0x5f, 0x06, 0x83, 0x10, 0x09, 0x16, 0xbe, 0xec, 0xba, 0xe6, 0xf1, 0xe0, 0x2d, 0x28, + 0x96, 0x5d, 0xd7, 0x3c, 0x56, 0x2f, 0xb2, 0x5b, 0x90, 0x13, 0x67, 0x04, 0x54, 0x83, 0x42, 0x97, + 0x04, 0x81, 0xd9, 0x8e, 0x06, 0x2a, 0xba, 0xd5, 0xff, 0x06, 0x65, 0xd5, 0x2e, 0x38, 0x74, 0xf8, + 0x88, 0xcd, 0x91, 0x63, 0x62, 0x19, 0xc4, 0x31, 0xfd, 0x80, 0x2f, 0x7a, 0xb5, 0xd1, 0x64, 0x64, + 0x33, 0x5c, 0xf7, 0x4c, 0xaa, 0xd4, 0x9a, 0xf6, 0xe1, 0x8a, 0xb2, 0x7f, 0x6b, 0x32, 0xeb, 0xdf, + 0xfc, 0x7c, 0x2c, 0x8e, 0x79, 0xad, 0x90, 0x9a, 0xe2, 0xe8, 0x17, 0x1b, 0x4f, 0x73, 0xf9, 0x96, + 0x12, 0xef, 0x06, 0xe8, 0xb1, 0x5a, 0x20, 0x72, 0x9a, 0xf5, 0x89, 0x6d, 0x2c, 0x78, 0x07, 0x1b, + 0x44, 0xff, 0x4a, 0x83, 0xca, 0x89, 0x0e, 0x47, 0x0f, 0x20, 0x4b, 0x43, 0x87, 0x4c, 0x6e, 0xb4, + 0x44, 0x8e, 0x58, 0x40, 0xf9, 0x37, 0xac, 0x69, 0xf1, 0x50, 0x54, 0x00, 0x37, 0x26, 0x1a, 0xad, + 0x0b, 0x18, 0x56, 0x70, 0xf4, 0x67, 0xc8, 0xf5, 0x78, 0x48, 0xaa, 0xcf, 0x96, 0x4e, 0x0f, 0x1c, + 0x4b, 0x70, 0xe3, 0xda, 0xd0, 0x86, 0xe6, 0xe9, 0xa0, 0x3c, 0xa4, 0x71, 0xb3, 0x9a, 0x6a, 0xfc, + 0x75, 0x68, 0xb9, 0x0a, 0x55, 0x01, 0x32, 0x9b, 0x7b, 0xcd, 0x6a, 0x0a, 0x4d, 0x03, 0x6c, 0xbf, + 0xe6, 0x1d, 0xfe, 0x77, 0xc7, 0xeb, 0x55, 0x35, 0x54, 0x81, 0xf2, 0xf6, 0x6b, 0xd1, 0xb8, 0x42, + 0x90, 0x6e, 0x3c, 0x80, 0x52, 0xbc, 0xf5, 0x50, 0x19, 0x0a, 0x4d, 0xb7, 0xe3, 0x7a, 0x3d, 0xb7, + 0x9a, 0x42, 0x00, 0x79, 0xdc, 0xe4, 0xe2, 0xaa, 0xc6, 0x15, 0xd8, 0xec, 0x89, 0x9b, 0x74, 0xe3, + 0x21, 0x4c, 0x0d, 0x65, 0xc6, 0x91, 0x5b, 0xb4, 0x8f, 0x43, 0x6e, 0x75, 0x05, 0x8a, 0x9b, 0x9e, + 0xe7, 0x6c, 0x71, 0x0e, 0x0d, 0x15, 0x21, 0xfb, 0xd2, 0x76, 0x9c, 0x6a, 0xba, 0xd1, 0x80, 0xea, + 0xc9, 0xe7, 0x81, 0x4a, 0x90, 0x7b, 0x76, 0x6c, 0x5a, 0xac, 0x9a, 0xe2, 0x0e, 0xf6, 0xed, 0xae, + 0xed, 0x98, 0xb4, 0xaa, 0xad, 0x7d, 0x99, 0xe3, 0xc9, 0xca, 0x74, 0x76, 0x65, 0x4d, 0xd0, 0x21, + 0xa0, 0xd1, 0xff, 0x0f, 0xe8, 0xee, 0x68, 0xf1, 0x26, 0xfe, 0xc3, 0xa8, 0xff, 0xe9, 0x7c, 0x60, + 0x79, 0x64, 0xd5, 0x53, 0xa8, 0x03, 0xd5, 0x93, 0x3f, 0x08, 0xd0, 0x9d, 0x31, 0x4b, 0x7a, 0xfc, + 0x0f, 0x89, 0x7a, 0xe3, 0x3c, 0xd0, 0xa4, 0xb3, 0xf5, 0x56, 0xeb, 0x4c, 0x67, 0x13, 0xbe, 0xbf, + 0xc7, 0x39, 0x9b, 0xf4, 0x61, 0xad, 0xa7, 0x90, 0x0b, 0xb3, 0xbb, 0x5e, 0xcb, 0x7e, 0xdf, 0xff, + 0x8d, 0xfc, 0x31, 0x98, 0x1d, 0xf3, 0x6b, 0x02, 0x8d, 0x79, 0x20, 0x93, 0xff, 0x87, 0xd4, 0xef, + 0x9d, 0x13, 0x1d, 0x7b, 0xfd, 0x0f, 0xcc, 0xae, 0x5b, 0x87, 0xa1, 0x4d, 0x93, 0x87, 0xd7, 0x00, + 0x9d, 0xfe, 0x55, 0x13, 0x77, 0xcb, 0xed, 0xb3, 0x60, 0x91, 0x9f, 0x65, 0xed, 0xbe, 0xb6, 0x31, + 0xf7, 0xe3, 0xe7, 0x45, 0xed, 0xfb, 0x0f, 0x4b, 0xda, 0x0f, 0x1f, 0x96, 0xb4, 0x9f, 0x3e, 0x2c, + 0x69, 0x9f, 0xfe, 0xbc, 0x94, 0x3a, 0xc8, 0x8b, 0x3f, 0x6b, 0x0f, 0x7f, 0x0d, 0x00, 0x00, 0xff, + 0xff, 0x94, 0xd9, 0x7e, 0x43, 0xac, 0x13, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -2952,6 +3198,18 @@ func (m *ResourceGroup) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } + if m.RunawaySettings != nil { + { + size, err := m.RunawaySettings.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintResourceManager(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x32 + } if m.Priority != 0 { i = encodeVarintResourceManager(dAtA, i, uint64(m.Priority)) i-- @@ -3220,6 +3478,131 @@ func (m *Error) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } +func (m *RunawayRule) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *RunawayRule) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *RunawayRule) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if m.ExecElapsedTimeMs != 0 { + i = encodeVarintResourceManager(dAtA, i, uint64(m.ExecElapsedTimeMs)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *RunawayWatch) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *RunawayWatch) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *RunawayWatch) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if m.Type != 0 { + i = encodeVarintResourceManager(dAtA, i, uint64(m.Type)) + i-- + dAtA[i] = 0x10 + } + if m.LastDurationMs != 0 { + i = encodeVarintResourceManager(dAtA, i, uint64(m.LastDurationMs)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *RunawaySettings) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *RunawaySettings) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *RunawaySettings) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if m.Watch != nil { + { + size, err := m.Watch.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintResourceManager(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.Action != 0 { + i = encodeVarintResourceManager(dAtA, i, uint64(m.Action)) + i-- + dAtA[i] = 0x10 + } + if m.Rule != nil { + { + size, err := m.Rule.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintResourceManager(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + func encodeVarintResourceManager(dAtA []byte, offset int, v uint64) int { offset -= sovResourceManager(v) base := offset @@ -3670,6 +4053,10 @@ func (m *ResourceGroup) Size() (n int) { if m.Priority != 0 { n += 1 + sovResourceManager(uint64(m.Priority)) } + if m.RunawaySettings != nil { + l = m.RunawaySettings.Size() + n += 1 + l + sovResourceManager(uint64(l)) + } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } @@ -3772,10 +4159,66 @@ func (m *Error) Size() (n int) { return n } -func sovResourceManager(x uint64) (n int) { - return (math_bits.Len64(x|1) + 6) / 7 -} -func sozResourceManager(x uint64) (n int) { +func (m *RunawayRule) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ExecElapsedTimeMs != 0 { + n += 1 + sovResourceManager(uint64(m.ExecElapsedTimeMs)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *RunawayWatch) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.LastDurationMs != 0 { + n += 1 + sovResourceManager(uint64(m.LastDurationMs)) + } + if m.Type != 0 { + n += 1 + sovResourceManager(uint64(m.Type)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *RunawaySettings) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Rule != nil { + l = m.Rule.Size() + n += 1 + l + sovResourceManager(uint64(l)) + } + if m.Action != 0 { + n += 1 + sovResourceManager(uint64(m.Action)) + } + if m.Watch != nil { + l = m.Watch.Size() + n += 1 + l + sovResourceManager(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func sovResourceManager(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozResourceManager(x uint64) (n int) { return sovResourceManager(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } func (m *ListResourceGroupsRequest) Unmarshal(dAtA []byte) error { @@ -6040,6 +6483,42 @@ func (m *ResourceGroup) Unmarshal(dAtA []byte) error { break } } + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RunawaySettings", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowResourceManager + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthResourceManager + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthResourceManager + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.RunawaySettings == nil { + m.RunawaySettings = &RunawaySettings{} + } + if err := m.RunawaySettings.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipResourceManager(dAtA[iNdEx:]) @@ -6589,6 +7068,307 @@ func (m *Error) Unmarshal(dAtA []byte) error { } return nil } +func (m *RunawayRule) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowResourceManager + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: RunawayRule: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RunawayRule: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ExecElapsedTimeMs", wireType) + } + m.ExecElapsedTimeMs = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowResourceManager + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ExecElapsedTimeMs |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipResourceManager(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthResourceManager + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *RunawayWatch) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowResourceManager + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: RunawayWatch: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RunawayWatch: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field LastDurationMs", wireType) + } + m.LastDurationMs = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowResourceManager + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.LastDurationMs |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) + } + m.Type = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowResourceManager + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Type |= RunawayWatchType(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipResourceManager(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthResourceManager + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *RunawaySettings) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowResourceManager + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: RunawaySettings: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RunawaySettings: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Rule", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowResourceManager + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthResourceManager + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthResourceManager + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Rule == nil { + m.Rule = &RunawayRule{} + } + if err := m.Rule.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Action", wireType) + } + m.Action = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowResourceManager + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Action |= RunawayAction(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Watch", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowResourceManager + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthResourceManager + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthResourceManager + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Watch == nil { + m.Watch = &RunawayWatch{} + } + if err := m.Watch.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipResourceManager(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthResourceManager + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func skipResourceManager(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/proto/kvrpcpb.proto b/proto/kvrpcpb.proto index d4826cb15..cd4c2e828 100644 --- a/proto/kvrpcpb.proto +++ b/proto/kvrpcpb.proto @@ -880,6 +880,10 @@ message ResourceControlContext { // The resource consumption of the resource group that have completed at all TiKVs between the previous request to this TiKV and current request. // It's used as penalty to make the local resource scheduling on one TiKV takes the gloabl resource consumption into consideration. resource_manager.Consumption penalty = 2; + + // This priority would override the original priority of the resource group for the request. + // Used to deprioritize the runaway queries. + uint64 override_priority = 3; } // The API version the server and the client is using. diff --git a/proto/pdpb.proto b/proto/pdpb.proto index a824a1d5e..22339b6e9 100644 --- a/proto/pdpb.proto +++ b/proto/pdpb.proto @@ -79,6 +79,14 @@ service PD { rpc UpdateServiceGCSafePoint(UpdateServiceGCSafePointRequest) returns (UpdateServiceGCSafePointResponse) {} + rpc GetGCSafePointV2(GetGCSafePointV2Request) returns (GetGCSafePointV2Response) {} + + rpc WatchGCSafePointV2(WatchGCSafePointV2Request) returns (stream WatchGCSafePointV2Response) {} + + rpc UpdateGCSafePointV2(UpdateGCSafePointV2Request) returns (UpdateGCSafePointV2Response) {} + + rpc UpdateServiceSafePointV2(UpdateServiceSafePointV2Request) returns (UpdateServiceSafePointV2Response) {} + rpc SyncRegions(stream SyncRegionRequest) returns (stream SyncRegionResponse) {} rpc GetOperator(GetOperatorRequest) returns (GetOperatorResponse) {} @@ -104,6 +112,11 @@ service PD { rpc SetExternalTimestamp(SetExternalTimestampRequest) returns (SetExternalTimestampResponse) {} rpc GetExternalTimestamp(GetExternalTimestampRequest) returns (GetExternalTimestampResponse) {} + + // Get the minimum timestamp across all keyspace groups from API server + // TODO: Currently, we need to ask API server to get the minimum timestamp. + // Once we support service discovery, we can remove it. + rpc GetMinTS (GetMinTSRequest) returns (GetMinTSResponse) {} } message WatchGlobalConfigRequest { @@ -812,6 +825,72 @@ message UpdateServiceGCSafePointResponse { uint64 min_safe_point = 4; } +message GetGCSafePointV2Request { + RequestHeader header = 1; + + uint32 keyspace_id = 2; +} + +message GetGCSafePointV2Response { + ResponseHeader header = 1; + + uint64 safe_point = 2; +} + +message WatchGCSafePointV2Request { + RequestHeader header = 1; + int64 revision = 2; + +} + +// SafePointEvent is for the rpc WatchGCSafePointV2. +message SafePointEvent { + uint32 keyspace_id = 1; + uint64 safe_point = 2; + EventType type = 3; +} + +message WatchGCSafePointV2Response { + ResponseHeader header = 1; + repeated SafePointEvent events = 2; + int64 revision = 3; +} + +message UpdateGCSafePointV2Request { + RequestHeader header = 1; + + uint32 keyspace_id = 2; + uint64 safe_point = 3; +} + +message UpdateGCSafePointV2Response { + ResponseHeader header = 1; + + uint64 new_safe_point = 2; +} + +message UpdateServiceSafePointV2Request { + RequestHeader header = 1; + + uint32 keyspace_id = 2; + bytes service_id = 3; + uint64 safe_point = 4; + // Safe point will be set to expire on (PD Server time + TTL), + // pass in a ttl < 0 to remove target safe point; + // pass in MAX_INT64 to set a safe point that never expire. + // This should be set by component that may crash unexpectedly so that it doesn't block + // cluster garbage collection. + int64 ttl = 5; +} + +message UpdateServiceSafePointV2Response { + ResponseHeader header = 1; + + bytes service_id = 2; + int64 ttl = 3; + uint64 min_safe_point = 4; +} + message RegionStat { // Bytes read/written during this period. uint64 bytes_written = 1; @@ -996,3 +1075,13 @@ message GetExternalTimestampResponse { uint64 timestamp = 2; } + +message GetMinTSRequest { + RequestHeader header = 1; +} + +message GetMinTSResponse { + ResponseHeader header = 1; + + Timestamp timestamp = 2; +} diff --git a/proto/resource_manager.proto b/proto/resource_manager.proto index 20613a763..eb4898680 100644 --- a/proto/resource_manager.proto +++ b/proto/resource_manager.proto @@ -154,6 +154,8 @@ message ResourceGroup { GroupRawResourceSettings raw_resource_settings = 4; // The task scheduling priority uint32 priority = 5; + // Runaway queries settings + RunawaySettings runaway_settings = 6; } message GroupRequestUnitSettings { @@ -180,4 +182,31 @@ message TokenLimitSettings { message Error { string message = 1; +} + +enum RunawayAction { + DryRun = 0; // do nothing + CoolDown = 1; // deprioritize the task + Kill = 2; // kill the task +} + +enum RunawayWatchType { + Exact = 0; + Similar = 1; +} + +message RunawayRule { + uint64 exec_elapsed_time_ms = 1; +} + +message RunawayWatch { + // how long would the watch last + uint64 last_duration_ms = 1; + RunawayWatchType type = 2; +} + +message RunawaySettings { + RunawayRule rule = 1; + RunawayAction action = 2; + RunawayWatch watch = 3; } \ No newline at end of file diff --git a/scripts/proto.lock b/scripts/proto.lock index dc6b073cc..488ad2036 100644 --- a/scripts/proto.lock +++ b/scripts/proto.lock @@ -9446,6 +9446,11 @@ "id": 2, "name": "penalty", "type": "resource_manager.Consumption" + }, + { + "id": 3, + "name": "override_priority", + "type": "uint64" } ] }, @@ -13917,6 +13922,182 @@ } ] }, + { + "name": "GetGCSafePointV2Request", + "fields": [ + { + "id": 1, + "name": "header", + "type": "RequestHeader" + }, + { + "id": 2, + "name": "keyspace_id", + "type": "uint32" + } + ] + }, + { + "name": "GetGCSafePointV2Response", + "fields": [ + { + "id": 1, + "name": "header", + "type": "ResponseHeader" + }, + { + "id": 2, + "name": "safe_point", + "type": "uint64" + } + ] + }, + { + "name": "WatchGCSafePointV2Request", + "fields": [ + { + "id": 1, + "name": "header", + "type": "RequestHeader" + }, + { + "id": 2, + "name": "revision", + "type": "int64" + } + ] + }, + { + "name": "SafePointEvent", + "fields": [ + { + "id": 1, + "name": "keyspace_id", + "type": "uint32" + }, + { + "id": 2, + "name": "safe_point", + "type": "uint64" + }, + { + "id": 3, + "name": "type", + "type": "EventType" + } + ] + }, + { + "name": "WatchGCSafePointV2Response", + "fields": [ + { + "id": 1, + "name": "header", + "type": "ResponseHeader" + }, + { + "id": 2, + "name": "events", + "type": "SafePointEvent", + "is_repeated": true + }, + { + "id": 3, + "name": "revision", + "type": "int64" + } + ] + }, + { + "name": "UpdateGCSafePointV2Request", + "fields": [ + { + "id": 1, + "name": "header", + "type": "RequestHeader" + }, + { + "id": 2, + "name": "keyspace_id", + "type": "uint32" + }, + { + "id": 3, + "name": "safe_point", + "type": "uint64" + } + ] + }, + { + "name": "UpdateGCSafePointV2Response", + "fields": [ + { + "id": 1, + "name": "header", + "type": "ResponseHeader" + }, + { + "id": 2, + "name": "new_safe_point", + "type": "uint64" + } + ] + }, + { + "name": "UpdateServiceSafePointV2Request", + "fields": [ + { + "id": 1, + "name": "header", + "type": "RequestHeader" + }, + { + "id": 2, + "name": "keyspace_id", + "type": "uint32" + }, + { + "id": 3, + "name": "service_id", + "type": "bytes" + }, + { + "id": 4, + "name": "safe_point", + "type": "uint64" + }, + { + "id": 5, + "name": "ttl", + "type": "int64" + } + ] + }, + { + "name": "UpdateServiceSafePointV2Response", + "fields": [ + { + "id": 1, + "name": "header", + "type": "ResponseHeader" + }, + { + "id": 2, + "name": "service_id", + "type": "bytes" + }, + { + "id": 3, + "name": "ttl", + "type": "int64" + }, + { + "id": 4, + "name": "min_safe_point", + "type": "uint64" + } + ] + }, { "name": "RegionStat", "fields": [ @@ -14419,6 +14600,31 @@ "type": "uint64" } ] + }, + { + "name": "GetMinTSRequest", + "fields": [ + { + "id": 1, + "name": "header", + "type": "RequestHeader" + } + ] + }, + { + "name": "GetMinTSResponse", + "fields": [ + { + "id": 1, + "name": "header", + "type": "ResponseHeader" + }, + { + "id": 2, + "name": "timestamp", + "type": "Timestamp" + } + ] } ], "services": [ @@ -14571,6 +14777,27 @@ "in_type": "UpdateServiceGCSafePointRequest", "out_type": "UpdateServiceGCSafePointResponse" }, + { + "name": "GetGCSafePointV2", + "in_type": "GetGCSafePointV2Request", + "out_type": "GetGCSafePointV2Response" + }, + { + "name": "WatchGCSafePointV2", + "in_type": "WatchGCSafePointV2Request", + "out_type": "WatchGCSafePointV2Response", + "out_streamed": true + }, + { + "name": "UpdateGCSafePointV2", + "in_type": "UpdateGCSafePointV2Request", + "out_type": "UpdateGCSafePointV2Response" + }, + { + "name": "UpdateServiceSafePointV2", + "in_type": "UpdateServiceSafePointV2Request", + "out_type": "UpdateServiceSafePointV2Response" + }, { "name": "SyncRegions", "in_type": "SyncRegionRequest", @@ -14639,6 +14866,11 @@ "name": "GetExternalTimestamp", "in_type": "GetExternalTimestampRequest", "out_type": "GetExternalTimestampResponse" + }, + { + "name": "GetMinTS", + "in_type": "GetMinTSRequest", + "out_type": "GetMinTSResponse" } ] } @@ -17036,6 +17268,34 @@ "integer": 2 } ] + }, + { + "name": "RunawayAction", + "enum_fields": [ + { + "name": "DryRun" + }, + { + "name": "CoolDown", + "integer": 1 + }, + { + "name": "Kill", + "integer": 2 + } + ] + }, + { + "name": "RunawayWatchType", + "enum_fields": [ + { + "name": "Exact" + }, + { + "name": "Similar", + "integer": 1 + } + ] } ], "messages": [ @@ -17383,6 +17643,11 @@ "id": 5, "name": "priority", "type": "uint32" + }, + { + "id": 6, + "name": "runaway_settings", + "type": "RunawaySettings" } ] }, @@ -17460,6 +17725,51 @@ "type": "string" } ] + }, + { + "name": "RunawayRule", + "fields": [ + { + "id": 1, + "name": "exec_elapsed_time_ms", + "type": "uint64" + } + ] + }, + { + "name": "RunawayWatch", + "fields": [ + { + "id": 1, + "name": "last_duration_ms", + "type": "uint64" + }, + { + "id": 2, + "name": "type", + "type": "RunawayWatchType" + } + ] + }, + { + "name": "RunawaySettings", + "fields": [ + { + "id": 1, + "name": "rule", + "type": "RunawayRule" + }, + { + "id": 2, + "name": "action", + "type": "RunawayAction" + }, + { + "id": 3, + "name": "watch", + "type": "RunawayWatch" + } + ] } ], "services": [