From d3169959869920288675410495f6c8b55d7055b9 Mon Sep 17 00:00:00 2001 From: wuhuizuo Date: Tue, 20 Aug 2024 11:51:12 +0800 Subject: [PATCH 1/5] Update OWNERS_ALIASES (#1258) * Update OWNERS_ALIASES * Update OWNERS_ALIASES --- OWNERS_ALIASES | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/OWNERS_ALIASES b/OWNERS_ALIASES index d7b564dc1..103d81c73 100644 --- a/OWNERS_ALIASES +++ b/OWNERS_ALIASES @@ -2,6 +2,7 @@ aliases: emeritus-approvers: # do not assign it in any OWNERS file. - tonyxuqqi # 2024-05 + - kevin-xialiu # 2024-08 sig-approvers: # default approvers for the repo on rest folders. - cfzjywxk - lance6716 @@ -9,9 +10,8 @@ aliases: - you06 - YuJuncen sig-approvers-pb: # default approvers for `proto` folder - - kevin-xialiu - yudongusa - - zhangjinpeng1987 + - zhangjinpeng87 sig-approvers-pb-autoid: [bb7133, tiancaiamao] sig-approvers-pb-br: [BornChanger, overvenus] sig-approvers-pb-import: [BornChanger, D3Hunter, lance6716] From c203a27de26d1138decbbd91065a45e8a641a20e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=B1=B1=E5=B2=9A?= <36239017+YuJuncen@users.noreply.github.com> Date: Wed, 21 Aug 2024 15:19:24 +0800 Subject: [PATCH 2/5] Added messages needed by compact log backup (#1256) * added compaction log Signed-off-by: hillium * added compaction meta Signed-off-by: hillium * added type for compaction Signed-off-by: hillium * added migration Signed-off-by: hillium * refine prepare backup Signed-off-by: hillium * added crc64xor for backup Signed-off-by: hillium * update field name Signed-off-by: hillium * rename compaction to subcompaction; compactionrun to compactin Signed-off-by: hillium * update names Signed-off-by: hillium * added deletion Signed-off-by: hillium * added hint for deleting generated ssts Signed-off-by: hillium * added rewrite meta Signed-off-by: hillium * make migration meta-based Signed-off-by: hillium * refine MetaEditr Signed-off-by: hillium * added destruct prefix Signed-off-by: hillium * fix subcomactions Signed-off-by: hillium * added table id for subcompaction meta Signed-off-by: hillium * added a newline to end of file Signed-off-by: hillium * added more comments Signed-off-by: hillium * address comments Signed-off-by: hillium * added some fields Signed-off-by: hillium * make epoch repeated Signed-off-by: hillium --------- Signed-off-by: hillium Signed-off-by: hillium --- pkg/brpb/brpb.pb.go | 12435 ++++++++++++++++++++++++++---------------- proto/brpb.proto | 122 + scripts/proto.lock | 261 + 3 files changed, 8205 insertions(+), 4613 deletions(-) diff --git a/pkg/brpb/brpb.pb.go b/pkg/brpb/brpb.pb.go index 432d9607f..1d55bfacb 100644 --- a/pkg/brpb/brpb.pb.go +++ b/pkg/brpb/brpb.pb.go @@ -3792,10 +3792,24 @@ type DataFileInfo struct { // The range length of the merged file, if it exists. RangeLength uint64 `protobuf:"varint,17,opt,name=range_length,json=rangeLength,proto3" json:"range_length,omitempty"` // The compression type for the file. - CompressionType CompressionType `protobuf:"varint,18,opt,name=compression_type,json=compressionType,proto3,enum=backup.CompressionType" json:"compression_type,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + CompressionType CompressionType `protobuf:"varint,18,opt,name=compression_type,json=compressionType,proto3,enum=backup.CompressionType" json:"compression_type,omitempty"` + // The CRC64XOR of all contents of the file. + // In older versions, this might be empty. + Crc64Xor uint64 `protobuf:"varint,19,opt,name=crc64xor,proto3" json:"crc64xor,omitempty"` + // The original region range the log file belongs to. + // In older versions, this might be empty. + RegionStartKey []byte `protobuf:"bytes,20,opt,name=region_start_key,json=regionStartKey,proto3" json:"region_start_key,omitempty"` + // The original region range the log file belongs to. + // In older versions, this might be empty. + RegionEndKey []byte `protobuf:"bytes,21,opt,name=region_end_key,json=regionEndKey,proto3" json:"region_end_key,omitempty"` + // The region epoch that the log file belongs to. + // In older versions, this might be empty. + // If a region get split or merged during observing, + // the file may contain multi epoches. + RegionEpoch []*metapb.RegionEpoch `protobuf:"bytes,22,rep,name=region_epoch,json=regionEpoch,proto3" json:"region_epoch,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } func (m *DataFileInfo) Reset() { *m = DataFileInfo{} } @@ -3957,6 +3971,34 @@ func (m *DataFileInfo) GetCompressionType() CompressionType { return CompressionType_UNKNOWN } +func (m *DataFileInfo) GetCrc64Xor() uint64 { + if m != nil { + return m.Crc64Xor + } + return 0 +} + +func (m *DataFileInfo) GetRegionStartKey() []byte { + if m != nil { + return m.RegionStartKey + } + return nil +} + +func (m *DataFileInfo) GetRegionEndKey() []byte { + if m != nil { + return m.RegionEndKey + } + return nil +} + +func (m *DataFileInfo) GetRegionEpoch() []*metapb.RegionEpoch { + if m != nil { + return m.RegionEpoch + } + return nil +} + type StreamBackupError struct { // the unix epoch time (in millisecs) of the time the error reported. HappenAt uint64 `protobuf:"varint,1,opt,name=happen_at,json=happenAt,proto3" json:"happen_at,omitempty"` @@ -4032,1128 +4074,1470 @@ func (m *StreamBackupError) GetStoreId() uint64 { return 0 } -func init() { - proto.RegisterEnum("backup.PrepareSnapshotBackupRequestType", PrepareSnapshotBackupRequestType_name, PrepareSnapshotBackupRequestType_value) - proto.RegisterEnum("backup.PrepareSnapshotBackupEventType", PrepareSnapshotBackupEventType_name, PrepareSnapshotBackupEventType_value) - proto.RegisterEnum("backup.CompressionType", CompressionType_name, CompressionType_value) - proto.RegisterEnum("backup.BackupMode", BackupMode_name, BackupMode_value) - proto.RegisterEnum("backup.MetaVersion", MetaVersion_name, MetaVersion_value) - proto.RegisterEnum("backup.FileType", FileType_name, FileType_value) - proto.RegisterType((*PrepareSnapshotBackupRequest)(nil), "backup.PrepareSnapshotBackupRequest") - proto.RegisterType((*PrepareSnapshotBackupResponse)(nil), "backup.PrepareSnapshotBackupResponse") - proto.RegisterType((*BackupMeta)(nil), "backup.BackupMeta") - proto.RegisterType((*BackupRange)(nil), "backup.BackupRange") - proto.RegisterType((*File)(nil), "backup.File") - proto.RegisterType((*MetaFile)(nil), "backup.MetaFile") - proto.RegisterType((*PlacementPolicy)(nil), "backup.PlacementPolicy") - proto.RegisterType((*StatsBlock)(nil), "backup.StatsBlock") - proto.RegisterType((*StatsFile)(nil), "backup.StatsFile") - proto.RegisterType((*StatsFileIndex)(nil), "backup.StatsFileIndex") - proto.RegisterType((*Schema)(nil), "backup.Schema") - proto.RegisterType((*IDMap)(nil), "backup.IDMap") - proto.RegisterType((*PitrTableMap)(nil), "backup.PitrTableMap") - proto.RegisterType((*PitrDBMap)(nil), "backup.PitrDBMap") - proto.RegisterType((*RawRange)(nil), "backup.RawRange") - proto.RegisterType((*ClusterIDError)(nil), "backup.ClusterIDError") - proto.RegisterType((*Error)(nil), "backup.Error") - proto.RegisterType((*CipherInfo)(nil), "backup.CipherInfo") - proto.RegisterType((*BackupRequest)(nil), "backup.BackupRequest") - proto.RegisterType((*StreamBackupTaskInfo)(nil), "backup.StreamBackupTaskInfo") - proto.RegisterType((*StorageBackend)(nil), "backup.StorageBackend") - proto.RegisterType((*Noop)(nil), "backup.Noop") - proto.RegisterType((*Local)(nil), "backup.Local") - proto.RegisterType((*S3)(nil), "backup.S3") - proto.RegisterType((*GCS)(nil), "backup.GCS") - proto.RegisterType((*AzureCustomerKey)(nil), "backup.AzureCustomerKey") - proto.RegisterType((*AzureBlobStorage)(nil), "backup.AzureBlobStorage") - proto.RegisterType((*Bucket)(nil), "backup.Bucket") - proto.RegisterType((*CloudDynamic)(nil), "backup.CloudDynamic") - proto.RegisterMapType((map[string]string)(nil), "backup.CloudDynamic.AttrsEntry") - proto.RegisterType((*HDFS)(nil), "backup.HDFS") - proto.RegisterType((*BackupResponse)(nil), "backup.BackupResponse") - proto.RegisterType((*CleanupRequest)(nil), "backup.CleanupRequest") - proto.RegisterType((*CleanupResponse)(nil), "backup.CleanupResponse") - proto.RegisterType((*PrepareRequest)(nil), "backup.PrepareRequest") - proto.RegisterType((*PrepareResponse)(nil), "backup.PrepareResponse") - proto.RegisterType((*CheckAdminRequest)(nil), "backup.CheckAdminRequest") - proto.RegisterType((*CheckAdminResponse)(nil), "backup.CheckAdminResponse") - proto.RegisterType((*ExternalStorageRestoreRequest)(nil), "backup.ExternalStorageRestoreRequest") - proto.RegisterType((*ExternalStorageRestoreResponse)(nil), "backup.ExternalStorageRestoreResponse") - proto.RegisterType((*ExternalStorageSaveRequest)(nil), "backup.ExternalStorageSaveRequest") - proto.RegisterType((*ExternalStorageSaveResponse)(nil), "backup.ExternalStorageSaveResponse") - proto.RegisterType((*Metadata)(nil), "backup.Metadata") - proto.RegisterType((*DataFileGroup)(nil), "backup.DataFileGroup") - proto.RegisterType((*DataFileInfo)(nil), "backup.DataFileInfo") - proto.RegisterType((*StreamBackupError)(nil), "backup.StreamBackupError") +type Span struct { + Offset uint64 `protobuf:"varint,1,opt,name=offset,proto3" json:"offset,omitempty"` + Length uint64 `protobuf:"varint,2,opt,name=length,proto3" json:"length,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } -func init() { proto.RegisterFile("brpb.proto", fileDescriptor_483d1f48d58a4885) } - -var fileDescriptor_483d1f48d58a4885 = []byte{ - // 3723 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x7a, 0x5b, 0x6f, 0x23, 0x47, - 0x76, 0xbf, 0x9a, 0x77, 0x1e, 0x92, 0x22, 0x55, 0x73, 0x31, 0xad, 0xd9, 0x99, 0x91, 0x7b, 0x3c, - 0xf3, 0xd7, 0x5f, 0x5e, 0x6b, 0xbd, 0x33, 0x5e, 0xef, 0x24, 0xde, 0xc0, 0xd0, 0x6d, 0x2c, 0x79, - 0x6e, 0x4a, 0x49, 0xeb, 0x45, 0xfc, 0xd2, 0x68, 0x76, 0x97, 0xc4, 0x5e, 0x35, 0xbb, 0x7b, 0xbb, - 0x9a, 0x1c, 0xc9, 0x8f, 0x79, 0x37, 0x72, 0x01, 0x02, 0xe4, 0x0b, 0x04, 0xc8, 0x43, 0x02, 0xe4, - 0x23, 0xe4, 0x25, 0xc0, 0x06, 0x09, 0x90, 0x05, 0x92, 0x87, 0x3c, 0x06, 0x0e, 0xf2, 0x31, 0x02, - 0x04, 0xe7, 0x54, 0x55, 0xb3, 0xc9, 0xa1, 0x34, 0x33, 0x9b, 0x60, 0x9f, 0xd8, 0xf5, 0x3b, 0xa7, - 0xaa, 0x4f, 0x9d, 0x7b, 0x55, 0x13, 0x60, 0x90, 0x26, 0x83, 0xcd, 0x24, 0x8d, 0xb3, 0x98, 0xd5, - 0x06, 0xae, 0x77, 0x36, 0x4e, 0x56, 0x3b, 0x67, 0x93, 0x34, 0xf1, 0x0c, 0xbc, 0xda, 0x11, 0x69, - 0x1a, 0xe7, 0x5c, 0xab, 0xed, 0x91, 0xc8, 0xdc, 0x7c, 0xc4, 0x44, 0xe4, 0xa5, 0x17, 0x49, 0x16, - 0xc4, 0x51, 0x8e, 0x5d, 0x3f, 0x8d, 0x4f, 0x63, 0x7a, 0xfc, 0x11, 0x3e, 0x69, 0xb4, 0x9b, 0x8e, - 0x65, 0x46, 0x8f, 0x0a, 0xb0, 0xff, 0xc6, 0x82, 0x1f, 0x1c, 0xa6, 0x22, 0x71, 0x53, 0x71, 0x14, - 0xb9, 0x89, 0x1c, 0xc6, 0xd9, 0x36, 0x09, 0xc0, 0xc5, 0xaf, 0xc6, 0x42, 0x66, 0xec, 0x31, 0x94, - 0xb2, 0x8b, 0xbe, 0xb5, 0x66, 0xad, 0x2f, 0x3f, 0x5c, 0xdf, 0x54, 0xc2, 0x6d, 0x5e, 0x35, 0xe3, - 0xf8, 0x22, 0x11, 0xbc, 0x94, 0x5d, 0xb0, 0x75, 0xa8, 0xa7, 0xe2, 0x34, 0x88, 0x23, 0xd9, 0x2f, - 0xad, 0x95, 0xd7, 0x5b, 0x0f, 0x97, 0x37, 0xb5, 0xd4, 0x9c, 0x60, 0x6e, 0xc8, 0x6c, 0x1d, 0x7a, - 0xa1, 0x70, 0xa5, 0x70, 0x82, 0xc8, 0x91, 0xc2, 0x8b, 0x23, 0x5f, 0xf6, 0xcb, 0x6b, 0xd6, 0x7a, - 0x85, 0x2f, 0x13, 0x7e, 0x10, 0x1d, 0x29, 0xd4, 0xfe, 0x37, 0x0b, 0x6e, 0x5f, 0xf2, 0x72, 0x99, - 0xc4, 0x91, 0x14, 0xec, 0xb3, 0x82, 0xbc, 0x0f, 0xae, 0x94, 0x77, 0x6f, 0x22, 0xa2, 0xa9, 0xb4, - 0x0f, 0xa0, 0xa6, 0xc4, 0xe9, 0x97, 0xd6, 0xac, 0x05, 0xc2, 0x6a, 0x2a, 0xfb, 0x10, 0xaa, 0x64, - 0x0a, 0x12, 0x10, 0xd9, 0x8c, 0x61, 0xf6, 0xf0, 0x97, 0x2b, 0x22, 0xfb, 0x18, 0xae, 0x85, 0xae, - 0xcc, 0x1c, 0xbd, 0x2d, 0xe9, 0x4c, 0xdc, 0x30, 0xf0, 0xfb, 0x95, 0x35, 0x6b, 0xbd, 0xc1, 0x7b, - 0x48, 0x7a, 0x46, 0x1b, 0x93, 0x5f, 0x23, 0x6e, 0xff, 0x57, 0x1d, 0x40, 0x09, 0xf5, 0x5c, 0x64, - 0x2e, 0xbb, 0x0d, 0xe0, 0x85, 0x63, 0x99, 0x89, 0xd4, 0x09, 0x7c, 0xda, 0x4b, 0x85, 0x37, 0x35, - 0x72, 0xe0, 0xb3, 0xff, 0x07, 0x5d, 0x43, 0x9e, 0x88, 0x54, 0x1a, 0x99, 0x9b, 0x7c, 0x59, 0xc3, - 0x5f, 0x2b, 0x14, 0xd7, 0x19, 0x4c, 0x79, 0x5a, 0xc4, 0xd3, 0x1c, 0xe4, 0xe4, 0x3e, 0xd4, 0x0d, - 0xad, 0xbd, 0x66, 0xad, 0x57, 0xb9, 0x19, 0x32, 0x1b, 0xaa, 0x27, 0x41, 0x28, 0x64, 0xbf, 0x42, - 0x86, 0x6b, 0x1b, 0x3d, 0x3e, 0x09, 0x42, 0xc1, 0x15, 0x89, 0xfd, 0x08, 0x00, 0x1f, 0x9c, 0x20, - 0xf2, 0xc5, 0x79, 0xbf, 0x43, 0xda, 0xe8, 0x19, 0x46, 0xdc, 0x06, 0x31, 0x37, 0x91, 0xe7, 0x00, - 0x59, 0xd8, 0x3d, 0xe8, 0xc8, 0xcc, 0x4d, 0xb3, 0x5c, 0xa0, 0x2a, 0x6d, 0xac, 0x4d, 0xa0, 0x91, - 0xe9, 0x2e, 0xb4, 0x44, 0xe4, 0xe7, 0x2c, 0x35, 0x62, 0x01, 0x11, 0xf9, 0x86, 0x61, 0x1d, 0xea, - 0xd2, 0x1b, 0x8a, 0x91, 0x2b, 0xfb, 0x75, 0xed, 0x55, 0xfa, 0x9d, 0x47, 0x04, 0x73, 0x43, 0x66, - 0x8f, 0xa0, 0xad, 0x1e, 0xb5, 0x88, 0xcb, 0x97, 0x88, 0xd8, 0x52, 0x5c, 0x4a, 0xc8, 0x55, 0x68, - 0x06, 0xd2, 0x49, 0xdd, 0x57, 0xce, 0xd9, 0xa4, 0xdf, 0x20, 0x73, 0xd5, 0x03, 0xc9, 0xdd, 0x57, - 0x4f, 0x27, 0xb8, 0x63, 0x24, 0xa4, 0x6e, 0x74, 0x2a, 0x64, 0xbf, 0x49, 0x6f, 0xcf, 0x97, 0xe3, - 0xee, 0x2b, 0x8e, 0x04, 0xde, 0x4c, 0xf5, 0x93, 0x64, 0x8f, 0xa1, 0x9b, 0x4f, 0xd0, 0x42, 0x74, - 0x2f, 0x11, 0xa2, 0x63, 0x66, 0x29, 0x31, 0x18, 0x54, 0x7c, 0x3f, 0x94, 0x7d, 0x58, 0xb3, 0xd6, - 0xdb, 0x9c, 0x9e, 0xd9, 0x8f, 0xa1, 0xe5, 0xfb, 0xa1, 0x5a, 0x47, 0xc8, 0x7e, 0xef, 0x92, 0x95, - 0xc0, 0xf7, 0xc3, 0x03, 0xc5, 0x83, 0x2a, 0x57, 0x64, 0x27, 0x15, 0x72, 0x1c, 0x66, 0xfd, 0x15, - 0xf2, 0x81, 0xf6, 0xc0, 0xc4, 0xcc, 0x38, 0xcc, 0xd8, 0xa7, 0xd0, 0x72, 0x93, 0x20, 0x57, 0x39, - 0xa3, 0xd0, 0xb9, 0xb6, 0x69, 0xf2, 0xcf, 0xd6, 0xe1, 0x81, 0xd6, 0x3d, 0x07, 0x37, 0x09, 0x8c, - 0x1d, 0x1e, 0x41, 0x23, 0x89, 0xc3, 0xc0, 0x0b, 0x84, 0xec, 0x5f, 0x23, 0x55, 0xbc, 0x97, 0x47, - 0x5b, 0xe8, 0x7a, 0x62, 0x24, 0xa2, 0xec, 0x10, 0x19, 0x2e, 0x78, 0xce, 0xc8, 0x3e, 0x85, 0x9b, - 0x91, 0x78, 0xe5, 0x78, 0x71, 0x18, 0xba, 0x98, 0xad, 0xa4, 0x23, 0x22, 0x77, 0x10, 0x0a, 0xbf, - 0x7f, 0x9d, 0x04, 0xbb, 0x1e, 0x89, 0x57, 0x3b, 0x39, 0x71, 0x4f, 0xd1, 0xb4, 0x4d, 0xb2, 0xf3, - 0x08, 0x6d, 0x72, 0xc3, 0xd8, 0xe4, 0xf8, 0x3c, 0x7a, 0x3a, 0x61, 0x1b, 0x50, 0xf7, 0x07, 0xce, - 0xc8, 0x4d, 0x64, 0xff, 0x26, 0x49, 0xb1, 0x92, 0x4b, 0x11, 0x64, 0xe9, 0xee, 0xf6, 0x73, 0x37, - 0xe1, 0x35, 0x7f, 0xf0, 0xdc, 0x4d, 0x24, 0x7b, 0x00, 0x95, 0x51, 0xec, 0x8b, 0xfe, 0x7b, 0xb4, - 0x43, 0x66, 0x18, 0x75, 0xe0, 0xc5, 0xbe, 0xe0, 0x44, 0x67, 0x1f, 0x41, 0x4d, 0xdb, 0xb8, 0x4f, - 0x4b, 0x5e, 0x9b, 0xe5, 0x54, 0x66, 0xd6, 0x2c, 0xe8, 0xb0, 0x5a, 0xc5, 0x32, 0xf8, 0x56, 0xf4, - 0xdf, 0x57, 0x0e, 0xab, 0xa0, 0xa3, 0xe0, 0x5b, 0xf1, 0x55, 0xa5, 0x51, 0xee, 0x55, 0x78, 0x25, - 0x71, 0xb3, 0xa1, 0x7d, 0x0a, 0xad, 0xc2, 0x1a, 0xec, 0x16, 0x34, 0x55, 0x44, 0x9c, 0x09, 0x95, - 0xb2, 0xda, 0xbc, 0x41, 0xc0, 0x53, 0x71, 0xc1, 0xde, 0x83, 0x3a, 0x46, 0x02, 0x92, 0x4a, 0x44, - 0xaa, 0x89, 0xc8, 0x47, 0x42, 0x1e, 0x9c, 0xe5, 0x4b, 0x83, 0xd3, 0xfe, 0xc7, 0x12, 0x54, 0x70, - 0x8c, 0x8e, 0x14, 0xb9, 0x23, 0x41, 0xab, 0x37, 0x39, 0x3d, 0xb3, 0x9b, 0x50, 0x93, 0x43, 0xf7, - 0xe1, 0x4f, 0x3e, 0x33, 0x0b, 0xab, 0xd1, 0xac, 0x38, 0xe5, 0xcb, 0xc5, 0xa9, 0xcc, 0x88, 0xf3, - 0x7f, 0x13, 0xd6, 0xab, 0xd0, 0xf0, 0x52, 0xef, 0xb3, 0x4f, 0xcf, 0xe3, 0xb4, 0x5f, 0x27, 0x6a, - 0x3e, 0x46, 0xb9, 0xb2, 0x38, 0x73, 0x43, 0xe7, 0x6c, 0x22, 0x29, 0x26, 0x2b, 0xbc, 0x41, 0xc0, - 0xd3, 0x09, 0xe9, 0x5f, 0x11, 0x07, 0x17, 0x19, 0x45, 0x25, 0xad, 0x4c, 0xd0, 0x36, 0x22, 0x6c, - 0x19, 0x4a, 0xde, 0x09, 0x05, 0x52, 0x93, 0x97, 0xbc, 0x13, 0xd4, 0x08, 0x59, 0xaa, 0x45, 0x9c, - 0xf4, 0x8c, 0x6f, 0xf0, 0x82, 0x64, 0x88, 0xf9, 0x76, 0x42, 0xb9, 0xb0, 0xcd, 0x1b, 0x0a, 0x38, - 0x98, 0xd8, 0xdf, 0x95, 0xa0, 0x61, 0xa2, 0x8b, 0x7d, 0x04, 0x80, 0x75, 0xc1, 0x51, 0x16, 0xb0, - 0x16, 0x58, 0xa0, 0x39, 0xd2, 0xbc, 0x12, 0x99, 0x7d, 0x37, 0x67, 0x2e, 0x2d, 0x62, 0x46, 0xba, - 0x62, 0x2e, 0x24, 0xb6, 0xf2, 0xd5, 0x89, 0x6d, 0x36, 0x0f, 0x55, 0xde, 0x26, 0x0f, 0xe5, 0x69, - 0x40, 0xcd, 0xa9, 0x5d, 0xee, 0xd7, 0x26, 0x37, 0xa8, 0x99, 0x26, 0x0f, 0x55, 0xd7, 0xca, 0x26, - 0x0f, 0xd9, 0xf7, 0xa1, 0x3b, 0x17, 0xe1, 0xc8, 0x16, 0x44, 0x27, 0xb1, 0xf6, 0x61, 0x7a, 0xb6, - 0x9f, 0x01, 0x1c, 0x65, 0x6e, 0x26, 0xb7, 0xc3, 0xd8, 0x3b, 0x43, 0x33, 0x25, 0xc3, 0x0b, 0x19, - 0x78, 0x6e, 0x68, 0x6a, 0x5a, 0x99, 0x83, 0x81, 0x0e, 0x7c, 0xac, 0x55, 0xbf, 0x94, 0x71, 0xe4, - 0x64, 0x18, 0xf3, 0xda, 0x31, 0x9b, 0x88, 0x1c, 0x23, 0x60, 0xff, 0x14, 0x9a, 0xb4, 0x1a, 0x19, - 0x61, 0x03, 0x6a, 0x03, 0x5c, 0xd5, 0x18, 0x20, 0x0f, 0xe5, 0xe9, 0x0b, 0xb9, 0xe6, 0xb0, 0xff, - 0xce, 0x82, 0xe5, 0x7c, 0x66, 0x9e, 0x5c, 0xdf, 0x3a, 0x26, 0xde, 0x87, 0x06, 0x7a, 0x88, 0x23, - 0x22, 0x4f, 0xb7, 0x24, 0x75, 0x1c, 0xef, 0x45, 0x5e, 0x4e, 0x8a, 0xd3, 0x80, 0x42, 0x42, 0x93, - 0x5e, 0xa6, 0xc1, 0xac, 0x3f, 0x55, 0x67, 0xfd, 0x09, 0x55, 0x11, 0x44, 0x61, 0x10, 0x09, 0x07, - 0x8d, 0x4f, 0xb1, 0xd0, 0xe6, 0xa0, 0xa0, 0x5d, 0x37, 0x73, 0xed, 0x3f, 0x2e, 0x41, 0x4d, 0xd9, - 0x1c, 0x9d, 0xd7, 0x1f, 0x68, 0xb5, 0x96, 0xfc, 0x01, 0xbb, 0x0e, 0xd5, 0xa2, 0x82, 0xd4, 0x60, - 0x26, 0x78, 0xca, 0x57, 0x05, 0x4f, 0xe5, 0xea, 0xe0, 0xa9, 0xbe, 0x16, 0x3c, 0xff, 0x1f, 0x7a, - 0x59, 0x70, 0x12, 0xba, 0x72, 0xe8, 0xa4, 0x22, 0x09, 0x03, 0xcf, 0x95, 0x24, 0x70, 0x87, 0x77, - 0x35, 0xce, 0x35, 0x8c, 0xa2, 0x49, 0xd4, 0x33, 0x85, 0x6f, 0x9b, 0xab, 0x01, 0xfb, 0x29, 0xb4, - 0xe8, 0x41, 0x97, 0xbf, 0x06, 0xd9, 0xeb, 0xe6, 0x8c, 0xbd, 0x72, 0xc3, 0x70, 0x20, 0x56, 0x7a, - 0xb6, 0x9f, 0x43, 0xf5, 0x60, 0xf7, 0xb9, 0x9b, 0xa0, 0x8c, 0xe3, 0x44, 0x66, 0xa9, 0x70, 0x47, - 0x05, 0xcf, 0x31, 0xd0, 0x81, 0x8f, 0x09, 0xc8, 0x8f, 0x5f, 0x45, 0x53, 0x96, 0x12, 0xb1, 0xb4, - 0xa7, 0xe0, 0x81, 0x6f, 0xbf, 0x82, 0x36, 0x16, 0x04, 0x72, 0x26, 0x5c, 0x75, 0x91, 0x0f, 0x7c, - 0x08, 0xb5, 0xc0, 0xc7, 0x5a, 0xa2, 0x5b, 0xc0, 0x8e, 0x11, 0x93, 0x04, 0xe1, 0xd5, 0xc0, 0xc7, - 0x99, 0x1f, 0x03, 0x24, 0x6e, 0x9a, 0x05, 0x54, 0xa2, 0x74, 0xa8, 0xce, 0x71, 0x16, 0x18, 0x6c, - 0x09, 0xcd, 0xbc, 0x12, 0xfd, 0x2f, 0xde, 0xfa, 0x43, 0xa8, 0x91, 0xad, 0xcd, 0x1b, 0xaf, 0x17, - 0xcb, 0x9c, 0xd9, 0x15, 0xd7, 0x3c, 0xf6, 0x21, 0x34, 0x4c, 0x1e, 0xf8, 0x2d, 0x8b, 0x8c, 0xca, - 0x9a, 0x65, 0x93, 0x35, 0xed, 0x5d, 0x58, 0xde, 0xd1, 0x0d, 0xe8, 0x2e, 0x75, 0xba, 0xd8, 0x3d, - 0x7a, 0xe3, 0x34, 0x15, 0x51, 0xa6, 0x3b, 0x54, 0x33, 0x44, 0x4a, 0xaa, 0xce, 0x02, 0xb4, 0x68, - 0x85, 0x9b, 0xa1, 0xfd, 0xcf, 0x16, 0x54, 0xd5, 0xec, 0x1e, 0x94, 0x47, 0xf2, 0x54, 0x2b, 0x02, - 0x1f, 0xd9, 0x36, 0xf4, 0xa6, 0x4d, 0xaf, 0x53, 0xec, 0xb1, 0x73, 0x77, 0x99, 0x95, 0x60, 0x7f, - 0x29, 0x6f, 0x78, 0x0f, 0x7c, 0xb5, 0xea, 0x26, 0x34, 0xce, 0x26, 0x7a, 0x6e, 0x85, 0xe6, 0xae, - 0xe4, 0x7d, 0xcc, 0x53, 0x71, 0x61, 0xa6, 0xd5, 0xcf, 0x26, 0x8a, 0xff, 0x11, 0xb4, 0x55, 0x5b, - 0xaf, 0xe7, 0x54, 0x17, 0xf5, 0xf4, 0xfb, 0x4b, 0xbc, 0xa5, 0xb8, 0x68, 0xb8, 0xdd, 0x80, 0x9a, - 0x2f, 0x32, 0x37, 0x08, 0xed, 0x10, 0x60, 0x47, 0x45, 0x75, 0x74, 0x12, 0xb3, 0x2f, 0xa0, 0xa5, - 0x83, 0x3e, 0xbb, 0x48, 0x84, 0x3e, 0x82, 0xdc, 0xd9, 0x9c, 0x39, 0x9b, 0xed, 0xe5, 0x83, 0xe7, - 0x22, 0x1b, 0xc6, 0x3e, 0x07, 0x35, 0x05, 0x8f, 0x21, 0xd4, 0xf6, 0xab, 0x05, 0xa6, 0xf6, 0xd0, - 0x79, 0xe4, 0xa9, 0xb8, 0xb0, 0xbf, 0xab, 0x41, 0x67, 0xf6, 0x6c, 0xf6, 0x86, 0x73, 0xc2, 0x8c, - 0xe5, 0x4b, 0x97, 0x5b, 0xbe, 0x7c, 0x75, 0x3d, 0xaf, 0xbc, 0xb9, 0x9e, 0x57, 0x5f, 0xab, 0xe7, - 0xb7, 0xb1, 0x46, 0x65, 0xc2, 0x09, 0x83, 0x51, 0x90, 0xe9, 0x8a, 0xde, 0x44, 0xe4, 0x19, 0x02, - 0x6c, 0x0d, 0x5a, 0x5e, 0x1c, 0x29, 0x87, 0xf1, 0x2e, 0xa8, 0xa8, 0x77, 0x78, 0x11, 0x62, 0x5f, - 0x40, 0x57, 0x66, 0x71, 0xea, 0x9e, 0x0a, 0x07, 0xad, 0x2f, 0x22, 0x9f, 0x6a, 0xfb, 0x4c, 0xf2, - 0x20, 0xf2, 0xb6, 0xa2, 0xf2, 0x65, 0x39, 0x33, 0x9e, 0xed, 0xe4, 0x61, 0xb6, 0x93, 0x57, 0xde, - 0xdd, 0xca, 0x7b, 0x02, 0xf4, 0xbd, 0x78, 0x94, 0xa4, 0x42, 0xa2, 0xf0, 0xca, 0x7e, 0x6d, 0xb2, - 0x5f, 0xde, 0xd4, 0xee, 0x4c, 0xe9, 0x74, 0x66, 0xec, 0x7a, 0xb3, 0x00, 0xfb, 0x08, 0x56, 0x8a, - 0x6b, 0x84, 0x62, 0x22, 0x42, 0x3a, 0x16, 0x55, 0x79, 0x71, 0xf1, 0x67, 0x88, 0xb3, 0x47, 0xb9, - 0xaf, 0x50, 0xdd, 0x54, 0x47, 0x93, 0xbc, 0x8c, 0x4d, 0x9d, 0xca, 0xf8, 0x07, 0x39, 0xd8, 0xe7, - 0xd0, 0xf5, 0x65, 0xe6, 0x14, 0x9b, 0xf5, 0xee, 0xe5, 0xcd, 0x7a, 0xc7, 0x97, 0xd9, 0xd6, 0xb4, - 0x5f, 0xff, 0x04, 0x40, 0x8e, 0x07, 0xa6, 0x01, 0xe8, 0xe9, 0x5e, 0xb9, 0x10, 0x1c, 0xba, 0x6b, - 0x90, 0xe3, 0x81, 0xae, 0xfd, 0x1f, 0x60, 0x70, 0x50, 0x72, 0x77, 0x52, 0xe1, 0xfa, 0x74, 0x76, - 0x68, 0x60, 0x28, 0x10, 0xc6, 0x85, 0xeb, 0xe7, 0x1d, 0x35, 0x7b, 0x43, 0x47, 0x7d, 0x0b, 0x9a, - 0xe3, 0x28, 0xf8, 0xd5, 0x58, 0xa0, 0x9f, 0x5e, 0x23, 0xb5, 0x37, 0x14, 0x70, 0xe0, 0x63, 0x0b, - 0xef, 0xc5, 0x51, 0x26, 0xce, 0x33, 0x3a, 0x05, 0x60, 0x2f, 0x63, 0xc4, 0xda, 0x51, 0x38, 0x37, - 0x0c, 0x5f, 0x55, 0x1a, 0xb5, 0x5e, 0x5d, 0x37, 0xd3, 0x7f, 0x51, 0x82, 0xeb, 0x47, 0x94, 0xdf, - 0xd5, 0xfb, 0x8e, 0x5d, 0x79, 0x46, 0x7a, 0xfa, 0x04, 0xea, 0xda, 0x17, 0x28, 0x26, 0x2e, 0x77, - 0x19, 0xc3, 0x46, 0xa5, 0x9c, 0x7c, 0x3e, 0x93, 0x26, 0x65, 0xd1, 0xf8, 0x58, 0xb2, 0x1b, 0x80, - 0x81, 0x81, 0x04, 0x55, 0x59, 0xab, 0x22, 0xf2, 0x8f, 0x65, 0x9e, 0xc9, 0x2b, 0x85, 0x4c, 0xfe, - 0x01, 0xb4, 0x29, 0xff, 0x62, 0xbf, 0x97, 0x89, 0x94, 0x9a, 0xa6, 0x26, 0x6f, 0x11, 0xf6, 0x84, - 0xa0, 0x85, 0x8e, 0x56, 0x7b, 0x37, 0x47, 0xe3, 0xcb, 0x74, 0xb3, 0x30, 0x4e, 0x7c, 0x8c, 0xaf, - 0x4c, 0x9a, 0x93, 0x08, 0xaf, 0x61, 0xf5, 0x1c, 0x4b, 0xfb, 0x37, 0x25, 0xec, 0x78, 0x66, 0x62, - 0xc1, 0x86, 0x4a, 0x14, 0xc7, 0x89, 0x56, 0x47, 0xde, 0x82, 0xbe, 0x88, 0xe3, 0x64, 0x7f, 0x89, - 0x13, 0x8d, 0xdd, 0x87, 0x6a, 0x18, 0x7b, 0x6e, 0x38, 0x5f, 0x86, 0x9e, 0x21, 0xb8, 0xbf, 0xc4, - 0x15, 0x95, 0xfd, 0x00, 0x4a, 0xf2, 0x91, 0x4e, 0xcc, 0x90, 0xeb, 0xf5, 0xd1, 0xfe, 0x12, 0x2f, - 0xc9, 0x47, 0xec, 0x2e, 0x94, 0x4f, 0x3d, 0xa9, 0x73, 0x6f, 0xcb, 0x90, 0xbf, 0xdc, 0x39, 0xda, - 0x5f, 0xe2, 0x48, 0x61, 0x9f, 0x43, 0xc7, 0x0b, 0xe3, 0xb1, 0xef, 0xf8, 0x17, 0x91, 0x3b, 0x0a, - 0x3c, 0x9d, 0x72, 0xaf, 0x4f, 0x53, 0x7c, 0x3c, 0xf6, 0x77, 0x15, 0x6d, 0x7f, 0x89, 0xb7, 0xbd, - 0xc2, 0x18, 0xb7, 0x31, 0xf4, 0x4f, 0x54, 0x07, 0x52, 0xd8, 0xc6, 0xfe, 0xee, 0x13, 0x5c, 0x9f, - 0x68, 0x6c, 0x1f, 0x98, 0xfb, 0xed, 0x38, 0x15, 0xce, 0x20, 0x8c, 0x07, 0x8e, 0xf1, 0x83, 0x3a, - 0xcd, 0xe8, 0x9b, 0x19, 0x5b, 0xc8, 0xb1, 0x1d, 0xc6, 0x03, 0xad, 0xa7, 0xfd, 0x25, 0xde, 0x73, - 0xe7, 0xb0, 0xed, 0x26, 0xd4, 0x75, 0xe6, 0xb1, 0x6b, 0x50, 0x41, 0x5d, 0xd9, 0xb7, 0xa0, 0x4a, - 0xea, 0x40, 0xf3, 0xa3, 0x0f, 0x9a, 0x42, 0x4e, 0xfe, 0xf8, 0xe7, 0x15, 0x28, 0x1d, 0x3d, 0xc2, - 0x66, 0x4c, 0x44, 0x7e, 0x12, 0x07, 0xba, 0x30, 0x36, 0x79, 0x3e, 0xc6, 0x2e, 0xb3, 0x70, 0xc9, - 0xd4, 0xcc, 0x2f, 0x95, 0x6e, 0x42, 0x6d, 0x30, 0xf6, 0xce, 0x44, 0xa6, 0x2b, 0xae, 0x1e, 0x21, - 0x9e, 0xa4, 0xe2, 0x24, 0x38, 0xd7, 0x7e, 0xa6, 0x47, 0x2a, 0x47, 0xab, 0xe4, 0xe8, 0x85, 0xae, - 0x54, 0x9d, 0x5b, 0x13, 0x73, 0x34, 0x81, 0x3b, 0x88, 0x61, 0x89, 0x95, 0x52, 0xb9, 0x57, 0x93, - 0xe3, 0x23, 0x22, 0xae, 0x17, 0x92, 0x32, 0x9a, 0x1c, 0x1f, 0x31, 0x4d, 0xbb, 0x9e, 0x27, 0xa4, - 0xa4, 0x42, 0xd0, 0x50, 0x37, 0x44, 0x0a, 0xc1, 0x5a, 0xb0, 0x01, 0x2b, 0x52, 0x78, 0xa9, 0xc8, - 0x9c, 0x02, 0x57, 0x93, 0xb8, 0xba, 0x8a, 0xb0, 0x95, 0xf3, 0xae, 0x43, 0xef, 0x24, 0x4e, 0x3d, - 0xe1, 0xa0, 0x32, 0x1c, 0x99, 0x5d, 0x84, 0x42, 0xa7, 0xdd, 0x65, 0xc2, 0x0f, 0xdd, 0x6c, 0x78, - 0x84, 0x28, 0xbb, 0x07, 0xcb, 0x52, 0x0a, 0xe7, 0x6c, 0x44, 0xeb, 0x61, 0x4a, 0x50, 0x99, 0xb8, - 0x25, 0xa5, 0x78, 0x3a, 0xc2, 0xc5, 0x0e, 0x7c, 0x0c, 0xc9, 0x34, 0x0e, 0x85, 0xe3, 0xa6, 0xea, - 0x76, 0xaa, 0xc9, 0xeb, 0x38, 0xde, 0x4a, 0x55, 0xf1, 0x39, 0xcf, 0x44, 0x1a, 0xa9, 0xb3, 0x44, - 0x87, 0xa8, 0x60, 0xa0, 0x03, 0x9f, 0x6d, 0xc2, 0xb5, 0x78, 0xf0, 0x4b, 0xe1, 0x65, 0x0e, 0x9e, - 0x01, 0xf2, 0x3b, 0x86, 0x65, 0x92, 0x66, 0x45, 0x91, 0x9e, 0xc5, 0xde, 0x99, 0xb9, 0x60, 0x40, - 0x75, 0x9a, 0x88, 0x8c, 0xcf, 0x84, 0x4a, 0xab, 0xa8, 0x4e, 0x1d, 0x75, 0x88, 0xa1, 0x5d, 0x93, - 0x34, 0x9e, 0x04, 0xbe, 0x48, 0xe9, 0xee, 0xa5, 0xc9, 0xf3, 0x31, 0x76, 0x3c, 0x49, 0x1a, 0xe3, - 0x31, 0x4f, 0xdf, 0xb0, 0x98, 0xa1, 0xfd, 0x6b, 0x0b, 0xca, 0x5f, 0xee, 0x1c, 0xbd, 0xc9, 0x2b, - 0xb4, 0xf5, 0x4b, 0x97, 0x58, 0xbf, 0x7c, 0xb5, 0xf5, 0x2b, 0x0b, 0xac, 0x7f, 0x1f, 0x96, 0x93, - 0x54, 0xf8, 0xe2, 0x24, 0x88, 0x84, 0xef, 0xa0, 0xd9, 0x95, 0x8f, 0x74, 0xa6, 0xe8, 0x96, 0x17, - 0x62, 0x83, 0xef, 0x21, 0x10, 0x65, 0x81, 0x1b, 0x4a, 0x0a, 0x1a, 0xed, 0x31, 0xdd, 0x02, 0x8e, - 0x61, 0x61, 0x8f, 0xa0, 0x47, 0x71, 0xb3, 0x33, 0x96, 0x59, 0x3c, 0xa2, 0x9e, 0x04, 0xdf, 0x32, - 0xed, 0x6f, 0xf2, 0x0e, 0xb3, 0xc9, 0x3b, 0x53, 0x14, 0xd9, 0x1e, 0xc2, 0x8d, 0x59, 0x36, 0xa7, - 0x70, 0xd8, 0x6a, 0xf2, 0x6b, 0x33, 0xdc, 0x47, 0x44, 0xc2, 0x34, 0xd6, 0x9b, 0x8f, 0xd3, 0xdf, - 0xbd, 0x1a, 0x3f, 0x80, 0xb6, 0xeb, 0x79, 0xf1, 0x38, 0xca, 0x1c, 0xca, 0xf7, 0x4a, 0x89, 0x2d, - 0x8d, 0xbd, 0xc0, 0xb4, 0x7f, 0x1b, 0x40, 0x0e, 0xdd, 0x54, 0xa8, 0x66, 0x4a, 0x29, 0xaf, 0xa9, - 0x10, 0xdc, 0xfb, 0x34, 0xc4, 0x64, 0x70, 0x3a, 0x1b, 0x62, 0x47, 0xc1, 0x29, 0x1a, 0xa0, 0xa0, - 0x1a, 0xe9, 0xc5, 0x89, 0x30, 0x11, 0x36, 0xc5, 0x8f, 0x10, 0x66, 0x5f, 0xbc, 0xa6, 0x6c, 0x58, - 0x90, 0xd6, 0x0a, 0xe6, 0x99, 0x33, 0x83, 0xfd, 0x67, 0x16, 0xd4, 0xb6, 0x95, 0x52, 0xde, 0x2e, - 0x4b, 0x95, 0x2f, 0xc9, 0x52, 0x95, 0x4b, 0x14, 0x5c, 0xbd, 0x5a, 0xc1, 0xb5, 0xd7, 0x15, 0x8c, - 0x47, 0x82, 0x76, 0x31, 0xe9, 0xb3, 0x07, 0xf9, 0x5b, 0x2c, 0xdd, 0x8d, 0x9b, 0xae, 0x82, 0xd0, - 0xfc, 0xad, 0xf7, 0xa0, 0x63, 0xe2, 0x4f, 0x99, 0x46, 0x59, 0xbd, 0x6d, 0x40, 0xb2, 0xcd, 0x4f, - 0xa0, 0xea, 0x66, 0x59, 0x6a, 0x4e, 0x4d, 0x77, 0x17, 0x95, 0x99, 0xcd, 0x2d, 0xe4, 0xd8, 0x8b, - 0xb2, 0xf4, 0x82, 0x2b, 0xee, 0xd5, 0xc7, 0x00, 0x53, 0x10, 0xd3, 0xe6, 0xd4, 0xb3, 0xf1, 0x11, - 0xcf, 0xba, 0x13, 0x37, 0x1c, 0x9b, 0x77, 0xaa, 0xc1, 0xef, 0x97, 0x1e, 0x5b, 0xf6, 0x1d, 0xa8, - 0x60, 0x39, 0x52, 0x3a, 0x1c, 0xc5, 0x99, 0x39, 0xeb, 0xe9, 0x91, 0xfd, 0x0f, 0x16, 0x2c, 0xcf, - 0x7d, 0xb1, 0xb8, 0x67, 0xbe, 0x28, 0x58, 0xb3, 0x85, 0x77, 0xe6, 0x83, 0xc2, 0x6f, 0xd7, 0xcb, - 0xbf, 0xcd, 0x3d, 0xfe, 0xdc, 0xf5, 0x6f, 0xf5, 0xad, 0xae, 0x7f, 0xed, 0x8f, 0xf1, 0x3c, 0x28, - 0xdc, 0x68, 0x7a, 0x18, 0x99, 0xe9, 0xf1, 0xac, 0xd9, 0x1e, 0xcf, 0x3e, 0x84, 0x6e, 0xce, 0xfe, - 0x2e, 0xdb, 0xee, 0x43, 0x5d, 0x8e, 0x29, 0x56, 0x68, 0xd3, 0x0d, 0x6e, 0x86, 0xf6, 0x63, 0x58, - 0xd6, 0x5f, 0x75, 0x8c, 0x00, 0x0f, 0xa0, 0x2b, 0xdd, 0x89, 0x70, 0xb2, 0xd8, 0x29, 0xb6, 0x7f, - 0x0d, 0xde, 0x41, 0xf8, 0x38, 0xd6, 0x39, 0xc4, 0xfe, 0x5b, 0x0b, 0xba, 0xf9, 0xd4, 0x77, 0xb4, - 0xc1, 0x74, 0x87, 0xa5, 0xb9, 0x2e, 0xf6, 0x87, 0xc0, 0xbc, 0x38, 0x0c, 0xb1, 0xe8, 0xd0, 0x67, - 0x11, 0xca, 0x0f, 0xba, 0x67, 0xec, 0x69, 0x0a, 0xaa, 0x7d, 0x07, 0x71, 0x2c, 0xac, 0x33, 0xdc, - 0x74, 0x23, 0xa9, 0x0e, 0x5a, 0xdd, 0x02, 0xf3, 0x51, 0xf0, 0xad, 0xb0, 0xaf, 0xc1, 0xca, 0xce, - 0x50, 0x78, 0x67, 0x5b, 0xfe, 0x28, 0x88, 0xf4, 0x66, 0xed, 0xef, 0x2c, 0x60, 0x45, 0xf4, 0x5d, - 0xf6, 0xf1, 0xb6, 0x9f, 0xba, 0x36, 0x60, 0x65, 0xe8, 0x4a, 0x27, 0x11, 0x91, 0x1f, 0x44, 0xa7, - 0x8e, 0x8b, 0x6f, 0xa2, 0x1d, 0x35, 0x78, 0x77, 0xe8, 0xca, 0x43, 0x85, 0x93, 0x00, 0xf6, 0x3f, - 0x59, 0x70, 0x7b, 0x4f, 0x57, 0x60, 0xad, 0x68, 0x2e, 0xd0, 0x0c, 0xb9, 0x79, 0x16, 0x1c, 0xe8, - 0xac, 0x77, 0x3a, 0xd0, 0xdd, 0x85, 0x96, 0xae, 0xea, 0x85, 0x70, 0x07, 0x05, 0xbd, 0xd0, 0xfd, - 0x77, 0xaa, 0xde, 0xa9, 0x38, 0x54, 0xf6, 0x6a, 0x69, 0x8c, 0x58, 0xee, 0xc3, 0x32, 0x1d, 0x25, - 0xa2, 0xcc, 0x09, 0x45, 0x74, 0x9a, 0x0d, 0xb5, 0xd2, 0x3b, 0x1a, 0x7d, 0x46, 0xa0, 0xbd, 0x06, - 0x77, 0x2e, 0xdb, 0x8c, 0x52, 0xb4, 0xfd, 0x57, 0x16, 0xac, 0xce, 0xb1, 0x1c, 0xb9, 0x93, 0xdf, - 0xe1, 0x66, 0x5f, 0xdf, 0x49, 0x79, 0xd1, 0x4e, 0x6e, 0xc3, 0xad, 0x85, 0x62, 0xea, 0x6d, 0xfc, - 0xa9, 0xbe, 0xdb, 0xf6, 0xdd, 0xcc, 0x65, 0x1b, 0x26, 0x5b, 0x58, 0xb3, 0x57, 0x4c, 0xbb, 0xfa, - 0x8e, 0x9a, 0x0e, 0xa4, 0x3a, 0x6b, 0x7c, 0x06, 0x2d, 0x72, 0xdc, 0xd3, 0x34, 0x1e, 0x27, 0xe6, - 0x42, 0xf9, 0xc6, 0xfc, 0x8c, 0x2f, 0x91, 0xca, 0xe9, 0x3b, 0x21, 0x3d, 0x4a, 0x75, 0xd2, 0x42, - 0x0b, 0xe5, 0xf7, 0x74, 0x74, 0x08, 0xc3, 0x08, 0xba, 0x0b, 0x68, 0xaa, 0x38, 0x9c, 0x88, 0xc2, - 0x71, 0x0b, 0x0c, 0xa4, 0x8e, 0x62, 0x23, 0xf7, 0x1c, 0x69, 0xca, 0x68, 0xd5, 0x91, 0x7b, 0xae, - 0xe1, 0x20, 0x42, 0xb8, 0xaa, 0xe1, 0x20, 0x3a, 0x46, 0x09, 0xe9, 0x23, 0x79, 0x9e, 0xd8, 0xea, - 0x3a, 0xb1, 0x15, 0xbe, 0x97, 0x99, 0xc4, 0xd6, 0x1a, 0x4d, 0x07, 0xf6, 0xbf, 0x58, 0xd0, 0x99, - 0x91, 0x7f, 0x51, 0xb3, 0xcf, 0x7e, 0x06, 0xdd, 0xe9, 0xd5, 0xbe, 0x3a, 0xc4, 0x97, 0xae, 0xd0, - 0x5a, 0x27, 0xbf, 0xe7, 0xa7, 0x13, 0xea, 0x54, 0xe4, 0x72, 0x51, 0xe4, 0x4b, 0x36, 0xf8, 0x00, - 0xba, 0xc8, 0x5d, 0x54, 0x8e, 0xda, 0x69, 0x47, 0x85, 0xbe, 0xd1, 0xcf, 0x4d, 0xa8, 0x69, 0x57, - 0x50, 0xdf, 0x57, 0xf4, 0xc8, 0xfe, 0xd7, 0x0a, 0xb4, 0x8b, 0xd2, 0x14, 0x2e, 0xbb, 0xad, 0x99, - 0xcb, 0x6e, 0xb3, 0xd1, 0x52, 0x61, 0xa3, 0x1b, 0xb0, 0x12, 0x8d, 0x47, 0x03, 0x91, 0x3a, 0xf1, - 0x89, 0x23, 0xa2, 0x2c, 0x0d, 0x84, 0x92, 0xba, 0xcc, 0xbb, 0x8a, 0xf0, 0xf2, 0x64, 0x4f, 0xc1, - 0x85, 0x6d, 0x55, 0x16, 0x6f, 0xab, 0x5a, 0xdc, 0xd6, 0x9c, 0xbd, 0x6b, 0xaf, 0xd9, 0xfb, 0x16, - 0x34, 0xf5, 0xed, 0x5c, 0xe0, 0x93, 0xf9, 0xca, 0xbc, 0xa1, 0x80, 0xf9, 0xcb, 0xad, 0xc6, 0xe5, - 0x05, 0xb1, 0xb9, 0xe0, 0x5a, 0x73, 0xfa, 0x31, 0xe8, 0x43, 0xa8, 0xd0, 0x19, 0xbc, 0x45, 0xce, - 0xd1, 0x2b, 0xd6, 0x47, 0x3a, 0x6b, 0x13, 0x15, 0x97, 0x0b, 0xa4, 0x83, 0x4e, 0x42, 0x47, 0x91, - 0x06, 0xaf, 0x05, 0x92, 0x3e, 0xd4, 0xbf, 0x0f, 0x0d, 0x75, 0xe2, 0xd7, 0xc7, 0x90, 0x32, 0xaf, - 0xd3, 0xf8, 0xc0, 0x2f, 0x18, 0x63, 0xb9, 0x68, 0x0c, 0xf6, 0x7b, 0xb0, 0x8a, 0x3a, 0x1a, 0x88, - 0x53, 0xd2, 0x94, 0x13, 0x44, 0x8e, 0x2f, 0x4e, 0xdc, 0x71, 0x98, 0x39, 0xde, 0x09, 0x1d, 0x3c, - 0x2a, 0xfc, 0xc6, 0x28, 0x88, 0xb6, 0x91, 0xe1, 0x58, 0x1e, 0x44, 0xbb, 0x8a, 0xba, 0x73, 0x42, - 0xf9, 0x8d, 0x3e, 0x25, 0xc7, 0x27, 0x27, 0x52, 0x64, 0x74, 0x0a, 0xa9, 0xf0, 0x16, 0x61, 0x2f, - 0x09, 0x9a, 0xb2, 0xe8, 0x77, 0xaf, 0x14, 0x58, 0x54, 0x46, 0x58, 0x78, 0x05, 0xc1, 0xde, 0xf1, - 0x0a, 0xa2, 0x14, 0x4c, 0xec, 0x3f, 0xb1, 0x60, 0xa5, 0x78, 0xfd, 0xb2, 0x67, 0x6a, 0xe4, 0xd0, - 0x4d, 0x12, 0x11, 0x39, 0xae, 0xb9, 0x17, 0x6e, 0x28, 0x60, 0x8b, 0xee, 0x2b, 0xa9, 0x02, 0x39, - 0x5e, 0xec, 0x9b, 0x9c, 0xd6, 0x24, 0x64, 0x27, 0xf6, 0xb1, 0x78, 0xa9, 0x7f, 0xb9, 0x38, 0x23, - 0x21, 0x25, 0x96, 0x6f, 0x95, 0xc0, 0xdb, 0x04, 0x3e, 0x57, 0xd8, 0x4c, 0x02, 0x31, 0x5f, 0x5d, - 0x54, 0x02, 0xd9, 0x78, 0x01, 0x6b, 0x6f, 0xfa, 0x63, 0x0a, 0xeb, 0x42, 0xeb, 0xe7, 0x74, 0x73, - 0x42, 0xff, 0xbf, 0xe8, 0x2d, 0xb1, 0x0e, 0x34, 0x7f, 0xe1, 0x06, 0xd9, 0x56, 0x92, 0x84, 0x17, - 0x3d, 0x8b, 0x01, 0xd4, 0x9e, 0x04, 0x51, 0x20, 0x87, 0xbd, 0xd2, 0xc6, 0x57, 0x70, 0xe7, 0xea, - 0x3f, 0x8e, 0xb0, 0x15, 0xe8, 0xe4, 0x93, 0x77, 0xe3, 0x08, 0xd7, 0xbb, 0x01, 0x2b, 0x85, 0x17, - 0xa8, 0x4f, 0xec, 0x3d, 0x6b, 0xe3, 0x0f, 0xa0, 0x3b, 0xa7, 0x55, 0xd6, 0x82, 0xfa, 0xcf, 0x5f, - 0x3c, 0x7d, 0xf1, 0xf2, 0x17, 0x2f, 0x7a, 0x4b, 0xac, 0x0e, 0xe5, 0x67, 0xdf, 0x7c, 0xaa, 0x04, - 0x38, 0x7a, 0xb1, 0x75, 0x78, 0xf8, 0x47, 0xbd, 0x12, 0x6b, 0x40, 0xe5, 0x9b, 0xa3, 0xe3, 0xdd, - 0x5e, 0x79, 0x63, 0x2d, 0xff, 0x7f, 0x08, 0x2a, 0xaa, 0x01, 0x95, 0xa3, 0x9d, 0x2d, 0x9c, 0xd6, - 0x80, 0xca, 0x93, 0x83, 0x67, 0x7b, 0x3d, 0x6b, 0xe3, 0x36, 0xb4, 0x0a, 0x29, 0x8d, 0xd5, 0xa0, - 0xf4, 0xf5, 0x8f, 0x7b, 0x4b, 0xf4, 0xfb, 0xb0, 0x67, 0x6d, 0xdc, 0x85, 0x86, 0x71, 0x6a, 0x7c, - 0xc5, 0xae, 0x08, 0x45, 0x26, 0xd4, 0x7b, 0x0f, 0xc7, 0x59, 0xcf, 0x7a, 0xf8, 0xdf, 0x25, 0xa8, - 0xa9, 0x57, 0xb0, 0xcf, 0x41, 0xff, 0x09, 0x89, 0xdd, 0x98, 0xfb, 0x42, 0xa8, 0x14, 0xb9, 0x7a, - 0x73, 0x1e, 0xd6, 0xd5, 0x64, 0xe9, 0x13, 0x8b, 0x1d, 0xc2, 0x35, 0xea, 0x4b, 0x8a, 0xdd, 0xc1, - 0xcb, 0x84, 0xbd, 0x9f, 0xfb, 0xd6, 0x7c, 0x2b, 0xb3, 0xba, 0xba, 0x88, 0x54, 0x58, 0x71, 0x08, - 0x37, 0x16, 0x9a, 0x81, 0x7d, 0xf8, 0x36, 0x7f, 0x47, 0x5a, 0xbd, 0xff, 0x06, 0x2e, 0xf5, 0xa6, - 0x75, 0xeb, 0x13, 0x8b, 0xfd, 0x0c, 0x8f, 0xf1, 0xc4, 0xc4, 0x6e, 0xce, 0xcd, 0x32, 0xab, 0xbd, - 0xf7, 0x1a, 0x6e, 0x24, 0xc5, 0xd9, 0x9e, 0xea, 0x71, 0x59, 0xe1, 0x8b, 0x45, 0xb1, 0x47, 0x9e, - 0xce, 0x9e, 0x6b, 0x86, 0xed, 0xa5, 0x87, 0x7f, 0x6f, 0x41, 0x77, 0xae, 0x52, 0xb3, 0x6f, 0xa0, - 0xae, 0x9b, 0x17, 0x96, 0xef, 0xe2, 0xca, 0x26, 0x6b, 0xf5, 0xc1, 0x9b, 0xd8, 0x72, 0x69, 0xff, - 0x10, 0x2a, 0xd8, 0x16, 0x33, 0xfb, 0x92, 0x19, 0x85, 0x6e, 0x66, 0xf5, 0xde, 0x95, 0x3c, 0x66, - 0xc9, 0xed, 0x07, 0xff, 0xfe, 0xd7, 0x0d, 0xeb, 0xd7, 0xdf, 0xdf, 0xb1, 0x7e, 0xf3, 0xfd, 0x1d, - 0xeb, 0x3f, 0xbe, 0xbf, 0x63, 0xfd, 0xe5, 0x7f, 0xde, 0x59, 0x82, 0x5e, 0x9c, 0x9e, 0x6e, 0x66, - 0xc1, 0xd9, 0x64, 0xf3, 0x6c, 0x42, 0xff, 0x39, 0x1b, 0xd4, 0xe8, 0xe7, 0xd1, 0xff, 0x04, 0x00, - 0x00, 0xff, 0xff, 0x1c, 0x1b, 0xef, 0xfe, 0xf7, 0x26, 0x00, 0x00, +func (m *Span) Reset() { *m = Span{} } +func (m *Span) String() string { return proto.CompactTextString(m) } +func (*Span) ProtoMessage() {} +func (*Span) Descriptor() ([]byte, []int) { + return fileDescriptor_483d1f48d58a4885, []int{45} +} +func (m *Span) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Span) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Span.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 *Span) XXX_Merge(src proto.Message) { + xxx_messageInfo_Span.Merge(m, src) +} +func (m *Span) XXX_Size() int { + return m.Size() +} +func (m *Span) XXX_DiscardUnknown() { + xxx_messageInfo_Span.DiscardUnknown(m) } -// 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 +var xxx_messageInfo_Span proto.InternalMessageInfo -// BackupClient is the client API for Backup service. -// -// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. -type BackupClient interface { - Backup(ctx context.Context, in *BackupRequest, opts ...grpc.CallOption) (Backup_BackupClient, error) - // CheckPendingAdminOp used for snapshot backup. before we start snapshot for a TiKV. - // we need stop all schedule first and make sure all in-flight schedule has finished. - // this rpc check all pending conf change for leader. - CheckPendingAdminOp(ctx context.Context, in *CheckAdminRequest, opts ...grpc.CallOption) (Backup_CheckPendingAdminOpClient, error) - // PrepareSnapshotBackup is an advanced version of preparing snapshot backup. - // Check the defination of `PrepareSnapshotBackupRequest` for more. - PrepareSnapshotBackup(ctx context.Context, opts ...grpc.CallOption) (Backup_PrepareSnapshotBackupClient, error) - // prepare is used for file-copy backup. before we start the backup for a TiKV. - // we need invoke this function to generate the SST files map. or we get nothing to backup. - Prepare(ctx context.Context, in *PrepareRequest, opts ...grpc.CallOption) (*PrepareResponse, error) - // cleanup used for file-copy backup. after we finish the backup for a TiKV. - // we need clean some internel state. e.g. checkpoint, SST File maps - Cleanup(ctx context.Context, in *CleanupRequest, opts ...grpc.CallOption) (*CleanupResponse, error) +func (m *Span) GetOffset() uint64 { + if m != nil { + return m.Offset + } + return 0 } -type backupClient struct { - cc *grpc.ClientConn +func (m *Span) GetLength() uint64 { + if m != nil { + return m.Length + } + return 0 } -func NewBackupClient(cc *grpc.ClientConn) BackupClient { - return &backupClient{cc} +type SpansOfFile struct { + Path string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"` + Spans []*Span `protobuf:"bytes,2,rep,name=spans,proto3" json:"spans,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } -func (c *backupClient) Backup(ctx context.Context, in *BackupRequest, opts ...grpc.CallOption) (Backup_BackupClient, error) { - stream, err := c.cc.NewStream(ctx, &_Backup_serviceDesc.Streams[0], "/backup.Backup/backup", opts...) - if err != nil { - return nil, err - } - x := &backupBackupClient{stream} - if err := x.ClientStream.SendMsg(in); err != nil { - return nil, err - } - if err := x.ClientStream.CloseSend(); err != nil { - return nil, err +func (m *SpansOfFile) Reset() { *m = SpansOfFile{} } +func (m *SpansOfFile) String() string { return proto.CompactTextString(m) } +func (*SpansOfFile) ProtoMessage() {} +func (*SpansOfFile) Descriptor() ([]byte, []int) { + return fileDescriptor_483d1f48d58a4885, []int{46} +} +func (m *SpansOfFile) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SpansOfFile) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_SpansOfFile.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 x, nil } - -type Backup_BackupClient interface { - Recv() (*BackupResponse, error) - grpc.ClientStream +func (m *SpansOfFile) XXX_Merge(src proto.Message) { + xxx_messageInfo_SpansOfFile.Merge(m, src) } - -type backupBackupClient struct { - grpc.ClientStream +func (m *SpansOfFile) XXX_Size() int { + return m.Size() +} +func (m *SpansOfFile) XXX_DiscardUnknown() { + xxx_messageInfo_SpansOfFile.DiscardUnknown(m) } -func (x *backupBackupClient) Recv() (*BackupResponse, error) { - m := new(BackupResponse) - if err := x.ClientStream.RecvMsg(m); err != nil { - return nil, err +var xxx_messageInfo_SpansOfFile proto.InternalMessageInfo + +func (m *SpansOfFile) GetPath() string { + if m != nil { + return m.Path } - return m, nil + return "" } -func (c *backupClient) CheckPendingAdminOp(ctx context.Context, in *CheckAdminRequest, opts ...grpc.CallOption) (Backup_CheckPendingAdminOpClient, error) { - stream, err := c.cc.NewStream(ctx, &_Backup_serviceDesc.Streams[1], "/backup.Backup/CheckPendingAdminOp", opts...) - if err != nil { - return nil, err - } - x := &backupCheckPendingAdminOpClient{stream} - if err := x.ClientStream.SendMsg(in); err != nil { - return nil, err - } - if err := x.ClientStream.CloseSend(); err != nil { - return nil, err +func (m *SpansOfFile) GetSpans() []*Span { + if m != nil { + return m.Spans } - return x, nil + return nil } -type Backup_CheckPendingAdminOpClient interface { - Recv() (*CheckAdminResponse, error) - grpc.ClientStream +type LogFileSubcompactionMeta struct { + // The whole size of this subcompaction. + // It should be the physical size of all input logs. + Size_ uint64 `protobuf:"varint,1,opt,name=size,proto3" json:"size,omitempty"` + // The region that we perform the subcompaction. + RegionId uint64 `protobuf:"varint,2,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty"` + Cf string `protobuf:"bytes,3,opt,name=cf,proto3" json:"cf,omitempty"` + InputMaxTs uint64 `protobuf:"varint,4,opt,name=input_max_ts,json=inputMaxTs,proto3" json:"input_max_ts,omitempty"` + InputMinTs uint64 `protobuf:"varint,5,opt,name=input_min_ts,json=inputMinTs,proto3" json:"input_min_ts,omitempty"` + // The whole compaction's configure. + CompactFromTs uint64 `protobuf:"varint,6,opt,name=compact_from_ts,json=compactFromTs,proto3" json:"compact_from_ts,omitempty"` + CompactUntilTs uint64 `protobuf:"varint,7,opt,name=compact_until_ts,json=compactUntilTs,proto3" json:"compact_until_ts,omitempty"` + // The key range of the input logs. + // They are encoded user key. (i.e. mem-comparable, no 'z' prefix) + MinKey []byte `protobuf:"bytes,8,opt,name=min_key,json=minKey,proto3" json:"min_key,omitempty"` + // The largest key from the input. + MaxKey []byte `protobuf:"bytes,9,opt,name=max_key,json=maxKey,proto3" json:"max_key,omitempty"` + // The type of operations in the file. (Write or Delete) + Ty FileType `protobuf:"varint,10,opt,name=ty,proto3,enum=backup.FileType" json:"ty,omitempty"` + TableId int64 `protobuf:"varint,11,opt,name=table_id,json=tableId,proto3" json:"table_id,omitempty"` + // The input log files of this. + Sources []*SpansOfFile `protobuf:"bytes,12,rep,name=sources,proto3" json:"sources,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } -type backupCheckPendingAdminOpClient struct { - grpc.ClientStream +func (m *LogFileSubcompactionMeta) Reset() { *m = LogFileSubcompactionMeta{} } +func (m *LogFileSubcompactionMeta) String() string { return proto.CompactTextString(m) } +func (*LogFileSubcompactionMeta) ProtoMessage() {} +func (*LogFileSubcompactionMeta) Descriptor() ([]byte, []int) { + return fileDescriptor_483d1f48d58a4885, []int{47} } - -func (x *backupCheckPendingAdminOpClient) Recv() (*CheckAdminResponse, error) { - m := new(CheckAdminResponse) - if err := x.ClientStream.RecvMsg(m); err != nil { - return nil, err - } - return m, nil +func (m *LogFileSubcompactionMeta) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) } - -func (c *backupClient) PrepareSnapshotBackup(ctx context.Context, opts ...grpc.CallOption) (Backup_PrepareSnapshotBackupClient, error) { - stream, err := c.cc.NewStream(ctx, &_Backup_serviceDesc.Streams[2], "/backup.Backup/PrepareSnapshotBackup", opts...) - if err != nil { - return nil, err +func (m *LogFileSubcompactionMeta) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_LogFileSubcompactionMeta.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 := &backupPrepareSnapshotBackupClient{stream} - return x, nil } - -type Backup_PrepareSnapshotBackupClient interface { - Send(*PrepareSnapshotBackupRequest) error - Recv() (*PrepareSnapshotBackupResponse, error) - grpc.ClientStream +func (m *LogFileSubcompactionMeta) XXX_Merge(src proto.Message) { + xxx_messageInfo_LogFileSubcompactionMeta.Merge(m, src) } - -type backupPrepareSnapshotBackupClient struct { - grpc.ClientStream +func (m *LogFileSubcompactionMeta) XXX_Size() int { + return m.Size() } - -func (x *backupPrepareSnapshotBackupClient) Send(m *PrepareSnapshotBackupRequest) error { - return x.ClientStream.SendMsg(m) +func (m *LogFileSubcompactionMeta) XXX_DiscardUnknown() { + xxx_messageInfo_LogFileSubcompactionMeta.DiscardUnknown(m) } -func (x *backupPrepareSnapshotBackupClient) Recv() (*PrepareSnapshotBackupResponse, error) { - m := new(PrepareSnapshotBackupResponse) - if err := x.ClientStream.RecvMsg(m); err != nil { - return nil, err +var xxx_messageInfo_LogFileSubcompactionMeta proto.InternalMessageInfo + +func (m *LogFileSubcompactionMeta) GetSize_() uint64 { + if m != nil { + return m.Size_ } - return m, nil + return 0 } -func (c *backupClient) Prepare(ctx context.Context, in *PrepareRequest, opts ...grpc.CallOption) (*PrepareResponse, error) { - out := new(PrepareResponse) - err := c.cc.Invoke(ctx, "/backup.Backup/prepare", in, out, opts...) - if err != nil { - return nil, err +func (m *LogFileSubcompactionMeta) GetRegionId() uint64 { + if m != nil { + return m.RegionId } - return out, nil + return 0 } -func (c *backupClient) Cleanup(ctx context.Context, in *CleanupRequest, opts ...grpc.CallOption) (*CleanupResponse, error) { - out := new(CleanupResponse) - err := c.cc.Invoke(ctx, "/backup.Backup/cleanup", in, out, opts...) - if err != nil { - return nil, err +func (m *LogFileSubcompactionMeta) GetCf() string { + if m != nil { + return m.Cf } - return out, nil + return "" } -// BackupServer is the server API for Backup service. -type BackupServer interface { - Backup(*BackupRequest, Backup_BackupServer) error - // CheckPendingAdminOp used for snapshot backup. before we start snapshot for a TiKV. - // we need stop all schedule first and make sure all in-flight schedule has finished. - // this rpc check all pending conf change for leader. - CheckPendingAdminOp(*CheckAdminRequest, Backup_CheckPendingAdminOpServer) error - // PrepareSnapshotBackup is an advanced version of preparing snapshot backup. - // Check the defination of `PrepareSnapshotBackupRequest` for more. - PrepareSnapshotBackup(Backup_PrepareSnapshotBackupServer) error - // prepare is used for file-copy backup. before we start the backup for a TiKV. - // we need invoke this function to generate the SST files map. or we get nothing to backup. - Prepare(context.Context, *PrepareRequest) (*PrepareResponse, error) - // cleanup used for file-copy backup. after we finish the backup for a TiKV. - // we need clean some internel state. e.g. checkpoint, SST File maps - Cleanup(context.Context, *CleanupRequest) (*CleanupResponse, error) +func (m *LogFileSubcompactionMeta) GetInputMaxTs() uint64 { + if m != nil { + return m.InputMaxTs + } + return 0 } -// UnimplementedBackupServer can be embedded to have forward compatible implementations. -type UnimplementedBackupServer struct { +func (m *LogFileSubcompactionMeta) GetInputMinTs() uint64 { + if m != nil { + return m.InputMinTs + } + return 0 } -func (*UnimplementedBackupServer) Backup(req *BackupRequest, srv Backup_BackupServer) error { - return status.Errorf(codes.Unimplemented, "method Backup not implemented") +func (m *LogFileSubcompactionMeta) GetCompactFromTs() uint64 { + if m != nil { + return m.CompactFromTs + } + return 0 } -func (*UnimplementedBackupServer) CheckPendingAdminOp(req *CheckAdminRequest, srv Backup_CheckPendingAdminOpServer) error { - return status.Errorf(codes.Unimplemented, "method CheckPendingAdminOp not implemented") + +func (m *LogFileSubcompactionMeta) GetCompactUntilTs() uint64 { + if m != nil { + return m.CompactUntilTs + } + return 0 } -func (*UnimplementedBackupServer) PrepareSnapshotBackup(srv Backup_PrepareSnapshotBackupServer) error { - return status.Errorf(codes.Unimplemented, "method PrepareSnapshotBackup not implemented") + +func (m *LogFileSubcompactionMeta) GetMinKey() []byte { + if m != nil { + return m.MinKey + } + return nil } -func (*UnimplementedBackupServer) Prepare(ctx context.Context, req *PrepareRequest) (*PrepareResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method Prepare not implemented") + +func (m *LogFileSubcompactionMeta) GetMaxKey() []byte { + if m != nil { + return m.MaxKey + } + return nil } -func (*UnimplementedBackupServer) Cleanup(ctx context.Context, req *CleanupRequest) (*CleanupResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method Cleanup not implemented") + +func (m *LogFileSubcompactionMeta) GetTy() FileType { + if m != nil { + return m.Ty + } + return FileType_Delete } -func RegisterBackupServer(s *grpc.Server, srv BackupServer) { - s.RegisterService(&_Backup_serviceDesc, srv) +func (m *LogFileSubcompactionMeta) GetTableId() int64 { + if m != nil { + return m.TableId + } + return 0 } -func _Backup_Backup_Handler(srv interface{}, stream grpc.ServerStream) error { - m := new(BackupRequest) - if err := stream.RecvMsg(m); err != nil { - return err +func (m *LogFileSubcompactionMeta) GetSources() []*SpansOfFile { + if m != nil { + return m.Sources } - return srv.(BackupServer).Backup(m, &backupBackupServer{stream}) + return nil } -type Backup_BackupServer interface { - Send(*BackupResponse) error - grpc.ServerStream +// A subcompaction from a compaction. +// Subcompactions are actions that collect then sort key values from one region. +type LogFileSubcompaction struct { + // The metadata of the subcompaction. + Meta *LogFileSubcompactionMeta `protobuf:"bytes,1,opt,name=meta,proto3" json:"meta,omitempty"` + // The generated SSTs. + SstOutputs []*File `protobuf:"bytes,2,rep,name=sst_outputs,json=sstOutputs,proto3" json:"sst_outputs,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } -type backupBackupServer struct { - grpc.ServerStream +func (m *LogFileSubcompaction) Reset() { *m = LogFileSubcompaction{} } +func (m *LogFileSubcompaction) String() string { return proto.CompactTextString(m) } +func (*LogFileSubcompaction) ProtoMessage() {} +func (*LogFileSubcompaction) Descriptor() ([]byte, []int) { + return fileDescriptor_483d1f48d58a4885, []int{48} +} +func (m *LogFileSubcompaction) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *LogFileSubcompaction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_LogFileSubcompaction.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 *LogFileSubcompaction) XXX_Merge(src proto.Message) { + xxx_messageInfo_LogFileSubcompaction.Merge(m, src) +} +func (m *LogFileSubcompaction) XXX_Size() int { + return m.Size() +} +func (m *LogFileSubcompaction) XXX_DiscardUnknown() { + xxx_messageInfo_LogFileSubcompaction.DiscardUnknown(m) } -func (x *backupBackupServer) Send(m *BackupResponse) error { - return x.ServerStream.SendMsg(m) +var xxx_messageInfo_LogFileSubcompaction proto.InternalMessageInfo + +func (m *LogFileSubcompaction) GetMeta() *LogFileSubcompactionMeta { + if m != nil { + return m.Meta + } + return nil } -func _Backup_CheckPendingAdminOp_Handler(srv interface{}, stream grpc.ServerStream) error { - m := new(CheckAdminRequest) - if err := stream.RecvMsg(m); err != nil { - return err +func (m *LogFileSubcompaction) GetSstOutputs() []*File { + if m != nil { + return m.SstOutputs } - return srv.(BackupServer).CheckPendingAdminOp(m, &backupCheckPendingAdminOpServer{stream}) + return nil } -type Backup_CheckPendingAdminOpServer interface { - Send(*CheckAdminResponse) error - grpc.ServerStream +// Batched version of `LogFileSubcompaction`. +// So we can store many subcompactions to one file, to reduce the number of file. +type LogFileSubcompactions struct { + Subcompactions []*LogFileSubcompaction `protobuf:"bytes,1,rep,name=subcompactions,proto3" json:"subcompactions,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } -type backupCheckPendingAdminOpServer struct { - grpc.ServerStream +func (m *LogFileSubcompactions) Reset() { *m = LogFileSubcompactions{} } +func (m *LogFileSubcompactions) String() string { return proto.CompactTextString(m) } +func (*LogFileSubcompactions) ProtoMessage() {} +func (*LogFileSubcompactions) Descriptor() ([]byte, []int) { + return fileDescriptor_483d1f48d58a4885, []int{49} +} +func (m *LogFileSubcompactions) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *LogFileSubcompactions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_LogFileSubcompactions.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 *LogFileSubcompactions) XXX_Merge(src proto.Message) { + xxx_messageInfo_LogFileSubcompactions.Merge(m, src) +} +func (m *LogFileSubcompactions) XXX_Size() int { + return m.Size() +} +func (m *LogFileSubcompactions) XXX_DiscardUnknown() { + xxx_messageInfo_LogFileSubcompactions.DiscardUnknown(m) } -func (x *backupCheckPendingAdminOpServer) Send(m *CheckAdminResponse) error { - return x.ServerStream.SendMsg(m) +var xxx_messageInfo_LogFileSubcompactions proto.InternalMessageInfo + +func (m *LogFileSubcompactions) GetSubcompactions() []*LogFileSubcompaction { + if m != nil { + return m.Subcompactions + } + return nil } -func _Backup_PrepareSnapshotBackup_Handler(srv interface{}, stream grpc.ServerStream) error { - return srv.(BackupServer).PrepareSnapshotBackup(&backupPrepareSnapshotBackupServer{stream}) +type LogFileCompaction struct { + CompactionFromTs uint64 `protobuf:"varint,1,opt,name=compaction_from_ts,json=compactionFromTs,proto3" json:"compaction_from_ts,omitempty"` + CompactionUntilTs uint64 `protobuf:"varint,2,opt,name=compaction_until_ts,json=compactionUntilTs,proto3" json:"compaction_until_ts,omitempty"` + // The user provided name for the compaction. + Name string `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"` + // The statistics or other useful information for human. + Comments string `protobuf:"bytes,4,opt,name=comments,proto3" json:"comments,omitempty"` + // relative path to the generated subcompaction metas. ("artificates") + Artifacts string `protobuf:"bytes,5,opt,name=artifacts,proto3" json:"artifacts,omitempty"` + // the XOR of all artificate's hash. + ArtifactsHash uint64 `protobuf:"varint,6,opt,name=artifacts_hash,json=artifactsHash,proto3" json:"artifacts_hash,omitempty"` + // relative path to the subcompaction generated SST files. + // this is a hint for garbage-collecting, so we don't need to read the metas one by one. + // Those SSTs cannot be directly used, what you need is probably in `artificates`. + GeneratedFiles string `protobuf:"bytes,7,opt,name=generated_files,json=generatedFiles,proto3" json:"generated_files,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } -type Backup_PrepareSnapshotBackupServer interface { - Send(*PrepareSnapshotBackupResponse) error - Recv() (*PrepareSnapshotBackupRequest, error) - grpc.ServerStream +func (m *LogFileCompaction) Reset() { *m = LogFileCompaction{} } +func (m *LogFileCompaction) String() string { return proto.CompactTextString(m) } +func (*LogFileCompaction) ProtoMessage() {} +func (*LogFileCompaction) Descriptor() ([]byte, []int) { + return fileDescriptor_483d1f48d58a4885, []int{50} +} +func (m *LogFileCompaction) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *LogFileCompaction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_LogFileCompaction.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 *LogFileCompaction) XXX_Merge(src proto.Message) { + xxx_messageInfo_LogFileCompaction.Merge(m, src) +} +func (m *LogFileCompaction) XXX_Size() int { + return m.Size() +} +func (m *LogFileCompaction) XXX_DiscardUnknown() { + xxx_messageInfo_LogFileCompaction.DiscardUnknown(m) } -type backupPrepareSnapshotBackupServer struct { - grpc.ServerStream +var xxx_messageInfo_LogFileCompaction proto.InternalMessageInfo + +func (m *LogFileCompaction) GetCompactionFromTs() uint64 { + if m != nil { + return m.CompactionFromTs + } + return 0 } -func (x *backupPrepareSnapshotBackupServer) Send(m *PrepareSnapshotBackupResponse) error { - return x.ServerStream.SendMsg(m) +func (m *LogFileCompaction) GetCompactionUntilTs() uint64 { + if m != nil { + return m.CompactionUntilTs + } + return 0 } -func (x *backupPrepareSnapshotBackupServer) Recv() (*PrepareSnapshotBackupRequest, error) { - m := new(PrepareSnapshotBackupRequest) - if err := x.ServerStream.RecvMsg(m); err != nil { - return nil, err +func (m *LogFileCompaction) GetName() string { + if m != nil { + return m.Name } - return m, nil + return "" } -func _Backup_Prepare_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(PrepareRequest) - if err := dec(in); err != nil { - return nil, err +func (m *LogFileCompaction) GetComments() string { + if m != nil { + return m.Comments } - if interceptor == nil { - return srv.(BackupServer).Prepare(ctx, in) + return "" +} + +func (m *LogFileCompaction) GetArtifacts() string { + if m != nil { + return m.Artifacts } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/backup.Backup/Prepare", + return "" +} + +func (m *LogFileCompaction) GetArtifactsHash() uint64 { + if m != nil { + return m.ArtifactsHash } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(BackupServer).Prepare(ctx, req.(*PrepareRequest)) + return 0 +} + +func (m *LogFileCompaction) GetGeneratedFiles() string { + if m != nil { + return m.GeneratedFiles } - return interceptor(ctx, in, info, handler) + return "" } -func _Backup_Cleanup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(CleanupRequest) - if err := dec(in); err != nil { - return nil, err +type MetaEdit struct { + // Path to the meta file. + Path string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"` + // Delete the physical files (MetaFileGroup) in the meta file. + DeletePhysicalFiles []string `protobuf:"bytes,2,rep,name=delete_physical_files,json=deletePhysicalFiles,proto3" json:"delete_physical_files,omitempty"` + // Delete the logical files (MetaFileInfo) in the meta file. + // Note: Even the operation have been performed in the meta, + // this modification should be kept as long as the corresponding physical + // file not deleted. Or we may cannot know when to delete the physical file. + // Then the file will be leak until truncated. + DeleteLogicalFiles []*DeleteSpansOfFile `protobuf:"bytes,3,rep,name=delete_logical_files,json=deleteLogicalFiles,proto3" json:"delete_logical_files,omitempty"` + // Whether to delete the metadata itself. + DestructSelf bool `protobuf:"varint,4,opt,name=destruct_self,json=destructSelf,proto3" json:"destruct_self,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *MetaEdit) Reset() { *m = MetaEdit{} } +func (m *MetaEdit) String() string { return proto.CompactTextString(m) } +func (*MetaEdit) ProtoMessage() {} +func (*MetaEdit) Descriptor() ([]byte, []int) { + return fileDescriptor_483d1f48d58a4885, []int{51} +} +func (m *MetaEdit) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MetaEdit) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MetaEdit.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - if interceptor == nil { - return srv.(BackupServer).Cleanup(ctx, in) +} +func (m *MetaEdit) XXX_Merge(src proto.Message) { + xxx_messageInfo_MetaEdit.Merge(m, src) +} +func (m *MetaEdit) XXX_Size() int { + return m.Size() +} +func (m *MetaEdit) XXX_DiscardUnknown() { + xxx_messageInfo_MetaEdit.DiscardUnknown(m) +} + +var xxx_messageInfo_MetaEdit proto.InternalMessageInfo + +func (m *MetaEdit) GetPath() string { + if m != nil { + return m.Path } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/backup.Backup/Cleanup", + return "" +} + +func (m *MetaEdit) GetDeletePhysicalFiles() []string { + if m != nil { + return m.DeletePhysicalFiles } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(BackupServer).Cleanup(ctx, req.(*CleanupRequest)) + return nil +} + +func (m *MetaEdit) GetDeleteLogicalFiles() []*DeleteSpansOfFile { + if m != nil { + return m.DeleteLogicalFiles } - return interceptor(ctx, in, info, handler) + return nil } -var _Backup_serviceDesc = grpc.ServiceDesc{ - ServiceName: "backup.Backup", - HandlerType: (*BackupServer)(nil), - Methods: []grpc.MethodDesc{ - { - MethodName: "prepare", - Handler: _Backup_Prepare_Handler, - }, - { - MethodName: "cleanup", - Handler: _Backup_Cleanup_Handler, - }, - }, - Streams: []grpc.StreamDesc{ - { - StreamName: "backup", - Handler: _Backup_Backup_Handler, - ServerStreams: true, - }, - { - StreamName: "CheckPendingAdminOp", - Handler: _Backup_CheckPendingAdminOp_Handler, - ServerStreams: true, - }, - { - StreamName: "PrepareSnapshotBackup", - Handler: _Backup_PrepareSnapshotBackup_Handler, - ServerStreams: true, - ClientStreams: true, - }, - }, - Metadata: "brpb.proto", +func (m *MetaEdit) GetDestructSelf() bool { + if m != nil { + return m.DestructSelf + } + return false } -// ExternalStorageClient is the client API for ExternalStorage service. -// -// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. -type ExternalStorageClient interface { - // Restore to a file - Restore(ctx context.Context, in *ExternalStorageRestoreRequest, opts ...grpc.CallOption) (*ExternalStorageRestoreResponse, error) - // Save a file to storage - Save(ctx context.Context, in *ExternalStorageSaveRequest, opts ...grpc.CallOption) (*ExternalStorageSaveResponse, error) +// An extended version of `SpansOfFile`, added more metadata for the +// execution of delayed deletion. +type DeleteSpansOfFile struct { + Path string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"` + Spans []*Span `protobuf:"bytes,2,rep,name=spans,proto3" json:"spans,omitempty"` + // This is a hint for garbage collecting. + // So we can easily check whether a set of spans consists the whole file. + WholeFileLength uint64 `protobuf:"varint,3,opt,name=whole_file_length,json=wholeFileLength,proto3" json:"whole_file_length,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } -type externalStorageClient struct { - cc *grpc.ClientConn +func (m *DeleteSpansOfFile) Reset() { *m = DeleteSpansOfFile{} } +func (m *DeleteSpansOfFile) String() string { return proto.CompactTextString(m) } +func (*DeleteSpansOfFile) ProtoMessage() {} +func (*DeleteSpansOfFile) Descriptor() ([]byte, []int) { + return fileDescriptor_483d1f48d58a4885, []int{52} } - -func NewExternalStorageClient(cc *grpc.ClientConn) ExternalStorageClient { - return &externalStorageClient{cc} +func (m *DeleteSpansOfFile) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) } - -func (c *externalStorageClient) Restore(ctx context.Context, in *ExternalStorageRestoreRequest, opts ...grpc.CallOption) (*ExternalStorageRestoreResponse, error) { - out := new(ExternalStorageRestoreResponse) - err := c.cc.Invoke(ctx, "/backup.ExternalStorage/restore", in, out, opts...) - if err != nil { - return nil, err +func (m *DeleteSpansOfFile) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_DeleteSpansOfFile.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 *externalStorageClient) Save(ctx context.Context, in *ExternalStorageSaveRequest, opts ...grpc.CallOption) (*ExternalStorageSaveResponse, error) { - out := new(ExternalStorageSaveResponse) - err := c.cc.Invoke(ctx, "/backup.ExternalStorage/save", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil +func (m *DeleteSpansOfFile) XXX_Merge(src proto.Message) { + xxx_messageInfo_DeleteSpansOfFile.Merge(m, src) } - -// ExternalStorageServer is the server API for ExternalStorage service. -type ExternalStorageServer interface { - // Restore to a file - Restore(context.Context, *ExternalStorageRestoreRequest) (*ExternalStorageRestoreResponse, error) - // Save a file to storage - Save(context.Context, *ExternalStorageSaveRequest) (*ExternalStorageSaveResponse, error) +func (m *DeleteSpansOfFile) XXX_Size() int { + return m.Size() } - -// UnimplementedExternalStorageServer can be embedded to have forward compatible implementations. -type UnimplementedExternalStorageServer struct { +func (m *DeleteSpansOfFile) XXX_DiscardUnknown() { + xxx_messageInfo_DeleteSpansOfFile.DiscardUnknown(m) } -func (*UnimplementedExternalStorageServer) Restore(ctx context.Context, req *ExternalStorageRestoreRequest) (*ExternalStorageRestoreResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method Restore not implemented") -} -func (*UnimplementedExternalStorageServer) Save(ctx context.Context, req *ExternalStorageSaveRequest) (*ExternalStorageSaveResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method Save not implemented") -} +var xxx_messageInfo_DeleteSpansOfFile proto.InternalMessageInfo -func RegisterExternalStorageServer(s *grpc.Server, srv ExternalStorageServer) { - s.RegisterService(&_ExternalStorage_serviceDesc, srv) +func (m *DeleteSpansOfFile) GetPath() string { + if m != nil { + return m.Path + } + return "" } -func _ExternalStorage_Restore_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(ExternalStorageRestoreRequest) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(ExternalStorageServer).Restore(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/backup.ExternalStorage/Restore", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(ExternalStorageServer).Restore(ctx, req.(*ExternalStorageRestoreRequest)) +func (m *DeleteSpansOfFile) GetSpans() []*Span { + if m != nil { + return m.Spans } - return interceptor(ctx, in, info, handler) + return nil } -func _ExternalStorage_Save_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(ExternalStorageSaveRequest) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(ExternalStorageServer).Save(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/backup.ExternalStorage/Save", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(ExternalStorageServer).Save(ctx, req.(*ExternalStorageSaveRequest)) +func (m *DeleteSpansOfFile) GetWholeFileLength() uint64 { + if m != nil { + return m.WholeFileLength } - return interceptor(ctx, in, info, handler) + return 0 } -var _ExternalStorage_serviceDesc = grpc.ServiceDesc{ - ServiceName: "backup.ExternalStorage", - HandlerType: (*ExternalStorageServer)(nil), - Methods: []grpc.MethodDesc{ - { - MethodName: "restore", - Handler: _ExternalStorage_Restore_Handler, - }, - { - MethodName: "save", - Handler: _ExternalStorage_Save_Handler, - }, - }, - Streams: []grpc.StreamDesc{}, - Metadata: "brpb.proto", +type Migration struct { + EditMeta []*MetaEdit `protobuf:"bytes,1,rep,name=edit_meta,json=editMeta,proto3" json:"edit_meta,omitempty"` + TruncatedTo uint64 `protobuf:"varint,2,opt,name=truncated_to,json=truncatedTo,proto3" json:"truncated_to,omitempty"` + Compactions []*LogFileCompaction `protobuf:"bytes,3,rep,name=compactions,proto3" json:"compactions,omitempty"` + // Delete all files matches this prefix. + DestructPrefix []string `protobuf:"bytes,4,rep,name=destruct_prefix,json=destructPrefix,proto3" json:"destruct_prefix,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } -func (m *PrepareSnapshotBackupRequest) 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 *Migration) Reset() { *m = Migration{} } +func (m *Migration) String() string { return proto.CompactTextString(m) } +func (*Migration) ProtoMessage() {} +func (*Migration) Descriptor() ([]byte, []int) { + return fileDescriptor_483d1f48d58a4885, []int{53} } - -func (m *PrepareSnapshotBackupRequest) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func (m *Migration) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) } - -func (m *PrepareSnapshotBackupRequest) 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.LeaseInSeconds != 0 { - i = encodeVarintBrpb(dAtA, i, uint64(m.LeaseInSeconds)) - 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 = encodeVarintBrpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 +func (m *Migration) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Migration.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err } + return b[:n], nil } - if m.Ty != 0 { - i = encodeVarintBrpb(dAtA, i, uint64(m.Ty)) - i-- - dAtA[i] = 0x8 - } - return len(dAtA) - i, nil +} +func (m *Migration) XXX_Merge(src proto.Message) { + xxx_messageInfo_Migration.Merge(m, src) +} +func (m *Migration) XXX_Size() int { + return m.Size() +} +func (m *Migration) XXX_DiscardUnknown() { + xxx_messageInfo_Migration.DiscardUnknown(m) } -func (m *PrepareSnapshotBackupResponse) 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 xxx_messageInfo_Migration proto.InternalMessageInfo + +func (m *Migration) GetEditMeta() []*MetaEdit { + if m != nil { + return m.EditMeta } - return dAtA[:n], nil + return nil } -func (m *PrepareSnapshotBackupResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func (m *Migration) GetTruncatedTo() uint64 { + if m != nil { + return m.TruncatedTo + } + return 0 } -func (m *PrepareSnapshotBackupResponse) 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 (m *Migration) GetCompactions() []*LogFileCompaction { + if m != nil { + return m.Compactions } - if m.LastLeaseIsValid { - i-- - if m.LastLeaseIsValid { - dAtA[i] = 1 - } else { - dAtA[i] = 0 - } - i-- - dAtA[i] = 0x20 + return nil +} + +func (m *Migration) GetDestructPrefix() []string { + if m != nil { + return m.DestructPrefix } - if m.Error != nil { - { - size, err := m.Error.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintBrpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a + return nil +} + +func init() { + proto.RegisterEnum("backup.PrepareSnapshotBackupRequestType", PrepareSnapshotBackupRequestType_name, PrepareSnapshotBackupRequestType_value) + proto.RegisterEnum("backup.PrepareSnapshotBackupEventType", PrepareSnapshotBackupEventType_name, PrepareSnapshotBackupEventType_value) + proto.RegisterEnum("backup.CompressionType", CompressionType_name, CompressionType_value) + proto.RegisterEnum("backup.BackupMode", BackupMode_name, BackupMode_value) + proto.RegisterEnum("backup.MetaVersion", MetaVersion_name, MetaVersion_value) + proto.RegisterEnum("backup.FileType", FileType_name, FileType_value) + proto.RegisterType((*PrepareSnapshotBackupRequest)(nil), "backup.PrepareSnapshotBackupRequest") + proto.RegisterType((*PrepareSnapshotBackupResponse)(nil), "backup.PrepareSnapshotBackupResponse") + proto.RegisterType((*BackupMeta)(nil), "backup.BackupMeta") + proto.RegisterType((*BackupRange)(nil), "backup.BackupRange") + proto.RegisterType((*File)(nil), "backup.File") + proto.RegisterType((*MetaFile)(nil), "backup.MetaFile") + proto.RegisterType((*PlacementPolicy)(nil), "backup.PlacementPolicy") + proto.RegisterType((*StatsBlock)(nil), "backup.StatsBlock") + proto.RegisterType((*StatsFile)(nil), "backup.StatsFile") + proto.RegisterType((*StatsFileIndex)(nil), "backup.StatsFileIndex") + proto.RegisterType((*Schema)(nil), "backup.Schema") + proto.RegisterType((*IDMap)(nil), "backup.IDMap") + proto.RegisterType((*PitrTableMap)(nil), "backup.PitrTableMap") + proto.RegisterType((*PitrDBMap)(nil), "backup.PitrDBMap") + proto.RegisterType((*RawRange)(nil), "backup.RawRange") + proto.RegisterType((*ClusterIDError)(nil), "backup.ClusterIDError") + proto.RegisterType((*Error)(nil), "backup.Error") + proto.RegisterType((*CipherInfo)(nil), "backup.CipherInfo") + proto.RegisterType((*BackupRequest)(nil), "backup.BackupRequest") + proto.RegisterType((*StreamBackupTaskInfo)(nil), "backup.StreamBackupTaskInfo") + proto.RegisterType((*StorageBackend)(nil), "backup.StorageBackend") + proto.RegisterType((*Noop)(nil), "backup.Noop") + proto.RegisterType((*Local)(nil), "backup.Local") + proto.RegisterType((*S3)(nil), "backup.S3") + proto.RegisterType((*GCS)(nil), "backup.GCS") + proto.RegisterType((*AzureCustomerKey)(nil), "backup.AzureCustomerKey") + proto.RegisterType((*AzureBlobStorage)(nil), "backup.AzureBlobStorage") + proto.RegisterType((*Bucket)(nil), "backup.Bucket") + proto.RegisterType((*CloudDynamic)(nil), "backup.CloudDynamic") + proto.RegisterMapType((map[string]string)(nil), "backup.CloudDynamic.AttrsEntry") + proto.RegisterType((*HDFS)(nil), "backup.HDFS") + proto.RegisterType((*BackupResponse)(nil), "backup.BackupResponse") + proto.RegisterType((*CleanupRequest)(nil), "backup.CleanupRequest") + proto.RegisterType((*CleanupResponse)(nil), "backup.CleanupResponse") + proto.RegisterType((*PrepareRequest)(nil), "backup.PrepareRequest") + proto.RegisterType((*PrepareResponse)(nil), "backup.PrepareResponse") + proto.RegisterType((*CheckAdminRequest)(nil), "backup.CheckAdminRequest") + proto.RegisterType((*CheckAdminResponse)(nil), "backup.CheckAdminResponse") + proto.RegisterType((*ExternalStorageRestoreRequest)(nil), "backup.ExternalStorageRestoreRequest") + proto.RegisterType((*ExternalStorageRestoreResponse)(nil), "backup.ExternalStorageRestoreResponse") + proto.RegisterType((*ExternalStorageSaveRequest)(nil), "backup.ExternalStorageSaveRequest") + proto.RegisterType((*ExternalStorageSaveResponse)(nil), "backup.ExternalStorageSaveResponse") + proto.RegisterType((*Metadata)(nil), "backup.Metadata") + proto.RegisterType((*DataFileGroup)(nil), "backup.DataFileGroup") + proto.RegisterType((*DataFileInfo)(nil), "backup.DataFileInfo") + proto.RegisterType((*StreamBackupError)(nil), "backup.StreamBackupError") + proto.RegisterType((*Span)(nil), "backup.Span") + proto.RegisterType((*SpansOfFile)(nil), "backup.SpansOfFile") + proto.RegisterType((*LogFileSubcompactionMeta)(nil), "backup.LogFileSubcompactionMeta") + proto.RegisterType((*LogFileSubcompaction)(nil), "backup.LogFileSubcompaction") + proto.RegisterType((*LogFileSubcompactions)(nil), "backup.LogFileSubcompactions") + proto.RegisterType((*LogFileCompaction)(nil), "backup.LogFileCompaction") + proto.RegisterType((*MetaEdit)(nil), "backup.MetaEdit") + proto.RegisterType((*DeleteSpansOfFile)(nil), "backup.DeleteSpansOfFile") + proto.RegisterType((*Migration)(nil), "backup.Migration") +} + +func init() { proto.RegisterFile("brpb.proto", fileDescriptor_483d1f48d58a4885) } + +var fileDescriptor_483d1f48d58a4885 = []byte{ + // 4318 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x7a, 0xdd, 0x6f, 0x1c, 0x47, + 0x72, 0x38, 0x67, 0xbf, 0xb7, 0xf6, 0x93, 0x43, 0x51, 0x5e, 0xd3, 0x96, 0x44, 0x8f, 0x6c, 0x1d, + 0x7f, 0xbc, 0x13, 0xcf, 0x27, 0xf9, 0x74, 0xfe, 0xc5, 0x17, 0x18, 0xfc, 0x92, 0x49, 0x8b, 0x92, + 0x98, 0x21, 0xed, 0x43, 0x0c, 0x04, 0x83, 0xd9, 0x99, 0x5e, 0xee, 0x1c, 0x67, 0x67, 0xe6, 0xa6, + 0x7b, 0x57, 0xa2, 0xf3, 0x96, 0x77, 0xc3, 0x49, 0x80, 0x00, 0xf9, 0x07, 0x02, 0xe4, 0x21, 0x01, + 0xf2, 0x27, 0x04, 0x48, 0x02, 0x5c, 0x90, 0x00, 0xb9, 0x87, 0x3c, 0xe4, 0x31, 0x70, 0x90, 0xbf, + 0x21, 0x4f, 0x01, 0x82, 0xaa, 0xee, 0x9e, 0x9d, 0x5d, 0x2e, 0x29, 0xc9, 0x09, 0xee, 0x69, 0xb7, + 0xab, 0xaa, 0xbb, 0xab, 0xeb, 0xbb, 0xba, 0x07, 0xa0, 0x9f, 0x26, 0xfd, 0xad, 0x24, 0x8d, 0x45, + 0x6c, 0x56, 0xfa, 0xae, 0x77, 0x3e, 0x4e, 0xd6, 0x5a, 0xe7, 0x93, 0x34, 0xf1, 0x34, 0x78, 0xad, + 0xc5, 0xd2, 0x34, 0xce, 0xa8, 0xd6, 0x9a, 0x23, 0x26, 0xdc, 0x6c, 0x64, 0xb2, 0xc8, 0x4b, 0x2f, + 0x12, 0x11, 0xc4, 0x51, 0x06, 0xbb, 0x71, 0x16, 0x9f, 0xc5, 0xf4, 0xf7, 0xc7, 0xf8, 0x4f, 0x41, + 0x3b, 0xe9, 0x98, 0x0b, 0xfa, 0x2b, 0x01, 0xd6, 0x5f, 0x19, 0xf0, 0xee, 0x71, 0xca, 0x12, 0x37, + 0x65, 0x27, 0x91, 0x9b, 0xf0, 0x61, 0x2c, 0x76, 0x88, 0x01, 0x9b, 0xfd, 0x6a, 0xcc, 0xb8, 0x30, + 0x3f, 0x86, 0x82, 0xb8, 0xe8, 0x19, 0xeb, 0xc6, 0x46, 0xfb, 0xc1, 0xc6, 0x96, 0x64, 0x6e, 0xeb, + 0xba, 0x19, 0xa7, 0x17, 0x09, 0xb3, 0x0b, 0xe2, 0xc2, 0xdc, 0x80, 0x6a, 0xca, 0xce, 0x82, 0x38, + 0xe2, 0xbd, 0xc2, 0x7a, 0x71, 0xa3, 0xf1, 0xa0, 0xbd, 0xa5, 0xb8, 0xb6, 0x09, 0x6c, 0x6b, 0xb4, + 0xb9, 0x01, 0xdd, 0x90, 0xb9, 0x9c, 0x39, 0x41, 0xe4, 0x70, 0xe6, 0xc5, 0x91, 0xcf, 0x7b, 0xc5, + 0x75, 0x63, 0xa3, 0x64, 0xb7, 0x09, 0x7e, 0x18, 0x9d, 0x48, 0xa8, 0xf5, 0xaf, 0x06, 0xdc, 0xba, + 0x62, 0x73, 0x9e, 0xc4, 0x11, 0x67, 0xe6, 0xa3, 0x1c, 0xbf, 0xf7, 0xae, 0xe5, 0x77, 0x7f, 0xc2, + 0xa2, 0x29, 0xb7, 0xf7, 0xa0, 0x22, 0xd9, 0xe9, 0x15, 0xd6, 0x8d, 0x05, 0xcc, 0x2a, 0xac, 0xf9, + 0x3e, 0x94, 0x49, 0x15, 0xc4, 0x20, 0x92, 0x69, 0xc5, 0xec, 0xe3, 0xaf, 0x2d, 0x91, 0xe6, 0x7d, + 0x58, 0x09, 0x5d, 0x2e, 0x1c, 0x75, 0x2c, 0xee, 0x4c, 0xdc, 0x30, 0xf0, 0x7b, 0xa5, 0x75, 0x63, + 0xa3, 0x66, 0x77, 0x11, 0x75, 0x44, 0x07, 0xe3, 0x5f, 0x22, 0xdc, 0xfa, 0xcf, 0x2a, 0x80, 0x64, + 0xea, 0x29, 0x13, 0xae, 0x79, 0x0b, 0xc0, 0x0b, 0xc7, 0x5c, 0xb0, 0xd4, 0x09, 0x7c, 0x3a, 0x4b, + 0xc9, 0xae, 0x2b, 0xc8, 0xa1, 0x6f, 0xfe, 0x00, 0x3a, 0x1a, 0x3d, 0x61, 0x29, 0xd7, 0x3c, 0xd7, + 0xed, 0xb6, 0x02, 0x7f, 0x29, 0xa1, 0xb8, 0x4e, 0x7f, 0x4a, 0xd3, 0x20, 0x9a, 0x7a, 0x3f, 0x43, + 0xf7, 0xa0, 0xaa, 0x71, 0xcd, 0x75, 0x63, 0xa3, 0x6c, 0xeb, 0xa1, 0x69, 0x41, 0x79, 0x10, 0x84, + 0x8c, 0xf7, 0x4a, 0xa4, 0xb8, 0xa6, 0x96, 0xe3, 0xe3, 0x20, 0x64, 0xb6, 0x44, 0x99, 0x3f, 0x06, + 0xc0, 0x3f, 0x4e, 0x10, 0xf9, 0xec, 0x65, 0xaf, 0x45, 0xd2, 0xe8, 0x6a, 0x42, 0x3c, 0x06, 0x11, + 0xd7, 0x91, 0xe6, 0x10, 0x49, 0xcc, 0xbb, 0xd0, 0xe2, 0xc2, 0x4d, 0x45, 0xc6, 0x50, 0x99, 0x0e, + 0xd6, 0x24, 0xa0, 0xe6, 0xe9, 0x0e, 0x34, 0x58, 0xe4, 0x67, 0x24, 0x15, 0x22, 0x01, 0x16, 0xf9, + 0x9a, 0x60, 0x03, 0xaa, 0xdc, 0x1b, 0xb2, 0x91, 0xcb, 0x7b, 0x55, 0x65, 0x55, 0x6a, 0xcf, 0x13, + 0x02, 0xdb, 0x1a, 0x6d, 0x3e, 0x84, 0xa6, 0xfc, 0xab, 0x58, 0x6c, 0x5f, 0xc1, 0x62, 0x43, 0x52, + 0x49, 0x26, 0xd7, 0xa0, 0x1e, 0x70, 0x27, 0x75, 0x5f, 0x38, 0xe7, 0x93, 0x5e, 0x8d, 0xd4, 0x55, + 0x0d, 0xb8, 0xed, 0xbe, 0x78, 0x32, 0xc1, 0x13, 0x23, 0x22, 0x75, 0xa3, 0x33, 0xc6, 0x7b, 0x75, + 0xda, 0x3d, 0x5b, 0xce, 0x76, 0x5f, 0xd8, 0x88, 0xb0, 0xeb, 0xa9, 0xfa, 0xc7, 0xcd, 0x8f, 0xa1, + 0x93, 0x4d, 0x50, 0x4c, 0x74, 0xae, 0x60, 0xa2, 0xa5, 0x67, 0x49, 0x36, 0x4c, 0x28, 0xf9, 0x7e, + 0xc8, 0x7b, 0xb0, 0x6e, 0x6c, 0x34, 0x6d, 0xfa, 0x6f, 0xfe, 0x04, 0x1a, 0xbe, 0x1f, 0xca, 0x75, + 0x18, 0xef, 0x75, 0xaf, 0x58, 0x09, 0x7c, 0x3f, 0x3c, 0x94, 0x34, 0x28, 0x72, 0x89, 0x76, 0x52, + 0xc6, 0xc7, 0xa1, 0xe8, 0x2d, 0x93, 0x0d, 0x34, 0xfb, 0xda, 0x67, 0xc6, 0xa1, 0x30, 0x3f, 0x82, + 0x86, 0x9b, 0x04, 0x99, 0xc8, 0x4d, 0x72, 0x9d, 0x95, 0x2d, 0x1d, 0x7f, 0xb6, 0x8f, 0x0f, 0x95, + 0xec, 0x6d, 0x70, 0x93, 0x40, 0xeb, 0xe1, 0x21, 0xd4, 0x92, 0x38, 0x0c, 0xbc, 0x80, 0xf1, 0xde, + 0x0a, 0x89, 0xe2, 0xad, 0xcc, 0xdb, 0x42, 0xd7, 0x63, 0x23, 0x16, 0x89, 0x63, 0x24, 0xb8, 0xb0, + 0x33, 0x42, 0xf3, 0x23, 0xb8, 0x19, 0xb1, 0x17, 0x8e, 0x17, 0x87, 0xa1, 0x8b, 0xd1, 0x8a, 0x3b, + 0x2c, 0x72, 0xfb, 0x21, 0xf3, 0x7b, 0x37, 0x88, 0xb1, 0x1b, 0x11, 0x7b, 0xb1, 0x9b, 0x21, 0xf7, + 0x25, 0x4e, 0xe9, 0x44, 0xbc, 0x8c, 0x50, 0x27, 0xab, 0x5a, 0x27, 0xa7, 0x2f, 0xa3, 0x27, 0x13, + 0x73, 0x13, 0xaa, 0x7e, 0xdf, 0x19, 0xb9, 0x09, 0xef, 0xdd, 0x24, 0x2e, 0x96, 0x33, 0x2e, 0x02, + 0x91, 0xee, 0xed, 0x3c, 0x75, 0x13, 0xbb, 0xe2, 0xf7, 0x9f, 0xba, 0x09, 0x37, 0xef, 0x41, 0x69, + 0x14, 0xfb, 0xac, 0xf7, 0x16, 0x9d, 0xd0, 0xd4, 0x84, 0xca, 0xf1, 0x62, 0x9f, 0xd9, 0x84, 0x37, + 0x7f, 0x08, 0x15, 0xa5, 0xe3, 0x1e, 0x2d, 0xb9, 0x32, 0x4b, 0x29, 0xd5, 0xac, 0x48, 0xd0, 0x60, + 0x95, 0x88, 0x79, 0xf0, 0x35, 0xeb, 0xbd, 0x2d, 0x0d, 0x56, 0x82, 0x4e, 0x82, 0xaf, 0xd9, 0xe7, + 0xa5, 0x5a, 0xb1, 0x5b, 0xb2, 0x4b, 0x89, 0x2b, 0x86, 0xd6, 0x19, 0x34, 0x72, 0x6b, 0x98, 0xef, + 0x40, 0x5d, 0x7a, 0xc4, 0x39, 0x93, 0x21, 0xab, 0x69, 0xd7, 0x08, 0xf0, 0x84, 0x5d, 0x98, 0x6f, + 0x41, 0x15, 0x3d, 0x01, 0x51, 0x05, 0x42, 0x55, 0x58, 0xe4, 0x23, 0x22, 0x73, 0xce, 0xe2, 0x95, + 0xce, 0x69, 0xfd, 0x63, 0x01, 0x4a, 0x38, 0x46, 0x43, 0x8a, 0xdc, 0x11, 0xa3, 0xd5, 0xeb, 0x36, + 0xfd, 0x37, 0x6f, 0x42, 0x85, 0x0f, 0xdd, 0x07, 0x3f, 0x7d, 0xa4, 0x17, 0x96, 0xa3, 0x59, 0x76, + 0x8a, 0x57, 0xb3, 0x53, 0x9a, 0x61, 0xe7, 0xff, 0xc6, 0xad, 0xd7, 0xa0, 0xe6, 0xa5, 0xde, 0xa3, + 0x8f, 0x5e, 0xc6, 0x69, 0xaf, 0x4a, 0xd8, 0x6c, 0x8c, 0x7c, 0x89, 0x58, 0xb8, 0xa1, 0x73, 0x3e, + 0xe1, 0xe4, 0x93, 0x25, 0xbb, 0x46, 0x80, 0x27, 0x13, 0x92, 0xbf, 0x44, 0xf6, 0x2f, 0x04, 0x79, + 0x25, 0xad, 0x4c, 0xa0, 0x1d, 0x84, 0x98, 0x6d, 0x28, 0x78, 0x03, 0x72, 0xa4, 0xba, 0x5d, 0xf0, + 0x06, 0x28, 0x11, 0xd2, 0x54, 0x83, 0x28, 0xe9, 0x3f, 0xee, 0xe0, 0x05, 0xc9, 0x10, 0xe3, 0xed, + 0x84, 0x62, 0x61, 0xd3, 0xae, 0x49, 0xc0, 0xe1, 0xc4, 0xfa, 0xa6, 0x00, 0x35, 0xed, 0x5d, 0xe6, + 0x0f, 0x01, 0x30, 0x2f, 0x38, 0x52, 0x03, 0xc6, 0x02, 0x0d, 0xd4, 0x47, 0x8a, 0x96, 0x23, 0xb1, + 0xef, 0x66, 0xc4, 0x85, 0x45, 0xc4, 0x88, 0x97, 0xc4, 0xb9, 0xc0, 0x56, 0xbc, 0x3e, 0xb0, 0xcd, + 0xc6, 0xa1, 0xd2, 0xeb, 0xc4, 0xa1, 0x2c, 0x0c, 0xc8, 0x39, 0x95, 0xab, 0xed, 0x5a, 0xc7, 0x06, + 0x39, 0x53, 0xc7, 0xa1, 0xf2, 0x7a, 0x51, 0xc7, 0x21, 0xeb, 0x03, 0xe8, 0xcc, 0x79, 0x38, 0x92, + 0x05, 0xd1, 0x20, 0x56, 0x36, 0x4c, 0xff, 0xad, 0x23, 0x80, 0x13, 0xe1, 0x0a, 0xbe, 0x13, 0xc6, + 0xde, 0x39, 0xaa, 0x29, 0x19, 0x5e, 0xf0, 0xc0, 0x73, 0x43, 0x9d, 0xd3, 0x8a, 0x36, 0x68, 0xd0, + 0xa1, 0x8f, 0xb9, 0xea, 0x97, 0x3c, 0x8e, 0x1c, 0x81, 0x3e, 0xaf, 0x0c, 0xb3, 0x8e, 0x90, 0x53, + 0x04, 0x58, 0x3f, 0x83, 0x3a, 0xad, 0x46, 0x4a, 0xd8, 0x84, 0x4a, 0x1f, 0x57, 0xd5, 0x0a, 0xc8, + 0x5c, 0x79, 0xba, 0xa1, 0xad, 0x28, 0xac, 0xbf, 0x31, 0xa0, 0x9d, 0xcd, 0xcc, 0x82, 0xeb, 0x6b, + 0xfb, 0xc4, 0xdb, 0x50, 0x43, 0x0b, 0x71, 0x58, 0xe4, 0xa9, 0x92, 0xa4, 0x8a, 0xe3, 0xfd, 0xc8, + 0xcb, 0x50, 0x71, 0x1a, 0x90, 0x4b, 0x28, 0xd4, 0xf3, 0x34, 0x98, 0xb5, 0xa7, 0xf2, 0xac, 0x3d, + 0xa1, 0x28, 0x82, 0x28, 0x0c, 0x22, 0xe6, 0xa0, 0xf2, 0xc9, 0x17, 0x9a, 0x36, 0x48, 0xd0, 0x9e, + 0x2b, 0x5c, 0xeb, 0x8f, 0x0a, 0x50, 0x91, 0x3a, 0x47, 0xe3, 0xf5, 0xfb, 0x4a, 0xac, 0x05, 0xbf, + 0x6f, 0xde, 0x80, 0x72, 0x5e, 0x40, 0x72, 0x30, 0xe3, 0x3c, 0xc5, 0xeb, 0x9c, 0xa7, 0x74, 0xbd, + 0xf3, 0x94, 0x2f, 0x39, 0xcf, 0xff, 0x83, 0xae, 0x08, 0x06, 0xa1, 0xcb, 0x87, 0x4e, 0xca, 0x92, + 0x30, 0xf0, 0x5c, 0x4e, 0x0c, 0xb7, 0xec, 0x8e, 0x82, 0xdb, 0x0a, 0x8c, 0xac, 0x71, 0x94, 0x33, + 0xb9, 0x6f, 0xd3, 0x96, 0x03, 0xf3, 0x67, 0xd0, 0xa0, 0x3f, 0x2a, 0xfd, 0xd5, 0x48, 0x5f, 0x37, + 0x67, 0xf4, 0x95, 0x29, 0xc6, 0x06, 0x22, 0xa5, 0xff, 0xd6, 0x53, 0x28, 0x1f, 0xee, 0x3d, 0x75, + 0x13, 0xe4, 0x71, 0x9c, 0x70, 0x91, 0x32, 0x77, 0x94, 0xb3, 0x1c, 0x0d, 0x3a, 0xf4, 0x31, 0x00, + 0xf9, 0xf1, 0x8b, 0x68, 0x4a, 0x52, 0x20, 0x92, 0xe6, 0x14, 0x78, 0xe8, 0x5b, 0x2f, 0xa0, 0x89, + 0x09, 0x81, 0x8c, 0x09, 0x57, 0x5d, 0x64, 0x03, 0xef, 0x43, 0x25, 0xf0, 0x31, 0x97, 0xa8, 0x12, + 0xb0, 0xa5, 0xd9, 0x24, 0x46, 0xec, 0x72, 0xe0, 0xe3, 0xcc, 0xfb, 0x00, 0x89, 0x9b, 0x8a, 0x80, + 0x52, 0x94, 0x72, 0xd5, 0x39, 0xca, 0x1c, 0x81, 0xc5, 0xa1, 0x9e, 0x65, 0xa2, 0xff, 0xc5, 0xae, + 0x3f, 0x82, 0x0a, 0xe9, 0x5a, 0xef, 0x78, 0x23, 0x9f, 0xe6, 0xf4, 0xa9, 0x6c, 0x45, 0x63, 0x1d, + 0x43, 0x4d, 0xc7, 0x81, 0xef, 0x99, 0x64, 0x64, 0xd4, 0x2c, 0xea, 0xa8, 0x69, 0xed, 0x41, 0x7b, + 0x57, 0x15, 0xa0, 0x7b, 0x54, 0xe9, 0x62, 0xf5, 0xe8, 0x8d, 0xd3, 0x94, 0x45, 0x42, 0x55, 0xa8, + 0x7a, 0x88, 0x98, 0x54, 0xf6, 0x02, 0xb4, 0x68, 0xc9, 0xd6, 0x43, 0xeb, 0x9f, 0x0d, 0x28, 0xcb, + 0xd9, 0x5d, 0x28, 0x8e, 0xf8, 0x99, 0x12, 0x04, 0xfe, 0x35, 0x77, 0xa0, 0x3b, 0x2d, 0x7a, 0x9d, + 0x7c, 0x8d, 0x9d, 0x99, 0xcb, 0x2c, 0x07, 0x07, 0x4b, 0x59, 0xc1, 0x7b, 0xe8, 0xcb, 0x55, 0xb7, + 0xa0, 0x76, 0x3e, 0x51, 0x73, 0x4b, 0x34, 0x77, 0x39, 0xab, 0x63, 0x9e, 0xb0, 0x0b, 0x3d, 0xad, + 0x7a, 0x3e, 0x91, 0xf4, 0x0f, 0xa1, 0x29, 0xcb, 0x7a, 0x35, 0xa7, 0xbc, 0xa8, 0xa6, 0x3f, 0x58, + 0xb2, 0x1b, 0x92, 0x8a, 0x86, 0x3b, 0x35, 0xa8, 0xf8, 0x4c, 0xb8, 0x41, 0x68, 0x85, 0x00, 0xbb, + 0xd2, 0xab, 0xa3, 0x41, 0x6c, 0x7e, 0x0a, 0x0d, 0xe5, 0xf4, 0xe2, 0x22, 0x61, 0xaa, 0x05, 0xb9, + 0xbd, 0x35, 0xd3, 0x9b, 0xed, 0x67, 0x83, 0xa7, 0x4c, 0x0c, 0x63, 0xdf, 0x06, 0x39, 0x05, 0xdb, + 0x10, 0x2a, 0xfb, 0xe5, 0x02, 0x53, 0x7d, 0xa8, 0x38, 0xf2, 0x84, 0x5d, 0x58, 0xdf, 0x54, 0xa0, + 0x35, 0xdb, 0x9b, 0xbd, 0xa2, 0x4f, 0x98, 0xd1, 0x7c, 0xe1, 0x6a, 0xcd, 0x17, 0xaf, 0xcf, 0xe7, + 0xa5, 0x57, 0xe7, 0xf3, 0xf2, 0xa5, 0x7c, 0x7e, 0x0b, 0x73, 0x94, 0x60, 0x4e, 0x18, 0x8c, 0x02, + 0xa1, 0x32, 0x7a, 0x1d, 0x21, 0x47, 0x08, 0x30, 0xd7, 0xa1, 0xe1, 0xc5, 0x91, 0x34, 0x18, 0xef, + 0x82, 0x92, 0x7a, 0xcb, 0xce, 0x83, 0xcc, 0x4f, 0xa1, 0xc3, 0x45, 0x9c, 0xba, 0x67, 0xcc, 0x41, + 0xed, 0xb3, 0xc8, 0xa7, 0xdc, 0x3e, 0x13, 0x3c, 0x08, 0xbd, 0x23, 0xb1, 0x76, 0x9b, 0xcf, 0x8c, + 0x67, 0x2b, 0x79, 0x98, 0xad, 0xe4, 0xa5, 0x75, 0x37, 0xb2, 0x9a, 0x00, 0x6d, 0x2f, 0x1e, 0x25, + 0x29, 0xe3, 0xc8, 0xbc, 0xd4, 0x5f, 0x93, 0xf4, 0x97, 0x15, 0xb5, 0xbb, 0x53, 0x3c, 0xf5, 0x8c, + 0x1d, 0x6f, 0x16, 0x60, 0xfe, 0x10, 0x96, 0xf3, 0x6b, 0x84, 0x6c, 0xc2, 0x42, 0x6a, 0x8b, 0xca, + 0x76, 0x7e, 0xf1, 0x23, 0x84, 0x9b, 0x0f, 0x33, 0x5b, 0xa1, 0xbc, 0x29, 0x5b, 0x93, 0x2c, 0x8d, + 0x4d, 0x8d, 0x4a, 0xdb, 0x07, 0x19, 0xd8, 0x27, 0xd0, 0xf1, 0xb9, 0x70, 0xf2, 0xc5, 0x7a, 0xe7, + 0xea, 0x62, 0xbd, 0xe5, 0x73, 0xb1, 0x3d, 0xad, 0xd7, 0x3f, 0x04, 0xe0, 0xe3, 0xbe, 0x2e, 0x00, + 0xba, 0xaa, 0x56, 0xce, 0x39, 0x87, 0xaa, 0x1a, 0xf8, 0xb8, 0xaf, 0x72, 0xff, 0x7b, 0xe8, 0x1c, + 0x14, 0xdc, 0x9d, 0x94, 0xb9, 0x3e, 0xf5, 0x0e, 0x35, 0x74, 0x05, 0x82, 0xd9, 0xcc, 0xf5, 0xb3, + 0x8a, 0xda, 0x7c, 0x45, 0x45, 0xfd, 0x0e, 0xd4, 0xc7, 0x51, 0xf0, 0xab, 0x31, 0x43, 0x3b, 0x5d, + 0x21, 0xb1, 0xd7, 0x24, 0xe0, 0xd0, 0xc7, 0x12, 0xde, 0x8b, 0x23, 0xc1, 0x5e, 0x0a, 0xea, 0x02, + 0xb0, 0x96, 0xd1, 0x6c, 0xed, 0x4a, 0xb8, 0xad, 0x09, 0x3e, 0x2f, 0xd5, 0x2a, 0xdd, 0xaa, 0x2a, + 0xa6, 0xff, 0xac, 0x00, 0x37, 0x4e, 0x28, 0xbe, 0xcb, 0xfd, 0x4e, 0x5d, 0x7e, 0x4e, 0x72, 0xfa, + 0x10, 0xaa, 0xca, 0x16, 0xc8, 0x27, 0xae, 0x36, 0x19, 0x4d, 0x46, 0xa9, 0x9c, 0x6c, 0x5e, 0x70, + 0x1d, 0xb2, 0x68, 0x7c, 0xca, 0xcd, 0x55, 0x40, 0xc7, 0x40, 0x84, 0xcc, 0xac, 0x65, 0x16, 0xf9, + 0xa7, 0x3c, 0x8b, 0xe4, 0xa5, 0x5c, 0x24, 0x7f, 0x0f, 0x9a, 0x14, 0x7f, 0xb1, 0xde, 0x13, 0x2c, + 0xa5, 0xa2, 0xa9, 0x6e, 0x37, 0x08, 0xf6, 0x98, 0x40, 0x0b, 0x0d, 0xad, 0xf2, 0x66, 0x86, 0x66, + 0xb7, 0xe9, 0x66, 0x61, 0x9c, 0xf8, 0xe8, 0x5f, 0x82, 0xeb, 0x4e, 0xc4, 0xae, 0x60, 0xf6, 0x1c, + 0x73, 0xeb, 0x37, 0x05, 0xac, 0x78, 0x66, 0x7c, 0xc1, 0x82, 0x52, 0x14, 0xc7, 0x89, 0x12, 0x47, + 0x56, 0x82, 0x3e, 0x8b, 0xe3, 0xe4, 0x60, 0xc9, 0x26, 0x9c, 0xf9, 0x01, 0x94, 0xc3, 0xd8, 0x73, + 0xc3, 0xf9, 0x34, 0x74, 0x84, 0xc0, 0x83, 0x25, 0x5b, 0x62, 0xcd, 0x77, 0xa1, 0xc0, 0x1f, 0xaa, + 0xc0, 0x0c, 0x99, 0x5c, 0x1f, 0x1e, 0x2c, 0xd9, 0x05, 0xfe, 0xd0, 0xbc, 0x03, 0xc5, 0x33, 0x8f, + 0xab, 0xd8, 0xdb, 0xd0, 0xe8, 0xcf, 0x76, 0x4f, 0x0e, 0x96, 0x6c, 0xc4, 0x98, 0x9f, 0x40, 0xcb, + 0x0b, 0xe3, 0xb1, 0xef, 0xf8, 0x17, 0x91, 0x3b, 0x0a, 0x3c, 0x15, 0x72, 0x6f, 0x4c, 0x43, 0x7c, + 0x3c, 0xf6, 0xf7, 0x24, 0xee, 0x60, 0xc9, 0x6e, 0x7a, 0xb9, 0x31, 0x1e, 0x63, 0xe8, 0x0f, 0x64, + 0x05, 0x92, 0x3b, 0xc6, 0xc1, 0xde, 0x63, 0x5c, 0x9f, 0x70, 0xe6, 0x01, 0x98, 0xee, 0xd7, 0xe3, + 0x94, 0x39, 0xfd, 0x30, 0xee, 0x3b, 0xda, 0x0e, 0xaa, 0x34, 0xa3, 0xa7, 0x67, 0x6c, 0x23, 0xc5, + 0x4e, 0x18, 0xf7, 0x95, 0x9c, 0x0e, 0x96, 0xec, 0xae, 0x3b, 0x07, 0xdb, 0xa9, 0x43, 0x55, 0x45, + 0x1e, 0xab, 0x02, 0x25, 0x94, 0x95, 0xf5, 0x0e, 0x94, 0x49, 0x1c, 0xa8, 0x7e, 0xb4, 0x41, 0x9d, + 0xc8, 0xc9, 0x1e, 0xff, 0xb4, 0x04, 0x85, 0x93, 0x87, 0x58, 0x8c, 0xb1, 0xc8, 0x4f, 0xe2, 0x40, + 0x25, 0xc6, 0xba, 0x9d, 0x8d, 0xb1, 0xca, 0xcc, 0x5d, 0x32, 0xd5, 0xb3, 0x4b, 0xa5, 0x9b, 0x50, + 0xe9, 0x8f, 0xbd, 0x73, 0x26, 0x54, 0xc6, 0x55, 0x23, 0x84, 0x27, 0x29, 0x1b, 0x04, 0x2f, 0x95, + 0x9d, 0xa9, 0x91, 0x8c, 0xd1, 0x32, 0x38, 0x7a, 0xa1, 0xcb, 0x65, 0xe5, 0x56, 0xc7, 0x18, 0x4d, + 0xc0, 0x5d, 0x84, 0x61, 0x8a, 0xe5, 0x5c, 0x9a, 0x57, 0xdd, 0xc6, 0xbf, 0x08, 0x71, 0xbd, 0x90, + 0x84, 0x51, 0xb7, 0xf1, 0x2f, 0x86, 0x69, 0xd7, 0xf3, 0x18, 0xe7, 0x94, 0x08, 0x6a, 0xf2, 0x86, + 0x48, 0x42, 0x30, 0x17, 0x6c, 0xc2, 0x32, 0x67, 0x5e, 0xca, 0x84, 0x93, 0xa3, 0xaa, 0x13, 0x55, + 0x47, 0x22, 0xb6, 0x33, 0xda, 0x0d, 0xe8, 0x0e, 0xe2, 0xd4, 0x63, 0x0e, 0x0a, 0xc3, 0xe1, 0xe2, + 0x22, 0x64, 0x2a, 0xec, 0xb6, 0x09, 0x7e, 0xec, 0x8a, 0xe1, 0x09, 0x42, 0xcd, 0xbb, 0xd0, 0xe6, + 0x9c, 0x39, 0xe7, 0x23, 0x5a, 0x0f, 0x43, 0x82, 0x8c, 0xc4, 0x0d, 0xce, 0xd9, 0x93, 0x11, 0x2e, + 0x76, 0xe8, 0xa3, 0x4b, 0xa6, 0x71, 0xc8, 0x1c, 0x37, 0x95, 0xb7, 0x53, 0x75, 0xbb, 0x8a, 0xe3, + 0xed, 0x54, 0x26, 0x9f, 0x97, 0x82, 0xa5, 0x91, 0xec, 0x25, 0x5a, 0x84, 0x05, 0x0d, 0x3a, 0xf4, + 0xcd, 0x2d, 0x58, 0x89, 0xfb, 0xbf, 0x64, 0x9e, 0x70, 0xb0, 0x07, 0xc8, 0xee, 0x18, 0xda, 0xc4, + 0xcd, 0xb2, 0x44, 0x1d, 0xc5, 0xde, 0xb9, 0xbe, 0x60, 0x40, 0x71, 0x6a, 0x8f, 0x8c, 0xcf, 0x99, + 0x0c, 0xab, 0x28, 0x4e, 0xe5, 0x75, 0x08, 0x43, 0xbd, 0x26, 0x69, 0x3c, 0x09, 0x7c, 0x96, 0xd2, + 0xdd, 0x4b, 0xdd, 0xce, 0xc6, 0x58, 0xf1, 0x24, 0x69, 0x8c, 0x6d, 0x9e, 0xba, 0x61, 0xd1, 0x43, + 0xeb, 0xd7, 0x06, 0x14, 0x3f, 0xdb, 0x3d, 0x79, 0x95, 0x55, 0x28, 0xed, 0x17, 0xae, 0xd0, 0x7e, + 0xf1, 0x7a, 0xed, 0x97, 0x16, 0x68, 0xff, 0x03, 0x68, 0x27, 0x29, 0xf3, 0xd9, 0x20, 0x88, 0x98, + 0xef, 0xa0, 0xda, 0xa5, 0x8d, 0xb4, 0xa6, 0xd0, 0x6d, 0x2f, 0xc4, 0x02, 0xdf, 0x43, 0x40, 0x24, + 0x02, 0x37, 0xe4, 0xe4, 0x34, 0xca, 0x62, 0x3a, 0x39, 0x38, 0xba, 0x85, 0x35, 0x82, 0x2e, 0xf9, + 0xcd, 0xee, 0x98, 0x8b, 0x78, 0x44, 0x35, 0x09, 0xee, 0x32, 0xad, 0x6f, 0xb2, 0x0a, 0xb3, 0x6e, + 0xb7, 0xa6, 0x50, 0x24, 0x7b, 0x00, 0xab, 0xb3, 0x64, 0x4e, 0xae, 0xd9, 0xaa, 0xdb, 0x2b, 0x33, + 0xd4, 0x27, 0x84, 0xc2, 0x30, 0xd6, 0x9d, 0xf7, 0xd3, 0xdf, 0xbe, 0x18, 0xdf, 0x83, 0xa6, 0xeb, + 0x79, 0xf1, 0x38, 0x12, 0x0e, 0xc5, 0x7b, 0x29, 0xc4, 0x86, 0x82, 0x3d, 0xc3, 0xb0, 0x7f, 0x0b, + 0x80, 0x0f, 0xdd, 0x94, 0xc9, 0x62, 0x4a, 0x0a, 0xaf, 0x2e, 0x21, 0x78, 0xf6, 0xa9, 0x8b, 0xf1, + 0xe0, 0x6c, 0xd6, 0xc5, 0x4e, 0x82, 0x33, 0x54, 0x40, 0x4e, 0x34, 0xdc, 0x8b, 0x13, 0xa6, 0x3d, + 0x6c, 0x0a, 0x3f, 0x41, 0xb0, 0xf9, 0xe9, 0x25, 0x61, 0xc3, 0x82, 0xb0, 0x96, 0x53, 0xcf, 0x9c, + 0x1a, 0xac, 0x3f, 0x31, 0xa0, 0xb2, 0x23, 0x85, 0xf2, 0x7a, 0x51, 0xaa, 0x78, 0x45, 0x94, 0x2a, + 0x5d, 0x21, 0xe0, 0xf2, 0xf5, 0x02, 0xae, 0x5c, 0x16, 0x30, 0xb6, 0x04, 0xcd, 0x7c, 0xd0, 0x37, + 0xef, 0x65, 0xbb, 0x18, 0xaa, 0x1a, 0xd7, 0x55, 0x05, 0x41, 0xb3, 0x5d, 0xef, 0x42, 0x4b, 0xfb, + 0x9f, 0x54, 0x8d, 0xd4, 0x7a, 0x53, 0x03, 0x49, 0x37, 0x3f, 0x85, 0xb2, 0x2b, 0x44, 0xaa, 0xbb, + 0xa6, 0x3b, 0x8b, 0xd2, 0xcc, 0xd6, 0x36, 0x52, 0xec, 0x47, 0x22, 0xbd, 0xb0, 0x25, 0xf5, 0xda, + 0xc7, 0x00, 0x53, 0x20, 0x86, 0xcd, 0xa9, 0x65, 0xe3, 0x5f, 0xec, 0x75, 0x27, 0x6e, 0x38, 0xd6, + 0x7b, 0xca, 0xc1, 0xef, 0x14, 0x3e, 0x36, 0xac, 0xdb, 0x50, 0xc2, 0x74, 0x24, 0x65, 0x38, 0x8a, + 0x85, 0xee, 0xf5, 0xd4, 0xc8, 0xfa, 0x07, 0x03, 0xda, 0x73, 0x2f, 0x16, 0x77, 0xf5, 0x8b, 0x82, + 0x31, 0x9b, 0x78, 0x67, 0x1e, 0x14, 0xbe, 0x5f, 0x2d, 0xff, 0x3a, 0xf7, 0xf8, 0x73, 0xd7, 0xbf, + 0xe5, 0xd7, 0xba, 0xfe, 0xb5, 0xee, 0x63, 0x3f, 0xc8, 0xdc, 0x68, 0xda, 0x8c, 0xcc, 0xd4, 0x78, + 0xc6, 0x6c, 0x8d, 0x67, 0x1d, 0x43, 0x27, 0x23, 0x7f, 0x93, 0x63, 0xf7, 0xa0, 0xca, 0xc7, 0xe4, + 0x2b, 0x74, 0xe8, 0x9a, 0xad, 0x87, 0xd6, 0xc7, 0xd0, 0x56, 0xaf, 0x3a, 0x9a, 0x81, 0x7b, 0xd0, + 0xe1, 0xee, 0x84, 0x39, 0x22, 0x76, 0xf2, 0xe5, 0x5f, 0xcd, 0x6e, 0x21, 0xf8, 0x34, 0x56, 0x31, + 0xc4, 0xfa, 0x6b, 0x03, 0x3a, 0xd9, 0xd4, 0x37, 0xd4, 0xc1, 0xf4, 0x84, 0x85, 0xb9, 0x2a, 0xf6, + 0x47, 0x60, 0x7a, 0x71, 0x18, 0x62, 0xd2, 0xa1, 0x67, 0x11, 0x8a, 0x0f, 0xaa, 0x66, 0xec, 0x2a, + 0x0c, 0x8a, 0x7d, 0x17, 0xe1, 0x98, 0x58, 0x67, 0xa8, 0xe9, 0x46, 0x52, 0x36, 0x5a, 0x9d, 0x1c, + 0xf1, 0x49, 0xf0, 0x35, 0xb3, 0x56, 0x60, 0x79, 0x77, 0xc8, 0xbc, 0xf3, 0x6d, 0x7f, 0x14, 0x44, + 0xea, 0xb0, 0xd6, 0x37, 0x06, 0x98, 0x79, 0xe8, 0x9b, 0x9c, 0xe3, 0x75, 0x9f, 0xba, 0x36, 0x61, + 0x79, 0xe8, 0x72, 0x27, 0x61, 0x91, 0x1f, 0x44, 0x67, 0x8e, 0x8b, 0x3b, 0xd1, 0x89, 0x6a, 0x76, + 0x67, 0xe8, 0xf2, 0x63, 0x09, 0x27, 0x06, 0xac, 0x7f, 0x32, 0xe0, 0xd6, 0xbe, 0xca, 0xc0, 0x4a, + 0xd0, 0x36, 0x43, 0x35, 0x64, 0xea, 0x59, 0xd0, 0xd0, 0x19, 0x6f, 0xd4, 0xd0, 0xdd, 0x81, 0x86, + 0xca, 0xea, 0x39, 0x77, 0x07, 0x09, 0x7a, 0xa6, 0xea, 0xef, 0x54, 0xee, 0x29, 0x29, 0x64, 0xf4, + 0x6a, 0x28, 0x18, 0x91, 0x7c, 0x00, 0x6d, 0x6a, 0x25, 0x22, 0xe1, 0x84, 0x2c, 0x3a, 0x13, 0x43, + 0x25, 0xf4, 0x96, 0x82, 0x1e, 0x11, 0xd0, 0x5a, 0x87, 0xdb, 0x57, 0x1d, 0x46, 0x0a, 0xda, 0xfa, + 0x0b, 0x03, 0xd6, 0xe6, 0x48, 0x4e, 0xdc, 0xc9, 0x6f, 0xf1, 0xb0, 0x97, 0x4f, 0x52, 0x5c, 0x74, + 0x92, 0x5b, 0xf0, 0xce, 0x42, 0x36, 0xd5, 0x31, 0xfe, 0x58, 0xdd, 0x6d, 0xfb, 0xae, 0x70, 0xcd, + 0x4d, 0x1d, 0x2d, 0x8c, 0xd9, 0x2b, 0xa6, 0x3d, 0x75, 0x47, 0x4d, 0x0d, 0xa9, 0x8a, 0x1a, 0x8f, + 0xa0, 0x41, 0x86, 0x7b, 0x96, 0xc6, 0xe3, 0x44, 0x5f, 0x28, 0xaf, 0xce, 0xcf, 0xf8, 0x0c, 0xb1, + 0x36, 0xbd, 0x13, 0xd2, 0x5f, 0x2e, 0x3b, 0x2d, 0xd4, 0x50, 0x76, 0x4f, 0x47, 0x4d, 0x18, 0x7a, + 0xd0, 0x1d, 0x40, 0x55, 0xc5, 0xe1, 0x84, 0xe5, 0xda, 0x2d, 0xd0, 0x20, 0xd9, 0x8a, 0x8d, 0xdc, + 0x97, 0x88, 0x93, 0x4a, 0x2b, 0x8f, 0xdc, 0x97, 0x0a, 0x1c, 0x44, 0x08, 0x2e, 0x2b, 0x70, 0x10, + 0x9d, 0x22, 0x87, 0xf4, 0x48, 0x9e, 0x05, 0xb6, 0xaa, 0x0a, 0x6c, 0xb9, 0xf7, 0x32, 0x1d, 0xd8, + 0x1a, 0xa3, 0xe9, 0xc0, 0xfa, 0x17, 0x03, 0x5a, 0x33, 0xfc, 0x2f, 0x2a, 0xf6, 0xcd, 0x9f, 0x43, + 0x67, 0x7a, 0xb5, 0x2f, 0x9b, 0xf8, 0xc2, 0x35, 0x52, 0x6b, 0x65, 0xf7, 0xfc, 0xd4, 0xa1, 0x4e, + 0x59, 0x2e, 0xe6, 0x59, 0xbe, 0xe2, 0x80, 0xf7, 0xa0, 0x83, 0xd4, 0x79, 0xe1, 0xc8, 0x93, 0xb6, + 0xa4, 0xeb, 0x6b, 0xf9, 0xdc, 0x84, 0x8a, 0x32, 0x05, 0xf9, 0xbe, 0xa2, 0x46, 0xd6, 0x7f, 0x95, + 0xa1, 0x99, 0xe7, 0x26, 0x77, 0xd9, 0x6d, 0xcc, 0x5c, 0x76, 0xeb, 0x83, 0x16, 0x72, 0x07, 0xdd, + 0x84, 0xe5, 0x68, 0x3c, 0xea, 0xb3, 0xd4, 0x89, 0x07, 0x0e, 0x8b, 0x44, 0x1a, 0x30, 0xc9, 0x75, + 0xd1, 0xee, 0x48, 0xc4, 0xf3, 0xc1, 0xbe, 0x04, 0xe7, 0x8e, 0x55, 0x5a, 0x7c, 0xac, 0x72, 0xfe, + 0x58, 0x73, 0xfa, 0xae, 0x5c, 0xd2, 0xf7, 0x3b, 0x50, 0x57, 0xb7, 0x73, 0x81, 0x4f, 0xea, 0x2b, + 0xda, 0x35, 0x09, 0x98, 0xbf, 0xdc, 0xaa, 0x5d, 0x9d, 0x10, 0xeb, 0x0b, 0xae, 0x35, 0xa7, 0x8f, + 0x41, 0xef, 0x43, 0x89, 0x7a, 0xf0, 0x06, 0x19, 0x47, 0x37, 0x9f, 0x1f, 0xa9, 0xd7, 0x26, 0x2c, + 0x2e, 0x17, 0x70, 0x07, 0x8d, 0x84, 0x5a, 0x91, 0x9a, 0x5d, 0x09, 0x38, 0x3d, 0xd4, 0xbf, 0x0d, + 0x35, 0xd9, 0xf1, 0xab, 0x36, 0xa4, 0x68, 0x57, 0x69, 0x7c, 0xe8, 0xe7, 0x94, 0xd1, 0xce, 0x2b, + 0xc3, 0xfc, 0xff, 0xb0, 0x86, 0x32, 0xea, 0xb3, 0x33, 0x92, 0x94, 0x13, 0x44, 0x8e, 0xcf, 0x06, + 0xee, 0x38, 0x14, 0x8e, 0x37, 0xa0, 0xc6, 0xa3, 0x64, 0xaf, 0x8e, 0x82, 0x68, 0x07, 0x09, 0x4e, + 0xf9, 0x61, 0xb4, 0x27, 0xb1, 0xbb, 0x03, 0x8a, 0x6f, 0xf4, 0x94, 0x1c, 0x0f, 0x06, 0x9c, 0x09, + 0xea, 0x42, 0x4a, 0x76, 0x83, 0x60, 0xcf, 0x09, 0x34, 0x25, 0x51, 0x7b, 0x2f, 0xe7, 0x48, 0x64, + 0x44, 0x58, 0x78, 0x05, 0x61, 0xbe, 0xe1, 0x5d, 0x57, 0xfe, 0xc1, 0x61, 0x65, 0xee, 0xc1, 0x61, + 0x03, 0xba, 0x4a, 0x6b, 0x53, 0xfd, 0xdc, 0x20, 0x25, 0xb4, 0x25, 0xfc, 0x44, 0x6b, 0xe9, 0x7d, + 0x68, 0xeb, 0xdb, 0x57, 0xa5, 0xac, 0x55, 0xa2, 0x53, 0x77, 0xb2, 0xfb, 0x52, 0x65, 0x8f, 0xa6, + 0x77, 0xb4, 0x49, 0xec, 0x0d, 0xd5, 0x33, 0xef, 0xca, 0x6c, 0xce, 0xda, 0x47, 0x54, 0x76, 0x4d, + 0x4b, 0x83, 0x42, 0x30, 0xb1, 0xbe, 0x35, 0x60, 0x39, 0x7f, 0x45, 0xb4, 0xaf, 0xf3, 0xf8, 0xd0, + 0x4d, 0x12, 0x16, 0x39, 0xae, 0xbe, 0xbb, 0xae, 0x49, 0xc0, 0x36, 0xdd, 0xa9, 0x52, 0x96, 0x74, + 0xbc, 0xd8, 0xd7, 0x71, 0xb7, 0x4e, 0x90, 0xdd, 0xd8, 0xc7, 0x04, 0x2b, 0xbf, 0xc4, 0x71, 0x46, + 0x8c, 0x73, 0x2c, 0x31, 0x64, 0x92, 0x69, 0x12, 0xf0, 0xa9, 0x84, 0xcd, 0x04, 0x39, 0xfd, 0x32, + 0x24, 0x83, 0x9c, 0xf5, 0x08, 0x4a, 0x27, 0x89, 0x4b, 0xb5, 0xb4, 0xd2, 0xa2, 0x64, 0x40, 0x8d, + 0x72, 0x66, 0x53, 0x98, 0xf1, 0xe1, 0x7d, 0x68, 0xe0, 0x3c, 0xfe, 0x7c, 0xa0, 0x9f, 0x75, 0x2f, + 0x85, 0x24, 0x0b, 0xca, 0x1c, 0x49, 0xe6, 0x1f, 0x1a, 0x71, 0x9e, 0x2d, 0x51, 0xd6, 0xb7, 0x45, + 0xe8, 0x1d, 0xc5, 0x67, 0x54, 0x5b, 0x8c, 0xfb, 0xa8, 0x56, 0xd7, 0x53, 0xb7, 0xd1, 0x6e, 0xf6, + 0x32, 0x6a, 0xcc, 0xbe, 0x8c, 0x4e, 0x7d, 0x50, 0xb2, 0x34, 0xf5, 0xc1, 0xb9, 0x47, 0x02, 0x73, + 0x1d, 0x9a, 0x41, 0x94, 0x8c, 0x85, 0x33, 0x13, 0xc5, 0x80, 0x60, 0x4f, 0xc9, 0xe7, 0xa7, 0x14, + 0xf9, 0x88, 0xad, 0x28, 0x28, 0x58, 0xdc, 0x83, 0x8e, 0x62, 0xcb, 0x19, 0xa4, 0xf1, 0x68, 0x1a, + 0x19, 0x5a, 0x0a, 0xfc, 0x38, 0x8d, 0x47, 0xa7, 0xf4, 0xcd, 0x90, 0xa6, 0x1b, 0x47, 0x22, 0x08, + 0x1d, 0xf5, 0xf2, 0x54, 0xb2, 0xdb, 0x0a, 0xfe, 0x05, 0x82, 0x4f, 0x39, 0x7a, 0x2f, 0xee, 0x36, + 0x8d, 0x13, 0x18, 0xa4, 0x54, 0x94, 0x40, 0x46, 0x73, 0x51, 0x62, 0xe4, 0xbe, 0x44, 0xc4, 0x3a, + 0x7d, 0x43, 0x04, 0x57, 0xc4, 0x84, 0x82, 0xb8, 0x98, 0x71, 0xfc, 0xc6, 0xac, 0xe3, 0xdf, 0x87, + 0x2a, 0x8f, 0xc7, 0xa9, 0xc7, 0x78, 0xaf, 0x39, 0xfb, 0xcc, 0x9a, 0x53, 0xa0, 0xad, 0x69, 0xac, + 0x3f, 0x84, 0x1b, 0x8b, 0x14, 0x62, 0x7e, 0x04, 0x25, 0x0a, 0x38, 0xb2, 0x6c, 0x58, 0x9f, 0xde, + 0xc6, 0x2d, 0x56, 0x9e, 0x4d, 0xd4, 0xe6, 0x7d, 0x68, 0x70, 0x2e, 0x9c, 0x78, 0x2c, 0x92, 0xb1, + 0x58, 0xfc, 0xe4, 0x0c, 0x9c, 0x8b, 0xe7, 0x12, 0x6f, 0xfd, 0x01, 0xac, 0x2e, 0x5a, 0x90, 0x9b, + 0x7b, 0xd0, 0xe6, 0x33, 0x10, 0x55, 0x13, 0xbc, 0x7b, 0x1d, 0x1f, 0xf6, 0xdc, 0x1c, 0xeb, 0xdb, + 0x02, 0x2c, 0x2b, 0xc2, 0xdd, 0xe9, 0xc9, 0xa8, 0x52, 0xd6, 0xa3, 0x4c, 0xc9, 0x86, 0xae, 0x94, + 0x35, 0x46, 0xe9, 0x79, 0x0b, 0x56, 0x72, 0xd4, 0x99, 0xaa, 0xa5, 0x29, 0x2e, 0x4f, 0x51, 0x5a, + 0xdb, 0xfa, 0x62, 0xb6, 0x98, 0xbb, 0x98, 0xc5, 0x70, 0x15, 0x8f, 0x46, 0x2c, 0x12, 0xba, 0xc9, + 0xcf, 0xc6, 0xe6, 0xbb, 0x50, 0x77, 0x53, 0x11, 0x0c, 0x5c, 0x4f, 0xe8, 0x6b, 0xb4, 0x29, 0x00, + 0xab, 0xac, 0x6c, 0xe0, 0x0c, 0x5d, 0xae, 0x53, 0x6b, 0x2b, 0x83, 0x1e, 0xb8, 0x7c, 0x68, 0xfe, + 0x00, 0x3a, 0x67, 0x2c, 0x62, 0xa9, 0x2b, 0x98, 0xaf, 0x5e, 0xfb, 0xe5, 0x25, 0x5b, 0x3b, 0x03, + 0x53, 0xf2, 0xb7, 0xfe, 0xde, 0x90, 0xf5, 0xd6, 0xbe, 0x1f, 0x88, 0x85, 0x4e, 0xfc, 0x00, 0x56, + 0x7d, 0x16, 0x32, 0xc1, 0x9c, 0xec, 0xb9, 0x7c, 0xfa, 0xf5, 0x40, 0xdd, 0x5e, 0x91, 0xc8, 0x63, + 0x85, 0x93, 0x5f, 0x0e, 0x3c, 0x81, 0x1b, 0x6a, 0x4e, 0x18, 0x9f, 0xe5, 0xa6, 0xc8, 0x9e, 0xf7, + 0xed, 0xac, 0x20, 0x21, 0x9a, 0xbc, 0x11, 0x9a, 0x72, 0xda, 0x91, 0x9c, 0x25, 0x17, 0xbb, 0x0b, + 0x2d, 0x9f, 0x71, 0x91, 0x8e, 0x3d, 0xe1, 0x70, 0x16, 0x0e, 0xd4, 0x37, 0x6b, 0x4d, 0x0d, 0x3c, + 0x61, 0xe1, 0xc0, 0x7a, 0x01, 0xcb, 0x97, 0x56, 0xfb, 0xbe, 0x31, 0x09, 0x2b, 0x8c, 0x17, 0xc3, + 0x58, 0x5e, 0x9b, 0xb3, 0xd9, 0x62, 0xb6, 0x43, 0x08, 0x5c, 0x5d, 0x95, 0xb3, 0x7f, 0x67, 0x40, + 0xfd, 0x69, 0x70, 0x96, 0xd2, 0x07, 0x42, 0xe6, 0x7d, 0xa8, 0x33, 0x3f, 0x10, 0x8e, 0x72, 0x94, + 0xe2, 0xfc, 0xf7, 0x50, 0x28, 0x65, 0xbb, 0x86, 0x24, 0x14, 0xdf, 0xde, 0x83, 0xa6, 0x48, 0xc7, + 0x91, 0x47, 0x5a, 0x12, 0xb1, 0xb2, 0xa1, 0x46, 0x06, 0x3b, 0x8d, 0xcd, 0x4f, 0xa0, 0x91, 0x37, + 0xfa, 0x39, 0x09, 0x5e, 0xb2, 0x65, 0x3b, 0x4f, 0x8d, 0x56, 0x90, 0x89, 0x2e, 0xbb, 0xb6, 0x45, + 0xad, 0xb5, 0x35, 0xf8, 0x98, 0xa0, 0x9b, 0xcf, 0x60, 0xfd, 0x55, 0x5f, 0x50, 0x9a, 0x1d, 0x68, + 0x7c, 0x41, 0x57, 0xfc, 0xf4, 0xa1, 0x60, 0x77, 0xc9, 0x6c, 0x41, 0xfd, 0x17, 0x6e, 0x20, 0xb6, + 0x93, 0x24, 0xbc, 0xe8, 0x1a, 0x26, 0x40, 0xe5, 0x71, 0x10, 0x05, 0x7c, 0xd8, 0x2d, 0x6c, 0x7e, + 0x0e, 0xb7, 0xaf, 0xff, 0xc2, 0xd1, 0x5c, 0x86, 0x56, 0x36, 0x79, 0x2f, 0x8e, 0x70, 0xbd, 0x55, + 0x58, 0xce, 0x6d, 0x20, 0xbf, 0x05, 0xeb, 0x1a, 0x9b, 0xbf, 0x0b, 0x9d, 0xb9, 0xf4, 0x6f, 0x36, + 0xa0, 0xfa, 0xc5, 0xb3, 0x27, 0xcf, 0x9e, 0xff, 0xe2, 0x59, 0x77, 0xc9, 0xac, 0x42, 0xf1, 0xe8, + 0xab, 0x8f, 0x24, 0x03, 0x27, 0xcf, 0xb6, 0x8f, 0x8f, 0x7f, 0xbf, 0x5b, 0x30, 0x6b, 0x50, 0xfa, + 0xea, 0xe4, 0x74, 0xaf, 0x5b, 0xdc, 0x5c, 0xcf, 0x3e, 0x64, 0xc4, 0x6c, 0x59, 0x83, 0xd2, 0xc9, + 0xee, 0x36, 0x4e, 0xab, 0x41, 0xe9, 0xf1, 0xe1, 0xd1, 0x7e, 0xd7, 0xd8, 0xbc, 0x05, 0x8d, 0x5c, + 0xed, 0x6d, 0x56, 0xa0, 0xf0, 0xe5, 0x4f, 0xba, 0x4b, 0xf4, 0xfb, 0xa0, 0x6b, 0x6c, 0xde, 0x81, + 0x9a, 0x8e, 0xb4, 0xb8, 0x85, 0x34, 0x33, 0xb9, 0xef, 0xf1, 0x58, 0x74, 0x8d, 0x07, 0xff, 0x5d, + 0x80, 0x8a, 0xdc, 0xc2, 0xfc, 0x04, 0xd4, 0xd7, 0xb2, 0xe6, 0xea, 0xdc, 0xa7, 0x2c, 0x52, 0x90, + 0x6b, 0x37, 0xe7, 0xc1, 0xaa, 0xed, 0x59, 0xfa, 0xd0, 0x30, 0x8f, 0x61, 0x85, 0x1a, 0xe8, 0x7c, + 0x1b, 0xfb, 0x3c, 0x31, 0x33, 0x65, 0x5f, 0xea, 0xb9, 0xd7, 0xd6, 0x16, 0xa1, 0x72, 0x2b, 0x0e, + 0x61, 0x75, 0xa1, 0x1a, 0xcc, 0xf7, 0x5f, 0xe7, 0xbb, 0xd9, 0xb5, 0x0f, 0x5e, 0x41, 0x25, 0x77, + 0xda, 0x30, 0x3e, 0x34, 0xcc, 0x9f, 0x43, 0x35, 0x91, 0x44, 0xe6, 0xcd, 0xb9, 0x59, 0x7a, 0xb5, + 0xb7, 0x2e, 0xc1, 0x35, 0xa7, 0x38, 0xdb, 0x93, 0x97, 0x31, 0x66, 0xee, 0x69, 0x3d, 0x7f, 0x99, + 0x33, 0x9d, 0x3d, 0x77, 0x6b, 0x63, 0x2d, 0x3d, 0xf8, 0x5b, 0x03, 0x3a, 0x73, 0x2d, 0xa5, 0xf9, + 0x15, 0x54, 0x55, 0x97, 0x6d, 0x66, 0xa7, 0xb8, 0xf6, 0x36, 0x60, 0xed, 0xde, 0xab, 0xc8, 0x32, + 0x6e, 0x7f, 0x0f, 0x4a, 0xdc, 0x9d, 0x30, 0xd3, 0xba, 0x62, 0x46, 0xae, 0xed, 0x5e, 0xbb, 0x7b, + 0x2d, 0x8d, 0x5e, 0x72, 0xe7, 0xde, 0xbf, 0xfd, 0x65, 0xcd, 0xf8, 0xf5, 0x77, 0xb7, 0x8d, 0xdf, + 0x7c, 0x77, 0xdb, 0xf8, 0xf7, 0xef, 0x6e, 0x1b, 0x7f, 0xfe, 0x1f, 0xb7, 0x97, 0xa0, 0x1b, 0xa7, + 0x67, 0x5b, 0x22, 0x38, 0x9f, 0x6c, 0x9d, 0x4f, 0xe8, 0xe3, 0xe8, 0x7e, 0x85, 0x7e, 0x1e, 0xfe, + 0x4f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x6c, 0xe1, 0x83, 0x91, 0xa0, 0x2d, 0x00, 0x00, +} + +// 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 + +// BackupClient is the client API for Backup service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type BackupClient interface { + Backup(ctx context.Context, in *BackupRequest, opts ...grpc.CallOption) (Backup_BackupClient, error) + // CheckPendingAdminOp used for snapshot backup. before we start snapshot for a TiKV. + // we need stop all schedule first and make sure all in-flight schedule has finished. + // this rpc check all pending conf change for leader. + CheckPendingAdminOp(ctx context.Context, in *CheckAdminRequest, opts ...grpc.CallOption) (Backup_CheckPendingAdminOpClient, error) + // PrepareSnapshotBackup is an advanced version of preparing snapshot backup. + // Check the defination of `PrepareSnapshotBackupRequest` for more. + PrepareSnapshotBackup(ctx context.Context, opts ...grpc.CallOption) (Backup_PrepareSnapshotBackupClient, error) + // prepare is used for file-copy backup. before we start the backup for a TiKV. + // we need invoke this function to generate the SST files map. or we get nothing to backup. + Prepare(ctx context.Context, in *PrepareRequest, opts ...grpc.CallOption) (*PrepareResponse, error) + // cleanup used for file-copy backup. after we finish the backup for a TiKV. + // we need clean some internel state. e.g. checkpoint, SST File maps + Cleanup(ctx context.Context, in *CleanupRequest, opts ...grpc.CallOption) (*CleanupResponse, error) +} + +type backupClient struct { + cc *grpc.ClientConn +} + +func NewBackupClient(cc *grpc.ClientConn) BackupClient { + return &backupClient{cc} +} + +func (c *backupClient) Backup(ctx context.Context, in *BackupRequest, opts ...grpc.CallOption) (Backup_BackupClient, error) { + stream, err := c.cc.NewStream(ctx, &_Backup_serviceDesc.Streams[0], "/backup.Backup/backup", opts...) + if 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 = encodeVarintBrpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 + x := &backupBackupClient{stream} + if err := x.ClientStream.SendMsg(in); err != nil { + return nil, err } - if m.Ty != 0 { - i = encodeVarintBrpb(dAtA, i, uint64(m.Ty)) - i-- - dAtA[i] = 0x8 + if err := x.ClientStream.CloseSend(); err != nil { + return nil, err } - return len(dAtA) - i, nil + return x, nil } -func (m *BackupMeta) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) +type Backup_BackupClient interface { + Recv() (*BackupResponse, error) + grpc.ClientStream +} + +type backupBackupClient struct { + grpc.ClientStream +} + +func (x *backupBackupClient) Recv() (*BackupResponse, error) { + m := new(BackupResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +func (c *backupClient) CheckPendingAdminOp(ctx context.Context, in *CheckAdminRequest, opts ...grpc.CallOption) (Backup_CheckPendingAdminOpClient, error) { + stream, err := c.cc.NewStream(ctx, &_Backup_serviceDesc.Streams[1], "/backup.Backup/CheckPendingAdminOp", opts...) if err != nil { return nil, err } - return dAtA[:n], nil + x := &backupCheckPendingAdminOpClient{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 } -func (m *BackupMeta) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +type Backup_CheckPendingAdminOpClient interface { + Recv() (*CheckAdminResponse, error) + grpc.ClientStream } -func (m *BackupMeta) 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 backupCheckPendingAdminOpClient struct { + grpc.ClientStream +} + +func (x *backupCheckPendingAdminOpClient) Recv() (*CheckAdminResponse, error) { + m := new(CheckAdminResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err } - if m.BackupSize != 0 { - i = encodeVarintBrpb(dAtA, i, uint64(m.BackupSize)) - i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0xc8 + return m, nil +} + +func (c *backupClient) PrepareSnapshotBackup(ctx context.Context, opts ...grpc.CallOption) (Backup_PrepareSnapshotBackupClient, error) { + stream, err := c.cc.NewStream(ctx, &_Backup_serviceDesc.Streams[2], "/backup.Backup/PrepareSnapshotBackup", opts...) + if err != nil { + return nil, err } - if len(m.Ranges) > 0 { - for iNdEx := len(m.Ranges) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.Ranges[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintBrpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0xc2 - } + x := &backupPrepareSnapshotBackupClient{stream} + return x, nil +} + +type Backup_PrepareSnapshotBackupClient interface { + Send(*PrepareSnapshotBackupRequest) error + Recv() (*PrepareSnapshotBackupResponse, error) + grpc.ClientStream +} + +type backupPrepareSnapshotBackupClient struct { + grpc.ClientStream +} + +func (x *backupPrepareSnapshotBackupClient) Send(m *PrepareSnapshotBackupRequest) error { + return x.ClientStream.SendMsg(m) +} + +func (x *backupPrepareSnapshotBackupClient) Recv() (*PrepareSnapshotBackupResponse, error) { + m := new(PrepareSnapshotBackupResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err } - if m.Mode != 0 { - i = encodeVarintBrpb(dAtA, i, uint64(m.Mode)) - i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0xb8 + return m, nil +} + +func (c *backupClient) Prepare(ctx context.Context, in *PrepareRequest, opts ...grpc.CallOption) (*PrepareResponse, error) { + out := new(PrepareResponse) + err := c.cc.Invoke(ctx, "/backup.Backup/prepare", in, out, opts...) + if err != nil { + return nil, err } - if len(m.DbMaps) > 0 { - for iNdEx := len(m.DbMaps) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.DbMaps[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintBrpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0xb2 - } - } - if m.IsTxnKv { - i-- - if m.IsTxnKv { - dAtA[i] = 1 - } else { - dAtA[i] = 0 - } - i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0xa8 + return out, nil +} + +func (c *backupClient) Cleanup(ctx context.Context, in *CleanupRequest, opts ...grpc.CallOption) (*CleanupResponse, error) { + out := new(CleanupResponse) + err := c.cc.Invoke(ctx, "/backup.Backup/cleanup", in, out, opts...) + if err != nil { + return nil, err } - if len(m.NewCollationsEnabled) > 0 { - i -= len(m.NewCollationsEnabled) - copy(dAtA[i:], m.NewCollationsEnabled) - i = encodeVarintBrpb(dAtA, i, uint64(len(m.NewCollationsEnabled))) - i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0xa2 + return out, nil +} + +// BackupServer is the server API for Backup service. +type BackupServer interface { + Backup(*BackupRequest, Backup_BackupServer) error + // CheckPendingAdminOp used for snapshot backup. before we start snapshot for a TiKV. + // we need stop all schedule first and make sure all in-flight schedule has finished. + // this rpc check all pending conf change for leader. + CheckPendingAdminOp(*CheckAdminRequest, Backup_CheckPendingAdminOpServer) error + // PrepareSnapshotBackup is an advanced version of preparing snapshot backup. + // Check the defination of `PrepareSnapshotBackupRequest` for more. + PrepareSnapshotBackup(Backup_PrepareSnapshotBackupServer) error + // prepare is used for file-copy backup. before we start the backup for a TiKV. + // we need invoke this function to generate the SST files map. or we get nothing to backup. + Prepare(context.Context, *PrepareRequest) (*PrepareResponse, error) + // cleanup used for file-copy backup. after we finish the backup for a TiKV. + // we need clean some internel state. e.g. checkpoint, SST File maps + Cleanup(context.Context, *CleanupRequest) (*CleanupResponse, error) +} + +// UnimplementedBackupServer can be embedded to have forward compatible implementations. +type UnimplementedBackupServer struct { +} + +func (*UnimplementedBackupServer) Backup(req *BackupRequest, srv Backup_BackupServer) error { + return status.Errorf(codes.Unimplemented, "method Backup not implemented") +} +func (*UnimplementedBackupServer) CheckPendingAdminOp(req *CheckAdminRequest, srv Backup_CheckPendingAdminOpServer) error { + return status.Errorf(codes.Unimplemented, "method CheckPendingAdminOp not implemented") +} +func (*UnimplementedBackupServer) PrepareSnapshotBackup(srv Backup_PrepareSnapshotBackupServer) error { + return status.Errorf(codes.Unimplemented, "method PrepareSnapshotBackup not implemented") +} +func (*UnimplementedBackupServer) Prepare(ctx context.Context, req *PrepareRequest) (*PrepareResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Prepare not implemented") +} +func (*UnimplementedBackupServer) Cleanup(ctx context.Context, req *CleanupRequest) (*CleanupResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Cleanup not implemented") +} + +func RegisterBackupServer(s *grpc.Server, srv BackupServer) { + s.RegisterService(&_Backup_serviceDesc, srv) +} + +func _Backup_Backup_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(BackupRequest) + if err := stream.RecvMsg(m); err != nil { + return err } - if len(m.Policies) > 0 { - for iNdEx := len(m.Policies) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.Policies[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintBrpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0x9a - } + return srv.(BackupServer).Backup(m, &backupBackupServer{stream}) +} + +type Backup_BackupServer interface { + Send(*BackupResponse) error + grpc.ServerStream +} + +type backupBackupServer struct { + grpc.ServerStream +} + +func (x *backupBackupServer) Send(m *BackupResponse) error { + return x.ServerStream.SendMsg(m) +} + +func _Backup_CheckPendingAdminOp_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(CheckAdminRequest) + if err := stream.RecvMsg(m); err != nil { + return err } - if m.ApiVersion != 0 { - i = encodeVarintBrpb(dAtA, i, uint64(m.ApiVersion)) - i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0x90 + return srv.(BackupServer).CheckPendingAdminOp(m, &backupCheckPendingAdminOpServer{stream}) +} + +type Backup_CheckPendingAdminOpServer interface { + Send(*CheckAdminResponse) error + grpc.ServerStream +} + +type backupCheckPendingAdminOpServer struct { + grpc.ServerStream +} + +func (x *backupCheckPendingAdminOpServer) Send(m *CheckAdminResponse) error { + return x.ServerStream.SendMsg(m) +} + +func _Backup_PrepareSnapshotBackup_Handler(srv interface{}, stream grpc.ServerStream) error { + return srv.(BackupServer).PrepareSnapshotBackup(&backupPrepareSnapshotBackupServer{stream}) +} + +type Backup_PrepareSnapshotBackupServer interface { + Send(*PrepareSnapshotBackupResponse) error + Recv() (*PrepareSnapshotBackupRequest, error) + grpc.ServerStream +} + +type backupPrepareSnapshotBackupServer struct { + grpc.ServerStream +} + +func (x *backupPrepareSnapshotBackupServer) Send(m *PrepareSnapshotBackupResponse) error { + return x.ServerStream.SendMsg(m) +} + +func (x *backupPrepareSnapshotBackupServer) Recv() (*PrepareSnapshotBackupRequest, error) { + m := new(PrepareSnapshotBackupRequest) + if err := x.ServerStream.RecvMsg(m); err != nil { + return nil, err } - if len(m.BackupResult) > 0 { - i -= len(m.BackupResult) - copy(dAtA[i:], m.BackupResult) - i = encodeVarintBrpb(dAtA, i, uint64(len(m.BackupResult))) - i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0x8a + return m, nil +} + +func _Backup_Prepare_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(PrepareRequest) + if err := dec(in); err != nil { + return nil, err } - if m.DdlIndexes != nil { - { - size, err := m.DdlIndexes.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintBrpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0x82 + if interceptor == nil { + return srv.(BackupServer).Prepare(ctx, in) } - if m.RawRangeIndex != nil { - { - size, err := m.RawRangeIndex.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintBrpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x7a + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/backup.Backup/Prepare", } - if m.SchemaIndex != nil { - { - size, err := m.SchemaIndex.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintBrpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x72 + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(BackupServer).Prepare(ctx, req.(*PrepareRequest)) } - if m.FileIndex != nil { - { - size, err := m.FileIndex.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintBrpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x6a + return interceptor(ctx, in, info, handler) +} + +func _Backup_Cleanup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(CleanupRequest) + if err := dec(in); err != nil { + return nil, err } - if m.Version != 0 { - i = encodeVarintBrpb(dAtA, i, uint64(m.Version)) - i-- - dAtA[i] = 0x60 + if interceptor == nil { + return srv.(BackupServer).Cleanup(ctx, in) } - if len(m.BrVersion) > 0 { - i -= len(m.BrVersion) - copy(dAtA[i:], m.BrVersion) - i = encodeVarintBrpb(dAtA, i, uint64(len(m.BrVersion))) - i-- - dAtA[i] = 0x5a + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/backup.Backup/Cleanup", } - if len(m.Ddls) > 0 { - i -= len(m.Ddls) - copy(dAtA[i:], m.Ddls) - i = encodeVarintBrpb(dAtA, i, uint64(len(m.Ddls))) - i-- - dAtA[i] = 0x52 + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(BackupServer).Cleanup(ctx, req.(*CleanupRequest)) } - if len(m.RawRanges) > 0 { - for iNdEx := len(m.RawRanges) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.RawRanges[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintBrpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x4a - } + return interceptor(ctx, in, info, handler) +} + +var _Backup_serviceDesc = grpc.ServiceDesc{ + ServiceName: "backup.Backup", + HandlerType: (*BackupServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "prepare", + Handler: _Backup_Prepare_Handler, + }, + { + MethodName: "cleanup", + Handler: _Backup_Cleanup_Handler, + }, + }, + Streams: []grpc.StreamDesc{ + { + StreamName: "backup", + Handler: _Backup_Backup_Handler, + ServerStreams: true, + }, + { + StreamName: "CheckPendingAdminOp", + Handler: _Backup_CheckPendingAdminOp_Handler, + ServerStreams: true, + }, + { + StreamName: "PrepareSnapshotBackup", + Handler: _Backup_PrepareSnapshotBackup_Handler, + ServerStreams: true, + ClientStreams: true, + }, + }, + Metadata: "brpb.proto", +} + +// ExternalStorageClient is the client API for ExternalStorage service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type ExternalStorageClient interface { + // Restore to a file + Restore(ctx context.Context, in *ExternalStorageRestoreRequest, opts ...grpc.CallOption) (*ExternalStorageRestoreResponse, error) + // Save a file to storage + Save(ctx context.Context, in *ExternalStorageSaveRequest, opts ...grpc.CallOption) (*ExternalStorageSaveResponse, error) +} + +type externalStorageClient struct { + cc *grpc.ClientConn +} + +func NewExternalStorageClient(cc *grpc.ClientConn) ExternalStorageClient { + return &externalStorageClient{cc} +} + +func (c *externalStorageClient) Restore(ctx context.Context, in *ExternalStorageRestoreRequest, opts ...grpc.CallOption) (*ExternalStorageRestoreResponse, error) { + out := new(ExternalStorageRestoreResponse) + err := c.cc.Invoke(ctx, "/backup.ExternalStorage/restore", in, out, opts...) + if err != nil { + return nil, err } - if m.IsRawKv { - i-- - if m.IsRawKv { - dAtA[i] = 1 - } else { - dAtA[i] = 0 - } - i-- - dAtA[i] = 0x40 + return out, nil +} + +func (c *externalStorageClient) Save(ctx context.Context, in *ExternalStorageSaveRequest, opts ...grpc.CallOption) (*ExternalStorageSaveResponse, error) { + out := new(ExternalStorageSaveResponse) + err := c.cc.Invoke(ctx, "/backup.ExternalStorage/save", in, out, opts...) + if err != nil { + return nil, err } - if len(m.Schemas) > 0 { - for iNdEx := len(m.Schemas) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.Schemas[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintBrpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x3a - } + return out, nil +} + +// ExternalStorageServer is the server API for ExternalStorage service. +type ExternalStorageServer interface { + // Restore to a file + Restore(context.Context, *ExternalStorageRestoreRequest) (*ExternalStorageRestoreResponse, error) + // Save a file to storage + Save(context.Context, *ExternalStorageSaveRequest) (*ExternalStorageSaveResponse, error) +} + +// UnimplementedExternalStorageServer can be embedded to have forward compatible implementations. +type UnimplementedExternalStorageServer struct { +} + +func (*UnimplementedExternalStorageServer) Restore(ctx context.Context, req *ExternalStorageRestoreRequest) (*ExternalStorageRestoreResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Restore not implemented") +} +func (*UnimplementedExternalStorageServer) Save(ctx context.Context, req *ExternalStorageSaveRequest) (*ExternalStorageSaveResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Save not implemented") +} + +func RegisterExternalStorageServer(s *grpc.Server, srv ExternalStorageServer) { + s.RegisterService(&_ExternalStorage_serviceDesc, srv) +} + +func _ExternalStorage_Restore_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ExternalStorageRestoreRequest) + if err := dec(in); err != nil { + return nil, err } - if m.EndVersion != 0 { - i = encodeVarintBrpb(dAtA, i, uint64(m.EndVersion)) - i-- - dAtA[i] = 0x30 + if interceptor == nil { + return srv.(ExternalStorageServer).Restore(ctx, in) } - if m.StartVersion != 0 { - i = encodeVarintBrpb(dAtA, i, uint64(m.StartVersion)) - i-- - dAtA[i] = 0x28 + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/backup.ExternalStorage/Restore", } - if len(m.Files) > 0 { - for iNdEx := len(m.Files) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.Files[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintBrpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x22 - } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ExternalStorageServer).Restore(ctx, req.(*ExternalStorageRestoreRequest)) } - if len(m.ClusterVersion) > 0 { - i -= len(m.ClusterVersion) - copy(dAtA[i:], m.ClusterVersion) - i = encodeVarintBrpb(dAtA, i, uint64(len(m.ClusterVersion))) - i-- - dAtA[i] = 0x12 + return interceptor(ctx, in, info, handler) +} + +func _ExternalStorage_Save_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ExternalStorageSaveRequest) + if err := dec(in); err != nil { + return nil, err } - if m.ClusterId != 0 { - i = encodeVarintBrpb(dAtA, i, uint64(m.ClusterId)) - i-- - dAtA[i] = 0x8 + if interceptor == nil { + return srv.(ExternalStorageServer).Save(ctx, in) } - return len(dAtA) - i, nil + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/backup.ExternalStorage/Save", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ExternalStorageServer).Save(ctx, req.(*ExternalStorageSaveRequest)) + } + return interceptor(ctx, in, info, handler) } -func (m *BackupRange) Marshal() (dAtA []byte, err error) { +var _ExternalStorage_serviceDesc = grpc.ServiceDesc{ + ServiceName: "backup.ExternalStorage", + HandlerType: (*ExternalStorageServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "restore", + Handler: _ExternalStorage_Restore_Handler, + }, + { + MethodName: "save", + Handler: _ExternalStorage_Save_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "brpb.proto", +} + +func (m *PrepareSnapshotBackupRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -5163,12 +5547,12 @@ func (m *BackupRange) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *BackupRange) MarshalTo(dAtA []byte) (int, error) { +func (m *PrepareSnapshotBackupRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *BackupRange) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *PrepareSnapshotBackupRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -5177,10 +5561,15 @@ func (m *BackupRange) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if len(m.Files) > 0 { - for iNdEx := len(m.Files) - 1; iNdEx >= 0; iNdEx-- { + if m.LeaseInSeconds != 0 { + i = encodeVarintBrpb(dAtA, i, uint64(m.LeaseInSeconds)) + i-- + dAtA[i] = 0x18 + } + if len(m.Regions) > 0 { + for iNdEx := len(m.Regions) - 1; iNdEx >= 0; iNdEx-- { { - size, err := m.Files[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Regions[iNdEx].MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -5188,27 +5577,18 @@ func (m *BackupRange) MarshalToSizedBuffer(dAtA []byte) (int, error) { i = encodeVarintBrpb(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0x1a + dAtA[i] = 0x12 } } - if len(m.EndKey) > 0 { - i -= len(m.EndKey) - copy(dAtA[i:], m.EndKey) - i = encodeVarintBrpb(dAtA, i, uint64(len(m.EndKey))) - i-- - dAtA[i] = 0x12 - } - if len(m.StartKey) > 0 { - i -= len(m.StartKey) - copy(dAtA[i:], m.StartKey) - i = encodeVarintBrpb(dAtA, i, uint64(len(m.StartKey))) + if m.Ty != 0 { + i = encodeVarintBrpb(dAtA, i, uint64(m.Ty)) i-- - dAtA[i] = 0xa + dAtA[i] = 0x8 } return len(dAtA) - i, nil } -func (m *File) Marshal() (dAtA []byte, err error) { +func (m *PrepareSnapshotBackupResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -5218,12 +5598,12 @@ func (m *File) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *File) MarshalTo(dAtA []byte) (int, error) { +func (m *PrepareSnapshotBackupResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *File) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *PrepareSnapshotBackupResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -5232,82 +5612,49 @@ func (m *File) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if len(m.CipherIv) > 0 { - i -= len(m.CipherIv) - copy(dAtA[i:], m.CipherIv) - i = encodeVarintBrpb(dAtA, i, uint64(len(m.CipherIv))) - i-- - dAtA[i] = 0x62 - } - if m.Size_ != 0 { - i = encodeVarintBrpb(dAtA, i, uint64(m.Size_)) + if m.LastLeaseIsValid { i-- - dAtA[i] = 0x58 - } - if len(m.Cf) > 0 { - i -= len(m.Cf) - copy(dAtA[i:], m.Cf) - i = encodeVarintBrpb(dAtA, i, uint64(len(m.Cf))) - i-- - dAtA[i] = 0x52 - } - if m.TotalBytes != 0 { - i = encodeVarintBrpb(dAtA, i, uint64(m.TotalBytes)) - i-- - dAtA[i] = 0x48 - } - if m.TotalKvs != 0 { - i = encodeVarintBrpb(dAtA, i, uint64(m.TotalKvs)) - i-- - dAtA[i] = 0x40 - } - if m.Crc64Xor != 0 { - i = encodeVarintBrpb(dAtA, i, uint64(m.Crc64Xor)) - i-- - dAtA[i] = 0x38 - } - if m.EndVersion != 0 { - i = encodeVarintBrpb(dAtA, i, uint64(m.EndVersion)) - i-- - dAtA[i] = 0x30 - } - if m.StartVersion != 0 { - i = encodeVarintBrpb(dAtA, i, uint64(m.StartVersion)) - i-- - dAtA[i] = 0x28 - } - if len(m.EndKey) > 0 { - i -= len(m.EndKey) - copy(dAtA[i:], m.EndKey) - i = encodeVarintBrpb(dAtA, i, uint64(len(m.EndKey))) + if m.LastLeaseIsValid { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } i-- - dAtA[i] = 0x22 + dAtA[i] = 0x20 } - if len(m.StartKey) > 0 { - i -= len(m.StartKey) - copy(dAtA[i:], m.StartKey) - i = encodeVarintBrpb(dAtA, i, uint64(len(m.StartKey))) + if m.Error != nil { + { + size, err := m.Error.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintBrpb(dAtA, i, uint64(size)) + } i-- dAtA[i] = 0x1a } - if len(m.Sha256) > 0 { - i -= len(m.Sha256) - copy(dAtA[i:], m.Sha256) - i = encodeVarintBrpb(dAtA, i, uint64(len(m.Sha256))) + if m.Region != nil { + { + size, err := m.Region.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintBrpb(dAtA, i, uint64(size)) + } i-- dAtA[i] = 0x12 } - if len(m.Name) > 0 { - i -= len(m.Name) - copy(dAtA[i:], m.Name) - i = encodeVarintBrpb(dAtA, i, uint64(len(m.Name))) + if m.Ty != 0 { + i = encodeVarintBrpb(dAtA, i, uint64(m.Ty)) i-- - dAtA[i] = 0xa + dAtA[i] = 0x8 } return len(dAtA) - i, nil } -func (m *MetaFile) Marshal() (dAtA []byte, err error) { +func (m *BackupMeta) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -5317,12 +5664,12 @@ func (m *MetaFile) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *MetaFile) MarshalTo(dAtA []byte) (int, error) { +func (m *BackupMeta) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MetaFile) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *BackupMeta) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -5331,10 +5678,17 @@ func (m *MetaFile) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if len(m.BackupRanges) > 0 { - for iNdEx := len(m.BackupRanges) - 1; iNdEx >= 0; iNdEx-- { + if m.BackupSize != 0 { + i = encodeVarintBrpb(dAtA, i, uint64(m.BackupSize)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xc8 + } + if len(m.Ranges) > 0 { + for iNdEx := len(m.Ranges) - 1; iNdEx >= 0; iNdEx-- { { - size, err := m.BackupRanges[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Ranges[iNdEx].MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -5342,22 +5696,22 @@ func (m *MetaFile) MarshalToSizedBuffer(dAtA []byte) (int, error) { i = encodeVarintBrpb(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0x32 - } - } - if len(m.Ddls) > 0 { - for iNdEx := len(m.Ddls) - 1; iNdEx >= 0; iNdEx-- { - i -= len(m.Ddls[iNdEx]) - copy(dAtA[i:], m.Ddls[iNdEx]) - i = encodeVarintBrpb(dAtA, i, uint64(len(m.Ddls[iNdEx]))) + dAtA[i] = 0x1 i-- - dAtA[i] = 0x2a + dAtA[i] = 0xc2 } } - if len(m.RawRanges) > 0 { - for iNdEx := len(m.RawRanges) - 1; iNdEx >= 0; iNdEx-- { + if m.Mode != 0 { + i = encodeVarintBrpb(dAtA, i, uint64(m.Mode)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xb8 + } + if len(m.DbMaps) > 0 { + for iNdEx := len(m.DbMaps) - 1; iNdEx >= 0; iNdEx-- { { - size, err := m.RawRanges[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + size, err := m.DbMaps[iNdEx].MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -5365,13 +5719,36 @@ func (m *MetaFile) MarshalToSizedBuffer(dAtA []byte) (int, error) { i = encodeVarintBrpb(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0x22 + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xb2 } } - if len(m.Schemas) > 0 { - for iNdEx := len(m.Schemas) - 1; iNdEx >= 0; iNdEx-- { + if m.IsTxnKv { + i-- + if m.IsTxnKv { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xa8 + } + if len(m.NewCollationsEnabled) > 0 { + i -= len(m.NewCollationsEnabled) + copy(dAtA[i:], m.NewCollationsEnabled) + i = encodeVarintBrpb(dAtA, i, uint64(len(m.NewCollationsEnabled))) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xa2 + } + if len(m.Policies) > 0 { + for iNdEx := len(m.Policies) - 1; iNdEx >= 0; iNdEx-- { { - size, err := m.Schemas[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Policies[iNdEx].MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -5379,27 +5756,100 @@ func (m *MetaFile) MarshalToSizedBuffer(dAtA []byte) (int, error) { i = encodeVarintBrpb(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0x1a + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x9a } } - if len(m.DataFiles) > 0 { - for iNdEx := len(m.DataFiles) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.DataFiles[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintBrpb(dAtA, i, uint64(size)) + if m.ApiVersion != 0 { + i = encodeVarintBrpb(dAtA, i, uint64(m.ApiVersion)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x90 + } + if len(m.BackupResult) > 0 { + i -= len(m.BackupResult) + copy(dAtA[i:], m.BackupResult) + i = encodeVarintBrpb(dAtA, i, uint64(len(m.BackupResult))) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x8a + } + if m.DdlIndexes != nil { + { + size, err := m.DdlIndexes.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err } - i-- - dAtA[i] = 0x12 + i -= size + i = encodeVarintBrpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x82 + } + if m.RawRangeIndex != nil { + { + size, err := m.RawRangeIndex.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintBrpb(dAtA, i, uint64(size)) } + i-- + dAtA[i] = 0x7a } - if len(m.MetaFiles) > 0 { - for iNdEx := len(m.MetaFiles) - 1; iNdEx >= 0; iNdEx-- { + if m.SchemaIndex != nil { + { + size, err := m.SchemaIndex.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintBrpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x72 + } + if m.FileIndex != nil { + { + size, err := m.FileIndex.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintBrpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x6a + } + if m.Version != 0 { + i = encodeVarintBrpb(dAtA, i, uint64(m.Version)) + i-- + dAtA[i] = 0x60 + } + if len(m.BrVersion) > 0 { + i -= len(m.BrVersion) + copy(dAtA[i:], m.BrVersion) + i = encodeVarintBrpb(dAtA, i, uint64(len(m.BrVersion))) + i-- + dAtA[i] = 0x5a + } + if len(m.Ddls) > 0 { + i -= len(m.Ddls) + copy(dAtA[i:], m.Ddls) + i = encodeVarintBrpb(dAtA, i, uint64(len(m.Ddls))) + i-- + dAtA[i] = 0x52 + } + if len(m.RawRanges) > 0 { + for iNdEx := len(m.RawRanges) - 1; iNdEx >= 0; iNdEx-- { { - size, err := m.MetaFiles[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + size, err := m.RawRanges[iNdEx].MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -5407,86 +5857,73 @@ func (m *MetaFile) MarshalToSizedBuffer(dAtA []byte) (int, error) { i = encodeVarintBrpb(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0xa + dAtA[i] = 0x4a } } - return len(dAtA) - i, nil -} - -func (m *PlacementPolicy) 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.IsRawKv { + i-- + if m.IsRawKv { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x40 } - return dAtA[:n], nil -} - -func (m *PlacementPolicy) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *PlacementPolicy) 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.Schemas) > 0 { + for iNdEx := len(m.Schemas) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Schemas[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintBrpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x3a + } } - if len(m.Info) > 0 { - i -= len(m.Info) - copy(dAtA[i:], m.Info) - i = encodeVarintBrpb(dAtA, i, uint64(len(m.Info))) + if m.EndVersion != 0 { + i = encodeVarintBrpb(dAtA, i, uint64(m.EndVersion)) i-- - dAtA[i] = 0xa + dAtA[i] = 0x30 } - return len(dAtA) - i, nil -} - -func (m *StatsBlock) 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.StartVersion != 0 { + i = encodeVarintBrpb(dAtA, i, uint64(m.StartVersion)) + i-- + dAtA[i] = 0x28 } - return dAtA[:n], nil -} - -func (m *StatsBlock) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *StatsBlock) 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.Files) > 0 { + for iNdEx := len(m.Files) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Files[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintBrpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } } - if len(m.JsonTable) > 0 { - i -= len(m.JsonTable) - copy(dAtA[i:], m.JsonTable) - i = encodeVarintBrpb(dAtA, i, uint64(len(m.JsonTable))) + if len(m.ClusterVersion) > 0 { + i -= len(m.ClusterVersion) + copy(dAtA[i:], m.ClusterVersion) + i = encodeVarintBrpb(dAtA, i, uint64(len(m.ClusterVersion))) i-- dAtA[i] = 0x12 } - if m.PhysicalId != 0 { - i = encodeVarintBrpb(dAtA, i, uint64(m.PhysicalId)) + if m.ClusterId != 0 { + i = encodeVarintBrpb(dAtA, i, uint64(m.ClusterId)) i-- dAtA[i] = 0x8 } return len(dAtA) - i, nil } -func (m *StatsFile) Marshal() (dAtA []byte, err error) { +func (m *BackupRange) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -5496,12 +5933,12 @@ func (m *StatsFile) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *StatsFile) MarshalTo(dAtA []byte) (int, error) { +func (m *BackupRange) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *StatsFile) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *BackupRange) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -5510,10 +5947,10 @@ func (m *StatsFile) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if len(m.Blocks) > 0 { - for iNdEx := len(m.Blocks) - 1; iNdEx >= 0; iNdEx-- { + if len(m.Files) > 0 { + for iNdEx := len(m.Files) - 1; iNdEx >= 0; iNdEx-- { { - size, err := m.Blocks[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Files[iNdEx].MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -5521,13 +5958,27 @@ func (m *StatsFile) MarshalToSizedBuffer(dAtA []byte) (int, error) { i = encodeVarintBrpb(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0xa + dAtA[i] = 0x1a } } + if len(m.EndKey) > 0 { + i -= len(m.EndKey) + copy(dAtA[i:], m.EndKey) + i = encodeVarintBrpb(dAtA, i, uint64(len(m.EndKey))) + i-- + dAtA[i] = 0x12 + } + if len(m.StartKey) > 0 { + i -= len(m.StartKey) + copy(dAtA[i:], m.StartKey) + i = encodeVarintBrpb(dAtA, i, uint64(len(m.StartKey))) + i-- + dAtA[i] = 0xa + } return len(dAtA) - i, nil } -func (m *StatsFileIndex) Marshal() (dAtA []byte, err error) { +func (m *File) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -5537,12 +5988,12 @@ func (m *StatsFileIndex) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *StatsFileIndex) MarshalTo(dAtA []byte) (int, error) { +func (m *File) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *StatsFileIndex) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *File) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -5551,29 +6002,63 @@ func (m *StatsFileIndex) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if len(m.InlineData) > 0 { - i -= len(m.InlineData) - copy(dAtA[i:], m.InlineData) - i = encodeVarintBrpb(dAtA, i, uint64(len(m.InlineData))) - i-- - dAtA[i] = 0x32 - } if len(m.CipherIv) > 0 { i -= len(m.CipherIv) copy(dAtA[i:], m.CipherIv) i = encodeVarintBrpb(dAtA, i, uint64(len(m.CipherIv))) i-- - dAtA[i] = 0x2a + dAtA[i] = 0x62 } - if m.SizeOri != 0 { - i = encodeVarintBrpb(dAtA, i, uint64(m.SizeOri)) + if m.Size_ != 0 { + i = encodeVarintBrpb(dAtA, i, uint64(m.Size_)) i-- - dAtA[i] = 0x20 + dAtA[i] = 0x58 } - if m.SizeEnc != 0 { - i = encodeVarintBrpb(dAtA, i, uint64(m.SizeEnc)) + if len(m.Cf) > 0 { + i -= len(m.Cf) + copy(dAtA[i:], m.Cf) + i = encodeVarintBrpb(dAtA, i, uint64(len(m.Cf))) i-- - dAtA[i] = 0x18 + dAtA[i] = 0x52 + } + if m.TotalBytes != 0 { + i = encodeVarintBrpb(dAtA, i, uint64(m.TotalBytes)) + i-- + dAtA[i] = 0x48 + } + if m.TotalKvs != 0 { + i = encodeVarintBrpb(dAtA, i, uint64(m.TotalKvs)) + i-- + dAtA[i] = 0x40 + } + if m.Crc64Xor != 0 { + i = encodeVarintBrpb(dAtA, i, uint64(m.Crc64Xor)) + i-- + dAtA[i] = 0x38 + } + if m.EndVersion != 0 { + i = encodeVarintBrpb(dAtA, i, uint64(m.EndVersion)) + i-- + dAtA[i] = 0x30 + } + if m.StartVersion != 0 { + i = encodeVarintBrpb(dAtA, i, uint64(m.StartVersion)) + i-- + dAtA[i] = 0x28 + } + if len(m.EndKey) > 0 { + i -= len(m.EndKey) + copy(dAtA[i:], m.EndKey) + i = encodeVarintBrpb(dAtA, i, uint64(len(m.EndKey))) + i-- + dAtA[i] = 0x22 + } + if len(m.StartKey) > 0 { + i -= len(m.StartKey) + copy(dAtA[i:], m.StartKey) + i = encodeVarintBrpb(dAtA, i, uint64(len(m.StartKey))) + i-- + dAtA[i] = 0x1a } if len(m.Sha256) > 0 { i -= len(m.Sha256) @@ -5592,7 +6077,7 @@ func (m *StatsFileIndex) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *Schema) Marshal() (dAtA []byte, err error) { +func (m *MetaFile) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -5602,12 +6087,12 @@ func (m *Schema) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *Schema) MarshalTo(dAtA []byte) (int, error) { +func (m *MetaFile) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *Schema) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *MetaFile) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -5616,10 +6101,10 @@ func (m *Schema) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if len(m.StatsIndex) > 0 { - for iNdEx := len(m.StatsIndex) - 1; iNdEx >= 0; iNdEx-- { + if len(m.BackupRanges) > 0 { + for iNdEx := len(m.BackupRanges) - 1; iNdEx >= 0; iNdEx-- { { - size, err := m.StatsIndex[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + size, err := m.BackupRanges[iNdEx].MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -5627,54 +6112,78 @@ func (m *Schema) MarshalToSizedBuffer(dAtA []byte) (int, error) { i = encodeVarintBrpb(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0x42 + dAtA[i] = 0x32 } } - if len(m.Stats) > 0 { - i -= len(m.Stats) - copy(dAtA[i:], m.Stats) - i = encodeVarintBrpb(dAtA, i, uint64(len(m.Stats))) - i-- - dAtA[i] = 0x3a + if len(m.Ddls) > 0 { + for iNdEx := len(m.Ddls) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Ddls[iNdEx]) + copy(dAtA[i:], m.Ddls[iNdEx]) + i = encodeVarintBrpb(dAtA, i, uint64(len(m.Ddls[iNdEx]))) + i-- + dAtA[i] = 0x2a + } } - if m.TiflashReplicas != 0 { - i = encodeVarintBrpb(dAtA, i, uint64(m.TiflashReplicas)) - i-- - dAtA[i] = 0x30 + if len(m.RawRanges) > 0 { + for iNdEx := len(m.RawRanges) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.RawRanges[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintBrpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } } - if m.TotalBytes != 0 { - i = encodeVarintBrpb(dAtA, i, uint64(m.TotalBytes)) - i-- - dAtA[i] = 0x28 - } - if m.TotalKvs != 0 { - i = encodeVarintBrpb(dAtA, i, uint64(m.TotalKvs)) - i-- - dAtA[i] = 0x20 - } - if m.Crc64Xor != 0 { - i = encodeVarintBrpb(dAtA, i, uint64(m.Crc64Xor)) - i-- - dAtA[i] = 0x18 + if len(m.Schemas) > 0 { + for iNdEx := len(m.Schemas) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Schemas[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintBrpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } } - if len(m.Table) > 0 { - i -= len(m.Table) - copy(dAtA[i:], m.Table) - i = encodeVarintBrpb(dAtA, i, uint64(len(m.Table))) - i-- - dAtA[i] = 0x12 + if len(m.DataFiles) > 0 { + for iNdEx := len(m.DataFiles) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.DataFiles[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintBrpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } } - if len(m.Db) > 0 { - i -= len(m.Db) - copy(dAtA[i:], m.Db) - i = encodeVarintBrpb(dAtA, i, uint64(len(m.Db))) - i-- - dAtA[i] = 0xa + if len(m.MetaFiles) > 0 { + for iNdEx := len(m.MetaFiles) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.MetaFiles[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintBrpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } } return len(dAtA) - i, nil } -func (m *IDMap) Marshal() (dAtA []byte, err error) { +func (m *PlacementPolicy) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -5684,12 +6193,12 @@ func (m *IDMap) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *IDMap) MarshalTo(dAtA []byte) (int, error) { +func (m *PlacementPolicy) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *IDMap) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *PlacementPolicy) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -5698,20 +6207,17 @@ func (m *IDMap) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if m.DownstreamId != 0 { - i = encodeVarintBrpb(dAtA, i, uint64(m.DownstreamId)) - i-- - dAtA[i] = 0x10 - } - if m.UpstreamId != 0 { - i = encodeVarintBrpb(dAtA, i, uint64(m.UpstreamId)) + if len(m.Info) > 0 { + i -= len(m.Info) + copy(dAtA[i:], m.Info) + i = encodeVarintBrpb(dAtA, i, uint64(len(m.Info))) i-- - dAtA[i] = 0x8 + dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *PitrTableMap) Marshal() (dAtA []byte, err error) { +func (m *StatsBlock) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -5721,12 +6227,12 @@ func (m *PitrTableMap) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *PitrTableMap) MarshalTo(dAtA []byte) (int, error) { +func (m *StatsBlock) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *PitrTableMap) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *StatsBlock) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -5735,43 +6241,22 @@ func (m *PitrTableMap) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if len(m.Partitions) > 0 { - for iNdEx := len(m.Partitions) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.Partitions[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintBrpb(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a - } - } - if m.IdMap != nil { - { - size, err := m.IdMap.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintBrpb(dAtA, i, uint64(size)) - } + if len(m.JsonTable) > 0 { + i -= len(m.JsonTable) + copy(dAtA[i:], m.JsonTable) + i = encodeVarintBrpb(dAtA, i, uint64(len(m.JsonTable))) i-- dAtA[i] = 0x12 } - if len(m.Name) > 0 { - i -= len(m.Name) - copy(dAtA[i:], m.Name) - i = encodeVarintBrpb(dAtA, i, uint64(len(m.Name))) + if m.PhysicalId != 0 { + i = encodeVarintBrpb(dAtA, i, uint64(m.PhysicalId)) i-- - dAtA[i] = 0xa + dAtA[i] = 0x8 } return len(dAtA) - i, nil } -func (m *PitrDBMap) Marshal() (dAtA []byte, err error) { +func (m *StatsFile) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -5781,12 +6266,12 @@ func (m *PitrDBMap) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *PitrDBMap) MarshalTo(dAtA []byte) (int, error) { +func (m *StatsFile) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *PitrDBMap) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *StatsFile) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -5795,10 +6280,10 @@ func (m *PitrDBMap) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if len(m.Tables) > 0 { - for iNdEx := len(m.Tables) - 1; iNdEx >= 0; iNdEx-- { + if len(m.Blocks) > 0 { + for iNdEx := len(m.Blocks) - 1; iNdEx >= 0; iNdEx-- { { - size, err := m.Tables[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Blocks[iNdEx].MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -5806,32 +6291,13 @@ func (m *PitrDBMap) MarshalToSizedBuffer(dAtA []byte) (int, error) { i = encodeVarintBrpb(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0x1a - } - } - if m.IdMap != nil { - { - size, err := m.IdMap.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintBrpb(dAtA, i, uint64(size)) + dAtA[i] = 0xa } - i-- - dAtA[i] = 0x12 - } - if len(m.Name) > 0 { - i -= len(m.Name) - copy(dAtA[i:], m.Name) - i = encodeVarintBrpb(dAtA, i, uint64(len(m.Name))) - i-- - dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *RawRange) Marshal() (dAtA []byte, err error) { +func (m *StatsFileIndex) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -5841,12 +6307,12 @@ func (m *RawRange) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *RawRange) MarshalTo(dAtA []byte) (int, error) { +func (m *StatsFileIndex) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *RawRange) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *StatsFileIndex) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -5855,31 +6321,48 @@ func (m *RawRange) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if len(m.Cf) > 0 { - i -= len(m.Cf) - copy(dAtA[i:], m.Cf) - i = encodeVarintBrpb(dAtA, i, uint64(len(m.Cf))) + if len(m.InlineData) > 0 { + i -= len(m.InlineData) + copy(dAtA[i:], m.InlineData) + i = encodeVarintBrpb(dAtA, i, uint64(len(m.InlineData))) i-- - dAtA[i] = 0x1a + dAtA[i] = 0x32 } - if len(m.EndKey) > 0 { - i -= len(m.EndKey) - copy(dAtA[i:], m.EndKey) - i = encodeVarintBrpb(dAtA, i, uint64(len(m.EndKey))) + if len(m.CipherIv) > 0 { + i -= len(m.CipherIv) + copy(dAtA[i:], m.CipherIv) + i = encodeVarintBrpb(dAtA, i, uint64(len(m.CipherIv))) + i-- + dAtA[i] = 0x2a + } + if m.SizeOri != 0 { + i = encodeVarintBrpb(dAtA, i, uint64(m.SizeOri)) + i-- + dAtA[i] = 0x20 + } + if m.SizeEnc != 0 { + i = encodeVarintBrpb(dAtA, i, uint64(m.SizeEnc)) + i-- + dAtA[i] = 0x18 + } + if len(m.Sha256) > 0 { + i -= len(m.Sha256) + copy(dAtA[i:], m.Sha256) + i = encodeVarintBrpb(dAtA, i, uint64(len(m.Sha256))) i-- dAtA[i] = 0x12 } - if len(m.StartKey) > 0 { - i -= len(m.StartKey) - copy(dAtA[i:], m.StartKey) - i = encodeVarintBrpb(dAtA, i, uint64(len(m.StartKey))) + if len(m.Name) > 0 { + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintBrpb(dAtA, i, uint64(len(m.Name))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *ClusterIDError) Marshal() (dAtA []byte, err error) { +func (m *Schema) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -5889,12 +6372,12 @@ func (m *ClusterIDError) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *ClusterIDError) MarshalTo(dAtA []byte) (int, error) { +func (m *Schema) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ClusterIDError) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *Schema) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -5903,35 +6386,80 @@ func (m *ClusterIDError) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if m.Request != 0 { - i = encodeVarintBrpb(dAtA, i, uint64(m.Request)) + if len(m.StatsIndex) > 0 { + for iNdEx := len(m.StatsIndex) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.StatsIndex[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintBrpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x42 + } + } + if len(m.Stats) > 0 { + i -= len(m.Stats) + copy(dAtA[i:], m.Stats) + i = encodeVarintBrpb(dAtA, i, uint64(len(m.Stats))) i-- - dAtA[i] = 0x10 + dAtA[i] = 0x3a } - if m.Current != 0 { - i = encodeVarintBrpb(dAtA, i, uint64(m.Current)) + if m.TiflashReplicas != 0 { + i = encodeVarintBrpb(dAtA, i, uint64(m.TiflashReplicas)) i-- - dAtA[i] = 0x8 + dAtA[i] = 0x30 } - return len(dAtA) - i, nil -} - -func (m *Error) 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.TotalBytes != 0 { + i = encodeVarintBrpb(dAtA, i, uint64(m.TotalBytes)) + i-- + dAtA[i] = 0x28 } - return dAtA[:n], nil -} - -func (m *Error) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) + if m.TotalKvs != 0 { + i = encodeVarintBrpb(dAtA, i, uint64(m.TotalKvs)) + i-- + dAtA[i] = 0x20 + } + if m.Crc64Xor != 0 { + i = encodeVarintBrpb(dAtA, i, uint64(m.Crc64Xor)) + i-- + dAtA[i] = 0x18 + } + if len(m.Table) > 0 { + i -= len(m.Table) + copy(dAtA[i:], m.Table) + i = encodeVarintBrpb(dAtA, i, uint64(len(m.Table))) + i-- + dAtA[i] = 0x12 + } + if len(m.Db) > 0 { + i -= len(m.Db) + copy(dAtA[i:], m.Db) + i = encodeVarintBrpb(dAtA, i, uint64(len(m.Db))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil } -func (m *Error) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *IDMap) 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 *IDMap) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *IDMap) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -5940,35 +6468,60 @@ func (m *Error) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if m.Detail != nil { - { - size := m.Detail.Size() - i -= size - if _, err := m.Detail.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - } + if m.DownstreamId != 0 { + i = encodeVarintBrpb(dAtA, i, uint64(m.DownstreamId)) + i-- + dAtA[i] = 0x10 } - if len(m.Msg) > 0 { - i -= len(m.Msg) - copy(dAtA[i:], m.Msg) - i = encodeVarintBrpb(dAtA, i, uint64(len(m.Msg))) + if m.UpstreamId != 0 { + i = encodeVarintBrpb(dAtA, i, uint64(m.UpstreamId)) i-- - dAtA[i] = 0xa + dAtA[i] = 0x8 } return len(dAtA) - i, nil } -func (m *Error_ClusterIdError) MarshalTo(dAtA []byte) (int, error) { +func (m *PitrTableMap) 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 *PitrTableMap) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *Error_ClusterIdError) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *PitrTableMap) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) - if m.ClusterIdError != nil { + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.Partitions) > 0 { + for iNdEx := len(m.Partitions) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Partitions[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintBrpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + } + if m.IdMap != nil { { - size, err := m.ClusterIdError.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.IdMap.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -5976,20 +6529,59 @@ func (m *Error_ClusterIdError) MarshalToSizedBuffer(dAtA []byte) (int, error) { i = encodeVarintBrpb(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0x1a + dAtA[i] = 0x12 + } + if len(m.Name) > 0 { + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintBrpb(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *Error_KvError) MarshalTo(dAtA []byte) (int, error) { + +func (m *PitrDBMap) 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 *PitrDBMap) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *Error_KvError) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *PitrDBMap) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) - if m.KvError != nil { + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.Tables) > 0 { + for iNdEx := len(m.Tables) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Tables[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintBrpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + } + if m.IdMap != nil { { - size, err := m.KvError.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.IdMap.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -5997,32 +6589,67 @@ func (m *Error_KvError) MarshalToSizedBuffer(dAtA []byte) (int, error) { i = encodeVarintBrpb(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0x22 + dAtA[i] = 0x12 + } + if len(m.Name) > 0 { + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintBrpb(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *Error_RegionError) MarshalTo(dAtA []byte) (int, error) { + +func (m *RawRange) 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 *RawRange) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *Error_RegionError) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *RawRange) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) - if m.RegionError != nil { - { - size, err := m.RegionError.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintBrpb(dAtA, i, uint64(size)) - } + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.Cf) > 0 { + i -= len(m.Cf) + copy(dAtA[i:], m.Cf) + i = encodeVarintBrpb(dAtA, i, uint64(len(m.Cf))) i-- - dAtA[i] = 0x2a + dAtA[i] = 0x1a + } + if len(m.EndKey) > 0 { + i -= len(m.EndKey) + copy(dAtA[i:], m.EndKey) + i = encodeVarintBrpb(dAtA, i, uint64(len(m.EndKey))) + i-- + dAtA[i] = 0x12 + } + if len(m.StartKey) > 0 { + i -= len(m.StartKey) + copy(dAtA[i:], m.StartKey) + i = encodeVarintBrpb(dAtA, i, uint64(len(m.StartKey))) + i-- + dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *CipherInfo) Marshal() (dAtA []byte, err error) { + +func (m *ClusterIDError) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -6032,12 +6659,12 @@ func (m *CipherInfo) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *CipherInfo) MarshalTo(dAtA []byte) (int, error) { +func (m *ClusterIDError) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *CipherInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ClusterIDError) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -6046,22 +6673,20 @@ func (m *CipherInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if len(m.CipherKey) > 0 { - i -= len(m.CipherKey) - copy(dAtA[i:], m.CipherKey) - i = encodeVarintBrpb(dAtA, i, uint64(len(m.CipherKey))) + if m.Request != 0 { + i = encodeVarintBrpb(dAtA, i, uint64(m.Request)) i-- - dAtA[i] = 0x12 + dAtA[i] = 0x10 } - if m.CipherType != 0 { - i = encodeVarintBrpb(dAtA, i, uint64(m.CipherType)) + if m.Current != 0 { + i = encodeVarintBrpb(dAtA, i, uint64(m.Current)) i-- dAtA[i] = 0x8 } return len(dAtA) - i, nil } -func (m *BackupRequest) 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]) @@ -6071,12 +6696,12 @@ func (m *BackupRequest) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *BackupRequest) MarshalTo(dAtA []byte) (int, error) { +func (m *Error) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *BackupRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *Error) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -6085,24 +6710,169 @@ func (m *BackupRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - if m.Context != nil { + if m.Detail != nil { { - size, err := m.Context.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { + size := m.Detail.Size() + i -= size + if _, err := m.Detail.MarshalTo(dAtA[i:]); err != nil { return 0, err } - i -= size - i = encodeVarintBrpb(dAtA, i, uint64(size)) } - i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0xa2 } - if len(m.UniqueId) > 0 { - i -= len(m.UniqueId) - copy(dAtA[i:], m.UniqueId) - i = encodeVarintBrpb(dAtA, i, uint64(len(m.UniqueId))) + if len(m.Msg) > 0 { + i -= len(m.Msg) + copy(dAtA[i:], m.Msg) + i = encodeVarintBrpb(dAtA, i, uint64(len(m.Msg))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Error_ClusterIdError) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Error_ClusterIdError) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.ClusterIdError != nil { + { + size, err := m.ClusterIdError.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintBrpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + return len(dAtA) - i, nil +} +func (m *Error_KvError) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Error_KvError) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.KvError != nil { + { + size, err := m.KvError.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintBrpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + return len(dAtA) - i, nil +} +func (m *Error_RegionError) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Error_RegionError) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.RegionError != nil { + { + size, err := m.RegionError.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintBrpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + } + return len(dAtA) - i, nil +} +func (m *CipherInfo) 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 *CipherInfo) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *CipherInfo) 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.CipherKey) > 0 { + i -= len(m.CipherKey) + copy(dAtA[i:], m.CipherKey) + i = encodeVarintBrpb(dAtA, i, uint64(len(m.CipherKey))) + i-- + dAtA[i] = 0x12 + } + if m.CipherType != 0 { + i = encodeVarintBrpb(dAtA, i, uint64(m.CipherType)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *BackupRequest) 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 *BackupRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *BackupRequest) 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.Context != nil { + { + size, err := m.Context.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintBrpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xa2 + } + if len(m.UniqueId) > 0 { + i -= len(m.UniqueId) + copy(dAtA[i:], m.UniqueId) + i = encodeVarintBrpb(dAtA, i, uint64(len(m.UniqueId))) i-- dAtA[i] = 0x1 i-- @@ -7748,6 +8518,47 @@ func (m *DataFileInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } + if len(m.RegionEpoch) > 0 { + for iNdEx := len(m.RegionEpoch) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.RegionEpoch[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintBrpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xb2 + } + } + if len(m.RegionEndKey) > 0 { + i -= len(m.RegionEndKey) + copy(dAtA[i:], m.RegionEndKey) + i = encodeVarintBrpb(dAtA, i, uint64(len(m.RegionEndKey))) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xaa + } + if len(m.RegionStartKey) > 0 { + i -= len(m.RegionStartKey) + copy(dAtA[i:], m.RegionStartKey) + i = encodeVarintBrpb(dAtA, i, uint64(len(m.RegionStartKey))) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xa2 + } + if m.Crc64Xor != 0 { + i = encodeVarintBrpb(dAtA, i, uint64(m.Crc64Xor)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x98 + } if m.CompressionType != 0 { i = encodeVarintBrpb(dAtA, i, uint64(m.CompressionType)) i-- @@ -7913,446 +8724,600 @@ func (m *StreamBackupError) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func encodeVarintBrpb(dAtA []byte, offset int, v uint64) int { - offset -= sovBrpb(v) - base := offset - for v >= 1<<7 { - dAtA[offset] = uint8(v&0x7f | 0x80) - v >>= 7 - offset++ +func (m *Span) 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[offset] = uint8(v) - return base + return dAtA[:n], nil } -func (m *PrepareSnapshotBackupRequest) Size() (n int) { - if m == nil { - return 0 - } + +func (m *Span) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Span) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.Ty != 0 { - n += 1 + sovBrpb(uint64(m.Ty)) - } - if len(m.Regions) > 0 { - for _, e := range m.Regions { - l = e.Size() - n += 1 + l + sovBrpb(uint64(l)) - } + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - if m.LeaseInSeconds != 0 { - n += 1 + sovBrpb(uint64(m.LeaseInSeconds)) + if m.Length != 0 { + i = encodeVarintBrpb(dAtA, i, uint64(m.Length)) + i-- + dAtA[i] = 0x10 } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + if m.Offset != 0 { + i = encodeVarintBrpb(dAtA, i, uint64(m.Offset)) + i-- + dAtA[i] = 0x8 } - return n + return len(dAtA) - i, nil } -func (m *PrepareSnapshotBackupResponse) Size() (n int) { - if m == nil { - return 0 +func (m *SpansOfFile) 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 *SpansOfFile) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SpansOfFile) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.Ty != 0 { - n += 1 + sovBrpb(uint64(m.Ty)) - } - if m.Region != nil { - l = m.Region.Size() - n += 1 + l + sovBrpb(uint64(l)) + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - if m.Error != nil { - l = m.Error.Size() - n += 1 + l + sovBrpb(uint64(l)) - } - if m.LastLeaseIsValid { - n += 2 + if len(m.Spans) > 0 { + for iNdEx := len(m.Spans) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Spans[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintBrpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + if len(m.Path) > 0 { + i -= len(m.Path) + copy(dAtA[i:], m.Path) + i = encodeVarintBrpb(dAtA, i, uint64(len(m.Path))) + i-- + dAtA[i] = 0xa } - return n + return len(dAtA) - i, nil } -func (m *BackupMeta) Size() (n int) { - if m == nil { - return 0 +func (m *LogFileSubcompactionMeta) 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 *LogFileSubcompactionMeta) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *LogFileSubcompactionMeta) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.ClusterId != 0 { - n += 1 + sovBrpb(uint64(m.ClusterId)) - } - l = len(m.ClusterVersion) - if l > 0 { - n += 1 + l + sovBrpb(uint64(l)) - } - if len(m.Files) > 0 { - for _, e := range m.Files { - l = e.Size() - n += 1 + l + sovBrpb(uint64(l)) - } - } - if m.StartVersion != 0 { - n += 1 + sovBrpb(uint64(m.StartVersion)) - } - if m.EndVersion != 0 { - n += 1 + sovBrpb(uint64(m.EndVersion)) + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - if len(m.Schemas) > 0 { - for _, e := range m.Schemas { - l = e.Size() - n += 1 + l + sovBrpb(uint64(l)) + if len(m.Sources) > 0 { + for iNdEx := len(m.Sources) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Sources[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintBrpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x62 } } - if m.IsRawKv { - n += 2 - } - if len(m.RawRanges) > 0 { - for _, e := range m.RawRanges { - l = e.Size() - n += 1 + l + sovBrpb(uint64(l)) - } + if m.TableId != 0 { + i = encodeVarintBrpb(dAtA, i, uint64(m.TableId)) + i-- + dAtA[i] = 0x58 } - l = len(m.Ddls) - if l > 0 { - n += 1 + l + sovBrpb(uint64(l)) + if m.Ty != 0 { + i = encodeVarintBrpb(dAtA, i, uint64(m.Ty)) + i-- + dAtA[i] = 0x50 } - l = len(m.BrVersion) - if l > 0 { - n += 1 + l + sovBrpb(uint64(l)) + if len(m.MaxKey) > 0 { + i -= len(m.MaxKey) + copy(dAtA[i:], m.MaxKey) + i = encodeVarintBrpb(dAtA, i, uint64(len(m.MaxKey))) + i-- + dAtA[i] = 0x4a } - if m.Version != 0 { - n += 1 + sovBrpb(uint64(m.Version)) + if len(m.MinKey) > 0 { + i -= len(m.MinKey) + copy(dAtA[i:], m.MinKey) + i = encodeVarintBrpb(dAtA, i, uint64(len(m.MinKey))) + i-- + dAtA[i] = 0x42 } - if m.FileIndex != nil { - l = m.FileIndex.Size() - n += 1 + l + sovBrpb(uint64(l)) + if m.CompactUntilTs != 0 { + i = encodeVarintBrpb(dAtA, i, uint64(m.CompactUntilTs)) + i-- + dAtA[i] = 0x38 } - if m.SchemaIndex != nil { - l = m.SchemaIndex.Size() - n += 1 + l + sovBrpb(uint64(l)) + if m.CompactFromTs != 0 { + i = encodeVarintBrpb(dAtA, i, uint64(m.CompactFromTs)) + i-- + dAtA[i] = 0x30 } - if m.RawRangeIndex != nil { - l = m.RawRangeIndex.Size() - n += 1 + l + sovBrpb(uint64(l)) + if m.InputMinTs != 0 { + i = encodeVarintBrpb(dAtA, i, uint64(m.InputMinTs)) + i-- + dAtA[i] = 0x28 } - if m.DdlIndexes != nil { - l = m.DdlIndexes.Size() - n += 2 + l + sovBrpb(uint64(l)) + if m.InputMaxTs != 0 { + i = encodeVarintBrpb(dAtA, i, uint64(m.InputMaxTs)) + i-- + dAtA[i] = 0x20 } - l = len(m.BackupResult) - if l > 0 { - n += 2 + l + sovBrpb(uint64(l)) + if len(m.Cf) > 0 { + i -= len(m.Cf) + copy(dAtA[i:], m.Cf) + i = encodeVarintBrpb(dAtA, i, uint64(len(m.Cf))) + i-- + dAtA[i] = 0x1a } - if m.ApiVersion != 0 { - n += 2 + sovBrpb(uint64(m.ApiVersion)) + if m.RegionId != 0 { + i = encodeVarintBrpb(dAtA, i, uint64(m.RegionId)) + i-- + dAtA[i] = 0x10 } - if len(m.Policies) > 0 { - for _, e := range m.Policies { - l = e.Size() - n += 2 + l + sovBrpb(uint64(l)) - } + if m.Size_ != 0 { + i = encodeVarintBrpb(dAtA, i, uint64(m.Size_)) + i-- + dAtA[i] = 0x8 } - l = len(m.NewCollationsEnabled) - if l > 0 { - n += 2 + l + sovBrpb(uint64(l)) + return len(dAtA) - i, nil +} + +func (m *LogFileSubcompaction) 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.IsTxnKv { - n += 3 + return dAtA[:n], nil +} + +func (m *LogFileSubcompaction) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *LogFileSubcompaction) 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.DbMaps) > 0 { - for _, e := range m.DbMaps { - l = e.Size() - n += 2 + l + sovBrpb(uint64(l)) + if len(m.SstOutputs) > 0 { + for iNdEx := len(m.SstOutputs) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.SstOutputs[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintBrpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 } } - if m.Mode != 0 { - n += 2 + sovBrpb(uint64(m.Mode)) - } - if len(m.Ranges) > 0 { - for _, e := range m.Ranges { - l = e.Size() - n += 2 + l + sovBrpb(uint64(l)) + if m.Meta != nil { + { + size, err := m.Meta.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintBrpb(dAtA, i, uint64(size)) } + i-- + dAtA[i] = 0xa } - if m.BackupSize != 0 { - n += 2 + sovBrpb(uint64(m.BackupSize)) - } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) - } - return n + return len(dAtA) - i, nil } -func (m *BackupRange) Size() (n int) { - if m == nil { - return 0 +func (m *LogFileSubcompactions) 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 *LogFileSubcompactions) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *LogFileSubcompactions) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - l = len(m.StartKey) - if l > 0 { - n += 1 + l + sovBrpb(uint64(l)) - } - l = len(m.EndKey) - if l > 0 { - n += 1 + l + sovBrpb(uint64(l)) + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - if len(m.Files) > 0 { - for _, e := range m.Files { - l = e.Size() - n += 1 + l + sovBrpb(uint64(l)) + if len(m.Subcompactions) > 0 { + for iNdEx := len(m.Subcompactions) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Subcompactions[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintBrpb(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 *File) Size() (n int) { - if m == nil { - return 0 +func (m *LogFileCompaction) 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 *LogFileCompaction) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *LogFileCompaction) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - l = len(m.Name) - if l > 0 { - n += 1 + l + sovBrpb(uint64(l)) - } - l = len(m.Sha256) - if l > 0 { - n += 1 + l + sovBrpb(uint64(l)) - } - l = len(m.StartKey) - if l > 0 { - n += 1 + l + sovBrpb(uint64(l)) - } - l = len(m.EndKey) - if l > 0 { - n += 1 + l + sovBrpb(uint64(l)) - } - if m.StartVersion != 0 { - n += 1 + sovBrpb(uint64(m.StartVersion)) - } - if m.EndVersion != 0 { - n += 1 + sovBrpb(uint64(m.EndVersion)) + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - if m.Crc64Xor != 0 { - n += 1 + sovBrpb(uint64(m.Crc64Xor)) + if len(m.GeneratedFiles) > 0 { + i -= len(m.GeneratedFiles) + copy(dAtA[i:], m.GeneratedFiles) + i = encodeVarintBrpb(dAtA, i, uint64(len(m.GeneratedFiles))) + i-- + dAtA[i] = 0x3a } - if m.TotalKvs != 0 { - n += 1 + sovBrpb(uint64(m.TotalKvs)) + if m.ArtifactsHash != 0 { + i = encodeVarintBrpb(dAtA, i, uint64(m.ArtifactsHash)) + i-- + dAtA[i] = 0x30 } - if m.TotalBytes != 0 { - n += 1 + sovBrpb(uint64(m.TotalBytes)) + if len(m.Artifacts) > 0 { + i -= len(m.Artifacts) + copy(dAtA[i:], m.Artifacts) + i = encodeVarintBrpb(dAtA, i, uint64(len(m.Artifacts))) + i-- + dAtA[i] = 0x2a } - l = len(m.Cf) - if l > 0 { - n += 1 + l + sovBrpb(uint64(l)) + if len(m.Comments) > 0 { + i -= len(m.Comments) + copy(dAtA[i:], m.Comments) + i = encodeVarintBrpb(dAtA, i, uint64(len(m.Comments))) + i-- + dAtA[i] = 0x22 } - if m.Size_ != 0 { - n += 1 + sovBrpb(uint64(m.Size_)) + if len(m.Name) > 0 { + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintBrpb(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0x1a } - l = len(m.CipherIv) - if l > 0 { - n += 1 + l + sovBrpb(uint64(l)) + if m.CompactionUntilTs != 0 { + i = encodeVarintBrpb(dAtA, i, uint64(m.CompactionUntilTs)) + i-- + dAtA[i] = 0x10 } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + if m.CompactionFromTs != 0 { + i = encodeVarintBrpb(dAtA, i, uint64(m.CompactionFromTs)) + i-- + dAtA[i] = 0x8 } - return n + return len(dAtA) - i, nil } -func (m *MetaFile) Size() (n int) { - if m == nil { - return 0 +func (m *MetaEdit) 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 *MetaEdit) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MetaEdit) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if len(m.MetaFiles) > 0 { - for _, e := range m.MetaFiles { - l = e.Size() - n += 1 + l + sovBrpb(uint64(l)) - } - } - if len(m.DataFiles) > 0 { - for _, e := range m.DataFiles { - l = e.Size() - n += 1 + l + sovBrpb(uint64(l)) - } - } - if len(m.Schemas) > 0 { - for _, e := range m.Schemas { - l = e.Size() - n += 1 + l + sovBrpb(uint64(l)) - } + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - if len(m.RawRanges) > 0 { - for _, e := range m.RawRanges { - l = e.Size() - n += 1 + l + sovBrpb(uint64(l)) + if m.DestructSelf { + i-- + if m.DestructSelf { + dAtA[i] = 1 + } else { + dAtA[i] = 0 } + i-- + dAtA[i] = 0x20 } - if len(m.Ddls) > 0 { - for _, b := range m.Ddls { - l = len(b) - n += 1 + l + sovBrpb(uint64(l)) + if len(m.DeleteLogicalFiles) > 0 { + for iNdEx := len(m.DeleteLogicalFiles) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.DeleteLogicalFiles[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintBrpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a } } - if len(m.BackupRanges) > 0 { - for _, e := range m.BackupRanges { - l = e.Size() - n += 1 + l + sovBrpb(uint64(l)) + if len(m.DeletePhysicalFiles) > 0 { + for iNdEx := len(m.DeletePhysicalFiles) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.DeletePhysicalFiles[iNdEx]) + copy(dAtA[i:], m.DeletePhysicalFiles[iNdEx]) + i = encodeVarintBrpb(dAtA, i, uint64(len(m.DeletePhysicalFiles[iNdEx]))) + i-- + dAtA[i] = 0x12 } } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + if len(m.Path) > 0 { + i -= len(m.Path) + copy(dAtA[i:], m.Path) + i = encodeVarintBrpb(dAtA, i, uint64(len(m.Path))) + i-- + dAtA[i] = 0xa } - return n + return len(dAtA) - i, nil } -func (m *PlacementPolicy) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Info) - if l > 0 { - n += 1 + l + sovBrpb(uint64(l)) - } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) +func (m *DeleteSpansOfFile) 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 *StatsBlock) Size() (n int) { - if m == nil { - return 0 - } +func (m *DeleteSpansOfFile) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DeleteSpansOfFile) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.PhysicalId != 0 { - n += 1 + sovBrpb(uint64(m.PhysicalId)) - } - l = len(m.JsonTable) - if l > 0 { - n += 1 + l + sovBrpb(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 *StatsFile) Size() (n int) { - if m == nil { - return 0 + if m.WholeFileLength != 0 { + i = encodeVarintBrpb(dAtA, i, uint64(m.WholeFileLength)) + i-- + dAtA[i] = 0x18 } - var l int - _ = l - if len(m.Blocks) > 0 { - for _, e := range m.Blocks { - l = e.Size() - n += 1 + l + sovBrpb(uint64(l)) + if len(m.Spans) > 0 { + for iNdEx := len(m.Spans) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Spans[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintBrpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 } } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + if len(m.Path) > 0 { + i -= len(m.Path) + copy(dAtA[i:], m.Path) + i = encodeVarintBrpb(dAtA, i, uint64(len(m.Path))) + i-- + dAtA[i] = 0xa } - return n + return len(dAtA) - i, nil } -func (m *StatsFileIndex) Size() (n int) { - if m == nil { - return 0 +func (m *Migration) 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 *Migration) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Migration) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - l = len(m.Name) - if l > 0 { - n += 1 + l + sovBrpb(uint64(l)) - } - l = len(m.Sha256) - if l > 0 { - n += 1 + l + sovBrpb(uint64(l)) + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) } - if m.SizeEnc != 0 { - n += 1 + sovBrpb(uint64(m.SizeEnc)) + if len(m.DestructPrefix) > 0 { + for iNdEx := len(m.DestructPrefix) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.DestructPrefix[iNdEx]) + copy(dAtA[i:], m.DestructPrefix[iNdEx]) + i = encodeVarintBrpb(dAtA, i, uint64(len(m.DestructPrefix[iNdEx]))) + i-- + dAtA[i] = 0x22 + } } - if m.SizeOri != 0 { - n += 1 + sovBrpb(uint64(m.SizeOri)) - } - l = len(m.CipherIv) - if l > 0 { - n += 1 + l + sovBrpb(uint64(l)) + if len(m.Compactions) > 0 { + for iNdEx := len(m.Compactions) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Compactions[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintBrpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } } - l = len(m.InlineData) - if l > 0 { - n += 1 + l + sovBrpb(uint64(l)) + if m.TruncatedTo != 0 { + i = encodeVarintBrpb(dAtA, i, uint64(m.TruncatedTo)) + i-- + dAtA[i] = 0x10 } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + if len(m.EditMeta) > 0 { + for iNdEx := len(m.EditMeta) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.EditMeta[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintBrpb(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } } - return n + return len(dAtA) - i, nil } -func (m *Schema) Size() (n int) { +func encodeVarintBrpb(dAtA []byte, offset int, v uint64) int { + offset -= sovBrpb(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *PrepareSnapshotBackupRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l - l = len(m.Db) - if l > 0 { - n += 1 + l + sovBrpb(uint64(l)) - } - l = len(m.Table) - if l > 0 { - n += 1 + l + sovBrpb(uint64(l)) - } - if m.Crc64Xor != 0 { - n += 1 + sovBrpb(uint64(m.Crc64Xor)) - } - if m.TotalKvs != 0 { - n += 1 + sovBrpb(uint64(m.TotalKvs)) - } - if m.TotalBytes != 0 { - n += 1 + sovBrpb(uint64(m.TotalBytes)) - } - if m.TiflashReplicas != 0 { - n += 1 + sovBrpb(uint64(m.TiflashReplicas)) - } - l = len(m.Stats) - if l > 0 { - n += 1 + l + sovBrpb(uint64(l)) + if m.Ty != 0 { + n += 1 + sovBrpb(uint64(m.Ty)) } - if len(m.StatsIndex) > 0 { - for _, e := range m.StatsIndex { + if len(m.Regions) > 0 { + for _, e := range m.Regions { l = e.Size() n += 1 + l + sovBrpb(uint64(l)) } } + if m.LeaseInSeconds != 0 { + n += 1 + sovBrpb(uint64(m.LeaseInSeconds)) + } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } -func (m *IDMap) Size() (n int) { +func (m *PrepareSnapshotBackupResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.UpstreamId != 0 { - n += 1 + sovBrpb(uint64(m.UpstreamId)) + if m.Ty != 0 { + n += 1 + sovBrpb(uint64(m.Ty)) } - if m.DownstreamId != 0 { - n += 1 + sovBrpb(uint64(m.DownstreamId)) + if m.Region != nil { + l = m.Region.Size() + n += 1 + l + sovBrpb(uint64(l)) + } + if m.Error != nil { + l = m.Error.Size() + n += 1 + l + sovBrpb(uint64(l)) + } + if m.LastLeaseIsValid { + n += 2 } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) @@ -8360,48 +9325,133 @@ func (m *IDMap) Size() (n int) { return n } -func (m *PitrTableMap) Size() (n int) { +func (m *BackupMeta) Size() (n int) { if m == nil { return 0 } var l int _ = l - l = len(m.Name) + if m.ClusterId != 0 { + n += 1 + sovBrpb(uint64(m.ClusterId)) + } + l = len(m.ClusterVersion) if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } - if m.IdMap != nil { - l = m.IdMap.Size() - n += 1 + l + sovBrpb(uint64(l)) + if len(m.Files) > 0 { + for _, e := range m.Files { + l = e.Size() + n += 1 + l + sovBrpb(uint64(l)) + } } - if len(m.Partitions) > 0 { - for _, e := range m.Partitions { + if m.StartVersion != 0 { + n += 1 + sovBrpb(uint64(m.StartVersion)) + } + if m.EndVersion != 0 { + n += 1 + sovBrpb(uint64(m.EndVersion)) + } + if len(m.Schemas) > 0 { + for _, e := range m.Schemas { + l = e.Size() + n += 1 + l + sovBrpb(uint64(l)) + } + } + if m.IsRawKv { + n += 2 + } + if len(m.RawRanges) > 0 { + for _, e := range m.RawRanges { l = e.Size() n += 1 + l + sovBrpb(uint64(l)) } } + l = len(m.Ddls) + if l > 0 { + n += 1 + l + sovBrpb(uint64(l)) + } + l = len(m.BrVersion) + if l > 0 { + n += 1 + l + sovBrpb(uint64(l)) + } + if m.Version != 0 { + n += 1 + sovBrpb(uint64(m.Version)) + } + if m.FileIndex != nil { + l = m.FileIndex.Size() + n += 1 + l + sovBrpb(uint64(l)) + } + if m.SchemaIndex != nil { + l = m.SchemaIndex.Size() + n += 1 + l + sovBrpb(uint64(l)) + } + if m.RawRangeIndex != nil { + l = m.RawRangeIndex.Size() + n += 1 + l + sovBrpb(uint64(l)) + } + if m.DdlIndexes != nil { + l = m.DdlIndexes.Size() + n += 2 + l + sovBrpb(uint64(l)) + } + l = len(m.BackupResult) + if l > 0 { + n += 2 + l + sovBrpb(uint64(l)) + } + if m.ApiVersion != 0 { + n += 2 + sovBrpb(uint64(m.ApiVersion)) + } + if len(m.Policies) > 0 { + for _, e := range m.Policies { + l = e.Size() + n += 2 + l + sovBrpb(uint64(l)) + } + } + l = len(m.NewCollationsEnabled) + if l > 0 { + n += 2 + l + sovBrpb(uint64(l)) + } + if m.IsTxnKv { + n += 3 + } + if len(m.DbMaps) > 0 { + for _, e := range m.DbMaps { + l = e.Size() + n += 2 + l + sovBrpb(uint64(l)) + } + } + if m.Mode != 0 { + n += 2 + sovBrpb(uint64(m.Mode)) + } + if len(m.Ranges) > 0 { + for _, e := range m.Ranges { + l = e.Size() + n += 2 + l + sovBrpb(uint64(l)) + } + } + if m.BackupSize != 0 { + n += 2 + sovBrpb(uint64(m.BackupSize)) + } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } -func (m *PitrDBMap) Size() (n int) { +func (m *BackupRange) Size() (n int) { if m == nil { return 0 } var l int _ = l - l = len(m.Name) + l = len(m.StartKey) if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } - if m.IdMap != nil { - l = m.IdMap.Size() + l = len(m.EndKey) + if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } - if len(m.Tables) > 0 { - for _, e := range m.Tables { + if len(m.Files) > 0 { + for _, e := range m.Files { l = e.Size() n += 1 + l + sovBrpb(uint64(l)) } @@ -8412,12 +9462,20 @@ func (m *PitrDBMap) Size() (n int) { return n } -func (m *RawRange) Size() (n int) { +func (m *File) Size() (n int) { if m == nil { return 0 } var l int _ = l + l = len(m.Name) + if l > 0 { + n += 1 + l + sovBrpb(uint64(l)) + } + l = len(m.Sha256) + if l > 0 { + n += 1 + l + sovBrpb(uint64(l)) + } l = len(m.StartKey) if l > 0 { n += 1 + l + sovBrpb(uint64(l)) @@ -8426,27 +9484,31 @@ func (m *RawRange) Size() (n int) { if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } + if m.StartVersion != 0 { + n += 1 + sovBrpb(uint64(m.StartVersion)) + } + if m.EndVersion != 0 { + n += 1 + sovBrpb(uint64(m.EndVersion)) + } + if m.Crc64Xor != 0 { + n += 1 + sovBrpb(uint64(m.Crc64Xor)) + } + if m.TotalKvs != 0 { + n += 1 + sovBrpb(uint64(m.TotalKvs)) + } + if m.TotalBytes != 0 { + n += 1 + sovBrpb(uint64(m.TotalBytes)) + } l = len(m.Cf) if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) - } - return n -} - -func (m *ClusterIDError) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Current != 0 { - n += 1 + sovBrpb(uint64(m.Current)) + if m.Size_ != 0 { + n += 1 + sovBrpb(uint64(m.Size_)) } - if m.Request != 0 { - n += 1 + sovBrpb(uint64(m.Request)) + l = len(m.CipherIv) + if l > 0 { + n += 1 + l + sovBrpb(uint64(l)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) @@ -8454,18 +9516,47 @@ func (m *ClusterIDError) Size() (n int) { return n } -func (m *Error) Size() (n int) { +func (m *MetaFile) Size() (n int) { if m == nil { return 0 } var l int _ = l - l = len(m.Msg) - if l > 0 { - n += 1 + l + sovBrpb(uint64(l)) + if len(m.MetaFiles) > 0 { + for _, e := range m.MetaFiles { + l = e.Size() + n += 1 + l + sovBrpb(uint64(l)) + } } - if m.Detail != nil { - n += m.Detail.Size() + if len(m.DataFiles) > 0 { + for _, e := range m.DataFiles { + l = e.Size() + n += 1 + l + sovBrpb(uint64(l)) + } + } + if len(m.Schemas) > 0 { + for _, e := range m.Schemas { + l = e.Size() + n += 1 + l + sovBrpb(uint64(l)) + } + } + if len(m.RawRanges) > 0 { + for _, e := range m.RawRanges { + l = e.Size() + n += 1 + l + sovBrpb(uint64(l)) + } + } + if len(m.Ddls) > 0 { + for _, b := range m.Ddls { + l = len(b) + n += 1 + l + sovBrpb(uint64(l)) + } + } + if len(m.BackupRanges) > 0 { + for _, e := range m.BackupRanges { + l = e.Size() + n += 1 + l + sovBrpb(uint64(l)) + } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) @@ -8473,52 +9564,84 @@ func (m *Error) Size() (n int) { return n } -func (m *Error_ClusterIdError) Size() (n int) { +func (m *PlacementPolicy) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.ClusterIdError != nil { - l = m.ClusterIdError.Size() + l = len(m.Info) + if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } -func (m *Error_KvError) Size() (n int) { + +func (m *StatsBlock) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.KvError != nil { - l = m.KvError.Size() + if m.PhysicalId != 0 { + n += 1 + sovBrpb(uint64(m.PhysicalId)) + } + l = len(m.JsonTable) + if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } -func (m *Error_RegionError) Size() (n int) { + +func (m *StatsFile) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.RegionError != nil { - l = m.RegionError.Size() - n += 1 + l + sovBrpb(uint64(l)) + if len(m.Blocks) > 0 { + for _, e := range m.Blocks { + l = e.Size() + n += 1 + l + sovBrpb(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) } return n } -func (m *CipherInfo) Size() (n int) { + +func (m *StatsFileIndex) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.CipherType != 0 { - n += 1 + sovBrpb(uint64(m.CipherType)) + l = len(m.Name) + if l > 0 { + n += 1 + l + sovBrpb(uint64(l)) } - l = len(m.CipherKey) + l = len(m.Sha256) + if l > 0 { + n += 1 + l + sovBrpb(uint64(l)) + } + if m.SizeEnc != 0 { + n += 1 + sovBrpb(uint64(m.SizeEnc)) + } + if m.SizeOri != 0 { + n += 1 + sovBrpb(uint64(m.SizeOri)) + } + l = len(m.CipherIv) + if l > 0 { + n += 1 + l + sovBrpb(uint64(l)) + } + l = len(m.InlineData) if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } @@ -8528,78 +9651,59 @@ func (m *CipherInfo) Size() (n int) { return n } -func (m *BackupRequest) Size() (n int) { +func (m *Schema) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.ClusterId != 0 { - n += 1 + sovBrpb(uint64(m.ClusterId)) - } - l = len(m.StartKey) + l = len(m.Db) if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } - l = len(m.EndKey) + l = len(m.Table) if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } - if m.StartVersion != 0 { - n += 1 + sovBrpb(uint64(m.StartVersion)) - } - if m.EndVersion != 0 { - n += 1 + sovBrpb(uint64(m.EndVersion)) - } - if m.RateLimit != 0 { - n += 1 + sovBrpb(uint64(m.RateLimit)) + if m.Crc64Xor != 0 { + n += 1 + sovBrpb(uint64(m.Crc64Xor)) } - if m.Concurrency != 0 { - n += 1 + sovBrpb(uint64(m.Concurrency)) + if m.TotalKvs != 0 { + n += 1 + sovBrpb(uint64(m.TotalKvs)) } - if m.StorageBackend != nil { - l = m.StorageBackend.Size() - n += 1 + l + sovBrpb(uint64(l)) + if m.TotalBytes != 0 { + n += 1 + sovBrpb(uint64(m.TotalBytes)) } - if m.IsRawKv { - n += 2 + if m.TiflashReplicas != 0 { + n += 1 + sovBrpb(uint64(m.TiflashReplicas)) } - l = len(m.Cf) + l = len(m.Stats) if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } - if m.CompressionType != 0 { - n += 1 + sovBrpb(uint64(m.CompressionType)) - } - if m.CompressionLevel != 0 { - n += 1 + sovBrpb(uint64(m.CompressionLevel)) - } - if m.CipherInfo != nil { - l = m.CipherInfo.Size() - n += 1 + l + sovBrpb(uint64(l)) - } - if m.DstApiVersion != 0 { - n += 1 + sovBrpb(uint64(m.DstApiVersion)) - } - if len(m.SubRanges) > 0 { - for _, e := range m.SubRanges { + if len(m.StatsIndex) > 0 { + for _, e := range m.StatsIndex { l = e.Size() - n += 2 + l + sovBrpb(uint64(l)) + n += 1 + l + sovBrpb(uint64(l)) } } - if m.ReplicaRead { - n += 3 + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) } - if m.Mode != 0 { - n += 2 + sovBrpb(uint64(m.Mode)) + return n +} + +func (m *IDMap) Size() (n int) { + if m == nil { + return 0 } - l = len(m.UniqueId) - if l > 0 { - n += 2 + l + sovBrpb(uint64(l)) + var l int + _ = l + if m.UpstreamId != 0 { + n += 1 + sovBrpb(uint64(m.UpstreamId)) } - if m.Context != nil { - l = m.Context.Size() - n += 2 + l + sovBrpb(uint64(l)) + if m.DownstreamId != 0 { + n += 1 + sovBrpb(uint64(m.DownstreamId)) } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) @@ -8607,49 +9711,51 @@ func (m *BackupRequest) Size() (n int) { return n } -func (m *StreamBackupTaskInfo) Size() (n int) { +func (m *PitrTableMap) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.Storage != nil { - l = m.Storage.Size() - n += 1 + l + sovBrpb(uint64(l)) - } - if m.StartTs != 0 { - n += 1 + sovBrpb(uint64(m.StartTs)) - } - if m.EndTs != 0 { - n += 1 + sovBrpb(uint64(m.EndTs)) - } l = len(m.Name) if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } - if len(m.TableFilter) > 0 { - for _, s := range m.TableFilter { - l = len(s) + if m.IdMap != nil { + l = m.IdMap.Size() + n += 1 + l + sovBrpb(uint64(l)) + } + if len(m.Partitions) > 0 { + for _, e := range m.Partitions { + l = e.Size() n += 1 + l + sovBrpb(uint64(l)) } } - if m.CompressionType != 0 { - n += 1 + sovBrpb(uint64(m.CompressionType)) - } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } return n } -func (m *StorageBackend) Size() (n int) { +func (m *PitrDBMap) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.Backend != nil { - n += m.Backend.Size() + l = len(m.Name) + if l > 0 { + n += 1 + l + sovBrpb(uint64(l)) + } + if m.IdMap != nil { + l = m.IdMap.Size() + n += 1 + l + sovBrpb(uint64(l)) + } + if len(m.Tables) > 0 { + for _, e := range m.Tables { + l = e.Size() + n += 1 + l + sovBrpb(uint64(l)) + } } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) @@ -8657,41 +9763,286 @@ func (m *StorageBackend) Size() (n int) { return n } -func (m *StorageBackend_Noop) Size() (n int) { +func (m *RawRange) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.Noop != nil { - l = m.Noop.Size() + l = len(m.StartKey) + if l > 0 { + n += 1 + l + sovBrpb(uint64(l)) + } + l = len(m.EndKey) + if l > 0 { + n += 1 + l + sovBrpb(uint64(l)) + } + l = len(m.Cf) + if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } -func (m *StorageBackend_Local) Size() (n int) { + +func (m *ClusterIDError) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.Local != nil { - l = m.Local.Size() - n += 1 + l + sovBrpb(uint64(l)) + if m.Current != 0 { + n += 1 + sovBrpb(uint64(m.Current)) + } + if m.Request != 0 { + n += 1 + sovBrpb(uint64(m.Request)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) } return n } -func (m *StorageBackend_S3) Size() (n int) { + +func (m *Error) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.S3 != nil { - l = m.S3.Size() + l = len(m.Msg) + if l > 0 { n += 1 + l + sovBrpb(uint64(l)) } - return n + if m.Detail != nil { + n += m.Detail.Size() + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *Error_ClusterIdError) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ClusterIdError != nil { + l = m.ClusterIdError.Size() + n += 1 + l + sovBrpb(uint64(l)) + } + return n +} +func (m *Error_KvError) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.KvError != nil { + l = m.KvError.Size() + n += 1 + l + sovBrpb(uint64(l)) + } + return n +} +func (m *Error_RegionError) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.RegionError != nil { + l = m.RegionError.Size() + n += 1 + l + sovBrpb(uint64(l)) + } + return n +} +func (m *CipherInfo) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.CipherType != 0 { + n += 1 + sovBrpb(uint64(m.CipherType)) + } + l = len(m.CipherKey) + if l > 0 { + n += 1 + l + sovBrpb(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *BackupRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ClusterId != 0 { + n += 1 + sovBrpb(uint64(m.ClusterId)) + } + l = len(m.StartKey) + if l > 0 { + n += 1 + l + sovBrpb(uint64(l)) + } + l = len(m.EndKey) + if l > 0 { + n += 1 + l + sovBrpb(uint64(l)) + } + if m.StartVersion != 0 { + n += 1 + sovBrpb(uint64(m.StartVersion)) + } + if m.EndVersion != 0 { + n += 1 + sovBrpb(uint64(m.EndVersion)) + } + if m.RateLimit != 0 { + n += 1 + sovBrpb(uint64(m.RateLimit)) + } + if m.Concurrency != 0 { + n += 1 + sovBrpb(uint64(m.Concurrency)) + } + if m.StorageBackend != nil { + l = m.StorageBackend.Size() + n += 1 + l + sovBrpb(uint64(l)) + } + if m.IsRawKv { + n += 2 + } + l = len(m.Cf) + if l > 0 { + n += 1 + l + sovBrpb(uint64(l)) + } + if m.CompressionType != 0 { + n += 1 + sovBrpb(uint64(m.CompressionType)) + } + if m.CompressionLevel != 0 { + n += 1 + sovBrpb(uint64(m.CompressionLevel)) + } + if m.CipherInfo != nil { + l = m.CipherInfo.Size() + n += 1 + l + sovBrpb(uint64(l)) + } + if m.DstApiVersion != 0 { + n += 1 + sovBrpb(uint64(m.DstApiVersion)) + } + if len(m.SubRanges) > 0 { + for _, e := range m.SubRanges { + l = e.Size() + n += 2 + l + sovBrpb(uint64(l)) + } + } + if m.ReplicaRead { + n += 3 + } + if m.Mode != 0 { + n += 2 + sovBrpb(uint64(m.Mode)) + } + l = len(m.UniqueId) + if l > 0 { + n += 2 + l + sovBrpb(uint64(l)) + } + if m.Context != nil { + l = m.Context.Size() + n += 2 + l + sovBrpb(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *StreamBackupTaskInfo) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Storage != nil { + l = m.Storage.Size() + n += 1 + l + sovBrpb(uint64(l)) + } + if m.StartTs != 0 { + n += 1 + sovBrpb(uint64(m.StartTs)) + } + if m.EndTs != 0 { + n += 1 + sovBrpb(uint64(m.EndTs)) + } + l = len(m.Name) + if l > 0 { + n += 1 + l + sovBrpb(uint64(l)) + } + if len(m.TableFilter) > 0 { + for _, s := range m.TableFilter { + l = len(s) + n += 1 + l + sovBrpb(uint64(l)) + } + } + if m.CompressionType != 0 { + n += 1 + sovBrpb(uint64(m.CompressionType)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *StorageBackend) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Backend != nil { + n += m.Backend.Size() + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *StorageBackend_Noop) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Noop != nil { + l = m.Noop.Size() + n += 1 + l + sovBrpb(uint64(l)) + } + return n +} +func (m *StorageBackend_Local) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Local != nil { + l = m.Local.Size() + n += 1 + l + sovBrpb(uint64(l)) + } + return n +} +func (m *StorageBackend_S3) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.S3 != nil { + l = m.S3.Size() + n += 1 + l + sovBrpb(uint64(l)) + } + return n } func (m *StorageBackend_Gcs) Size() (n int) { if m == nil { @@ -9383,6 +10734,23 @@ func (m *DataFileInfo) Size() (n int) { if m.CompressionType != 0 { n += 2 + sovBrpb(uint64(m.CompressionType)) } + if m.Crc64Xor != 0 { + n += 2 + sovBrpb(uint64(m.Crc64Xor)) + } + l = len(m.RegionStartKey) + if l > 0 { + n += 2 + l + sovBrpb(uint64(l)) + } + l = len(m.RegionEndKey) + if l > 0 { + n += 2 + l + sovBrpb(uint64(l)) + } + if len(m.RegionEpoch) > 0 { + for _, e := range m.RegionEpoch { + l = e.Size() + n += 2 + l + sovBrpb(uint64(l)) + } + } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } @@ -9415,10 +10783,270 @@ func (m *StreamBackupError) Size() (n int) { return n } -func sovBrpb(x uint64) (n int) { - return (math_bits.Len64(x|1) + 6) / 7 +func (m *Span) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Offset != 0 { + n += 1 + sovBrpb(uint64(m.Offset)) + } + if m.Length != 0 { + n += 1 + sovBrpb(uint64(m.Length)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n } -func sozBrpb(x uint64) (n int) { + +func (m *SpansOfFile) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Path) + if l > 0 { + n += 1 + l + sovBrpb(uint64(l)) + } + if len(m.Spans) > 0 { + for _, e := range m.Spans { + l = e.Size() + n += 1 + l + sovBrpb(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *LogFileSubcompactionMeta) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Size_ != 0 { + n += 1 + sovBrpb(uint64(m.Size_)) + } + if m.RegionId != 0 { + n += 1 + sovBrpb(uint64(m.RegionId)) + } + l = len(m.Cf) + if l > 0 { + n += 1 + l + sovBrpb(uint64(l)) + } + if m.InputMaxTs != 0 { + n += 1 + sovBrpb(uint64(m.InputMaxTs)) + } + if m.InputMinTs != 0 { + n += 1 + sovBrpb(uint64(m.InputMinTs)) + } + if m.CompactFromTs != 0 { + n += 1 + sovBrpb(uint64(m.CompactFromTs)) + } + if m.CompactUntilTs != 0 { + n += 1 + sovBrpb(uint64(m.CompactUntilTs)) + } + l = len(m.MinKey) + if l > 0 { + n += 1 + l + sovBrpb(uint64(l)) + } + l = len(m.MaxKey) + if l > 0 { + n += 1 + l + sovBrpb(uint64(l)) + } + if m.Ty != 0 { + n += 1 + sovBrpb(uint64(m.Ty)) + } + if m.TableId != 0 { + n += 1 + sovBrpb(uint64(m.TableId)) + } + if len(m.Sources) > 0 { + for _, e := range m.Sources { + l = e.Size() + n += 1 + l + sovBrpb(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *LogFileSubcompaction) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Meta != nil { + l = m.Meta.Size() + n += 1 + l + sovBrpb(uint64(l)) + } + if len(m.SstOutputs) > 0 { + for _, e := range m.SstOutputs { + l = e.Size() + n += 1 + l + sovBrpb(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *LogFileSubcompactions) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Subcompactions) > 0 { + for _, e := range m.Subcompactions { + l = e.Size() + n += 1 + l + sovBrpb(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *LogFileCompaction) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.CompactionFromTs != 0 { + n += 1 + sovBrpb(uint64(m.CompactionFromTs)) + } + if m.CompactionUntilTs != 0 { + n += 1 + sovBrpb(uint64(m.CompactionUntilTs)) + } + l = len(m.Name) + if l > 0 { + n += 1 + l + sovBrpb(uint64(l)) + } + l = len(m.Comments) + if l > 0 { + n += 1 + l + sovBrpb(uint64(l)) + } + l = len(m.Artifacts) + if l > 0 { + n += 1 + l + sovBrpb(uint64(l)) + } + if m.ArtifactsHash != 0 { + n += 1 + sovBrpb(uint64(m.ArtifactsHash)) + } + l = len(m.GeneratedFiles) + if l > 0 { + n += 1 + l + sovBrpb(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *MetaEdit) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Path) + if l > 0 { + n += 1 + l + sovBrpb(uint64(l)) + } + if len(m.DeletePhysicalFiles) > 0 { + for _, s := range m.DeletePhysicalFiles { + l = len(s) + n += 1 + l + sovBrpb(uint64(l)) + } + } + if len(m.DeleteLogicalFiles) > 0 { + for _, e := range m.DeleteLogicalFiles { + l = e.Size() + n += 1 + l + sovBrpb(uint64(l)) + } + } + if m.DestructSelf { + n += 2 + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *DeleteSpansOfFile) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Path) + if l > 0 { + n += 1 + l + sovBrpb(uint64(l)) + } + if len(m.Spans) > 0 { + for _, e := range m.Spans { + l = e.Size() + n += 1 + l + sovBrpb(uint64(l)) + } + } + if m.WholeFileLength != 0 { + n += 1 + sovBrpb(uint64(m.WholeFileLength)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *Migration) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.EditMeta) > 0 { + for _, e := range m.EditMeta { + l = e.Size() + n += 1 + l + sovBrpb(uint64(l)) + } + } + if m.TruncatedTo != 0 { + n += 1 + sovBrpb(uint64(m.TruncatedTo)) + } + if len(m.Compactions) > 0 { + for _, e := range m.Compactions { + l = e.Size() + n += 1 + l + sovBrpb(uint64(l)) + } + } + if len(m.DestructPrefix) > 0 { + for _, s := range m.DestructPrefix { + l = len(s) + n += 1 + l + sovBrpb(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func sovBrpb(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozBrpb(x uint64) (n int) { return sovBrpb(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } func (m *PrepareSnapshotBackupRequest) Unmarshal(dAtA []byte) error { @@ -9431,30 +11059,926 @@ func (m *PrepareSnapshotBackupRequest) Unmarshal(dAtA []byte) error { if shift >= 64 { return ErrIntOverflowBrpb } - 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: PrepareSnapshotBackupRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: PrepareSnapshotBackupRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Ty", wireType) + } + m.Ty = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Ty |= PrepareSnapshotBackupRequestType(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Regions", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthBrpb + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthBrpb + } + 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 { + return err + } + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field LeaseInSeconds", wireType) + } + m.LeaseInSeconds = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.LeaseInSeconds |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipBrpb(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthBrpb + } + 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 *PrepareSnapshotBackupResponse) 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 ErrIntOverflowBrpb + } + 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: PrepareSnapshotBackupResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: PrepareSnapshotBackupResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Ty", wireType) + } + m.Ty = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Ty |= PrepareSnapshotBackupEventType(b&0x7F) << shift + if b < 0x80 { + break + } + } + 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 ErrIntOverflowBrpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthBrpb + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthBrpb + } + 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 Error", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthBrpb + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthBrpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Error == nil { + m.Error = &errorpb.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 LastLeaseIsValid", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.LastLeaseIsValid = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := skipBrpb(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthBrpb + } + 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 *BackupMeta) 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 ErrIntOverflowBrpb + } + 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: BackupMeta: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BackupMeta: 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 ErrIntOverflowBrpb + } + 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 ClusterVersion", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + 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 ErrInvalidLengthBrpb + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthBrpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ClusterVersion = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Files", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthBrpb + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthBrpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Files = append(m.Files, &File{}) + if err := m.Files[len(m.Files)-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 StartVersion", wireType) + } + m.StartVersion = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.StartVersion |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field EndVersion", wireType) + } + m.EndVersion = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.EndVersion |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Schemas", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthBrpb + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthBrpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Schemas = append(m.Schemas, &Schema{}) + if err := m.Schemas[len(m.Schemas)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field IsRawKv", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.IsRawKv = bool(v != 0) + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RawRanges", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthBrpb + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthBrpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.RawRanges = append(m.RawRanges, &RawRange{}) + if err := m.RawRanges[len(m.RawRanges)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Ddls", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthBrpb + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthBrpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Ddls = append(m.Ddls[:0], dAtA[iNdEx:postIndex]...) + if m.Ddls == nil { + m.Ddls = []byte{} + } + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BrVersion", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + 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 ErrInvalidLengthBrpb + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthBrpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BrVersion = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 12: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) + } + m.Version = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Version |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 13: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FileIndex", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthBrpb + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthBrpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.FileIndex == nil { + m.FileIndex = &MetaFile{} + } + if err := m.FileIndex.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SchemaIndex", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthBrpb + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthBrpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SchemaIndex == nil { + m.SchemaIndex = &MetaFile{} + } + if err := m.SchemaIndex.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RawRangeIndex", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthBrpb + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthBrpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.RawRangeIndex == nil { + m.RawRangeIndex = &MetaFile{} + } + if err := m.RawRangeIndex.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 16: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DdlIndexes", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthBrpb + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthBrpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.DdlIndexes == nil { + m.DdlIndexes = &MetaFile{} + } + if err := m.DdlIndexes.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 17: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BackupResult", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + 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 ErrInvalidLengthBrpb + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthBrpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BackupResult = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 18: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ApiVersion", wireType) + } + m.ApiVersion = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ApiVersion |= kvrpcpb.APIVersion(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 19: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Policies", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthBrpb + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthBrpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Policies = append(m.Policies, &PlacementPolicy{}) + if err := m.Policies[len(m.Policies)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 20: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NewCollationsEnabled", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + 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 ErrInvalidLengthBrpb + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthBrpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.NewCollationsEnabled = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 21: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field IsTxnKv", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.IsTxnKv = bool(v != 0) + case 22: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DbMaps", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthBrpb + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthBrpb + } + if postIndex > l { return io.ErrUnexpectedEOF } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break + m.DbMaps = append(m.DbMaps, &PitrDBMap{}) + if err := m.DbMaps[len(m.DbMaps)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: PrepareSnapshotBackupRequest: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: PrepareSnapshotBackupRequest: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + iNdEx = postIndex + case 23: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Ty", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Mode", wireType) } - m.Ty = 0 + m.Mode = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -9464,14 +11988,14 @@ func (m *PrepareSnapshotBackupRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Ty |= PrepareSnapshotBackupRequestType(b&0x7F) << shift + m.Mode |= BackupMode(b&0x7F) << shift if b < 0x80 { break } } - case 2: + case 24: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Regions", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Ranges", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -9498,16 +12022,16 @@ func (m *PrepareSnapshotBackupRequest) 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.Ranges = append(m.Ranges, &BackupRange{}) + if err := m.Ranges[len(m.Ranges)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 3: + case 25: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field LeaseInSeconds", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field BackupSize", wireType) } - m.LeaseInSeconds = 0 + m.BackupSize = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -9517,7 +12041,7 @@ func (m *PrepareSnapshotBackupRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.LeaseInSeconds |= uint64(b&0x7F) << shift + m.BackupSize |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -9544,7 +12068,7 @@ func (m *PrepareSnapshotBackupRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *PrepareSnapshotBackupResponse) Unmarshal(dAtA []byte) error { +func (m *BackupRange) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -9567,17 +12091,17 @@ func (m *PrepareSnapshotBackupResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: PrepareSnapshotBackupResponse: wiretype end group for non-group") + return fmt.Errorf("proto: BackupRange: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: PrepareSnapshotBackupResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: BackupRange: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Ty", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StartKey", wireType) } - m.Ty = 0 + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -9587,16 +12111,31 @@ func (m *PrepareSnapshotBackupResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Ty |= PrepareSnapshotBackupEventType(b&0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } + if byteLen < 0 { + return ErrInvalidLengthBrpb + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthBrpb + } + 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 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Region", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field EndKey", wireType) } - var msglen int + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -9606,31 +12145,29 @@ func (m *PrepareSnapshotBackupResponse) 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 ErrInvalidLengthBrpb } - postIndex := iNdEx + msglen + postIndex := iNdEx + byteLen if postIndex < 0 { return ErrInvalidLengthBrpb } 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.EndKey = append(m.EndKey[:0], dAtA[iNdEx:postIndex]...) + if m.EndKey == nil { + m.EndKey = []byte{} } 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 Files", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -9657,33 +12194,11 @@ func (m *PrepareSnapshotBackupResponse) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Error == nil { - m.Error = &errorpb.Error{} - } - if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.Files = append(m.Files, &File{}) + if err := m.Files[len(m.Files)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 4: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field LastLeaseIsValid", wireType) - } - var v int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowBrpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - v |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - m.LastLeaseIsValid = bool(v != 0) default: iNdEx = preIndex skippy, err := skipBrpb(dAtA[iNdEx:]) @@ -9706,7 +12221,7 @@ func (m *PrepareSnapshotBackupResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *BackupMeta) Unmarshal(dAtA []byte) error { +func (m *File) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -9729,17 +12244,17 @@ func (m *BackupMeta) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: BackupMeta: wiretype end group for non-group") + return fmt.Errorf("proto: File: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: BackupMeta: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: File: 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 Name", wireType) } - m.ClusterId = 0 + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -9749,16 +12264,29 @@ func (m *BackupMeta) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.ClusterId |= uint64(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthBrpb + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthBrpb + } + 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 ClusterVersion", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Sha256", wireType) } - var stringLen uint64 + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -9768,29 +12296,65 @@ func (m *BackupMeta) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + if byteLen < 0 { return ErrInvalidLengthBrpb } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + byteLen if postIndex < 0 { return ErrInvalidLengthBrpb } if postIndex > l { return io.ErrUnexpectedEOF } - m.ClusterVersion = string(dAtA[iNdEx:postIndex]) + m.Sha256 = append(m.Sha256[:0], dAtA[iNdEx:postIndex]...) + if m.Sha256 == nil { + m.Sha256 = []byte{} + } + iNdEx = postIndex + case 3: + 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 ErrIntOverflowBrpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthBrpb + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthBrpb + } + 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 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Files", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field EndKey", wireType) } - var msglen int + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -9800,24 +12364,24 @@ func (m *BackupMeta) 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 ErrInvalidLengthBrpb } - postIndex := iNdEx + msglen + postIndex := iNdEx + byteLen if postIndex < 0 { return ErrInvalidLengthBrpb } if postIndex > l { return io.ErrUnexpectedEOF } - m.Files = append(m.Files, &File{}) - if err := m.Files[len(m.Files)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + m.EndKey = append(m.EndKey[:0], dAtA[iNdEx:postIndex]...) + if m.EndKey == nil { + m.EndKey = []byte{} } iNdEx = postIndex case 5: @@ -9859,10 +12423,10 @@ func (m *BackupMeta) Unmarshal(dAtA []byte) error { } } case 7: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Schemas", wireType) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Crc64Xor", wireType) } - var msglen int + m.Crc64Xor = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -9872,31 +12436,16 @@ func (m *BackupMeta) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + m.Crc64Xor |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { - return ErrInvalidLengthBrpb - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthBrpb - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Schemas = append(m.Schemas, &Schema{}) - if err := m.Schemas[len(m.Schemas)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex case 8: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field IsRawKv", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field TotalKvs", wireType) } - var v int + m.TotalKvs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -9906,17 +12455,16 @@ func (m *BackupMeta) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - v |= int(b&0x7F) << shift + m.TotalKvs |= uint64(b&0x7F) << shift if b < 0x80 { break } } - m.IsRawKv = bool(v != 0) case 9: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field RawRanges", wireType) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field TotalBytes", wireType) } - var msglen int + m.TotalBytes = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -9926,31 +12474,16 @@ func (m *BackupMeta) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + m.TotalBytes |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { - return ErrInvalidLengthBrpb - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthBrpb - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.RawRanges = append(m.RawRanges, &RawRange{}) - if err := m.RawRanges[len(m.RawRanges)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex case 10: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Ddls", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Cf", wireType) } - var byteLen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -9960,31 +12493,29 @@ func (m *BackupMeta) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return ErrInvalidLengthBrpb } - postIndex := iNdEx + byteLen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthBrpb } if postIndex > l { return io.ErrUnexpectedEOF } - m.Ddls = append(m.Ddls[:0], dAtA[iNdEx:postIndex]...) - if m.Ddls == nil { - m.Ddls = []byte{} - } + m.Cf = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 11: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field BrVersion", wireType) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Size_", wireType) } - var stringLen uint64 + m.Size_ = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -9994,29 +12525,16 @@ func (m *BackupMeta) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + m.Size_ |= uint64(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthBrpb - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthBrpb - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.BrVersion = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex case 12: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CipherIv", wireType) } - m.Version = 0 + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -10026,14 +12544,80 @@ func (m *BackupMeta) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Version |= int32(b&0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } - case 13: + if byteLen < 0 { + return ErrInvalidLengthBrpb + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthBrpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.CipherIv = append(m.CipherIv[:0], dAtA[iNdEx:postIndex]...) + if m.CipherIv == nil { + m.CipherIv = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipBrpb(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthBrpb + } + 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 *MetaFile) 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 ErrIntOverflowBrpb + } + 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: MetaFile: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MetaFile: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field FileIndex", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field MetaFiles", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -10060,16 +12644,14 @@ func (m *BackupMeta) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.FileIndex == nil { - m.FileIndex = &MetaFile{} - } - if err := m.FileIndex.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.MetaFiles = append(m.MetaFiles, &File{}) + if err := m.MetaFiles[len(m.MetaFiles)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 14: + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field SchemaIndex", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field DataFiles", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -10096,16 +12678,14 @@ func (m *BackupMeta) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.SchemaIndex == nil { - m.SchemaIndex = &MetaFile{} - } - if err := m.SchemaIndex.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.DataFiles = append(m.DataFiles, &File{}) + if err := m.DataFiles[len(m.DataFiles)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 15: + case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field RawRangeIndex", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Schemas", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -10132,16 +12712,14 @@ func (m *BackupMeta) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.RawRangeIndex == nil { - m.RawRangeIndex = &MetaFile{} - } - if err := m.RawRangeIndex.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.Schemas = append(m.Schemas, &Schema{}) + if err := m.Schemas[len(m.Schemas)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 16: + case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field DdlIndexes", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field RawRanges", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -10168,18 +12746,16 @@ func (m *BackupMeta) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.DdlIndexes == nil { - m.DdlIndexes = &MetaFile{} - } - if err := m.DdlIndexes.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.RawRanges = append(m.RawRanges, &RawRange{}) + if err := m.RawRanges[len(m.RawRanges)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 17: + case 5: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field BackupResult", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Ddls", wireType) } - var stringLen uint64 + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -10189,29 +12765,29 @@ func (m *BackupMeta) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + if byteLen < 0 { return ErrInvalidLengthBrpb } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + byteLen if postIndex < 0 { return ErrInvalidLengthBrpb } if postIndex > l { return io.ErrUnexpectedEOF } - m.BackupResult = string(dAtA[iNdEx:postIndex]) + m.Ddls = append(m.Ddls, make([]byte, postIndex-iNdEx)) + copy(m.Ddls[len(m.Ddls)-1], dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 18: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field ApiVersion", wireType) + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BackupRanges", wireType) } - m.ApiVersion = 0 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -10221,16 +12797,82 @@ func (m *BackupMeta) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.ApiVersion |= kvrpcpb.APIVersion(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - case 19: + if msglen < 0 { + return ErrInvalidLengthBrpb + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthBrpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BackupRanges = append(m.BackupRanges, &BackupRange{}) + if err := m.BackupRanges[len(m.BackupRanges)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipBrpb(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthBrpb + } + 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 *PlacementPolicy) 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 ErrIntOverflowBrpb + } + 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: PlacementPolicy: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: PlacementPolicy: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Policies", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Info", wireType) } - var msglen int + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -10240,63 +12882,82 @@ func (m *BackupMeta) 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 ErrInvalidLengthBrpb } - postIndex := iNdEx + msglen + postIndex := iNdEx + byteLen if postIndex < 0 { return ErrInvalidLengthBrpb } if postIndex > l { return io.ErrUnexpectedEOF } - m.Policies = append(m.Policies, &PlacementPolicy{}) - if err := m.Policies[len(m.Policies)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + m.Info = append(m.Info[:0], dAtA[iNdEx:postIndex]...) + if m.Info == nil { + m.Info = []byte{} } iNdEx = postIndex - case 20: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field NewCollationsEnabled", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowBrpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - stringLen |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } + default: + iNdEx = preIndex + skippy, err := skipBrpb(dAtA[iNdEx:]) + if err != nil { + return err } - intStringLen := int(stringLen) - if intStringLen < 0 { + if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthBrpb } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthBrpb + 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 *StatsBlock) 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 ErrIntOverflowBrpb + } + if iNdEx >= l { return io.ErrUnexpectedEOF } - m.NewCollationsEnabled = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 21: + 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: StatsBlock: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: StatsBlock: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field IsTxnKv", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field PhysicalId", wireType) } - var v int + m.PhysicalId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -10306,17 +12967,16 @@ func (m *BackupMeta) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - v |= int(b&0x7F) << shift + m.PhysicalId |= int64(b&0x7F) << shift if b < 0x80 { break } } - m.IsTxnKv = bool(v != 0) - case 22: + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field DbMaps", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field JsonTable", wireType) } - var msglen int + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -10326,48 +12986,80 @@ func (m *BackupMeta) 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 ErrInvalidLengthBrpb } - postIndex := iNdEx + msglen + postIndex := iNdEx + byteLen if postIndex < 0 { return ErrInvalidLengthBrpb } if postIndex > l { return io.ErrUnexpectedEOF } - m.DbMaps = append(m.DbMaps, &PitrDBMap{}) - if err := m.DbMaps[len(m.DbMaps)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + m.JsonTable = append(m.JsonTable[:0], dAtA[iNdEx:postIndex]...) + if m.JsonTable == nil { + m.JsonTable = []byte{} } iNdEx = postIndex - case 23: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Mode", wireType) + default: + iNdEx = preIndex + skippy, err := skipBrpb(dAtA[iNdEx:]) + if err != nil { + return err } - m.Mode = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowBrpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.Mode |= BackupMode(b&0x7F) << shift - if b < 0x80 { - break - } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthBrpb } - case 24: + 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 *StatsFile) 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 ErrIntOverflowBrpb + } + 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: StatsFile: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: StatsFile: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Ranges", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Blocks", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -10394,30 +13086,11 @@ func (m *BackupMeta) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Ranges = append(m.Ranges, &BackupRange{}) - if err := m.Ranges[len(m.Ranges)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.Blocks = append(m.Blocks, &StatsBlock{}) + if err := m.Blocks[len(m.Blocks)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 25: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field BackupSize", wireType) - } - m.BackupSize = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowBrpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.BackupSize |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } default: iNdEx = preIndex skippy, err := skipBrpb(dAtA[iNdEx:]) @@ -10440,7 +13113,7 @@ func (m *BackupMeta) Unmarshal(dAtA []byte) error { } return nil } -func (m *BackupRange) Unmarshal(dAtA []byte) error { +func (m *StatsFileIndex) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -10463,15 +13136,47 @@ func (m *BackupRange) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: BackupRange: wiretype end group for non-group") + return fmt.Errorf("proto: StatsFileIndex: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: BackupRange: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: StatsFileIndex: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field StartKey", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + 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 ErrInvalidLengthBrpb + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthBrpb + } + 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 Sha256", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { @@ -10498,14 +13203,52 @@ func (m *BackupRange) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.StartKey = append(m.StartKey[:0], dAtA[iNdEx:postIndex]...) - if m.StartKey == nil { - m.StartKey = []byte{} + m.Sha256 = append(m.Sha256[:0], dAtA[iNdEx:postIndex]...) + if m.Sha256 == nil { + m.Sha256 = []byte{} } iNdEx = postIndex - case 2: + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field SizeEnc", wireType) + } + m.SizeEnc = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.SizeEnc |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field SizeOri", wireType) + } + m.SizeOri = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.SizeOri |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 5: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field EndKey", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field CipherIv", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { @@ -10532,16 +13275,16 @@ func (m *BackupRange) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.EndKey = append(m.EndKey[:0], dAtA[iNdEx:postIndex]...) - if m.EndKey == nil { - m.EndKey = []byte{} + m.CipherIv = append(m.CipherIv[:0], dAtA[iNdEx:postIndex]...) + if m.CipherIv == nil { + m.CipherIv = []byte{} } iNdEx = postIndex - case 3: + case 6: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Files", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field InlineData", wireType) } - var msglen int + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -10551,24 +13294,24 @@ func (m *BackupRange) 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 ErrInvalidLengthBrpb } - postIndex := iNdEx + msglen + postIndex := iNdEx + byteLen if postIndex < 0 { return ErrInvalidLengthBrpb } if postIndex > l { return io.ErrUnexpectedEOF } - m.Files = append(m.Files, &File{}) - if err := m.Files[len(m.Files)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + m.InlineData = append(m.InlineData[:0], dAtA[iNdEx:postIndex]...) + if m.InlineData == nil { + m.InlineData = []byte{} } iNdEx = postIndex default: @@ -10593,7 +13336,7 @@ func (m *BackupRange) Unmarshal(dAtA []byte) error { } return nil } -func (m *File) Unmarshal(dAtA []byte) error { +func (m *Schema) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -10616,17 +13359,17 @@ func (m *File) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: File: wiretype end group for non-group") + return fmt.Errorf("proto: Schema: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: File: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: Schema: 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) + return fmt.Errorf("proto: wrong wireType = %d for field Db", wireType) } - var stringLen uint64 + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -10636,27 +13379,29 @@ func (m *File) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + if byteLen < 0 { return ErrInvalidLengthBrpb } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + byteLen if postIndex < 0 { return ErrInvalidLengthBrpb } if postIndex > l { return io.ErrUnexpectedEOF } - m.Name = string(dAtA[iNdEx:postIndex]) + m.Db = append(m.Db[:0], dAtA[iNdEx:postIndex]...) + if m.Db == nil { + m.Db = []byte{} + } iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Sha256", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Table", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { @@ -10683,16 +13428,16 @@ func (m *File) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Sha256 = append(m.Sha256[:0], dAtA[iNdEx:postIndex]...) - if m.Sha256 == nil { - m.Sha256 = []byte{} + m.Table = append(m.Table[:0], dAtA[iNdEx:postIndex]...) + if m.Table == nil { + m.Table = []byte{} } iNdEx = postIndex case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field StartKey", wireType) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Crc64Xor", wireType) } - var byteLen int + m.Crc64Xor = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -10702,31 +13447,16 @@ func (m *File) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= int(b&0x7F) << shift + m.Crc64Xor |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { - return ErrInvalidLengthBrpb - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthBrpb - } - 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 4: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field EndKey", wireType) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field TotalKvs", wireType) } - var byteLen int + m.TotalKvs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -10736,31 +13466,16 @@ func (m *File) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= int(b&0x7F) << shift + m.TotalKvs |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { - return ErrInvalidLengthBrpb - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthBrpb - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.EndKey = append(m.EndKey[:0], dAtA[iNdEx:postIndex]...) - if m.EndKey == nil { - m.EndKey = []byte{} - } - iNdEx = postIndex case 5: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field StartVersion", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field TotalBytes", wireType) } - m.StartVersion = 0 + m.TotalBytes = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -10770,16 +13485,16 @@ func (m *File) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.StartVersion |= uint64(b&0x7F) << shift + m.TotalBytes |= uint64(b&0x7F) << shift if b < 0x80 { break } } case 6: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field EndVersion", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field TiflashReplicas", wireType) } - m.EndVersion = 0 + m.TiflashReplicas = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -10789,16 +13504,16 @@ func (m *File) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.EndVersion |= uint64(b&0x7F) << shift + m.TiflashReplicas |= uint32(b&0x7F) << shift if b < 0x80 { break } } case 7: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Crc64Xor", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Stats", wireType) } - m.Crc64Xor = 0 + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -10808,54 +13523,31 @@ func (m *File) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Crc64Xor |= uint64(b&0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } - case 8: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field TotalKvs", wireType) + if byteLen < 0 { + return ErrInvalidLengthBrpb } - m.TotalKvs = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowBrpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.TotalKvs |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthBrpb } - case 9: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field TotalBytes", wireType) + if postIndex > l { + return io.ErrUnexpectedEOF } - m.TotalBytes = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowBrpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.TotalBytes |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } + m.Stats = append(m.Stats[:0], dAtA[iNdEx:postIndex]...) + if m.Stats == nil { + m.Stats = []byte{} } - case 10: + iNdEx = postIndex + case 8: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Cf", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field StatsIndex", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -10865,29 +13557,82 @@ func (m *File) 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 ErrInvalidLengthBrpb } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthBrpb } - if postIndex > l { + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.StatsIndex = append(m.StatsIndex, &StatsFileIndex{}) + if err := m.StatsIndex[len(m.StatsIndex)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipBrpb(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthBrpb + } + 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 *IDMap) 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 ErrIntOverflowBrpb + } + if iNdEx >= l { return io.ErrUnexpectedEOF } - m.Cf = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 11: + 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: IDMap: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: IDMap: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Size_", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field UpstreamId", wireType) } - m.Size_ = 0 + m.UpstreamId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -10897,16 +13642,16 @@ func (m *File) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Size_ |= uint64(b&0x7F) << shift + m.UpstreamId |= int64(b&0x7F) << shift if b < 0x80 { break } } - case 12: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field CipherIv", wireType) + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field DownstreamId", wireType) } - var byteLen int + m.DownstreamId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -10916,26 +13661,11 @@ func (m *File) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= int(b&0x7F) << shift + m.DownstreamId |= int64(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { - return ErrInvalidLengthBrpb - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthBrpb - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.CipherIv = append(m.CipherIv[:0], dAtA[iNdEx:postIndex]...) - if m.CipherIv == nil { - m.CipherIv = []byte{} - } - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipBrpb(dAtA[iNdEx:]) @@ -10958,7 +13688,7 @@ func (m *File) Unmarshal(dAtA []byte) error { } return nil } -func (m *MetaFile) Unmarshal(dAtA []byte) error { +func (m *PitrTableMap) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -10981,17 +13711,17 @@ func (m *MetaFile) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MetaFile: wiretype end group for non-group") + return fmt.Errorf("proto: PitrTableMap: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MetaFile: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: PitrTableMap: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field MetaFiles", 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 ErrIntOverflowBrpb @@ -11001,29 +13731,27 @@ func (m *MetaFile) 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 ErrInvalidLengthBrpb } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthBrpb } if postIndex > l { return io.ErrUnexpectedEOF } - m.MetaFiles = append(m.MetaFiles, &File{}) - if err := m.MetaFiles[len(m.MetaFiles)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.Name = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field DataFiles", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field IdMap", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -11050,14 +13778,16 @@ func (m *MetaFile) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.DataFiles = append(m.DataFiles, &File{}) - if err := m.DataFiles[len(m.DataFiles)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if m.IdMap == nil { + m.IdMap = &IDMap{} + } + if err := m.IdMap.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Schemas", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Partitions", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -11084,16 +13814,67 @@ func (m *MetaFile) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Schemas = append(m.Schemas, &Schema{}) - if err := m.Schemas[len(m.Schemas)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.Partitions = append(m.Partitions, &IDMap{}) + if err := m.Partitions[len(m.Partitions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 4: + default: + iNdEx = preIndex + skippy, err := skipBrpb(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthBrpb + } + 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 *PitrDBMap) 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 ErrIntOverflowBrpb + } + 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: PitrDBMap: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: PitrDBMap: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field RawRanges", 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 ErrIntOverflowBrpb @@ -11103,31 +13884,29 @@ func (m *MetaFile) 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 ErrInvalidLengthBrpb } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthBrpb } if postIndex > l { return io.ErrUnexpectedEOF } - m.RawRanges = append(m.RawRanges, &RawRange{}) - if err := m.RawRanges[len(m.RawRanges)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.Name = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 5: + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Ddls", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field IdMap", wireType) } - var byteLen int + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -11137,27 +13916,31 @@ func (m *MetaFile) 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 ErrInvalidLengthBrpb } - postIndex := iNdEx + byteLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthBrpb } if postIndex > l { return io.ErrUnexpectedEOF } - m.Ddls = append(m.Ddls, make([]byte, postIndex-iNdEx)) - copy(m.Ddls[len(m.Ddls)-1], dAtA[iNdEx:postIndex]) + if m.IdMap == nil { + m.IdMap = &IDMap{} + } + if err := m.IdMap.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } iNdEx = postIndex - case 6: + case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field BackupRanges", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Tables", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -11184,8 +13967,8 @@ func (m *MetaFile) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.BackupRanges = append(m.BackupRanges, &BackupRange{}) - if err := m.BackupRanges[len(m.BackupRanges)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.Tables = append(m.Tables, &PitrTableMap{}) + if err := m.Tables[len(m.Tables)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -11211,7 +13994,7 @@ func (m *MetaFile) Unmarshal(dAtA []byte) error { } return nil } -func (m *PlacementPolicy) Unmarshal(dAtA []byte) error { +func (m *RawRange) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -11234,15 +14017,15 @@ func (m *PlacementPolicy) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: PlacementPolicy: wiretype end group for non-group") + return fmt.Errorf("proto: RawRange: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: PlacementPolicy: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: RawRange: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Info", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field StartKey", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { @@ -11269,67 +14052,16 @@ func (m *PlacementPolicy) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Info = append(m.Info[:0], dAtA[iNdEx:postIndex]...) - if m.Info == nil { - m.Info = []byte{} - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipBrpb(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthBrpb - } - 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 *StatsBlock) 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 ErrIntOverflowBrpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break + m.StartKey = append(m.StartKey[:0], dAtA[iNdEx:postIndex]...) + if m.StartKey == nil { + m.StartKey = []byte{} } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: StatsBlock: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: StatsBlock: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field PhysicalId", wireType) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EndKey", wireType) } - m.PhysicalId = 0 + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -11339,16 +14071,31 @@ func (m *StatsBlock) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.PhysicalId |= int64(b&0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } - case 2: + if byteLen < 0 { + return ErrInvalidLengthBrpb + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthBrpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.EndKey = append(m.EndKey[:0], dAtA[iNdEx:postIndex]...) + if m.EndKey == nil { + m.EndKey = []byte{} + } + iNdEx = postIndex + case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field JsonTable", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Cf", wireType) } - var byteLen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -11358,25 +14105,23 @@ func (m *StatsBlock) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return ErrInvalidLengthBrpb } - postIndex := iNdEx + byteLen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthBrpb } if postIndex > l { return io.ErrUnexpectedEOF } - m.JsonTable = append(m.JsonTable[:0], dAtA[iNdEx:postIndex]...) - if m.JsonTable == nil { - m.JsonTable = []byte{} - } + m.Cf = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex @@ -11400,7 +14145,7 @@ func (m *StatsBlock) Unmarshal(dAtA []byte) error { } return nil } -func (m *StatsFile) Unmarshal(dAtA []byte) error { +func (m *ClusterIDError) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -11423,17 +14168,17 @@ func (m *StatsFile) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: StatsFile: wiretype end group for non-group") + return fmt.Errorf("proto: ClusterIDError: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: StatsFile: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: ClusterIDError: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Blocks", wireType) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Current", wireType) } - var msglen int + m.Current = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -11443,26 +14188,30 @@ func (m *StatsFile) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + m.Current |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { - return ErrInvalidLengthBrpb - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthBrpb - } - if postIndex > l { - return io.ErrUnexpectedEOF + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Request", wireType) } - m.Blocks = append(m.Blocks, &StatsBlock{}) - if err := m.Blocks[len(m.Blocks)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + m.Request = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Request |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } } - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipBrpb(dAtA[iNdEx:]) @@ -11485,7 +14234,7 @@ func (m *StatsFile) Unmarshal(dAtA []byte) error { } return nil } -func (m *StatsFileIndex) Unmarshal(dAtA []byte) error { +func (m *Error) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -11508,15 +14257,15 @@ func (m *StatsFileIndex) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: StatsFileIndex: wiretype end group for non-group") + return fmt.Errorf("proto: Error: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: StatsFileIndex: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: Error: 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) + return fmt.Errorf("proto: wrong wireType = %d for field Msg", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -11544,13 +14293,13 @@ func (m *StatsFileIndex) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Name = string(dAtA[iNdEx:postIndex]) + m.Msg = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 2: + case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Sha256", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ClusterIdError", wireType) } - var byteLen int + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -11560,31 +14309,32 @@ func (m *StatsFileIndex) 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 ErrInvalidLengthBrpb } - postIndex := iNdEx + byteLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthBrpb } if postIndex > l { return io.ErrUnexpectedEOF } - m.Sha256 = append(m.Sha256[:0], dAtA[iNdEx:postIndex]...) - if m.Sha256 == nil { - m.Sha256 = []byte{} + v := &ClusterIDError{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } + m.Detail = &Error_ClusterIdError{v} iNdEx = postIndex - case 3: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field SizeEnc", wireType) + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field KvError", wireType) } - m.SizeEnc = 0 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -11594,16 +14344,32 @@ func (m *StatsFileIndex) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.SizeEnc |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - case 4: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field SizeOri", wireType) + if msglen < 0 { + return ErrInvalidLengthBrpb } - m.SizeOri = 0 + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthBrpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &kvrpcpb.KeyError{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Detail = &Error_KvError{v} + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RegionError", wireType) + } + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -11613,16 +14379,83 @@ func (m *StatsFileIndex) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.SizeOri |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - case 5: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field CipherIv", wireType) + if msglen < 0 { + return ErrInvalidLengthBrpb } - var byteLen int + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthBrpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &errorpb.Error{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Detail = &Error_RegionError{v} + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipBrpb(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthBrpb + } + 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 *CipherInfo) 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 ErrIntOverflowBrpb + } + 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: CipherInfo: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CipherInfo: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CipherType", wireType) + } + m.CipherType = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -11632,29 +14465,14 @@ func (m *StatsFileIndex) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= int(b&0x7F) << shift + m.CipherType |= encryptionpb.EncryptionMethod(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { - return ErrInvalidLengthBrpb - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthBrpb - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.CipherIv = append(m.CipherIv[:0], dAtA[iNdEx:postIndex]...) - if m.CipherIv == nil { - m.CipherIv = []byte{} - } - iNdEx = postIndex - case 6: + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field InlineData", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field CipherKey", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { @@ -11681,9 +14499,9 @@ func (m *StatsFileIndex) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.InlineData = append(m.InlineData[:0], dAtA[iNdEx:postIndex]...) - if m.InlineData == nil { - m.InlineData = []byte{} + m.CipherKey = append(m.CipherKey[:0], dAtA[iNdEx:postIndex]...) + if m.CipherKey == nil { + m.CipherKey = []byte{} } iNdEx = postIndex default: @@ -11708,7 +14526,7 @@ func (m *StatsFileIndex) Unmarshal(dAtA []byte) error { } return nil } -func (m *Schema) Unmarshal(dAtA []byte) error { +func (m *BackupRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -11731,17 +14549,17 @@ func (m *Schema) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: Schema: wiretype end group for non-group") + return fmt.Errorf("proto: BackupRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: Schema: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: BackupRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Db", wireType) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ClusterId", wireType) } - var byteLen int + m.ClusterId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -11751,29 +14569,14 @@ func (m *Schema) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= int(b&0x7F) << shift + m.ClusterId |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { - return ErrInvalidLengthBrpb - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthBrpb - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Db = append(m.Db[:0], dAtA[iNdEx:postIndex]...) - if m.Db == nil { - m.Db = []byte{} - } - iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Table", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field StartKey", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { @@ -11800,16 +14603,16 @@ func (m *Schema) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Table = append(m.Table[:0], dAtA[iNdEx:postIndex]...) - if m.Table == nil { - m.Table = []byte{} + 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 Crc64Xor", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EndKey", wireType) } - m.Crc64Xor = 0 + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -11819,16 +14622,31 @@ func (m *Schema) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Crc64Xor |= uint64(b&0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } + if byteLen < 0 { + return ErrInvalidLengthBrpb + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthBrpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.EndKey = append(m.EndKey[:0], dAtA[iNdEx:postIndex]...) + if m.EndKey == nil { + m.EndKey = []byte{} + } + iNdEx = postIndex case 4: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field TotalKvs", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field StartVersion", wireType) } - m.TotalKvs = 0 + m.StartVersion = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -11838,16 +14656,16 @@ func (m *Schema) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.TotalKvs |= uint64(b&0x7F) << shift + m.StartVersion |= uint64(b&0x7F) << shift if b < 0x80 { break } } case 5: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field TotalBytes", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field EndVersion", wireType) } - m.TotalBytes = 0 + m.EndVersion = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -11857,16 +14675,16 @@ func (m *Schema) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.TotalBytes |= uint64(b&0x7F) << shift + m.EndVersion |= uint64(b&0x7F) << shift if b < 0x80 { break } } - case 6: + case 7: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field TiflashReplicas", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field RateLimit", wireType) } - m.TiflashReplicas = 0 + m.RateLimit = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -11876,16 +14694,16 @@ func (m *Schema) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.TiflashReplicas |= uint32(b&0x7F) << shift + m.RateLimit |= uint64(b&0x7F) << shift if b < 0x80 { break } } - case 7: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Stats", wireType) + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Concurrency", wireType) } - var byteLen int + m.Concurrency = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -11895,29 +14713,14 @@ func (m *Schema) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= int(b&0x7F) << shift + m.Concurrency |= uint32(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { - return ErrInvalidLengthBrpb - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthBrpb - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Stats = append(m.Stats[:0], dAtA[iNdEx:postIndex]...) - if m.Stats == nil { - m.Stats = []byte{} - } - iNdEx = postIndex - case 8: + case 9: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field StatsIndex", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field StorageBackend", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -11944,86 +14747,18 @@ func (m *Schema) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.StatsIndex = append(m.StatsIndex, &StatsFileIndex{}) - if err := m.StatsIndex[len(m.StatsIndex)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + if m.StorageBackend == nil { + m.StorageBackend = &StorageBackend{} } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipBrpb(dAtA[iNdEx:]) - if err != nil { + if err := m.StorageBackend.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthBrpb - } - 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 *IDMap) 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 ErrIntOverflowBrpb - } - 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: IDMap: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: IDMap: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field UpstreamId", wireType) - } - m.UpstreamId = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowBrpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.UpstreamId |= int64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 2: + iNdEx = postIndex + case 10: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field DownstreamId", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field IsRawKv", wireType) } - m.DownstreamId = 0 + var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -12033,65 +14768,15 @@ func (m *IDMap) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.DownstreamId |= int64(b&0x7F) << shift + v |= int(b&0x7F) << shift if b < 0x80 { break } } - default: - iNdEx = preIndex - skippy, err := skipBrpb(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthBrpb - } - 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 *PitrTableMap) 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 ErrIntOverflowBrpb - } - 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: PitrTableMap: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: PitrTableMap: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + m.IsRawKv = bool(v != 0) + case 11: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Cf", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -12119,11 +14804,49 @@ func (m *PitrTableMap) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Name = string(dAtA[iNdEx:postIndex]) + m.Cf = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 2: + case 12: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CompressionType", wireType) + } + m.CompressionType = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.CompressionType |= CompressionType(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CompressionLevel", wireType) + } + m.CompressionLevel = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.CompressionLevel |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 14: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field IdMap", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field CipherInfo", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -12150,16 +14873,35 @@ func (m *PitrTableMap) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.IdMap == nil { - m.IdMap = &IDMap{} + if m.CipherInfo == nil { + m.CipherInfo = &CipherInfo{} } - if err := m.IdMap.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.CipherInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 3: + case 15: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field DstApiVersion", wireType) + } + m.DstApiVersion = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.DstApiVersion |= kvrpcpb.APIVersion(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 16: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Partitions", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field SubRanges", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -12186,67 +14928,16 @@ func (m *PitrTableMap) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Partitions = append(m.Partitions, &IDMap{}) - if err := m.Partitions[len(m.Partitions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.SubRanges = append(m.SubRanges, &kvrpcpb.KeyRange{}) + if err := m.SubRanges[len(m.SubRanges)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipBrpb(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthBrpb - } - 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 *PitrDBMap) 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 ErrIntOverflowBrpb - } - 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: PitrDBMap: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: PitrDBMap: 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 17: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ReplicaRead", wireType) } - var stringLen uint64 + var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -12256,29 +14947,36 @@ func (m *PitrDBMap) 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 ErrInvalidLengthBrpb - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthBrpb + m.ReplicaRead = bool(v != 0) + case 18: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Mode", wireType) } - if postIndex > l { - return io.ErrUnexpectedEOF + m.Mode = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Mode |= BackupMode(b&0x7F) << shift + if b < 0x80 { + break + } } - m.Name = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 2: + case 19: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field IdMap", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field UniqueId", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -12288,31 +14986,27 @@ func (m *PitrDBMap) 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 ErrInvalidLengthBrpb } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthBrpb } if postIndex > l { return io.ErrUnexpectedEOF } - if m.IdMap == nil { - m.IdMap = &IDMap{} - } - if err := m.IdMap.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.UniqueId = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 3: + case 20: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Tables", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -12339,8 +15033,10 @@ func (m *PitrDBMap) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Tables = append(m.Tables, &PitrTableMap{}) - if err := m.Tables[len(m.Tables)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if m.Context == nil { + m.Context = &kvrpcpb.Context{} + } + if err := m.Context.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -12366,7 +15062,7 @@ func (m *PitrDBMap) Unmarshal(dAtA []byte) error { } return nil } -func (m *RawRange) Unmarshal(dAtA []byte) error { +func (m *StreamBackupTaskInfo) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -12389,17 +15085,72 @@ func (m *RawRange) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: RawRange: wiretype end group for non-group") + return fmt.Errorf("proto: StreamBackupTaskInfo: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: RawRange: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: StreamBackupTaskInfo: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field StartKey", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Storage", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthBrpb + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthBrpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Storage == nil { + m.Storage = &StorageBackend{} + } + if err := m.Storage.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field StartTs", wireType) + } + m.StartTs = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.StartTs |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } } - var byteLen int + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field EndTs", wireType) + } + m.EndTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -12409,31 +15160,16 @@ func (m *RawRange) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= int(b&0x7F) << shift + m.EndTs |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { - return ErrInvalidLengthBrpb - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthBrpb - } - 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 2: + case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field EndKey", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) } - var byteLen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -12443,29 +15179,27 @@ func (m *RawRange) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return ErrInvalidLengthBrpb } - postIndex := iNdEx + byteLen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthBrpb } if postIndex > l { return io.ErrUnexpectedEOF } - m.EndKey = append(m.EndKey[:0], dAtA[iNdEx:postIndex]...) - if m.EndKey == nil { - m.EndKey = []byte{} - } + m.Name = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 3: + case 5: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Cf", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field TableFilter", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -12493,8 +15227,27 @@ func (m *RawRange) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Cf = string(dAtA[iNdEx:postIndex]) + m.TableFilter = append(m.TableFilter, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CompressionType", wireType) + } + m.CompressionType = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.CompressionType |= CompressionType(b&0x7F) << shift + if b < 0x80 { + break + } + } default: iNdEx = preIndex skippy, err := skipBrpb(dAtA[iNdEx:]) @@ -12517,7 +15270,7 @@ func (m *RawRange) Unmarshal(dAtA []byte) error { } return nil } -func (m *ClusterIDError) Unmarshal(dAtA []byte) error { +func (m *StorageBackend) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -12540,17 +15293,17 @@ func (m *ClusterIDError) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: ClusterIDError: wiretype end group for non-group") + return fmt.Errorf("proto: StorageBackend: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: ClusterIDError: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: StorageBackend: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Current", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Noop", wireType) } - m.Current = 0 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -12560,16 +15313,32 @@ func (m *ClusterIDError) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Current |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } + if msglen < 0 { + return ErrInvalidLengthBrpb + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthBrpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &Noop{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Backend = &StorageBackend_Noop{v} + iNdEx = postIndex case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Request", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Local", wireType) } - m.Request = 0 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -12579,67 +15348,67 @@ func (m *ClusterIDError) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Request |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - default: - iNdEx = preIndex - skippy, err := skipBrpb(dAtA[iNdEx:]) - if err != nil { - return err + if msglen < 0 { + return ErrInvalidLengthBrpb } - if (skippy < 0) || (iNdEx+skippy) < 0 { + postIndex := iNdEx + msglen + if postIndex < 0 { return ErrInvalidLengthBrpb } - 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 *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 ErrIntOverflowBrpb + v := &Local{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } - if iNdEx >= l { + m.Backend = &StorageBackend_Local{v} + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field S3", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthBrpb + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthBrpb + } + if postIndex > l { return io.ErrUnexpectedEOF } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break + v := &S3{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } - } - 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: + m.Backend = &StorageBackend_S3{v} + iNdEx = postIndex + case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Msg", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Gcs", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -12649,27 +15418,30 @@ func (m *Error) 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 ErrInvalidLengthBrpb } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthBrpb } if postIndex > l { return io.ErrUnexpectedEOF } - m.Msg = string(dAtA[iNdEx:postIndex]) + v := &GCS{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Backend = &StorageBackend_Gcs{v} iNdEx = postIndex - case 3: + case 5: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ClusterIdError", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field CloudDynamic", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -12696,15 +15468,15 @@ func (m *Error) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &ClusterIDError{} + v := &CloudDynamic{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.Detail = &Error_ClusterIdError{v} + m.Backend = &StorageBackend_CloudDynamic{v} iNdEx = postIndex - case 4: + case 6: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field KvError", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Hdfs", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -12731,15 +15503,15 @@ func (m *Error) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &kvrpcpb.KeyError{} + v := &HDFS{} if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.Detail = &Error_KvError{v} + m.Backend = &StorageBackend_Hdfs{v} iNdEx = postIndex - case 5: + case 7: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field RegionError", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field AzureBlobStorage", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -12763,15 +15535,66 @@ func (m *Error) Unmarshal(dAtA []byte) error { if postIndex < 0 { return ErrInvalidLengthBrpb } - if postIndex > l { + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &AzureBlobStorage{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Backend = &StorageBackend_AzureBlobStorage{v} + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipBrpb(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthBrpb + } + 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 *Noop) 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 ErrIntOverflowBrpb + } + if iNdEx >= l { return io.ErrUnexpectedEOF } - v := &errorpb.Error{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break } - m.Detail = &Error_RegionError{v} - iNdEx = postIndex + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Noop: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Noop: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { default: iNdEx = preIndex skippy, err := skipBrpb(dAtA[iNdEx:]) @@ -12794,7 +15617,7 @@ func (m *Error) Unmarshal(dAtA []byte) error { } return nil } -func (m *CipherInfo) Unmarshal(dAtA []byte) error { +func (m *Local) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -12817,36 +15640,17 @@ func (m *CipherInfo) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: CipherInfo: wiretype end group for non-group") + return fmt.Errorf("proto: Local: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: CipherInfo: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: Local: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field CipherType", wireType) - } - m.CipherType = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowBrpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.CipherType |= encryptionpb.EncryptionMethod(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field CipherKey", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType) } - var byteLen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -12856,25 +15660,23 @@ func (m *CipherInfo) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return ErrInvalidLengthBrpb } - postIndex := iNdEx + byteLen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthBrpb } if postIndex > l { return io.ErrUnexpectedEOF } - m.CipherKey = append(m.CipherKey[:0], dAtA[iNdEx:postIndex]...) - if m.CipherKey == nil { - m.CipherKey = []byte{} - } + m.Path = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex @@ -12898,7 +15700,7 @@ func (m *CipherInfo) Unmarshal(dAtA []byte) error { } return nil } -func (m *BackupRequest) Unmarshal(dAtA []byte) error { +func (m *S3) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -12921,36 +15723,17 @@ func (m *BackupRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: BackupRequest: wiretype end group for non-group") + return fmt.Errorf("proto: S3: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: BackupRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: S3: 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 ErrIntOverflowBrpb - } - 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 StartKey", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Endpoint", wireType) } - var byteLen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -12960,31 +15743,29 @@ func (m *BackupRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return ErrInvalidLengthBrpb } - postIndex := iNdEx + byteLen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthBrpb } if postIndex > l { return io.ErrUnexpectedEOF } - m.StartKey = append(m.StartKey[:0], dAtA[iNdEx:postIndex]...) - if m.StartKey == nil { - m.StartKey = []byte{} - } + m.Endpoint = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 3: + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field EndKey", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Region", wireType) } - var byteLen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -12994,107 +15775,29 @@ func (m *BackupRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return ErrInvalidLengthBrpb } - postIndex := iNdEx + byteLen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthBrpb } if postIndex > l { return io.ErrUnexpectedEOF } - m.EndKey = append(m.EndKey[:0], dAtA[iNdEx:postIndex]...) - if m.EndKey == nil { - m.EndKey = []byte{} - } + m.Region = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 4: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field StartVersion", wireType) - } - m.StartVersion = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowBrpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.StartVersion |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 5: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field EndVersion", wireType) - } - m.EndVersion = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowBrpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.EndVersion |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 7: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field RateLimit", wireType) - } - m.RateLimit = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowBrpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.RateLimit |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 8: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Concurrency", wireType) - } - m.Concurrency = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowBrpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.Concurrency |= uint32(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 9: + case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field StorageBackend", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Bucket", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -13104,51 +15807,27 @@ func (m *BackupRequest) 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 ErrInvalidLengthBrpb } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthBrpb } if postIndex > l { return io.ErrUnexpectedEOF } - if m.StorageBackend == nil { - m.StorageBackend = &StorageBackend{} - } - if err := m.StorageBackend.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 10: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field IsRawKv", wireType) - } - var v int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowBrpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - v |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - m.IsRawKv = bool(v != 0) - case 11: + m.Bucket = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Cf", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Prefix", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -13176,13 +15855,13 @@ func (m *BackupRequest) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Cf = string(dAtA[iNdEx:postIndex]) + m.Prefix = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 12: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field CompressionType", wireType) + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StorageClass", wireType) } - m.CompressionType = 0 + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -13192,35 +15871,29 @@ func (m *BackupRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.CompressionType |= CompressionType(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - case 13: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field CompressionLevel", wireType) + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthBrpb } - m.CompressionLevel = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowBrpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.CompressionLevel |= int32(b&0x7F) << shift - if b < 0x80 { - break - } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthBrpb } - case 14: + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.StorageClass = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field CipherInfo", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Sse", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -13230,33 +15903,29 @@ func (m *BackupRequest) 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 ErrInvalidLengthBrpb } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthBrpb } if postIndex > l { return io.ErrUnexpectedEOF } - if m.CipherInfo == nil { - m.CipherInfo = &CipherInfo{} - } - if err := m.CipherInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.Sse = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 15: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field DstApiVersion", wireType) + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Acl", wireType) } - m.DstApiVersion = 0 + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -13266,16 +15935,29 @@ func (m *BackupRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.DstApiVersion |= kvrpcpb.APIVersion(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - case 16: + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthBrpb + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthBrpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Acl = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 8: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field SubRanges", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field AccessKey", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -13285,31 +15967,29 @@ func (m *BackupRequest) 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 ErrInvalidLengthBrpb } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthBrpb } if postIndex > l { return io.ErrUnexpectedEOF } - m.SubRanges = append(m.SubRanges, &kvrpcpb.KeyRange{}) - if err := m.SubRanges[len(m.SubRanges)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.AccessKey = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 17: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field ReplicaRead", wireType) + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SecretAccessKey", wireType) } - var v int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -13319,17 +15999,29 @@ func (m *BackupRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - v |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - m.ReplicaRead = bool(v != 0) - case 18: + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthBrpb + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthBrpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SecretAccessKey = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 10: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Mode", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ForcePathStyle", wireType) } - m.Mode = 0 + var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -13339,14 +16031,15 @@ func (m *BackupRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Mode |= BackupMode(b&0x7F) << shift + v |= int(b&0x7F) << shift if b < 0x80 { break } } - case 19: + m.ForcePathStyle = bool(v != 0) + case 11: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field UniqueId", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field SseKmsKeyId", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -13374,13 +16067,13 @@ func (m *BackupRequest) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.UniqueId = string(dAtA[iNdEx:postIndex]) + m.SseKmsKeyId = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 20: + case 12: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field RoleArn", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -13390,120 +16083,29 @@ func (m *BackupRequest) 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 ErrInvalidLengthBrpb } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthBrpb } if postIndex > l { return io.ErrUnexpectedEOF } - if m.Context == nil { - m.Context = &kvrpcpb.Context{} - } - if err := m.Context.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.RoleArn = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipBrpb(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthBrpb - } - 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 *StreamBackupTaskInfo) 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 ErrIntOverflowBrpb - } - 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: StreamBackupTaskInfo: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: StreamBackupTaskInfo: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + case 13: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Storage", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowBrpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthBrpb - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthBrpb - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Storage == nil { - m.Storage = &StorageBackend{} - } - if err := m.Storage.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field StartTs", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ExternalId", wireType) } - m.StartTs = 0 + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -13513,16 +16115,29 @@ func (m *StreamBackupTaskInfo) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.StartTs |= uint64(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - case 3: + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthBrpb + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthBrpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ExternalId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 14: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field EndTs", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ObjectLockEnabled", wireType) } - m.EndTs = 0 + var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -13532,14 +16147,15 @@ func (m *StreamBackupTaskInfo) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.EndTs |= uint64(b&0x7F) << shift + v |= int(b&0x7F) << shift if b < 0x80 { break } } - case 4: + m.ObjectLockEnabled = bool(v != 0) + case 15: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field SessionToken", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -13567,11 +16183,11 @@ func (m *StreamBackupTaskInfo) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Name = string(dAtA[iNdEx:postIndex]) + m.SessionToken = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 5: + case 16: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field TableFilter", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Provider", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -13599,13 +16215,13 @@ func (m *StreamBackupTaskInfo) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.TableFilter = append(m.TableFilter, string(dAtA[iNdEx:postIndex])) + m.Provider = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 6: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field CompressionType", wireType) + case 17: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Profile", wireType) } - m.CompressionType = 0 + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -13615,11 +16231,24 @@ func (m *StreamBackupTaskInfo) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.CompressionType |= CompressionType(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthBrpb + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthBrpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Profile = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipBrpb(dAtA[iNdEx:]) @@ -13642,7 +16271,7 @@ func (m *StreamBackupTaskInfo) Unmarshal(dAtA []byte) error { } return nil } -func (m *StorageBackend) Unmarshal(dAtA []byte) error { +func (m *GCS) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -13665,17 +16294,17 @@ func (m *StorageBackend) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: StorageBackend: wiretype end group for non-group") + return fmt.Errorf("proto: GCS: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: StorageBackend: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: GCS: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Noop", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Endpoint", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -13685,32 +16314,29 @@ func (m *StorageBackend) 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 ErrInvalidLengthBrpb } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthBrpb } if postIndex > l { return io.ErrUnexpectedEOF } - v := &Noop{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.Backend = &StorageBackend_Noop{v} + m.Endpoint = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Local", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Bucket", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -13720,32 +16346,29 @@ func (m *StorageBackend) 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 ErrInvalidLengthBrpb } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthBrpb } if postIndex > l { return io.ErrUnexpectedEOF } - v := &Local{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.Backend = &StorageBackend_Local{v} + m.Bucket = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field S3", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Prefix", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -13755,32 +16378,29 @@ func (m *StorageBackend) 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 ErrInvalidLengthBrpb } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthBrpb } if postIndex > l { return io.ErrUnexpectedEOF } - v := &S3{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.Backend = &StorageBackend_S3{v} + m.Prefix = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Gcs", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field StorageClass", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -13790,32 +16410,29 @@ func (m *StorageBackend) 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 ErrInvalidLengthBrpb } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthBrpb } if postIndex > l { return io.ErrUnexpectedEOF } - v := &GCS{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.Backend = &StorageBackend_Gcs{v} + m.StorageClass = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 5: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field CloudDynamic", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field PredefinedAcl", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -13825,67 +16442,29 @@ func (m *StorageBackend) 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 ErrInvalidLengthBrpb } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthBrpb } if postIndex > l { return io.ErrUnexpectedEOF } - v := &CloudDynamic{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.Backend = &StorageBackend_CloudDynamic{v} + m.PredefinedAcl = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 6: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Hdfs", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowBrpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthBrpb - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthBrpb - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - v := &HDFS{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.Backend = &StorageBackend_Hdfs{v} - iNdEx = postIndex - case 7: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field AzureBlobStorage", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field CredentialsBlob", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -13895,26 +16474,23 @@ func (m *StorageBackend) 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 ErrInvalidLengthBrpb } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthBrpb } if postIndex > l { return io.ErrUnexpectedEOF } - v := &AzureBlobStorage{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.Backend = &StorageBackend_AzureBlobStorage{v} + m.CredentialsBlob = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex @@ -13938,58 +16514,7 @@ func (m *StorageBackend) Unmarshal(dAtA []byte) error { } return nil } -func (m *Noop) 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 ErrIntOverflowBrpb - } - 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: Noop: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: Noop: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - default: - iNdEx = preIndex - skippy, err := skipBrpb(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthBrpb - } - 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 *Local) Unmarshal(dAtA []byte) error { +func (m *AzureCustomerKey) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -14012,15 +16537,15 @@ func (m *Local) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: Local: wiretype end group for non-group") + return fmt.Errorf("proto: AzureCustomerKey: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: Local: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: AzureCustomerKey: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field EncryptionKey", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -14048,7 +16573,39 @@ func (m *Local) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Path = string(dAtA[iNdEx:postIndex]) + m.EncryptionKey = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EncryptionKeySha256", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + 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 ErrInvalidLengthBrpb + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthBrpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.EncryptionKeySha256 = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex @@ -14072,7 +16629,7 @@ func (m *Local) Unmarshal(dAtA []byte) error { } return nil } -func (m *S3) Unmarshal(dAtA []byte) error { +func (m *AzureBlobStorage) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -14095,10 +16652,10 @@ func (m *S3) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: S3: wiretype end group for non-group") + return fmt.Errorf("proto: AzureBlobStorage: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: S3: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: AzureBlobStorage: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -14135,7 +16692,7 @@ func (m *S3) 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 Bucket", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -14163,11 +16720,11 @@ func (m *S3) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Region = string(dAtA[iNdEx:postIndex]) + m.Bucket = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Bucket", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Prefix", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -14195,11 +16752,11 @@ func (m *S3) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Bucket = string(dAtA[iNdEx:postIndex]) + m.Prefix = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Prefix", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field StorageClass", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -14227,11 +16784,11 @@ func (m *S3) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Prefix = string(dAtA[iNdEx:postIndex]) + m.StorageClass = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 5: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field StorageClass", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field AccountName", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -14259,11 +16816,11 @@ func (m *S3) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.StorageClass = string(dAtA[iNdEx:postIndex]) + m.AccountName = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 6: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Sse", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field SharedKey", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -14291,11 +16848,11 @@ func (m *S3) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Sse = string(dAtA[iNdEx:postIndex]) + m.SharedKey = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 7: + case 8: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Acl", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field AccessSig", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -14323,11 +16880,11 @@ func (m *S3) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Acl = string(dAtA[iNdEx:postIndex]) + m.AccessSig = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 8: + case 9: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field AccessKey", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field EncryptionScope", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -14355,13 +16912,13 @@ func (m *S3) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.AccessKey = string(dAtA[iNdEx:postIndex]) + m.EncryptionScope = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 9: + case 10: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field SecretAccessKey", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field EncryptionKey", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -14371,29 +16928,84 @@ func (m *S3) 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 ErrInvalidLengthBrpb } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthBrpb } if postIndex > l { return io.ErrUnexpectedEOF } - m.SecretAccessKey = string(dAtA[iNdEx:postIndex]) + if m.EncryptionKey == nil { + m.EncryptionKey = &AzureCustomerKey{} + } + if err := m.EncryptionKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } iNdEx = postIndex - case 10: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field ForcePathStyle", wireType) + default: + iNdEx = preIndex + skippy, err := skipBrpb(dAtA[iNdEx:]) + if err != nil { + return err } - var v int + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthBrpb + } + 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 *Bucket) 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 ErrIntOverflowBrpb + } + 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: Bucket: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Bucket: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Endpoint", wireType) + } + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -14403,15 +17015,27 @@ func (m *S3) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - v |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - m.ForcePathStyle = bool(v != 0) - case 11: + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthBrpb + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthBrpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Endpoint = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field SseKmsKeyId", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Region", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -14439,11 +17063,11 @@ func (m *S3) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.SseKmsKeyId = string(dAtA[iNdEx:postIndex]) + m.Region = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 12: + case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field RoleArn", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Bucket", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -14471,11 +17095,11 @@ func (m *S3) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.RoleArn = string(dAtA[iNdEx:postIndex]) + m.Bucket = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 13: + case 5: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ExternalId", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Prefix", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -14503,13 +17127,13 @@ func (m *S3) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.ExternalId = string(dAtA[iNdEx:postIndex]) + m.Prefix = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 14: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field ObjectLockEnabled", wireType) + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StorageClass", wireType) } - var v int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -14519,17 +17143,80 @@ func (m *S3) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - v |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - m.ObjectLockEnabled = bool(v != 0) - case 15: + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthBrpb + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthBrpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.StorageClass = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipBrpb(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthBrpb + } + 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 *CloudDynamic) 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 ErrIntOverflowBrpb + } + 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: CloudDynamic: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CloudDynamic: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field SessionToken", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Bucket", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -14539,27 +17226,31 @@ func (m *S3) 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 ErrInvalidLengthBrpb } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthBrpb } if postIndex > l { return io.ErrUnexpectedEOF } - m.SessionToken = string(dAtA[iNdEx:postIndex]) + if m.Bucket == nil { + m.Bucket = &Bucket{} + } + if err := m.Bucket.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 Provider", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ProviderName", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -14587,13 +17278,13 @@ func (m *S3) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Provider = string(dAtA[iNdEx:postIndex]) + m.ProviderName = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 17: + case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Profile", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Attrs", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -14603,23 +17294,118 @@ func (m *S3) 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 ErrInvalidLengthBrpb } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthBrpb } if postIndex > l { return io.ErrUnexpectedEOF } - m.Profile = string(dAtA[iNdEx:postIndex]) + if m.Attrs == nil { + m.Attrs = make(map[string]string) + } + var mapkey string + var mapvalue string + for iNdEx < postIndex { + entryPreIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + 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 ErrIntOverflowBrpb + } + 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 ErrInvalidLengthBrpb + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey < 0 { + return ErrInvalidLengthBrpb + } + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + } else if fieldNum == 2 { + var stringLenmapvalue uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapvalue |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapvalue := int(stringLenmapvalue) + if intStringLenmapvalue < 0 { + return ErrInvalidLengthBrpb + } + postStringIndexmapvalue := iNdEx + intStringLenmapvalue + if postStringIndexmapvalue < 0 { + return ErrInvalidLengthBrpb + } + if postStringIndexmapvalue > l { + return io.ErrUnexpectedEOF + } + mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) + iNdEx = postStringIndexmapvalue + } else { + iNdEx = entryPreIndex + skippy, err := skipBrpb(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthBrpb + } + if (iNdEx + skippy) > postIndex { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + m.Attrs[mapkey] = mapvalue iNdEx = postIndex default: iNdEx = preIndex @@ -14643,7 +17429,7 @@ func (m *S3) Unmarshal(dAtA []byte) error { } return nil } -func (m *GCS) Unmarshal(dAtA []byte) error { +func (m *HDFS) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -14666,15 +17452,15 @@ func (m *GCS) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: GCS: wiretype end group for non-group") + return fmt.Errorf("proto: HDFS: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: GCS: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: HDFS: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Endpoint", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Remote", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -14702,13 +17488,64 @@ func (m *GCS) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Endpoint = string(dAtA[iNdEx:postIndex]) + m.Remote = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 2: + default: + iNdEx = preIndex + skippy, err := skipBrpb(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthBrpb + } + 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 *BackupResponse) 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 ErrIntOverflowBrpb + } + 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: BackupResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BackupResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Bucket", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -14718,29 +17555,33 @@ func (m *GCS) 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 ErrInvalidLengthBrpb } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthBrpb } if postIndex > l { return io.ErrUnexpectedEOF } - m.Bucket = string(dAtA[iNdEx:postIndex]) + if m.Error == nil { + m.Error = &Error{} + } + if err := m.Error.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 Prefix", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field StartKey", wireType) } - var stringLen uint64 + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -14750,29 +17591,31 @@ func (m *GCS) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + if byteLen < 0 { return ErrInvalidLengthBrpb } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + byteLen if postIndex < 0 { return ErrInvalidLengthBrpb } if postIndex > l { return io.ErrUnexpectedEOF } - m.Prefix = string(dAtA[iNdEx:postIndex]) + m.StartKey = append(m.StartKey[:0], dAtA[iNdEx:postIndex]...) + if m.StartKey == nil { + m.StartKey = []byte{} + } iNdEx = postIndex - case 4: + case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field StorageClass", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field EndKey", wireType) } - var stringLen uint64 + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -14782,29 +17625,31 @@ func (m *GCS) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + if byteLen < 0 { return ErrInvalidLengthBrpb } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + byteLen if postIndex < 0 { return ErrInvalidLengthBrpb } if postIndex > l { return io.ErrUnexpectedEOF } - m.StorageClass = string(dAtA[iNdEx:postIndex]) + m.EndKey = append(m.EndKey[:0], dAtA[iNdEx:postIndex]...) + if m.EndKey == nil { + m.EndKey = []byte{} + } iNdEx = postIndex - case 5: + case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field PredefinedAcl", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Files", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -14814,29 +17659,31 @@ func (m *GCS) 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 ErrInvalidLengthBrpb } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthBrpb } if postIndex > l { return io.ErrUnexpectedEOF } - m.PredefinedAcl = string(dAtA[iNdEx:postIndex]) + m.Files = append(m.Files, &File{}) + if err := m.Files[len(m.Files)-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 CredentialsBlob", wireType) + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ApiVersion", wireType) } - var stringLen uint64 + m.ApiVersion = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -14846,24 +17693,11 @@ func (m *GCS) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + m.ApiVersion |= kvrpcpb.APIVersion(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthBrpb - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthBrpb - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.CredentialsBlob = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipBrpb(dAtA[iNdEx:]) @@ -14886,7 +17720,7 @@ func (m *GCS) Unmarshal(dAtA []byte) error { } return nil } -func (m *AzureCustomerKey) Unmarshal(dAtA []byte) error { +func (m *CleanupRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -14909,47 +17743,15 @@ func (m *AzureCustomerKey) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: AzureCustomerKey: wiretype end group for non-group") + return fmt.Errorf("proto: CleanupRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: AzureCustomerKey: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: CleanupRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field EncryptionKey", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowBrpb - } - 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 ErrInvalidLengthBrpb - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthBrpb - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.EncryptionKey = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field EncryptionKeySha256", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field UniqueId", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -14977,7 +17779,7 @@ func (m *AzureCustomerKey) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.EncryptionKeySha256 = string(dAtA[iNdEx:postIndex]) + m.UniqueId = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex @@ -15001,7 +17803,7 @@ func (m *AzureCustomerKey) Unmarshal(dAtA []byte) error { } return nil } -func (m *AzureBlobStorage) Unmarshal(dAtA []byte) error { +func (m *CleanupResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -15024,17 +17826,17 @@ func (m *AzureBlobStorage) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: AzureBlobStorage: wiretype end group for non-group") + return fmt.Errorf("proto: CleanupResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: AzureBlobStorage: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: CleanupResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Endpoint", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -15044,29 +17846,33 @@ func (m *AzureBlobStorage) 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 ErrInvalidLengthBrpb } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthBrpb } if postIndex > l { return io.ErrUnexpectedEOF } - m.Endpoint = string(dAtA[iNdEx:postIndex]) + if m.Error == nil { + m.Error = &Error{} + } + if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } iNdEx = postIndex case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Bucket", wireType) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Success", wireType) } - var stringLen uint64 + var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -15076,29 +17882,68 @@ func (m *AzureBlobStorage) 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 ErrInvalidLengthBrpb + m.Success = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := skipBrpb(dAtA[iNdEx:]) + if err != nil { + return err } - postIndex := iNdEx + intStringLen - if postIndex < 0 { + if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthBrpb } - if postIndex > l { + if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } - m.Bucket = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Prefix", wireType) + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *PrepareRequest) 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 ErrIntOverflowBrpb } - var stringLen uint64 + 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: PrepareRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: PrepareRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field SaveToStorage", wireType) + } + var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -15108,29 +17953,68 @@ func (m *AzureBlobStorage) 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 ErrInvalidLengthBrpb + m.SaveToStorage = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := skipBrpb(dAtA[iNdEx:]) + if err != nil { + return err } - postIndex := iNdEx + intStringLen - if postIndex < 0 { + if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthBrpb } - if postIndex > l { + if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } - m.Prefix = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 4: + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *PrepareResponse) 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 ErrIntOverflowBrpb + } + 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: PrepareResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: PrepareResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field StorageClass", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -15140,27 +18024,31 @@ func (m *AzureBlobStorage) 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 ErrInvalidLengthBrpb } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthBrpb } if postIndex > l { return io.ErrUnexpectedEOF } - m.StorageClass = string(dAtA[iNdEx:postIndex]) + if m.Error == nil { + m.Error = &Error{} + } + if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } iNdEx = postIndex - case 5: + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field AccountName", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field UniqueId", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -15188,13 +18076,13 @@ func (m *AzureBlobStorage) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.AccountName = string(dAtA[iNdEx:postIndex]) + m.UniqueId = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 6: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field SharedKey", wireType) + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CollectFileCount", wireType) } - var stringLen uint64 + m.CollectFileCount = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -15204,29 +18092,16 @@ func (m *AzureBlobStorage) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + m.CollectFileCount |= uint64(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthBrpb - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthBrpb - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.SharedKey = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 8: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field AccessSig", wireType) + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CollectFileSize", wireType) } - var stringLen uint64 + m.CollectFileSize = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -15236,29 +18111,118 @@ func (m *AzureBlobStorage) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + m.CollectFileSize |= uint64(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + default: + iNdEx = preIndex + skippy, err := skipBrpb(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthBrpb } - postIndex := iNdEx + intStringLen - if postIndex < 0 { + 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 *CheckAdminRequest) 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 ErrIntOverflowBrpb + } + 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: CheckAdminRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CheckAdminRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipBrpb(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthBrpb } - if postIndex > l { + if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } - m.AccessSig = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 9: + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CheckAdminResponse) 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 ErrIntOverflowBrpb + } + 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: CheckAdminResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CheckAdminResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field EncryptionScope", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -15268,27 +18232,31 @@ func (m *AzureBlobStorage) 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 ErrInvalidLengthBrpb } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthBrpb } if postIndex > l { return io.ErrUnexpectedEOF } - m.EncryptionScope = string(dAtA[iNdEx:postIndex]) + if m.Error == nil { + m.Error = &Error{} + } + if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } iNdEx = postIndex - case 10: + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field EncryptionKey", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Region", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -15315,13 +18283,33 @@ func (m *AzureBlobStorage) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.EncryptionKey == nil { - m.EncryptionKey = &AzureCustomerKey{} + if m.Region == nil { + m.Region = &metapb.Region{} } - if err := m.EncryptionKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Region.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field HasPendingAdmin", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.HasPendingAdmin = bool(v != 0) default: iNdEx = preIndex skippy, err := skipBrpb(dAtA[iNdEx:]) @@ -15344,7 +18332,7 @@ func (m *AzureBlobStorage) Unmarshal(dAtA []byte) error { } return nil } -func (m *Bucket) Unmarshal(dAtA []byte) error { +func (m *ExternalStorageRestoreRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -15367,17 +18355,17 @@ func (m *Bucket) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: Bucket: wiretype end group for non-group") + return fmt.Errorf("proto: ExternalStorageRestoreRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: Bucket: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: ExternalStorageRestoreRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Endpoint", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field StorageBackend", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -15387,59 +18375,31 @@ func (m *Bucket) 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 ErrInvalidLengthBrpb } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthBrpb } if postIndex > l { return io.ErrUnexpectedEOF } - m.Endpoint = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Region", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowBrpb - } - 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 ErrInvalidLengthBrpb - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthBrpb + if m.StorageBackend == nil { + m.StorageBackend = &StorageBackend{} } - if postIndex > l { - return io.ErrUnexpectedEOF + if err := m.StorageBackend.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } - m.Region = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 4: + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Bucket", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ObjectName", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -15467,11 +18427,11 @@ func (m *Bucket) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Bucket = string(dAtA[iNdEx:postIndex]) + m.ObjectName = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 5: + case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Prefix", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field RestoreName", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -15499,13 +18459,13 @@ func (m *Bucket) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Prefix = string(dAtA[iNdEx:postIndex]) + m.RestoreName = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 6: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field StorageClass", wireType) + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ContentLength", wireType) } - var stringLen uint64 + m.ContentLength = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -15515,24 +18475,62 @@ func (m *Bucket) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + m.ContentLength |= uint64(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthBrpb + default: + iNdEx = preIndex + skippy, err := skipBrpb(dAtA[iNdEx:]) + if err != nil { + return err } - postIndex := iNdEx + intStringLen - if postIndex < 0 { + if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthBrpb } - if postIndex > l { + if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } - m.StorageClass = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ExternalStorageRestoreResponse) 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 ErrIntOverflowBrpb + } + 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: ExternalStorageRestoreResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ExternalStorageRestoreResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { default: iNdEx = preIndex skippy, err := skipBrpb(dAtA[iNdEx:]) @@ -15555,7 +18553,7 @@ func (m *Bucket) Unmarshal(dAtA []byte) error { } return nil } -func (m *CloudDynamic) Unmarshal(dAtA []byte) error { +func (m *ExternalStorageSaveRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -15578,15 +18576,15 @@ func (m *CloudDynamic) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: CloudDynamic: wiretype end group for non-group") + return fmt.Errorf("proto: ExternalStorageSaveRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: CloudDynamic: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: ExternalStorageSaveRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Bucket", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field StorageBackend", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -15613,16 +18611,16 @@ func (m *CloudDynamic) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Bucket == nil { - m.Bucket = &Bucket{} + if m.StorageBackend == nil { + m.StorageBackend = &StorageBackend{} } - if err := m.Bucket.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.StorageBackend.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ProviderName", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ObjectName", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -15650,13 +18648,13 @@ func (m *CloudDynamic) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.ProviderName = string(dAtA[iNdEx:postIndex]) + m.ObjectName = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Attrs", wireType) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ContentLength", wireType) } - var msglen int + m.ContentLength = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -15666,119 +18664,11 @@ func (m *CloudDynamic) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + m.ContentLength |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { - return ErrInvalidLengthBrpb - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthBrpb - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Attrs == nil { - m.Attrs = make(map[string]string) - } - var mapkey string - var mapvalue string - for iNdEx < postIndex { - entryPreIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowBrpb - } - 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 ErrIntOverflowBrpb - } - 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 ErrInvalidLengthBrpb - } - postStringIndexmapkey := iNdEx + intStringLenmapkey - if postStringIndexmapkey < 0 { - return ErrInvalidLengthBrpb - } - if postStringIndexmapkey > l { - return io.ErrUnexpectedEOF - } - mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) - iNdEx = postStringIndexmapkey - } else if fieldNum == 2 { - var stringLenmapvalue uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowBrpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - stringLenmapvalue |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - intStringLenmapvalue := int(stringLenmapvalue) - if intStringLenmapvalue < 0 { - return ErrInvalidLengthBrpb - } - postStringIndexmapvalue := iNdEx + intStringLenmapvalue - if postStringIndexmapvalue < 0 { - return ErrInvalidLengthBrpb - } - if postStringIndexmapvalue > l { - return io.ErrUnexpectedEOF - } - mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) - iNdEx = postStringIndexmapvalue - } else { - iNdEx = entryPreIndex - skippy, err := skipBrpb(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthBrpb - } - if (iNdEx + skippy) > postIndex { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - m.Attrs[mapkey] = mapvalue - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipBrpb(dAtA[iNdEx:]) @@ -15801,67 +18691,35 @@ func (m *CloudDynamic) Unmarshal(dAtA []byte) error { } return nil } -func (m *HDFS) Unmarshal(dAtA []byte) error { +func (m *ExternalStorageSaveResponse) 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 ErrIntOverflowBrpb - } - 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: HDFS: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: HDFS: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Remote", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowBrpb - } - 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 ErrInvalidLengthBrpb - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthBrpb + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb } - if postIndex > l { + if iNdEx >= l { return io.ErrUnexpectedEOF } - m.Remote = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex + 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: ExternalStorageSaveResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ExternalStorageSaveResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { default: iNdEx = preIndex skippy, err := skipBrpb(dAtA[iNdEx:]) @@ -15884,7 +18742,7 @@ func (m *HDFS) Unmarshal(dAtA []byte) error { } return nil } -func (m *BackupResponse) Unmarshal(dAtA []byte) error { +func (m *Metadata) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -15907,15 +18765,15 @@ func (m *BackupResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: BackupResponse: wiretype end group for non-group") + return fmt.Errorf("proto: Metadata: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: BackupResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: Metadata: 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) + return fmt.Errorf("proto: wrong wireType = %d for field Files", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -15942,18 +18800,16 @@ func (m *BackupResponse) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Error == nil { - m.Error = &Error{} - } - if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.Files = append(m.Files, &DataFileInfo{}) + if err := m.Files[len(m.Files)-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 StartKey", wireType) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field StoreId", wireType) } - var byteLen int + m.StoreId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -15963,31 +18819,16 @@ func (m *BackupResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= int(b&0x7F) << shift + m.StoreId |= int64(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { - return ErrInvalidLengthBrpb - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthBrpb - } - 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 != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field EndKey", wireType) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ResolvedTs", wireType) } - var byteLen int + m.ResolvedTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -15997,29 +18838,52 @@ func (m *BackupResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= int(b&0x7F) << shift + m.ResolvedTs |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { - return ErrInvalidLengthBrpb + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MaxTs", wireType) } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthBrpb + m.MaxTs = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.MaxTs |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } } - if postIndex > l { - return io.ErrUnexpectedEOF + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MinTs", wireType) } - m.EndKey = append(m.EndKey[:0], dAtA[iNdEx:postIndex]...) - if m.EndKey == nil { - m.EndKey = []byte{} + m.MinTs = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.MinTs |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } } - iNdEx = postIndex - case 4: + case 6: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Files", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field FileGroups", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -16046,16 +18910,16 @@ func (m *BackupResponse) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Files = append(m.Files, &File{}) - if err := m.Files[len(m.Files)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.FileGroups = append(m.FileGroups, &DataFileGroup{}) + if err := m.FileGroups[len(m.FileGroups)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 5: + case 7: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field ApiVersion", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field MetaVersion", wireType) } - m.ApiVersion = 0 + m.MetaVersion = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -16065,7 +18929,7 @@ func (m *BackupResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.ApiVersion |= kvrpcpb.APIVersion(b&0x7F) << shift + m.MetaVersion |= MetaVersion(b&0x7F) << shift if b < 0x80 { break } @@ -16092,7 +18956,7 @@ func (m *BackupResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *CleanupRequest) Unmarshal(dAtA []byte) error { +func (m *DataFileGroup) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -16115,17 +18979,140 @@ func (m *CleanupRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: CleanupRequest: wiretype end group for non-group") + return fmt.Errorf("proto: DataFileGroup: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: CleanupRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: DataFileGroup: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field UniqueId", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + 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 ErrInvalidLengthBrpb + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthBrpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Path = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DataFilesInfo", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthBrpb + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthBrpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DataFilesInfo = append(m.DataFilesInfo, &DataFileInfo{}) + if err := m.DataFilesInfo[len(m.DataFilesInfo)-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 MinTs", wireType) + } + m.MinTs = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.MinTs |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MaxTs", wireType) + } + m.MaxTs = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.MaxTs |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MinResolvedTs", wireType) + } + m.MinResolvedTs = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.MinResolvedTs |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } } - var stringLen uint64 + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Length", wireType) + } + m.Length = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -16135,24 +19122,11 @@ func (m *CleanupRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + m.Length |= uint64(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthBrpb - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthBrpb - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.UniqueId = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipBrpb(dAtA[iNdEx:]) @@ -16175,7 +19149,7 @@ func (m *CleanupRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *CleanupResponse) Unmarshal(dAtA []byte) error { +func (m *DataFileInfo) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -16198,17 +19172,17 @@ func (m *CleanupResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: CleanupResponse: wiretype end group for non-group") + return fmt.Errorf("proto: DataFileInfo: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: CleanupResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: DataFileInfo: 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) + return fmt.Errorf("proto: wrong wireType = %d for field Sha256", wireType) } - var msglen int + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -16218,33 +19192,31 @@ func (m *CleanupResponse) 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 ErrInvalidLengthBrpb } - postIndex := iNdEx + msglen + postIndex := iNdEx + byteLen if postIndex < 0 { return ErrInvalidLengthBrpb } 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 + m.Sha256 = append(m.Sha256[:0], dAtA[iNdEx:postIndex]...) + if m.Sha256 == nil { + m.Sha256 = []byte{} } iNdEx = postIndex case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Success", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType) } - var v int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -16254,68 +19226,67 @@ func (m *CleanupResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - v |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - m.Success = bool(v != 0) - default: - iNdEx = preIndex - skippy, err := skipBrpb(dAtA[iNdEx:]) - if err != nil { - return err + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthBrpb } - if (skippy < 0) || (iNdEx+skippy) < 0 { + postIndex := iNdEx + intStringLen + if postIndex < 0 { return ErrInvalidLengthBrpb } - 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 *PrepareRequest) 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 ErrIntOverflowBrpb + m.Path = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field NumberOfEntries", wireType) } - if iNdEx >= l { - return io.ErrUnexpectedEOF + m.NumberOfEntries = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.NumberOfEntries |= int64(b&0x7F) << shift + if b < 0x80 { + break + } } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MinTs", wireType) } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: PrepareRequest: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: PrepareRequest: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + m.MinTs = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.MinTs |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 5: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field SaveToStorage", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field MaxTs", wireType) } - var v int + m.MaxTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -16325,68 +19296,88 @@ func (m *PrepareRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - v |= int(b&0x7F) << shift + m.MaxTs |= uint64(b&0x7F) << shift if b < 0x80 { break } } - m.SaveToStorage = bool(v != 0) - default: - iNdEx = preIndex - skippy, err := skipBrpb(dAtA[iNdEx:]) - if err != nil { - return err + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ResolvedTs", wireType) } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthBrpb + m.ResolvedTs = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ResolvedTs |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field RegionId", wireType) } - m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *PrepareResponse) 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 ErrIntOverflowBrpb + m.RegionId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.RegionId |= int64(b&0x7F) << shift + if b < 0x80 { + break + } } - if iNdEx >= l { - return io.ErrUnexpectedEOF + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StartKey", wireType) } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: PrepareResponse: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: PrepareResponse: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + if byteLen < 0 { + return ErrInvalidLengthBrpb + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthBrpb + } + 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 9: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field EndKey", wireType) } - var msglen int + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -16396,31 +19387,29 @@ func (m *PrepareResponse) 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 ErrInvalidLengthBrpb } - postIndex := iNdEx + msglen + postIndex := iNdEx + byteLen if postIndex < 0 { return ErrInvalidLengthBrpb } 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 + m.EndKey = append(m.EndKey[:0], dAtA[iNdEx:postIndex]...) + if m.EndKey == nil { + m.EndKey = []byte{} } iNdEx = postIndex - case 2: + case 10: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field UniqueId", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Cf", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -16448,13 +19437,13 @@ func (m *PrepareResponse) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.UniqueId = string(dAtA[iNdEx:postIndex]) + m.Cf = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 3: + case 11: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field CollectFileCount", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) } - m.CollectFileCount = 0 + m.Type = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -16464,16 +19453,16 @@ func (m *PrepareResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.CollectFileCount |= uint64(b&0x7F) << shift + m.Type |= FileType(b&0x7F) << shift if b < 0x80 { break } } - case 4: + case 12: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field CollectFileSize", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field IsMeta", wireType) } - m.CollectFileSize = 0 + var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -16483,118 +19472,150 @@ func (m *PrepareResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.CollectFileSize |= uint64(b&0x7F) << shift + v |= int(b&0x7F) << shift if b < 0x80 { break } } - default: - iNdEx = preIndex - skippy, err := skipBrpb(dAtA[iNdEx:]) - if err != nil { - return err + m.IsMeta = bool(v != 0) + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field TableId", wireType) } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthBrpb + m.TableId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.TableId |= int64(b&0x7F) << shift + if b < 0x80 { + break + } } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF + case 14: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Length", wireType) } - m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *CheckAdminRequest) 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 ErrIntOverflowBrpb + m.Length = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Length |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } } - if iNdEx >= l { - return io.ErrUnexpectedEOF + case 15: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MinBeginTsInDefaultCf", wireType) } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break + m.MinBeginTsInDefaultCf = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.MinBeginTsInDefaultCf |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: CheckAdminRequest: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: CheckAdminRequest: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - default: - iNdEx = preIndex - skippy, err := skipBrpb(dAtA[iNdEx:]) - if err != nil { - return err + case 16: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field RangeOffset", wireType) } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthBrpb + m.RangeOffset = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.RangeOffset |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF + case 17: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field RangeLength", wireType) } - m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *CheckAdminResponse) 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 ErrIntOverflowBrpb + m.RangeLength = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.RangeLength |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } } - if iNdEx >= l { - return io.ErrUnexpectedEOF + case 18: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CompressionType", wireType) } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break + m.CompressionType = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.CompressionType |= CompressionType(b&0x7F) << shift + if b < 0x80 { + break + } } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: CheckAdminResponse: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: CheckAdminResponse: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + case 19: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Crc64Xor", wireType) + } + m.Crc64Xor = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Crc64Xor |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 20: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field RegionStartKey", wireType) } - var msglen int + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -16604,33 +19625,31 @@ func (m *CheckAdminResponse) 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 ErrInvalidLengthBrpb } - postIndex := iNdEx + msglen + postIndex := iNdEx + byteLen if postIndex < 0 { return ErrInvalidLengthBrpb } 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 + m.RegionStartKey = append(m.RegionStartKey[:0], dAtA[iNdEx:postIndex]...) + if m.RegionStartKey == nil { + m.RegionStartKey = []byte{} } iNdEx = postIndex - case 2: + case 21: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Region", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field RegionEndKey", wireType) } - var msglen int + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -16640,33 +19659,31 @@ func (m *CheckAdminResponse) 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 ErrInvalidLengthBrpb } - postIndex := iNdEx + msglen + postIndex := iNdEx + byteLen if postIndex < 0 { return ErrInvalidLengthBrpb } 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.RegionEndKey = append(m.RegionEndKey[:0], dAtA[iNdEx:postIndex]...) + if m.RegionEndKey == nil { + m.RegionEndKey = []byte{} } iNdEx = postIndex - case 3: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field HasPendingAdmin", wireType) + case 22: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RegionEpoch", wireType) } - var v int + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -16676,12 +19693,26 @@ func (m *CheckAdminResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - v |= int(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - m.HasPendingAdmin = bool(v != 0) + if msglen < 0 { + return ErrInvalidLengthBrpb + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthBrpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.RegionEpoch = append(m.RegionEpoch, &metapb.RegionEpoch{}) + if err := m.RegionEpoch[len(m.RegionEpoch)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipBrpb(dAtA[iNdEx:]) @@ -16704,7 +19735,7 @@ func (m *CheckAdminResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *ExternalStorageRestoreRequest) Unmarshal(dAtA []byte) error { +func (m *StreamBackupError) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -16727,17 +19758,17 @@ func (m *ExternalStorageRestoreRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: ExternalStorageRestoreRequest: wiretype end group for non-group") + return fmt.Errorf("proto: StreamBackupError: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: ExternalStorageRestoreRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: StreamBackupError: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field StorageBackend", wireType) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field HappenAt", wireType) } - var msglen int + m.HappenAt = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -16747,31 +19778,14 @@ func (m *ExternalStorageRestoreRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + m.HappenAt |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { - return ErrInvalidLengthBrpb - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthBrpb - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.StorageBackend == nil { - m.StorageBackend = &StorageBackend{} - } - if err := m.StorageBackend.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ObjectName", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ErrorCode", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -16799,11 +19813,11 @@ func (m *ExternalStorageRestoreRequest) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.ObjectName = string(dAtA[iNdEx:postIndex]) + m.ErrorCode = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field RestoreName", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ErrorMessage", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -16831,13 +19845,13 @@ func (m *ExternalStorageRestoreRequest) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.RestoreName = string(dAtA[iNdEx:postIndex]) + m.ErrorMessage = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 4: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field ContentLength", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field StoreId", wireType) } - m.ContentLength = 0 + m.StoreId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -16847,7 +19861,7 @@ func (m *ExternalStorageRestoreRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.ContentLength |= uint64(b&0x7F) << shift + m.StoreId |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -16874,7 +19888,7 @@ func (m *ExternalStorageRestoreRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *ExternalStorageRestoreResponse) Unmarshal(dAtA []byte) error { +func (m *Span) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -16897,12 +19911,50 @@ func (m *ExternalStorageRestoreResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: ExternalStorageRestoreResponse: wiretype end group for non-group") + return fmt.Errorf("proto: Span: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: ExternalStorageRestoreResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: Span: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Offset", wireType) + } + m.Offset = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Offset |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Length", wireType) + } + m.Length = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Length |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } default: iNdEx = preIndex skippy, err := skipBrpb(dAtA[iNdEx:]) @@ -16925,7 +19977,7 @@ func (m *ExternalStorageRestoreResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *ExternalStorageSaveRequest) Unmarshal(dAtA []byte) error { +func (m *SpansOfFile) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -16948,17 +20000,17 @@ func (m *ExternalStorageSaveRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: ExternalStorageSaveRequest: wiretype end group for non-group") + return fmt.Errorf("proto: SpansOfFile: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: ExternalStorageSaveRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: SpansOfFile: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field StorageBackend", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -16968,33 +20020,29 @@ func (m *ExternalStorageSaveRequest) 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 ErrInvalidLengthBrpb } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthBrpb } if postIndex > l { return io.ErrUnexpectedEOF } - if m.StorageBackend == nil { - m.StorageBackend = &StorageBackend{} - } - if err := m.StorageBackend.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.Path = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ObjectName", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Spans", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -17004,43 +20052,26 @@ func (m *ExternalStorageSaveRequest) 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 ErrInvalidLengthBrpb } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthBrpb } if postIndex > l { return io.ErrUnexpectedEOF } - m.ObjectName = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 3: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field ContentLength", wireType) - } - m.ContentLength = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowBrpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.ContentLength |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } + m.Spans = append(m.Spans, &Span{}) + if err := m.Spans[len(m.Spans)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipBrpb(dAtA[iNdEx:]) @@ -17063,7 +20094,7 @@ func (m *ExternalStorageSaveRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *ExternalStorageSaveResponse) Unmarshal(dAtA []byte) error { +func (m *LogFileSubcompactionMeta) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -17086,68 +20117,55 @@ func (m *ExternalStorageSaveResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: ExternalStorageSaveResponse: wiretype end group for non-group") + return fmt.Errorf("proto: LogFileSubcompactionMeta: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: ExternalStorageSaveResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: LogFileSubcompactionMeta: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { - default: - iNdEx = preIndex - skippy, err := skipBrpb(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthBrpb - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Size_", wireType) } - m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *Metadata) 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 ErrIntOverflowBrpb + m.Size_ = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Size_ |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } } - if iNdEx >= l { - return io.ErrUnexpectedEOF + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field RegionId", wireType) } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break + m.RegionId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.RegionId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: Metadata: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: Metadata: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Files", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Cf", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -17157,31 +20175,29 @@ func (m *Metadata) 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 ErrInvalidLengthBrpb } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthBrpb } if postIndex > l { return io.ErrUnexpectedEOF } - m.Files = append(m.Files, &DataFileInfo{}) - if err := m.Files[len(m.Files)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.Cf = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 2: + case 4: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field StoreId", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field InputMaxTs", wireType) } - m.StoreId = 0 + m.InputMaxTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -17191,16 +20207,16 @@ func (m *Metadata) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.StoreId |= int64(b&0x7F) << shift + m.InputMaxTs |= uint64(b&0x7F) << shift if b < 0x80 { break } } - case 3: + case 5: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field ResolvedTs", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field InputMinTs", wireType) } - m.ResolvedTs = 0 + m.InputMinTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -17210,16 +20226,16 @@ func (m *Metadata) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.ResolvedTs |= uint64(b&0x7F) << shift + m.InputMinTs |= uint64(b&0x7F) << shift if b < 0x80 { break } } - case 4: + case 6: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field MaxTs", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field CompactFromTs", wireType) } - m.MaxTs = 0 + m.CompactFromTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -17229,16 +20245,16 @@ func (m *Metadata) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.MaxTs |= uint64(b&0x7F) << shift + m.CompactFromTs |= uint64(b&0x7F) << shift if b < 0x80 { break } } - case 5: + case 7: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field MinTs", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field CompactUntilTs", wireType) } - m.MinTs = 0 + m.CompactUntilTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -17248,16 +20264,16 @@ func (m *Metadata) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.MinTs |= uint64(b&0x7F) << shift + m.CompactUntilTs |= uint64(b&0x7F) << shift if b < 0x80 { break } } - case 6: + case 8: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field FileGroups", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field MinKey", wireType) } - var msglen int + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -17267,31 +20283,65 @@ func (m *Metadata) 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 ErrInvalidLengthBrpb } - postIndex := iNdEx + msglen + postIndex := iNdEx + byteLen if postIndex < 0 { return ErrInvalidLengthBrpb } if postIndex > l { return io.ErrUnexpectedEOF } - m.FileGroups = append(m.FileGroups, &DataFileGroup{}) - if err := m.FileGroups[len(m.FileGroups)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + m.MinKey = append(m.MinKey[:0], dAtA[iNdEx:postIndex]...) + if m.MinKey == nil { + m.MinKey = []byte{} } iNdEx = postIndex - case 7: + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MaxKey", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthBrpb + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthBrpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.MaxKey = append(m.MaxKey[:0], dAtA[iNdEx:postIndex]...) + if m.MaxKey == nil { + m.MaxKey = []byte{} + } + iNdEx = postIndex + case 10: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field MetaVersion", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Ty", wireType) } - m.MetaVersion = 0 + m.Ty = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -17301,11 +20351,64 @@ func (m *Metadata) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.MetaVersion |= MetaVersion(b&0x7F) << shift + m.Ty |= FileType(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 11: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field TableId", wireType) + } + m.TableId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.TableId |= int64(b&0x7F) << shift if b < 0x80 { break } } + case 12: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sources", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBrpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthBrpb + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthBrpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Sources = append(m.Sources, &SpansOfFile{}) + if err := m.Sources[len(m.Sources)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipBrpb(dAtA[iNdEx:]) @@ -17328,7 +20431,7 @@ func (m *Metadata) Unmarshal(dAtA []byte) error { } return nil } -func (m *DataFileGroup) Unmarshal(dAtA []byte) error { +func (m *LogFileSubcompaction) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -17351,47 +20454,15 @@ func (m *DataFileGroup) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: DataFileGroup: wiretype end group for non-group") + return fmt.Errorf("proto: LogFileSubcompaction: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: DataFileGroup: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: LogFileSubcompaction: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowBrpb - } - 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 ErrInvalidLengthBrpb - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthBrpb - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Path = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field DataFilesInfo", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Meta", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -17418,73 +20489,18 @@ func (m *DataFileGroup) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.DataFilesInfo = append(m.DataFilesInfo, &DataFileInfo{}) - if err := m.DataFilesInfo[len(m.DataFilesInfo)-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 MinTs", wireType) - } - m.MinTs = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowBrpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.MinTs |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 4: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field MaxTs", wireType) - } - m.MaxTs = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowBrpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.MaxTs |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 5: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field MinResolvedTs", wireType) - } - m.MinResolvedTs = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowBrpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.MinResolvedTs |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } + if m.Meta == nil { + m.Meta = &LogFileSubcompactionMeta{} } - case 6: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Length", wireType) + if err := m.Meta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } - m.Length = 0 + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SstOutputs", wireType) + } + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -17494,11 +20510,26 @@ func (m *DataFileGroup) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Length |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } + if msglen < 0 { + return ErrInvalidLengthBrpb + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthBrpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SstOutputs = append(m.SstOutputs, &File{}) + if err := m.SstOutputs[len(m.SstOutputs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipBrpb(dAtA[iNdEx:]) @@ -17521,7 +20552,7 @@ func (m *DataFileGroup) Unmarshal(dAtA []byte) error { } return nil } -func (m *DataFileInfo) Unmarshal(dAtA []byte) error { +func (m *LogFileSubcompactions) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -17544,17 +20575,17 @@ func (m *DataFileInfo) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: DataFileInfo: wiretype end group for non-group") + return fmt.Errorf("proto: LogFileSubcompactions: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: DataFileInfo: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: LogFileSubcompactions: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Sha256", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Subcompactions", wireType) } - var byteLen int + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -17564,31 +20595,82 @@ func (m *DataFileInfo) 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 ErrInvalidLengthBrpb } - postIndex := iNdEx + byteLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthBrpb } if postIndex > l { return io.ErrUnexpectedEOF } - m.Sha256 = append(m.Sha256[:0], dAtA[iNdEx:postIndex]...) - if m.Sha256 == nil { - m.Sha256 = []byte{} + m.Subcompactions = append(m.Subcompactions, &LogFileSubcompaction{}) + if err := m.Subcompactions[len(m.Subcompactions)-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 Path", wireType) + default: + iNdEx = preIndex + skippy, err := skipBrpb(dAtA[iNdEx:]) + if err != nil { + return err } - var stringLen uint64 + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthBrpb + } + 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 *LogFileCompaction) 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 ErrIntOverflowBrpb + } + 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: LogFileCompaction: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: LogFileCompaction: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CompactionFromTs", wireType) + } + m.CompactionFromTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -17598,29 +20680,16 @@ func (m *DataFileInfo) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + m.CompactionFromTs |= uint64(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthBrpb - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthBrpb - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Path = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 3: + case 2: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field NumberOfEntries", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field CompactionUntilTs", wireType) } - m.NumberOfEntries = 0 + m.CompactionUntilTs = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -17630,16 +20699,16 @@ func (m *DataFileInfo) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.NumberOfEntries |= int64(b&0x7F) << shift + m.CompactionUntilTs |= uint64(b&0x7F) << shift if b < 0x80 { break } } - case 4: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field MinTs", wireType) + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) } - m.MinTs = 0 + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -17649,16 +20718,29 @@ func (m *DataFileInfo) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.MinTs |= uint64(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - case 5: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field MaxTs", wireType) + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthBrpb } - m.MaxTs = 0 + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthBrpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Comments", wireType) + } + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -17668,16 +20750,29 @@ func (m *DataFileInfo) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.MaxTs |= uint64(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - case 6: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field ResolvedTs", wireType) + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthBrpb } - m.ResolvedTs = 0 + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthBrpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Comments = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Artifacts", wireType) + } + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -17687,16 +20782,29 @@ func (m *DataFileInfo) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.ResolvedTs |= uint64(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - case 7: + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthBrpb + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthBrpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Artifacts = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field RegionId", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ArtifactsHash", wireType) } - m.RegionId = 0 + m.ArtifactsHash = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -17706,16 +20814,16 @@ func (m *DataFileInfo) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.RegionId |= int64(b&0x7F) << shift + m.ArtifactsHash |= uint64(b&0x7F) << shift if b < 0x80 { break } } - case 8: + case 7: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field StartKey", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field GeneratedFiles", wireType) } - var byteLen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -17725,31 +20833,80 @@ func (m *DataFileInfo) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return ErrInvalidLengthBrpb } - postIndex := iNdEx + byteLen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthBrpb } if postIndex > l { return io.ErrUnexpectedEOF } - m.StartKey = append(m.StartKey[:0], dAtA[iNdEx:postIndex]...) - if m.StartKey == nil { - m.StartKey = []byte{} - } + m.GeneratedFiles = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 9: + default: + iNdEx = preIndex + skippy, err := skipBrpb(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthBrpb + } + 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 *MetaEdit) 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 ErrIntOverflowBrpb + } + 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: MetaEdit: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MetaEdit: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field EndKey", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType) } - var byteLen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -17759,29 +20916,27 @@ func (m *DataFileInfo) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return ErrInvalidLengthBrpb } - postIndex := iNdEx + byteLen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthBrpb } if postIndex > l { return io.ErrUnexpectedEOF } - m.EndKey = append(m.EndKey[:0], dAtA[iNdEx:postIndex]...) - if m.EndKey == nil { - m.EndKey = []byte{} - } + m.Path = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 10: + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Cf", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field DeletePhysicalFiles", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -17809,13 +20964,13 @@ func (m *DataFileInfo) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Cf = string(dAtA[iNdEx:postIndex]) + m.DeletePhysicalFiles = append(m.DeletePhysicalFiles, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex - case 11: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DeleteLogicalFiles", wireType) } - m.Type = 0 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -17825,14 +20980,29 @@ func (m *DataFileInfo) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Type |= FileType(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - case 12: + if msglen < 0 { + return ErrInvalidLengthBrpb + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthBrpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DeleteLogicalFiles = append(m.DeleteLogicalFiles, &DeleteSpansOfFile{}) + if err := m.DeleteLogicalFiles[len(m.DeleteLogicalFiles)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field IsMeta", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field DestructSelf", wireType) } var v int for shift := uint(0); ; shift += 7 { @@ -17849,69 +21019,63 @@ func (m *DataFileInfo) Unmarshal(dAtA []byte) error { break } } - m.IsMeta = bool(v != 0) - case 13: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field TableId", wireType) + m.DestructSelf = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := skipBrpb(dAtA[iNdEx:]) + if err != nil { + return err } - m.TableId = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowBrpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.TableId |= int64(b&0x7F) << shift - if b < 0x80 { - break - } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthBrpb } - case 14: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Length", wireType) + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF } - m.Length = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowBrpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.Length |= uint64(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 *DeleteSpansOfFile) 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 ErrIntOverflowBrpb } - case 15: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field MinBeginTsInDefaultCf", wireType) + if iNdEx >= l { + return io.ErrUnexpectedEOF } - m.MinBeginTsInDefaultCf = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowBrpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.MinBeginTsInDefaultCf |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break } - case 16: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field RangeOffset", wireType) + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: DeleteSpansOfFile: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DeleteSpansOfFile: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType) } - m.RangeOffset = 0 + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -17921,16 +21085,29 @@ func (m *DataFileInfo) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.RangeOffset |= uint64(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - case 17: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field RangeLength", wireType) + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthBrpb } - m.RangeLength = 0 + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthBrpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Path = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Spans", wireType) + } + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -17940,16 +21117,31 @@ func (m *DataFileInfo) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.RangeLength |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - case 18: + if msglen < 0 { + return ErrInvalidLengthBrpb + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthBrpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Spans = append(m.Spans, &Span{}) + if err := m.Spans[len(m.Spans)-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 CompressionType", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field WholeFileLength", wireType) } - m.CompressionType = 0 + m.WholeFileLength = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -17959,7 +21151,7 @@ func (m *DataFileInfo) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.CompressionType |= CompressionType(b&0x7F) << shift + m.WholeFileLength |= uint64(b&0x7F) << shift if b < 0x80 { break } @@ -17986,7 +21178,7 @@ func (m *DataFileInfo) Unmarshal(dAtA []byte) error { } return nil } -func (m *StreamBackupError) Unmarshal(dAtA []byte) error { +func (m *Migration) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -18009,17 +21201,17 @@ func (m *StreamBackupError) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: StreamBackupError: wiretype end group for non-group") + return fmt.Errorf("proto: Migration: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: StreamBackupError: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: Migration: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field HappenAt", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EditMeta", wireType) } - m.HappenAt = 0 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -18029,16 +21221,31 @@ func (m *StreamBackupError) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.HappenAt |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } + if msglen < 0 { + return ErrInvalidLengthBrpb + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthBrpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.EditMeta = append(m.EditMeta, &MetaEdit{}) + if err := m.EditMeta[len(m.EditMeta)-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 ErrorCode", wireType) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field TruncatedTo", wireType) } - var stringLen uint64 + m.TruncatedTo = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -18048,29 +21255,16 @@ func (m *StreamBackupError) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + m.TruncatedTo |= uint64(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthBrpb - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthBrpb - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.ErrorCode = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ErrorMessage", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Compactions", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -18080,29 +21274,31 @@ func (m *StreamBackupError) 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 ErrInvalidLengthBrpb } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthBrpb } if postIndex > l { return io.ErrUnexpectedEOF } - m.ErrorMessage = string(dAtA[iNdEx:postIndex]) + m.Compactions = append(m.Compactions, &LogFileCompaction{}) + if err := m.Compactions[len(m.Compactions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } iNdEx = postIndex case 4: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field StoreId", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DestructPrefix", wireType) } - m.StoreId = 0 + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowBrpb @@ -18112,11 +21308,24 @@ func (m *StreamBackupError) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.StoreId |= uint64(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthBrpb + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthBrpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DestructPrefix = append(m.DestructPrefix, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipBrpb(dAtA[iNdEx:]) diff --git a/proto/brpb.proto b/proto/brpb.proto index 447ee3541..9c64a1545 100644 --- a/proto/brpb.proto +++ b/proto/brpb.proto @@ -709,6 +709,22 @@ message DataFileInfo { // The compression type for the file. CompressionType compression_type = 18; + // The CRC64XOR of all contents of the file. + // In older versions, this might be empty. + uint64 crc64xor = 19; + + // The original region range the log file belongs to. + // In older versions, this might be empty. + bytes region_start_key = 20; + // The original region range the log file belongs to. + // In older versions, this might be empty. + bytes region_end_key = 21; + // The region epoch that the log file belongs to. + // In older versions, this might be empty. + // If a region get split or merged during observing, + // the file may contain multi epoches. + repeated metapb.RegionEpoch region_epoch = 22; + // It may support encrypting at future. reserved "iv"; } @@ -723,3 +739,109 @@ message StreamBackupError { // the store id of who issues the error. uint64 store_id = 4; } + +message Span { + uint64 offset = 1; + uint64 length = 2; +} + +message SpansOfFile { + string path = 1; + repeated Span spans = 2; +} + + +message LogFileSubcompactionMeta { + // The whole size of this subcompaction. + // It should be the physical size of all input logs. + uint64 size = 1; + // The region that we perform the subcompaction. + uint64 region_id = 2; + string cf = 3; + + uint64 input_max_ts = 4; + uint64 input_min_ts = 5; + // The whole compaction's configure. + uint64 compact_from_ts = 6; + uint64 compact_until_ts = 7; + // The key range of the input logs. + // They are encoded user key. (i.e. mem-comparable, no 'z' prefix) + bytes min_key = 8; + // The largest key from the input. + bytes max_key = 9; + // The type of operations in the file. (Write or Delete) + FileType ty = 10; + int64 table_id = 11; + + // The input log files of this. + repeated SpansOfFile sources = 12; +} + +// A subcompaction from a compaction. +// Subcompactions are actions that collect then sort key values from one region. +message LogFileSubcompaction { + // The metadata of the subcompaction. + LogFileSubcompactionMeta meta = 1; + // The generated SSTs. + repeated File sst_outputs = 2; +} + +// Batched version of `LogFileSubcompaction`. +// So we can store many subcompactions to one file, to reduce the number of file. +message LogFileSubcompactions { + repeated LogFileSubcompaction subcompactions = 1; +} + +message LogFileCompaction { + uint64 compaction_from_ts = 1; + uint64 compaction_until_ts = 2; + // The user provided name for the compaction. + string name = 3; + // The statistics or other useful information for human. + string comments = 4; + + // relative path to the generated subcompaction metas. ("artificates") + string artifacts = 5; + // the XOR of all artificate's hash. + uint64 artifacts_hash = 6; + + // relative path to the subcompaction generated SST files. + // this is a hint for garbage-collecting, so we don't need to read the metas one by one. + // Those SSTs cannot be directly used, what you need is probably in `artificates`. + string generated_files = 7; +} + +message MetaEdit { + // Path to the meta file. + string path = 1; + // Delete the physical files (MetaFileGroup) in the meta file. + repeated string delete_physical_files = 2; + // Delete the logical files (MetaFileInfo) in the meta file. + // Note: Even the operation have been performed in the meta, + // this modification should be kept as long as the corresponding physical + // file not deleted. Or we may cannot know when to delete the physical file. + // Then the file will be leak until truncated. + repeated DeleteSpansOfFile delete_logical_files = 3; + // Whether to delete the metadata itself. + bool destruct_self = 4; +} + +// An extended version of `SpansOfFile`, added more metadata for the +// execution of delayed deletion. +message DeleteSpansOfFile { + string path = 1; + repeated Span spans = 2; + + // This is a hint for garbage collecting. + // So we can easily check whether a set of spans consists the whole file. + uint64 whole_file_length = 3; +} + +message Migration { + repeated MetaEdit edit_meta = 1; + uint64 truncated_to = 2; + repeated LogFileCompaction compactions = 3; + // Delete all files matches this prefix. + repeated string destruct_prefix = 4; +} + diff --git a/scripts/proto.lock b/scripts/proto.lock index 44407517a..c88b06c93 100644 --- a/scripts/proto.lock +++ b/scripts/proto.lock @@ -1607,6 +1607,27 @@ "id": 18, "name": "compression_type", "type": "CompressionType" + }, + { + "id": 19, + "name": "crc64xor", + "type": "uint64" + }, + { + "id": 20, + "name": "region_start_key", + "type": "bytes" + }, + { + "id": 21, + "name": "region_end_key", + "type": "bytes" + }, + { + "id": 22, + "name": "region_epoch", + "type": "metapb.RegionEpoch", + "is_repeated": true } ], "reserved_names": [ @@ -1637,6 +1658,246 @@ "type": "uint64" } ] + }, + { + "name": "Span", + "fields": [ + { + "id": 1, + "name": "offset", + "type": "uint64" + }, + { + "id": 2, + "name": "length", + "type": "uint64" + } + ] + }, + { + "name": "SpansOfFile", + "fields": [ + { + "id": 1, + "name": "path", + "type": "string" + }, + { + "id": 2, + "name": "spans", + "type": "Span", + "is_repeated": true + } + ] + }, + { + "name": "LogFileSubcompactionMeta", + "fields": [ + { + "id": 1, + "name": "size", + "type": "uint64" + }, + { + "id": 2, + "name": "region_id", + "type": "uint64" + }, + { + "id": 3, + "name": "cf", + "type": "string" + }, + { + "id": 4, + "name": "input_max_ts", + "type": "uint64" + }, + { + "id": 5, + "name": "input_min_ts", + "type": "uint64" + }, + { + "id": 6, + "name": "compact_from_ts", + "type": "uint64" + }, + { + "id": 7, + "name": "compact_until_ts", + "type": "uint64" + }, + { + "id": 8, + "name": "min_key", + "type": "bytes" + }, + { + "id": 9, + "name": "max_key", + "type": "bytes" + }, + { + "id": 10, + "name": "ty", + "type": "FileType" + }, + { + "id": 11, + "name": "table_id", + "type": "int64" + }, + { + "id": 12, + "name": "sources", + "type": "SpansOfFile", + "is_repeated": true + } + ] + }, + { + "name": "LogFileSubcompaction", + "fields": [ + { + "id": 1, + "name": "meta", + "type": "LogFileSubcompactionMeta" + }, + { + "id": 2, + "name": "sst_outputs", + "type": "File", + "is_repeated": true + } + ] + }, + { + "name": "LogFileSubcompactions", + "fields": [ + { + "id": 1, + "name": "subcompactions", + "type": "LogFileSubcompaction", + "is_repeated": true + } + ] + }, + { + "name": "LogFileCompaction", + "fields": [ + { + "id": 1, + "name": "compaction_from_ts", + "type": "uint64" + }, + { + "id": 2, + "name": "compaction_until_ts", + "type": "uint64" + }, + { + "id": 3, + "name": "name", + "type": "string" + }, + { + "id": 4, + "name": "comments", + "type": "string" + }, + { + "id": 5, + "name": "artifacts", + "type": "string" + }, + { + "id": 6, + "name": "artifacts_hash", + "type": "uint64" + }, + { + "id": 7, + "name": "generated_files", + "type": "string" + } + ] + }, + { + "name": "MetaEdit", + "fields": [ + { + "id": 1, + "name": "path", + "type": "string" + }, + { + "id": 2, + "name": "delete_physical_files", + "type": "string", + "is_repeated": true + }, + { + "id": 3, + "name": "delete_logical_files", + "type": "DeleteSpansOfFile", + "is_repeated": true + }, + { + "id": 4, + "name": "destruct_self", + "type": "bool" + } + ] + }, + { + "name": "DeleteSpansOfFile", + "fields": [ + { + "id": 1, + "name": "path", + "type": "string" + }, + { + "id": 2, + "name": "spans", + "type": "Span", + "is_repeated": true + }, + { + "id": 3, + "name": "whole_file_length", + "type": "uint64" + } + ] + }, + { + "name": "Migration", + "fields": [ + { + "id": 1, + "name": "edit_meta", + "type": "MetaEdit", + "is_repeated": true + }, + { + "id": 2, + "name": "truncated_to", + "type": "uint64" + }, + { + "id": 3, + "name": "compactions", + "type": "LogFileCompaction", + "is_repeated": true + }, + { + "id": 4, + "name": "destruct_prefix", + "type": "string", + "is_repeated": true + } + ] } ], "services": [ From 4403a1b5d138f74cab6fd83aa1fdeb0b772e1389 Mon Sep 17 00:00:00 2001 From: Ti Chi Robot Date: Wed, 21 Aug 2024 19:37:42 +0800 Subject: [PATCH 3/5] [skip ci] Update OWNERS file (#1257) skip-checks: true Signed-off-by: Ti Chi Robot Co-authored-by: wuhuizuo --- OWNERS | 125 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 124 insertions(+), 1 deletion(-) diff --git a/OWNERS b/OWNERS index d61c6dd11..30bbad499 100644 --- a/OWNERS +++ b/OWNERS @@ -1,3 +1,126 @@ # See the OWNERS docs at https://go.k8s.io/owners approvers: - - sig-approvers + - 3pointer + - AilinKid + - amyangfei + - AndreMouche + - AndrewDi + - andylokandy + - b41sh + - bb7133 + - Benjamin2037 + - BornChanger + - breezewish + - c4pt0r + - cbcwestwolf + - cfzjywxk + - chrysan + - coocood + - crazycs520 + - D3Hunter + - Deardrops + - Defined2014 + - disksing + - djshow832 + - dveeden + - Ehco1996 + - ekexium + - elsa0520 + - eurekaka + - fixdb + - francis0407 + - fzhedu + - glorv + - GMHDBJD + - gozssky + - guo-shaoge + - hanfei1991 + - hawkingrei + - ichn-hu + - imtbkcat + - jackysp + - jiyfhust + - joccau + - kennytm + - lance6716 + - lcwangchao + - Leavrth + - lichunzhu + - Little-Wallace + - liuzix + - lonng + - lysu + - lzmhhh123 + - mjonss + - mmyj + - morgo + - MyonKeminta + - ngaut + - nrc + - overvenus + - qiuyesuifeng + - qw4990 + - rebelice + - Reminiscent + - shenli + - siddontang + - sticnarf + - SunRunAway + - sylzd + - tangenta + - tiancaiamao + - time-and-fate + - tisonkun + - windtalker + - winkyao + - winoros + - wjhuang2016 + - wshwsh12 + - xhebox + - xiongjiwei + - XuHuaiyu + - xuyifangreeneyes + - yangkeao + - Yisaer + - you06 + - youjiali1995 + - YuJuncen + - ywqzzy + - zanmato1984 + - zhouqiang-cl + - zimulala + - zwj-coder + - zyguan + - zz-jason +reviewers: + - aytrack + - bobotu + - CabinfeverB + - ChenPeng2013 + - dhysum + - fzzf678 + - JmPotato + - js00070 + - lamxTyler + - LittleFall + - longfangsong + - lyzx2001 + - mengxin9014 + - mornyx + - nolouch + - pingyu + - rleungx + - Rustin170506 + - SeaRise + - shihongzhi + - spongedu + - tangwz + - Tjianke + - TonsnakeLin + - tsthght + - TszKitLo40 + - xzhangxian1008 + - yibin87 + - zhangjinpeng1987 + - zhongzc + - zhuo-zhi From 767001c94b1871e0a6467bbb6e177d676b1bf3cb Mon Sep 17 00:00:00 2001 From: MyonKeminta <9948422+MyonKeminta@users.noreply.github.com> Date: Tue, 3 Sep 2024 19:38:29 +0800 Subject: [PATCH 4/5] Support replacing lock by key for deadlock detector service (#1259) * Support replacing lock by key for deadlock detector service Signed-off-by: MyonKeminta * Add deadlock_key field to deadlock error Signed-off-by: MyonKeminta * Make ReplaceLockByKey batched Signed-off-by: MyonKeminta * Remove the ReplaceLocksByKeys type Signed-off-by: MyonKeminta --------- Signed-off-by: MyonKeminta Co-authored-by: MyonKeminta --- pkg/deadlock/deadlock.pb.go | 719 +++++++++++++++++++++++++-- pkg/kvrpcpb/kvrpcpb.pb.go | 965 +++++++++++++++++++----------------- proto/deadlock.proto | 18 +- proto/kvrpcpb.proto | 5 + scripts/proto.lock | 59 ++- 5 files changed, 1247 insertions(+), 519 deletions(-) diff --git a/pkg/deadlock/deadlock.pb.go b/pkg/deadlock/deadlock.pb.go index c19b5a3ce..8fc227082 100644 --- a/pkg/deadlock/deadlock.pb.go +++ b/pkg/deadlock/deadlock.pb.go @@ -237,19 +237,138 @@ func (m *WaitForEntry) GetWaitTime() uint64 { return 0 } +type ReplaceLockByKeyItem struct { + KeyHash uint64 `protobuf:"varint,1,opt,name=key_hash,json=keyHash,proto3" json:"key_hash,omitempty"` + Key []byte `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` + OldLockTs uint64 `protobuf:"varint,3,opt,name=old_lock_ts,json=oldLockTs,proto3" json:"old_lock_ts,omitempty"` + NewLockTs uint64 `protobuf:"varint,4,opt,name=new_lock_ts,json=newLockTs,proto3" json:"new_lock_ts,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ReplaceLockByKeyItem) Reset() { *m = ReplaceLockByKeyItem{} } +func (m *ReplaceLockByKeyItem) String() string { return proto.CompactTextString(m) } +func (*ReplaceLockByKeyItem) ProtoMessage() {} +func (*ReplaceLockByKeyItem) Descriptor() ([]byte, []int) { + return fileDescriptor_1995e4345c820a37, []int{3} +} +func (m *ReplaceLockByKeyItem) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ReplaceLockByKeyItem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ReplaceLockByKeyItem.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 *ReplaceLockByKeyItem) XXX_Merge(src proto.Message) { + xxx_messageInfo_ReplaceLockByKeyItem.Merge(m, src) +} +func (m *ReplaceLockByKeyItem) XXX_Size() int { + return m.Size() +} +func (m *ReplaceLockByKeyItem) XXX_DiscardUnknown() { + xxx_messageInfo_ReplaceLockByKeyItem.DiscardUnknown(m) +} + +var xxx_messageInfo_ReplaceLockByKeyItem proto.InternalMessageInfo + +func (m *ReplaceLockByKeyItem) GetKeyHash() uint64 { + if m != nil { + return m.KeyHash + } + return 0 +} + +func (m *ReplaceLockByKeyItem) GetKey() []byte { + if m != nil { + return m.Key + } + return nil +} + +func (m *ReplaceLockByKeyItem) GetOldLockTs() uint64 { + if m != nil { + return m.OldLockTs + } + return 0 +} + +func (m *ReplaceLockByKeyItem) GetNewLockTs() uint64 { + if m != nil { + return m.NewLockTs + } + return 0 +} + +type ReplaceLocksByKeysRequest struct { + Items []*ReplaceLockByKeyItem `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ReplaceLocksByKeysRequest) Reset() { *m = ReplaceLocksByKeysRequest{} } +func (m *ReplaceLocksByKeysRequest) String() string { return proto.CompactTextString(m) } +func (*ReplaceLocksByKeysRequest) ProtoMessage() {} +func (*ReplaceLocksByKeysRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_1995e4345c820a37, []int{4} +} +func (m *ReplaceLocksByKeysRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ReplaceLocksByKeysRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ReplaceLocksByKeysRequest.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 *ReplaceLocksByKeysRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ReplaceLocksByKeysRequest.Merge(m, src) +} +func (m *ReplaceLocksByKeysRequest) XXX_Size() int { + return m.Size() +} +func (m *ReplaceLocksByKeysRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ReplaceLocksByKeysRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_ReplaceLocksByKeysRequest proto.InternalMessageInfo + +func (m *ReplaceLocksByKeysRequest) GetItems() []*ReplaceLockByKeyItem { + if m != nil { + return m.Items + } + return nil +} + type DeadlockRequest struct { - Tp DeadlockRequestType `protobuf:"varint,1,opt,name=tp,proto3,enum=deadlock.DeadlockRequestType" json:"tp,omitempty"` - Entry WaitForEntry `protobuf:"bytes,2,opt,name=entry,proto3" json:"entry"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + Tp DeadlockRequestType `protobuf:"varint,1,opt,name=tp,proto3,enum=deadlock.DeadlockRequestType" json:"tp,omitempty"` + Entry *WaitForEntry `protobuf:"bytes,2,opt,name=entry,proto3" json:"entry,omitempty"` + ReplaceLocksByKeys *ReplaceLocksByKeysRequest `protobuf:"bytes,3,opt,name=replace_locks_by_keys,json=replaceLocksByKeys,proto3" json:"replace_locks_by_keys,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } func (m *DeadlockRequest) Reset() { *m = DeadlockRequest{} } func (m *DeadlockRequest) String() string { return proto.CompactTextString(m) } func (*DeadlockRequest) ProtoMessage() {} func (*DeadlockRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_1995e4345c820a37, []int{3} + return fileDescriptor_1995e4345c820a37, []int{5} } func (m *DeadlockRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -285,31 +404,40 @@ func (m *DeadlockRequest) GetTp() DeadlockRequestType { return DeadlockRequestType_Detect } -func (m *DeadlockRequest) GetEntry() WaitForEntry { +func (m *DeadlockRequest) GetEntry() *WaitForEntry { if m != nil { return m.Entry } - return WaitForEntry{} + return nil +} + +func (m *DeadlockRequest) GetReplaceLocksByKeys() *ReplaceLocksByKeysRequest { + if m != nil { + return m.ReplaceLocksByKeys + } + return nil } type DeadlockResponse struct { // The same entry sent by DeadlockRequest, identifies the sender. Entry WaitForEntry `protobuf:"bytes,1,opt,name=entry,proto3" json:"entry"` - // The key hash of the lock that is hold by the waiting transaction. + // The key hash of the lock that is hold by the waiting transaction. The hash of the `deadlock_key` field. DeadlockKeyHash uint64 `protobuf:"varint,2,opt,name=deadlock_key_hash,json=deadlockKeyHash,proto3" json:"deadlock_key_hash,omitempty"` // The other entries of the dead lock circle. The current entry is in `entry` field and not // included in this field. - WaitChain []*WaitForEntry `protobuf:"bytes,3,rep,name=wait_chain,json=waitChain,proto3" json:"wait_chain,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + WaitChain []*WaitForEntry `protobuf:"bytes,3,rep,name=wait_chain,json=waitChain,proto3" json:"wait_chain,omitempty"` + // The key of the lock that is hold by the waiting transaction. + DeadlockKey []byte `protobuf:"bytes,4,opt,name=deadlock_key,json=deadlockKey,proto3" json:"deadlock_key,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } func (m *DeadlockResponse) Reset() { *m = DeadlockResponse{} } func (m *DeadlockResponse) String() string { return proto.CompactTextString(m) } func (*DeadlockResponse) ProtoMessage() {} func (*DeadlockResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_1995e4345c820a37, []int{4} + return fileDescriptor_1995e4345c820a37, []int{6} } func (m *DeadlockResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -359,11 +487,20 @@ func (m *DeadlockResponse) GetWaitChain() []*WaitForEntry { return nil } +func (m *DeadlockResponse) GetDeadlockKey() []byte { + if m != nil { + return m.DeadlockKey + } + return nil +} + func init() { proto.RegisterEnum("deadlock.DeadlockRequestType", DeadlockRequestType_name, DeadlockRequestType_value) proto.RegisterType((*WaitForEntriesRequest)(nil), "deadlock.WaitForEntriesRequest") proto.RegisterType((*WaitForEntriesResponse)(nil), "deadlock.WaitForEntriesResponse") proto.RegisterType((*WaitForEntry)(nil), "deadlock.WaitForEntry") + proto.RegisterType((*ReplaceLockByKeyItem)(nil), "deadlock.ReplaceLockByKeyItem") + proto.RegisterType((*ReplaceLocksByKeysRequest)(nil), "deadlock.ReplaceLocksByKeysRequest") proto.RegisterType((*DeadlockRequest)(nil), "deadlock.DeadlockRequest") proto.RegisterType((*DeadlockResponse)(nil), "deadlock.DeadlockResponse") } @@ -371,37 +508,45 @@ func init() { func init() { proto.RegisterFile("deadlock.proto", fileDescriptor_1995e4345c820a37) } var fileDescriptor_1995e4345c820a37 = []byte{ - // 465 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x93, 0x51, 0x6e, 0xd3, 0x40, - 0x10, 0x86, 0xb3, 0x49, 0x9a, 0x84, 0x69, 0x94, 0xba, 0x03, 0x14, 0x37, 0x88, 0xd4, 0xf2, 0x53, - 0x54, 0x41, 0x41, 0x41, 0x70, 0x80, 0xb4, 0xa5, 0x48, 0xbc, 0x20, 0x2b, 0x08, 0xde, 0xac, 0x25, - 0x1d, 0x6c, 0xcb, 0xad, 0xd7, 0xd8, 0x1b, 0xb5, 0xbe, 0x09, 0x57, 0x40, 0xdc, 0x80, 0x13, 0xf4, - 0x91, 0x13, 0x20, 0x14, 0x2e, 0x82, 0x76, 0xed, 0x4d, 0x4a, 0x95, 0x40, 0xdf, 0xd6, 0xf3, 0xff, - 0xfb, 0xef, 0xcc, 0xb7, 0x6b, 0xe8, 0x9d, 0x12, 0x3f, 0x3d, 0x13, 0xd3, 0xf8, 0x20, 0xcd, 0x84, - 0x14, 0xd8, 0x31, 0xdf, 0xfd, 0x7b, 0x81, 0x08, 0x84, 0x2e, 0x3e, 0x55, 0xab, 0x52, 0x77, 0x1f, - 0xc0, 0xfd, 0xf7, 0x3c, 0x92, 0xaf, 0x44, 0x76, 0x9c, 0xc8, 0x2c, 0xa2, 0xdc, 0xa3, 0xcf, 0x33, - 0xca, 0xa5, 0xfb, 0x16, 0x76, 0x6e, 0x0a, 0x79, 0x2a, 0x92, 0x9c, 0xf0, 0x25, 0xb4, 0xa9, 0x2c, - 0xd9, 0xcc, 0x69, 0x0c, 0x37, 0x47, 0x3b, 0x07, 0x8b, 0x43, 0xaf, 0x6d, 0x29, 0xc6, 0xcd, 0xab, - 0x9f, 0x7b, 0x35, 0xcf, 0x98, 0xdd, 0xef, 0x0c, 0xba, 0xd7, 0x75, 0xb4, 0xa0, 0x21, 0x2f, 0x13, - 0x9b, 0x39, 0x6c, 0xd8, 0xf4, 0xd4, 0x12, 0x1d, 0xe8, 0x5e, 0xf0, 0x48, 0xfa, 0x9f, 0x44, 0xe6, - 0x2b, 0xa9, 0xae, 0x25, 0xb8, 0x28, 0x77, 0x4d, 0x2e, 0x13, 0xdc, 0x85, 0x4e, 0x4c, 0x85, 0x1f, - 0xf2, 0x3c, 0xb4, 0x1b, 0x5a, 0x6d, 0xc7, 0x54, 0xbc, 0xe6, 0x79, 0xa8, 0xe2, 0x62, 0x2a, 0xec, - 0xa6, 0xc3, 0x86, 0x5d, 0x4f, 0x2d, 0xf1, 0x31, 0x60, 0x46, 0xb9, 0x98, 0x65, 0x53, 0xf2, 0x83, - 0x4c, 0xcc, 0x52, 0x5f, 0xf2, 0xc0, 0xde, 0xd0, 0x06, 0xcb, 0x28, 0x27, 0x4a, 0x98, 0xf0, 0x00, - 0x1f, 0xc2, 0x1d, 0x7d, 0xb8, 0x8c, 0xce, 0xc9, 0x6e, 0xe9, 0xec, 0x8e, 0x2a, 0x4c, 0xa2, 0x73, - 0x72, 0x25, 0x6c, 0x1d, 0x55, 0x43, 0x56, 0x84, 0xf0, 0x09, 0xd4, 0x65, 0xaa, 0xbb, 0xef, 0x8d, - 0x1e, 0x2d, 0x11, 0xdc, 0xb0, 0x4d, 0x8a, 0x94, 0xbc, 0xba, 0x4c, 0x71, 0x04, 0x1b, 0x8a, 0x44, - 0xa1, 0x87, 0xfa, 0x1f, 0xb4, 0xd2, 0xea, 0x7e, 0x65, 0x60, 0x2d, 0xf3, 0x2a, 0xfe, 0x8b, 0x20, - 0x76, 0xeb, 0x20, 0xdc, 0x87, 0x6d, 0xe3, 0xf2, 0x17, 0xfc, 0x4a, 0xba, 0x5b, 0x46, 0x78, 0x53, - 0x71, 0x7c, 0x01, 0x1a, 0xb8, 0x3f, 0x0d, 0x79, 0x94, 0xd8, 0x8d, 0x7f, 0x5d, 0xb1, 0xa7, 0x89, - 0x1d, 0x2a, 0xe3, 0xfe, 0x18, 0xee, 0xae, 0x18, 0x1d, 0x01, 0x5a, 0x47, 0x24, 0x69, 0x2a, 0xad, - 0x1a, 0x22, 0xf4, 0x0e, 0xcf, 0x88, 0x27, 0xef, 0xd2, 0x2a, 0xc4, 0x62, 0xb8, 0x09, 0xed, 0xaa, - 0x66, 0xd5, 0x47, 0xdf, 0x18, 0x74, 0x4c, 0x08, 0x7e, 0x80, 0xed, 0x13, 0x92, 0x7f, 0x3f, 0x42, - 0xdc, 0x5b, 0xd9, 0xc8, 0xf2, 0xdd, 0xf6, 0x9d, 0xf5, 0x86, 0x92, 0x9f, 0x5b, 0xc3, 0x63, 0xd3, - 0x13, 0xee, 0xae, 0xbd, 0xb7, 0x7e, 0x7f, 0x95, 0x64, 0x22, 0x86, 0xec, 0x19, 0x1b, 0x5b, 0x57, - 0xf3, 0x01, 0xfb, 0x31, 0x1f, 0xb0, 0x5f, 0xf3, 0x01, 0xfb, 0xf2, 0x7b, 0x50, 0xfb, 0xd8, 0xd2, - 0x3f, 0xd5, 0xf3, 0x3f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x1f, 0x1a, 0x00, 0x2a, 0x86, 0x03, 0x00, - 0x00, + // 597 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x54, 0x5d, 0x6e, 0xd3, 0x4c, + 0x14, 0xcd, 0x24, 0x69, 0x9b, 0xde, 0x44, 0xad, 0x3b, 0x5f, 0xdb, 0xcf, 0x0d, 0xc2, 0x0d, 0xe6, + 0x25, 0xaa, 0x4a, 0x41, 0xe1, 0x67, 0x01, 0x69, 0x4b, 0x41, 0xe5, 0x01, 0xac, 0xf0, 0xf3, 0x66, + 0xb9, 0xce, 0x25, 0xb1, 0x9c, 0x78, 0x8c, 0x3d, 0x55, 0xea, 0x67, 0x36, 0xc1, 0x1e, 0xd8, 0x01, + 0x0b, 0x40, 0x7d, 0xe0, 0x81, 0x15, 0x20, 0x54, 0x36, 0x82, 0x66, 0xc6, 0xd3, 0x24, 0xc5, 0xe9, + 0xdb, 0x78, 0xce, 0xf1, 0xb9, 0xe7, 0xde, 0x7b, 0x6c, 0x58, 0xeb, 0xa3, 0xd7, 0x1f, 0x31, 0x3f, + 0x3c, 0x88, 0x13, 0xc6, 0x19, 0xad, 0xe9, 0xe7, 0xe6, 0xe6, 0x80, 0x0d, 0x98, 0xbc, 0x7c, 0x28, + 0x4e, 0x0a, 0xb7, 0xff, 0x87, 0xad, 0xf7, 0x5e, 0xc0, 0x9f, 0xb3, 0xe4, 0x38, 0xe2, 0x49, 0x80, + 0xa9, 0x83, 0x9f, 0xce, 0x31, 0xe5, 0xf6, 0x6b, 0xd8, 0xbe, 0x09, 0xa4, 0x31, 0x8b, 0x52, 0xa4, + 0xcf, 0x60, 0x05, 0xd5, 0x95, 0x49, 0x5a, 0x95, 0x76, 0xbd, 0xb3, 0x7d, 0x70, 0x5d, 0x74, 0xe6, + 0x95, 0xac, 0x5b, 0xbd, 0xfc, 0xb5, 0x5b, 0x72, 0x34, 0xd9, 0xfe, 0x46, 0xa0, 0x31, 0x8b, 0x53, + 0x03, 0x2a, 0xfc, 0x22, 0x32, 0x49, 0x8b, 0xb4, 0xab, 0x8e, 0x38, 0xd2, 0x16, 0x34, 0x26, 0x5e, + 0xc0, 0xdd, 0x8f, 0x2c, 0x71, 0x05, 0x54, 0x96, 0x10, 0x4c, 0xd4, 0x5b, 0xbd, 0x8b, 0x88, 0xee, + 0x40, 0x2d, 0xc4, 0xcc, 0x1d, 0x7a, 0xe9, 0xd0, 0xac, 0x48, 0x74, 0x25, 0xc4, 0xec, 0x85, 0x97, + 0x0e, 0x85, 0x5c, 0x88, 0x99, 0x59, 0x6d, 0x91, 0x76, 0xc3, 0x11, 0x47, 0xba, 0x0f, 0x34, 0xc1, + 0x94, 0x9d, 0x27, 0x3e, 0xba, 0x83, 0x84, 0x9d, 0xc7, 0x2e, 0xf7, 0x06, 0xe6, 0x92, 0x24, 0x18, + 0x1a, 0x39, 0x11, 0x40, 0xcf, 0x1b, 0xd0, 0x3b, 0xb0, 0x2a, 0x8b, 0xf3, 0x60, 0x8c, 0xe6, 0xb2, + 0xd4, 0xae, 0x89, 0x8b, 0x5e, 0x30, 0x46, 0xfb, 0x33, 0x81, 0x4d, 0x07, 0xe3, 0x91, 0xe7, 0xe3, + 0x2b, 0xe6, 0x87, 0xdd, 0xec, 0x14, 0xb3, 0x97, 0x1c, 0xc7, 0x73, 0x86, 0x48, 0xa1, 0xa1, 0xf2, + 0xd4, 0x90, 0x05, 0x75, 0x36, 0xea, 0xbb, 0x62, 0x54, 0x2e, 0x4f, 0xf3, 0x06, 0x56, 0xd9, 0xa8, + 0x2f, 0x34, 0x7b, 0xa9, 0xc0, 0x23, 0x9c, 0x5c, 0xe3, 0x55, 0x85, 0x47, 0x38, 0x51, 0xb8, 0xfd, + 0x06, 0x76, 0x66, 0x4c, 0xa4, 0xd2, 0x85, 0xde, 0x18, 0x7d, 0x02, 0x4b, 0x01, 0xc7, 0xb1, 0xde, + 0x8a, 0x35, 0xdd, 0x4a, 0x91, 0x71, 0x47, 0x91, 0xed, 0xef, 0x04, 0xd6, 0x8f, 0x72, 0xa2, 0x56, + 0x7a, 0x00, 0x65, 0x1e, 0xcb, 0x6e, 0xd6, 0x3a, 0x77, 0xa7, 0x32, 0x37, 0x68, 0xbd, 0x2c, 0x46, + 0xa7, 0xcc, 0x63, 0xba, 0x0f, 0x4b, 0x62, 0xc7, 0xaa, 0xd3, 0x85, 0x71, 0x70, 0x14, 0x89, 0xbe, + 0x83, 0xad, 0x44, 0xf9, 0x91, 0x7d, 0xa6, 0xee, 0x59, 0xe6, 0x86, 0x98, 0xa9, 0x69, 0xd4, 0x3b, + 0xf7, 0x0b, 0x6d, 0xcf, 0xb7, 0xea, 0xd0, 0xe4, 0x1f, 0xc8, 0xfe, 0x41, 0xc0, 0x98, 0x3a, 0xcc, + 0xb3, 0xda, 0xd1, 0xd6, 0xc8, 0x6d, 0xd6, 0xf2, 0xa4, 0xe6, 0x06, 0xf7, 0x60, 0x43, 0xb3, 0xdc, + 0xeb, 0xd5, 0xaa, 0x24, 0xae, 0x6b, 0xe0, 0x34, 0x5f, 0xf1, 0x53, 0x90, 0xe1, 0x74, 0xfd, 0xa1, + 0x17, 0x44, 0x66, 0xe5, 0xb6, 0xcf, 0xc1, 0x91, 0xe9, 0x3a, 0x14, 0x44, 0x7a, 0x0f, 0x1a, 0xb3, + 0x25, 0xf2, 0xcc, 0xd6, 0x67, 0xd4, 0xf7, 0xba, 0xf0, 0x5f, 0xc1, 0xbc, 0x29, 0xc0, 0xf2, 0x11, + 0x72, 0xf4, 0xb9, 0x51, 0xa2, 0x14, 0xd6, 0x0e, 0x47, 0xe8, 0x45, 0x6f, 0xe3, 0xbc, 0x8e, 0x41, + 0x68, 0x1d, 0x56, 0xf2, 0x3b, 0xa3, 0xdc, 0xf9, 0x4a, 0xa0, 0xa6, 0x45, 0xe8, 0x07, 0xd8, 0x38, + 0x41, 0x3e, 0xff, 0x4d, 0xd3, 0xdd, 0x42, 0xaf, 0xd3, 0xdf, 0x40, 0xb3, 0xb5, 0x98, 0xa0, 0x46, + 0x6c, 0x97, 0xe8, 0xb1, 0xf6, 0x44, 0x77, 0x16, 0x86, 0xa5, 0xd9, 0x2c, 0x82, 0xb4, 0x44, 0x9b, + 0x3c, 0x22, 0x5d, 0xe3, 0xf2, 0xca, 0x22, 0x3f, 0xaf, 0x2c, 0xf2, 0xfb, 0xca, 0x22, 0x5f, 0xfe, + 0x58, 0xa5, 0xb3, 0x65, 0xf9, 0x8f, 0x7a, 0xfc, 0x37, 0x00, 0x00, 0xff, 0xff, 0x93, 0xe7, 0xdb, + 0x29, 0xd5, 0x04, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -692,6 +837,96 @@ func (m *WaitForEntry) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } +func (m *ReplaceLockByKeyItem) 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 *ReplaceLockByKeyItem) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ReplaceLockByKeyItem) 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.NewLockTs != 0 { + i = encodeVarintDeadlock(dAtA, i, uint64(m.NewLockTs)) + i-- + dAtA[i] = 0x20 + } + if m.OldLockTs != 0 { + i = encodeVarintDeadlock(dAtA, i, uint64(m.OldLockTs)) + i-- + dAtA[i] = 0x18 + } + if len(m.Key) > 0 { + i -= len(m.Key) + copy(dAtA[i:], m.Key) + i = encodeVarintDeadlock(dAtA, i, uint64(len(m.Key))) + i-- + dAtA[i] = 0x12 + } + if m.KeyHash != 0 { + i = encodeVarintDeadlock(dAtA, i, uint64(m.KeyHash)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *ReplaceLocksByKeysRequest) 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 *ReplaceLocksByKeysRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ReplaceLocksByKeysRequest) 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.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 = encodeVarintDeadlock(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + func (m *DeadlockRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -716,16 +951,30 @@ func (m *DeadlockRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - { - size, err := m.Entry.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err + if m.ReplaceLocksByKeys != nil { + { + size, err := m.ReplaceLocksByKeys.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDeadlock(dAtA, i, uint64(size)) } - i -= size - i = encodeVarintDeadlock(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.Entry != nil { + { + size, err := m.Entry.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintDeadlock(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 } - i-- - dAtA[i] = 0x12 if m.Tp != 0 { i = encodeVarintDeadlock(dAtA, i, uint64(m.Tp)) i-- @@ -758,6 +1007,13 @@ func (m *DeadlockResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } + if len(m.DeadlockKey) > 0 { + i -= len(m.DeadlockKey) + copy(dAtA[i:], m.DeadlockKey) + i = encodeVarintDeadlock(dAtA, i, uint64(len(m.DeadlockKey))) + i-- + dAtA[i] = 0x22 + } if len(m.WaitChain) > 0 { for iNdEx := len(m.WaitChain) - 1; iNdEx >= 0; iNdEx-- { { @@ -863,6 +1119,49 @@ func (m *WaitForEntry) Size() (n int) { return n } +func (m *ReplaceLockByKeyItem) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.KeyHash != 0 { + n += 1 + sovDeadlock(uint64(m.KeyHash)) + } + l = len(m.Key) + if l > 0 { + n += 1 + l + sovDeadlock(uint64(l)) + } + if m.OldLockTs != 0 { + n += 1 + sovDeadlock(uint64(m.OldLockTs)) + } + if m.NewLockTs != 0 { + n += 1 + sovDeadlock(uint64(m.NewLockTs)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *ReplaceLocksByKeysRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Items) > 0 { + for _, e := range m.Items { + l = e.Size() + n += 1 + l + sovDeadlock(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + func (m *DeadlockRequest) Size() (n int) { if m == nil { return 0 @@ -872,8 +1171,14 @@ func (m *DeadlockRequest) Size() (n int) { if m.Tp != 0 { n += 1 + sovDeadlock(uint64(m.Tp)) } - l = m.Entry.Size() - n += 1 + l + sovDeadlock(uint64(l)) + if m.Entry != nil { + l = m.Entry.Size() + n += 1 + l + sovDeadlock(uint64(l)) + } + if m.ReplaceLocksByKeys != nil { + l = m.ReplaceLocksByKeys.Size() + n += 1 + l + sovDeadlock(uint64(l)) + } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } @@ -897,6 +1202,10 @@ func (m *DeadlockResponse) Size() (n int) { n += 1 + l + sovDeadlock(uint64(l)) } } + l = len(m.DeadlockKey) + if l > 0 { + n += 1 + l + sovDeadlock(uint64(l)) + } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } @@ -1240,6 +1549,233 @@ func (m *WaitForEntry) Unmarshal(dAtA []byte) error { } return nil } +func (m *ReplaceLockByKeyItem) 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 ErrIntOverflowDeadlock + } + 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: ReplaceLockByKeyItem: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ReplaceLockByKeyItem: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field KeyHash", wireType) + } + m.KeyHash = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDeadlock + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.KeyHash |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDeadlock + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthDeadlock + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthDeadlock + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...) + if m.Key == nil { + m.Key = []byte{} + } + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field OldLockTs", wireType) + } + m.OldLockTs = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDeadlock + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.OldLockTs |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field NewLockTs", wireType) + } + m.NewLockTs = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDeadlock + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.NewLockTs |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipDeadlock(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDeadlock + } + 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 *ReplaceLocksByKeysRequest) 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 ErrIntOverflowDeadlock + } + 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: ReplaceLocksByKeysRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ReplaceLocksByKeysRequest: 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 ErrIntOverflowDeadlock + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDeadlock + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDeadlock + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Items = append(m.Items, &ReplaceLockByKeyItem{}) + if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDeadlock(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthDeadlock + } + 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 *DeadlockRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1317,10 +1853,49 @@ func (m *DeadlockRequest) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } + if m.Entry == nil { + m.Entry = &WaitForEntry{} + } if err := m.Entry.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ReplaceLocksByKeys", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDeadlock + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDeadlock + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthDeadlock + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ReplaceLocksByKeys == nil { + m.ReplaceLocksByKeys = &ReplaceLocksByKeysRequest{} + } + if err := m.ReplaceLocksByKeys.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipDeadlock(dAtA[iNdEx:]) @@ -1458,6 +2033,40 @@ func (m *DeadlockResponse) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DeadlockKey", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDeadlock + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthDeadlock + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthDeadlock + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DeadlockKey = append(m.DeadlockKey[:0], dAtA[iNdEx:postIndex]...) + if m.DeadlockKey == nil { + m.DeadlockKey = []byte{} + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipDeadlock(dAtA[iNdEx:]) diff --git a/pkg/kvrpcpb/kvrpcpb.pb.go b/pkg/kvrpcpb/kvrpcpb.pb.go index cb16b2fbc..d450ffe9c 100644 --- a/pkg/kvrpcpb/kvrpcpb.pb.go +++ b/pkg/kvrpcpb/kvrpcpb.pb.go @@ -6942,13 +6942,16 @@ func (m *AlreadyExist) GetKey() []byte { } type Deadlock struct { - LockTs uint64 `protobuf:"varint,1,opt,name=lock_ts,json=lockTs,proto3" json:"lock_ts,omitempty"` - LockKey []byte `protobuf:"bytes,2,opt,name=lock_key,json=lockKey,proto3" json:"lock_key,omitempty"` - DeadlockKeyHash uint64 `protobuf:"varint,3,opt,name=deadlock_key_hash,json=deadlockKeyHash,proto3" json:"deadlock_key_hash,omitempty"` - WaitChain []*deadlock.WaitForEntry `protobuf:"bytes,4,rep,name=wait_chain,json=waitChain,proto3" json:"wait_chain,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + LockTs uint64 `protobuf:"varint,1,opt,name=lock_ts,json=lockTs,proto3" json:"lock_ts,omitempty"` + LockKey []byte `protobuf:"bytes,2,opt,name=lock_key,json=lockKey,proto3" json:"lock_key,omitempty"` + // The hash of `deadlock_key` field. + DeadlockKeyHash uint64 `protobuf:"varint,3,opt,name=deadlock_key_hash,json=deadlockKeyHash,proto3" json:"deadlock_key_hash,omitempty"` + WaitChain []*deadlock.WaitForEntry `protobuf:"bytes,4,rep,name=wait_chain,json=waitChain,proto3" json:"wait_chain,omitempty"` + // The key that the current transaction has already acquired and blocks another transaction to form the deadlock. + DeadlockKey []byte `protobuf:"bytes,5,opt,name=deadlock_key,json=deadlockKey,proto3" json:"deadlock_key,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } func (m *Deadlock) Reset() { *m = Deadlock{} } @@ -7012,6 +7015,13 @@ func (m *Deadlock) GetWaitChain() []*deadlock.WaitForEntry { return nil } +func (m *Deadlock) GetDeadlockKey() []byte { + if m != nil { + return m.DeadlockKey + } + return nil +} + type CommitTsExpired struct { StartTs uint64 `protobuf:"varint,1,opt,name=start_ts,json=startTs,proto3" json:"start_ts,omitempty"` AttemptedCommitTs uint64 `protobuf:"varint,2,opt,name=attempted_commit_ts,json=attemptedCommitTs,proto3" json:"attempted_commit_ts,omitempty"` @@ -11058,459 +11068,459 @@ func init() { func init() { proto.RegisterFile("kvrpcpb.proto", fileDescriptor_1afe832be69693c7) } var fileDescriptor_1afe832be69693c7 = []byte{ - // 7223 bytes of a gzipped FileDescriptorProto + // 7232 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x7d, 0x5b, 0x6c, 0x24, 0xc9, 0x71, 0xe0, 0x54, 0x3f, 0xd8, 0xcd, 0x68, 0xb2, 0xbb, 0x58, 0x7c, 0x35, 0x39, 0x33, 0x3b, 0x9c, 0x5a, 0xcd, 0xee, 0x88, 0xab, 0xe5, 0x68, 0xb9, 0x0f, 0x3d, 0x6f, 0xb5, 0x33, 0x9c, 0x17, 0x77, 0x66, 0x48, 0xa2, 0xba, 0x77, 0xf6, 0x16, 0x77, 0x52, 0x29, 0x59, 0x9d, 0xec, 0x2e, 0x74, 0x75, 0x55, 0x4d, 0x65, 0x36, 0xc9, 0x16, 0x70, 0xc0, 0x09, 0xf7, 0x00, 0x74, 0x38, 0xdc, 0xe9, 0x04, - 0x01, 0x3a, 0x40, 0xc2, 0x01, 0xf7, 0x21, 0xe0, 0xce, 0x80, 0x0c, 0x1b, 0xfe, 0xb1, 0xad, 0x0f, - 0xc3, 0x80, 0x3f, 0x56, 0x86, 0x05, 0xc9, 0x30, 0x0c, 0x19, 0xb2, 0x21, 0x18, 0x6b, 0xc0, 0xbf, - 0xd2, 0x87, 0x0d, 0xfb, 0xc7, 0xb0, 0x91, 0xaf, 0x7a, 0x74, 0xf7, 0x90, 0x1c, 0x0e, 0x67, 0x24, - 0xf9, 0x8b, 0x5d, 0x11, 0x91, 0x99, 0x91, 0x11, 0x91, 0x91, 0x91, 0x99, 0x91, 0x49, 0x98, 0xee, - 0xee, 0x47, 0xa1, 0x13, 0xee, 0xae, 0x85, 0x51, 0x40, 0x03, 0xa3, 0x24, 0x3f, 0x97, 0xa7, 0x7a, - 0x98, 0x22, 0x05, 0x5e, 0x9e, 0xc6, 0x51, 0x14, 0x44, 0xf1, 0xe7, 0x5c, 0x3b, 0x68, 0x07, 0xfc, - 0xe7, 0x35, 0xf6, 0x4b, 0x42, 0x6b, 0x51, 0x9f, 0x50, 0xfe, 0x53, 0x02, 0xaa, 0x2d, 0x8c, 0x5a, - 0x5e, 0xe0, 0x74, 0x55, 0x2d, 0x34, 0x42, 0x0e, 0x8e, 0x6b, 0x59, 0x88, 0x30, 0x09, 0xfa, 0x91, - 0x83, 0xed, 0x1e, 0xf2, 0x51, 0x1b, 0x47, 0x02, 0x6e, 0xb6, 0x00, 0xee, 0x60, 0x6a, 0xe1, 0x47, - 0x7d, 0x4c, 0xa8, 0xb1, 0x0a, 0x25, 0x27, 0xf0, 0x29, 0x3e, 0xa4, 0x75, 0x6d, 0x45, 0xbb, 0x5a, - 0x59, 0xd7, 0xd7, 0x14, 0xcb, 0x1b, 0x02, 0x6e, 0x29, 0x02, 0x43, 0x87, 0x7c, 0x17, 0x0f, 0xea, - 0xb9, 0x15, 0xed, 0xea, 0x94, 0xc5, 0x7e, 0x1a, 0x75, 0x28, 0xed, 0xe3, 0x88, 0xb8, 0x81, 0x5f, - 0xcf, 0xaf, 0x68, 0x57, 0x0b, 0x96, 0xfa, 0x34, 0x3f, 0xd2, 0xa0, 0xc2, 0x9b, 0x21, 0x61, 0xe0, - 0x13, 0x6c, 0xbc, 0x06, 0x53, 0x11, 0x6e, 0xbb, 0x81, 0x6f, 0xf3, 0xbe, 0xca, 0xc6, 0xaa, 0x6b, - 0xaa, 0xe7, 0xb7, 0xd8, 0x5f, 0xab, 0x22, 0x68, 0xf8, 0x87, 0xf1, 0x32, 0x14, 0x05, 0x6d, 0x8e, - 0xd3, 0xce, 0xc4, 0x8c, 0xdd, 0xc3, 0x03, 0x41, 0x2e, 0xf0, 0xc6, 0x1c, 0x14, 0xf7, 0x91, 0xd7, - 0xc7, 0x9c, 0x87, 0x29, 0x4b, 0x7c, 0x18, 0xe7, 0x61, 0xd2, 0x0f, 0xa8, 0xbd, 0x17, 0xf4, 0xfd, - 0x56, 0xbd, 0xb0, 0xa2, 0x5d, 0x2d, 0x5b, 0x65, 0x3f, 0xa0, 0xb7, 0xd9, 0xb7, 0xf1, 0x36, 0xd4, - 0xf0, 0x21, 0x76, 0xec, 0x16, 0xa6, 0xc8, 0xf5, 0x88, 0xbd, 0xbf, 0x5e, 0x9f, 0xe0, 0xad, 0x2c, - 0xc4, 0xad, 0xdc, 0x3a, 0xc4, 0xce, 0x4d, 0x81, 0x7e, 0xb8, 0x6e, 0x4d, 0xe3, 0xf4, 0xe7, 0xbb, - 0x85, 0x72, 0x51, 0x9f, 0x30, 0xff, 0x5e, 0x83, 0x4a, 0xc3, 0x41, 0xfe, 0x69, 0x84, 0x79, 0x1e, - 0x26, 0x09, 0x45, 0x11, 0xb5, 0x13, 0x91, 0x96, 0x39, 0xe0, 0x1e, 0x1e, 0xb0, 0x1e, 0x79, 0x6e, - 0xcf, 0xa5, 0xbc, 0x47, 0xd3, 0x96, 0xf8, 0x48, 0x4b, 0xbb, 0x90, 0x91, 0xb6, 0xb1, 0x04, 0xe5, - 0x2e, 0x1e, 0xd8, 0x81, 0xef, 0x0d, 0xea, 0x45, 0xde, 0xd5, 0x52, 0x17, 0x0f, 0xb6, 0x7d, 0x8f, - 0xab, 0x28, 0xc2, 0x8c, 0x0e, 0xf3, 0x1e, 0x96, 0x2d, 0xf5, 0x69, 0x2c, 0x42, 0x09, 0xfb, 0x2d, - 0xde, 0x7e, 0x89, 0xb7, 0x3f, 0x81, 0xfd, 0x16, 0x6b, 0xfd, 0x12, 0x54, 0x08, 0xea, 0x85, 0x1e, - 0xb6, 0x09, 0xc5, 0x61, 0xbd, 0xcc, 0x79, 0x00, 0x01, 0x6a, 0x50, 0x1c, 0x9a, 0xff, 0x4b, 0x83, - 0x29, 0xd1, 0xef, 0xd3, 0x6b, 0xf7, 0x0a, 0x14, 0x43, 0xe4, 0x46, 0xa4, 0x9e, 0x5b, 0xc9, 0x5f, - 0xad, 0xac, 0xd7, 0x12, 0xed, 0xee, 0xef, 0x20, 0x37, 0xb2, 0x04, 0x36, 0x31, 0x82, 0xfc, 0xd1, - 0x46, 0x60, 0xfe, 0xa2, 0x04, 0xb5, 0x9d, 0x08, 0x1f, 0x44, 0x2e, 0xc5, 0xa7, 0xd1, 0xc7, 0x35, - 0x98, 0xec, 0xf5, 0x29, 0xa2, 0x6e, 0xe0, 0x2b, 0x9e, 0x92, 0xc6, 0x1e, 0x48, 0x8c, 0x95, 0xd0, - 0x18, 0x97, 0x61, 0x2a, 0x8c, 0xdc, 0x1e, 0x8a, 0x06, 0x36, 0x1b, 0x84, 0xd2, 0xf8, 0x2a, 0x12, - 0x76, 0x3f, 0x70, 0xba, 0xc6, 0x8b, 0x30, 0x2d, 0x74, 0x9c, 0x55, 0xdb, 0x14, 0x07, 0x3e, 0x4c, - 0x74, 0xc7, 0xca, 0xdb, 0x94, 0x7a, 0x5c, 0x77, 0x05, 0xab, 0xc4, 0xbe, 0x9b, 0xd4, 0x33, 0xd6, - 0x61, 0x9e, 0x74, 0xdd, 0xd0, 0x76, 0x02, 0x9f, 0xd0, 0x08, 0xb9, 0x3e, 0xb5, 0x9d, 0x0e, 0x76, - 0xba, 0x52, 0x93, 0xb3, 0x0c, 0xb9, 0x11, 0xe3, 0x36, 0x18, 0xca, 0xf8, 0x77, 0x30, 0x1b, 0x62, - 0x42, 0xdc, 0x9e, 0x4b, 0xa8, 0xeb, 0xd8, 0xc8, 0x11, 0x3d, 0x2a, 0xad, 0xe4, 0xaf, 0x56, 0xd7, - 0x57, 0xe3, 0x1e, 0x0d, 0x89, 0x6a, 0x6d, 0x27, 0x29, 0x73, 0x9d, 0x17, 0xb1, 0x8c, 0x70, 0x18, - 0x44, 0x18, 0xaf, 0xf4, 0xd0, 0xb7, 0x89, 0xfb, 0x15, 0xcc, 0xcd, 0xa2, 0x60, 0x95, 0xe8, 0xa1, - 0xdf, 0x70, 0xbf, 0x82, 0x0d, 0x13, 0xa6, 0xf7, 0x82, 0xc8, 0xee, 0x87, 0x2d, 0x44, 0xb1, 0x4d, - 0x49, 0x7d, 0x92, 0xe3, 0x2b, 0x7b, 0x41, 0xf4, 0x1e, 0x87, 0x35, 0x09, 0xa3, 0xe9, 0xb9, 0xbe, - 0xed, 0x04, 0xbd, 0x9e, 0x4b, 0x19, 0x0d, 0x08, 0x9a, 0x9e, 0xeb, 0x6f, 0x70, 0x58, 0x93, 0x18, - 0x57, 0x41, 0xef, 0x13, 0x6c, 0x23, 0x32, 0xf0, 0x1d, 0x49, 0x59, 0xaf, 0xf0, 0xee, 0x56, 0xfb, - 0x04, 0x5f, 0x67, 0x60, 0x41, 0x6b, 0xac, 0x40, 0x85, 0x60, 0x27, 0xf0, 0x5b, 0x28, 0x72, 0x31, - 0xa9, 0x4f, 0xad, 0xe4, 0x99, 0xfc, 0x53, 0x20, 0xe3, 0x02, 0x00, 0x8d, 0xd8, 0xb0, 0xc0, 0x76, - 0xe8, 0xd4, 0xa7, 0x85, 0x0f, 0xa0, 0xd1, 0x60, 0xdb, 0xc7, 0x3b, 0x0e, 0xe7, 0x06, 0x1d, 0xa6, - 0xb8, 0xa9, 0x4a, 0x6e, 0xd0, 0x61, 0xcc, 0xcd, 0x3b, 0x50, 0x43, 0x84, 0xe0, 0x88, 0x75, 0xdf, - 0xf6, 0xf0, 0x3e, 0xf6, 0xea, 0xb5, 0x15, 0xed, 0x6a, 0x75, 0x7d, 0x31, 0x96, 0xe4, 0x75, 0x85, - 0xbf, 0xcf, 0xd0, 0x56, 0x15, 0x65, 0xbe, 0x0d, 0x17, 0x96, 0x32, 0x72, 0x49, 0x29, 0x93, 0xd4, - 0x75, 0x6e, 0x67, 0x6b, 0x8f, 0xd5, 0xca, 0xed, 0x58, 0x78, 0x8d, 0x44, 0xcf, 0xd6, 0x42, 0x4a, - 0xa6, 0x09, 0x98, 0x18, 0x2f, 0x41, 0x8d, 0x69, 0x67, 0xcf, 0xf5, 0xb0, 0xed, 0x74, 0xfa, 0x7e, - 0x97, 0xd4, 0x5b, 0x2b, 0xf9, 0xab, 0x05, 0x6b, 0x9a, 0x1e, 0xfa, 0xb7, 0x5d, 0x0f, 0x6f, 0x70, - 0xe0, 0xf2, 0x2e, 0xcc, 0x8f, 0xad, 0x98, 0xb9, 0x1d, 0xd7, 0x6f, 0xe1, 0x43, 0x3e, 0x5a, 0xa6, - 0x2d, 0xf1, 0x61, 0xbc, 0x0e, 0x0b, 0xf8, 0x30, 0xc4, 0x0e, 0xc5, 0x2d, 0x3b, 0xab, 0xe2, 0x1c, - 0x17, 0xd8, 0xac, 0xc2, 0x26, 0x95, 0x12, 0x73, 0x17, 0x66, 0x46, 0x4c, 0xca, 0x58, 0x86, 0x85, - 0xc6, 0xbd, 0xcd, 0x1d, 0x7b, 0xe7, 0x56, 0xa3, 0xb1, 0xf9, 0x60, 0xb3, 0xd1, 0xdc, 0xdc, 0xb0, - 0x37, 0xee, 0xde, 0xda, 0xb8, 0xa7, 0x9f, 0x33, 0xea, 0x30, 0x77, 0x73, 0x7b, 0x0c, 0x46, 0x33, - 0x16, 0x61, 0xf6, 0xe6, 0xb6, 0xbd, 0xb1, 0xbd, 0xd5, 0x68, 0x5a, 0xd7, 0x37, 0xb7, 0x9a, 0x12, - 0x91, 0x33, 0xff, 0x49, 0x03, 0x3d, 0x91, 0xd8, 0xe9, 0x5d, 0xd1, 0xc7, 0x61, 0x82, 0x63, 0x47, - 0xc7, 0x7d, 0xec, 0x64, 0x24, 0xc1, 0xa8, 0x05, 0xe7, 0x47, 0x2d, 0xf8, 0x65, 0xd0, 0x85, 0xc5, - 0xa5, 0xc8, 0xc4, 0xc0, 0x9f, 0x0e, 0x98, 0xe1, 0xc5, 0x84, 0x63, 0x26, 0xa1, 0xe2, 0x13, 0x4c, - 0x42, 0xe6, 0x1f, 0x15, 0x60, 0x21, 0x25, 0x64, 0xe6, 0x72, 0xfe, 0xb5, 0x78, 0xbe, 0x11, 0x6f, - 0x32, 0x31, 0xd6, 0x9b, 0xb8, 0xc4, 0xde, 0x73, 0x23, 0x42, 0x05, 0x1f, 0x25, 0x3e, 0xc0, 0x2b, - 0x2e, 0xb9, 0xcd, 0x60, 0x9c, 0x8f, 0xcb, 0x30, 0x75, 0x80, 0x98, 0x0a, 0xdc, 0x1e, 0x0e, 0xfa, - 0x94, 0x3b, 0xad, 0xbc, 0x55, 0x61, 0xb0, 0xa6, 0x00, 0x19, 0x75, 0x28, 0xee, 0x05, 0x91, 0x83, - 0xb9, 0xc3, 0x2a, 0xdf, 0xc8, 0xd5, 0x35, 0x4b, 0x00, 0x58, 0x27, 0x22, 0x4c, 0xfb, 0x91, 0x6f, - 0xf3, 0x88, 0x42, 0xb8, 0xab, 0xb2, 0x35, 0x25, 0x80, 0x0f, 0x39, 0x6c, 0xd4, 0x22, 0x2a, 0xe3, - 0x2c, 0xa2, 0xc6, 0xfd, 0xb6, 0x8d, 0x0f, 0x5d, 0x42, 0xb1, 0xef, 0xe0, 0xfa, 0x94, 0x70, 0x69, - 0x1c, 0x7c, 0x4b, 0x41, 0x8d, 0x57, 0x61, 0x96, 0x4b, 0x84, 0x4d, 0xe4, 0xb6, 0xbb, 0x27, 0xe8, - 0x89, 0xf4, 0x5c, 0x3a, 0x43, 0xb1, 0x39, 0x7d, 0x73, 0x8f, 0x97, 0x20, 0xc6, 0x4d, 0xd6, 0xbb, - 0x2e, 0xb6, 0xfb, 0xa1, 0xdd, 0x0b, 0x5a, 0x98, 0x3b, 0xb0, 0xea, 0xba, 0x99, 0xb8, 0x93, 0xac, - 0x71, 0xbc, 0x8f, 0xba, 0xf8, 0xbd, 0xf0, 0x41, 0xd0, 0xc2, 0x16, 0x1c, 0xc4, 0xbf, 0xcd, 0x5f, - 0x68, 0x50, 0x1f, 0xa2, 0xbc, 0x87, 0x07, 0x16, 0x26, 0x7d, 0x8f, 0x1a, 0x9f, 0x81, 0x02, 0x1d, - 0x84, 0x98, 0x5b, 0x51, 0x75, 0xfd, 0xca, 0xe3, 0xaa, 0x8e, 0x0b, 0x34, 0x07, 0x21, 0xb6, 0x78, - 0x91, 0x24, 0x2c, 0xcb, 0xa5, 0xc3, 0xb2, 0x0b, 0x30, 0x99, 0x48, 0x21, 0xcf, 0x3b, 0x96, 0x00, - 0x8c, 0x37, 0x61, 0x91, 0xf5, 0x12, 0xb7, 0xec, 0x03, 0x97, 0x76, 0x98, 0xaf, 0xdc, 0xf3, 0x5c, - 0x27, 0x35, 0x84, 0xe6, 0x04, 0xfa, 0x7d, 0x97, 0x76, 0x36, 0x24, 0xb2, 0x49, 0x8c, 0x35, 0xe0, - 0x73, 0xa1, 0xcd, 0x42, 0x5e, 0x6f, 0xdf, 0xf5, 0xdb, 0xc2, 0x20, 0xc4, 0xbc, 0x31, 0xc3, 0x50, - 0x96, 0xc2, 0x30, 0x6e, 0xcd, 0xbf, 0xcd, 0xc1, 0xe2, 0xc8, 0xc8, 0x79, 0x2e, 0x0e, 0xe4, 0x12, - 0x4c, 0x0e, 0x39, 0x0f, 0x6e, 0x71, 0x65, 0x47, 0xd9, 0x4a, 0x5d, 0x49, 0x8d, 0xf5, 0x77, 0x4a, - 0x98, 0xa3, 0x90, 0xdc, 0x02, 0x4c, 0x48, 0x3b, 0x2c, 0xf2, 0xa9, 0x4e, 0x7e, 0x19, 0x17, 0x01, - 0xe2, 0x40, 0x97, 0x0d, 0x94, 0x3c, 0x13, 0xa9, 0x8a, 0x74, 0xc7, 0x7a, 0x99, 0xd2, 0x13, 0x78, - 0x19, 0xe3, 0x73, 0x2c, 0x80, 0x64, 0xaa, 0x25, 0xf5, 0x32, 0xef, 0xdd, 0xe5, 0x63, 0x8d, 0xc0, - 0x52, 0x25, 0xcc, 0xef, 0x6a, 0xb0, 0x9c, 0xa2, 0xb2, 0x02, 0xcf, 0xdb, 0x45, 0xa7, 0x73, 0x53, - 0x23, 0x2e, 0x25, 0x37, 0xc6, 0xa5, 0x8c, 0xf8, 0x8d, 0xfc, 0xa8, 0xdf, 0x30, 0xa0, 0xd0, 0xc5, - 0x03, 0x66, 0x50, 0x4c, 0x8a, 0xfc, 0xb7, 0xf9, 0x7d, 0x0d, 0xce, 0x8f, 0xe5, 0xf3, 0xb9, 0x18, - 0xc5, 0x18, 0x15, 0xe5, 0x9f, 0x64, 0x22, 0xf8, 0x53, 0x0d, 0x66, 0x9b, 0x87, 0xfe, 0x5d, 0x8c, - 0x22, 0x7a, 0x03, 0xa3, 0x53, 0x2d, 0xee, 0x86, 0x9d, 0x7a, 0xee, 0x04, 0x4e, 0x3d, 0x3f, 0x46, - 0x03, 0x2f, 0x41, 0x0d, 0xb5, 0xf6, 0x5d, 0x82, 0xed, 0xd8, 0xb7, 0xcb, 0xc9, 0x4f, 0x80, 0xef, - 0x4b, 0x0f, 0xff, 0x02, 0x54, 0x5c, 0x62, 0xab, 0x78, 0xa5, 0xde, 0x12, 0x9e, 0xc0, 0x25, 0x4d, - 0x11, 0xaa, 0x98, 0x3f, 0xd4, 0x60, 0x2e, 0xdb, 0xa7, 0xe7, 0xb0, 0x92, 0x4c, 0xcf, 0x48, 0xf9, - 0xec, 0x8c, 0x34, 0x46, 0x47, 0x85, 0x27, 0xd1, 0xd1, 0xf7, 0xf2, 0x30, 0xcf, 0x23, 0xf4, 0xe6, - 0xa1, 0xdf, 0xa0, 0x88, 0xf6, 0xc9, 0x69, 0xb4, 0x74, 0x09, 0x94, 0x46, 0x52, 0xeb, 0x46, 0x90, - 0x20, 0xb6, 0x76, 0x5b, 0x84, 0x92, 0xe8, 0x81, 0x32, 0xfd, 0x09, 0xde, 0x01, 0x1e, 0x1c, 0x3a, - 0xc8, 0xf3, 0x70, 0x64, 0x0b, 0x1d, 0x26, 0x41, 0x89, 0x00, 0x37, 0x18, 0xb4, 0xc9, 0xbd, 0x89, - 0xd3, 0x8f, 0x22, 0xec, 0x73, 0x12, 0x31, 0x2d, 0x4f, 0x4a, 0x48, 0x93, 0x18, 0xaf, 0xc1, 0x7c, - 0x24, 0x07, 0x07, 0x9b, 0xa0, 0x98, 0xe3, 0xe1, 0xde, 0x5b, 0x2e, 0x49, 0x0c, 0x85, 0xdc, 0xdc, - 0xdb, 0x0a, 0x28, 0x9f, 0xa6, 0x8c, 0x55, 0x98, 0xe1, 0xf3, 0xa9, 0x9d, 0x0e, 0xe9, 0xc5, 0x5c, - 0x5d, 0xe3, 0x88, 0x46, 0x12, 0xd3, 0x7f, 0x1e, 0x96, 0x13, 0x1f, 0x9e, 0x5e, 0xc7, 0x70, 0x9b, - 0x2c, 0xf3, 0x42, 0xf5, 0x98, 0x62, 0xc8, 0xff, 0xb0, 0x96, 0xf6, 0x71, 0xe4, 0xee, 0x0d, 0x6c, - 0x97, 0xd8, 0x52, 0x28, 0x62, 0x5a, 0xb7, 0x6a, 0x02, 0xb1, 0x49, 0x76, 0x04, 0xf8, 0x58, 0xfb, - 0xfb, 0x51, 0x0e, 0x16, 0x86, 0xf5, 0xf5, 0xcb, 0xb5, 0xc0, 0x2b, 0x50, 0x95, 0x53, 0x47, 0x36, - 0xa8, 0x9a, 0x16, 0x50, 0x35, 0x00, 0x5f, 0x86, 0x09, 0xb1, 0xe8, 0xe3, 0xca, 0xab, 0xa6, 0x56, - 0xd6, 0x72, 0x61, 0x27, 0xd1, 0xc6, 0x1a, 0x4c, 0xf2, 0xa6, 0x5c, 0x7f, 0x2f, 0x90, 0xbb, 0x1f, - 0x09, 0x5f, 0x4c, 0x9e, 0x9b, 0xfe, 0x5e, 0x60, 0x71, 0x76, 0xd8, 0xaf, 0xa7, 0x9d, 0x48, 0xcc, - 0xaf, 0x6a, 0xb0, 0xcc, 0x25, 0xda, 0x90, 0x4b, 0x34, 0xee, 0x55, 0x4e, 0x35, 0x0c, 0x94, 0x0b, - 0xcf, 0x25, 0x2e, 0xfc, 0x44, 0xde, 0xc9, 0xfc, 0x67, 0x0d, 0xce, 0x8f, 0xe5, 0xe1, 0x39, 0xa8, - 0xf6, 0x65, 0x28, 0x32, 0x59, 0xb2, 0x81, 0x99, 0x1f, 0x2f, 0x6b, 0x81, 0x37, 0xce, 0xa7, 0x63, - 0x04, 0xa1, 0xe3, 0x24, 0x3e, 0x78, 0xda, 0x45, 0xc3, 0x0f, 0x34, 0x98, 0x16, 0x83, 0xed, 0x99, - 0x4d, 0xc2, 0x4a, 0x3b, 0xf9, 0x94, 0x76, 0x4e, 0x68, 0xbc, 0xc7, 0x8c, 0x4a, 0xb1, 0xef, 0x66, - 0x4d, 0xec, 0xba, 0xbe, 0x17, 0xb4, 0xcd, 0x3f, 0xd3, 0xa0, 0xaa, 0xfa, 0xf2, 0x1c, 0x14, 0x38, - 0xda, 0x87, 0xfc, 0xb8, 0x3e, 0x3c, 0xed, 0x4c, 0xd1, 0x86, 0xe9, 0xcd, 0x5e, 0x18, 0x44, 0xb1, - 0x82, 0x32, 0x0b, 0x34, 0xed, 0x04, 0x0b, 0xb4, 0x51, 0x46, 0x73, 0x63, 0x18, 0x35, 0x3f, 0x80, - 0xaa, 0x6a, 0xe8, 0xf4, 0xd2, 0x9b, 0x4b, 0x4b, 0x6f, 0x52, 0xed, 0xc6, 0x7d, 0x83, 0x69, 0xc6, - 0xc3, 0xc8, 0xef, 0x87, 0x67, 0xb3, 0xd3, 0x7c, 0xa2, 0xd8, 0x23, 0x3b, 0x77, 0x15, 0x86, 0xe6, - 0x2e, 0xf3, 0x9b, 0x1a, 0xd4, 0x62, 0xa6, 0x7e, 0x65, 0xec, 0xc5, 0xec, 0x42, 0xed, 0x06, 0xa2, - 0x4e, 0xe7, 0x94, 0xbb, 0xf2, 0xe3, 0x7c, 0xe1, 0xe3, 0xf7, 0xe5, 0xff, 0x52, 0x03, 0x3d, 0x69, - 0xed, 0x99, 0x6f, 0xdf, 0x3e, 0xe5, 0x58, 0x48, 0x64, 0x5d, 0x3c, 0x5a, 0xd6, 0xef, 0x16, 0xca, - 0x79, 0xbd, 0x60, 0x7e, 0x5b, 0x83, 0x39, 0xde, 0xbb, 0x67, 0xbe, 0xd0, 0x18, 0xe7, 0xe3, 0x8e, - 0x0b, 0x29, 0x7e, 0x47, 0x83, 0xf9, 0x21, 0xee, 0x9e, 0x83, 0x15, 0x3e, 0xed, 0xe2, 0xe2, 0x37, - 0x34, 0xa8, 0x35, 0x1c, 0xe4, 0x9f, 0x76, 0x7b, 0xe9, 0x12, 0x54, 0x7a, 0xe8, 0x70, 0x48, 0x98, - 0xd0, 0x43, 0x87, 0x4a, 0x94, 0x99, 0x93, 0x90, 0xfc, 0xe3, 0x4e, 0x42, 0x0a, 0xe9, 0x93, 0x90, - 0xd4, 0xd1, 0x45, 0x31, 0x7d, 0x74, 0x61, 0xfe, 0x44, 0x03, 0x3d, 0x61, 0xf6, 0x57, 0x69, 0x52, - 0x7f, 0xda, 0x59, 0xe1, 0xe7, 0x1a, 0x18, 0x62, 0x13, 0x03, 0x9f, 0x56, 0x13, 0x27, 0x32, 0xec, - 0x13, 0x4e, 0x72, 0xaf, 0xc2, 0x24, 0x33, 0x74, 0x16, 0x3b, 0x8a, 0x95, 0x74, 0xba, 0xe5, 0xe6, - 0xa1, 0x2f, 0x62, 0x47, 0x2a, 0x7e, 0x24, 0x6b, 0xee, 0xe2, 0x13, 0x0c, 0x97, 0xdf, 0xd6, 0x60, - 0x36, 0xd3, 0xe3, 0x5f, 0x83, 0xc1, 0xf2, 0x10, 0x26, 0xef, 0x6c, 0x9c, 0x46, 0x37, 0x17, 0x01, - 0x08, 0xda, 0xc3, 0x76, 0x18, 0xb8, 0x3e, 0x95, 0x8a, 0x99, 0x64, 0x90, 0x1d, 0x06, 0x30, 0x3b, - 0x00, 0xac, 0xde, 0x67, 0x2f, 0x01, 0xf3, 0x5b, 0x1a, 0x18, 0x37, 0xb1, 0x87, 0x29, 0xb6, 0x90, - 0xdf, 0xc6, 0x67, 0x7e, 0xb4, 0x99, 0x1a, 0xba, 0xf9, 0xe1, 0x53, 0x47, 0x3f, 0xa0, 0x6c, 0xf1, - 0xc6, 0x8f, 0x31, 0xc5, 0x89, 0x2d, 0x08, 0xd0, 0xb6, 0xef, 0x0d, 0xcc, 0x2f, 0xc1, 0x6c, 0x86, - 0xb1, 0xb3, 0x8e, 0x59, 0x7e, 0x4f, 0x83, 0x95, 0x9d, 0x08, 0x87, 0x28, 0xc2, 0xb7, 0x3d, 0x44, - 0x3a, 0xcc, 0x43, 0x37, 0x03, 0x69, 0xf0, 0xcf, 0x4f, 0x0e, 0x4b, 0x50, 0x1e, 0x5a, 0xa1, 0x97, - 0x88, 0x5c, 0x9b, 0xa7, 0xa6, 0xf5, 0x62, 0x76, 0x5a, 0xf7, 0xe0, 0xf2, 0x11, 0xac, 0x9f, 0xb5, - 0xa4, 0x7e, 0xa4, 0xc1, 0xd2, 0xd9, 0x88, 0x28, 0xd5, 0xa3, 0x5c, 0xf6, 0x48, 0xfb, 0xc8, 0x59, - 0x21, 0x25, 0xbc, 0xc2, 0x63, 0x85, 0x57, 0xcc, 0x0a, 0x2f, 0xb3, 0xaa, 0x9a, 0xc8, 0xae, 0xaa, - 0x4c, 0x0c, 0xcb, 0xcf, 0x43, 0x70, 0x5f, 0x84, 0x69, 0x0b, 0x1d, 0x9c, 0x59, 0xfa, 0x45, 0x15, - 0x72, 0xce, 0x1e, 0x17, 0xce, 0xa4, 0x95, 0x73, 0xf6, 0xcc, 0xff, 0xae, 0x41, 0x55, 0xd5, 0x7f, - 0xc6, 0xac, 0x9f, 0x22, 0xc9, 0xc2, 0x6c, 0x81, 0x61, 0xa1, 0x83, 0xb3, 0x8e, 0x6d, 0x87, 0x3b, - 0x1d, 0xc0, 0x6c, 0xa6, 0x95, 0x67, 0x1d, 0xd3, 0x9a, 0xff, 0x47, 0xe3, 0x5a, 0xdc, 0xe9, 0x9f, - 0x91, 0x16, 0xc7, 0x4b, 0x56, 0x74, 0xb3, 0xa0, 0xba, 0xc9, 0xca, 0x25, 0xe7, 0x64, 0xec, 0x27, - 0x1b, 0x04, 0x7b, 0x41, 0x64, 0x3b, 0x88, 0xc8, 0xcd, 0xb7, 0x89, 0xbd, 0x20, 0xda, 0x40, 0x84, - 0xad, 0xeb, 0x14, 0x7f, 0x67, 0x6d, 0xc0, 0xbf, 0xaf, 0x25, 0x3a, 0x3d, 0xa5, 0x00, 0x4e, 0xb8, - 0x72, 0x18, 0x52, 0xb3, 0x31, 0x27, 0xfa, 0x5f, 0x88, 0x8f, 0x4c, 0x86, 0x65, 0x50, 0x4c, 0xcb, - 0x80, 0x59, 0x0e, 0xa5, 0x9e, 0x38, 0x0e, 0x29, 0x58, 0xfc, 0x37, 0x9b, 0x40, 0x32, 0xbc, 0x9f, - 0xb5, 0x70, 0x06, 0xa0, 0x5b, 0xe8, 0x40, 0xce, 0x51, 0xcf, 0x62, 0x80, 0xa7, 0xbb, 0x5b, 0xc8, - 0xa8, 0xfc, 0xdf, 0xc3, 0x4c, 0xaa, 0xe9, 0xb3, 0xee, 0xd8, 0x7f, 0xd4, 0x60, 0x5e, 0x49, 0xee, - 0xf4, 0xdd, 0x3b, 0xc1, 0x60, 0x7e, 0x7c, 0x07, 0x11, 0x2c, 0x0c, 0x73, 0x70, 0xd6, 0xbd, 0xfc, - 0xa1, 0xf0, 0x9e, 0xcf, 0x31, 0xa1, 0x2b, 0x9d, 0xb6, 0x55, 0xc8, 0xa6, 0x6d, 0x09, 0xc1, 0x14, - 0x63, 0xc1, 0x3c, 0x79, 0x1a, 0x97, 0xd9, 0x86, 0x5a, 0xdc, 0x9d, 0xd3, 0xcb, 0xea, 0x32, 0xe4, - 0xbb, 0xfb, 0x8f, 0x1d, 0xac, 0x0c, 0x67, 0x7e, 0x4d, 0x98, 0xc7, 0x2f, 0x25, 0x6a, 0x1c, 0x72, - 0x93, 0xd2, 0x4e, 0x9e, 0x69, 0x9c, 0xf8, 0x63, 0x2d, 0xf1, 0x23, 0xa7, 0x35, 0x96, 0x8f, 0xc3, - 0x44, 0xc4, 0xb8, 0x1b, 0x7b, 0x38, 0x28, 0xf8, 0x96, 0x04, 0x6c, 0x65, 0x80, 0x91, 0xd3, 0xb1, - 0xd3, 0xf6, 0x33, 0xc9, 0x20, 0xf7, 0xcf, 0xcc, 0x86, 0x4c, 0x0f, 0xe6, 0xb2, 0x3d, 0x7a, 0xa6, - 0xf6, 0xf2, 0x1f, 0x60, 0xe9, 0x3d, 0x9f, 0xad, 0x6d, 0x6e, 0x62, 0x42, 0xa3, 0x60, 0xf0, 0x7c, - 0x4d, 0x86, 0xc5, 0x7a, 0xe3, 0x9a, 0x3f, 0x6b, 0x33, 0xf9, 0x32, 0x9c, 0xb7, 0x70, 0xdb, 0x25, - 0x14, 0x47, 0x6c, 0xf9, 0xba, 0xbd, 0x4b, 0x70, 0xb4, 0x8f, 0xa3, 0xd3, 0xf4, 0x73, 0x1e, 0x26, - 0x7a, 0xe8, 0x30, 0xc9, 0xb8, 0x2a, 0xf6, 0xd0, 0x61, 0x93, 0x98, 0x6f, 0xc0, 0x85, 0xf1, 0x2d, - 0xc8, 0xae, 0xc4, 0x7c, 0x69, 0xd9, 0x18, 0xb4, 0xce, 0x4f, 0x40, 0x9e, 0x11, 0x53, 0x7d, 0x58, - 0x1a, 0x53, 0xfd, 0x51, 0x1c, 0x31, 0x13, 0x76, 0x89, 0xed, 0x78, 0x18, 0x89, 0x55, 0x40, 0xd9, - 0x2a, 0xb9, 0x84, 0x6f, 0xd4, 0x9e, 0x78, 0x7b, 0xc5, 0xfc, 0x12, 0x2c, 0x59, 0xb8, 0x17, 0x88, - 0xad, 0x82, 0x67, 0xd0, 0xad, 0x75, 0x58, 0x1e, 0x57, 0xff, 0x91, 0x92, 0xfe, 0x9f, 0x1a, 0x2c, - 0xee, 0x74, 0x06, 0xc4, 0x75, 0x90, 0xf7, 0x34, 0x3b, 0x68, 0xe3, 0x59, 0x3a, 0xc5, 0xbe, 0x99, - 0xf9, 0x01, 0xd4, 0x47, 0x19, 0x3a, 0x52, 0x37, 0xb1, 0x02, 0x72, 0xc7, 0x28, 0xe0, 0x3b, 0x1a, - 0x18, 0x8d, 0xd0, 0x73, 0xa9, 0xc5, 0x47, 0xc6, 0xe9, 0x76, 0x0a, 0x27, 0x09, 0xab, 0x21, 0x19, - 0xce, 0x22, 0x37, 0x86, 0x03, 0x59, 0xa7, 0x2e, 0x02, 0xc4, 0x04, 0x6a, 0xeb, 0x75, 0x52, 0x61, - 0x89, 0xb1, 0x0c, 0x93, 0x2e, 0xb1, 0x23, 0x74, 0x60, 0x77, 0xf7, 0x95, 0x2f, 0x74, 0x89, 0x85, - 0x0e, 0xee, 0xed, 0x9b, 0x3f, 0xd7, 0x60, 0x36, 0xc3, 0xde, 0xe9, 0x87, 0xfb, 0x4b, 0x50, 0xf0, - 0xf0, 0x1e, 0x95, 0x3b, 0x29, 0xd5, 0x35, 0x99, 0xca, 0x2f, 0x2a, 0xe6, 0x1c, 0x73, 0xbc, 0x71, - 0x15, 0x8a, 0x91, 0xdb, 0xee, 0x50, 0xb9, 0x83, 0x34, 0x8e, 0x50, 0x10, 0x18, 0x57, 0x99, 0x63, - 0x6e, 0xf3, 0xe3, 0x1d, 0xb1, 0x95, 0x36, 0x44, 0x6b, 0x29, 0x74, 0x2a, 0xa9, 0xa4, 0x75, 0x4c, - 0x52, 0x89, 0xf9, 0x9f, 0x35, 0xd0, 0x2d, 0x8c, 0x5a, 0x9b, 0x7e, 0x0b, 0x1f, 0x9e, 0x46, 0x1d, - 0xe9, 0xb5, 0x74, 0x2e, 0xbb, 0x96, 0x4e, 0xa6, 0xaf, 0xfc, 0x31, 0xd3, 0x97, 0xf9, 0x75, 0x0d, - 0x66, 0x52, 0x6c, 0x9c, 0x5e, 0xec, 0x17, 0x01, 0x22, 0x8c, 0x5a, 0xb6, 0xc8, 0x50, 0x95, 0x3b, - 0x64, 0x91, 0xaa, 0x99, 0xb1, 0x24, 0x52, 0xc3, 0x46, 0x32, 0xc5, 0x63, 0x4b, 0x95, 0x04, 0x66, - 0x03, 0x66, 0x1f, 0xec, 0x3b, 0xce, 0x1d, 0x4c, 0x6f, 0x0c, 0x78, 0xce, 0xd2, 0x19, 0x84, 0xea, - 0xe6, 0x7f, 0xd5, 0x60, 0x2e, 0x5b, 0xeb, 0x59, 0xaf, 0xc0, 0xaf, 0x40, 0x81, 0x1f, 0xd5, 0x0f, - 0xf7, 0x8f, 0xb5, 0xca, 0xfb, 0xc7, 0xd1, 0xe6, 0x97, 0x61, 0x31, 0xe6, 0x43, 0x26, 0x75, 0x9c, - 0xad, 0xf6, 0xd9, 0x50, 0xaf, 0x8f, 0x36, 0x71, 0xd6, 0xdd, 0x95, 0x22, 0xce, 0x27, 0xab, 0x21, - 0x25, 0x80, 0xc2, 0xd1, 0x02, 0xf8, 0x2d, 0x80, 0xd2, 0x46, 0x12, 0x21, 0x48, 0x6e, 0xdc, 0x16, - 0x67, 0xa5, 0x60, 0x95, 0x05, 0x60, 0xb3, 0x65, 0xbc, 0x95, 0xb0, 0x1a, 0x06, 0x4e, 0x47, 0x0e, - 0xe8, 0xd9, 0xec, 0xd8, 0xbb, 0xc5, 0x50, 0x31, 0xbf, 0xec, 0xc3, 0x58, 0x81, 0x42, 0x88, 0xb1, - 0xba, 0x92, 0x30, 0xa5, 0xe8, 0x77, 0x30, 0x8e, 0x2c, 0x8e, 0xe1, 0xab, 0x4f, 0x1c, 0xf5, 0xe4, - 0x6a, 0x9d, 0xff, 0x36, 0xae, 0x41, 0x39, 0x8c, 0xdc, 0x20, 0x72, 0xe9, 0x80, 0x87, 0x5f, 0xd5, - 0xf5, 0xd9, 0x94, 0xf4, 0x7b, 0x3d, 0xe4, 0xb7, 0x76, 0x22, 0xd7, 0x8a, 0x89, 0x8c, 0x77, 0xa0, - 0xe6, 0x92, 0xc0, 0x43, 0xa9, 0xdc, 0xf3, 0xd2, 0x50, 0xee, 0xf9, 0xa6, 0xc2, 0xcb, 0xdc, 0x73, - 0x37, 0xf3, 0x6d, 0x7c, 0x0c, 0xaa, 0x7c, 0x77, 0xc6, 0xf5, 0x3c, 0xdb, 0x41, 0x4e, 0x07, 0xcb, - 0x0c, 0x9a, 0x29, 0x3f, 0xa0, 0xb7, 0x5d, 0xcf, 0xdb, 0x60, 0x30, 0xae, 0xe9, 0x81, 0xef, 0xd8, - 0x5e, 0xd0, 0x96, 0xc9, 0x32, 0x25, 0xf6, 0x7d, 0x3f, 0x68, 0x1b, 0x57, 0x41, 0x8f, 0xb0, 0x13, - 0x44, 0x2d, 0x9e, 0x40, 0x6b, 0x13, 0x8a, 0xa8, 0x4c, 0x82, 0xad, 0x0a, 0x78, 0xd3, 0xed, 0xe1, - 0x06, 0x45, 0x34, 0x45, 0x49, 0x1c, 0xe4, 0x0b, 0xca, 0x4a, 0x9a, 0x92, 0xcd, 0x37, 0x9c, 0xf2, - 0x32, 0x93, 0x7a, 0xe8, 0xb9, 0x0e, 0xb2, 0xd9, 0xe8, 0x95, 0x99, 0xb0, 0x15, 0x09, 0x63, 0xae, - 0xc2, 0xb8, 0x02, 0x55, 0x91, 0xe3, 0x83, 0x5b, 0xb6, 0x98, 0x7d, 0xa6, 0x45, 0x1e, 0xbb, 0x82, - 0xf2, 0xa4, 0x0d, 0xe3, 0x33, 0xb0, 0xc4, 0xe6, 0x45, 0x7c, 0x88, 0x9d, 0x3e, 0x17, 0x52, 0xab, - 0x1f, 0x09, 0x69, 0xf5, 0x54, 0x32, 0xff, 0x42, 0x0f, 0x1d, 0xde, 0x52, 0xf8, 0x9b, 0x12, 0xfd, - 0x80, 0x27, 0x8b, 0xa0, 0x30, 0xf4, 0x5c, 0xac, 0xfc, 0x49, 0x4d, 0x1c, 0x85, 0x48, 0xa0, 0x70, - 0x29, 0x8b, 0x50, 0xa2, 0x88, 0x74, 0x99, 0xe9, 0xe8, 0x22, 0x97, 0x8a, 0x7d, 0x6e, 0xb6, 0xf8, - 0x3c, 0x44, 0x91, 0x87, 0x45, 0x07, 0x66, 0xc4, 0xc1, 0x05, 0x87, 0x70, 0xf6, 0x3f, 0x01, 0x46, - 0x7c, 0xf7, 0xaa, 0x1d, 0x05, 0xfd, 0xd0, 0xa6, 0xa8, 0x5d, 0x37, 0xb8, 0x21, 0xeb, 0x0a, 0x73, - 0x87, 0x21, 0x9a, 0xa8, 0x6d, 0x7c, 0x1a, 0xa6, 0x5b, 0x2e, 0xe9, 0xda, 0x7b, 0x7d, 0xcf, 0xb3, - 0x83, 0x90, 0xd6, 0x67, 0xb9, 0x92, 0xe7, 0x62, 0x25, 0xdf, 0x74, 0x49, 0xf7, 0x76, 0xdf, 0xf3, - 0xb6, 0x43, 0x6a, 0x55, 0x5a, 0xc9, 0x07, 0x93, 0x39, 0x9b, 0xef, 0x30, 0x8d, 0x06, 0x76, 0x24, - 0x86, 0x78, 0x7d, 0x4e, 0xc8, 0xdc, 0x25, 0x16, 0x03, 0xab, 0x81, 0xff, 0x06, 0x54, 0x50, 0xe8, - 0xc6, 0x27, 0x3a, 0xf3, 0x43, 0xe6, 0x77, 0x7d, 0x67, 0x53, 0x6d, 0x79, 0x02, 0x0a, 0xdd, 0x24, - 0x93, 0xa8, 0x26, 0x36, 0x48, 0x69, 0xac, 0x87, 0x05, 0xae, 0x87, 0x6a, 0x0c, 0x16, 0x8a, 0xf8, - 0x2c, 0x88, 0xbb, 0x67, 0xb6, 0xf2, 0x2e, 0x8b, 0x7c, 0x64, 0xcc, 0xaf, 0xa9, 0x1b, 0x69, 0x4d, - 0xf6, 0x57, 0xb9, 0x98, 0x29, 0x9a, 0xfa, 0x12, 0xba, 0xe6, 0x5c, 0xda, 0x42, 0x30, 0xf5, 0x3a, - 0xf7, 0x02, 0xd3, 0x12, 0xda, 0xe0, 0x40, 0x26, 0x72, 0x7e, 0xf3, 0x44, 0x90, 0x2c, 0x09, 0xef, - 0x4f, 0x0f, 0x7d, 0x89, 0x5e, 0x85, 0x99, 0xdd, 0x3e, 0x19, 0xd8, 0xb4, 0x13, 0x61, 0xd2, 0x09, - 0xbc, 0x16, 0x33, 0x81, 0xf3, 0x3c, 0xf4, 0xa9, 0x31, 0x44, 0x53, 0xc1, 0x1f, 0x10, 0xe3, 0x03, - 0xa8, 0xc7, 0xea, 0x61, 0x0c, 0x47, 0x81, 0x17, 0x33, 0x7e, 0x81, 0x33, 0x7e, 0x29, 0x96, 0x8c, - 0x25, 0x09, 0x37, 0x04, 0x9d, 0xea, 0x42, 0x7c, 0xb7, 0x2e, 0x0b, 0x37, 0x2e, 0x41, 0x85, 0x85, - 0x26, 0x21, 0x93, 0x85, 0xdb, 0xaa, 0xaf, 0x88, 0x9b, 0x53, 0x0a, 0xb4, 0xd9, 0x62, 0x22, 0xdd, - 0xed, 0x3b, 0x5d, 0x4c, 0x49, 0xac, 0x8c, 0xcb, 0xbc, 0x2f, 0x55, 0x09, 0x56, 0xb2, 0x7f, 0x03, - 0x2a, 0x92, 0x45, 0x42, 0x7b, 0xb4, 0x6e, 0x4a, 0xd7, 0xa4, 0xf8, 0x12, 0xdd, 0x6e, 0xd0, 0x1e, - 0xb5, 0x80, 0xc4, 0xbf, 0x79, 0x02, 0x84, 0xd7, 0x67, 0x0b, 0x02, 0xd6, 0xfc, 0x8b, 0x32, 0x01, - 0x42, 0x40, 0x36, 0x5b, 0xef, 0x16, 0xca, 0x05, 0xbd, 0xf8, 0x6e, 0xa1, 0xbc, 0xac, 0x9f, 0x67, - 0x03, 0x0e, 0xb5, 0xec, 0x47, 0xfd, 0x20, 0xea, 0xf7, 0xcc, 0xdf, 0xd4, 0x60, 0x61, 0x7c, 0x57, - 0x8d, 0x35, 0x98, 0x1d, 0x32, 0x66, 0x1f, 0xf5, 0xb0, 0x0c, 0x12, 0x67, 0x32, 0xd6, 0xbc, 0x85, - 0x7a, 0xd8, 0xf8, 0x14, 0x94, 0x42, 0xec, 0x23, 0x8f, 0x0e, 0xa4, 0x3f, 0xbd, 0xb8, 0x36, 0x72, - 0x11, 0x71, 0x23, 0xf0, 0x49, 0xbf, 0x17, 0xf2, 0xb4, 0x15, 0x45, 0x6d, 0xbc, 0x02, 0x33, 0xc1, - 0x3e, 0x8e, 0x22, 0xb7, 0x85, 0xed, 0xd8, 0x51, 0x8a, 0xb3, 0x47, 0x5d, 0x21, 0x76, 0x24, 0xdc, - 0xfc, 0x6f, 0x1a, 0x40, 0x22, 0x83, 0xcc, 0x64, 0xa5, 0x65, 0x43, 0x95, 0x17, 0x61, 0xda, 0x09, - 0x7c, 0x1f, 0xf3, 0x9c, 0x37, 0x26, 0x15, 0x79, 0xe8, 0x99, 0x00, 0x37, 0x5b, 0x6c, 0xa4, 0x33, - 0x31, 0x33, 0xb4, 0xcc, 0x9a, 0x64, 0x9f, 0x9b, 0x2d, 0x7e, 0x64, 0x8a, 0x09, 0xd3, 0x88, 0x8d, - 0x3c, 0x57, 0xee, 0x4a, 0x4d, 0x5a, 0x53, 0x12, 0x78, 0x9d, 0xc1, 0xcc, 0xef, 0xe7, 0xa1, 0xac, - 0x82, 0x8c, 0x91, 0x3c, 0x5a, 0x6d, 0x34, 0x8f, 0xf6, 0x32, 0x4c, 0xf1, 0xc4, 0xbb, 0xec, 0xc9, - 0x47, 0x85, 0xc1, 0x94, 0xfa, 0x47, 0x27, 0xbf, 0x74, 0x62, 0x60, 0x21, 0x9b, 0x18, 0x98, 0xbe, - 0x95, 0x55, 0xcc, 0xde, 0xca, 0xba, 0x2a, 0x73, 0xfc, 0x78, 0x0e, 0xbf, 0x98, 0x75, 0x2a, 0xb1, - 0x11, 0x6d, 0x87, 0x22, 0xbb, 0xaf, 0x39, 0x08, 0xb1, 0xf1, 0x0a, 0x18, 0x9c, 0x32, 0x9b, 0x3e, - 0x5d, 0xe2, 0xd5, 0xd5, 0x18, 0x26, 0x75, 0xbb, 0x67, 0xec, 0x25, 0xad, 0xf2, 0xd8, 0x4b, 0x5a, - 0x23, 0xd7, 0x23, 0x26, 0x47, 0xaf, 0x47, 0x0c, 0x5d, 0xe4, 0x82, 0xd1, 0x8b, 0x5c, 0x9f, 0x85, - 0xe5, 0xd8, 0xb7, 0xd3, 0xc0, 0xf6, 0x10, 0xa1, 0x8a, 0xc9, 0x9e, 0xba, 0x71, 0xb1, 0xa0, 0x28, - 0x9a, 0xc1, 0x7d, 0x44, 0xa8, 0xe0, 0xf5, 0xc1, 0xf1, 0xc7, 0xcc, 0x7f, 0x55, 0x80, 0xb2, 0x0a, - 0x9e, 0x53, 0x51, 0xa4, 0x76, 0x4c, 0x14, 0x69, 0x5c, 0x60, 0xa1, 0x05, 0x8d, 0x06, 0x68, 0xd7, - 0xc3, 0x32, 0x72, 0x49, 0x00, 0x2c, 0xa6, 0x41, 0xbb, 0x41, 0x44, 0xe5, 0xde, 0xa6, 0xf8, 0x30, - 0xd6, 0xa1, 0xac, 0xae, 0x34, 0x8c, 0x9c, 0xfe, 0xbf, 0x1f, 0xb9, 0x14, 0xab, 0x3b, 0x0d, 0x56, - 0x4c, 0xc7, 0x9c, 0x2b, 0xf2, 0xd8, 0x60, 0x1d, 0xc8, 0x4c, 0xdb, 0xa2, 0x74, 0xae, 0xb1, 0xf7, - 0x16, 0x58, 0x9e, 0x6c, 0x6b, 0x4d, 0xa1, 0xd4, 0x97, 0xf1, 0x2a, 0x94, 0xd5, 0x25, 0xe1, 0x91, - 0x0c, 0xcf, 0x9b, 0x12, 0x61, 0xc5, 0x24, 0xc6, 0x4d, 0x98, 0x89, 0x15, 0x65, 0xe3, 0xc3, 0xd0, - 0x8d, 0x70, 0x4b, 0xe6, 0x78, 0xd6, 0x33, 0xb1, 0x0a, 0x53, 0xdb, 0x2d, 0x81, 0xb7, 0x6a, 0x4e, - 0x16, 0xc0, 0x26, 0x34, 0x26, 0xed, 0xe4, 0x5c, 0xa8, 0xcc, 0x6b, 0x98, 0x4b, 0xa7, 0x07, 0x6c, - 0xc9, 0x33, 0x22, 0xab, 0x42, 0x93, 0x0f, 0xe3, 0x2e, 0xcc, 0x26, 0xed, 0xd3, 0x80, 0x29, 0x3a, - 0x6a, 0x8b, 0x8b, 0x39, 0x95, 0xf5, 0xa5, 0x11, 0x0e, 0x9a, 0x41, 0x70, 0x9f, 0x11, 0x58, 0xba, - 0x33, 0x04, 0x31, 0x36, 0x40, 0x4f, 0xee, 0xed, 0xed, 0x21, 0xd7, 0xc3, 0x2d, 0x1e, 0xb8, 0xa4, - 0x3b, 0x12, 0x5f, 0xdc, 0xbb, 0xcd, 0xf1, 0x56, 0x72, 0xd3, 0x4f, 0x00, 0x58, 0x25, 0x6a, 0x28, - 0xf7, 0x5c, 0xd2, 0x43, 0xd4, 0xe9, 0x70, 0x5b, 0x4b, 0x57, 0x22, 0xd3, 0x89, 0x1f, 0x48, 0xbc, - 0x55, 0x0b, 0xb3, 0x00, 0xf3, 0xcf, 0x73, 0x30, 0x9d, 0x51, 0xed, 0x51, 0xce, 0xea, 0x12, 0x54, - 0xd2, 0x57, 0x5e, 0x64, 0xae, 0x8c, 0x93, 0x5c, 0x74, 0x19, 0xf5, 0x0b, 0x75, 0x28, 0xa9, 0x4c, - 0x67, 0x71, 0x14, 0xaa, 0x3e, 0x59, 0x18, 0x12, 0x57, 0x96, 0x8c, 0x3f, 0xe1, 0x20, 0x74, 0x85, - 0x89, 0x07, 0xe1, 0x9b, 0x30, 0x11, 0x61, 0x44, 0x02, 0x5f, 0xba, 0x89, 0x8b, 0xe3, 0x0d, 0x73, - 0xcd, 0xe2, 0x44, 0x96, 0x24, 0x36, 0x0f, 0x60, 0x42, 0x40, 0x8c, 0x0a, 0x94, 0xde, 0xf3, 0xbb, - 0x7e, 0x70, 0xe0, 0xeb, 0xe7, 0x8c, 0x2a, 0xc0, 0x76, 0x48, 0x65, 0x6e, 0xb6, 0xae, 0x19, 0x73, - 0xa0, 0xa7, 0xaf, 0x57, 0xb0, 0x61, 0xa2, 0xe7, 0x0c, 0x03, 0xaa, 0x0d, 0xec, 0xed, 0x59, 0x81, - 0xe7, 0xe1, 0xd6, 0x0d, 0xe4, 0x74, 0xf5, 0xbc, 0x31, 0x0d, 0x93, 0x96, 0x23, 0x12, 0xaf, 0x89, - 0x5e, 0x30, 0x16, 0x61, 0xf6, 0x3e, 0xfa, 0xca, 0xe0, 0x3d, 0xdf, 0x7d, 0xd4, 0xc7, 0x3e, 0x26, - 0x84, 0xa3, 0xf4, 0xa2, 0xb9, 0x02, 0x53, 0x69, 0xc3, 0x57, 0x92, 0xd1, 0x92, 0x15, 0xd9, 0xff, - 0xd5, 0xa0, 0xac, 0x8c, 0x3c, 0x9d, 0x17, 0xaf, 0x65, 0xf2, 0xe2, 0x95, 0x5f, 0x4d, 0x96, 0x73, - 0x9c, 0xf0, 0x1e, 0x1e, 0xb0, 0xa0, 0x42, 0x0d, 0x0d, 0x86, 0xb6, 0x3b, 0x88, 0x74, 0xe4, 0xfc, - 0x50, 0x53, 0x88, 0x7b, 0x78, 0x70, 0x17, 0x91, 0x8e, 0xf1, 0x26, 0x00, 0xbf, 0x68, 0xe6, 0x74, - 0x90, 0xeb, 0xcb, 0x55, 0xfc, 0xc2, 0x5a, 0x7c, 0x43, 0xff, 0x7d, 0xe4, 0xd2, 0xdb, 0x41, 0x74, - 0xcb, 0x67, 0x41, 0xd9, 0x24, 0xa3, 0xdc, 0x60, 0x84, 0xe6, 0x37, 0x34, 0xa8, 0x0d, 0x0d, 0xa8, - 0xa3, 0xec, 0x63, 0x0d, 0x66, 0x11, 0xa5, 0xb8, 0x17, 0xb2, 0x88, 0x2c, 0xd1, 0xa9, 0xb0, 0x93, - 0x99, 0x18, 0x15, 0x2b, 0x75, 0xd4, 0x5c, 0x46, 0xfc, 0x71, 0x61, 0xc4, 0x1f, 0x9b, 0x9b, 0x50, - 0x49, 0x0d, 0xd1, 0x63, 0xec, 0xf5, 0xc8, 0xeb, 0x08, 0xe6, 0x35, 0xd0, 0x87, 0x47, 0x6b, 0xf6, - 0x20, 0x5e, 0x1b, 0x3a, 0x88, 0xff, 0x63, 0x0d, 0x6a, 0x43, 0x03, 0xf3, 0x28, 0x06, 0x46, 0x8f, - 0xcc, 0x3e, 0x09, 0x93, 0xf1, 0x38, 0xe6, 0x1d, 0xaf, 0xae, 0x1b, 0xa3, 0x43, 0xde, 0x4a, 0x88, - 0x98, 0x9a, 0xb9, 0x63, 0x75, 0xfd, 0xf6, 0xf0, 0xdd, 0x88, 0x9a, 0x42, 0xa8, 0xdb, 0x11, 0x9f, - 0x00, 0x23, 0xa6, 0x1d, 0x19, 0x53, 0x0a, 0x13, 0x0b, 0xf2, 0x3a, 0xd4, 0x86, 0xfc, 0x43, 0x36, - 0xe9, 0x5e, 0x3b, 0x36, 0xe9, 0xde, 0xfc, 0x13, 0x0d, 0x80, 0x2d, 0xb2, 0x44, 0x8a, 0x91, 0xf1, - 0x71, 0x98, 0xe1, 0x66, 0x76, 0x80, 0x3c, 0x4f, 0xac, 0xc9, 0x7a, 0x4a, 0x26, 0x55, 0x86, 0x78, - 0x1f, 0x79, 0x1e, 0x23, 0x7f, 0x40, 0x8c, 0x6b, 0x30, 0x17, 0x46, 0x81, 0x83, 0x09, 0xc9, 0x52, - 0x4b, 0x63, 0x91, 0xb8, 0x54, 0x81, 0x35, 0x98, 0xeb, 0xee, 0xf3, 0x25, 0x4d, 0xb6, 0x80, 0x8c, - 0xc1, 0xba, 0xfb, 0x6c, 0x71, 0x93, 0xa2, 0x5f, 0x87, 0x05, 0x1a, 0x50, 0xe4, 0xd9, 0x51, 0xe8, - 0xa4, 0x4a, 0xf8, 0x4a, 0x78, 0x06, 0xc7, 0x5a, 0xa1, 0xa3, 0xca, 0x6c, 0x11, 0xf3, 0xef, 0x72, - 0x30, 0x95, 0x74, 0xe7, 0xe1, 0xfa, 0x98, 0x0e, 0xf9, 0x63, 0x3b, 0xb4, 0xf5, 0x98, 0x0e, 0xf9, - 0x8f, 0xeb, 0xd0, 0x16, 0x31, 0xde, 0x86, 0x0b, 0xaa, 0x00, 0xe9, 0x93, 0x10, 0xfb, 0xad, 0x6c, - 0x41, 0xd1, 0xb1, 0xba, 0xa4, 0x69, 0x08, 0x92, 0x54, 0xf9, 0xb1, 0x02, 0x89, 0xbb, 0x37, 0x24, - 0x90, 0xad, 0xa3, 0x04, 0x52, 0x7c, 0x9c, 0x40, 0x8c, 0x37, 0x60, 0xb1, 0xbb, 0x6f, 0xb7, 0x59, - 0x09, 0xc5, 0xab, 0x2a, 0x24, 0x72, 0x54, 0x66, 0xbb, 0xfb, 0x77, 0xa2, 0xd0, 0xd9, 0x11, 0xc8, - 0x0c, 0x67, 0x6d, 0xd1, 0x8e, 0xbc, 0xde, 0x6a, 0xfb, 0x2a, 0x5c, 0xd3, 0x45, 0x91, 0xf7, 0xe5, - 0x25, 0xd7, 0x2d, 0x62, 0x7e, 0x11, 0xca, 0x6c, 0xfd, 0xcd, 0x03, 0xd4, 0x39, 0x28, 0x72, 0x3e, - 0xb8, 0x94, 0xf3, 0x96, 0xf8, 0x60, 0xd1, 0x8c, 0x6c, 0x1f, 0x8b, 0x10, 0x39, 0x6f, 0x25, 0x80, - 0x78, 0xef, 0x6d, 0x77, 0x40, 0xb1, 0x90, 0x5b, 0x5e, 0xec, 0xbd, 0xdd, 0x60, 0x00, 0xf3, 0x3f, - 0xb1, 0x68, 0xdc, 0x41, 0xbe, 0x34, 0xd2, 0x97, 0xa1, 0xc8, 0xef, 0x64, 0x8f, 0xd8, 0xb7, 0xe2, - 0xc1, 0x12, 0x78, 0xe3, 0x0a, 0x14, 0xe2, 0xbb, 0x66, 0x63, 0xe9, 0x38, 0x9a, 0x91, 0xb5, 0x10, - 0x45, 0x23, 0x1b, 0x5f, 0x09, 0x19, 0x43, 0x9b, 0xff, 0x50, 0x14, 0xaf, 0x52, 0xc4, 0xb6, 0xf5, - 0x2a, 0x18, 0x71, 0x17, 0x54, 0xb0, 0xad, 0x8c, 0x6b, 0x26, 0xc6, 0xc8, 0x90, 0x9b, 0x18, 0x6f, - 0xc1, 0xe2, 0x28, 0x79, 0xfa, 0xad, 0x83, 0xf9, 0x91, 0x32, 0x3c, 0xc6, 0xbe, 0x02, 0x55, 0xa1, - 0xf6, 0xb8, 0x09, 0x99, 0x6d, 0xcf, 0xa1, 0x71, 0xf5, 0x5f, 0x80, 0x0b, 0x11, 0x5b, 0x2d, 0xb7, - 0x76, 0xed, 0x16, 0x3f, 0x9e, 0xb4, 0x49, 0xd7, 0x0d, 0x43, 0xee, 0xc8, 0xfb, 0x3e, 0x95, 0xd6, - 0xb8, 0x24, 0x69, 0xc4, 0x09, 0x66, 0x43, 0x50, 0x6c, 0x30, 0x02, 0xe3, 0x33, 0xa0, 0x90, 0x7c, - 0x36, 0xca, 0x96, 0x16, 0x36, 0xb9, 0x20, 0x09, 0xee, 0xe1, 0x41, 0xa6, 0xe8, 0x3b, 0x70, 0x51, - 0x15, 0xdd, 0xe5, 0xee, 0x87, 0xef, 0x06, 0xd9, 0x1d, 0x36, 0x61, 0xf1, 0xe2, 0xc5, 0x4c, 0xe3, - 0x37, 0x18, 0x0d, 0xdf, 0x1c, 0xba, 0xeb, 0x52, 0x51, 0xc3, 0xa7, 0xa0, 0x9e, 0xad, 0x81, 0xdb, - 0x83, 0x28, 0x2c, 0x0c, 0x75, 0x3e, 0x5d, 0x98, 0x8d, 0x0c, 0x51, 0xf0, 0x4d, 0x58, 0x1c, 0x53, - 0x90, 0x19, 0x92, 0xb4, 0xd6, 0xb9, 0xe1, 0x72, 0xcc, 0xa6, 0x1e, 0xd3, 0x9e, 0x8f, 0xfc, 0x40, - 0x2d, 0x21, 0x46, 0xda, 0xdb, 0x62, 0x48, 0xe6, 0xa1, 0xdb, 0x98, 0xda, 0xc4, 0x47, 0x21, 0xe9, - 0x04, 0x54, 0x16, 0x11, 0x0f, 0x4d, 0xe8, 0x6d, 0x4c, 0x1b, 0x12, 0x21, 0xa8, 0x99, 0x60, 0xe2, - 0x4d, 0x65, 0x36, 0x02, 0xc3, 0x80, 0x60, 0x31, 0xa6, 0x44, 0xc1, 0x8a, 0x14, 0x8c, 0xda, 0x67, - 0xde, 0x11, 0x24, 0x6c, 0x6c, 0x8d, 0xab, 0x81, 0x85, 0x55, 0x6e, 0xd4, 0x4b, 0xd7, 0x30, 0x35, - 0x54, 0xc3, 0x86, 0x20, 0x19, 0xad, 0x21, 0x0c, 0x02, 0xcf, 0x26, 0x4e, 0x07, 0xb7, 0xfa, 0x5e, - 0x86, 0x87, 0xe9, 0xa4, 0x86, 0x9d, 0x20, 0xf0, 0x1a, 0x92, 0x24, 0xae, 0xc1, 0xfc, 0x2f, 0x1a, - 0x54, 0x52, 0x69, 0xa9, 0xc6, 0x1b, 0x50, 0xe1, 0x1e, 0x41, 0x64, 0xb1, 0xca, 0x61, 0x98, 0x6c, - 0x1e, 0x24, 0x0e, 0xd8, 0x02, 0x9a, 0xcc, 0x2d, 0x6f, 0x40, 0x85, 0xef, 0xdd, 0xc9, 0x52, 0xb9, - 0xe1, 0x2d, 0x87, 0x78, 0x68, 0x59, 0x40, 0xe2, 0xdf, 0x22, 0xf1, 0x5e, 0xec, 0x2c, 0x98, 0xff, - 0xa8, 0xc1, 0x74, 0x26, 0x3d, 0xf6, 0x94, 0x9c, 0x7c, 0x0e, 0xaa, 0x29, 0x4e, 0xec, 0xfd, 0x75, - 0xc9, 0xcc, 0xfc, 0x18, 0x66, 0x1e, 0xae, 0x5b, 0x53, 0x24, 0x3d, 0xea, 0x3f, 0x05, 0x53, 0xdc, - 0xbb, 0xa8, 0x36, 0xf3, 0x43, 0xab, 0x0f, 0x1e, 0xce, 0xca, 0x46, 0x2b, 0x07, 0xc9, 0x07, 0x6b, - 0x35, 0xc5, 0x6b, 0x92, 0xa0, 0x3d, 0x3f, 0x86, 0x5d, 0xd6, 0x2a, 0x4d, 0x7d, 0x99, 0x5f, 0x2d, - 0x41, 0x25, 0x55, 0xb3, 0xf1, 0x3a, 0x2c, 0x10, 0x1a, 0x44, 0xd8, 0xde, 0x65, 0xd3, 0x7e, 0x5a, - 0x9b, 0xc2, 0xff, 0xcc, 0x72, 0x2c, 0x3f, 0x71, 0x4f, 0x2c, 0xe1, 0x4d, 0xee, 0x81, 0xb8, 0x09, - 0x12, 0x31, 0x5b, 0xc5, 0xa5, 0x84, 0x4b, 0x99, 0x93, 0xe8, 0x06, 0x9f, 0xa8, 0x54, 0xb1, 0x55, - 0x98, 0x09, 0x99, 0x97, 0xe1, 0xef, 0x20, 0xb4, 0x65, 0x01, 0x19, 0xa7, 0x4a, 0xc4, 0xfd, 0xa0, - 0x2d, 0x68, 0x37, 0xe0, 0x52, 0x84, 0xf6, 0xa8, 0xdd, 0xda, 0xb5, 0x85, 0x94, 0x3c, 0x8c, 0x5a, - 0x38, 0x4a, 0x37, 0x25, 0x5c, 0xc9, 0x32, 0x23, 0xbb, 0xb9, 0xcb, 0xfb, 0x74, 0x9f, 0xd3, 0x24, - 0x0d, 0xae, 0xc3, 0x82, 0xaa, 0x44, 0xed, 0x1c, 0xcb, 0xb2, 0x72, 0xa2, 0x13, 0x65, 0x1b, 0x62, - 0x17, 0x59, 0x94, 0x79, 0x1b, 0x2e, 0x64, 0x1b, 0xee, 0xe1, 0x1e, 0x65, 0x4b, 0x65, 0x59, 0x52, - 0x38, 0x91, 0x7a, 0xaa, 0xd5, 0x07, 0x92, 0x40, 0x94, 0xbf, 0x0a, 0x72, 0x95, 0x97, 0x6a, 0x4d, - 0x38, 0x10, 0xb9, 0x1b, 0x19, 0xb7, 0xf4, 0x3a, 0x2c, 0xa0, 0x30, 0xf4, 0x06, 0xa3, 0xa2, 0x17, - 0x6e, 0x7c, 0x96, 0x63, 0x87, 0x44, 0xff, 0x12, 0xd4, 0x44, 0xa1, 0xa4, 0xf6, 0x49, 0x79, 0x6d, - 0x99, 0x81, 0x47, 0x2b, 0xef, 0xf5, 0x29, 0x3e, 0x14, 0x77, 0x9c, 0xd3, 0x2e, 0x46, 0x54, 0xfe, - 0x80, 0x21, 0x59, 0x34, 0x17, 0x8f, 0x70, 0x51, 0xe8, 0x71, 0x22, 0x97, 0x5e, 0x86, 0x13, 0x8d, - 0x95, 0xf8, 0x6b, 0x30, 0x9f, 0xae, 0xe1, 0x00, 0x79, 0x19, 0xef, 0x62, 0x24, 0x25, 0xdf, 0x47, - 0x9e, 0x28, 0xf2, 0x39, 0x58, 0x4e, 0x17, 0x19, 0x12, 0xb7, 0xf0, 0x29, 0x8b, 0x49, 0xb9, 0x11, - 0x69, 0x7b, 0xc3, 0xd2, 0x13, 0x3b, 0xea, 0x55, 0x2f, 0x2b, 0xb8, 0x17, 0x61, 0x5a, 0x05, 0x2e, - 0x82, 0x4c, 0xee, 0xa4, 0x4b, 0xa0, 0x20, 0x62, 0x53, 0x64, 0x27, 0x0a, 0x28, 0x8d, 0xdb, 0xd7, - 0xe5, 0x14, 0x29, 0xa1, 0x82, 0xec, 0xdf, 0xc0, 0xf9, 0xe1, 0x3b, 0xbf, 0x69, 0x06, 0x66, 0x64, - 0xbc, 0x36, 0xfc, 0xaa, 0x85, 0x72, 0x83, 0x1f, 0xc0, 0x84, 0x48, 0x33, 0x49, 0xb2, 0xdd, 0xb5, - 0x63, 0xf2, 0xfd, 0x4f, 0x98, 0x8d, 0x69, 0x7e, 0x55, 0x83, 0xb2, 0xba, 0x69, 0x67, 0x9c, 0x87, - 0x5c, 0x10, 0xca, 0x17, 0x31, 0x32, 0xbb, 0x69, 0xb9, 0x20, 0x3c, 0x71, 0x7e, 0x67, 0x66, 0x9d, - 0x52, 0x38, 0xc1, 0x3a, 0xc5, 0xfc, 0x49, 0x0e, 0x26, 0x1f, 0xec, 0x3b, 0x0e, 0x57, 0x97, 0x71, - 0x29, 0xf3, 0x30, 0x47, 0x86, 0x0d, 0xf1, 0xfc, 0xc6, 0x11, 0xc7, 0xb7, 0xe7, 0x47, 0x1e, 0xa1, - 0x48, 0x5d, 0x30, 0xbd, 0x04, 0x15, 0xd2, 0x09, 0x22, 0x6a, 0xa7, 0x9e, 0xa1, 0xb0, 0x80, 0x83, - 0xf8, 0x93, 0x27, 0x2c, 0x4e, 0xea, 0x20, 0x62, 0x07, 0xfb, 0x38, 0xf2, 0x10, 0x0f, 0x41, 0xd4, - 0xa5, 0x6f, 0x99, 0x83, 0x39, 0xdf, 0x41, 0x64, 0x3b, 0xc6, 0xaa, 0xcb, 0x4e, 0xc6, 0x0a, 0x4c, - 0xb1, 0x72, 0x6d, 0xc7, 0xde, 0xe3, 0x8f, 0x7f, 0x88, 0x1c, 0x24, 0xe8, 0x20, 0x72, 0xc7, 0xb9, - 0xcd, 0x5f, 0xff, 0x58, 0x82, 0x72, 0x8c, 0x15, 0x63, 0xbb, 0xd4, 0x96, 0xa8, 0x8f, 0x41, 0x95, - 0xef, 0xfa, 0x39, 0x1d, 0xe4, 0xb7, 0xf9, 0xd6, 0xa4, 0x18, 0xcc, 0x53, 0x0c, 0xba, 0xc1, 0x81, - 0x7c, 0x13, 0x63, 0x31, 0x0e, 0xdc, 0xd4, 0x3e, 0xa1, 0x28, 0x21, 0x47, 0xf3, 0x9c, 0x42, 0x8b, - 0x4d, 0x42, 0x51, 0xd0, 0xfc, 0xbc, 0x10, 0xac, 0xe8, 0xde, 0x11, 0xab, 0xcd, 0xb1, 0x2f, 0x9a, - 0x98, 0xdf, 0xc9, 0x43, 0x99, 0x15, 0xe7, 0x7b, 0xbb, 0x4f, 0xa3, 0x96, 0xd4, 0x56, 0x4e, 0x3e, - 0xbb, 0x95, 0x73, 0xac, 0x4e, 0x46, 0xb3, 0x83, 0x4f, 0xf2, 0x82, 0x4e, 0x7a, 0xe3, 0xb8, 0x34, - 0xbc, 0x71, 0x7c, 0xd2, 0x1d, 0xde, 0xa1, 0xdd, 0xdb, 0xc9, 0xd1, 0xdd, 0xdb, 0x4b, 0x50, 0x89, - 0xdf, 0x0c, 0xa0, 0x62, 0x7f, 0xb7, 0x60, 0x81, 0x02, 0x35, 0xc9, 0x18, 0xe5, 0x56, 0x9e, 0x4c, - 0xb9, 0x53, 0x47, 0x28, 0xf7, 0x6b, 0x9a, 0x50, 0x0f, 0x5f, 0xfc, 0xa8, 0x15, 0x87, 0x36, 0xe6, - 0x08, 0x99, 0x67, 0xc3, 0x88, 0x15, 0xc7, 0x2a, 0x4c, 0x70, 0xaf, 0xa9, 0xd2, 0x5e, 0x8c, 0x0c, - 0x21, 0x1f, 0x80, 0x96, 0xa4, 0x60, 0xb4, 0xf2, 0x59, 0x96, 0xfc, 0x18, 0x5a, 0xae, 0x1e, 0xf5, - 0x54, 0x8b, 0xd9, 0x80, 0x92, 0xbc, 0x1b, 0xc5, 0x35, 0x76, 0xe8, 0x4b, 0x0b, 0x63, 0x3f, 0x8d, - 0x05, 0x98, 0x20, 0xfc, 0xa1, 0x01, 0x69, 0x17, 0xf2, 0xeb, 0xd8, 0x0d, 0xec, 0x77, 0xf8, 0xfe, - 0x35, 0xcf, 0xba, 0xc8, 0xe6, 0x04, 0x69, 0x8f, 0xcf, 0x88, 0xcb, 0x65, 0x32, 0xe2, 0xfe, 0x50, - 0x03, 0x10, 0x33, 0x0e, 0x67, 0xed, 0xc8, 0x43, 0xf3, 0x45, 0x28, 0x85, 0x58, 0x9c, 0x2f, 0x49, - 0x36, 0xd9, 0xe7, 0x66, 0x2b, 0x3e, 0xf3, 0xce, 0xa7, 0xce, 0xbc, 0x87, 0x4f, 0xd8, 0x0b, 0x27, - 0x3c, 0x61, 0x7f, 0x4d, 0xae, 0x37, 0x99, 0x04, 0xb0, 0xdc, 0xf0, 0x36, 0x52, 0x87, 0x72, 0xa8, - 0xd5, 0x60, 0x18, 0xb1, 0x06, 0xe5, 0x3f, 0xcd, 0x4d, 0x98, 0x8c, 0xe1, 0xa3, 0xc7, 0xbb, 0xda, - 0xf8, 0xe3, 0x5d, 0x7e, 0xe5, 0x8a, 0x26, 0x02, 0x47, 0x7b, 0xb8, 0xc9, 0xb4, 0x64, 0x88, 0x14, - 0x36, 0x2e, 0x12, 0x75, 0x86, 0xfa, 0x6a, 0x92, 0xa4, 0x23, 0xee, 0x60, 0x27, 0x61, 0x6c, 0x22, - 0xbb, 0x24, 0x53, 0xa7, 0x0a, 0xb9, 0xb8, 0xe2, 0x1c, 0x25, 0xe6, 0x17, 0x60, 0x36, 0x53, 0xa9, - 0x4c, 0x97, 0xa8, 0x67, 0x6b, 0x2d, 0x3c, 0xbe, 0x82, 0x9b, 0x60, 0x34, 0x58, 0xcc, 0xd8, 0x60, - 0x4c, 0x36, 0x14, 0x57, 0x6b, 0x30, 0xc9, 0x16, 0x83, 0x3c, 0xd9, 0x66, 0xdc, 0x6c, 0x27, 0x92, - 0x71, 0xca, 0x5d, 0xf9, 0xcb, 0x5c, 0x83, 0xd9, 0x4c, 0x2d, 0x92, 0x8d, 0x94, 0x2c, 0xb4, 0x8c, - 0x2c, 0x1c, 0x9e, 0xeb, 0x7a, 0x07, 0x33, 0x03, 0x6a, 0x36, 0xef, 0x3f, 0x9b, 0x7b, 0x2b, 0xff, - 0x43, 0xe3, 0xf9, 0xa7, 0xa9, 0x56, 0x9e, 0x41, 0x32, 0x49, 0xf2, 0xa2, 0x06, 0xf7, 0x8f, 0x47, - 0xde, 0x5c, 0xf9, 0xa9, 0xb8, 0xe2, 0xb1, 0x71, 0xbd, 0xf1, 0x2c, 0xaf, 0x78, 0x7c, 0x02, 0x8c, - 0x30, 0xc2, 0xfb, 0x6e, 0xd0, 0x27, 0xa9, 0x87, 0x54, 0x04, 0x2f, 0xba, 0xc2, 0xc4, 0xcf, 0xa8, - 0x5c, 0x81, 0x6a, 0x4c, 0x2d, 0x2a, 0x13, 0x57, 0x5f, 0xa7, 0x15, 0xf4, 0x61, 0xea, 0xde, 0xc8, - 0xc4, 0xf0, 0xbd, 0x91, 0x52, 0xdc, 0x73, 0xf3, 0x43, 0x91, 0xe7, 0xce, 0x3b, 0x77, 0xd6, 0x72, - 0xae, 0x43, 0x89, 0xf4, 0x1d, 0x07, 0xcb, 0x34, 0xac, 0xb2, 0xa5, 0x3e, 0x9f, 0x49, 0x67, 0xcd, - 0x9b, 0xb0, 0x70, 0x07, 0x53, 0x15, 0x05, 0xf2, 0x01, 0xf8, 0xe4, 0xfa, 0x32, 0xbf, 0xa9, 0xc1, - 0xe2, 0x48, 0x35, 0x67, 0x2d, 0x99, 0x4f, 0x32, 0xe7, 0x4b, 0xf9, 0x14, 0x99, 0x3f, 0xf2, 0x74, - 0x40, 0x91, 0x99, 0x77, 0x60, 0x29, 0xc5, 0xd5, 0x5d, 0x97, 0xad, 0x18, 0x4f, 0x93, 0xac, 0x66, - 0x7e, 0x4b, 0x83, 0xe5, 0x71, 0x35, 0xfd, 0xf2, 0xbb, 0xf8, 0x03, 0x71, 0x73, 0x60, 0x23, 0x90, - 0xab, 0x85, 0x20, 0x3a, 0x65, 0x1a, 0xb8, 0x13, 0x84, 0x91, 0x48, 0x4c, 0x10, 0x1c, 0x95, 0x19, - 0x80, 0xe7, 0x23, 0xf0, 0x75, 0x63, 0x18, 0xa9, 0xcd, 0x39, 0x3b, 0xc2, 0x8f, 0xa4, 0xe7, 0xa9, - 0x32, 0x78, 0x72, 0x77, 0x31, 0x95, 0xd4, 0x58, 0x38, 0x2e, 0x27, 0xdf, 0x90, 0x3b, 0x92, 0xc2, - 0x28, 0xc5, 0xf6, 0x63, 0x9f, 0xdf, 0x3c, 0xc8, 0x74, 0xe5, 0xac, 0x05, 0x6c, 0xa4, 0x36, 0x42, - 0x55, 0xb3, 0xdf, 0x15, 0x37, 0xb2, 0xf8, 0xdc, 0x42, 0xfa, 0xbd, 0xd3, 0xc8, 0xef, 0xd3, 0x30, - 0x89, 0xbc, 0x76, 0x10, 0xb9, 0xb4, 0xd3, 0xe3, 0x0d, 0x56, 0xd7, 0x97, 0x13, 0x6a, 0x59, 0xf1, - 0x75, 0x45, 0x61, 0x25, 0xc4, 0x4f, 0x92, 0x07, 0xfa, 0xbb, 0xe2, 0xd6, 0x44, 0xc2, 0xe7, 0x59, - 0x0b, 0x67, 0x19, 0xca, 0x8e, 0xac, 0x3c, 0x5e, 0xd3, 0xc8, 0x6f, 0x66, 0x21, 0x62, 0x8b, 0xb6, - 0xbb, 0x1f, 0xbf, 0xa8, 0xc3, 0x01, 0xf7, 0xf6, 0x79, 0x78, 0x2a, 0x90, 0x62, 0x77, 0x5b, 0xc4, - 0xd0, 0xc0, 0x41, 0x62, 0x7b, 0xfb, 0xff, 0xe7, 0x61, 0x6a, 0x23, 0xe8, 0x85, 0xc8, 0xa1, 0x82, - 0x81, 0x0f, 0x60, 0x1e, 0x47, 0x91, 0xed, 0xfa, 0xfb, 0xc8, 0x73, 0x5b, 0x76, 0x36, 0xe2, 0xaa, - 0xac, 0x7f, 0x2c, 0x7d, 0x52, 0x1d, 0x97, 0xda, 0x14, 0xd4, 0x0d, 0x19, 0x8d, 0xdd, 0x3d, 0x67, - 0x19, 0x38, 0x1a, 0x86, 0x1a, 0x1e, 0x5c, 0x60, 0x55, 0x87, 0x32, 0x4b, 0xdb, 0x96, 0x6b, 0xf6, - 0xd8, 0x61, 0x8a, 0x8d, 0xb0, 0xd5, 0xb1, 0x2d, 0xa8, 0xd4, 0xee, 0x26, 0x5f, 0xc7, 0x4b, 0x57, - 0x7a, 0xf7, 0x9c, 0x55, 0xc7, 0xd1, 0x78, 0x9c, 0x61, 0xc3, 0x22, 0x6b, 0xcd, 0x11, 0x95, 0xd8, - 0xae, 0x6f, 0x87, 0x51, 0xd0, 0x8e, 0x30, 0x21, 0x72, 0xdb, 0xec, 0xa5, 0xb1, 0x0d, 0xc9, 0xdf, - 0x9b, 0xfe, 0x8e, 0xa4, 0xbe, 0x7b, 0xce, 0x9a, 0xc3, 0xd1, 0x28, 0xdc, 0xd8, 0x83, 0x65, 0xd6, - 0x00, 0x0d, 0x02, 0xbb, 0x87, 0xfc, 0x81, 0x1d, 0x62, 0xbf, 0xe5, 0xfa, 0x6d, 0x9b, 0x22, 0xd2, - 0x25, 0x32, 0x1c, 0xbc, 0x3a, 0xb6, 0x8d, 0x66, 0x10, 0x3c, 0x40, 0xfe, 0x60, 0x47, 0x14, 0x68, - 0x32, 0xfa, 0xbb, 0xe7, 0xac, 0x05, 0x1c, 0x8d, 0xc3, 0xdc, 0x28, 0x49, 0x93, 0x30, 0x2f, 0xc2, - 0xf9, 0x23, 0x84, 0x6e, 0xbe, 0x08, 0x97, 0x8f, 0x95, 0x98, 0x79, 0x09, 0x2e, 0x1e, 0xd9, 0x5b, - 0xf3, 0x32, 0x5c, 0x3a, 0x86, 0x55, 0x16, 0x41, 0x54, 0x25, 0x8d, 0x1a, 0x92, 0x47, 0xc6, 0xe6, - 0xab, 0x30, 0x33, 0xa4, 0x73, 0x57, 0x9d, 0xc3, 0xd4, 0xc2, 0x34, 0x97, 0x9b, 0x2d, 0xbe, 0x39, - 0x13, 0xb4, 0xb3, 0xa4, 0xe2, 0x4c, 0xa6, 0x2a, 0xe1, 0x8a, 0x72, 0x28, 0xef, 0xaf, 0x74, 0xb2, - 0xbc, 0xbf, 0xa1, 0x2c, 0xb6, 0xf2, 0x70, 0x16, 0x9b, 0xf9, 0x07, 0xe2, 0xd4, 0x5a, 0x74, 0x4e, - 0x8e, 0xe3, 0x57, 0xb2, 0x5b, 0x2e, 0xf3, 0x63, 0x95, 0xaa, 0xc6, 0xea, 0x8b, 0x30, 0xdd, 0x41, - 0xc4, 0x8e, 0x70, 0x0f, 0xb9, 0xbe, 0xeb, 0xb7, 0xe5, 0xb5, 0x8f, 0xa9, 0x0e, 0x22, 0x96, 0x82, - 0x19, 0x6b, 0x3c, 0x1b, 0x84, 0x95, 0xc5, 0xe9, 0x31, 0x26, 0x9c, 0xdf, 0x4c, 0x8c, 0x6a, 0xa4, - 0x44, 0x98, 0xd0, 0x67, 0xaf, 0x87, 0xd7, 0x62, 0xc4, 0x2d, 0xb1, 0xe2, 0x79, 0x15, 0x96, 0x9a, - 0x2e, 0xbf, 0xf1, 0xdd, 0x18, 0x10, 0x8a, 0x7b, 0x5c, 0x60, 0x4a, 0x51, 0x3a, 0xe4, 0xc9, 0x23, - 0x4f, 0xa6, 0xb8, 0xb1, 0x9f, 0x66, 0x08, 0xcb, 0xe3, 0xc8, 0x65, 0xd7, 0x2d, 0xe9, 0x96, 0xb9, - 0x4e, 0x6f, 0xbc, 0xfd, 0xe1, 0xcf, 0x2e, 0x9d, 0xfb, 0xe9, 0xcf, 0x2e, 0xbd, 0xd5, 0x76, 0x69, - 0xa7, 0xbf, 0xbb, 0xe6, 0x04, 0xbd, 0x6b, 0xa1, 0xeb, 0xb7, 0x1d, 0x14, 0x5e, 0xeb, 0xee, 0x8b, - 0x67, 0xfd, 0xc3, 0x6e, 0xfb, 0x1a, 0xe9, 0xa0, 0x08, 0xb7, 0xb8, 0xcf, 0x59, 0x6b, 0xf0, 0xdf, - 0xdc, 0xdb, 0x48, 0xb7, 0xfe, 0x61, 0x0e, 0xa6, 0x6e, 0x7b, 0x7d, 0xd2, 0x79, 0x2e, 0x2f, 0xfa, - 0x0e, 0x9d, 0xe3, 0xe7, 0x47, 0x9e, 0x15, 0x3c, 0xe2, 0x51, 0x82, 0x91, 0x8c, 0x82, 0xe2, 0x68, - 0x86, 0xd7, 0x0b, 0x00, 0x6d, 0xec, 0x63, 0x91, 0x9f, 0x25, 0x77, 0x22, 0x52, 0x90, 0x4c, 0x72, - 0x5b, 0x29, 0x9b, 0xdc, 0x36, 0xe6, 0x05, 0xee, 0xf2, 0x13, 0xbd, 0xc0, 0x6d, 0x7e, 0x4f, 0x83, - 0x69, 0x29, 0xca, 0x5f, 0x8b, 0xd7, 0x3c, 0x1f, 0xc1, 0xfc, 0x8d, 0xfe, 0xde, 0x1e, 0x8e, 0x9e, - 0xeb, 0xab, 0x50, 0x0b, 0xc3, 0x6d, 0x3e, 0x97, 0x07, 0xb2, 0xe4, 0x55, 0xf0, 0xfc, 0xb3, 0x7c, - 0x44, 0xca, 0xbc, 0x0d, 0xf5, 0x3b, 0x98, 0xde, 0xc5, 0xc8, 0xa3, 0x9d, 0xdb, 0x18, 0xb7, 0x4e, - 0xf9, 0x30, 0x94, 0xf9, 0x75, 0x8d, 0x47, 0xe4, 0xc3, 0x15, 0x9d, 0x5e, 0x50, 0xef, 0x40, 0xad, - 0xc3, 0x2b, 0xb3, 0xf7, 0x64, 0x6d, 0x52, 0x64, 0x89, 0x6d, 0x0f, 0x35, 0x56, 0xed, 0x64, 0xbe, - 0xcd, 0x08, 0xaa, 0x59, 0x0a, 0x31, 0x52, 0x83, 0x08, 0x27, 0x7b, 0x37, 0x25, 0xfe, 0xbd, 0xd9, - 0x32, 0x5e, 0x82, 0x9a, 0x6a, 0xc7, 0x26, 0xf8, 0x91, 0xed, 0x07, 0xea, 0xa4, 0x5a, 0x81, 0x1b, - 0xf8, 0xd1, 0x56, 0xc0, 0xd3, 0xdb, 0xbd, 0xe0, 0xc0, 0x26, 0x4e, 0x10, 0x89, 0x25, 0x6b, 0xd1, - 0x9a, 0x64, 0x90, 0x06, 0x03, 0xac, 0xbe, 0x0b, 0x4b, 0x8f, 0x7d, 0x58, 0xda, 0x98, 0x03, 0x3d, - 0xf9, 0xda, 0x0a, 0xa2, 0x1e, 0xf2, 0xf4, 0x73, 0xc6, 0x22, 0xcc, 0x26, 0xd0, 0xdb, 0x41, 0xe4, - 0xf0, 0x6b, 0x74, 0xba, 0xb6, 0xea, 0xc1, 0x85, 0xa3, 0x5e, 0x92, 0x66, 0xd5, 0xc9, 0x4b, 0x6a, - 0x7d, 0x8f, 0xc6, 0xd5, 0xad, 0xc0, 0x85, 0x04, 0x7a, 0x7f, 0xe4, 0x41, 0x68, 0x91, 0x6f, 0x96, - 0x50, 0x88, 0x34, 0x22, 0x3d, 0xb7, 0xfa, 0x32, 0x40, 0x32, 0xe5, 0x19, 0x13, 0x90, 0x7b, 0xf8, - 0x9a, 0x7e, 0xce, 0x98, 0x84, 0xe2, 0xc3, 0xd7, 0x9a, 0xcd, 0xfb, 0xba, 0xc6, 0x41, 0xeb, 0x7a, - 0x6e, 0xf5, 0x15, 0x80, 0xe4, 0x4a, 0x86, 0x01, 0x30, 0x11, 0x37, 0x5d, 0x82, 0xfc, 0xfd, 0xe0, - 0x40, 0xd7, 0x8c, 0x32, 0x14, 0xee, 0xba, 0xed, 0x8e, 0x9e, 0x5b, 0xbd, 0x06, 0xd5, 0xec, 0x3d, - 0x0c, 0x56, 0x4d, 0x63, 0x53, 0x3f, 0xc7, 0xfe, 0x5a, 0x1b, 0xba, 0xc6, 0x73, 0xda, 0x36, 0x44, - 0x4e, 0x5b, 0x43, 0xcf, 0xad, 0x3e, 0x84, 0x4a, 0x2a, 0xa7, 0x9f, 0xf1, 0xba, 0x15, 0xd0, 0xeb, - 0x9e, 0x17, 0x1c, 0xe0, 0xd6, 0xb6, 0xcf, 0xc0, 0x42, 0x64, 0x31, 0xe8, 0xba, 0xd7, 0x0b, 0x08, - 0xe5, 0x08, 0xcd, 0xa8, 0xc3, 0x5c, 0x0a, 0xc1, 0x33, 0xe0, 0x38, 0x26, 0xb7, 0xea, 0x40, 0x6e, - 0x3b, 0x64, 0x1c, 0xee, 0xf4, 0xa9, 0x60, 0xf5, 0x26, 0xf6, 0x04, 0xab, 0x5c, 0xdc, 0x39, 0x63, - 0x0a, 0xca, 0x6a, 0x3b, 0x5e, 0xcf, 0xb3, 0x7e, 0x6d, 0xfa, 0xcc, 0x55, 0xea, 0x05, 0x63, 0x16, - 0x6a, 0x43, 0x8a, 0xd0, 0x8b, 0x86, 0x01, 0x55, 0xce, 0xb5, 0x8a, 0x8c, 0x88, 0x3e, 0xb1, 0xba, - 0x06, 0x93, 0xb1, 0xbf, 0x65, 0x35, 0x6f, 0x05, 0x3e, 0x16, 0x42, 0xe4, 0x24, 0xba, 0xc6, 0x1a, - 0x51, 0x05, 0x84, 0x74, 0xb2, 0xfe, 0x99, 0xf1, 0xb5, 0xbd, 0xb7, 0xa7, 0x9f, 0x63, 0xa5, 0x6f, - 0x23, 0x5e, 0x04, 0x60, 0xa2, 0x41, 0x23, 0xa6, 0xba, 0xdc, 0xea, 0xb7, 0x35, 0x98, 0x90, 0xff, - 0x2f, 0x80, 0xd7, 0x24, 0x7e, 0xeb, 0xe7, 0x8c, 0x79, 0x98, 0x69, 0x36, 0xef, 0x8b, 0x2c, 0xb9, - 0xb8, 0x17, 0x5c, 0x1e, 0xfc, 0xa4, 0x4d, 0x36, 0x19, 0x63, 0x72, 0xac, 0xc0, 0x83, 0x78, 0x12, - 0x6a, 0xec, 0xf4, 0x49, 0x07, 0xb7, 0xf4, 0x3c, 0xb3, 0x9e, 0xb8, 0x9e, 0x31, 0x6f, 0x3e, 0xeb, - 0x05, 0x63, 0x09, 0xe6, 0xd3, 0x55, 0xde, 0x0c, 0xb6, 0x02, 0xda, 0x71, 0xfd, 0xb6, 0x5e, 0x5c, - 0xbd, 0x02, 0xa5, 0x5b, 0x87, 0x34, 0x42, 0xdb, 0xa1, 0xe8, 0x7c, 0x10, 0xea, 0xe7, 0x0c, 0x1d, - 0xa6, 0x2c, 0x8c, 0x5a, 0xdb, 0x5e, 0x8b, 0x6f, 0x4b, 0xe8, 0xda, 0xaa, 0x09, 0x33, 0x23, 0x0b, - 0x27, 0x66, 0x06, 0x1b, 0x91, 0xf3, 0xd6, 0x1b, 0xf6, 0xbf, 0x0d, 0x22, 0xfd, 0xdc, 0x8d, 0x97, - 0xfe, 0xe2, 0xff, 0x95, 0xb5, 0x0f, 0x3f, 0x7a, 0x41, 0xfb, 0xf1, 0x47, 0x2f, 0x68, 0x7f, 0xfd, - 0xd1, 0x0b, 0xda, 0xff, 0xfe, 0x9b, 0x17, 0xce, 0x81, 0x1e, 0x44, 0xed, 0x35, 0xea, 0x76, 0xf7, - 0xd7, 0x64, 0xb0, 0xb0, 0x3b, 0xc1, 0xff, 0xbc, 0xfe, 0x2f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x3e, - 0xdb, 0xcf, 0x32, 0x4c, 0x68, 0x00, 0x00, + 0x01, 0x3a, 0x40, 0xc2, 0xfd, 0x09, 0xb8, 0x3b, 0x40, 0x86, 0x0d, 0xff, 0xd8, 0xd6, 0x87, 0x61, + 0x40, 0x1f, 0x2b, 0xc3, 0x82, 0x64, 0x18, 0x86, 0x0c, 0xd9, 0x10, 0x8c, 0x35, 0xe0, 0x5f, 0xe9, + 0xc3, 0x86, 0xfd, 0x63, 0xd8, 0xc8, 0x57, 0x3d, 0xba, 0x7b, 0x48, 0x0e, 0x87, 0x33, 0x92, 0xfc, + 0xc5, 0xae, 0x88, 0xc8, 0xcc, 0xc8, 0x88, 0xc8, 0xc8, 0xc8, 0xcc, 0xc8, 0x24, 0x4c, 0x77, 0xf7, + 0xa3, 0xd0, 0x09, 0x77, 0xd7, 0xc2, 0x28, 0xa0, 0x81, 0x51, 0x92, 0x9f, 0xcb, 0x53, 0x3d, 0x4c, + 0x91, 0x02, 0x2f, 0x4f, 0xe3, 0x28, 0x0a, 0xa2, 0xf8, 0x73, 0xae, 0x1d, 0xb4, 0x03, 0xfe, 0xf3, + 0x1a, 0xfb, 0x25, 0xa1, 0xb5, 0xa8, 0x4f, 0x28, 0xff, 0x29, 0x01, 0xd5, 0x16, 0x46, 0x2d, 0x2f, + 0x70, 0xba, 0xaa, 0x16, 0x1a, 0x21, 0x07, 0xc7, 0xb5, 0x2c, 0x44, 0x98, 0x04, 0xfd, 0xc8, 0xc1, + 0x76, 0x0f, 0xf9, 0xa8, 0x8d, 0x23, 0x01, 0x37, 0x5b, 0x00, 0x77, 0x30, 0xb5, 0xf0, 0xa3, 0x3e, + 0x26, 0xd4, 0x58, 0x85, 0x92, 0x13, 0xf8, 0x14, 0x1f, 0xd2, 0xba, 0xb6, 0xa2, 0x5d, 0xad, 0xac, + 0xeb, 0x6b, 0x8a, 0xe5, 0x0d, 0x01, 0xb7, 0x14, 0x81, 0xa1, 0x43, 0xbe, 0x8b, 0x07, 0xf5, 0xdc, + 0x8a, 0x76, 0x75, 0xca, 0x62, 0x3f, 0x8d, 0x3a, 0x94, 0xf6, 0x71, 0x44, 0xdc, 0xc0, 0xaf, 0xe7, + 0x57, 0xb4, 0xab, 0x05, 0x4b, 0x7d, 0x9a, 0x1f, 0x69, 0x50, 0xe1, 0xcd, 0x90, 0x30, 0xf0, 0x09, + 0x36, 0x5e, 0x83, 0xa9, 0x08, 0xb7, 0xdd, 0xc0, 0xb7, 0x79, 0x5f, 0x65, 0x63, 0xd5, 0x35, 0xd5, + 0xf3, 0x5b, 0xec, 0xaf, 0x55, 0x11, 0x34, 0xfc, 0xc3, 0x78, 0x19, 0x8a, 0x82, 0x36, 0xc7, 0x69, + 0x67, 0x62, 0xc6, 0xee, 0xe1, 0x81, 0x20, 0x17, 0x78, 0x63, 0x0e, 0x8a, 0xfb, 0xc8, 0xeb, 0x63, + 0xce, 0xc3, 0x94, 0x25, 0x3e, 0x8c, 0xf3, 0x30, 0xe9, 0x07, 0xd4, 0xde, 0x0b, 0xfa, 0x7e, 0xab, + 0x5e, 0x58, 0xd1, 0xae, 0x96, 0xad, 0xb2, 0x1f, 0xd0, 0xdb, 0xec, 0xdb, 0x78, 0x1b, 0x6a, 0xf8, + 0x10, 0x3b, 0x76, 0x0b, 0x53, 0xe4, 0x7a, 0xc4, 0xde, 0x5f, 0xaf, 0x4f, 0xf0, 0x56, 0x16, 0xe2, + 0x56, 0x6e, 0x1d, 0x62, 0xe7, 0xa6, 0x40, 0x3f, 0x5c, 0xb7, 0xa6, 0x71, 0xfa, 0xf3, 0xdd, 0x42, + 0xb9, 0xa8, 0x4f, 0x98, 0x7f, 0xaf, 0x41, 0xa5, 0xe1, 0x20, 0xff, 0x34, 0xc2, 0x3c, 0x0f, 0x93, + 0x84, 0xa2, 0x88, 0xda, 0x89, 0x48, 0xcb, 0x1c, 0x70, 0x0f, 0x0f, 0x58, 0x8f, 0x3c, 0xb7, 0xe7, + 0x52, 0xde, 0xa3, 0x69, 0x4b, 0x7c, 0xa4, 0xa5, 0x5d, 0xc8, 0x48, 0xdb, 0x58, 0x82, 0x72, 0x17, + 0x0f, 0xec, 0xc0, 0xf7, 0x06, 0xf5, 0x22, 0xef, 0x6a, 0xa9, 0x8b, 0x07, 0xdb, 0xbe, 0xc7, 0x55, + 0x14, 0x61, 0x46, 0x87, 0x79, 0x0f, 0xcb, 0x96, 0xfa, 0x34, 0x16, 0xa1, 0x84, 0xfd, 0x16, 0x6f, + 0xbf, 0xc4, 0xdb, 0x9f, 0xc0, 0x7e, 0x8b, 0xb5, 0x7e, 0x09, 0x2a, 0x04, 0xf5, 0x42, 0x0f, 0xdb, + 0x84, 0xe2, 0xb0, 0x5e, 0xe6, 0x3c, 0x80, 0x00, 0x35, 0x28, 0x0e, 0xcd, 0xff, 0xa5, 0xc1, 0x94, + 0xe8, 0xf7, 0xe9, 0xb5, 0x7b, 0x05, 0x8a, 0x21, 0x72, 0x23, 0x52, 0xcf, 0xad, 0xe4, 0xaf, 0x56, + 0xd6, 0x6b, 0x89, 0x76, 0xf7, 0x77, 0x90, 0x1b, 0x59, 0x02, 0x9b, 0x18, 0x41, 0xfe, 0x68, 0x23, + 0x30, 0x7f, 0x59, 0x82, 0xda, 0x4e, 0x84, 0x0f, 0x22, 0x97, 0xe2, 0xd3, 0xe8, 0xe3, 0x1a, 0x4c, + 0xf6, 0xfa, 0x14, 0x51, 0x37, 0xf0, 0x15, 0x4f, 0x49, 0x63, 0x0f, 0x24, 0xc6, 0x4a, 0x68, 0x8c, + 0xcb, 0x30, 0x15, 0x46, 0x6e, 0x0f, 0x45, 0x03, 0x9b, 0x0d, 0x42, 0x69, 0x7c, 0x15, 0x09, 0xbb, + 0x1f, 0x38, 0x5d, 0xe3, 0x45, 0x98, 0x16, 0x3a, 0xce, 0xaa, 0x6d, 0x8a, 0x03, 0x1f, 0x26, 0xba, + 0x63, 0xe5, 0x6d, 0x4a, 0x3d, 0xae, 0xbb, 0x82, 0x55, 0x62, 0xdf, 0x4d, 0xea, 0x19, 0xeb, 0x30, + 0x4f, 0xba, 0x6e, 0x68, 0x3b, 0x81, 0x4f, 0x68, 0x84, 0x5c, 0x9f, 0xda, 0x4e, 0x07, 0x3b, 0x5d, + 0xa9, 0xc9, 0x59, 0x86, 0xdc, 0x88, 0x71, 0x1b, 0x0c, 0x65, 0xfc, 0x3b, 0x98, 0x0d, 0x31, 0x21, + 0x6e, 0xcf, 0x25, 0xd4, 0x75, 0x6c, 0xe4, 0x88, 0x1e, 0x95, 0x56, 0xf2, 0x57, 0xab, 0xeb, 0xab, + 0x71, 0x8f, 0x86, 0x44, 0xb5, 0xb6, 0x93, 0x94, 0xb9, 0xce, 0x8b, 0x58, 0x46, 0x38, 0x0c, 0x22, + 0x8c, 0x57, 0x7a, 0xe8, 0xdb, 0xc4, 0xfd, 0x0a, 0xe6, 0x66, 0x51, 0xb0, 0x4a, 0xf4, 0xd0, 0x6f, + 0xb8, 0x5f, 0xc1, 0x86, 0x09, 0xd3, 0x7b, 0x41, 0x64, 0xf7, 0xc3, 0x16, 0xa2, 0xd8, 0xa6, 0xa4, + 0x3e, 0xc9, 0xf1, 0x95, 0xbd, 0x20, 0x7a, 0x8f, 0xc3, 0x9a, 0x84, 0xd1, 0xf4, 0x5c, 0xdf, 0x76, + 0x82, 0x5e, 0xcf, 0xa5, 0x8c, 0x06, 0x04, 0x4d, 0xcf, 0xf5, 0x37, 0x38, 0xac, 0x49, 0x8c, 0xab, + 0xa0, 0xf7, 0x09, 0xb6, 0x11, 0x19, 0xf8, 0x8e, 0xa4, 0xac, 0x57, 0x78, 0x77, 0xab, 0x7d, 0x82, + 0xaf, 0x33, 0xb0, 0xa0, 0x35, 0x56, 0xa0, 0x42, 0xb0, 0x13, 0xf8, 0x2d, 0x14, 0xb9, 0x98, 0xd4, + 0xa7, 0x56, 0xf2, 0x4c, 0xfe, 0x29, 0x90, 0x71, 0x01, 0x80, 0x46, 0x6c, 0x58, 0x60, 0x3b, 0x74, + 0xea, 0xd3, 0xc2, 0x07, 0xd0, 0x68, 0xb0, 0xed, 0xe3, 0x1d, 0x87, 0x73, 0x83, 0x0e, 0x53, 0xdc, + 0x54, 0x25, 0x37, 0xe8, 0x30, 0xe6, 0xe6, 0x1d, 0xa8, 0x21, 0x42, 0x70, 0xc4, 0xba, 0x6f, 0x7b, + 0x78, 0x1f, 0x7b, 0xf5, 0xda, 0x8a, 0x76, 0xb5, 0xba, 0xbe, 0x18, 0x4b, 0xf2, 0xba, 0xc2, 0xdf, + 0x67, 0x68, 0xab, 0x8a, 0x32, 0xdf, 0x86, 0x0b, 0x4b, 0x19, 0xb9, 0xa4, 0x94, 0x49, 0xea, 0x3a, + 0xb7, 0xb3, 0xb5, 0xc7, 0x6a, 0xe5, 0x76, 0x2c, 0xbc, 0x46, 0xa2, 0x67, 0x6b, 0x21, 0x25, 0xd3, + 0x04, 0x4c, 0x8c, 0x97, 0xa0, 0xc6, 0xb4, 0xb3, 0xe7, 0x7a, 0xd8, 0x76, 0x3a, 0x7d, 0xbf, 0x4b, + 0xea, 0xad, 0x95, 0xfc, 0xd5, 0x82, 0x35, 0x4d, 0x0f, 0xfd, 0xdb, 0xae, 0x87, 0x37, 0x38, 0x70, + 0x79, 0x17, 0xe6, 0xc7, 0x56, 0xcc, 0xdc, 0x8e, 0xeb, 0xb7, 0xf0, 0x21, 0x1f, 0x2d, 0xd3, 0x96, + 0xf8, 0x30, 0x5e, 0x87, 0x05, 0x7c, 0x18, 0x62, 0x87, 0xe2, 0x96, 0x9d, 0x55, 0x71, 0x8e, 0x0b, + 0x6c, 0x56, 0x61, 0x93, 0x4a, 0x89, 0xb9, 0x0b, 0x33, 0x23, 0x26, 0x65, 0x2c, 0xc3, 0x42, 0xe3, + 0xde, 0xe6, 0x8e, 0xbd, 0x73, 0xab, 0xd1, 0xd8, 0x7c, 0xb0, 0xd9, 0x68, 0x6e, 0x6e, 0xd8, 0x1b, + 0x77, 0x6f, 0x6d, 0xdc, 0xd3, 0xcf, 0x19, 0x75, 0x98, 0xbb, 0xb9, 0x3d, 0x06, 0xa3, 0x19, 0x8b, + 0x30, 0x7b, 0x73, 0xdb, 0xde, 0xd8, 0xde, 0x6a, 0x34, 0xad, 0xeb, 0x9b, 0x5b, 0x4d, 0x89, 0xc8, + 0x99, 0xff, 0xa4, 0x81, 0x9e, 0x48, 0xec, 0xf4, 0xae, 0xe8, 0xe3, 0x30, 0xc1, 0xb1, 0xa3, 0xe3, + 0x3e, 0x76, 0x32, 0x92, 0x60, 0xd4, 0x82, 0xf3, 0xa3, 0x16, 0xfc, 0x32, 0xe8, 0xc2, 0xe2, 0x52, + 0x64, 0x62, 0xe0, 0x4f, 0x07, 0xcc, 0xf0, 0x62, 0xc2, 0x31, 0x93, 0x50, 0xf1, 0x09, 0x26, 0x21, + 0xf3, 0x07, 0x05, 0x58, 0x48, 0x09, 0x99, 0xb9, 0x9c, 0x7f, 0x2d, 0x9e, 0x6f, 0xc4, 0x9b, 0x4c, + 0x8c, 0xf5, 0x26, 0x2e, 0xb1, 0xf7, 0xdc, 0x88, 0x50, 0xc1, 0x47, 0x89, 0x0f, 0xf0, 0x8a, 0x4b, + 0x6e, 0x33, 0x18, 0xe7, 0xe3, 0x32, 0x4c, 0x1d, 0x20, 0xa6, 0x02, 0xb7, 0x87, 0x83, 0x3e, 0xe5, + 0x4e, 0x2b, 0x6f, 0x55, 0x18, 0xac, 0x29, 0x40, 0x46, 0x1d, 0x8a, 0x7b, 0x41, 0xe4, 0x60, 0xee, + 0xb0, 0xca, 0x37, 0x72, 0x75, 0xcd, 0x12, 0x00, 0xd6, 0x89, 0x08, 0xd3, 0x7e, 0xe4, 0xdb, 0x3c, + 0xa2, 0x10, 0xee, 0xaa, 0x6c, 0x4d, 0x09, 0xe0, 0x43, 0x0e, 0x1b, 0xb5, 0x88, 0xca, 0x38, 0x8b, + 0xa8, 0x71, 0xbf, 0x6d, 0xe3, 0x43, 0x97, 0x50, 0xec, 0x3b, 0xb8, 0x3e, 0x25, 0x5c, 0x1a, 0x07, + 0xdf, 0x52, 0x50, 0xe3, 0x55, 0x98, 0xe5, 0x12, 0x61, 0x13, 0xb9, 0xed, 0xee, 0x09, 0x7a, 0x22, + 0x3d, 0x97, 0xce, 0x50, 0x6c, 0x4e, 0xdf, 0xdc, 0xe3, 0x25, 0x88, 0x71, 0x93, 0xf5, 0xae, 0x8b, + 0xed, 0x7e, 0x68, 0xf7, 0x82, 0x16, 0xe6, 0x0e, 0xac, 0xba, 0x6e, 0x26, 0xee, 0x24, 0x6b, 0x1c, + 0xef, 0xa3, 0x2e, 0x7e, 0x2f, 0x7c, 0x10, 0xb4, 0xb0, 0x05, 0x07, 0xf1, 0x6f, 0xf3, 0x97, 0x1a, + 0xd4, 0x87, 0x28, 0xef, 0xe1, 0x81, 0x85, 0x49, 0xdf, 0xa3, 0xc6, 0x67, 0xa0, 0x40, 0x07, 0x21, + 0xe6, 0x56, 0x54, 0x5d, 0xbf, 0xf2, 0xb8, 0xaa, 0xe3, 0x02, 0xcd, 0x41, 0x88, 0x2d, 0x5e, 0x24, + 0x09, 0xcb, 0x72, 0xe9, 0xb0, 0xec, 0x02, 0x4c, 0x26, 0x52, 0xc8, 0xf3, 0x8e, 0x25, 0x00, 0xe3, + 0x4d, 0x58, 0x64, 0xbd, 0xc4, 0x2d, 0xfb, 0xc0, 0xa5, 0x1d, 0xe6, 0x2b, 0xf7, 0x3c, 0xd7, 0x49, + 0x0d, 0xa1, 0x39, 0x81, 0x7e, 0xdf, 0xa5, 0x9d, 0x0d, 0x89, 0x6c, 0x12, 0x63, 0x0d, 0xf8, 0x5c, + 0x68, 0xb3, 0x90, 0xd7, 0xdb, 0x77, 0xfd, 0xb6, 0x30, 0x08, 0x31, 0x6f, 0xcc, 0x30, 0x94, 0xa5, + 0x30, 0x8c, 0x5b, 0xf3, 0x6f, 0x73, 0xb0, 0x38, 0x32, 0x72, 0x9e, 0x8b, 0x03, 0xb9, 0x04, 0x93, + 0x43, 0xce, 0x83, 0x5b, 0x5c, 0xd9, 0x51, 0xb6, 0x52, 0x57, 0x52, 0x63, 0xfd, 0x9d, 0x12, 0xe6, + 0x28, 0x24, 0xb7, 0x00, 0x13, 0xd2, 0x0e, 0x8b, 0x7c, 0xaa, 0x93, 0x5f, 0xc6, 0x45, 0x80, 0x38, + 0xd0, 0x65, 0x03, 0x25, 0xcf, 0x44, 0xaa, 0x22, 0xdd, 0xb1, 0x5e, 0xa6, 0xf4, 0x04, 0x5e, 0xc6, + 0xf8, 0x1c, 0x0b, 0x20, 0x99, 0x6a, 0x49, 0xbd, 0xcc, 0x7b, 0x77, 0xf9, 0x58, 0x23, 0xb0, 0x54, + 0x09, 0xf3, 0xbb, 0x1a, 0x2c, 0xa7, 0xa8, 0xac, 0xc0, 0xf3, 0x76, 0xd1, 0xe9, 0xdc, 0xd4, 0x88, + 0x4b, 0xc9, 0x8d, 0x71, 0x29, 0x23, 0x7e, 0x23, 0x3f, 0xea, 0x37, 0x0c, 0x28, 0x74, 0xf1, 0x80, + 0x19, 0x14, 0x93, 0x22, 0xff, 0x6d, 0x7e, 0x5f, 0x83, 0xf3, 0x63, 0xf9, 0x7c, 0x2e, 0x46, 0x31, + 0x46, 0x45, 0xf9, 0x27, 0x99, 0x08, 0xfe, 0x54, 0x83, 0xd9, 0xe6, 0xa1, 0x7f, 0x17, 0xa3, 0x88, + 0xde, 0xc0, 0xe8, 0x54, 0x8b, 0xbb, 0x61, 0xa7, 0x9e, 0x3b, 0x81, 0x53, 0xcf, 0x8f, 0xd1, 0xc0, + 0x4b, 0x50, 0x43, 0xad, 0x7d, 0x97, 0x60, 0x3b, 0xf6, 0xed, 0x72, 0xf2, 0x13, 0xe0, 0xfb, 0xd2, + 0xc3, 0xbf, 0x00, 0x15, 0x97, 0xd8, 0x2a, 0x5e, 0xa9, 0xb7, 0x84, 0x27, 0x70, 0x49, 0x53, 0x84, + 0x2a, 0xe6, 0x8f, 0x34, 0x98, 0xcb, 0xf6, 0xe9, 0x39, 0xac, 0x24, 0xd3, 0x33, 0x52, 0x3e, 0x3b, + 0x23, 0x8d, 0xd1, 0x51, 0xe1, 0x49, 0x74, 0xf4, 0xbd, 0x3c, 0xcc, 0xf3, 0x08, 0xbd, 0x79, 0xe8, + 0x37, 0x28, 0xa2, 0x7d, 0x72, 0x1a, 0x2d, 0x5d, 0x02, 0xa5, 0x91, 0xd4, 0xba, 0x11, 0x24, 0x88, + 0xad, 0xdd, 0x16, 0xa1, 0x24, 0x7a, 0xa0, 0x4c, 0x7f, 0x82, 0x77, 0x80, 0x07, 0x87, 0x0e, 0xf2, + 0x3c, 0x1c, 0xd9, 0x42, 0x87, 0x49, 0x50, 0x22, 0xc0, 0x0d, 0x06, 0x6d, 0x72, 0x6f, 0xe2, 0xf4, + 0xa3, 0x08, 0xfb, 0x9c, 0x44, 0x4c, 0xcb, 0x93, 0x12, 0xd2, 0x24, 0xc6, 0x6b, 0x30, 0x1f, 0xc9, + 0xc1, 0xc1, 0x26, 0x28, 0xe6, 0x78, 0xb8, 0xf7, 0x96, 0x4b, 0x12, 0x43, 0x21, 0x37, 0xf7, 0xb6, + 0x02, 0xca, 0xa7, 0x29, 0x63, 0x15, 0x66, 0xf8, 0x7c, 0x6a, 0xa7, 0x43, 0x7a, 0x31, 0x57, 0xd7, + 0x38, 0xa2, 0x91, 0xc4, 0xf4, 0x9f, 0x87, 0xe5, 0xc4, 0x87, 0xa7, 0xd7, 0x31, 0xdc, 0x26, 0xcb, + 0xbc, 0x50, 0x3d, 0xa6, 0x18, 0xf2, 0x3f, 0xac, 0xa5, 0x7d, 0x1c, 0xb9, 0x7b, 0x03, 0xdb, 0x25, + 0xb6, 0x14, 0x8a, 0x98, 0xd6, 0xad, 0x9a, 0x40, 0x6c, 0x92, 0x1d, 0x01, 0x3e, 0xd6, 0xfe, 0x7e, + 0x9c, 0x83, 0x85, 0x61, 0x7d, 0xfd, 0x6a, 0x2d, 0xf0, 0x0a, 0x54, 0xe5, 0xd4, 0x91, 0x0d, 0xaa, + 0xa6, 0x05, 0x54, 0x0d, 0xc0, 0x97, 0x61, 0x42, 0x2c, 0xfa, 0xb8, 0xf2, 0xaa, 0xa9, 0x95, 0xb5, + 0x5c, 0xd8, 0x49, 0xb4, 0xb1, 0x06, 0x93, 0xbc, 0x29, 0xd7, 0xdf, 0x0b, 0xe4, 0xee, 0x47, 0xc2, + 0x17, 0x93, 0xe7, 0xa6, 0xbf, 0x17, 0x58, 0x9c, 0x1d, 0xf6, 0xeb, 0x69, 0x27, 0x12, 0xf3, 0xab, + 0x1a, 0x2c, 0x73, 0x89, 0x36, 0xe4, 0x12, 0x8d, 0x7b, 0x95, 0x53, 0x0d, 0x03, 0xe5, 0xc2, 0x73, + 0x89, 0x0b, 0x3f, 0x91, 0x77, 0x32, 0xff, 0x59, 0x83, 0xf3, 0x63, 0x79, 0x78, 0x0e, 0xaa, 0x7d, + 0x19, 0x8a, 0x4c, 0x96, 0x6c, 0x60, 0xe6, 0xc7, 0xcb, 0x5a, 0xe0, 0x8d, 0xf3, 0xe9, 0x18, 0x41, + 0xe8, 0x38, 0x89, 0x0f, 0x9e, 0x76, 0xd1, 0xf0, 0x43, 0x0d, 0xa6, 0xc5, 0x60, 0x7b, 0x66, 0x93, + 0xb0, 0xd2, 0x4e, 0x3e, 0xa5, 0x9d, 0x13, 0x1a, 0xef, 0x31, 0xa3, 0x52, 0xec, 0xbb, 0x59, 0x13, + 0xbb, 0xae, 0xef, 0x05, 0x6d, 0xf3, 0xcf, 0x34, 0xa8, 0xaa, 0xbe, 0x3c, 0x07, 0x05, 0x8e, 0xf6, + 0x21, 0x3f, 0xae, 0x0f, 0x4f, 0x3b, 0x53, 0xb4, 0x61, 0x7a, 0xb3, 0x17, 0x06, 0x51, 0xac, 0xa0, + 0xcc, 0x02, 0x4d, 0x3b, 0xc1, 0x02, 0x6d, 0x94, 0xd1, 0xdc, 0x18, 0x46, 0xcd, 0x0f, 0xa0, 0xaa, + 0x1a, 0x3a, 0xbd, 0xf4, 0xe6, 0xd2, 0xd2, 0x9b, 0x54, 0xbb, 0x71, 0xdf, 0x60, 0x9a, 0xf1, 0x30, + 0xf2, 0xfb, 0xe1, 0xd9, 0xec, 0x34, 0x9f, 0x28, 0xf6, 0xc8, 0xce, 0x5d, 0x85, 0xa1, 0xb9, 0xcb, + 0xfc, 0xa6, 0x06, 0xb5, 0x98, 0xa9, 0x5f, 0x1b, 0x7b, 0x31, 0xbb, 0x50, 0xbb, 0x81, 0xa8, 0xd3, + 0x39, 0xe5, 0xae, 0xfc, 0x38, 0x5f, 0xf8, 0xf8, 0x7d, 0xf9, 0xbf, 0xd4, 0x40, 0x4f, 0x5a, 0x7b, + 0xe6, 0xdb, 0xb7, 0x4f, 0x39, 0x16, 0x12, 0x59, 0x17, 0x8f, 0x96, 0xf5, 0xbb, 0x85, 0x72, 0x5e, + 0x2f, 0x98, 0xdf, 0xd6, 0x60, 0x8e, 0xf7, 0xee, 0x99, 0x2f, 0x34, 0xc6, 0xf9, 0xb8, 0xe3, 0x42, + 0x8a, 0xdf, 0xd5, 0x60, 0x7e, 0x88, 0xbb, 0xe7, 0x60, 0x85, 0x4f, 0xbb, 0xb8, 0xf8, 0xff, 0x1a, + 0xd4, 0x1a, 0x0e, 0xf2, 0x4f, 0xbb, 0xbd, 0x74, 0x09, 0x2a, 0x3d, 0x74, 0x38, 0x24, 0x4c, 0xe8, + 0xa1, 0x43, 0x25, 0xca, 0xcc, 0x49, 0x48, 0xfe, 0x71, 0x27, 0x21, 0x85, 0xf4, 0x49, 0x48, 0xea, + 0xe8, 0xa2, 0x98, 0x3e, 0xba, 0x30, 0x7f, 0xaa, 0x81, 0x9e, 0x30, 0xfb, 0xeb, 0x34, 0xa9, 0x3f, + 0xed, 0xac, 0xf0, 0x0b, 0x0d, 0x0c, 0xb1, 0x89, 0x81, 0x4f, 0xab, 0x89, 0x13, 0x19, 0xf6, 0x09, + 0x27, 0xb9, 0x57, 0x61, 0x92, 0x19, 0x3a, 0x8b, 0x1d, 0xc5, 0x4a, 0x3a, 0xdd, 0x72, 0xf3, 0xd0, + 0x17, 0xb1, 0x23, 0x15, 0x3f, 0x92, 0x35, 0x77, 0xf1, 0x09, 0x86, 0xcb, 0xef, 0x68, 0x30, 0x9b, + 0xe9, 0xf1, 0x6f, 0xc0, 0x60, 0x79, 0x08, 0x93, 0x77, 0x36, 0x4e, 0xa3, 0x9b, 0x8b, 0x00, 0x04, + 0xed, 0x61, 0x3b, 0x0c, 0x5c, 0x9f, 0x4a, 0xc5, 0x4c, 0x32, 0xc8, 0x0e, 0x03, 0x98, 0x1d, 0x00, + 0x56, 0xef, 0xb3, 0x97, 0x80, 0xf9, 0x2d, 0x0d, 0x8c, 0x9b, 0xd8, 0xc3, 0x14, 0x5b, 0xc8, 0x6f, + 0xe3, 0x33, 0x3f, 0xda, 0x4c, 0x0d, 0xdd, 0xfc, 0xf0, 0xa9, 0xa3, 0x1f, 0x50, 0xb6, 0x78, 0xe3, + 0xc7, 0x98, 0xe2, 0xc4, 0x16, 0x04, 0x68, 0xdb, 0xf7, 0x06, 0xe6, 0x97, 0x60, 0x36, 0xc3, 0xd8, + 0x59, 0xc7, 0x2c, 0xbf, 0xaf, 0xc1, 0xca, 0x4e, 0x84, 0x43, 0x14, 0xe1, 0xdb, 0x1e, 0x22, 0x1d, + 0xe6, 0xa1, 0x9b, 0x81, 0x34, 0xf8, 0xe7, 0x27, 0x87, 0x25, 0x28, 0x0f, 0xad, 0xd0, 0x4b, 0x44, + 0xae, 0xcd, 0x53, 0xd3, 0x7a, 0x31, 0x3b, 0xad, 0x7b, 0x70, 0xf9, 0x08, 0xd6, 0xcf, 0x5a, 0x52, + 0x3f, 0xd6, 0x60, 0xe9, 0x6c, 0x44, 0x94, 0xea, 0x51, 0x2e, 0x7b, 0xa4, 0x7d, 0xe4, 0xac, 0x90, + 0x12, 0x5e, 0xe1, 0xb1, 0xc2, 0x2b, 0x66, 0x85, 0x97, 0x59, 0x55, 0x4d, 0x64, 0x57, 0x55, 0x26, + 0x86, 0xe5, 0xe7, 0x21, 0xb8, 0x2f, 0xc2, 0xb4, 0x85, 0x0e, 0xce, 0x2c, 0xfd, 0xa2, 0x0a, 0x39, + 0x67, 0x8f, 0x0b, 0x67, 0xd2, 0xca, 0x39, 0x7b, 0xe6, 0x7f, 0xd7, 0xa0, 0xaa, 0xea, 0x3f, 0x63, + 0xd6, 0x4f, 0x91, 0x64, 0x61, 0xb6, 0xc0, 0xb0, 0xd0, 0xc1, 0x59, 0xc7, 0xb6, 0xc3, 0x9d, 0x0e, + 0x60, 0x36, 0xd3, 0xca, 0xb3, 0x8e, 0x69, 0xcd, 0xff, 0xa3, 0x71, 0x2d, 0xee, 0xf4, 0xcf, 0x48, + 0x8b, 0xe3, 0x25, 0x2b, 0xba, 0x59, 0x50, 0xdd, 0x64, 0xe5, 0x92, 0x73, 0x32, 0xf6, 0x93, 0x0d, + 0x82, 0xbd, 0x20, 0xb2, 0x1d, 0x44, 0xe4, 0xe6, 0xdb, 0xc4, 0x5e, 0x10, 0x6d, 0x20, 0xc2, 0xd6, + 0x75, 0x8a, 0xbf, 0xb3, 0x36, 0xe0, 0x3f, 0xd0, 0x12, 0x9d, 0x9e, 0x52, 0x00, 0x27, 0x5c, 0x39, + 0x0c, 0xa9, 0xd9, 0x98, 0x13, 0xfd, 0x2f, 0xc4, 0x47, 0x26, 0xc3, 0x32, 0x28, 0xa6, 0x65, 0xc0, + 0x2c, 0x87, 0x52, 0x4f, 0x1c, 0x87, 0x14, 0x2c, 0xfe, 0x9b, 0x4d, 0x20, 0x19, 0xde, 0xcf, 0x5a, + 0x38, 0x03, 0xd0, 0x2d, 0x74, 0x20, 0xe7, 0xa8, 0x67, 0x31, 0xc0, 0xd3, 0xdd, 0x2d, 0x64, 0x54, + 0xfe, 0xef, 0x61, 0x26, 0xd5, 0xf4, 0x59, 0x77, 0xec, 0x3f, 0x6a, 0x30, 0xaf, 0x24, 0x77, 0xfa, + 0xee, 0x9d, 0x60, 0x30, 0x3f, 0xbe, 0x83, 0x08, 0x16, 0x86, 0x39, 0x38, 0xeb, 0x5e, 0xfe, 0x48, + 0x78, 0xcf, 0xe7, 0x98, 0xd0, 0x95, 0x4e, 0xdb, 0x2a, 0x64, 0xd3, 0xb6, 0x84, 0x60, 0x8a, 0xb1, + 0x60, 0x9e, 0x3c, 0x8d, 0xcb, 0x6c, 0x43, 0x2d, 0xee, 0xce, 0xe9, 0x65, 0x75, 0x19, 0xf2, 0xdd, + 0xfd, 0xc7, 0x0e, 0x56, 0x86, 0x33, 0xbf, 0x26, 0xcc, 0xe3, 0x57, 0x12, 0x35, 0x0e, 0xb9, 0x49, + 0x69, 0x27, 0xcf, 0x34, 0x4e, 0xfc, 0x89, 0x96, 0xf8, 0x91, 0xd3, 0x1a, 0xcb, 0xc7, 0x61, 0x22, + 0x62, 0xdc, 0x8d, 0x3d, 0x1c, 0x14, 0x7c, 0x4b, 0x02, 0xb6, 0x32, 0xc0, 0xc8, 0xe9, 0xd8, 0x69, + 0xfb, 0x99, 0x64, 0x90, 0xfb, 0x67, 0x66, 0x43, 0xa6, 0x07, 0x73, 0xd9, 0x1e, 0x3d, 0x53, 0x7b, + 0xf9, 0x0f, 0xb0, 0xf4, 0x9e, 0xcf, 0xd6, 0x36, 0x37, 0x31, 0xa1, 0x51, 0x30, 0x78, 0xbe, 0x26, + 0xc3, 0x62, 0xbd, 0x71, 0xcd, 0x9f, 0xb5, 0x99, 0x7c, 0x19, 0xce, 0x5b, 0xb8, 0xed, 0x12, 0x8a, + 0x23, 0xb6, 0x7c, 0xdd, 0xde, 0x25, 0x38, 0xda, 0xc7, 0xd1, 0x69, 0xfa, 0x39, 0x0f, 0x13, 0x3d, + 0x74, 0x98, 0x64, 0x5c, 0x15, 0x7b, 0xe8, 0xb0, 0x49, 0xcc, 0x37, 0xe0, 0xc2, 0xf8, 0x16, 0x64, + 0x57, 0x62, 0xbe, 0xb4, 0x6c, 0x0c, 0x5a, 0xe7, 0x27, 0x20, 0xcf, 0x88, 0xa9, 0x3e, 0x2c, 0x8d, + 0xa9, 0xfe, 0x28, 0x8e, 0x98, 0x09, 0xbb, 0xc4, 0x76, 0x3c, 0x8c, 0xc4, 0x2a, 0xa0, 0x6c, 0x95, + 0x5c, 0xc2, 0x37, 0x6a, 0x4f, 0xbc, 0xbd, 0x62, 0x7e, 0x09, 0x96, 0x2c, 0xdc, 0x0b, 0xc4, 0x56, + 0xc1, 0x33, 0xe8, 0xd6, 0x3a, 0x2c, 0x8f, 0xab, 0xff, 0x48, 0x49, 0xff, 0x4f, 0x0d, 0x16, 0x77, + 0x3a, 0x03, 0xe2, 0x3a, 0xc8, 0x7b, 0x9a, 0x1d, 0xb4, 0xf1, 0x2c, 0x9d, 0x62, 0xdf, 0xcc, 0xfc, + 0x00, 0xea, 0xa3, 0x0c, 0x1d, 0xa9, 0x9b, 0x58, 0x01, 0xb9, 0x63, 0x14, 0xf0, 0x1d, 0x0d, 0x8c, + 0x46, 0xe8, 0xb9, 0xd4, 0xe2, 0x23, 0xe3, 0x74, 0x3b, 0x85, 0x93, 0x84, 0xd5, 0x90, 0x0c, 0x67, + 0x91, 0x1b, 0xc3, 0x81, 0xac, 0x53, 0x17, 0x01, 0x62, 0x02, 0xb5, 0xf5, 0x3a, 0xa9, 0xb0, 0xc4, + 0x58, 0x86, 0x49, 0x97, 0xd8, 0x11, 0x3a, 0xb0, 0xbb, 0xfb, 0xca, 0x17, 0xba, 0xc4, 0x42, 0x07, + 0xf7, 0xf6, 0xcd, 0x5f, 0x68, 0x30, 0x9b, 0x61, 0xef, 0xf4, 0xc3, 0xfd, 0x25, 0x28, 0x78, 0x78, + 0x8f, 0xca, 0x9d, 0x94, 0xea, 0x9a, 0x4c, 0xe5, 0x17, 0x15, 0x73, 0x8e, 0x39, 0xde, 0xb8, 0x0a, + 0xc5, 0xc8, 0x6d, 0x77, 0xa8, 0xdc, 0x41, 0x1a, 0x47, 0x28, 0x08, 0x8c, 0xab, 0xcc, 0x31, 0xb7, + 0xf9, 0xf1, 0x8e, 0xd8, 0x4a, 0x1b, 0xa2, 0xb5, 0x14, 0x3a, 0x95, 0x54, 0xd2, 0x3a, 0x26, 0xa9, + 0xc4, 0xfc, 0xcf, 0x1a, 0xe8, 0x16, 0x46, 0xad, 0x4d, 0xbf, 0x85, 0x0f, 0x4f, 0xa3, 0x8e, 0xf4, + 0x5a, 0x3a, 0x97, 0x5d, 0x4b, 0x27, 0xd3, 0x57, 0xfe, 0x98, 0xe9, 0xcb, 0xfc, 0xba, 0x06, 0x33, + 0x29, 0x36, 0x4e, 0x2f, 0xf6, 0x8b, 0x00, 0x11, 0x46, 0x2d, 0x5b, 0x64, 0xa8, 0xca, 0x1d, 0xb2, + 0x48, 0xd5, 0xcc, 0x58, 0x12, 0xa9, 0x61, 0x23, 0x99, 0xe2, 0xb1, 0xa5, 0x4a, 0x02, 0xb3, 0x01, + 0xb3, 0x0f, 0xf6, 0x1d, 0xe7, 0x0e, 0xa6, 0x37, 0x06, 0x3c, 0x67, 0xe9, 0x0c, 0x42, 0x75, 0xf3, + 0xbf, 0x6a, 0x30, 0x97, 0xad, 0xf5, 0xac, 0x57, 0xe0, 0x57, 0xa0, 0xc0, 0x8f, 0xea, 0x87, 0xfb, + 0xc7, 0x5a, 0xe5, 0xfd, 0xe3, 0x68, 0xf3, 0xcb, 0xb0, 0x18, 0xf3, 0x21, 0x93, 0x3a, 0xce, 0x56, + 0xfb, 0x6c, 0xa8, 0xd7, 0x47, 0x9b, 0x38, 0xeb, 0xee, 0x4a, 0x11, 0xe7, 0x93, 0xd5, 0x90, 0x12, + 0x40, 0xe1, 0x68, 0x01, 0xfc, 0x36, 0x40, 0x69, 0x23, 0x89, 0x10, 0x24, 0x37, 0x6e, 0x8b, 0xb3, + 0x52, 0xb0, 0xca, 0x02, 0xb0, 0xd9, 0x32, 0xde, 0x4a, 0x58, 0x0d, 0x03, 0xa7, 0x23, 0x07, 0xf4, + 0x6c, 0x76, 0xec, 0xdd, 0x62, 0xa8, 0x98, 0x5f, 0xf6, 0x61, 0xac, 0x40, 0x21, 0xc4, 0x58, 0x5d, + 0x49, 0x98, 0x52, 0xf4, 0x3b, 0x18, 0x47, 0x16, 0xc7, 0xf0, 0xd5, 0x27, 0x8e, 0x7a, 0x72, 0xb5, + 0xce, 0x7f, 0x1b, 0xd7, 0xa0, 0x1c, 0x46, 0x6e, 0x10, 0xb9, 0x74, 0xc0, 0xc3, 0xaf, 0xea, 0xfa, + 0x6c, 0x4a, 0xfa, 0xbd, 0x1e, 0xf2, 0x5b, 0x3b, 0x91, 0x6b, 0xc5, 0x44, 0xc6, 0x3b, 0x50, 0x73, + 0x49, 0xe0, 0xa1, 0x54, 0xee, 0x79, 0x69, 0x28, 0xf7, 0x7c, 0x53, 0xe1, 0x65, 0xee, 0xb9, 0x9b, + 0xf9, 0x36, 0x3e, 0x06, 0x55, 0xbe, 0x3b, 0xe3, 0x7a, 0x9e, 0xed, 0x20, 0xa7, 0x83, 0x65, 0x06, + 0xcd, 0x94, 0x1f, 0xd0, 0xdb, 0xae, 0xe7, 0x6d, 0x30, 0x18, 0xd7, 0xf4, 0xc0, 0x77, 0x6c, 0x2f, + 0x68, 0xcb, 0x64, 0x99, 0x12, 0xfb, 0xbe, 0x1f, 0xb4, 0x8d, 0xab, 0xa0, 0x47, 0xd8, 0x09, 0xa2, + 0x16, 0x4f, 0xa0, 0xb5, 0x09, 0x45, 0x54, 0x26, 0xc1, 0x56, 0x05, 0xbc, 0xe9, 0xf6, 0x70, 0x83, + 0x22, 0x9a, 0xa2, 0x24, 0x0e, 0xf2, 0x05, 0x65, 0x25, 0x4d, 0xc9, 0xe6, 0x1b, 0x4e, 0x79, 0x99, + 0x49, 0x3d, 0xf4, 0x5c, 0x07, 0xd9, 0x6c, 0xf4, 0xca, 0x4c, 0xd8, 0x8a, 0x84, 0x31, 0x57, 0x61, + 0x5c, 0x81, 0xaa, 0xc8, 0xf1, 0xc1, 0x2d, 0x5b, 0xcc, 0x3e, 0xd3, 0x22, 0x8f, 0x5d, 0x41, 0x79, + 0xd2, 0x86, 0xf1, 0x19, 0x58, 0x62, 0xf3, 0x22, 0x3e, 0xc4, 0x4e, 0x9f, 0x0b, 0xa9, 0xd5, 0x8f, + 0x84, 0xb4, 0x7a, 0x2a, 0x99, 0x7f, 0xa1, 0x87, 0x0e, 0x6f, 0x29, 0xfc, 0x4d, 0x89, 0x7e, 0xc0, + 0x93, 0x45, 0x50, 0x18, 0x7a, 0x2e, 0x56, 0xfe, 0xa4, 0x26, 0x8e, 0x42, 0x24, 0x50, 0xb8, 0x94, + 0x45, 0x28, 0x51, 0x44, 0xba, 0xcc, 0x74, 0x74, 0x91, 0x4b, 0xc5, 0x3e, 0x37, 0x5b, 0x7c, 0x1e, + 0xa2, 0xc8, 0xc3, 0xa2, 0x03, 0x33, 0xe2, 0xe0, 0x82, 0x43, 0x38, 0xfb, 0x9f, 0x00, 0x23, 0xbe, + 0x7b, 0xd5, 0x8e, 0x82, 0x7e, 0x68, 0x53, 0xd4, 0xae, 0x1b, 0xdc, 0x90, 0x75, 0x85, 0xb9, 0xc3, + 0x10, 0x4d, 0xd4, 0x36, 0x3e, 0x0d, 0xd3, 0x2d, 0x97, 0x74, 0xed, 0xbd, 0xbe, 0xe7, 0xd9, 0x41, + 0x48, 0xeb, 0xb3, 0x5c, 0xc9, 0x73, 0xb1, 0x92, 0x6f, 0xba, 0xa4, 0x7b, 0xbb, 0xef, 0x79, 0xdb, + 0x21, 0xb5, 0x2a, 0xad, 0xe4, 0x83, 0xc9, 0x9c, 0xcd, 0x77, 0x98, 0x46, 0x03, 0x3b, 0x12, 0x43, + 0xbc, 0x3e, 0x27, 0x64, 0xee, 0x12, 0x8b, 0x81, 0xd5, 0xc0, 0x7f, 0x03, 0x2a, 0x28, 0x74, 0xe3, + 0x13, 0x9d, 0xf9, 0x21, 0xf3, 0xbb, 0xbe, 0xb3, 0xa9, 0xb6, 0x3c, 0x01, 0x85, 0x6e, 0x92, 0x49, + 0x54, 0x13, 0x1b, 0xa4, 0x34, 0xd6, 0xc3, 0x02, 0xd7, 0x43, 0x35, 0x06, 0x0b, 0x45, 0x7c, 0x16, + 0xc4, 0xdd, 0x33, 0x5b, 0x79, 0x97, 0x45, 0x3e, 0x32, 0xe6, 0xd7, 0xd4, 0x8d, 0xb4, 0x26, 0xfb, + 0xab, 0x5c, 0xcc, 0x14, 0x4d, 0x7d, 0x09, 0x5d, 0x73, 0x2e, 0x6d, 0x21, 0x98, 0x7a, 0x9d, 0x7b, + 0x81, 0x69, 0x09, 0x6d, 0x70, 0x20, 0x13, 0x39, 0xbf, 0x79, 0x22, 0x48, 0x96, 0x84, 0xf7, 0xa7, + 0x87, 0xbe, 0x44, 0xaf, 0xc2, 0xcc, 0x6e, 0x9f, 0x0c, 0x6c, 0xda, 0x89, 0x30, 0xe9, 0x04, 0x5e, + 0x8b, 0x99, 0xc0, 0x79, 0x1e, 0xfa, 0xd4, 0x18, 0xa2, 0xa9, 0xe0, 0x0f, 0x88, 0xf1, 0x01, 0xd4, + 0x63, 0xf5, 0x30, 0x86, 0xa3, 0xc0, 0x8b, 0x19, 0xbf, 0xc0, 0x19, 0xbf, 0x14, 0x4b, 0xc6, 0x92, + 0x84, 0x1b, 0x82, 0x4e, 0x75, 0x21, 0xbe, 0x5b, 0x97, 0x85, 0x1b, 0x97, 0xa0, 0xc2, 0x42, 0x93, + 0x90, 0xc9, 0xc2, 0x6d, 0xd5, 0x57, 0xc4, 0xcd, 0x29, 0x05, 0xda, 0x6c, 0x31, 0x91, 0xee, 0xf6, + 0x9d, 0x2e, 0xa6, 0x24, 0x56, 0xc6, 0x65, 0xde, 0x97, 0xaa, 0x04, 0x2b, 0xd9, 0xbf, 0x01, 0x15, + 0xc9, 0x22, 0xa1, 0x3d, 0x5a, 0x37, 0xa5, 0x6b, 0x52, 0x7c, 0x89, 0x6e, 0x37, 0x68, 0x8f, 0x5a, + 0x40, 0xe2, 0xdf, 0x3c, 0x01, 0xc2, 0xeb, 0xb3, 0x05, 0x01, 0x6b, 0xfe, 0x45, 0x99, 0x00, 0x21, + 0x20, 0x9b, 0xad, 0x77, 0x0b, 0xe5, 0x82, 0x5e, 0x7c, 0xb7, 0x50, 0x5e, 0xd6, 0xcf, 0xb3, 0x01, + 0x87, 0x5a, 0xf6, 0xa3, 0x7e, 0x10, 0xf5, 0x7b, 0xe6, 0x6f, 0x69, 0xb0, 0x30, 0xbe, 0xab, 0xc6, + 0x1a, 0xcc, 0x0e, 0x19, 0xb3, 0x8f, 0x7a, 0x58, 0x06, 0x89, 0x33, 0x19, 0x6b, 0xde, 0x42, 0x3d, + 0x6c, 0x7c, 0x0a, 0x4a, 0x21, 0xf6, 0x91, 0x47, 0x07, 0xd2, 0x9f, 0x5e, 0x5c, 0x1b, 0xb9, 0x88, + 0xb8, 0x11, 0xf8, 0xa4, 0xdf, 0x0b, 0x79, 0xda, 0x8a, 0xa2, 0x36, 0x5e, 0x81, 0x99, 0x60, 0x1f, + 0x47, 0x91, 0xdb, 0xc2, 0x76, 0xec, 0x28, 0xc5, 0xd9, 0xa3, 0xae, 0x10, 0x3b, 0x12, 0x6e, 0xfe, + 0x37, 0x0d, 0x20, 0x91, 0x41, 0x66, 0xb2, 0xd2, 0xb2, 0xa1, 0xca, 0x8b, 0x30, 0xed, 0x04, 0xbe, + 0x8f, 0x79, 0xce, 0x1b, 0x93, 0x8a, 0x3c, 0xf4, 0x4c, 0x80, 0x9b, 0x2d, 0x36, 0xd2, 0x99, 0x98, + 0x19, 0x5a, 0x66, 0x4d, 0xb2, 0xcf, 0xcd, 0x16, 0x3f, 0x32, 0xc5, 0x84, 0x69, 0xc4, 0x46, 0x9e, + 0x2b, 0x77, 0xa5, 0x26, 0xad, 0x29, 0x09, 0xbc, 0xce, 0x60, 0xe6, 0xf7, 0xf3, 0x50, 0x56, 0x41, + 0xc6, 0x48, 0x1e, 0xad, 0x36, 0x9a, 0x47, 0x7b, 0x19, 0xa6, 0x78, 0xe2, 0x5d, 0xf6, 0xe4, 0xa3, + 0xc2, 0x60, 0x4a, 0xfd, 0xa3, 0x93, 0x5f, 0x3a, 0x31, 0xb0, 0x90, 0x4d, 0x0c, 0x4c, 0xdf, 0xca, + 0x2a, 0x66, 0x6f, 0x65, 0x5d, 0x95, 0x39, 0x7e, 0x3c, 0x87, 0x5f, 0xcc, 0x3a, 0x95, 0xd8, 0x88, + 0xb6, 0x43, 0x91, 0xdd, 0xd7, 0x1c, 0x84, 0xd8, 0x78, 0x05, 0x0c, 0x4e, 0x99, 0x4d, 0x9f, 0x2e, + 0xf1, 0xea, 0x6a, 0x0c, 0x93, 0xba, 0xdd, 0x33, 0xf6, 0x92, 0x56, 0x79, 0xec, 0x25, 0xad, 0x91, + 0xeb, 0x11, 0x93, 0xa3, 0xd7, 0x23, 0x86, 0x2e, 0x72, 0xc1, 0xe8, 0x45, 0xae, 0xcf, 0xc2, 0x72, + 0xec, 0xdb, 0x69, 0x60, 0x7b, 0x88, 0x50, 0xc5, 0x64, 0x4f, 0xdd, 0xb8, 0x58, 0x50, 0x14, 0xcd, + 0xe0, 0x3e, 0x22, 0x54, 0xf0, 0xfa, 0xe0, 0xf8, 0x63, 0xe6, 0xbf, 0x2a, 0x40, 0x59, 0x05, 0xcf, + 0xa9, 0x28, 0x52, 0x3b, 0x26, 0x8a, 0x34, 0x2e, 0xb0, 0xd0, 0x82, 0x46, 0x03, 0xb4, 0xeb, 0x61, + 0x19, 0xb9, 0x24, 0x00, 0x16, 0xd3, 0xa0, 0xdd, 0x20, 0xa2, 0x72, 0x6f, 0x53, 0x7c, 0x18, 0xeb, + 0x50, 0x56, 0x57, 0x1a, 0x46, 0x4e, 0xff, 0xdf, 0x8f, 0x5c, 0x8a, 0xd5, 0x9d, 0x06, 0x2b, 0xa6, + 0x63, 0xce, 0x15, 0x79, 0x6c, 0xb0, 0x0e, 0x64, 0xa6, 0x6d, 0x51, 0x3a, 0xd7, 0xd8, 0x7b, 0x0b, + 0x2c, 0x4f, 0xb6, 0xb5, 0xa6, 0x50, 0xea, 0xcb, 0x78, 0x15, 0xca, 0xea, 0x92, 0xf0, 0x48, 0x86, + 0xe7, 0x4d, 0x89, 0xb0, 0x62, 0x12, 0xe3, 0x26, 0xcc, 0xc4, 0x8a, 0xb2, 0xf1, 0x61, 0xe8, 0x46, + 0xb8, 0x25, 0x73, 0x3c, 0xeb, 0x99, 0x58, 0x85, 0xa9, 0xed, 0x96, 0xc0, 0x5b, 0x35, 0x27, 0x0b, + 0x60, 0x13, 0x1a, 0x93, 0x76, 0x72, 0x2e, 0x54, 0xe6, 0x35, 0xcc, 0xa5, 0xd3, 0x03, 0xb6, 0xe4, + 0x19, 0x91, 0x55, 0xa1, 0xc9, 0x87, 0x71, 0x17, 0x66, 0x93, 0xf6, 0x69, 0xc0, 0x14, 0x1d, 0xb5, + 0xc5, 0xc5, 0x9c, 0xca, 0xfa, 0xd2, 0x08, 0x07, 0xcd, 0x20, 0xb8, 0xcf, 0x08, 0x2c, 0xdd, 0x19, + 0x82, 0x18, 0x1b, 0xa0, 0x27, 0xf7, 0xf6, 0xf6, 0x90, 0xeb, 0xe1, 0x16, 0x0f, 0x5c, 0xd2, 0x1d, + 0x89, 0x2f, 0xee, 0xdd, 0xe6, 0x78, 0x2b, 0xb9, 0xe9, 0x27, 0x00, 0xac, 0x12, 0x35, 0x94, 0x7b, + 0x2e, 0xe9, 0x21, 0xea, 0x74, 0xb8, 0xad, 0xa5, 0x2b, 0x91, 0xe9, 0xc4, 0x0f, 0x24, 0xde, 0xaa, + 0x85, 0x59, 0x80, 0xf9, 0xe7, 0x39, 0x98, 0xce, 0xa8, 0xf6, 0x28, 0x67, 0x75, 0x09, 0x2a, 0xe9, + 0x2b, 0x2f, 0x32, 0x57, 0xc6, 0x49, 0x2e, 0xba, 0x8c, 0xfa, 0x85, 0x3a, 0x94, 0x54, 0xa6, 0xb3, + 0x38, 0x0a, 0x55, 0x9f, 0x2c, 0x0c, 0x89, 0x2b, 0x4b, 0xc6, 0x9f, 0x70, 0x10, 0xba, 0xc2, 0xc4, + 0x83, 0xf0, 0x4d, 0x98, 0x88, 0x30, 0x22, 0x81, 0x2f, 0xdd, 0xc4, 0xc5, 0xf1, 0x86, 0xb9, 0x66, + 0x71, 0x22, 0x4b, 0x12, 0x9b, 0x07, 0x30, 0x21, 0x20, 0x46, 0x05, 0x4a, 0xef, 0xf9, 0x5d, 0x3f, + 0x38, 0xf0, 0xf5, 0x73, 0x46, 0x15, 0x60, 0x3b, 0xa4, 0x32, 0x37, 0x5b, 0xd7, 0x8c, 0x39, 0xd0, + 0xd3, 0xd7, 0x2b, 0xd8, 0x30, 0xd1, 0x73, 0x86, 0x01, 0xd5, 0x06, 0xf6, 0xf6, 0xac, 0xc0, 0xf3, + 0x70, 0xeb, 0x06, 0x72, 0xba, 0x7a, 0xde, 0x98, 0x86, 0x49, 0xcb, 0x11, 0x89, 0xd7, 0x44, 0x2f, + 0x18, 0x8b, 0x30, 0x7b, 0x1f, 0x7d, 0x65, 0xf0, 0x9e, 0xef, 0x3e, 0xea, 0x63, 0x1f, 0x13, 0xc2, + 0x51, 0x7a, 0xd1, 0x5c, 0x81, 0xa9, 0xb4, 0xe1, 0x2b, 0xc9, 0x68, 0xc9, 0x8a, 0xec, 0x07, 0x1a, + 0x94, 0x95, 0x91, 0xa7, 0xf3, 0xe2, 0xb5, 0x4c, 0x5e, 0xbc, 0xf2, 0xab, 0xc9, 0x72, 0x8e, 0x13, + 0xde, 0xc3, 0x03, 0x16, 0x54, 0xa8, 0xa1, 0xc1, 0xd0, 0x76, 0x07, 0x91, 0x8e, 0x9c, 0x1f, 0x6a, + 0x0a, 0x71, 0x0f, 0x0f, 0xee, 0x22, 0xd2, 0x31, 0xde, 0x04, 0xe0, 0x17, 0xcd, 0x9c, 0x0e, 0x72, + 0x7d, 0xb9, 0x8a, 0x5f, 0x58, 0x8b, 0x6f, 0xe8, 0xbf, 0x8f, 0x5c, 0x7a, 0x3b, 0x88, 0x6e, 0xf9, + 0x2c, 0x28, 0x9b, 0x64, 0x94, 0x1b, 0x8c, 0x90, 0x4d, 0x05, 0xe9, 0x26, 0x64, 0x36, 0x53, 0x25, + 0x55, 0xbb, 0xf9, 0x0d, 0x0d, 0x6a, 0x43, 0x63, 0xee, 0x28, 0x13, 0x5a, 0x83, 0x59, 0x44, 0x29, + 0xee, 0x85, 0x2c, 0x68, 0x4b, 0xd4, 0x2e, 0x4c, 0x69, 0x26, 0x46, 0xc5, 0x7a, 0x1f, 0xb5, 0xa8, + 0x11, 0x97, 0x5d, 0x18, 0x71, 0xd9, 0xe6, 0x26, 0x54, 0x52, 0xa3, 0xf8, 0x18, 0x93, 0x3e, 0xf2, + 0xc6, 0x82, 0x79, 0x0d, 0xf4, 0xe1, 0x01, 0x9d, 0x3d, 0xab, 0xd7, 0x86, 0xce, 0xea, 0xff, 0x58, + 0x83, 0xda, 0xd0, 0xd8, 0x3d, 0x8a, 0x81, 0xd1, 0x53, 0xb5, 0x4f, 0xc2, 0x64, 0x3c, 0xd4, 0x79, + 0xc7, 0xab, 0xeb, 0xc6, 0xa8, 0x57, 0xb0, 0x12, 0x22, 0x66, 0x09, 0xdc, 0xf7, 0xba, 0x7e, 0x7b, + 0xf8, 0xfa, 0x44, 0x4d, 0x21, 0xd4, 0x05, 0x8a, 0x4f, 0x80, 0x11, 0xd3, 0x8e, 0x0c, 0x3b, 0x85, + 0x89, 0x05, 0x79, 0x1d, 0x6a, 0x43, 0x2e, 0x24, 0x9b, 0x97, 0xaf, 0x1d, 0x9b, 0x97, 0x6f, 0xfe, + 0x89, 0x06, 0xc0, 0xd6, 0x61, 0x22, 0x0b, 0xc9, 0xf8, 0x38, 0xcc, 0x70, 0x4b, 0x3c, 0x40, 0x9e, + 0x27, 0x96, 0x6d, 0x3d, 0x25, 0x93, 0x2a, 0x43, 0xbc, 0x8f, 0x3c, 0x8f, 0x91, 0x3f, 0x20, 0xc6, + 0x35, 0x98, 0x0b, 0xa3, 0xc0, 0xc1, 0x84, 0x64, 0xa9, 0xa5, 0xb1, 0x48, 0x5c, 0xaa, 0xc0, 0x1a, + 0xcc, 0x75, 0xf7, 0xf9, 0xaa, 0x27, 0x5b, 0x40, 0x86, 0x69, 0xdd, 0x7d, 0xb6, 0xfe, 0x49, 0xd1, + 0xaf, 0xc3, 0x02, 0x0d, 0x28, 0xf2, 0xec, 0x28, 0x74, 0x52, 0x25, 0x7c, 0x25, 0x3c, 0x83, 0x63, + 0xad, 0xd0, 0x51, 0x65, 0xb6, 0x88, 0xf9, 0x77, 0x39, 0x98, 0x4a, 0xba, 0xf3, 0x70, 0x7d, 0x4c, + 0x87, 0xfc, 0xb1, 0x1d, 0xda, 0x7a, 0x4c, 0x87, 0xfc, 0xc7, 0x75, 0x68, 0x8b, 0x18, 0x6f, 0xc3, + 0x05, 0x55, 0x80, 0xf4, 0x49, 0x88, 0xfd, 0x56, 0xb6, 0xa0, 0xe8, 0x58, 0x5d, 0xd2, 0x34, 0x04, + 0x49, 0xaa, 0xfc, 0x58, 0x81, 0xc4, 0xdd, 0x1b, 0x12, 0xc8, 0xd6, 0x51, 0x02, 0x29, 0x3e, 0x4e, + 0x20, 0xc6, 0x1b, 0xb0, 0xd8, 0xdd, 0xb7, 0xdb, 0xac, 0x84, 0xe2, 0x55, 0x15, 0x12, 0x69, 0x2c, + 0xb3, 0xdd, 0xfd, 0x3b, 0x51, 0xe8, 0xec, 0x08, 0x64, 0x86, 0xb3, 0xb6, 0x68, 0x47, 0xde, 0x80, + 0xb5, 0x7d, 0x15, 0xd1, 0xe9, 0xa2, 0xc8, 0xfb, 0xf2, 0x1e, 0xec, 0x16, 0x31, 0xbf, 0x08, 0x65, + 0xb6, 0x44, 0xe7, 0x31, 0xec, 0x1c, 0x14, 0x39, 0x1f, 0x5c, 0xca, 0x79, 0x4b, 0x7c, 0xb0, 0x80, + 0x47, 0xb6, 0x8f, 0x45, 0x14, 0x9d, 0xb7, 0x12, 0x40, 0xbc, 0x3d, 0xb7, 0x3b, 0xa0, 0x58, 0xc8, + 0x2d, 0x2f, 0xb6, 0xe7, 0x6e, 0x30, 0x80, 0xf9, 0x9f, 0x58, 0xc0, 0xee, 0x20, 0x5f, 0x1a, 0xe9, + 0xcb, 0x50, 0xe4, 0xd7, 0xb6, 0x47, 0xec, 0x5b, 0xf1, 0x60, 0x09, 0xbc, 0x71, 0x05, 0x0a, 0xf1, + 0x75, 0xb4, 0xb1, 0x74, 0x1c, 0xcd, 0xc8, 0x5a, 0x88, 0xa2, 0x91, 0xbd, 0xb1, 0x84, 0x8c, 0xa1, + 0xcd, 0x7f, 0x28, 0x8a, 0x87, 0x2b, 0x62, 0xdb, 0x7a, 0x15, 0x8c, 0xb8, 0x0b, 0x2a, 0x1e, 0x57, + 0xc6, 0x35, 0x13, 0x63, 0x64, 0x54, 0x4e, 0x8c, 0xb7, 0x60, 0x71, 0x94, 0x3c, 0xfd, 0x1c, 0xc2, + 0xfc, 0x48, 0x19, 0x1e, 0x86, 0x5f, 0x81, 0xaa, 0x50, 0x7b, 0xdc, 0x84, 0x4c, 0xc8, 0xe7, 0xd0, + 0xb8, 0xfa, 0x2f, 0xc0, 0x85, 0x88, 0x2d, 0xa8, 0x5b, 0xbb, 0x76, 0x8b, 0x9f, 0x60, 0xda, 0xa4, + 0xeb, 0x86, 0x21, 0x77, 0xe4, 0x7d, 0x9f, 0x4a, 0x6b, 0x5c, 0x92, 0x34, 0xe2, 0x90, 0xb3, 0x21, + 0x28, 0x36, 0x18, 0x81, 0xf1, 0x19, 0x50, 0x48, 0x3e, 0x61, 0x65, 0x4b, 0x0b, 0x9b, 0x5c, 0x90, + 0x04, 0xf7, 0xf0, 0x20, 0x53, 0xf4, 0x1d, 0xb8, 0xa8, 0x8a, 0xee, 0x72, 0xf7, 0xc3, 0x37, 0x8c, + 0xec, 0x0e, 0x9b, 0xd3, 0x78, 0xf1, 0x62, 0xa6, 0xf1, 0x1b, 0x8c, 0x86, 0xef, 0x1f, 0xdd, 0x75, + 0xa9, 0xa8, 0xe1, 0x53, 0x50, 0xcf, 0xd6, 0xc0, 0xed, 0x41, 0x14, 0x16, 0x86, 0x3a, 0x9f, 0x2e, + 0xcc, 0x46, 0x86, 0x28, 0xf8, 0x26, 0x2c, 0x8e, 0x29, 0xc8, 0x0c, 0x49, 0x5a, 0xeb, 0xdc, 0x70, + 0x39, 0x66, 0x53, 0x8f, 0x69, 0xcf, 0x47, 0x7e, 0xa0, 0x56, 0x19, 0x23, 0xed, 0x6d, 0x31, 0x24, + 0xf3, 0xd0, 0x6d, 0x4c, 0x6d, 0xe2, 0xa3, 0x90, 0x74, 0x02, 0x2a, 0x8b, 0x88, 0xb7, 0x28, 0xf4, + 0x36, 0xa6, 0x0d, 0x89, 0x10, 0xd4, 0x4c, 0x30, 0xf1, 0xbe, 0x33, 0x1b, 0x81, 0x61, 0x40, 0xb0, + 0x18, 0x53, 0xa2, 0x60, 0x45, 0x0a, 0x46, 0x6d, 0x45, 0xef, 0x08, 0x12, 0x36, 0xb6, 0xc6, 0xd5, + 0xc0, 0x22, 0x2f, 0x37, 0xea, 0xa5, 0x6b, 0x98, 0x1a, 0xaa, 0x61, 0x43, 0x90, 0x8c, 0xd6, 0x10, + 0x06, 0x81, 0x67, 0x13, 0xa7, 0x83, 0x5b, 0x7d, 0x2f, 0xc3, 0xc3, 0x74, 0x52, 0xc3, 0x4e, 0x10, + 0x78, 0x0d, 0x49, 0x12, 0xd7, 0x60, 0xfe, 0x17, 0x0d, 0x2a, 0xa9, 0xcc, 0x55, 0xe3, 0x0d, 0xa8, + 0x70, 0x8f, 0x20, 0x12, 0x5d, 0xe5, 0x30, 0x4c, 0xf6, 0x17, 0x12, 0x07, 0x6c, 0x01, 0x4d, 0xe6, + 0x96, 0x37, 0xa0, 0xc2, 0xb7, 0xf7, 0x64, 0xa9, 0xdc, 0xf0, 0xae, 0x44, 0x3c, 0xb4, 0x2c, 0x20, + 0xf1, 0x6f, 0x91, 0x9b, 0x2f, 0x36, 0x1f, 0xcc, 0x7f, 0xd4, 0x60, 0x3a, 0x93, 0x41, 0x7b, 0x4a, + 0x4e, 0x3e, 0x07, 0xd5, 0x14, 0x27, 0xf6, 0xfe, 0xba, 0x64, 0x66, 0x7e, 0x0c, 0x33, 0x0f, 0xd7, + 0xad, 0x29, 0x92, 0x1e, 0xf5, 0x9f, 0x82, 0x29, 0xee, 0x5d, 0x54, 0x9b, 0xf9, 0xa1, 0x05, 0x0a, + 0x8f, 0x78, 0x65, 0xa3, 0x95, 0x83, 0xe4, 0x83, 0xb5, 0x9a, 0xe2, 0x35, 0xc9, 0xe1, 0x9e, 0x1f, + 0xc3, 0x2e, 0x6b, 0x95, 0xa6, 0xbe, 0xcc, 0xaf, 0x96, 0xa0, 0x92, 0xaa, 0xd9, 0x78, 0x1d, 0x16, + 0x08, 0x0d, 0x22, 0x6c, 0xef, 0xb2, 0x69, 0x3f, 0xad, 0x4d, 0xe1, 0x7f, 0x66, 0x39, 0x96, 0x1f, + 0xca, 0x27, 0x96, 0xf0, 0x26, 0xf7, 0x40, 0xdc, 0x04, 0x89, 0x98, 0xad, 0xe2, 0x52, 0xc2, 0xa5, + 0xcc, 0x49, 0x74, 0x83, 0x4f, 0x54, 0xaa, 0xd8, 0x2a, 0xcc, 0x84, 0xcc, 0xcb, 0xf0, 0xa7, 0x12, + 0xda, 0xb2, 0x80, 0x0c, 0x65, 0x25, 0xe2, 0x7e, 0xd0, 0x16, 0xb4, 0x1b, 0x70, 0x29, 0x42, 0x7b, + 0xd4, 0x6e, 0xed, 0xda, 0x42, 0x4a, 0x1e, 0x46, 0x2d, 0x1c, 0xa5, 0x9b, 0x12, 0xae, 0x64, 0x99, + 0x91, 0xdd, 0xdc, 0xe5, 0x7d, 0xba, 0xcf, 0x69, 0x92, 0x06, 0xd7, 0x61, 0x41, 0x55, 0xa2, 0x36, + 0x97, 0x65, 0x59, 0x39, 0xd1, 0x89, 0xb2, 0x0d, 0xb1, 0xd1, 0x2c, 0xca, 0xbc, 0x0d, 0x17, 0xb2, + 0x0d, 0xf7, 0x70, 0x8f, 0xb2, 0xd5, 0xb4, 0x2c, 0x29, 0x9c, 0x48, 0x3d, 0xd5, 0xea, 0x03, 0x49, + 0x20, 0xca, 0x5f, 0x05, 0xb9, 0x10, 0x4c, 0xb5, 0x26, 0x1c, 0x88, 0xdc, 0xb0, 0x8c, 0x5b, 0x7a, + 0x1d, 0x16, 0x50, 0x18, 0x7a, 0x83, 0x51, 0xd1, 0x0b, 0x37, 0x3e, 0xcb, 0xb1, 0x43, 0xa2, 0x7f, + 0x09, 0x6a, 0xa2, 0x50, 0x52, 0xfb, 0xa4, 0xbc, 0xd9, 0xcc, 0xc0, 0xa3, 0x95, 0xf7, 0xfa, 0x14, + 0x1f, 0x8a, 0x6b, 0xd0, 0x69, 0x17, 0x23, 0x2a, 0x7f, 0xc0, 0x90, 0x2c, 0x9a, 0x8b, 0x47, 0xb8, + 0x28, 0xf4, 0x38, 0x91, 0x4b, 0x2f, 0xc3, 0x89, 0xc6, 0x4a, 0xfc, 0x35, 0x98, 0x4f, 0xd7, 0x70, + 0x80, 0xbc, 0x8c, 0x77, 0x31, 0x92, 0x92, 0xef, 0x23, 0x4f, 0x14, 0xf9, 0x1c, 0x2c, 0xa7, 0x8b, + 0x0c, 0x89, 0x5b, 0xf8, 0x94, 0xc5, 0xa4, 0xdc, 0x88, 0xb4, 0xbd, 0x61, 0xe9, 0x89, 0x4d, 0xf7, + 0xaa, 0x97, 0x15, 0xdc, 0x8b, 0x30, 0xad, 0x02, 0x17, 0x41, 0x26, 0x37, 0xdb, 0x25, 0x50, 0x10, + 0xb1, 0x29, 0xb2, 0x13, 0x05, 0x94, 0xc6, 0xed, 0xeb, 0x72, 0x8a, 0x94, 0x50, 0x41, 0xf6, 0x6f, + 0xe0, 0xfc, 0xf0, 0xb5, 0xe0, 0x34, 0x03, 0x33, 0x32, 0x5e, 0x1b, 0x7e, 0xf8, 0x42, 0xb9, 0xc1, + 0x0f, 0x60, 0x42, 0x64, 0xa2, 0x24, 0x09, 0xf1, 0xda, 0x31, 0x57, 0x02, 0x4e, 0x98, 0xb0, 0x69, + 0x7e, 0x55, 0x83, 0xb2, 0xba, 0x8c, 0x67, 0x9c, 0x87, 0x5c, 0x10, 0xca, 0x47, 0x33, 0x32, 0x1b, + 0x6e, 0xb9, 0x20, 0x3c, 0x71, 0x0a, 0x68, 0x66, 0x9d, 0x52, 0x38, 0xc1, 0x3a, 0xc5, 0xfc, 0x69, + 0x0e, 0x26, 0x1f, 0xec, 0x3b, 0x0e, 0x57, 0x97, 0x71, 0x29, 0xf3, 0x76, 0x47, 0x86, 0x0d, 0xf1, + 0x42, 0xc7, 0x11, 0x27, 0xbc, 0xe7, 0x47, 0xde, 0xa9, 0x48, 0xdd, 0x41, 0xbd, 0x04, 0x15, 0xd2, + 0x09, 0x22, 0x6a, 0xa7, 0x5e, 0xaa, 0xb0, 0x80, 0x83, 0xf8, 0xab, 0x28, 0x2c, 0x4e, 0xea, 0x20, + 0x62, 0x07, 0xfb, 0x38, 0xf2, 0x10, 0x0f, 0x41, 0xd4, 0xbd, 0x70, 0x99, 0xa6, 0x39, 0xdf, 0x41, + 0x64, 0x3b, 0xc6, 0xaa, 0xfb, 0x50, 0xc6, 0x0a, 0x4c, 0xb1, 0x72, 0x6d, 0xc7, 0xde, 0xe3, 0xef, + 0x83, 0x88, 0x34, 0x25, 0xe8, 0x20, 0x72, 0xc7, 0xb9, 0xcd, 0x1f, 0x08, 0x59, 0x82, 0x72, 0x8c, + 0x15, 0x63, 0xbb, 0xd4, 0x96, 0xa8, 0x8f, 0x41, 0x95, 0x6f, 0x0c, 0x3a, 0x1d, 0xe4, 0xb7, 0xf9, + 0xee, 0xa5, 0x18, 0xcc, 0x53, 0x0c, 0xba, 0xc1, 0x81, 0x7c, 0x9f, 0x63, 0x31, 0x0e, 0xdc, 0xd4, + 0x56, 0xa2, 0x28, 0x21, 0x47, 0xf3, 0x9c, 0x42, 0x8b, 0x7d, 0x44, 0x51, 0xd0, 0xfc, 0xbc, 0x10, + 0xac, 0xe8, 0xde, 0x11, 0xab, 0xcd, 0xb1, 0x8f, 0x9e, 0x98, 0xdf, 0xc9, 0x43, 0x99, 0x15, 0xe7, + 0xdb, 0xbf, 0x4f, 0xa3, 0x96, 0xd4, 0x6e, 0x4f, 0x3e, 0xbb, 0xdb, 0x73, 0xac, 0x4e, 0x46, 0x13, + 0x88, 0x4f, 0xf2, 0xc8, 0x4e, 0x7a, 0x6f, 0xb9, 0x34, 0xbc, 0xb7, 0x7c, 0xd2, 0x4d, 0xe0, 0xa1, + 0x0d, 0xde, 0xc9, 0xd1, 0x0d, 0xde, 0x4b, 0x50, 0x89, 0x9f, 0x15, 0xa0, 0x62, 0x0b, 0xb8, 0x60, + 0x81, 0x02, 0x35, 0xc9, 0x18, 0xe5, 0x56, 0x9e, 0x4c, 0xb9, 0x53, 0x47, 0x28, 0xf7, 0x6b, 0x9a, + 0x50, 0x0f, 0x5f, 0xfc, 0xa8, 0x15, 0x87, 0x36, 0xe6, 0x94, 0x99, 0x27, 0xcc, 0x88, 0x15, 0xc7, + 0x2a, 0x4c, 0x70, 0xaf, 0xa9, 0x32, 0x63, 0x8c, 0x0c, 0x21, 0x1f, 0x80, 0x96, 0xa4, 0x60, 0xb4, + 0xf2, 0xe5, 0x96, 0xfc, 0x18, 0x5a, 0xae, 0x1e, 0xf5, 0x9a, 0x8b, 0xd9, 0x80, 0x92, 0xbc, 0x3e, + 0xc5, 0x35, 0x76, 0xe8, 0x4b, 0x0b, 0x63, 0x3f, 0x8d, 0x05, 0x98, 0x20, 0xfc, 0x2d, 0x02, 0x69, + 0x17, 0xf2, 0xeb, 0xd8, 0x3d, 0xee, 0x77, 0xf8, 0x16, 0x37, 0x4f, 0xcc, 0xc8, 0xa6, 0x0d, 0x69, + 0x8f, 0x4f, 0x9a, 0xcb, 0x65, 0x92, 0xe6, 0xfe, 0x48, 0x03, 0x10, 0x33, 0x0e, 0x67, 0xed, 0xc8, + 0x73, 0xf5, 0x45, 0x28, 0x85, 0x58, 0x1c, 0x41, 0x49, 0x36, 0xd9, 0xe7, 0x66, 0x2b, 0x3e, 0x16, + 0xcf, 0xa7, 0x8e, 0xc5, 0x87, 0x0f, 0xe1, 0x0b, 0x27, 0x3c, 0x84, 0x7f, 0x4d, 0xae, 0x37, 0x99, + 0x04, 0xb0, 0xdc, 0x13, 0x37, 0x52, 0xe7, 0x76, 0xa8, 0xd5, 0x60, 0x18, 0xb1, 0x06, 0xe5, 0x3f, + 0xcd, 0x4d, 0x98, 0x8c, 0xe1, 0xa3, 0x27, 0xc0, 0xda, 0xf8, 0x13, 0x60, 0x7e, 0x2b, 0x8b, 0x26, + 0x02, 0x47, 0x7b, 0xb8, 0xc9, 0xb4, 0x64, 0x88, 0x2c, 0x37, 0x2e, 0x12, 0x75, 0xcc, 0xfa, 0x6a, + 0x92, 0xc7, 0x23, 0xae, 0x69, 0x27, 0x61, 0x6c, 0x22, 0xbb, 0x24, 0x99, 0xa7, 0x0a, 0xb9, 0xb8, + 0xe2, 0x1c, 0x25, 0xe6, 0x17, 0x60, 0x36, 0x53, 0xa9, 0xcc, 0xa8, 0xa8, 0x67, 0x6b, 0x2d, 0x3c, + 0xbe, 0x82, 0x9b, 0x60, 0x34, 0x58, 0xcc, 0xd8, 0x60, 0x4c, 0x36, 0x14, 0x57, 0x6b, 0x30, 0xc9, + 0x16, 0x83, 0x3c, 0x1f, 0x67, 0xdc, 0x6c, 0x27, 0xf2, 0x75, 0xca, 0x5d, 0xf9, 0xcb, 0x5c, 0x83, + 0xd9, 0x4c, 0x2d, 0x92, 0x8d, 0x94, 0x2c, 0xb4, 0x8c, 0x2c, 0x1c, 0x9e, 0x0e, 0x7b, 0x07, 0x33, + 0x03, 0x6a, 0x36, 0xef, 0x3f, 0x9b, 0xab, 0x2d, 0xff, 0x43, 0xe3, 0x29, 0xaa, 0xa9, 0x56, 0x9e, + 0x41, 0xbe, 0x49, 0xf2, 0xe8, 0x06, 0xf7, 0x8f, 0x47, 0x5e, 0x6e, 0xf9, 0x99, 0xb8, 0x05, 0xb2, + 0x71, 0xbd, 0xf1, 0x2c, 0x6f, 0x81, 0x7c, 0x02, 0x8c, 0x30, 0xc2, 0xfb, 0x6e, 0xd0, 0x27, 0xa9, + 0xb7, 0x56, 0x04, 0x2f, 0xba, 0xc2, 0xc4, 0x2f, 0xad, 0x5c, 0x81, 0x6a, 0x4c, 0x2d, 0x2a, 0x13, + 0xfb, 0xc9, 0xd3, 0x0a, 0xfa, 0x30, 0x75, 0xb5, 0x64, 0x62, 0xf8, 0x6a, 0x49, 0x29, 0xee, 0xb9, + 0xf9, 0xa1, 0x48, 0x85, 0xe7, 0x9d, 0x3b, 0x6b, 0x39, 0xd7, 0xa1, 0x44, 0xfa, 0x8e, 0x83, 0x65, + 0xa6, 0x56, 0xd9, 0x52, 0x9f, 0xcf, 0xa4, 0xb3, 0xe6, 0x4d, 0x58, 0xb8, 0x83, 0xa9, 0x8a, 0x02, + 0xf9, 0x00, 0x7c, 0x72, 0x7d, 0x99, 0xdf, 0xd4, 0x60, 0x71, 0xa4, 0x9a, 0xb3, 0x96, 0xcc, 0x27, + 0x99, 0xf3, 0xa5, 0x7c, 0x8a, 0xcc, 0x1f, 0x79, 0x80, 0xa0, 0xc8, 0xcc, 0x3b, 0xb0, 0x94, 0xe2, + 0xea, 0xae, 0xcb, 0x56, 0x8c, 0xa7, 0xc9, 0x67, 0x33, 0xbf, 0xa5, 0xc1, 0xf2, 0xb8, 0x9a, 0x7e, + 0xf5, 0x5d, 0xfc, 0xa1, 0xb8, 0x5c, 0xb0, 0x11, 0xc8, 0xd5, 0x42, 0x10, 0x9d, 0x32, 0x53, 0xdc, + 0x09, 0xc2, 0x48, 0xe4, 0x2e, 0x08, 0x8e, 0xca, 0x0c, 0xc0, 0x53, 0x16, 0xf8, 0xba, 0x31, 0x8c, + 0xd4, 0xe6, 0x9c, 0x1d, 0xe1, 0x47, 0xd2, 0xf3, 0x54, 0x19, 0x3c, 0xb9, 0xde, 0x98, 0xca, 0x7b, + 0x2c, 0x1c, 0x97, 0xb6, 0x6f, 0xc8, 0x1d, 0x49, 0x61, 0x94, 0x62, 0xfb, 0xb1, 0xcf, 0x2f, 0x27, + 0x64, 0xba, 0x72, 0xd6, 0x02, 0x36, 0x52, 0x1b, 0xa1, 0xaa, 0xd9, 0xef, 0x8a, 0x4b, 0x5b, 0x7c, + 0x6e, 0x21, 0xfd, 0xde, 0x69, 0xe4, 0xf7, 0x69, 0x98, 0x44, 0x5e, 0x3b, 0x88, 0x5c, 0xda, 0xe9, + 0xf1, 0x06, 0xab, 0xeb, 0xcb, 0x09, 0xb5, 0xac, 0xf8, 0xba, 0xa2, 0xb0, 0x12, 0xe2, 0x27, 0x49, + 0x15, 0xfd, 0x3d, 0x71, 0xb1, 0x22, 0xe1, 0xf3, 0xac, 0x85, 0xb3, 0x0c, 0x65, 0x47, 0x56, 0x1e, + 0xaf, 0x69, 0xe4, 0x37, 0xb3, 0x10, 0xb1, 0x45, 0xdb, 0xdd, 0x8f, 0x1f, 0xdd, 0xe1, 0x80, 0x7b, + 0xfb, 0x3c, 0x3c, 0x15, 0x48, 0xb1, 0xbb, 0x2d, 0x62, 0x68, 0xe0, 0x20, 0xb1, 0xbd, 0xfd, 0xff, + 0xf2, 0x30, 0xb5, 0x11, 0xf4, 0x42, 0xe4, 0x50, 0xc1, 0xc0, 0x07, 0x30, 0x8f, 0xa3, 0xc8, 0x76, + 0xfd, 0x7d, 0xe4, 0xb9, 0x2d, 0x3b, 0x1b, 0x71, 0x55, 0xd6, 0x3f, 0x96, 0x3e, 0xcc, 0x8e, 0x4b, + 0x6d, 0x0a, 0xea, 0x86, 0x8c, 0xc6, 0xee, 0x9e, 0xb3, 0x0c, 0x1c, 0x0d, 0x43, 0x0d, 0x0f, 0x2e, + 0xb0, 0xaa, 0x43, 0x99, 0xc8, 0x6d, 0xcb, 0x35, 0x7b, 0xec, 0x30, 0xc5, 0x46, 0xd8, 0xea, 0xd8, + 0x16, 0x54, 0xf6, 0x77, 0x93, 0xaf, 0xe3, 0xa5, 0x2b, 0xbd, 0x7b, 0xce, 0xaa, 0xe3, 0x68, 0x3c, + 0xce, 0xb0, 0x61, 0x91, 0xb5, 0xe6, 0x88, 0x4a, 0x6c, 0xd7, 0xb7, 0xc3, 0x28, 0x68, 0x47, 0x98, + 0x10, 0xb9, 0x6d, 0xf6, 0xd2, 0xd8, 0x86, 0xe4, 0xef, 0x4d, 0x7f, 0x47, 0x52, 0xdf, 0x3d, 0x67, + 0xcd, 0xe1, 0x68, 0x14, 0x6e, 0xec, 0xc1, 0x32, 0x6b, 0x80, 0x06, 0x81, 0xdd, 0x43, 0xfe, 0xc0, + 0x0e, 0xb1, 0xdf, 0x72, 0xfd, 0xb6, 0x4d, 0x11, 0xe9, 0x12, 0x19, 0x0e, 0x5e, 0x1d, 0xdb, 0x46, + 0x33, 0x08, 0x1e, 0x20, 0x7f, 0xb0, 0x23, 0x0a, 0x34, 0x19, 0xfd, 0xdd, 0x73, 0xd6, 0x02, 0x8e, + 0xc6, 0x61, 0x6e, 0x94, 0xa4, 0x49, 0x98, 0x17, 0xe1, 0xfc, 0x11, 0x42, 0x37, 0x5f, 0x84, 0xcb, + 0xc7, 0x4a, 0xcc, 0xbc, 0x04, 0x17, 0x8f, 0xec, 0xad, 0x79, 0x19, 0x2e, 0x1d, 0xc3, 0x2a, 0x8b, + 0x20, 0xaa, 0x92, 0x46, 0x0d, 0xc9, 0x23, 0x63, 0xf3, 0x55, 0x98, 0x19, 0xd2, 0xb9, 0xab, 0xce, + 0x61, 0x6a, 0x61, 0x9a, 0xcb, 0xcd, 0x16, 0xdf, 0x9c, 0x09, 0xda, 0x59, 0x52, 0x71, 0x26, 0x53, + 0x95, 0x70, 0x45, 0x39, 0x94, 0x1a, 0x58, 0x3a, 0x59, 0x6a, 0xe0, 0x50, 0xa2, 0x5b, 0x79, 0x38, + 0xd1, 0xcd, 0xfc, 0x43, 0x71, 0x6a, 0x2d, 0x3a, 0x27, 0xc7, 0xf1, 0x2b, 0xd9, 0x2d, 0x97, 0xf9, + 0xb1, 0x4a, 0x55, 0x63, 0xf5, 0x45, 0x98, 0xee, 0x20, 0x62, 0x47, 0xb8, 0x87, 0x5c, 0xdf, 0xf5, + 0xdb, 0xf2, 0x66, 0xc8, 0x54, 0x07, 0x11, 0x4b, 0xc1, 0x8c, 0x35, 0x9e, 0x30, 0xc2, 0xca, 0xe2, + 0xf4, 0x18, 0x13, 0xce, 0x6f, 0x26, 0x46, 0x35, 0x52, 0x22, 0x4c, 0xe8, 0xb3, 0x37, 0xc8, 0x6b, + 0x31, 0xe2, 0x96, 0x58, 0xf1, 0xbc, 0x0a, 0x4b, 0x4d, 0x97, 0x5f, 0x0a, 0x6f, 0x0c, 0x08, 0xc5, + 0x3d, 0x2e, 0x30, 0xa5, 0x28, 0x1d, 0xf2, 0xe4, 0x91, 0x27, 0xb3, 0xe0, 0xd8, 0x4f, 0x33, 0x84, + 0xe5, 0x71, 0xe4, 0xb2, 0xeb, 0x96, 0x74, 0xcb, 0x5c, 0xa7, 0x37, 0xde, 0xfe, 0xf0, 0xe7, 0x97, + 0xce, 0xfd, 0xec, 0xe7, 0x97, 0xde, 0x6a, 0xbb, 0xb4, 0xd3, 0xdf, 0x5d, 0x73, 0x82, 0xde, 0xb5, + 0xd0, 0xf5, 0xdb, 0x0e, 0x0a, 0xaf, 0x75, 0xf7, 0xc5, 0xcb, 0xff, 0x61, 0xb7, 0x7d, 0x8d, 0x74, + 0x50, 0x84, 0x5b, 0xdc, 0xe7, 0xac, 0x35, 0xf8, 0x6f, 0xee, 0x6d, 0xa4, 0x5b, 0xff, 0x30, 0x07, + 0x53, 0xb7, 0xbd, 0x3e, 0xe9, 0x3c, 0x97, 0x47, 0x7f, 0x87, 0xce, 0xf1, 0xf3, 0x23, 0x2f, 0x0f, + 0x1e, 0xf1, 0x6e, 0xc1, 0x48, 0x46, 0x41, 0x71, 0x34, 0x09, 0xec, 0x05, 0x80, 0x36, 0xf6, 0xb1, + 0x48, 0xe1, 0x92, 0x3b, 0x11, 0x29, 0x48, 0x26, 0xff, 0xad, 0x94, 0xcd, 0x7f, 0x1b, 0xf3, 0x48, + 0x77, 0xf9, 0x89, 0x1e, 0xe9, 0x36, 0xbf, 0xa7, 0xc1, 0xb4, 0x14, 0xe5, 0x6f, 0xc4, 0x83, 0x9f, + 0x8f, 0x60, 0xfe, 0x46, 0x7f, 0x6f, 0x0f, 0x47, 0xcf, 0xf5, 0xe1, 0xa8, 0x85, 0xe1, 0x36, 0x9f, + 0xcb, 0x1b, 0x5a, 0xf2, 0xb6, 0x78, 0xfe, 0x59, 0xbe, 0x33, 0x65, 0xde, 0x86, 0xfa, 0x1d, 0x4c, + 0xef, 0x62, 0xe4, 0xd1, 0xce, 0x6d, 0x8c, 0x5b, 0xa7, 0x7c, 0x3b, 0xca, 0xfc, 0xba, 0xc6, 0x23, + 0xf2, 0xe1, 0x8a, 0x4e, 0x2f, 0xa8, 0x77, 0xa0, 0xd6, 0xe1, 0x95, 0xd9, 0x7b, 0xb2, 0x36, 0x29, + 0xb2, 0xc4, 0xb6, 0x87, 0x1a, 0xab, 0x76, 0x32, 0xdf, 0x66, 0x04, 0xd5, 0x2c, 0x85, 0x18, 0xa9, + 0x41, 0x84, 0x93, 0xbd, 0x9b, 0x12, 0xff, 0xde, 0x6c, 0x19, 0x2f, 0x41, 0x4d, 0xb5, 0x63, 0x13, + 0xfc, 0xc8, 0xf6, 0x03, 0x75, 0x52, 0xad, 0xc0, 0x0d, 0xfc, 0x68, 0x2b, 0xe0, 0x19, 0xf0, 0x5e, + 0x70, 0x60, 0x13, 0x27, 0x88, 0xc4, 0x92, 0xb5, 0x68, 0x4d, 0x32, 0x48, 0x83, 0x01, 0x56, 0xdf, + 0x85, 0xa5, 0xc7, 0xbe, 0x3d, 0x6d, 0xcc, 0x81, 0x9e, 0x7c, 0x6d, 0x05, 0x51, 0x0f, 0x79, 0xfa, + 0x39, 0x63, 0x11, 0x66, 0x13, 0xe8, 0xed, 0x20, 0x72, 0xf8, 0x4d, 0x3b, 0x5d, 0x5b, 0xf5, 0xe0, + 0xc2, 0x51, 0x8f, 0x4d, 0xb3, 0xea, 0xe4, 0x3d, 0xb6, 0xbe, 0x47, 0xe3, 0xea, 0x56, 0xe0, 0x42, + 0x02, 0xbd, 0x3f, 0xf2, 0x66, 0xb4, 0x48, 0x49, 0x4b, 0x28, 0x44, 0x1a, 0x91, 0x9e, 0x5b, 0x7d, + 0x19, 0x20, 0x99, 0xf2, 0x8c, 0x09, 0xc8, 0x3d, 0x7c, 0x4d, 0x3f, 0x67, 0x4c, 0x42, 0xf1, 0xe1, + 0x6b, 0xcd, 0xe6, 0x7d, 0x5d, 0xe3, 0xa0, 0x75, 0x3d, 0xb7, 0xfa, 0x0a, 0x40, 0x72, 0x6b, 0xc3, + 0x00, 0x98, 0x88, 0x9b, 0x2e, 0x41, 0xfe, 0x7e, 0x70, 0xa0, 0x6b, 0x46, 0x19, 0x0a, 0x77, 0xdd, + 0x76, 0x47, 0xcf, 0xad, 0x5e, 0x83, 0x6a, 0xf6, 0xaa, 0x06, 0xab, 0xa6, 0xb1, 0xa9, 0x9f, 0x63, + 0x7f, 0xad, 0x0d, 0x5d, 0xe3, 0x69, 0x6f, 0x1b, 0x22, 0xed, 0xad, 0xa1, 0xe7, 0x56, 0x1f, 0x42, + 0x25, 0x95, 0xf6, 0xcf, 0x78, 0xdd, 0x0a, 0xe8, 0x75, 0xcf, 0x0b, 0x0e, 0x70, 0x6b, 0xdb, 0x67, + 0x60, 0x21, 0xb2, 0x18, 0x74, 0xdd, 0xeb, 0x05, 0x84, 0x72, 0x84, 0x66, 0xd4, 0x61, 0x2e, 0x85, + 0xe0, 0x49, 0x72, 0x1c, 0x93, 0x5b, 0x75, 0x20, 0xb7, 0x1d, 0x32, 0x0e, 0x77, 0xfa, 0x54, 0xb0, + 0x7a, 0x13, 0x7b, 0x82, 0x55, 0x2e, 0xee, 0x9c, 0x31, 0x05, 0x65, 0xb5, 0x1d, 0xaf, 0xe7, 0x59, + 0xbf, 0x36, 0x7d, 0xe6, 0x2a, 0xf5, 0x82, 0x31, 0x0b, 0xb5, 0x21, 0x45, 0xe8, 0x45, 0xc3, 0x80, + 0x2a, 0xe7, 0x5a, 0x45, 0x46, 0x44, 0x9f, 0x58, 0x5d, 0x83, 0xc9, 0xd8, 0xdf, 0xb2, 0x9a, 0xb7, + 0x02, 0x1f, 0x0b, 0x21, 0x72, 0x12, 0x5d, 0x63, 0x8d, 0xa8, 0x02, 0x42, 0x3a, 0x59, 0xff, 0xcc, + 0xf8, 0xda, 0xde, 0xdb, 0xd3, 0xcf, 0xb1, 0xd2, 0xb7, 0x11, 0x2f, 0x02, 0x30, 0xd1, 0xa0, 0x11, + 0x53, 0x5d, 0x6e, 0xf5, 0xdb, 0x1a, 0x4c, 0xc8, 0x7f, 0x29, 0xc0, 0x6b, 0x12, 0xbf, 0xf5, 0x73, + 0xc6, 0x3c, 0xcc, 0x34, 0x9b, 0xf7, 0x45, 0x96, 0x5c, 0xdc, 0x0b, 0x2e, 0x0f, 0x7e, 0xd2, 0x26, + 0x9b, 0x8c, 0x31, 0x39, 0x56, 0xe0, 0x41, 0x3c, 0x09, 0x35, 0x76, 0xfa, 0xa4, 0x83, 0x5b, 0x7a, + 0x9e, 0x59, 0x4f, 0x5c, 0xcf, 0x98, 0x67, 0xa1, 0xf5, 0x82, 0xb1, 0x04, 0xf3, 0xe9, 0x2a, 0x6f, + 0x06, 0x5b, 0x01, 0xed, 0xb8, 0x7e, 0x5b, 0x2f, 0xae, 0x5e, 0x81, 0xd2, 0xad, 0x43, 0x1a, 0xa1, + 0xed, 0x50, 0x74, 0x3e, 0x08, 0xf5, 0x73, 0x86, 0x0e, 0x53, 0x16, 0x46, 0xad, 0x6d, 0xaf, 0xc5, + 0xb7, 0x25, 0x74, 0x6d, 0xd5, 0x84, 0x99, 0x91, 0x85, 0x13, 0x33, 0x83, 0x8d, 0xc8, 0x79, 0xeb, + 0x0d, 0xfb, 0xdf, 0x06, 0x91, 0x7e, 0xee, 0xc6, 0x4b, 0x7f, 0xf1, 0x7f, 0xcb, 0xda, 0x87, 0x1f, + 0xbd, 0xa0, 0xfd, 0xe4, 0xa3, 0x17, 0xb4, 0xbf, 0xfe, 0xe8, 0x05, 0xed, 0x7f, 0xff, 0xcd, 0x0b, + 0xe7, 0x40, 0x0f, 0xa2, 0xf6, 0x1a, 0x75, 0xbb, 0xfb, 0x6b, 0x32, 0x58, 0xd8, 0x9d, 0xe0, 0x7f, + 0x5e, 0xff, 0x97, 0x00, 0x00, 0x00, 0xff, 0xff, 0xee, 0x06, 0x54, 0x9e, 0x6f, 0x68, 0x00, 0x00, } func (m *GetRequest) Marshal() (dAtA []byte, err error) { @@ -17141,6 +17151,13 @@ func (m *Deadlock) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } + if len(m.DeadlockKey) > 0 { + i -= len(m.DeadlockKey) + copy(dAtA[i:], m.DeadlockKey) + i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.DeadlockKey))) + i-- + dAtA[i] = 0x2a + } if len(m.WaitChain) > 0 { for iNdEx := len(m.WaitChain) - 1; iNdEx >= 0; iNdEx-- { { @@ -22681,6 +22698,10 @@ func (m *Deadlock) Size() (n int) { n += 1 + l + sovKvrpcpb(uint64(l)) } } + l = len(m.DeadlockKey) + if l > 0 { + n += 1 + l + sovKvrpcpb(uint64(l)) + } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } @@ -39241,6 +39262,40 @@ func (m *Deadlock) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DeadlockKey", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowKvrpcpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthKvrpcpb + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthKvrpcpb + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DeadlockKey = append(m.DeadlockKey[:0], dAtA[iNdEx:postIndex]...) + if m.DeadlockKey == nil { + m.DeadlockKey = []byte{} + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) diff --git a/proto/deadlock.proto b/proto/deadlock.proto index da66a8c24..024c4d417 100644 --- a/proto/deadlock.proto +++ b/proto/deadlock.proto @@ -33,19 +33,33 @@ enum DeadlockRequestType { CleanUp = 2; } +message ReplaceLockByKeyItem { + uint64 key_hash = 1; + bytes key = 2; + uint64 old_lock_ts = 3; + uint64 new_lock_ts = 4; +} + +message ReplaceLocksByKeysRequest { + repeated ReplaceLockByKeyItem items = 1; +} + message DeadlockRequest { DeadlockRequestType tp = 1; - WaitForEntry entry = 2 [(gogoproto.nullable) = false]; + WaitForEntry entry = 2; + ReplaceLocksByKeysRequest replace_locks_by_keys = 3; } message DeadlockResponse { // The same entry sent by DeadlockRequest, identifies the sender. WaitForEntry entry = 1 [(gogoproto.nullable) = false]; - // The key hash of the lock that is hold by the waiting transaction. + // The key hash of the lock that is hold by the waiting transaction. The hash of the `deadlock_key` field. uint64 deadlock_key_hash = 2; // The other entries of the dead lock circle. The current entry is in `entry` field and not // included in this field. repeated WaitForEntry wait_chain = 3; + // The key of the lock that is hold by the waiting transaction. + bytes deadlock_key = 4; } service Deadlock { diff --git a/proto/kvrpcpb.proto b/proto/kvrpcpb.proto index 96e02e821..f8c9300b4 100644 --- a/proto/kvrpcpb.proto +++ b/proto/kvrpcpb.proto @@ -1039,8 +1039,13 @@ message AlreadyExist { message Deadlock { uint64 lock_ts = 1; bytes lock_key = 2; + + // The hash of `deadlock_key` field. uint64 deadlock_key_hash = 3; repeated deadlock.WaitForEntry wait_chain = 4; + + // The key that the current transaction has already acquired and blocks another transaction to form the deadlock. + bytes deadlock_key = 5; } message CommitTsExpired { diff --git a/scripts/proto.lock b/scripts/proto.lock index c88b06c93..8e8e04fcc 100644 --- a/scripts/proto.lock +++ b/scripts/proto.lock @@ -3522,6 +3522,42 @@ } ] }, + { + "name": "ReplaceLockByKeyItem", + "fields": [ + { + "id": 1, + "name": "key_hash", + "type": "uint64" + }, + { + "id": 2, + "name": "key", + "type": "bytes" + }, + { + "id": 3, + "name": "old_lock_ts", + "type": "uint64" + }, + { + "id": 4, + "name": "new_lock_ts", + "type": "uint64" + } + ] + }, + { + "name": "ReplaceLocksByKeysRequest", + "fields": [ + { + "id": 1, + "name": "items", + "type": "ReplaceLockByKeyItem", + "is_repeated": true + } + ] + }, { "name": "DeadlockRequest", "fields": [ @@ -3533,13 +3569,12 @@ { "id": 2, "name": "entry", - "type": "WaitForEntry", - "options": [ - { - "name": "(gogoproto.nullable)", - "value": "false" - } - ] + "type": "WaitForEntry" + }, + { + "id": 3, + "name": "replace_locks_by_keys", + "type": "ReplaceLocksByKeysRequest" } ] }, @@ -3567,6 +3602,11 @@ "name": "wait_chain", "type": "WaitForEntry", "is_repeated": true + }, + { + "id": 4, + "name": "deadlock_key", + "type": "bytes" } ] } @@ -10632,6 +10672,11 @@ "name": "wait_chain", "type": "deadlock.WaitForEntry", "is_repeated": true + }, + { + "id": 5, + "name": "deadlock_key", + "type": "bytes" } ] }, From ed6867bd9a7f2e940c3bbbbcec5eb7a357eb674c Mon Sep 17 00:00:00 2001 From: Hu# Date: Wed, 4 Sep 2024 09:49:53 +0800 Subject: [PATCH 5/5] owner: modify resource manager owner to PD (#1262) * modify Signed-off-by: husharp * Update OWNERS_ALIASES * Update OWNERS_ALIASES --------- Signed-off-by: husharp Co-authored-by: wuhuizuo --- OWNERS_ALIASES | 6 +++--- proto/OWNERS | 4 ++-- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/OWNERS_ALIASES b/OWNERS_ALIASES index 103d81c73..1369d814f 100644 --- a/OWNERS_ALIASES +++ b/OWNERS_ALIASES @@ -20,9 +20,9 @@ aliases: sig-approvers-pb-coprocessor: [cfzjywxk] sig-approvers-pb-deadlock: [MyonKeminta, cfzjywxk] sig-approvers-pb-debug: [cfzjywxk] - sig-approvers-pb-pd: [niubell, rleungx] - sig-approvers-pb-raftstore: [zhangjinpeng1987, overvenus] - sig-approvers-pb-tikv: [zhangjinpeng1987] + sig-approvers-pb-pd: [niubell, rleungx, nolouch] + sig-approvers-pb-raftstore: [zhangjinpeng87, overvenus] + sig-approvers-pb-tikv: [zhangjinpeng87] sig-approvers-pb-error: [cfzjywxk] sig-approvers-pb-kvrpc: [cfzjywxk] sig-approvers-pb-trace: [you06] diff --git a/proto/OWNERS b/proto/OWNERS index 95538f039..66ce1ebe8 100644 --- a/proto/OWNERS +++ b/proto/OWNERS @@ -40,12 +40,12 @@ filters: approvers: [sig-approvers-pb-raftstore] "^recoverdatapb\\.proto$": approvers: [sig-approvers-pb-br] - "^resource_manager\\.proto$": - approvers: [sig-approvers-pb-raftstore] "^tikvpb\\.proto$": approvers: [sig-approvers-pb-tikv, sig-approvers-pb-kvrpc] "^tracepb\\.proto$": approvers: [sig-approvers-pb-trace] + "^resource_manager\\.proto$": + approvers: [sig-approvers-pb-pd] "^pdpb\\.proto$": approvers: [sig-approvers-pb-pd] "^keyspacepb\\.proto$":