From 7aaed89985964c6797c839c59b26ffac2ccfe4b8 Mon Sep 17 00:00:00 2001 From: 5kbpers Date: Tue, 18 Aug 2020 16:03:53 +0800 Subject: [PATCH] [4.0] Pick serval PRs for ticdc compiling (#664) * cdc: add regions field for reducing message of resolved ts Signed-off-by: 5kbpers * pdpb: add replicate_mode (#584) Signed-off-by: disksing Signed-off-by: 5kbpers * replicate_mode: change recover-id to state-id (#594) Signed-off-by: disksing * replicate: add unknown region state (#595) Signed-off-by: disksing * *: update name and script (#597) Signed-off-by: Jay Lee Signed-off-by: 5kbpers * support batch coprocessor (#586) Add batch coprocessor function for TiFlash Engine. Signed-off-by: 5kbpers * pd: add UpdateServiceGCSafePoint method (#603) * pd: add UpdateServiceGCSafePoint method Signed-off-by: Shafreeck Sea Signed-off-by: 5kbpers * Add end_key_exclude field to SstMeta and distinguish restoring of RawKv (#581) * Add end_key_exclusive field to SSTMeta * Add is_raw_kv field to download request * Revert changes of unrelated go files Signed-off-by: MyonKeminta * build Co-authored-by: MyonKeminta Signed-off-by: 5kbpers * Revert "cdc: add regions field for reducing message of resolved ts" This reverts commit c382b16664e282fc60f2e6ac56fea63d9973b306. Signed-off-by: 5kbpers Co-authored-by: disksing Co-authored-by: Jay Co-authored-by: Han Fei Co-authored-by: Shafreeck Sea Co-authored-by: MyonKeminta <9948422+MyonKeminta@users.noreply.github.com> Co-authored-by: MyonKeminta --- .gitignore | 3 +- cpp/CMakeLists.txt | 1 + pkg/coprocessor/coprocessor.pb.go | 1200 +++++++++++++-- pkg/import_sstpb/import_sstpb.pb.go | 271 ++-- pkg/pdpb/pdpb.pb.go | 1295 ++++++++++++----- pkg/replicate_mode/replicate_mode.pb.go | 938 ------------ .../replication_modepb.pb.go | 955 ++++++++++++ pkg/tikvpb/tikvpb.pb.go | 321 ++-- proto/coprocessor.proto | 23 + proto/import_sstpb.proto | 3 + proto/pdpb.proto | 28 +- proto/replicate_mode.proto | 35 - proto/replication_modepb.proto | 51 + proto/tikvpb.proto | 1 + scripts/generate_cpp.sh | 2 +- scripts/generate_go.sh | 2 +- 16 files changed, 3456 insertions(+), 1673 deletions(-) delete mode 100644 pkg/replicate_mode/replicate_mode.pb.go create mode 100644 pkg/replication_modepb/replication_modepb.pb.go delete mode 100644 proto/replicate_mode.proto create mode 100644 proto/replication_modepb.proto diff --git a/.gitignore b/.gitignore index d3bc3e0a3..76f203fd9 100644 --- a/.gitignore +++ b/.gitignore @@ -13,6 +13,5 @@ Cargo.lock .idea _tools -cpp/kvproto/*.h -cpp/kvproto/*.cc +cpp/kvproto/* diff --git a/cpp/CMakeLists.txt b/cpp/CMakeLists.txt index 2035ed2f4..9657632a9 100644 --- a/cpp/CMakeLists.txt +++ b/cpp/CMakeLists.txt @@ -17,4 +17,5 @@ file(GLOB __tmp RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} kvproto/*.cc kvproto/*.h) list(APPEND generated_files ${__tmp}) add_library(kvproto ${generated_files}) +include_directories(${CMAKE_CURRENT_LIST_DIR}/kvproto) target_include_directories(kvproto PUBLIC ./) diff --git a/pkg/coprocessor/coprocessor.pb.go b/pkg/coprocessor/coprocessor.pb.go index c22b979be..d8ab0fb94 100644 --- a/pkg/coprocessor/coprocessor.pb.go +++ b/pkg/coprocessor/coprocessor.pb.go @@ -16,6 +16,8 @@ import ( kvrpcpb "github.com/pingcap/kvproto/pkg/kvrpcpb" + metapb "github.com/pingcap/kvproto/pkg/metapb" + github_com_pingcap_kvproto_pkg_sharedbytes "github.com/pingcap/kvproto/pkg/sharedbytes" ) @@ -43,7 +45,7 @@ func (m *KeyRange) Reset() { *m = KeyRange{} } func (m *KeyRange) String() string { return proto.CompactTextString(m) } func (*KeyRange) ProtoMessage() {} func (*KeyRange) Descriptor() ([]byte, []int) { - return fileDescriptor_coprocessor_dd6f753d38264f26, []int{0} + return fileDescriptor_coprocessor_bc259b8e05617443, []int{0} } func (m *KeyRange) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -107,7 +109,7 @@ func (m *Request) Reset() { *m = Request{} } func (m *Request) String() string { return proto.CompactTextString(m) } func (*Request) ProtoMessage() {} func (*Request) Descriptor() ([]byte, []int) { - return fileDescriptor_coprocessor_dd6f753d38264f26, []int{1} + return fileDescriptor_coprocessor_bc259b8e05617443, []int{1} } func (m *Request) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -211,7 +213,7 @@ func (m *Response) Reset() { *m = Response{} } func (m *Response) String() string { return proto.CompactTextString(m) } func (*Response) ProtoMessage() {} func (*Response) Descriptor() ([]byte, []int) { - return fileDescriptor_coprocessor_dd6f753d38264f26, []int{2} + return fileDescriptor_coprocessor_bc259b8e05617443, []int{2} } func (m *Response) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -296,10 +298,220 @@ func (m *Response) GetCanBeCached() bool { return false } +type RegionInfo struct { + RegionId uint64 `protobuf:"varint,1,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty"` + RegionEpoch *metapb.RegionEpoch `protobuf:"bytes,2,opt,name=region_epoch,json=regionEpoch" json:"region_epoch,omitempty"` + Ranges []*KeyRange `protobuf:"bytes,3,rep,name=ranges" json:"ranges,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RegionInfo) Reset() { *m = RegionInfo{} } +func (m *RegionInfo) String() string { return proto.CompactTextString(m) } +func (*RegionInfo) ProtoMessage() {} +func (*RegionInfo) Descriptor() ([]byte, []int) { + return fileDescriptor_coprocessor_bc259b8e05617443, []int{3} +} +func (m *RegionInfo) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RegionInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RegionInfo.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalTo(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (dst *RegionInfo) XXX_Merge(src proto.Message) { + xxx_messageInfo_RegionInfo.Merge(dst, src) +} +func (m *RegionInfo) XXX_Size() int { + return m.Size() +} +func (m *RegionInfo) XXX_DiscardUnknown() { + xxx_messageInfo_RegionInfo.DiscardUnknown(m) +} + +var xxx_messageInfo_RegionInfo proto.InternalMessageInfo + +func (m *RegionInfo) GetRegionId() uint64 { + if m != nil { + return m.RegionId + } + return 0 +} + +func (m *RegionInfo) GetRegionEpoch() *metapb.RegionEpoch { + if m != nil { + return m.RegionEpoch + } + return nil +} + +func (m *RegionInfo) GetRanges() []*KeyRange { + if m != nil { + return m.Ranges + } + return nil +} + +type BatchRequest struct { + Context *kvrpcpb.Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` + Tp int64 `protobuf:"varint,2,opt,name=tp,proto3" json:"tp,omitempty"` + Data []byte `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"` + Regions []*RegionInfo `protobuf:"bytes,4,rep,name=regions" json:"regions,omitempty"` + StartTs uint64 `protobuf:"varint,5,opt,name=start_ts,json=startTs,proto3" json:"start_ts,omitempty"` + // Any schema-ful storage to validate schema correctness if necessary. + SchemaVer int64 `protobuf:"varint,6,opt,name=schema_ver,json=schemaVer,proto3" json:"schema_ver,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *BatchRequest) Reset() { *m = BatchRequest{} } +func (m *BatchRequest) String() string { return proto.CompactTextString(m) } +func (*BatchRequest) ProtoMessage() {} +func (*BatchRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_coprocessor_bc259b8e05617443, []int{4} +} +func (m *BatchRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *BatchRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_BatchRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalTo(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (dst *BatchRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_BatchRequest.Merge(dst, src) +} +func (m *BatchRequest) XXX_Size() int { + return m.Size() +} +func (m *BatchRequest) XXX_DiscardUnknown() { + xxx_messageInfo_BatchRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_BatchRequest proto.InternalMessageInfo + +func (m *BatchRequest) GetContext() *kvrpcpb.Context { + if m != nil { + return m.Context + } + return nil +} + +func (m *BatchRequest) GetTp() int64 { + if m != nil { + return m.Tp + } + return 0 +} + +func (m *BatchRequest) GetData() []byte { + if m != nil { + return m.Data + } + return nil +} + +func (m *BatchRequest) GetRegions() []*RegionInfo { + if m != nil { + return m.Regions + } + return nil +} + +func (m *BatchRequest) GetStartTs() uint64 { + if m != nil { + return m.StartTs + } + return 0 +} + +func (m *BatchRequest) GetSchemaVer() int64 { + if m != nil { + return m.SchemaVer + } + return 0 +} + +type BatchResponse struct { + Data github_com_pingcap_kvproto_pkg_sharedbytes.SharedBytes `protobuf:"bytes,1,opt,name=data,proto3,customtype=github.com/pingcap/kvproto/pkg/sharedbytes.SharedBytes" json:"data"` + OtherError string `protobuf:"bytes,2,opt,name=other_error,json=otherError,proto3" json:"other_error,omitempty"` + ExecDetails *kvrpcpb.ExecDetails `protobuf:"bytes,3,opt,name=exec_details,json=execDetails" json:"exec_details,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *BatchResponse) Reset() { *m = BatchResponse{} } +func (m *BatchResponse) String() string { return proto.CompactTextString(m) } +func (*BatchResponse) ProtoMessage() {} +func (*BatchResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_coprocessor_bc259b8e05617443, []int{5} +} +func (m *BatchResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *BatchResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_BatchResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalTo(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (dst *BatchResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_BatchResponse.Merge(dst, src) +} +func (m *BatchResponse) XXX_Size() int { + return m.Size() +} +func (m *BatchResponse) XXX_DiscardUnknown() { + xxx_messageInfo_BatchResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_BatchResponse proto.InternalMessageInfo + +func (m *BatchResponse) GetOtherError() string { + if m != nil { + return m.OtherError + } + return "" +} + +func (m *BatchResponse) GetExecDetails() *kvrpcpb.ExecDetails { + if m != nil { + return m.ExecDetails + } + return nil +} + func init() { proto.RegisterType((*KeyRange)(nil), "coprocessor.KeyRange") proto.RegisterType((*Request)(nil), "coprocessor.Request") proto.RegisterType((*Response)(nil), "coprocessor.Response") + proto.RegisterType((*RegionInfo)(nil), "coprocessor.RegionInfo") + proto.RegisterType((*BatchRequest)(nil), "coprocessor.BatchRequest") + proto.RegisterType((*BatchResponse)(nil), "coprocessor.BatchResponse") } func (m *KeyRange) Marshal() (dAtA []byte, err error) { size := m.Size() @@ -513,71 +725,228 @@ func (m *Response) MarshalTo(dAtA []byte) (int, error) { return i, nil } -func encodeVarintCoprocessor(dAtA []byte, offset int, v uint64) int { - for v >= 1<<7 { - dAtA[offset] = uint8(v&0x7f | 0x80) - v >>= 7 - offset++ +func (m *RegionInfo) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err } - dAtA[offset] = uint8(v) - return offset + 1 + return dAtA[:n], nil } -func (m *KeyRange) Size() (n int) { + +func (m *RegionInfo) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i var l int _ = l - l = len(m.Start) - if l > 0 { - n += 1 + l + sovCoprocessor(uint64(l)) + if m.RegionId != 0 { + dAtA[i] = 0x8 + i++ + i = encodeVarintCoprocessor(dAtA, i, uint64(m.RegionId)) } - l = len(m.End) - if l > 0 { - n += 1 + l + sovCoprocessor(uint64(l)) + if m.RegionEpoch != nil { + dAtA[i] = 0x12 + i++ + i = encodeVarintCoprocessor(dAtA, i, uint64(m.RegionEpoch.Size())) + n7, err := m.RegionEpoch.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n7 + } + if len(m.Ranges) > 0 { + for _, msg := range m.Ranges { + dAtA[i] = 0x1a + i++ + i = encodeVarintCoprocessor(dAtA, i, uint64(msg.Size())) + n, err := msg.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n + } } if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + i += copy(dAtA[i:], m.XXX_unrecognized) } - return n + return i, nil } -func (m *Request) Size() (n int) { +func (m *BatchRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *BatchRequest) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i var l int _ = l if m.Context != nil { - l = m.Context.Size() - n += 1 + l + sovCoprocessor(uint64(l)) + dAtA[i] = 0xa + i++ + i = encodeVarintCoprocessor(dAtA, i, uint64(m.Context.Size())) + n8, err := m.Context.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n8 } if m.Tp != 0 { - n += 1 + sovCoprocessor(uint64(m.Tp)) + dAtA[i] = 0x10 + i++ + i = encodeVarintCoprocessor(dAtA, i, uint64(m.Tp)) } - l = len(m.Data) - if l > 0 { - n += 1 + l + sovCoprocessor(uint64(l)) + if len(m.Data) > 0 { + dAtA[i] = 0x1a + i++ + i = encodeVarintCoprocessor(dAtA, i, uint64(len(m.Data))) + i += copy(dAtA[i:], m.Data) } - if len(m.Ranges) > 0 { - for _, e := range m.Ranges { - l = e.Size() - n += 1 + l + sovCoprocessor(uint64(l)) + if len(m.Regions) > 0 { + for _, msg := range m.Regions { + dAtA[i] = 0x22 + i++ + i = encodeVarintCoprocessor(dAtA, i, uint64(msg.Size())) + n, err := msg.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n } } - if m.IsCacheEnabled { - n += 2 - } - if m.CacheIfMatchVersion != 0 { - n += 1 + sovCoprocessor(uint64(m.CacheIfMatchVersion)) - } if m.StartTs != 0 { - n += 1 + sovCoprocessor(uint64(m.StartTs)) + dAtA[i] = 0x28 + i++ + i = encodeVarintCoprocessor(dAtA, i, uint64(m.StartTs)) } if m.SchemaVer != 0 { - n += 1 + sovCoprocessor(uint64(m.SchemaVer)) + dAtA[i] = 0x30 + i++ + i = encodeVarintCoprocessor(dAtA, i, uint64(m.SchemaVer)) } if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) + i += copy(dAtA[i:], m.XXX_unrecognized) } - return n + return i, nil } -func (m *Response) Size() (n int) { +func (m *BatchResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *BatchResponse) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + dAtA[i] = 0xa + i++ + i = encodeVarintCoprocessor(dAtA, i, uint64(m.Data.Size())) + n9, err := m.Data.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n9 + if len(m.OtherError) > 0 { + dAtA[i] = 0x12 + i++ + i = encodeVarintCoprocessor(dAtA, i, uint64(len(m.OtherError))) + i += copy(dAtA[i:], m.OtherError) + } + if m.ExecDetails != nil { + dAtA[i] = 0x1a + i++ + i = encodeVarintCoprocessor(dAtA, i, uint64(m.ExecDetails.Size())) + n10, err := m.ExecDetails.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n10 + } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } + return i, nil +} + +func encodeVarintCoprocessor(dAtA []byte, offset int, v uint64) int { + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return offset + 1 +} +func (m *KeyRange) Size() (n int) { + var l int + _ = l + l = len(m.Start) + if l > 0 { + n += 1 + l + sovCoprocessor(uint64(l)) + } + l = len(m.End) + if l > 0 { + n += 1 + l + sovCoprocessor(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *Request) Size() (n int) { + var l int + _ = l + if m.Context != nil { + l = m.Context.Size() + n += 1 + l + sovCoprocessor(uint64(l)) + } + if m.Tp != 0 { + n += 1 + sovCoprocessor(uint64(m.Tp)) + } + l = len(m.Data) + if l > 0 { + n += 1 + l + sovCoprocessor(uint64(l)) + } + if len(m.Ranges) > 0 { + for _, e := range m.Ranges { + l = e.Size() + n += 1 + l + sovCoprocessor(uint64(l)) + } + } + if m.IsCacheEnabled { + n += 2 + } + if m.CacheIfMatchVersion != 0 { + n += 1 + sovCoprocessor(uint64(m.CacheIfMatchVersion)) + } + if m.StartTs != 0 { + n += 1 + sovCoprocessor(uint64(m.StartTs)) + } + if m.SchemaVer != 0 { + n += 1 + sovCoprocessor(uint64(m.SchemaVer)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *Response) Size() (n int) { var l int _ = l l = m.Data.Size() @@ -617,6 +986,79 @@ func (m *Response) Size() (n int) { return n } +func (m *RegionInfo) Size() (n int) { + var l int + _ = l + if m.RegionId != 0 { + n += 1 + sovCoprocessor(uint64(m.RegionId)) + } + if m.RegionEpoch != nil { + l = m.RegionEpoch.Size() + n += 1 + l + sovCoprocessor(uint64(l)) + } + if len(m.Ranges) > 0 { + for _, e := range m.Ranges { + l = e.Size() + n += 1 + l + sovCoprocessor(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *BatchRequest) Size() (n int) { + var l int + _ = l + if m.Context != nil { + l = m.Context.Size() + n += 1 + l + sovCoprocessor(uint64(l)) + } + if m.Tp != 0 { + n += 1 + sovCoprocessor(uint64(m.Tp)) + } + l = len(m.Data) + if l > 0 { + n += 1 + l + sovCoprocessor(uint64(l)) + } + if len(m.Regions) > 0 { + for _, e := range m.Regions { + l = e.Size() + n += 1 + l + sovCoprocessor(uint64(l)) + } + } + if m.StartTs != 0 { + n += 1 + sovCoprocessor(uint64(m.StartTs)) + } + if m.SchemaVer != 0 { + n += 1 + sovCoprocessor(uint64(m.SchemaVer)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *BatchResponse) Size() (n int) { + var l int + _ = l + l = m.Data.Size() + n += 1 + l + sovCoprocessor(uint64(l)) + l = len(m.OtherError) + if l > 0 { + n += 1 + l + sovCoprocessor(uint64(l)) + } + if m.ExecDetails != nil { + l = m.ExecDetails.Size() + n += 1 + l + sovCoprocessor(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + func sovCoprocessor(x uint64) (n int) { for { n++ @@ -1286,17 +1728,18 @@ func (m *Response) Unmarshal(dAtA []byte) error { } return nil } -func skipCoprocessor(dAtA []byte) (n int, err error) { +func (m *RegionInfo) 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 0, ErrIntOverflowCoprocessor + return ErrIntOverflowCoprocessor } if iNdEx >= l { - return 0, io.ErrUnexpectedEOF + return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ @@ -1305,84 +1748,563 @@ func skipCoprocessor(dAtA []byte) (n int, err error) { break } } + fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) - switch wireType { - case 0: + if wireType == 4 { + return fmt.Errorf("proto: RegionInfo: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RegionInfo: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field RegionId", wireType) + } + m.RegionId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { - return 0, ErrIntOverflowCoprocessor + return ErrIntOverflowCoprocessor } if iNdEx >= l { - return 0, io.ErrUnexpectedEOF + return io.ErrUnexpectedEOF } + b := dAtA[iNdEx] iNdEx++ - if dAtA[iNdEx-1] < 0x80 { + m.RegionId |= (uint64(b) & 0x7F) << shift + if b < 0x80 { break } } - return iNdEx, nil - case 1: - iNdEx += 8 - return iNdEx, nil case 2: - var length int + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RegionEpoch", wireType) + } + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { - return 0, ErrIntOverflowCoprocessor + return ErrIntOverflowCoprocessor } if iNdEx >= l { - return 0, io.ErrUnexpectedEOF + return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ - length |= (int(b) & 0x7F) << shift + msglen |= (int(b) & 0x7F) << shift if b < 0x80 { break } } - iNdEx += length - if length < 0 { - return 0, ErrInvalidLengthCoprocessor + if msglen < 0 { + return ErrInvalidLengthCoprocessor } - return iNdEx, nil + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.RegionEpoch == nil { + m.RegionEpoch = &metapb.RegionEpoch{} + } + if err := m.RegionEpoch.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex case 3: - for { - var innerWire uint64 - var start int = iNdEx - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return 0, ErrIntOverflowCoprocessor - } - if iNdEx >= l { - return 0, io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - innerWire |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break - } + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Ranges", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCoprocessor } - innerWireType := int(innerWire & 0x7) - if innerWireType == 4 { - break + if iNdEx >= l { + return io.ErrUnexpectedEOF } - next, err := skipCoprocessor(dAtA[start:]) - if err != nil { - return 0, err + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break } - iNdEx = start + next } - return iNdEx, nil - case 4: - return iNdEx, nil - case 5: - iNdEx += 4 - return iNdEx, nil - default: - return 0, fmt.Errorf("proto: illegal wireType %d", wireType) - } - } + if msglen < 0 { + return ErrInvalidLengthCoprocessor + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Ranges = append(m.Ranges, &KeyRange{}) + if err := m.Ranges[len(m.Ranges)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipCoprocessor(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthCoprocessor + } + 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 *BatchRequest) 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 ErrIntOverflowCoprocessor + } + 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: BatchRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BatchRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCoprocessor + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthCoprocessor + } + postIndex := iNdEx + msglen + 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 + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Tp", wireType) + } + m.Tp = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCoprocessor + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Tp |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCoprocessor + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthCoprocessor + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...) + if m.Data == nil { + m.Data = []byte{} + } + iNdEx = postIndex + case 4: + 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 ErrIntOverflowCoprocessor + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthCoprocessor + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Regions = append(m.Regions, &RegionInfo{}) + if err := m.Regions[len(m.Regions)-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 StartTs", wireType) + } + m.StartTs = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCoprocessor + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.StartTs |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field SchemaVer", wireType) + } + m.SchemaVer = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCoprocessor + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.SchemaVer |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipCoprocessor(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthCoprocessor + } + 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 *BatchResponse) 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 ErrIntOverflowCoprocessor + } + 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: BatchResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BatchResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCoprocessor + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthCoprocessor + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Data.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field OtherError", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCoprocessor + } + 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 ErrInvalidLengthCoprocessor + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.OtherError = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ExecDetails", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCoprocessor + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthCoprocessor + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ExecDetails == nil { + m.ExecDetails = &kvrpcpb.ExecDetails{} + } + if err := m.ExecDetails.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipCoprocessor(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthCoprocessor + } + 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 skipCoprocessor(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowCoprocessor + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowCoprocessor + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowCoprocessor + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthCoprocessor + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowCoprocessor + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipCoprocessor(dAtA[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } panic("unreachable") } @@ -1391,45 +2313,53 @@ var ( ErrIntOverflowCoprocessor = fmt.Errorf("proto: integer overflow") ) -func init() { proto.RegisterFile("coprocessor.proto", fileDescriptor_coprocessor_dd6f753d38264f26) } - -var fileDescriptor_coprocessor_dd6f753d38264f26 = []byte{ - // 587 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x52, 0x4d, 0x6f, 0xd3, 0x4a, - 0x14, 0xad, 0x93, 0x34, 0x71, 0xaf, 0xd3, 0xbe, 0x74, 0x5e, 0xdf, 0x93, 0x5f, 0xa5, 0x97, 0x46, - 0x59, 0xa0, 0xf0, 0xe5, 0x88, 0x54, 0x82, 0x1d, 0x8b, 0x94, 0x4a, 0x54, 0x94, 0xcd, 0x80, 0xba, - 0xb5, 0x26, 0xe3, 0x5b, 0xdb, 0x4a, 0xea, 0x31, 0x33, 0xd3, 0xa8, 0xfd, 0x27, 0x6c, 0xd9, 0xf1, - 0x0f, 0xf8, 0x0b, 0x5d, 0xb2, 0x44, 0x2c, 0x2a, 0x54, 0xfe, 0x08, 0xf2, 0x1d, 0x27, 0x74, 0xc3, - 0xca, 0xf7, 0x9e, 0x73, 0x72, 0x32, 0x73, 0xce, 0xc0, 0xae, 0x54, 0xa5, 0x56, 0x12, 0x8d, 0x51, - 0x3a, 0x2a, 0xb5, 0xb2, 0x8a, 0x05, 0xf7, 0xa0, 0xfd, 0x6d, 0xd4, 0x5a, 0xe9, 0x72, 0xe6, 0xb8, - 0xfd, 0xed, 0xf9, 0x52, 0x97, 0x72, 0xbd, 0xee, 0xa5, 0x2a, 0x55, 0x34, 0x8e, 0xab, 0xa9, 0x46, - 0xff, 0xd2, 0x97, 0xc6, 0xd2, 0xe8, 0x80, 0xe1, 0x04, 0xfc, 0x37, 0x78, 0xcd, 0x45, 0x91, 0x22, - 0xdb, 0x83, 0x4d, 0x63, 0x85, 0xb6, 0xa1, 0x37, 0xf0, 0x46, 0x5d, 0xee, 0x16, 0xd6, 0x83, 0x26, - 0x16, 0x49, 0xd8, 0x20, 0xac, 0x1a, 0x87, 0x9f, 0x1a, 0xd0, 0xe1, 0xf8, 0xe1, 0x12, 0x8d, 0x65, - 0x8f, 0xa0, 0x23, 0x55, 0x61, 0xf1, 0xca, 0xfd, 0x2a, 0x98, 0xf4, 0xa2, 0xd5, 0x39, 0x8e, 0x1c, - 0xce, 0x57, 0x02, 0xb6, 0x03, 0x0d, 0x5b, 0x92, 0x51, 0x93, 0x37, 0x6c, 0xc9, 0x18, 0xb4, 0x12, - 0x61, 0x45, 0xd8, 0x24, 0x6b, 0x9a, 0xd9, 0x53, 0x68, 0xeb, 0xea, 0x30, 0x26, 0x6c, 0x0d, 0x9a, - 0xa3, 0x60, 0xf2, 0x4f, 0x74, 0x3f, 0x85, 0xd5, 0x51, 0x79, 0x2d, 0x62, 0x23, 0xe8, 0xe5, 0x26, - 0x96, 0x42, 0x66, 0x18, 0x63, 0x21, 0x66, 0x0b, 0x4c, 0xc2, 0xcd, 0x81, 0x37, 0xf2, 0xf9, 0x4e, - 0x6e, 0x8e, 0x2a, 0xf8, 0xd8, 0xa1, 0xec, 0x10, 0xfe, 0x75, 0xb2, 0xfc, 0x3c, 0xbe, 0x10, 0x56, - 0x66, 0xf1, 0x12, 0xb5, 0xc9, 0x55, 0x11, 0xb6, 0x07, 0xde, 0xa8, 0xc5, 0xff, 0x26, 0xf6, 0xe4, - 0xfc, 0x6d, 0xc5, 0x9d, 0x39, 0x8a, 0xfd, 0x07, 0x3e, 0x85, 0x10, 0x5b, 0x13, 0x76, 0x48, 0xd6, - 0xa1, 0xfd, 0xbd, 0x61, 0xff, 0x03, 0x18, 0x99, 0xe1, 0x85, 0xa8, 0x7c, 0x42, 0x9f, 0x2e, 0xb5, - 0xe5, 0x90, 0x33, 0xd4, 0xc3, 0x2f, 0x4d, 0xf0, 0x39, 0x9a, 0x52, 0x15, 0x06, 0x19, 0xaf, 0x2f, - 0x4a, 0xb9, 0x4e, 0x5f, 0xde, 0xdc, 0x1e, 0x6c, 0x7c, 0xbf, 0x3d, 0x78, 0x9e, 0xe6, 0x36, 0xbb, - 0x9c, 0x45, 0x52, 0x5d, 0x8c, 0xcb, 0xbc, 0x48, 0xa5, 0x28, 0xc7, 0xf3, 0xa5, 0xab, 0xac, 0x9c, - 0xa7, 0x63, 0x93, 0x09, 0x8d, 0xc9, 0xec, 0xda, 0xa2, 0x89, 0xde, 0xd1, 0x3c, 0xad, 0xe6, 0x3a, - 0xa8, 0x67, 0xd0, 0xd5, 0x98, 0xe6, 0xaa, 0x88, 0xe9, 0x19, 0x50, 0xac, 0xc1, 0x64, 0x27, 0x5a, - 0x3d, 0x8a, 0xe3, 0xea, 0xcb, 0x03, 0xa7, 0xa1, 0x85, 0x3d, 0x84, 0xf6, 0x42, 0xc9, 0x39, 0x26, - 0x94, 0x78, 0x30, 0xd9, 0x5d, 0x57, 0x75, 0xaa, 0xe4, 0xfc, 0xa4, 0x38, 0x57, 0xbc, 0x16, 0xb0, - 0x03, 0x08, 0x94, 0xcd, 0x50, 0xd7, 0xe6, 0xad, 0x81, 0x37, 0xda, 0xe2, 0x40, 0x90, 0xf3, 0x7a, - 0x0c, 0x9b, 0x54, 0x01, 0xa5, 0xfd, 0xc7, 0x9a, 0x9c, 0x86, 0xbd, 0x80, 0x2e, 0x5e, 0xa1, 0x8c, - 0x13, 0xb4, 0x22, 0x5f, 0x18, 0x4a, 0x3c, 0x98, 0xec, 0xad, 0xff, 0xfe, 0xf8, 0x0a, 0xe5, 0x2b, - 0xc7, 0xf1, 0x00, 0x7f, 0x2f, 0x6c, 0x00, 0xdd, 0x75, 0xbd, 0x59, 0x6e, 0xa9, 0x03, 0x9f, 0x43, - 0x5d, 0xed, 0xeb, 0xdc, 0xb2, 0x27, 0xc0, 0x1c, 0xbd, 0x10, 0xc6, 0xae, 0x2b, 0xf5, 0xa9, 0xab, - 0x1e, 0x31, 0xa7, 0xc2, 0xd8, 0x55, 0x9f, 0x43, 0xd8, 0x96, 0xa2, 0x88, 0x67, 0xe8, 0x3c, 0x93, - 0x70, 0x8b, 0x0c, 0x03, 0x29, 0x8a, 0x29, 0x92, 0x67, 0x32, 0x7d, 0xf0, 0xed, 0xb3, 0xef, 0xdd, - 0xdc, 0xf5, 0xbd, 0xaf, 0x77, 0x7d, 0xef, 0xc7, 0x5d, 0xdf, 0xfb, 0xf8, 0xb3, 0xbf, 0x01, 0x3d, - 0xa5, 0xd3, 0xc8, 0xe6, 0xf3, 0x65, 0x54, 0x57, 0x34, 0x6b, 0xd3, 0xe7, 0xf0, 0x57, 0x00, 0x00, - 0x00, 0xff, 0xff, 0x4d, 0xb3, 0x7b, 0x49, 0xa7, 0x03, 0x00, 0x00, +func init() { proto.RegisterFile("coprocessor.proto", fileDescriptor_coprocessor_bc259b8e05617443) } + +var fileDescriptor_coprocessor_bc259b8e05617443 = []byte{ + // 708 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x53, 0x3d, 0x6f, 0xdb, 0x48, + 0x10, 0x35, 0xf5, 0x49, 0x0d, 0x25, 0x9f, 0xbc, 0xf6, 0xdd, 0xf1, 0x7c, 0x38, 0x59, 0x50, 0x71, + 0x50, 0xbe, 0x28, 0x58, 0x06, 0x9c, 0x2e, 0x85, 0x1c, 0x01, 0x31, 0xe2, 0x34, 0x9b, 0xc0, 0x2d, + 0xb1, 0x5a, 0xae, 0x49, 0x42, 0x12, 0x97, 0xd9, 0x5d, 0x0b, 0xf6, 0xbf, 0x48, 0x99, 0x36, 0x5d, + 0xfe, 0x41, 0xaa, 0xf4, 0x06, 0xd2, 0xa4, 0x0c, 0x52, 0x18, 0x81, 0xf3, 0x47, 0x02, 0xee, 0x92, + 0xf2, 0x47, 0x90, 0xc0, 0x8d, 0x2b, 0xcd, 0xbc, 0x19, 0x8e, 0x66, 0xdf, 0x7b, 0x03, 0x6b, 0x94, + 0xa7, 0x82, 0x53, 0x26, 0x25, 0x17, 0x5e, 0x2a, 0xb8, 0xe2, 0xc8, 0xb9, 0x02, 0x6d, 0xb6, 0x98, + 0x10, 0x5c, 0xa4, 0x13, 0x53, 0xdb, 0x6c, 0x4d, 0x17, 0x22, 0xa5, 0xcb, 0x74, 0x23, 0xe4, 0x21, + 0xd7, 0xe1, 0x20, 0x8b, 0x72, 0xf4, 0x0f, 0x71, 0x2c, 0x95, 0x0e, 0x73, 0xa0, 0x39, 0x67, 0x8a, + 0x14, 0x1f, 0xf5, 0x86, 0x60, 0x3f, 0x67, 0xa7, 0x98, 0x24, 0x21, 0x43, 0x1b, 0x50, 0x95, 0x8a, + 0x08, 0xe5, 0x5a, 0x5d, 0xab, 0xdf, 0xc4, 0x26, 0x41, 0x6d, 0x28, 0xb3, 0x24, 0x70, 0x4b, 0x1a, + 0xcb, 0xc2, 0xde, 0xbb, 0x12, 0xd4, 0x31, 0x7b, 0x7d, 0xcc, 0xa4, 0x42, 0xf7, 0xa1, 0x4e, 0x79, + 0xa2, 0xd8, 0x89, 0xf9, 0xca, 0x19, 0xb6, 0xbd, 0x62, 0xab, 0x3d, 0x83, 0xe3, 0xa2, 0x01, 0xad, + 0x42, 0x49, 0xa5, 0x7a, 0x50, 0x19, 0x97, 0x54, 0x8a, 0x10, 0x54, 0x02, 0xa2, 0x88, 0x5b, 0xd6, + 0xa3, 0x75, 0x8c, 0x1e, 0x41, 0x4d, 0x64, 0xcb, 0x48, 0xb7, 0xd2, 0x2d, 0xf7, 0x9d, 0xe1, 0x9f, + 0xde, 0x55, 0x4e, 0x8a, 0x55, 0x71, 0xde, 0x84, 0xfa, 0xd0, 0x8e, 0xa5, 0x4f, 0x09, 0x8d, 0x98, + 0xcf, 0x12, 0x32, 0x99, 0xb1, 0xc0, 0xad, 0x76, 0xad, 0xbe, 0x8d, 0x57, 0x63, 0xb9, 0x97, 0xc1, + 0x63, 0x83, 0xa2, 0x1d, 0xf8, 0xcb, 0xb4, 0xc5, 0x47, 0xfe, 0x9c, 0x28, 0x1a, 0xf9, 0x0b, 0x26, + 0x64, 0xcc, 0x13, 0xb7, 0xd6, 0xb5, 0xfa, 0x15, 0xbc, 0xae, 0xab, 0xfb, 0x47, 0x2f, 0xb2, 0xda, + 0xa1, 0x29, 0xa1, 0x7f, 0xc0, 0xd6, 0x24, 0xf8, 0x4a, 0xba, 0x75, 0xdd, 0x56, 0xd7, 0xf9, 0x2b, + 0x89, 0xfe, 0x03, 0x90, 0x34, 0x62, 0x73, 0x92, 0xcd, 0x71, 0x6d, 0xfd, 0xa8, 0x86, 0x41, 0x0e, + 0x99, 0xe8, 0x7d, 0x28, 0x83, 0x8d, 0x99, 0x4c, 0x79, 0x22, 0x19, 0xc2, 0xf9, 0x43, 0x35, 0xaf, + 0xa3, 0x27, 0x67, 0xe7, 0x5b, 0x2b, 0x5f, 0xcf, 0xb7, 0x76, 0xc3, 0x58, 0x45, 0xc7, 0x13, 0x8f, + 0xf2, 0xf9, 0x20, 0x8d, 0x93, 0x90, 0x92, 0x74, 0x30, 0x5d, 0x18, 0x01, 0xd3, 0x69, 0x38, 0x90, + 0x11, 0x11, 0x2c, 0x98, 0x9c, 0x2a, 0x26, 0xbd, 0x97, 0x3a, 0x1e, 0x65, 0x71, 0x4e, 0xd4, 0x36, + 0x34, 0x05, 0x0b, 0x63, 0x9e, 0xf8, 0xda, 0x14, 0x9a, 0x56, 0x67, 0xb8, 0xea, 0x15, 0x16, 0x19, + 0x67, 0xbf, 0xd8, 0x31, 0x3d, 0x3a, 0x41, 0xf7, 0xa0, 0x36, 0xe3, 0x74, 0xca, 0x02, 0xcd, 0xb8, + 0x33, 0x5c, 0x5b, 0x4a, 0x75, 0xc0, 0xe9, 0x74, 0x3f, 0x39, 0xe2, 0x38, 0x6f, 0x40, 0x5b, 0xe0, + 0x70, 0x15, 0x31, 0x91, 0x0f, 0xaf, 0x74, 0xad, 0x7e, 0x03, 0x83, 0x86, 0xcc, 0xac, 0x07, 0x50, + 0xd5, 0x12, 0x68, 0xb6, 0x7f, 0x29, 0x93, 0xe9, 0x41, 0x8f, 0xa1, 0xc9, 0x4e, 0x18, 0xf5, 0x03, + 0xa6, 0x48, 0x3c, 0x93, 0x9a, 0x71, 0x67, 0xb8, 0xb1, 0xfc, 0xfb, 0xf1, 0x09, 0xa3, 0x4f, 0x4d, + 0x0d, 0x3b, 0xec, 0x32, 0x41, 0x5d, 0x68, 0x2e, 0xe5, 0x8d, 0x62, 0xa5, 0x35, 0xb0, 0x31, 0xe4, + 0xd2, 0x3e, 0x8b, 0x15, 0x7a, 0x08, 0xc8, 0x94, 0x67, 0x44, 0xaa, 0xa5, 0xa4, 0xb6, 0xd6, 0xaa, + 0xad, 0x2b, 0x07, 0x44, 0xaa, 0x42, 0xcf, 0x1e, 0xb4, 0x28, 0x49, 0xfc, 0x09, 0x33, 0x33, 0x03, + 0xb7, 0xa1, 0x07, 0x3a, 0x94, 0x24, 0x23, 0xa6, 0x67, 0x06, 0xbd, 0x37, 0x16, 0x00, 0xd6, 0xac, + 0x65, 0x8c, 0xa0, 0x7f, 0xa1, 0x91, 0xf3, 0x1c, 0x07, 0x5a, 0xc0, 0x0a, 0xb6, 0x0d, 0xb0, 0x1f, + 0xa0, 0xdd, 0x4b, 0x11, 0x52, 0x4e, 0xa3, 0x5c, 0x84, 0x75, 0x2f, 0x3f, 0x31, 0x33, 0x66, 0x9c, + 0x95, 0x96, 0x4a, 0x64, 0xc9, 0x15, 0x97, 0x97, 0x6f, 0xe1, 0xf2, 0xde, 0x27, 0x0b, 0x9a, 0xa3, + 0xcc, 0x97, 0x77, 0x75, 0x75, 0xdb, 0x50, 0x37, 0xeb, 0x15, 0x67, 0xf7, 0xf7, 0xb5, 0x85, 0x2e, + 0xe9, 0xc0, 0x45, 0xdf, 0xb5, 0xd3, 0xa8, 0xfe, 0xee, 0x34, 0x6a, 0x37, 0x4f, 0xe3, 0xa3, 0x05, + 0xad, 0xfc, 0x35, 0x77, 0x78, 0x1f, 0x37, 0x1c, 0x5c, 0xfa, 0xc9, 0xc1, 0x37, 0x4d, 0x59, 0xbe, + 0xa5, 0x29, 0x47, 0xff, 0x7f, 0x79, 0x6f, 0x5b, 0x67, 0x17, 0x1d, 0xeb, 0xf3, 0x45, 0xc7, 0xfa, + 0x76, 0xd1, 0xb1, 0xde, 0x7e, 0xef, 0xac, 0x40, 0x9b, 0x8b, 0xd0, 0x53, 0xf1, 0x74, 0xe1, 0xe5, + 0x3b, 0x4e, 0x6a, 0xfa, 0x67, 0xe7, 0x47, 0x00, 0x00, 0x00, 0xff, 0xff, 0x9a, 0xf1, 0x47, 0xb2, + 0xd6, 0x05, 0x00, 0x00, } diff --git a/pkg/import_sstpb/import_sstpb.pb.go b/pkg/import_sstpb/import_sstpb.pb.go index 415296c56..c689ff241 100644 --- a/pkg/import_sstpb/import_sstpb.pb.go +++ b/pkg/import_sstpb/import_sstpb.pb.go @@ -56,7 +56,7 @@ func (x SwitchMode) String() string { return proto.EnumName(SwitchMode_name, int32(x)) } func (SwitchMode) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_import_sstpb_cd7d4af5b6c0f6ca, []int{0} + return fileDescriptor_import_sstpb_502e56bc1173f696, []int{0} } type SwitchModeRequest struct { @@ -70,7 +70,7 @@ func (m *SwitchModeRequest) Reset() { *m = SwitchModeRequest{} } func (m *SwitchModeRequest) String() string { return proto.CompactTextString(m) } func (*SwitchModeRequest) ProtoMessage() {} func (*SwitchModeRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_import_sstpb_cd7d4af5b6c0f6ca, []int{0} + return fileDescriptor_import_sstpb_502e56bc1173f696, []int{0} } func (m *SwitchModeRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -116,7 +116,7 @@ func (m *SwitchModeResponse) Reset() { *m = SwitchModeResponse{} } func (m *SwitchModeResponse) String() string { return proto.CompactTextString(m) } func (*SwitchModeResponse) ProtoMessage() {} func (*SwitchModeResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_import_sstpb_cd7d4af5b6c0f6ca, []int{1} + return fileDescriptor_import_sstpb_502e56bc1173f696, []int{1} } func (m *SwitchModeResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -157,7 +157,7 @@ func (m *Range) Reset() { *m = Range{} } func (m *Range) String() string { return proto.CompactTextString(m) } func (*Range) ProtoMessage() {} func (*Range) Descriptor() ([]byte, []int) { - return fileDescriptor_import_sstpb_cd7d4af5b6c0f6ca, []int{2} + return fileDescriptor_import_sstpb_502e56bc1173f696, []int{2} } func (m *Range) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -208,6 +208,7 @@ type SSTMeta struct { CfName string `protobuf:"bytes,5,opt,name=cf_name,json=cfName,proto3" json:"cf_name,omitempty"` RegionId uint64 `protobuf:"varint,6,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty"` RegionEpoch *metapb.RegionEpoch `protobuf:"bytes,7,opt,name=region_epoch,json=regionEpoch" json:"region_epoch,omitempty"` + EndKeyExclusive bool `protobuf:"varint,8,opt,name=end_key_exclusive,json=endKeyExclusive,proto3" json:"end_key_exclusive,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` @@ -217,7 +218,7 @@ func (m *SSTMeta) Reset() { *m = SSTMeta{} } func (m *SSTMeta) String() string { return proto.CompactTextString(m) } func (*SSTMeta) ProtoMessage() {} func (*SSTMeta) Descriptor() ([]byte, []int) { - return fileDescriptor_import_sstpb_cd7d4af5b6c0f6ca, []int{3} + return fileDescriptor_import_sstpb_502e56bc1173f696, []int{3} } func (m *SSTMeta) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -295,6 +296,13 @@ func (m *SSTMeta) GetRegionEpoch() *metapb.RegionEpoch { return nil } +func (m *SSTMeta) GetEndKeyExclusive() bool { + if m != nil { + return m.EndKeyExclusive + } + return false +} + // A rewrite rule is applied on the *encoded* keys (the internal storage // representation). type RewriteRule struct { @@ -310,7 +318,7 @@ func (m *RewriteRule) Reset() { *m = RewriteRule{} } func (m *RewriteRule) String() string { return proto.CompactTextString(m) } func (*RewriteRule) ProtoMessage() {} func (*RewriteRule) Descriptor() ([]byte, []int) { - return fileDescriptor_import_sstpb_cd7d4af5b6c0f6ca, []int{4} + return fileDescriptor_import_sstpb_502e56bc1173f696, []int{4} } func (m *RewriteRule) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -374,7 +382,7 @@ func (m *UploadRequest) Reset() { *m = UploadRequest{} } func (m *UploadRequest) String() string { return proto.CompactTextString(m) } func (*UploadRequest) ProtoMessage() {} func (*UploadRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_import_sstpb_cd7d4af5b6c0f6ca, []int{5} + return fileDescriptor_import_sstpb_502e56bc1173f696, []int{5} } func (m *UploadRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -520,7 +528,7 @@ func (m *UploadResponse) Reset() { *m = UploadResponse{} } func (m *UploadResponse) String() string { return proto.CompactTextString(m) } func (*UploadResponse) ProtoMessage() {} func (*UploadResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_import_sstpb_cd7d4af5b6c0f6ca, []int{6} + return fileDescriptor_import_sstpb_502e56bc1173f696, []int{6} } func (m *UploadResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -561,7 +569,7 @@ func (m *IngestRequest) Reset() { *m = IngestRequest{} } func (m *IngestRequest) String() string { return proto.CompactTextString(m) } func (*IngestRequest) ProtoMessage() {} func (*IngestRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_import_sstpb_cd7d4af5b6c0f6ca, []int{7} + return fileDescriptor_import_sstpb_502e56bc1173f696, []int{7} } func (m *IngestRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -615,7 +623,7 @@ func (m *IngestResponse) Reset() { *m = IngestResponse{} } func (m *IngestResponse) String() string { return proto.CompactTextString(m) } func (*IngestResponse) ProtoMessage() {} func (*IngestResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_import_sstpb_cd7d4af5b6c0f6ca, []int{8} + return fileDescriptor_import_sstpb_502e56bc1173f696, []int{8} } func (m *IngestResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -666,7 +674,7 @@ func (m *CompactRequest) Reset() { *m = CompactRequest{} } func (m *CompactRequest) String() string { return proto.CompactTextString(m) } func (*CompactRequest) ProtoMessage() {} func (*CompactRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_import_sstpb_cd7d4af5b6c0f6ca, []int{9} + return fileDescriptor_import_sstpb_502e56bc1173f696, []int{9} } func (m *CompactRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -719,7 +727,7 @@ func (m *CompactResponse) Reset() { *m = CompactResponse{} } func (m *CompactResponse) String() string { return proto.CompactTextString(m) } func (*CompactResponse) ProtoMessage() {} func (*CompactResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_import_sstpb_cd7d4af5b6c0f6ca, []int{10} + return fileDescriptor_import_sstpb_502e56bc1173f696, []int{10} } func (m *CompactResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -771,6 +779,7 @@ type DownloadRequest struct { // same order, otherwise the RPC request will fail. RewriteRule RewriteRule `protobuf:"bytes,13,opt,name=rewrite_rule,json=rewriteRule" json:"rewrite_rule"` StorageBackend *backup.StorageBackend `protobuf:"bytes,14,opt,name=storage_backend,json=storageBackend" json:"storage_backend,omitempty"` + IsRawKv bool `protobuf:"varint,15,opt,name=is_raw_kv,json=isRawKv,proto3" json:"is_raw_kv,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` @@ -780,7 +789,7 @@ func (m *DownloadRequest) Reset() { *m = DownloadRequest{} } func (m *DownloadRequest) String() string { return proto.CompactTextString(m) } func (*DownloadRequest) ProtoMessage() {} func (*DownloadRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_import_sstpb_cd7d4af5b6c0f6ca, []int{11} + return fileDescriptor_import_sstpb_502e56bc1173f696, []int{11} } func (m *DownloadRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -837,6 +846,13 @@ func (m *DownloadRequest) GetStorageBackend() *backup.StorageBackend { return nil } +func (m *DownloadRequest) GetIsRawKv() bool { + if m != nil { + return m.IsRawKv + } + return false +} + // For now it is just used for distinguishing the error of the request with the error // of gRPC, add more concrete types if it is necessary later. type Error struct { @@ -850,7 +866,7 @@ func (m *Error) Reset() { *m = Error{} } func (m *Error) String() string { return proto.CompactTextString(m) } func (*Error) ProtoMessage() {} func (*Error) Descriptor() ([]byte, []int) { - return fileDescriptor_import_sstpb_cd7d4af5b6c0f6ca, []int{12} + return fileDescriptor_import_sstpb_502e56bc1173f696, []int{12} } func (m *Error) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -903,7 +919,7 @@ func (m *DownloadResponse) Reset() { *m = DownloadResponse{} } func (m *DownloadResponse) String() string { return proto.CompactTextString(m) } func (*DownloadResponse) ProtoMessage() {} func (*DownloadResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_import_sstpb_cd7d4af5b6c0f6ca, []int{13} + return fileDescriptor_import_sstpb_502e56bc1173f696, []int{13} } func (m *DownloadResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -965,7 +981,7 @@ func (m *SetDownloadSpeedLimitRequest) Reset() { *m = SetDownloadSpeedLi func (m *SetDownloadSpeedLimitRequest) String() string { return proto.CompactTextString(m) } func (*SetDownloadSpeedLimitRequest) ProtoMessage() {} func (*SetDownloadSpeedLimitRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_import_sstpb_cd7d4af5b6c0f6ca, []int{14} + return fileDescriptor_import_sstpb_502e56bc1173f696, []int{14} } func (m *SetDownloadSpeedLimitRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1011,7 +1027,7 @@ func (m *SetDownloadSpeedLimitResponse) Reset() { *m = SetDownloadSpeedL func (m *SetDownloadSpeedLimitResponse) String() string { return proto.CompactTextString(m) } func (*SetDownloadSpeedLimitResponse) ProtoMessage() {} func (*SetDownloadSpeedLimitResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_import_sstpb_cd7d4af5b6c0f6ca, []int{15} + return fileDescriptor_import_sstpb_502e56bc1173f696, []int{15} } func (m *SetDownloadSpeedLimitResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1052,7 +1068,7 @@ func (m *Pair) Reset() { *m = Pair{} } func (m *Pair) String() string { return proto.CompactTextString(m) } func (*Pair) ProtoMessage() {} func (*Pair) Descriptor() ([]byte, []int) { - return fileDescriptor_import_sstpb_cd7d4af5b6c0f6ca, []int{16} + return fileDescriptor_import_sstpb_502e56bc1173f696, []int{16} } func (m *Pair) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1107,7 +1123,7 @@ func (m *WriteBatch) Reset() { *m = WriteBatch{} } func (m *WriteBatch) String() string { return proto.CompactTextString(m) } func (*WriteBatch) ProtoMessage() {} func (*WriteBatch) Descriptor() ([]byte, []int) { - return fileDescriptor_import_sstpb_cd7d4af5b6c0f6ca, []int{17} + return fileDescriptor_import_sstpb_502e56bc1173f696, []int{17} } func (m *WriteBatch) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1164,7 +1180,7 @@ func (m *WriteRequest) Reset() { *m = WriteRequest{} } func (m *WriteRequest) String() string { return proto.CompactTextString(m) } func (*WriteRequest) ProtoMessage() {} func (*WriteRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_import_sstpb_cd7d4af5b6c0f6ca, []int{18} + return fileDescriptor_import_sstpb_502e56bc1173f696, []int{18} } func (m *WriteRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1316,7 +1332,7 @@ func (m *WriteResponse) Reset() { *m = WriteResponse{} } func (m *WriteResponse) String() string { return proto.CompactTextString(m) } func (*WriteResponse) ProtoMessage() {} func (*WriteResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_import_sstpb_cd7d4af5b6c0f6ca, []int{19} + return fileDescriptor_import_sstpb_502e56bc1173f696, []int{19} } func (m *WriteResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1878,6 +1894,16 @@ func (m *SSTMeta) MarshalTo(dAtA []byte) (int, error) { } i += n2 } + if m.EndKeyExclusive { + dAtA[i] = 0x40 + i++ + if m.EndKeyExclusive { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i++ + } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } @@ -2171,6 +2197,16 @@ func (m *DownloadRequest) MarshalTo(dAtA []byte) (int, error) { } i += n11 } + if m.IsRawKv { + dAtA[i] = 0x78 + i++ + if m.IsRawKv { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i++ + } if m.XXX_unrecognized != nil { i += copy(dAtA[i:], m.XXX_unrecognized) } @@ -2545,6 +2581,9 @@ func (m *SSTMeta) Size() (n int) { l = m.RegionEpoch.Size() n += 1 + l + sovImportSstpb(uint64(l)) } + if m.EndKeyExclusive { + n += 2 + } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } @@ -2680,6 +2719,9 @@ func (m *DownloadRequest) Size() (n int) { l = m.StorageBackend.Size() n += 1 + l + sovImportSstpb(uint64(l)) } + if m.IsRawKv { + n += 2 + } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } @@ -3281,6 +3323,26 @@ func (m *SSTMeta) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field EndKeyExclusive", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowImportSstpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.EndKeyExclusive = bool(v != 0) default: iNdEx = preIndex skippy, err := skipImportSstpb(dAtA[iNdEx:]) @@ -4105,6 +4167,26 @@ func (m *DownloadRequest) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex + case 15: + 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 ErrIntOverflowImportSstpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.IsRawKv = bool(v != 0) default: iNdEx = preIndex skippy, err := skipImportSstpb(dAtA[iNdEx:]) @@ -5011,76 +5093,79 @@ var ( ErrIntOverflowImportSstpb = fmt.Errorf("proto: integer overflow") ) -func init() { proto.RegisterFile("import_sstpb.proto", fileDescriptor_import_sstpb_cd7d4af5b6c0f6ca) } - -var fileDescriptor_import_sstpb_cd7d4af5b6c0f6ca = []byte{ - // 1075 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x56, 0x4b, 0x73, 0x1b, 0x45, - 0x10, 0xd6, 0x46, 0xbb, 0x7a, 0xb4, 0x1e, 0x56, 0x06, 0x27, 0x28, 0x4a, 0x62, 0x2b, 0x4b, 0x0a, - 0x14, 0x1b, 0x64, 0x4a, 0xa9, 0xca, 0x35, 0x85, 0x12, 0x17, 0x36, 0x79, 0x54, 0x18, 0x99, 0xe2, - 0x40, 0x15, 0xaa, 0xf5, 0xee, 0x58, 0xde, 0xd2, 0xbe, 0x98, 0x99, 0x95, 0xe3, 0x0b, 0x77, 0xfe, - 0x01, 0x3f, 0x81, 0x7f, 0xc1, 0x35, 0x47, 0x8e, 0x9c, 0x28, 0xca, 0xe4, 0x87, 0x50, 0xf3, 0x58, - 0x49, 0xab, 0x92, 0x62, 0x8a, 0x93, 0xa6, 0xbb, 0xbf, 0xe9, 0xee, 0xe9, 0xfe, 0xba, 0x57, 0x80, - 0xfc, 0x30, 0x89, 0x29, 0x1f, 0x33, 0xc6, 0x93, 0xd3, 0x7e, 0x42, 0x63, 0x1e, 0xa3, 0xfa, 0xb2, - 0xae, 0x53, 0x0f, 0x09, 0x77, 0x32, 0x5b, 0xa7, 0x41, 0x28, 0x8d, 0xe9, 0x42, 0x9c, 0xce, 0x68, - 0xe2, 0xce, 0xc5, 0xed, 0x49, 0x3c, 0x89, 0xe5, 0xf1, 0x40, 0x9c, 0xb4, 0x76, 0x8b, 0xa6, 0x8c, - 0xcb, 0xa3, 0x56, 0xd4, 0x4f, 0x1d, 0x77, 0x9a, 0x26, 0x4a, 0xb2, 0xbf, 0x82, 0x9b, 0xa3, 0x0b, - 0x9f, 0xbb, 0xe7, 0xaf, 0x62, 0x8f, 0x60, 0xf2, 0x53, 0x4a, 0x18, 0x47, 0x9f, 0x83, 0x19, 0xc6, - 0x1e, 0x69, 0x1b, 0x5d, 0xa3, 0xd7, 0x1c, 0xb4, 0xfb, 0xb9, 0x34, 0x97, 0xe0, 0x12, 0x65, 0x6f, - 0x03, 0x5a, 0x76, 0xc1, 0x92, 0x38, 0x62, 0xc4, 0x3e, 0x00, 0x0b, 0x3b, 0xd1, 0x84, 0xa0, 0x6d, - 0xb0, 0x18, 0x77, 0x28, 0x97, 0xde, 0xea, 0x58, 0x09, 0xa8, 0x05, 0x45, 0x12, 0x79, 0xed, 0x1b, - 0x52, 0x27, 0x8e, 0xf6, 0x7b, 0x03, 0xca, 0xa3, 0xd1, 0xc9, 0x2b, 0xc2, 0x1d, 0x84, 0xc0, 0x4c, - 0x53, 0xdf, 0xd3, 0x57, 0xe4, 0x19, 0x3d, 0x02, 0x8b, 0x0a, 0x87, 0xf2, 0x4e, 0x6d, 0xf0, 0x51, - 0x3e, 0x2b, 0x19, 0x0b, 0x2b, 0x84, 0x08, 0xe9, 0x52, 0xf7, 0xf1, 0xa0, 0x5d, 0xec, 0x1a, 0xbd, - 0x06, 0x56, 0x02, 0xba, 0x0d, 0xa5, 0x80, 0x44, 0x13, 0x7e, 0xde, 0x36, 0xbb, 0x46, 0xcf, 0xc4, - 0x5a, 0x42, 0x1f, 0x43, 0xd9, 0x3d, 0x1b, 0x47, 0x4e, 0x48, 0xda, 0x56, 0xd7, 0xe8, 0x55, 0x71, - 0xc9, 0x3d, 0x7b, 0xed, 0x84, 0x04, 0xdd, 0x85, 0x2a, 0x25, 0x13, 0x3f, 0x8e, 0xc6, 0xbe, 0xd7, - 0x2e, 0xc9, 0x3b, 0x15, 0xa5, 0x38, 0xf6, 0xd0, 0x13, 0xa8, 0x6b, 0x23, 0x49, 0x62, 0xf7, 0xbc, - 0x5d, 0xd6, 0x59, 0xe9, 0x86, 0x61, 0x69, 0x3b, 0x14, 0x26, 0x5c, 0xa3, 0x0b, 0xc1, 0xfe, 0x19, - 0x6a, 0x98, 0x5c, 0x50, 0x9f, 0x13, 0x9c, 0x06, 0x04, 0x3d, 0x84, 0x66, 0x1c, 0x78, 0xe3, 0x29, - 0xb9, 0x1c, 0x27, 0x94, 0x9c, 0xf9, 0x6f, 0xf5, 0x9b, 0xeb, 0x71, 0xe0, 0xbd, 0x20, 0x97, 0x6f, - 0xa4, 0x4e, 0xa0, 0x22, 0x72, 0xb1, 0x8c, 0x52, 0x85, 0xab, 0x47, 0xe4, 0x62, 0x81, 0xfa, 0x04, - 0x1a, 0x02, 0xc5, 0xfd, 0x90, 0x30, 0xee, 0x84, 0x89, 0x7c, 0xbe, 0x29, 0x41, 0x27, 0x99, 0xce, - 0xfe, 0x01, 0x1a, 0xdf, 0x25, 0x41, 0xec, 0x78, 0x59, 0xb3, 0xf7, 0xc1, 0x14, 0x39, 0xcb, 0xb8, - 0xb5, 0xc1, 0xad, 0x95, 0x66, 0xab, 0x86, 0x1c, 0x15, 0xb0, 0x04, 0xa1, 0x6d, 0x30, 0x3d, 0x87, - 0x3b, 0x2a, 0xbc, 0xd0, 0x0a, 0x69, 0x58, 0x06, 0xcb, 0x3d, 0x4f, 0xa3, 0xa9, 0xdd, 0x82, 0x66, - 0xe6, 0x5c, 0xd3, 0xc0, 0x83, 0xc6, 0x71, 0x34, 0x21, 0x8c, 0x67, 0xe1, 0xf6, 0xa0, 0xec, 0xc6, - 0x11, 0x27, 0x6f, 0xb9, 0x8e, 0xd8, 0xea, 0x67, 0x34, 0x7e, 0xa6, 0xf4, 0x38, 0x03, 0xa0, 0xcf, - 0xa0, 0xc8, 0x18, 0xd7, 0x0d, 0x5f, 0x9f, 0x19, 0x16, 0x08, 0xfb, 0x09, 0x34, 0xb3, 0x28, 0x2a, - 0x2e, 0x7a, 0x08, 0x96, 0x1c, 0x16, 0x1d, 0xa4, 0xd9, 0xcf, 0x46, 0xe7, 0x50, 0xfc, 0x62, 0x65, - 0xb4, 0x7f, 0x84, 0xe6, 0xb3, 0x38, 0x4c, 0x1c, 0x77, 0x9e, 0xde, 0x9c, 0x65, 0xc6, 0xb5, 0x2c, - 0x7b, 0x00, 0xf5, 0x38, 0xe5, 0x49, 0xca, 0xc7, 0x01, 0x99, 0x91, 0x40, 0xa6, 0x69, 0xe1, 0x9a, - 0xd2, 0xbd, 0x14, 0x2a, 0xfb, 0x26, 0x6c, 0xcd, 0xfd, 0xeb, 0x82, 0xbc, 0x37, 0x60, 0xeb, 0x79, - 0x7c, 0x11, 0x2d, 0xb7, 0xe0, 0x8b, 0xeb, 0xdf, 0x39, 0x34, 0xdf, 0xfd, 0xb5, 0x5b, 0x90, 0xaf, - 0x15, 0xd3, 0x21, 0xd9, 0x5a, 0x95, 0x6c, 0x95, 0x67, 0x34, 0x14, 0x74, 0x94, 0xb4, 0x1a, 0xd3, - 0x34, 0x20, 0xed, 0x86, 0xf4, 0x75, 0x67, 0x25, 0xfd, 0x05, 0xf1, 0xb4, 0xbf, 0x1a, 0x5d, 0xe2, - 0xe2, 0x53, 0xd8, 0x62, 0x3c, 0xa6, 0xce, 0x84, 0x8c, 0xc5, 0x8e, 0x10, 0xf3, 0xd9, 0x94, 0x6e, - 0x6e, 0xf7, 0xf5, 0xce, 0x18, 0x29, 0xf3, 0x50, 0x59, 0x71, 0x93, 0xe5, 0xe4, 0x6f, 0xcc, 0x4a, - 0xa5, 0x55, 0xc5, 0xc5, 0x94, 0x06, 0xf6, 0x03, 0xb0, 0x64, 0xa5, 0x51, 0x1b, 0xca, 0x21, 0x61, - 0xcc, 0xd1, 0x25, 0xad, 0xe2, 0x4c, 0xb4, 0x7f, 0x31, 0xa0, 0xb5, 0xa8, 0x84, 0xee, 0xdb, 0xc1, - 0xf5, 0xf5, 0xd7, 0xa9, 0xeb, 0x2e, 0xdc, 0x81, 0x8a, 0xcf, 0xc6, 0x24, 0x4c, 0xf8, 0xa5, 0x2c, - 0x60, 0x05, 0x97, 0x7d, 0x76, 0x28, 0x44, 0xd1, 0x4b, 0xc5, 0x81, 0xe2, 0x3a, 0x5f, 0x39, 0x22, - 0x3c, 0x85, 0x7b, 0x23, 0xc2, 0xb3, 0x6c, 0x46, 0x09, 0x21, 0xde, 0x4b, 0x3f, 0xf4, 0xe7, 0xb4, - 0xd8, 0x85, 0x1a, 0x13, 0xca, 0x71, 0x20, 0xb4, 0x32, 0x39, 0x13, 0x03, 0x9b, 0xe3, 0xec, 0x5d, - 0xb8, 0xbf, 0xc1, 0x81, 0xee, 0x7b, 0x1f, 0xcc, 0x37, 0x8e, 0x4f, 0xc5, 0xe2, 0x9b, 0x92, 0x4b, - 0x3d, 0xe5, 0xe2, 0x28, 0xb6, 0xd5, 0xcc, 0x09, 0x52, 0xa2, 0x67, 0x5a, 0x09, 0xf6, 0x08, 0xe0, - 0x7b, 0xd1, 0x99, 0xa1, 0xc3, 0xdd, 0x73, 0xb1, 0x8a, 0xdc, 0x38, 0x0c, 0x7d, 0x3e, 0xe6, 0x4c, - 0x47, 0xaf, 0x28, 0xc5, 0x09, 0x43, 0x3d, 0xb0, 0x12, 0xc7, 0xa7, 0xac, 0x7d, 0xa3, 0x5b, 0xec, - 0xd5, 0x06, 0x28, 0xff, 0x4e, 0x11, 0x15, 0x2b, 0x80, 0x3d, 0x83, 0xba, 0x74, 0xfa, 0xbf, 0x66, - 0xff, 0x4b, 0xb0, 0x4e, 0x45, 0x32, 0x9a, 0xa7, 0x2b, 0x9f, 0x85, 0x45, 0xb2, 0x47, 0x05, 0xac, - 0x80, 0x8b, 0xbd, 0x30, 0x81, 0x86, 0x8e, 0xab, 0xdb, 0xfc, 0x28, 0x3f, 0x9e, 0x1f, 0x68, 0x0d, - 0xda, 0x07, 0x4b, 0x84, 0xcf, 0x5e, 0xb7, 0x61, 0x0d, 0x28, 0xcc, 0xde, 0x43, 0x80, 0xc5, 0xb7, - 0x08, 0x01, 0x94, 0x5e, 0xc7, 0x34, 0x74, 0x82, 0x56, 0x41, 0x9c, 0x8f, 0xe5, 0xc5, 0x96, 0x31, - 0xf8, 0xdd, 0x84, 0xaa, 0x12, 0x46, 0xa3, 0x13, 0xf4, 0x6d, 0xee, 0xce, 0xee, 0xc6, 0xaf, 0x9d, - 0xaa, 0x59, 0xa7, 0xbb, 0x19, 0xa0, 0x5b, 0x5d, 0x40, 0x5f, 0x43, 0x49, 0xed, 0x41, 0x74, 0x37, - 0x8f, 0xce, 0xad, 0xde, 0xce, 0xbd, 0xf5, 0xc6, 0xcc, 0x4d, 0xcf, 0x40, 0x87, 0x50, 0x52, 0x8b, - 0x6d, 0xd5, 0x51, 0x6e, 0xa9, 0xae, 0x3a, 0xca, 0xef, 0x42, 0xbb, 0x80, 0x8e, 0xa0, 0xac, 0xf7, - 0x10, 0x5a, 0x81, 0xe6, 0xd7, 0x5f, 0xe7, 0xfe, 0x06, 0xeb, 0xdc, 0x13, 0x85, 0x5b, 0x6b, 0x79, - 0x8e, 0xf6, 0x56, 0xca, 0xf2, 0x81, 0x69, 0xea, 0xec, 0xff, 0x27, 0xec, 0x3c, 0xe6, 0x0b, 0xa8, - 0x64, 0x76, 0xb4, 0x92, 0xe0, 0xca, 0x26, 0xed, 0xec, 0x6c, 0x32, 0xcf, 0x9d, 0x3d, 0x07, 0x4b, - 0x52, 0x11, 0x75, 0xd6, 0xf0, 0x37, 0x73, 0x73, 0x77, 0xad, 0x6d, 0xd1, 0x97, 0xe1, 0xa7, 0x7f, - 0xfe, 0x56, 0x31, 0xde, 0x5d, 0xed, 0x18, 0x7f, 0x5c, 0xed, 0x18, 0x7f, 0x5f, 0xed, 0x18, 0xbf, - 0xfe, 0xb3, 0x53, 0x80, 0x56, 0x4c, 0x27, 0x7d, 0xee, 0x4f, 0x67, 0xfd, 0xe9, 0x4c, 0xfe, 0xbd, - 0x3a, 0x2d, 0xc9, 0x9f, 0xc7, 0xff, 0x06, 0x00, 0x00, 0xff, 0xff, 0x60, 0xaf, 0xe8, 0x05, 0xea, - 0x09, 0x00, 0x00, +func init() { proto.RegisterFile("import_sstpb.proto", fileDescriptor_import_sstpb_502e56bc1173f696) } + +var fileDescriptor_import_sstpb_502e56bc1173f696 = []byte{ + // 1121 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x56, 0x4b, 0x8f, 0x1b, 0x45, + 0x10, 0xf6, 0xec, 0xce, 0xf8, 0x51, 0x7e, 0xac, 0xd3, 0x6c, 0xc2, 0xc4, 0x49, 0x76, 0x9d, 0x21, + 0x02, 0x67, 0x03, 0x0e, 0xda, 0x48, 0xb9, 0x46, 0x38, 0x59, 0x91, 0x90, 0x87, 0x42, 0x7b, 0x11, + 0x07, 0x24, 0x46, 0xb3, 0x33, 0x1d, 0xef, 0xc8, 0xf3, 0xa2, 0xbb, 0xc7, 0xce, 0x5e, 0x10, 0x57, + 0x6e, 0x1c, 0xf9, 0x09, 0xfc, 0x0b, 0xae, 0x39, 0x72, 0xe4, 0x84, 0x50, 0xf8, 0x23, 0xa8, 0x1f, + 0x63, 0x7b, 0x2c, 0x3b, 0x41, 0x9c, 0xdc, 0x55, 0xf5, 0x75, 0x55, 0x75, 0xd7, 0xd7, 0xdf, 0x18, + 0x50, 0x18, 0x67, 0x29, 0xe5, 0x2e, 0x63, 0x3c, 0x3b, 0x1b, 0x66, 0x34, 0xe5, 0x29, 0x6a, 0xad, + 0xfa, 0x7a, 0xad, 0x98, 0x70, 0xaf, 0x88, 0xf5, 0xda, 0x84, 0xd2, 0x94, 0x2e, 0xcd, 0xe9, 0x8c, + 0x66, 0xfe, 0xc2, 0xdc, 0x9f, 0xa4, 0x93, 0x54, 0x2e, 0xef, 0x8a, 0x95, 0xf6, 0xee, 0xd1, 0x9c, + 0x71, 0xb9, 0xd4, 0x8e, 0xd6, 0x99, 0xe7, 0x4f, 0xf3, 0x4c, 0x59, 0xce, 0x17, 0x70, 0x69, 0x3c, + 0x0f, 0xb9, 0x7f, 0xfe, 0x3c, 0x0d, 0x08, 0x26, 0x3f, 0xe4, 0x84, 0x71, 0xf4, 0x29, 0x98, 0x71, + 0x1a, 0x10, 0xdb, 0xe8, 0x1b, 0x83, 0xce, 0xb1, 0x3d, 0x2c, 0xb5, 0xb9, 0x02, 0x97, 0x28, 0x67, + 0x1f, 0xd0, 0x6a, 0x0a, 0x96, 0xa5, 0x09, 0x23, 0xce, 0x5d, 0xb0, 0xb0, 0x97, 0x4c, 0x08, 0xda, + 0x07, 0x8b, 0x71, 0x8f, 0x72, 0x99, 0xad, 0x85, 0x95, 0x81, 0xba, 0xb0, 0x4b, 0x92, 0xc0, 0xde, + 0x91, 0x3e, 0xb1, 0x74, 0x7e, 0xd9, 0x81, 0xda, 0x78, 0x7c, 0xfa, 0x9c, 0x70, 0x0f, 0x21, 0x30, + 0xf3, 0x3c, 0x0c, 0xf4, 0x16, 0xb9, 0x46, 0xb7, 0xc1, 0xa2, 0x22, 0xa1, 0xdc, 0xd3, 0x3c, 0xfe, + 0xa0, 0xdc, 0x95, 0xac, 0x85, 0x15, 0x42, 0x94, 0xf4, 0xa9, 0x7f, 0xef, 0xd8, 0xde, 0xed, 0x1b, + 0x83, 0x36, 0x56, 0x06, 0xba, 0x02, 0xd5, 0x88, 0x24, 0x13, 0x7e, 0x6e, 0x9b, 0x7d, 0x63, 0x60, + 0x62, 0x6d, 0xa1, 0x0f, 0xa1, 0xe6, 0xbf, 0x72, 0x13, 0x2f, 0x26, 0xb6, 0xd5, 0x37, 0x06, 0x0d, + 0x5c, 0xf5, 0x5f, 0xbd, 0xf0, 0x62, 0x82, 0xae, 0x41, 0x83, 0x92, 0x49, 0x98, 0x26, 0x6e, 0x18, + 0xd8, 0x55, 0xb9, 0xa7, 0xae, 0x1c, 0x4f, 0x02, 0x74, 0x1f, 0x5a, 0x3a, 0x48, 0xb2, 0xd4, 0x3f, + 0xb7, 0x6b, 0xba, 0x2b, 0x3d, 0x30, 0x2c, 0x63, 0x27, 0x22, 0x84, 0x9b, 0x74, 0x69, 0xa0, 0x23, + 0xb8, 0x44, 0x92, 0xc0, 0x9d, 0x92, 0x0b, 0x97, 0xbc, 0xf6, 0xa3, 0x9c, 0x85, 0x33, 0x62, 0xd7, + 0xfb, 0xc6, 0xa0, 0x8e, 0xf7, 0x48, 0x12, 0x3c, 0x25, 0x17, 0x27, 0x85, 0xdb, 0xf9, 0x11, 0x9a, + 0x98, 0xcc, 0x69, 0xc8, 0x09, 0xce, 0x23, 0x82, 0x6e, 0x41, 0x27, 0x8d, 0xd4, 0xd6, 0x8c, 0x92, + 0x57, 0xe1, 0x6b, 0x7d, 0x3f, 0xad, 0x34, 0x12, 0xfb, 0x5e, 0x4a, 0x9f, 0x40, 0x25, 0x64, 0xbe, + 0x8a, 0x52, 0x97, 0xdc, 0x4a, 0xc8, 0x7c, 0x89, 0xfa, 0x08, 0xda, 0x02, 0xc5, 0xc3, 0x98, 0x30, + 0xee, 0xc5, 0x99, 0xbc, 0x2a, 0x53, 0x82, 0x4e, 0x0b, 0x9f, 0xf3, 0x1d, 0xb4, 0xbf, 0xc9, 0xa2, + 0xd4, 0x0b, 0x0a, 0x62, 0xdc, 0x01, 0x53, 0x9c, 0x4f, 0xd6, 0x6d, 0x1e, 0x5f, 0x5e, 0x23, 0x86, + 0x1a, 0xde, 0xe3, 0x0a, 0x96, 0x20, 0xb4, 0x0f, 0x66, 0xe0, 0x71, 0x4f, 0x95, 0x17, 0x5e, 0x61, + 0x8d, 0x6a, 0x60, 0xf9, 0xe7, 0x79, 0x32, 0x75, 0xba, 0xd0, 0x29, 0x92, 0x6b, 0xca, 0x04, 0xd0, + 0x7e, 0x92, 0x4c, 0x08, 0xe3, 0x45, 0xb9, 0x23, 0xa8, 0xf9, 0x69, 0xc2, 0xc9, 0x6b, 0xae, 0x2b, + 0x76, 0x87, 0x05, 0xe5, 0x1f, 0x2a, 0x3f, 0x2e, 0x00, 0xe8, 0x13, 0xd8, 0x65, 0x8c, 0x6b, 0x72, + 0x6c, 0xee, 0x0c, 0x0b, 0x84, 0x73, 0x1f, 0x3a, 0x45, 0x15, 0x55, 0x17, 0xdd, 0x02, 0x4b, 0x3e, + 0x2c, 0x5d, 0xa4, 0x33, 0x2c, 0x9e, 0xd9, 0x89, 0xf8, 0xc5, 0x2a, 0xe8, 0x7c, 0x0f, 0x9d, 0x87, + 0x69, 0x9c, 0x79, 0xfe, 0xa2, 0xbd, 0x05, 0x23, 0x8d, 0xf7, 0x32, 0xf2, 0x26, 0xb4, 0xd2, 0x9c, + 0x67, 0x39, 0x77, 0x23, 0x32, 0x23, 0x91, 0x6c, 0xd3, 0xc2, 0x4d, 0xe5, 0x7b, 0x26, 0x5c, 0xce, + 0x25, 0xd8, 0x5b, 0xe4, 0xd7, 0x17, 0xf2, 0xd3, 0x0e, 0xec, 0x3d, 0x4a, 0xe7, 0xc9, 0xea, 0x08, + 0x3e, 0x7b, 0xff, 0x39, 0x47, 0xe6, 0x9b, 0xbf, 0x0e, 0x2b, 0xf2, 0xb4, 0xe2, 0x25, 0x49, 0x66, + 0x37, 0x24, 0xb3, 0xe5, 0x1a, 0x8d, 0x04, 0x75, 0x25, 0xad, 0x5c, 0x9a, 0x47, 0xc4, 0x6e, 0xcb, + 0x5c, 0x57, 0xd7, 0xda, 0x5f, 0x12, 0x4f, 0xe7, 0x6b, 0xd2, 0x15, 0x2e, 0x3e, 0x80, 0x3d, 0xc6, + 0x53, 0xea, 0x4d, 0x88, 0x2b, 0xf4, 0x44, 0xbc, 0xe5, 0x8e, 0x4c, 0x73, 0x65, 0xa8, 0xf5, 0x65, + 0xac, 0xc2, 0x23, 0x15, 0xc5, 0x1d, 0x56, 0xb2, 0x51, 0x0f, 0x1a, 0x21, 0x73, 0xa9, 0x37, 0x77, + 0xa7, 0x33, 0x7b, 0x4f, 0xf2, 0xbf, 0x16, 0x32, 0xec, 0xcd, 0x9f, 0xce, 0xbe, 0x32, 0xeb, 0xf5, + 0x6e, 0x03, 0xef, 0xe6, 0x34, 0x72, 0x6e, 0x82, 0x25, 0xa7, 0x80, 0x6c, 0xa8, 0xc5, 0x84, 0x31, + 0x4f, 0x5f, 0x77, 0x03, 0x17, 0xa6, 0xf3, 0xb3, 0x01, 0xdd, 0xe5, 0x2d, 0xe9, 0x99, 0xde, 0x7d, + 0xff, 0x6c, 0xf4, 0xb1, 0xf4, 0x84, 0xae, 0x42, 0x3d, 0x64, 0x2e, 0x89, 0x33, 0x7e, 0x21, 0x2f, + 0x57, 0xb6, 0x73, 0x22, 0x4c, 0x31, 0x67, 0xc5, 0x8f, 0xdd, 0x4d, 0xb9, 0x4a, 0x24, 0x79, 0x00, + 0xd7, 0xc7, 0x84, 0x17, 0xdd, 0x8c, 0x33, 0x42, 0x82, 0x67, 0x61, 0x1c, 0x2e, 0x28, 0x73, 0x08, + 0x4d, 0x26, 0x9c, 0x6e, 0x24, 0xbc, 0xb2, 0x39, 0x13, 0x03, 0x5b, 0xe0, 0x9c, 0x43, 0xb8, 0xb1, + 0x25, 0x81, 0xe6, 0xc4, 0x10, 0xcc, 0x97, 0x5e, 0x48, 0x85, 0x80, 0x4e, 0xc9, 0x85, 0x56, 0x00, + 0xb1, 0x14, 0xaa, 0x37, 0xf3, 0xa2, 0x9c, 0xe8, 0xf7, 0xae, 0x0c, 0x67, 0x0c, 0xf0, 0xad, 0x98, + 0xda, 0xc8, 0xe3, 0xfe, 0xb9, 0x90, 0x34, 0x3f, 0x8d, 0xe3, 0x90, 0xbb, 0x9c, 0xe9, 0xea, 0x75, + 0xe5, 0x38, 0x65, 0x68, 0x00, 0x56, 0xe6, 0x85, 0x94, 0xd9, 0x3b, 0xfd, 0xdd, 0x41, 0xf3, 0x18, + 0x95, 0xcf, 0x29, 0xaa, 0x62, 0x05, 0x70, 0x66, 0xd0, 0x92, 0x49, 0xff, 0x97, 0x2e, 0x7c, 0x0e, + 0xd6, 0x99, 0x68, 0x46, 0x73, 0x78, 0xed, 0xf3, 0xb2, 0x6c, 0xf6, 0x71, 0x05, 0x2b, 0xe0, 0x52, + 0x33, 0x26, 0xd0, 0xd6, 0x75, 0xf5, 0x98, 0x6f, 0x97, 0x9f, 0xee, 0x3b, 0x46, 0x83, 0xee, 0x80, + 0x25, 0xca, 0x17, 0xa7, 0xdb, 0x22, 0x11, 0x0a, 0x73, 0x74, 0x0b, 0x60, 0xf9, 0x4d, 0x43, 0x00, + 0xd5, 0x17, 0x29, 0x8d, 0xbd, 0xa8, 0x5b, 0x11, 0xeb, 0x27, 0x72, 0x63, 0xd7, 0x38, 0xfe, 0xdd, + 0x84, 0x86, 0x32, 0xc6, 0xe3, 0x53, 0xf4, 0x75, 0x69, 0xcf, 0xe1, 0xd6, 0xaf, 0xa6, 0xba, 0xb3, + 0x5e, 0x7f, 0x3b, 0x40, 0x8f, 0xba, 0x82, 0xbe, 0x84, 0xaa, 0xd2, 0x48, 0x74, 0xad, 0x8c, 0x2e, + 0xc9, 0x72, 0xef, 0xfa, 0xe6, 0x60, 0x91, 0x66, 0x60, 0xa0, 0x13, 0xa8, 0x2a, 0xd1, 0x5b, 0x4f, + 0x54, 0x12, 0xdc, 0xf5, 0x44, 0x65, 0x9d, 0x74, 0x2a, 0xe8, 0x31, 0xd4, 0xb4, 0x46, 0xa1, 0x35, + 0x68, 0x59, 0x1a, 0x7b, 0x37, 0xb6, 0x44, 0x17, 0x99, 0x28, 0x5c, 0xde, 0xc8, 0x73, 0x74, 0xb4, + 0x76, 0x2d, 0xef, 0x78, 0x4d, 0xbd, 0x3b, 0xff, 0x09, 0xbb, 0xa8, 0xf9, 0x14, 0xea, 0x45, 0x1c, + 0xad, 0x35, 0xb8, 0xa6, 0xb2, 0xbd, 0x83, 0x6d, 0xe1, 0x45, 0xb2, 0x47, 0x60, 0x49, 0x2a, 0xa2, + 0xde, 0x06, 0xfe, 0x16, 0x69, 0xae, 0x6d, 0x8c, 0x2d, 0xe7, 0x32, 0xfa, 0xf8, 0xcf, 0xdf, 0xea, + 0xc6, 0x9b, 0xb7, 0x07, 0xc6, 0x1f, 0x6f, 0x0f, 0x8c, 0xbf, 0xdf, 0x1e, 0x18, 0xbf, 0xfe, 0x73, + 0x50, 0x81, 0x6e, 0x4a, 0x27, 0x43, 0x1e, 0x4e, 0x67, 0xc3, 0xe9, 0x4c, 0xfe, 0x4d, 0x3b, 0xab, + 0xca, 0x9f, 0x7b, 0xff, 0x06, 0x00, 0x00, 0xff, 0xff, 0xae, 0x1e, 0x5e, 0xc2, 0x32, 0x0a, 0x00, + 0x00, } diff --git a/pkg/pdpb/pdpb.pb.go b/pkg/pdpb/pdpb.pb.go index 0b46658e8..07ae8862c 100644 --- a/pkg/pdpb/pdpb.pb.go +++ b/pkg/pdpb/pdpb.pb.go @@ -16,7 +16,7 @@ import ( metapb "github.com/pingcap/kvproto/pkg/metapb" - replicate_mode "github.com/pingcap/kvproto/pkg/replicate_mode" + replication_modepb "github.com/pingcap/kvproto/pkg/replication_modepb" context "golang.org/x/net/context" @@ -69,7 +69,7 @@ func (x ErrorType) String() string { return proto.EnumName(ErrorType_name, int32(x)) } func (ErrorType) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_pdpb_44ca8d4a3d8ba006, []int{0} + return fileDescriptor_pdpb_d3e161b7e0af7b49, []int{0} } type CheckPolicy int32 @@ -95,7 +95,7 @@ func (x CheckPolicy) String() string { return proto.EnumName(CheckPolicy_name, int32(x)) } func (CheckPolicy) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_pdpb_44ca8d4a3d8ba006, []int{1} + return fileDescriptor_pdpb_d3e161b7e0af7b49, []int{1} } type OperatorStatus int32 @@ -127,7 +127,7 @@ func (x OperatorStatus) String() string { return proto.EnumName(OperatorStatus_name, int32(x)) } func (OperatorStatus) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_pdpb_44ca8d4a3d8ba006, []int{2} + return fileDescriptor_pdpb_d3e161b7e0af7b49, []int{2} } type RequestHeader struct { @@ -142,7 +142,7 @@ func (m *RequestHeader) Reset() { *m = RequestHeader{} } func (m *RequestHeader) String() string { return proto.CompactTextString(m) } func (*RequestHeader) ProtoMessage() {} func (*RequestHeader) Descriptor() ([]byte, []int) { - return fileDescriptor_pdpb_44ca8d4a3d8ba006, []int{0} + return fileDescriptor_pdpb_d3e161b7e0af7b49, []int{0} } func (m *RequestHeader) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -191,7 +191,7 @@ func (m *ResponseHeader) Reset() { *m = ResponseHeader{} } func (m *ResponseHeader) String() string { return proto.CompactTextString(m) } func (*ResponseHeader) ProtoMessage() {} func (*ResponseHeader) Descriptor() ([]byte, []int) { - return fileDescriptor_pdpb_44ca8d4a3d8ba006, []int{1} + return fileDescriptor_pdpb_d3e161b7e0af7b49, []int{1} } func (m *ResponseHeader) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -246,7 +246,7 @@ func (m *Error) Reset() { *m = Error{} } func (m *Error) String() string { return proto.CompactTextString(m) } func (*Error) ProtoMessage() {} func (*Error) Descriptor() ([]byte, []int) { - return fileDescriptor_pdpb_44ca8d4a3d8ba006, []int{2} + return fileDescriptor_pdpb_d3e161b7e0af7b49, []int{2} } func (m *Error) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -301,7 +301,7 @@ func (m *TsoRequest) Reset() { *m = TsoRequest{} } func (m *TsoRequest) String() string { return proto.CompactTextString(m) } func (*TsoRequest) ProtoMessage() {} func (*TsoRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_pdpb_44ca8d4a3d8ba006, []int{3} + return fileDescriptor_pdpb_d3e161b7e0af7b49, []int{3} } func (m *TsoRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -356,7 +356,7 @@ func (m *Timestamp) Reset() { *m = Timestamp{} } func (m *Timestamp) String() string { return proto.CompactTextString(m) } func (*Timestamp) ProtoMessage() {} func (*Timestamp) Descriptor() ([]byte, []int) { - return fileDescriptor_pdpb_44ca8d4a3d8ba006, []int{4} + return fileDescriptor_pdpb_d3e161b7e0af7b49, []int{4} } func (m *Timestamp) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -412,7 +412,7 @@ func (m *TsoResponse) Reset() { *m = TsoResponse{} } func (m *TsoResponse) String() string { return proto.CompactTextString(m) } func (*TsoResponse) ProtoMessage() {} func (*TsoResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_pdpb_44ca8d4a3d8ba006, []int{5} + return fileDescriptor_pdpb_d3e161b7e0af7b49, []int{5} } func (m *TsoResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -475,7 +475,7 @@ func (m *BootstrapRequest) Reset() { *m = BootstrapRequest{} } func (m *BootstrapRequest) String() string { return proto.CompactTextString(m) } func (*BootstrapRequest) ProtoMessage() {} func (*BootstrapRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_pdpb_44ca8d4a3d8ba006, []int{6} + return fileDescriptor_pdpb_d3e161b7e0af7b49, []int{6} } func (m *BootstrapRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -526,18 +526,18 @@ func (m *BootstrapRequest) GetRegion() *metapb.Region { } type BootstrapResponse struct { - Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` - ReplicateStatus *replicate_mode.ReplicateStatus `protobuf:"bytes,2,opt,name=replicate_status,json=replicateStatus" json:"replicate_status,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + ReplicationStatus *replication_modepb.ReplicationStatus `protobuf:"bytes,2,opt,name=replication_status,json=replicationStatus" json:"replication_status,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } func (m *BootstrapResponse) Reset() { *m = BootstrapResponse{} } func (m *BootstrapResponse) String() string { return proto.CompactTextString(m) } func (*BootstrapResponse) ProtoMessage() {} func (*BootstrapResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_pdpb_44ca8d4a3d8ba006, []int{7} + return fileDescriptor_pdpb_d3e161b7e0af7b49, []int{7} } func (m *BootstrapResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -573,9 +573,9 @@ func (m *BootstrapResponse) GetHeader() *ResponseHeader { return nil } -func (m *BootstrapResponse) GetReplicateStatus() *replicate_mode.ReplicateStatus { +func (m *BootstrapResponse) GetReplicationStatus() *replication_modepb.ReplicationStatus { if m != nil { - return m.ReplicateStatus + return m.ReplicationStatus } return nil } @@ -591,7 +591,7 @@ func (m *IsBootstrappedRequest) Reset() { *m = IsBootstrappedRequest{} } func (m *IsBootstrappedRequest) String() string { return proto.CompactTextString(m) } func (*IsBootstrappedRequest) ProtoMessage() {} func (*IsBootstrappedRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_pdpb_44ca8d4a3d8ba006, []int{8} + return fileDescriptor_pdpb_d3e161b7e0af7b49, []int{8} } func (m *IsBootstrappedRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -639,7 +639,7 @@ func (m *IsBootstrappedResponse) Reset() { *m = IsBootstrappedResponse{} func (m *IsBootstrappedResponse) String() string { return proto.CompactTextString(m) } func (*IsBootstrappedResponse) ProtoMessage() {} func (*IsBootstrappedResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_pdpb_44ca8d4a3d8ba006, []int{9} + return fileDescriptor_pdpb_d3e161b7e0af7b49, []int{9} } func (m *IsBootstrappedResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -693,7 +693,7 @@ func (m *AllocIDRequest) Reset() { *m = AllocIDRequest{} } func (m *AllocIDRequest) String() string { return proto.CompactTextString(m) } func (*AllocIDRequest) ProtoMessage() {} func (*AllocIDRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_pdpb_44ca8d4a3d8ba006, []int{10} + return fileDescriptor_pdpb_d3e161b7e0af7b49, []int{10} } func (m *AllocIDRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -741,7 +741,7 @@ func (m *AllocIDResponse) Reset() { *m = AllocIDResponse{} } func (m *AllocIDResponse) String() string { return proto.CompactTextString(m) } func (*AllocIDResponse) ProtoMessage() {} func (*AllocIDResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_pdpb_44ca8d4a3d8ba006, []int{11} + return fileDescriptor_pdpb_d3e161b7e0af7b49, []int{11} } func (m *AllocIDResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -796,7 +796,7 @@ func (m *GetStoreRequest) Reset() { *m = GetStoreRequest{} } func (m *GetStoreRequest) String() string { return proto.CompactTextString(m) } func (*GetStoreRequest) ProtoMessage() {} func (*GetStoreRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_pdpb_44ca8d4a3d8ba006, []int{12} + return fileDescriptor_pdpb_d3e161b7e0af7b49, []int{12} } func (m *GetStoreRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -852,7 +852,7 @@ func (m *GetStoreResponse) Reset() { *m = GetStoreResponse{} } func (m *GetStoreResponse) String() string { return proto.CompactTextString(m) } func (*GetStoreResponse) ProtoMessage() {} func (*GetStoreResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_pdpb_44ca8d4a3d8ba006, []int{13} + return fileDescriptor_pdpb_d3e161b7e0af7b49, []int{13} } func (m *GetStoreResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -914,7 +914,7 @@ func (m *PutStoreRequest) Reset() { *m = PutStoreRequest{} } func (m *PutStoreRequest) String() string { return proto.CompactTextString(m) } func (*PutStoreRequest) ProtoMessage() {} func (*PutStoreRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_pdpb_44ca8d4a3d8ba006, []int{14} + return fileDescriptor_pdpb_d3e161b7e0af7b49, []int{14} } func (m *PutStoreRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -958,18 +958,18 @@ func (m *PutStoreRequest) GetStore() *metapb.Store { } type PutStoreResponse struct { - Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` - ReplicateStatus *replicate_mode.ReplicateStatus `protobuf:"bytes,2,opt,name=replicate_status,json=replicateStatus" json:"replicate_status,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + ReplicationStatus *replication_modepb.ReplicationStatus `protobuf:"bytes,2,opt,name=replication_status,json=replicationStatus" json:"replication_status,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } func (m *PutStoreResponse) Reset() { *m = PutStoreResponse{} } func (m *PutStoreResponse) String() string { return proto.CompactTextString(m) } func (*PutStoreResponse) ProtoMessage() {} func (*PutStoreResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_pdpb_44ca8d4a3d8ba006, []int{15} + return fileDescriptor_pdpb_d3e161b7e0af7b49, []int{15} } func (m *PutStoreResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1005,9 +1005,9 @@ func (m *PutStoreResponse) GetHeader() *ResponseHeader { return nil } -func (m *PutStoreResponse) GetReplicateStatus() *replicate_mode.ReplicateStatus { +func (m *PutStoreResponse) GetReplicationStatus() *replication_modepb.ReplicationStatus { if m != nil { - return m.ReplicateStatus + return m.ReplicationStatus } return nil } @@ -1025,7 +1025,7 @@ func (m *GetAllStoresRequest) Reset() { *m = GetAllStoresRequest{} } func (m *GetAllStoresRequest) String() string { return proto.CompactTextString(m) } func (*GetAllStoresRequest) ProtoMessage() {} func (*GetAllStoresRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_pdpb_44ca8d4a3d8ba006, []int{16} + return fileDescriptor_pdpb_d3e161b7e0af7b49, []int{16} } func (m *GetAllStoresRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1080,7 +1080,7 @@ func (m *GetAllStoresResponse) Reset() { *m = GetAllStoresResponse{} } func (m *GetAllStoresResponse) String() string { return proto.CompactTextString(m) } func (*GetAllStoresResponse) ProtoMessage() {} func (*GetAllStoresResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_pdpb_44ca8d4a3d8ba006, []int{17} + return fileDescriptor_pdpb_d3e161b7e0af7b49, []int{17} } func (m *GetAllStoresResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1135,7 +1135,7 @@ func (m *GetRegionRequest) Reset() { *m = GetRegionRequest{} } func (m *GetRegionRequest) String() string { return proto.CompactTextString(m) } func (*GetRegionRequest) ProtoMessage() {} func (*GetRegionRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_pdpb_44ca8d4a3d8ba006, []int{18} + return fileDescriptor_pdpb_d3e161b7e0af7b49, []int{18} } func (m *GetRegionRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1197,7 +1197,7 @@ func (m *GetRegionResponse) Reset() { *m = GetRegionResponse{} } func (m *GetRegionResponse) String() string { return proto.CompactTextString(m) } func (*GetRegionResponse) ProtoMessage() {} func (*GetRegionResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_pdpb_44ca8d4a3d8ba006, []int{19} + return fileDescriptor_pdpb_d3e161b7e0af7b49, []int{19} } func (m *GetRegionResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1280,7 +1280,7 @@ func (m *GetRegionByIDRequest) Reset() { *m = GetRegionByIDRequest{} } func (m *GetRegionByIDRequest) String() string { return proto.CompactTextString(m) } func (*GetRegionByIDRequest) ProtoMessage() {} func (*GetRegionByIDRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_pdpb_44ca8d4a3d8ba006, []int{20} + return fileDescriptor_pdpb_d3e161b7e0af7b49, []int{20} } func (m *GetRegionByIDRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1337,7 +1337,7 @@ func (m *ScanRegionsRequest) Reset() { *m = ScanRegionsRequest{} } func (m *ScanRegionsRequest) String() string { return proto.CompactTextString(m) } func (*ScanRegionsRequest) ProtoMessage() {} func (*ScanRegionsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_pdpb_44ca8d4a3d8ba006, []int{21} + return fileDescriptor_pdpb_d3e161b7e0af7b49, []int{21} } func (m *ScanRegionsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1407,7 +1407,7 @@ func (m *ScanRegionsResponse) Reset() { *m = ScanRegionsResponse{} } func (m *ScanRegionsResponse) String() string { return proto.CompactTextString(m) } func (*ScanRegionsResponse) ProtoMessage() {} func (*ScanRegionsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_pdpb_44ca8d4a3d8ba006, []int{22} + return fileDescriptor_pdpb_d3e161b7e0af7b49, []int{22} } func (m *ScanRegionsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1468,7 +1468,7 @@ func (m *GetClusterConfigRequest) Reset() { *m = GetClusterConfigRequest func (m *GetClusterConfigRequest) String() string { return proto.CompactTextString(m) } func (*GetClusterConfigRequest) ProtoMessage() {} func (*GetClusterConfigRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_pdpb_44ca8d4a3d8ba006, []int{23} + return fileDescriptor_pdpb_d3e161b7e0af7b49, []int{23} } func (m *GetClusterConfigRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1516,7 +1516,7 @@ func (m *GetClusterConfigResponse) Reset() { *m = GetClusterConfigRespon func (m *GetClusterConfigResponse) String() string { return proto.CompactTextString(m) } func (*GetClusterConfigResponse) ProtoMessage() {} func (*GetClusterConfigResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_pdpb_44ca8d4a3d8ba006, []int{24} + return fileDescriptor_pdpb_d3e161b7e0af7b49, []int{24} } func (m *GetClusterConfigResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1571,7 +1571,7 @@ func (m *PutClusterConfigRequest) Reset() { *m = PutClusterConfigRequest func (m *PutClusterConfigRequest) String() string { return proto.CompactTextString(m) } func (*PutClusterConfigRequest) ProtoMessage() {} func (*PutClusterConfigRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_pdpb_44ca8d4a3d8ba006, []int{25} + return fileDescriptor_pdpb_d3e161b7e0af7b49, []int{25} } func (m *PutClusterConfigRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1625,7 +1625,7 @@ func (m *PutClusterConfigResponse) Reset() { *m = PutClusterConfigRespon func (m *PutClusterConfigResponse) String() string { return proto.CompactTextString(m) } func (*PutClusterConfigResponse) ProtoMessage() {} func (*PutClusterConfigResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_pdpb_44ca8d4a3d8ba006, []int{26} + return fileDescriptor_pdpb_d3e161b7e0af7b49, []int{26} } func (m *PutClusterConfigResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1681,7 +1681,7 @@ func (m *Member) Reset() { *m = Member{} } func (m *Member) String() string { return proto.CompactTextString(m) } func (*Member) ProtoMessage() {} func (*Member) Descriptor() ([]byte, []int) { - return fileDescriptor_pdpb_44ca8d4a3d8ba006, []int{27} + return fileDescriptor_pdpb_d3e161b7e0af7b49, []int{27} } func (m *Member) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1777,7 +1777,7 @@ func (m *GetMembersRequest) Reset() { *m = GetMembersRequest{} } func (m *GetMembersRequest) String() string { return proto.CompactTextString(m) } func (*GetMembersRequest) ProtoMessage() {} func (*GetMembersRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_pdpb_44ca8d4a3d8ba006, []int{28} + return fileDescriptor_pdpb_d3e161b7e0af7b49, []int{28} } func (m *GetMembersRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1827,7 +1827,7 @@ func (m *GetMembersResponse) Reset() { *m = GetMembersResponse{} } func (m *GetMembersResponse) String() string { return proto.CompactTextString(m) } func (*GetMembersResponse) ProtoMessage() {} func (*GetMembersResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_pdpb_44ca8d4a3d8ba006, []int{29} + return fileDescriptor_pdpb_d3e161b7e0af7b49, []int{29} } func (m *GetMembersResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1896,7 +1896,7 @@ func (m *PeerStats) Reset() { *m = PeerStats{} } func (m *PeerStats) String() string { return proto.CompactTextString(m) } func (*PeerStats) ProtoMessage() {} func (*PeerStats) Descriptor() ([]byte, []int) { - return fileDescriptor_pdpb_44ca8d4a3d8ba006, []int{30} + return fileDescriptor_pdpb_d3e161b7e0af7b49, []int{30} } func (m *PeerStats) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1962,18 +1962,18 @@ type RegionHeartbeatRequest struct { // Approximate number of keys. ApproximateKeys uint64 `protobuf:"varint,13,opt,name=approximate_keys,json=approximateKeys,proto3" json:"approximate_keys,omitempty"` // Term is the term of raft group. - Term uint64 `protobuf:"varint,14,opt,name=term,proto3" json:"term,omitempty"` - ReplicateStatus *replicate_mode.RegionReplicateStatus `protobuf:"bytes,15,opt,name=replicate_status,json=replicateStatus" json:"replicate_status,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + Term uint64 `protobuf:"varint,14,opt,name=term,proto3" json:"term,omitempty"` + ReplicationStatus *replication_modepb.RegionReplicationStatus `protobuf:"bytes,15,opt,name=replication_status,json=replicationStatus" json:"replication_status,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } func (m *RegionHeartbeatRequest) Reset() { *m = RegionHeartbeatRequest{} } func (m *RegionHeartbeatRequest) String() string { return proto.CompactTextString(m) } func (*RegionHeartbeatRequest) ProtoMessage() {} func (*RegionHeartbeatRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_pdpb_44ca8d4a3d8ba006, []int{31} + return fileDescriptor_pdpb_d3e161b7e0af7b49, []int{31} } func (m *RegionHeartbeatRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2093,9 +2093,9 @@ func (m *RegionHeartbeatRequest) GetTerm() uint64 { return 0 } -func (m *RegionHeartbeatRequest) GetReplicateStatus() *replicate_mode.RegionReplicateStatus { +func (m *RegionHeartbeatRequest) GetReplicationStatus() *replication_modepb.RegionReplicationStatus { if m != nil { - return m.ReplicateStatus + return m.ReplicationStatus } return nil } @@ -2112,7 +2112,7 @@ func (m *ChangePeer) Reset() { *m = ChangePeer{} } func (m *ChangePeer) String() string { return proto.CompactTextString(m) } func (*ChangePeer) ProtoMessage() {} func (*ChangePeer) Descriptor() ([]byte, []int) { - return fileDescriptor_pdpb_44ca8d4a3d8ba006, []int{32} + return fileDescriptor_pdpb_d3e161b7e0af7b49, []int{32} } func (m *ChangePeer) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2166,7 +2166,7 @@ func (m *TransferLeader) Reset() { *m = TransferLeader{} } func (m *TransferLeader) String() string { return proto.CompactTextString(m) } func (*TransferLeader) ProtoMessage() {} func (*TransferLeader) Descriptor() ([]byte, []int) { - return fileDescriptor_pdpb_44ca8d4a3d8ba006, []int{33} + return fileDescriptor_pdpb_d3e161b7e0af7b49, []int{33} } func (m *TransferLeader) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2213,7 +2213,7 @@ func (m *Merge) Reset() { *m = Merge{} } func (m *Merge) String() string { return proto.CompactTextString(m) } func (*Merge) ProtoMessage() {} func (*Merge) Descriptor() ([]byte, []int) { - return fileDescriptor_pdpb_44ca8d4a3d8ba006, []int{34} + return fileDescriptor_pdpb_d3e161b7e0af7b49, []int{34} } func (m *Merge) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2261,7 +2261,7 @@ func (m *SplitRegion) Reset() { *m = SplitRegion{} } func (m *SplitRegion) String() string { return proto.CompactTextString(m) } func (*SplitRegion) ProtoMessage() {} func (*SplitRegion) Descriptor() ([]byte, []int) { - return fileDescriptor_pdpb_44ca8d4a3d8ba006, []int{35} + return fileDescriptor_pdpb_d3e161b7e0af7b49, []int{35} } func (m *SplitRegion) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2340,7 +2340,7 @@ func (m *RegionHeartbeatResponse) Reset() { *m = RegionHeartbeatResponse func (m *RegionHeartbeatResponse) String() string { return proto.CompactTextString(m) } func (*RegionHeartbeatResponse) ProtoMessage() {} func (*RegionHeartbeatResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_pdpb_44ca8d4a3d8ba006, []int{36} + return fileDescriptor_pdpb_d3e161b7e0af7b49, []int{36} } func (m *RegionHeartbeatResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2437,7 +2437,7 @@ func (m *AskSplitRequest) Reset() { *m = AskSplitRequest{} } func (m *AskSplitRequest) String() string { return proto.CompactTextString(m) } func (*AskSplitRequest) ProtoMessage() {} func (*AskSplitRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_pdpb_44ca8d4a3d8ba006, []int{37} + return fileDescriptor_pdpb_d3e161b7e0af7b49, []int{37} } func (m *AskSplitRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2497,7 +2497,7 @@ func (m *AskSplitResponse) Reset() { *m = AskSplitResponse{} } func (m *AskSplitResponse) String() string { return proto.CompactTextString(m) } func (*AskSplitResponse) ProtoMessage() {} func (*AskSplitResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_pdpb_44ca8d4a3d8ba006, []int{38} + return fileDescriptor_pdpb_d3e161b7e0af7b49, []int{38} } func (m *AskSplitResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2560,7 +2560,7 @@ func (m *ReportSplitRequest) Reset() { *m = ReportSplitRequest{} } func (m *ReportSplitRequest) String() string { return proto.CompactTextString(m) } func (*ReportSplitRequest) ProtoMessage() {} func (*ReportSplitRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_pdpb_44ca8d4a3d8ba006, []int{39} + return fileDescriptor_pdpb_d3e161b7e0af7b49, []int{39} } func (m *ReportSplitRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2621,7 +2621,7 @@ func (m *ReportSplitResponse) Reset() { *m = ReportSplitResponse{} } func (m *ReportSplitResponse) String() string { return proto.CompactTextString(m) } func (*ReportSplitResponse) ProtoMessage() {} func (*ReportSplitResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_pdpb_44ca8d4a3d8ba006, []int{40} + return fileDescriptor_pdpb_d3e161b7e0af7b49, []int{40} } func (m *ReportSplitResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2670,7 +2670,7 @@ func (m *AskBatchSplitRequest) Reset() { *m = AskBatchSplitRequest{} } func (m *AskBatchSplitRequest) String() string { return proto.CompactTextString(m) } func (*AskBatchSplitRequest) ProtoMessage() {} func (*AskBatchSplitRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_pdpb_44ca8d4a3d8ba006, []int{41} + return fileDescriptor_pdpb_d3e161b7e0af7b49, []int{41} } func (m *AskBatchSplitRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2732,7 +2732,7 @@ func (m *SplitID) Reset() { *m = SplitID{} } func (m *SplitID) String() string { return proto.CompactTextString(m) } func (*SplitID) ProtoMessage() {} func (*SplitID) Descriptor() ([]byte, []int) { - return fileDescriptor_pdpb_44ca8d4a3d8ba006, []int{42} + return fileDescriptor_pdpb_d3e161b7e0af7b49, []int{42} } func (m *SplitID) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2787,7 +2787,7 @@ func (m *AskBatchSplitResponse) Reset() { *m = AskBatchSplitResponse{} } func (m *AskBatchSplitResponse) String() string { return proto.CompactTextString(m) } func (*AskBatchSplitResponse) ProtoMessage() {} func (*AskBatchSplitResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_pdpb_44ca8d4a3d8ba006, []int{43} + return fileDescriptor_pdpb_d3e161b7e0af7b49, []int{43} } func (m *AskBatchSplitResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2842,7 +2842,7 @@ func (m *ReportBatchSplitRequest) Reset() { *m = ReportBatchSplitRequest func (m *ReportBatchSplitRequest) String() string { return proto.CompactTextString(m) } func (*ReportBatchSplitRequest) ProtoMessage() {} func (*ReportBatchSplitRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_pdpb_44ca8d4a3d8ba006, []int{44} + return fileDescriptor_pdpb_d3e161b7e0af7b49, []int{44} } func (m *ReportBatchSplitRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2896,7 +2896,7 @@ func (m *ReportBatchSplitResponse) Reset() { *m = ReportBatchSplitRespon func (m *ReportBatchSplitResponse) String() string { return proto.CompactTextString(m) } func (*ReportBatchSplitResponse) ProtoMessage() {} func (*ReportBatchSplitResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_pdpb_44ca8d4a3d8ba006, []int{45} + return fileDescriptor_pdpb_d3e161b7e0af7b49, []int{45} } func (m *ReportBatchSplitResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2946,7 +2946,7 @@ func (m *TimeInterval) Reset() { *m = TimeInterval{} } func (m *TimeInterval) String() string { return proto.CompactTextString(m) } func (*TimeInterval) ProtoMessage() {} func (*TimeInterval) Descriptor() ([]byte, []int) { - return fileDescriptor_pdpb_44ca8d4a3d8ba006, []int{46} + return fileDescriptor_pdpb_d3e161b7e0af7b49, []int{46} } func (m *TimeInterval) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3001,7 +3001,7 @@ func (m *RecordPair) Reset() { *m = RecordPair{} } func (m *RecordPair) String() string { return proto.CompactTextString(m) } func (*RecordPair) ProtoMessage() {} func (*RecordPair) Descriptor() ([]byte, []int) { - return fileDescriptor_pdpb_44ca8d4a3d8ba006, []int{47} + return fileDescriptor_pdpb_d3e161b7e0af7b49, []int{47} } func (m *RecordPair) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3091,7 +3091,7 @@ func (m *StoreStats) Reset() { *m = StoreStats{} } func (m *StoreStats) String() string { return proto.CompactTextString(m) } func (*StoreStats) ProtoMessage() {} func (*StoreStats) Descriptor() ([]byte, []int) { - return fileDescriptor_pdpb_44ca8d4a3d8ba006, []int{48} + return fileDescriptor_pdpb_d3e161b7e0af7b49, []int{48} } func (m *StoreStats) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3265,7 +3265,7 @@ func (m *StoreHeartbeatRequest) Reset() { *m = StoreHeartbeatRequest{} } func (m *StoreHeartbeatRequest) String() string { return proto.CompactTextString(m) } func (*StoreHeartbeatRequest) ProtoMessage() {} func (*StoreHeartbeatRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_pdpb_44ca8d4a3d8ba006, []int{49} + return fileDescriptor_pdpb_d3e161b7e0af7b49, []int{49} } func (m *StoreHeartbeatRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3309,18 +3309,18 @@ func (m *StoreHeartbeatRequest) GetStats() *StoreStats { } type StoreHeartbeatResponse struct { - Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` - ReplicateStatus *replicate_mode.ReplicateStatus `protobuf:"bytes,2,opt,name=replicate_status,json=replicateStatus" json:"replicate_status,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + ReplicationStatus *replication_modepb.ReplicationStatus `protobuf:"bytes,2,opt,name=replication_status,json=replicationStatus" json:"replication_status,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } func (m *StoreHeartbeatResponse) Reset() { *m = StoreHeartbeatResponse{} } func (m *StoreHeartbeatResponse) String() string { return proto.CompactTextString(m) } func (*StoreHeartbeatResponse) ProtoMessage() {} func (*StoreHeartbeatResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_pdpb_44ca8d4a3d8ba006, []int{50} + return fileDescriptor_pdpb_d3e161b7e0af7b49, []int{50} } func (m *StoreHeartbeatResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3356,9 +3356,9 @@ func (m *StoreHeartbeatResponse) GetHeader() *ResponseHeader { return nil } -func (m *StoreHeartbeatResponse) GetReplicateStatus() *replicate_mode.ReplicateStatus { +func (m *StoreHeartbeatResponse) GetReplicationStatus() *replication_modepb.ReplicationStatus { if m != nil { - return m.ReplicateStatus + return m.ReplicationStatus } return nil } @@ -3379,7 +3379,7 @@ func (m *ScatterRegionRequest) Reset() { *m = ScatterRegionRequest{} } func (m *ScatterRegionRequest) String() string { return proto.CompactTextString(m) } func (*ScatterRegionRequest) ProtoMessage() {} func (*ScatterRegionRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_pdpb_44ca8d4a3d8ba006, []int{51} + return fileDescriptor_pdpb_d3e161b7e0af7b49, []int{51} } func (m *ScatterRegionRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3447,7 +3447,7 @@ func (m *ScatterRegionResponse) Reset() { *m = ScatterRegionResponse{} } func (m *ScatterRegionResponse) String() string { return proto.CompactTextString(m) } func (*ScatterRegionResponse) ProtoMessage() {} func (*ScatterRegionResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_pdpb_44ca8d4a3d8ba006, []int{52} + return fileDescriptor_pdpb_d3e161b7e0af7b49, []int{52} } func (m *ScatterRegionResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3494,7 +3494,7 @@ func (m *GetGCSafePointRequest) Reset() { *m = GetGCSafePointRequest{} } func (m *GetGCSafePointRequest) String() string { return proto.CompactTextString(m) } func (*GetGCSafePointRequest) ProtoMessage() {} func (*GetGCSafePointRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_pdpb_44ca8d4a3d8ba006, []int{53} + return fileDescriptor_pdpb_d3e161b7e0af7b49, []int{53} } func (m *GetGCSafePointRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3542,7 +3542,7 @@ func (m *GetGCSafePointResponse) Reset() { *m = GetGCSafePointResponse{} func (m *GetGCSafePointResponse) String() string { return proto.CompactTextString(m) } func (*GetGCSafePointResponse) ProtoMessage() {} func (*GetGCSafePointResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_pdpb_44ca8d4a3d8ba006, []int{54} + return fileDescriptor_pdpb_d3e161b7e0af7b49, []int{54} } func (m *GetGCSafePointResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3597,7 +3597,7 @@ func (m *UpdateGCSafePointRequest) Reset() { *m = UpdateGCSafePointReque func (m *UpdateGCSafePointRequest) String() string { return proto.CompactTextString(m) } func (*UpdateGCSafePointRequest) ProtoMessage() {} func (*UpdateGCSafePointRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_pdpb_44ca8d4a3d8ba006, []int{55} + return fileDescriptor_pdpb_d3e161b7e0af7b49, []int{55} } func (m *UpdateGCSafePointRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3652,7 +3652,7 @@ func (m *UpdateGCSafePointResponse) Reset() { *m = UpdateGCSafePointResp func (m *UpdateGCSafePointResponse) String() string { return proto.CompactTextString(m) } func (*UpdateGCSafePointResponse) ProtoMessage() {} func (*UpdateGCSafePointResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_pdpb_44ca8d4a3d8ba006, []int{56} + return fileDescriptor_pdpb_d3e161b7e0af7b49, []int{56} } func (m *UpdateGCSafePointResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3695,6 +3695,148 @@ func (m *UpdateGCSafePointResponse) GetNewSafePoint() uint64 { return 0 } +type UpdateServiceGCSafePointRequest struct { + Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + ServiceId []byte `protobuf:"bytes,2,opt,name=service_id,json=serviceId,proto3" json:"service_id,omitempty"` + TTL int64 `protobuf:"varint,3,opt,name=TTL,proto3" json:"TTL,omitempty"` + SafePoint uint64 `protobuf:"varint,4,opt,name=safe_point,json=safePoint,proto3" json:"safe_point,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *UpdateServiceGCSafePointRequest) Reset() { *m = UpdateServiceGCSafePointRequest{} } +func (m *UpdateServiceGCSafePointRequest) String() string { return proto.CompactTextString(m) } +func (*UpdateServiceGCSafePointRequest) ProtoMessage() {} +func (*UpdateServiceGCSafePointRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_pdpb_d3e161b7e0af7b49, []int{57} +} +func (m *UpdateServiceGCSafePointRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *UpdateServiceGCSafePointRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_UpdateServiceGCSafePointRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalTo(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (dst *UpdateServiceGCSafePointRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_UpdateServiceGCSafePointRequest.Merge(dst, src) +} +func (m *UpdateServiceGCSafePointRequest) XXX_Size() int { + return m.Size() +} +func (m *UpdateServiceGCSafePointRequest) XXX_DiscardUnknown() { + xxx_messageInfo_UpdateServiceGCSafePointRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_UpdateServiceGCSafePointRequest proto.InternalMessageInfo + +func (m *UpdateServiceGCSafePointRequest) GetHeader() *RequestHeader { + if m != nil { + return m.Header + } + return nil +} + +func (m *UpdateServiceGCSafePointRequest) GetServiceId() []byte { + if m != nil { + return m.ServiceId + } + return nil +} + +func (m *UpdateServiceGCSafePointRequest) GetTTL() int64 { + if m != nil { + return m.TTL + } + return 0 +} + +func (m *UpdateServiceGCSafePointRequest) GetSafePoint() uint64 { + if m != nil { + return m.SafePoint + } + return 0 +} + +type UpdateServiceGCSafePointResponse struct { + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + ServiceId []byte `protobuf:"bytes,2,opt,name=service_id,json=serviceId,proto3" json:"service_id,omitempty"` + TTL int64 `protobuf:"varint,3,opt,name=TTL,proto3" json:"TTL,omitempty"` + MinSafePoint uint64 `protobuf:"varint,4,opt,name=min_safe_point,json=minSafePoint,proto3" json:"min_safe_point,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *UpdateServiceGCSafePointResponse) Reset() { *m = UpdateServiceGCSafePointResponse{} } +func (m *UpdateServiceGCSafePointResponse) String() string { return proto.CompactTextString(m) } +func (*UpdateServiceGCSafePointResponse) ProtoMessage() {} +func (*UpdateServiceGCSafePointResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_pdpb_d3e161b7e0af7b49, []int{58} +} +func (m *UpdateServiceGCSafePointResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *UpdateServiceGCSafePointResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_UpdateServiceGCSafePointResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalTo(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (dst *UpdateServiceGCSafePointResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_UpdateServiceGCSafePointResponse.Merge(dst, src) +} +func (m *UpdateServiceGCSafePointResponse) XXX_Size() int { + return m.Size() +} +func (m *UpdateServiceGCSafePointResponse) XXX_DiscardUnknown() { + xxx_messageInfo_UpdateServiceGCSafePointResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_UpdateServiceGCSafePointResponse proto.InternalMessageInfo + +func (m *UpdateServiceGCSafePointResponse) GetHeader() *ResponseHeader { + if m != nil { + return m.Header + } + return nil +} + +func (m *UpdateServiceGCSafePointResponse) GetServiceId() []byte { + if m != nil { + return m.ServiceId + } + return nil +} + +func (m *UpdateServiceGCSafePointResponse) GetTTL() int64 { + if m != nil { + return m.TTL + } + return 0 +} + +func (m *UpdateServiceGCSafePointResponse) GetMinSafePoint() uint64 { + if m != nil { + return m.MinSafePoint + } + return 0 +} + type RegionStat struct { // Bytes read/written during this period. BytesWritten uint64 `protobuf:"varint,1,opt,name=bytes_written,json=bytesWritten,proto3" json:"bytes_written,omitempty"` @@ -3711,7 +3853,7 @@ func (m *RegionStat) Reset() { *m = RegionStat{} } func (m *RegionStat) String() string { return proto.CompactTextString(m) } func (*RegionStat) ProtoMessage() {} func (*RegionStat) Descriptor() ([]byte, []int) { - return fileDescriptor_pdpb_44ca8d4a3d8ba006, []int{57} + return fileDescriptor_pdpb_d3e161b7e0af7b49, []int{59} } func (m *RegionStat) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3783,7 +3925,7 @@ func (m *SyncRegionRequest) Reset() { *m = SyncRegionRequest{} } func (m *SyncRegionRequest) String() string { return proto.CompactTextString(m) } func (*SyncRegionRequest) ProtoMessage() {} func (*SyncRegionRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_pdpb_44ca8d4a3d8ba006, []int{58} + return fileDescriptor_pdpb_d3e161b7e0af7b49, []int{60} } func (m *SyncRegionRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3850,7 +3992,7 @@ func (m *SyncRegionResponse) Reset() { *m = SyncRegionResponse{} } func (m *SyncRegionResponse) String() string { return proto.CompactTextString(m) } func (*SyncRegionResponse) ProtoMessage() {} func (*SyncRegionResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_pdpb_44ca8d4a3d8ba006, []int{59} + return fileDescriptor_pdpb_d3e161b7e0af7b49, []int{61} } func (m *SyncRegionResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3926,7 +4068,7 @@ func (m *GetOperatorRequest) Reset() { *m = GetOperatorRequest{} } func (m *GetOperatorRequest) String() string { return proto.CompactTextString(m) } func (*GetOperatorRequest) ProtoMessage() {} func (*GetOperatorRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_pdpb_44ca8d4a3d8ba006, []int{60} + return fileDescriptor_pdpb_d3e161b7e0af7b49, []int{62} } func (m *GetOperatorRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3984,7 +4126,7 @@ func (m *GetOperatorResponse) Reset() { *m = GetOperatorResponse{} } func (m *GetOperatorResponse) String() string { return proto.CompactTextString(m) } func (*GetOperatorResponse) ProtoMessage() {} func (*GetOperatorResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_pdpb_44ca8d4a3d8ba006, []int{61} + return fileDescriptor_pdpb_d3e161b7e0af7b49, []int{63} } func (m *GetOperatorResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4106,6 +4248,8 @@ func init() { proto.RegisterType((*GetGCSafePointResponse)(nil), "pdpb.GetGCSafePointResponse") proto.RegisterType((*UpdateGCSafePointRequest)(nil), "pdpb.UpdateGCSafePointRequest") proto.RegisterType((*UpdateGCSafePointResponse)(nil), "pdpb.UpdateGCSafePointResponse") + proto.RegisterType((*UpdateServiceGCSafePointRequest)(nil), "pdpb.UpdateServiceGCSafePointRequest") + proto.RegisterType((*UpdateServiceGCSafePointResponse)(nil), "pdpb.UpdateServiceGCSafePointResponse") proto.RegisterType((*RegionStat)(nil), "pdpb.RegionStat") proto.RegisterType((*SyncRegionRequest)(nil), "pdpb.SyncRegionRequest") proto.RegisterType((*SyncRegionResponse)(nil), "pdpb.SyncRegionResponse") @@ -4152,6 +4296,7 @@ type PDClient interface { ScatterRegion(ctx context.Context, in *ScatterRegionRequest, opts ...grpc.CallOption) (*ScatterRegionResponse, error) GetGCSafePoint(ctx context.Context, in *GetGCSafePointRequest, opts ...grpc.CallOption) (*GetGCSafePointResponse, error) UpdateGCSafePoint(ctx context.Context, in *UpdateGCSafePointRequest, opts ...grpc.CallOption) (*UpdateGCSafePointResponse, error) + UpdateServiceGCSafePoint(ctx context.Context, in *UpdateServiceGCSafePointRequest, opts ...grpc.CallOption) (*UpdateServiceGCSafePointResponse, error) SyncRegions(ctx context.Context, opts ...grpc.CallOption) (PD_SyncRegionsClient, error) GetOperator(ctx context.Context, in *GetOperatorRequest, opts ...grpc.CallOption) (*GetOperatorResponse, error) } @@ -4417,6 +4562,15 @@ func (c *pDClient) UpdateGCSafePoint(ctx context.Context, in *UpdateGCSafePointR return out, nil } +func (c *pDClient) UpdateServiceGCSafePoint(ctx context.Context, in *UpdateServiceGCSafePointRequest, opts ...grpc.CallOption) (*UpdateServiceGCSafePointResponse, error) { + out := new(UpdateServiceGCSafePointResponse) + err := c.cc.Invoke(ctx, "/pdpb.PD/UpdateServiceGCSafePoint", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *pDClient) SyncRegions(ctx context.Context, opts ...grpc.CallOption) (PD_SyncRegionsClient, error) { stream, err := c.cc.NewStream(ctx, &_PD_serviceDesc.Streams[2], "/pdpb.PD/SyncRegions", opts...) if err != nil { @@ -4485,6 +4639,7 @@ type PDServer interface { ScatterRegion(context.Context, *ScatterRegionRequest) (*ScatterRegionResponse, error) GetGCSafePoint(context.Context, *GetGCSafePointRequest) (*GetGCSafePointResponse, error) UpdateGCSafePoint(context.Context, *UpdateGCSafePointRequest) (*UpdateGCSafePointResponse, error) + UpdateServiceGCSafePoint(context.Context, *UpdateServiceGCSafePointRequest) (*UpdateServiceGCSafePointResponse, error) SyncRegions(PD_SyncRegionsServer) error GetOperator(context.Context, *GetOperatorRequest) (*GetOperatorResponse, error) } @@ -4923,6 +5078,24 @@ func _PD_UpdateGCSafePoint_Handler(srv interface{}, ctx context.Context, dec fun return interceptor(ctx, in, info, handler) } +func _PD_UpdateServiceGCSafePoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(UpdateServiceGCSafePointRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(PDServer).UpdateServiceGCSafePoint(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/pdpb.PD/UpdateServiceGCSafePoint", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(PDServer).UpdateServiceGCSafePoint(ctx, req.(*UpdateServiceGCSafePointRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _PD_SyncRegions_Handler(srv interface{}, stream grpc.ServerStream) error { return srv.(PDServer).SyncRegions(&pDSyncRegionsServer{stream}) } @@ -5055,6 +5228,10 @@ var _PD_serviceDesc = grpc.ServiceDesc{ MethodName: "UpdateGCSafePoint", Handler: _PD_UpdateGCSafePoint_Handler, }, + { + MethodName: "UpdateServiceGCSafePoint", + Handler: _PD_UpdateServiceGCSafePoint_Handler, + }, { MethodName: "GetOperator", Handler: _PD_GetOperator_Handler, @@ -5366,11 +5543,11 @@ func (m *BootstrapResponse) MarshalTo(dAtA []byte) (int, error) { } i += n8 } - if m.ReplicateStatus != nil { + if m.ReplicationStatus != nil { dAtA[i] = 0x12 i++ - i = encodeVarintPdpb(dAtA, i, uint64(m.ReplicateStatus.Size())) - n9, err := m.ReplicateStatus.MarshalTo(dAtA[i:]) + i = encodeVarintPdpb(dAtA, i, uint64(m.ReplicationStatus.Size())) + n9, err := m.ReplicationStatus.MarshalTo(dAtA[i:]) if err != nil { return 0, err } @@ -5674,11 +5851,11 @@ func (m *PutStoreResponse) MarshalTo(dAtA []byte) (int, error) { } i += n20 } - if m.ReplicateStatus != nil { + if m.ReplicationStatus != nil { dAtA[i] = 0x12 i++ - i = encodeVarintPdpb(dAtA, i, uint64(m.ReplicateStatus.Size())) - n21, err := m.ReplicateStatus.MarshalTo(dAtA[i:]) + i = encodeVarintPdpb(dAtA, i, uint64(m.ReplicationStatus.Size())) + n21, err := m.ReplicationStatus.MarshalTo(dAtA[i:]) if err != nil { return 0, err } @@ -6510,11 +6687,11 @@ func (m *RegionHeartbeatRequest) MarshalTo(dAtA []byte) (int, error) { i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Term)) } - if m.ReplicateStatus != nil { + if m.ReplicationStatus != nil { dAtA[i] = 0x7a i++ - i = encodeVarintPdpb(dAtA, i, uint64(m.ReplicateStatus.Size())) - n46, err := m.ReplicateStatus.MarshalTo(dAtA[i:]) + i = encodeVarintPdpb(dAtA, i, uint64(m.ReplicationStatus.Size())) + n46, err := m.ReplicationStatus.MarshalTo(dAtA[i:]) if err != nil { return 0, err } @@ -7427,11 +7604,11 @@ func (m *StoreHeartbeatResponse) MarshalTo(dAtA []byte) (int, error) { } i += n76 } - if m.ReplicateStatus != nil { + if m.ReplicationStatus != nil { dAtA[i] = 0x12 i++ - i = encodeVarintPdpb(dAtA, i, uint64(m.ReplicateStatus.Size())) - n77, err := m.ReplicateStatus.MarshalTo(dAtA[i:]) + i = encodeVarintPdpb(dAtA, i, uint64(m.ReplicationStatus.Size())) + n77, err := m.ReplicationStatus.MarshalTo(dAtA[i:]) if err != nil { return 0, err } @@ -7669,6 +7846,100 @@ func (m *UpdateGCSafePointResponse) MarshalTo(dAtA []byte) (int, error) { return i, nil } +func (m *UpdateServiceGCSafePointRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *UpdateServiceGCSafePointRequest) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Header != nil { + dAtA[i] = 0xa + i++ + i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) + n86, err := m.Header.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n86 + } + if len(m.ServiceId) > 0 { + dAtA[i] = 0x12 + i++ + i = encodeVarintPdpb(dAtA, i, uint64(len(m.ServiceId))) + i += copy(dAtA[i:], m.ServiceId) + } + if m.TTL != 0 { + dAtA[i] = 0x18 + i++ + i = encodeVarintPdpb(dAtA, i, uint64(m.TTL)) + } + if m.SafePoint != 0 { + dAtA[i] = 0x20 + i++ + i = encodeVarintPdpb(dAtA, i, uint64(m.SafePoint)) + } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *UpdateServiceGCSafePointResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *UpdateServiceGCSafePointResponse) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Header != nil { + dAtA[i] = 0xa + i++ + i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) + n87, err := m.Header.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n87 + } + if len(m.ServiceId) > 0 { + dAtA[i] = 0x12 + i++ + i = encodeVarintPdpb(dAtA, i, uint64(len(m.ServiceId))) + i += copy(dAtA[i:], m.ServiceId) + } + if m.TTL != 0 { + dAtA[i] = 0x18 + i++ + i = encodeVarintPdpb(dAtA, i, uint64(m.TTL)) + } + if m.MinSafePoint != 0 { + dAtA[i] = 0x20 + i++ + i = encodeVarintPdpb(dAtA, i, uint64(m.MinSafePoint)) + } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } + return i, nil +} + func (m *RegionStat) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -7729,21 +8000,21 @@ func (m *SyncRegionRequest) MarshalTo(dAtA []byte) (int, error) { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) - n86, err := m.Header.MarshalTo(dAtA[i:]) + n88, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n86 + i += n88 } if m.Member != nil { dAtA[i] = 0x12 i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Member.Size())) - n87, err := m.Member.MarshalTo(dAtA[i:]) + n89, err := m.Member.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n87 + i += n89 } if m.StartIndex != 0 { dAtA[i] = 0x18 @@ -7775,11 +8046,11 @@ func (m *SyncRegionResponse) MarshalTo(dAtA []byte) (int, error) { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) - n88, err := m.Header.MarshalTo(dAtA[i:]) + n90, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n88 + i += n90 } if len(m.Regions) > 0 { for _, msg := range m.Regions { @@ -7847,11 +8118,11 @@ func (m *GetOperatorRequest) MarshalTo(dAtA []byte) (int, error) { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) - n89, err := m.Header.MarshalTo(dAtA[i:]) + n91, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n89 + i += n91 } if m.RegionId != 0 { dAtA[i] = 0x10 @@ -7883,11 +8154,11 @@ func (m *GetOperatorResponse) MarshalTo(dAtA []byte) (int, error) { dAtA[i] = 0xa i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Header.Size())) - n90, err := m.Header.MarshalTo(dAtA[i:]) + n92, err := m.Header.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n90 + i += n92 } if m.RegionId != 0 { dAtA[i] = 0x10 @@ -8049,8 +8320,8 @@ func (m *BootstrapResponse) Size() (n int) { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } - if m.ReplicateStatus != nil { - l = m.ReplicateStatus.Size() + if m.ReplicationStatus != nil { + l = m.ReplicationStatus.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.XXX_unrecognized != nil { @@ -8178,8 +8449,8 @@ func (m *PutStoreResponse) Size() (n int) { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } - if m.ReplicateStatus != nil { - l = m.ReplicateStatus.Size() + if m.ReplicationStatus != nil { + l = m.ReplicationStatus.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.XXX_unrecognized != nil { @@ -8555,8 +8826,8 @@ func (m *RegionHeartbeatRequest) Size() (n int) { if m.Term != 0 { n += 1 + sovPdpb(uint64(m.Term)) } - if m.ReplicateStatus != nil { - l = m.ReplicateStatus.Size() + if m.ReplicationStatus != nil { + l = m.ReplicationStatus.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.XXX_unrecognized != nil { @@ -8963,8 +9234,8 @@ func (m *StoreHeartbeatResponse) Size() (n int) { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } - if m.ReplicateStatus != nil { - l = m.ReplicateStatus.Size() + if m.ReplicationStatus != nil { + l = m.ReplicationStatus.Size() n += 1 + l + sovPdpb(uint64(l)) } if m.XXX_unrecognized != nil { @@ -9071,6 +9342,52 @@ func (m *UpdateGCSafePointResponse) Size() (n int) { return n } +func (m *UpdateServiceGCSafePointRequest) Size() (n int) { + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + l = len(m.ServiceId) + if l > 0 { + n += 1 + l + sovPdpb(uint64(l)) + } + if m.TTL != 0 { + n += 1 + sovPdpb(uint64(m.TTL)) + } + if m.SafePoint != 0 { + n += 1 + sovPdpb(uint64(m.SafePoint)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *UpdateServiceGCSafePointResponse) Size() (n int) { + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + l = len(m.ServiceId) + if l > 0 { + n += 1 + l + sovPdpb(uint64(l)) + } + if m.TTL != 0 { + n += 1 + sovPdpb(uint64(m.TTL)) + } + if m.MinSafePoint != 0 { + n += 1 + sovPdpb(uint64(m.MinSafePoint)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + func (m *RegionStat) Size() (n int) { var l int _ = l @@ -10016,7 +10333,7 @@ func (m *BootstrapResponse) Unmarshal(dAtA []byte) error { iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ReplicateStatus", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ReplicationStatus", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -10040,10 +10357,10 @@ func (m *BootstrapResponse) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.ReplicateStatus == nil { - m.ReplicateStatus = &replicate_mode.ReplicateStatus{} + if m.ReplicationStatus == nil { + m.ReplicationStatus = &replication_modepb.ReplicationStatus{} } - if err := m.ReplicateStatus.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.ReplicationStatus.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -10878,7 +11195,7 @@ func (m *PutStoreResponse) Unmarshal(dAtA []byte) error { iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ReplicateStatus", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ReplicationStatus", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -10902,10 +11219,10 @@ func (m *PutStoreResponse) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.ReplicateStatus == nil { - m.ReplicateStatus = &replicate_mode.ReplicateStatus{} + if m.ReplicationStatus == nil { + m.ReplicationStatus = &replication_modepb.ReplicationStatus{} } - if err := m.ReplicateStatus.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.ReplicationStatus.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -13313,7 +13630,7 @@ func (m *RegionHeartbeatRequest) Unmarshal(dAtA []byte) error { } case 15: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ReplicateStatus", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ReplicationStatus", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -13337,10 +13654,10 @@ func (m *RegionHeartbeatRequest) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.ReplicateStatus == nil { - m.ReplicateStatus = &replicate_mode.RegionReplicateStatus{} + if m.ReplicationStatus == nil { + m.ReplicationStatus = &replication_modepb.RegionReplicationStatus{} } - if err := m.ReplicateStatus.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.ReplicationStatus.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -15979,7 +16296,7 @@ func (m *StoreHeartbeatResponse) Unmarshal(dAtA []byte) error { iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ReplicateStatus", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ReplicationStatus", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -16003,10 +16320,10 @@ func (m *StoreHeartbeatResponse) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.ReplicateStatus == nil { - m.ReplicateStatus = &replicate_mode.ReplicateStatus{} + if m.ReplicationStatus == nil { + m.ReplicationStatus = &replication_modepb.ReplicationStatus{} } - if err := m.ReplicateStatus.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.ReplicationStatus.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -16678,6 +16995,312 @@ func (m *UpdateGCSafePointResponse) Unmarshal(dAtA []byte) error { } return nil } +func (m *UpdateServiceGCSafePointRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: UpdateServiceGCSafePointRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: UpdateServiceGCSafePointRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthPdpb + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Header == nil { + m.Header = &RequestHeader{} + } + if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ServiceId", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthPdpb + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ServiceId = append(m.ServiceId[:0], dAtA[iNdEx:postIndex]...) + if m.ServiceId == nil { + m.ServiceId = []byte{} + } + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field TTL", wireType) + } + m.TTL = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.TTL |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field SafePoint", wireType) + } + m.SafePoint = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.SafePoint |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipPdpb(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthPdpb + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *UpdateServiceGCSafePointResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: UpdateServiceGCSafePointResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: UpdateServiceGCSafePointResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthPdpb + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Header == nil { + m.Header = &ResponseHeader{} + } + if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ServiceId", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthPdpb + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ServiceId = append(m.ServiceId[:0], dAtA[iNdEx:postIndex]...) + if m.ServiceId == nil { + m.ServiceId = []byte{} + } + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field TTL", wireType) + } + m.TTL = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.TTL |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MinSafePoint", wireType) + } + m.MinSafePoint = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.MinSafePoint |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipPdpb(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthPdpb + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func (m *RegionStat) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -17529,197 +18152,203 @@ var ( ErrIntOverflowPdpb = fmt.Errorf("proto: integer overflow") ) -func init() { proto.RegisterFile("pdpb.proto", fileDescriptor_pdpb_44ca8d4a3d8ba006) } - -var fileDescriptor_pdpb_44ca8d4a3d8ba006 = []byte{ - // 3024 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x5a, 0xcb, 0x8f, 0x1b, 0xc7, - 0xd1, 0xdf, 0xe1, 0x0e, 0xb9, 0x64, 0xf1, 0xb9, 0xad, 0x95, 0x96, 0xa2, 0xac, 0x87, 0x47, 0xb2, - 0x3f, 0xd9, 0x9f, 0xbd, 0xb6, 0x65, 0xc1, 0x30, 0x10, 0xd8, 0x08, 0x97, 0x4b, 0xad, 0x68, 0xad, - 0x48, 0x62, 0xc8, 0xb5, 0x63, 0x20, 0x30, 0x33, 0xcb, 0xe9, 0xe5, 0x4e, 0x96, 0x3b, 0x33, 0x9e, - 0x69, 0xae, 0x4c, 0x23, 0x87, 0x00, 0x01, 0x92, 0x00, 0x71, 0x80, 0x24, 0x80, 0x03, 0xff, 0x09, - 0x39, 0xe5, 0x98, 0x6b, 0xae, 0x39, 0xe6, 0x98, 0x63, 0xe0, 0x5c, 0x73, 0xc9, 0x29, 0xd7, 0xa0, - 0x5f, 0xf3, 0x22, 0xa9, 0x95, 0x47, 0x36, 0x7c, 0xe2, 0x74, 0x55, 0x75, 0x75, 0x75, 0x75, 0x75, - 0xf5, 0xaf, 0xab, 0x09, 0xe0, 0x9a, 0xee, 0xd1, 0x8e, 0xeb, 0x39, 0xc4, 0x41, 0x2a, 0xfd, 0x6e, - 0x94, 0xce, 0x30, 0x31, 0x24, 0xad, 0x51, 0xc6, 0x9e, 0x71, 0x4c, 0x82, 0xe6, 0x96, 0x87, 0xdd, - 0xa9, 0x35, 0x36, 0x08, 0x1e, 0x9d, 0x39, 0x26, 0x96, 0xd4, 0x89, 0x33, 0x71, 0xd8, 0xe7, 0x1b, - 0xf4, 0x4b, 0x50, 0xab, 0xde, 0xcc, 0x27, 0xec, 0x93, 0x13, 0xb4, 0x1d, 0x28, 0xeb, 0xf8, 0xd3, - 0x19, 0xf6, 0xc9, 0x43, 0x6c, 0x98, 0xd8, 0x43, 0xd7, 0x01, 0xc6, 0xd3, 0x99, 0x4f, 0xb0, 0x37, - 0xb2, 0xcc, 0xba, 0x72, 0x4b, 0xb9, 0xab, 0xea, 0x05, 0x41, 0xe9, 0x98, 0x9a, 0x0e, 0x15, 0x1d, - 0xfb, 0xae, 0x63, 0xfb, 0xf8, 0x99, 0x3a, 0xa0, 0x17, 0x21, 0x8b, 0x3d, 0xcf, 0xf1, 0xea, 0x99, - 0x5b, 0xca, 0xdd, 0xe2, 0xbd, 0xe2, 0x0e, 0x9b, 0x5c, 0x9b, 0x92, 0x74, 0xce, 0xd1, 0x1e, 0x40, - 0x96, 0xb5, 0xd1, 0x6d, 0x50, 0xc9, 0xdc, 0xc5, 0x4c, 0x49, 0xe5, 0x5e, 0x35, 0x22, 0x3a, 0x9c, - 0xbb, 0x58, 0x67, 0x4c, 0x54, 0x87, 0x8d, 0x33, 0xec, 0xfb, 0xc6, 0x04, 0x33, 0x95, 0x05, 0x5d, - 0x36, 0xb5, 0x1e, 0xc0, 0xd0, 0x77, 0xc4, 0x74, 0xd0, 0xff, 0x43, 0xee, 0x84, 0x59, 0xc8, 0xd4, - 0x15, 0xef, 0x5d, 0xe2, 0xea, 0x62, 0xb3, 0xd5, 0x85, 0x08, 0xda, 0x82, 0xec, 0xd8, 0x99, 0xd9, - 0x84, 0xa9, 0x2c, 0xeb, 0xbc, 0xa1, 0x35, 0xa1, 0x30, 0xb4, 0xce, 0xb0, 0x4f, 0x8c, 0x33, 0x17, - 0x35, 0x20, 0xef, 0x9e, 0xcc, 0x7d, 0x6b, 0x6c, 0x4c, 0x99, 0xc6, 0x75, 0x3d, 0x68, 0x53, 0x9b, - 0xa6, 0xce, 0x84, 0xb1, 0x32, 0x8c, 0x25, 0x9b, 0xda, 0xcf, 0x15, 0x28, 0x32, 0xa3, 0xb8, 0xcf, - 0xd0, 0x6b, 0x09, 0xab, 0xb6, 0xa4, 0x55, 0x51, 0x9f, 0x3e, 0xdd, 0x2c, 0xf4, 0x3a, 0x14, 0x88, - 0x34, 0xab, 0xbe, 0xce, 0xd4, 0x08, 0x5f, 0x05, 0xd6, 0xea, 0xa1, 0x84, 0xf6, 0x85, 0x02, 0xb5, - 0x5d, 0xc7, 0x21, 0x3e, 0xf1, 0x0c, 0x37, 0x95, 0x77, 0x6e, 0x43, 0xd6, 0x27, 0x8e, 0x87, 0xc5, - 0x1a, 0x96, 0x77, 0x44, 0x38, 0x0e, 0x28, 0x51, 0xe7, 0x3c, 0xf4, 0x32, 0xe4, 0x3c, 0x3c, 0xb1, - 0x1c, 0x5b, 0x98, 0x54, 0x91, 0x52, 0x3a, 0xa3, 0xea, 0x82, 0xab, 0xfd, 0x56, 0x81, 0xcd, 0x88, - 0x39, 0xa9, 0xfc, 0xf2, 0x01, 0xd4, 0xc2, 0xa0, 0xf7, 0x89, 0x41, 0x66, 0xbe, 0xb0, 0xed, 0xe6, - 0x4e, 0x62, 0x37, 0xe8, 0xb2, 0x39, 0x60, 0x62, 0x7a, 0xd5, 0x8b, 0x13, 0xb4, 0x3d, 0xb8, 0xdc, - 0xf1, 0x03, 0x83, 0x5c, 0x6c, 0xa6, 0x71, 0x91, 0xf6, 0x53, 0xb8, 0x92, 0xd4, 0x92, 0x6a, 0x66, - 0x1a, 0x94, 0x8e, 0x22, 0x5a, 0xd8, 0xac, 0xf2, 0x7a, 0x8c, 0xa6, 0xbd, 0x07, 0x95, 0xe6, 0x74, - 0xea, 0x8c, 0x3b, 0x7b, 0xa9, 0x4c, 0xed, 0x41, 0x35, 0xe8, 0x9e, 0xca, 0xc6, 0x0a, 0x64, 0x2c, - 0x6e, 0x99, 0xaa, 0x67, 0x2c, 0x53, 0xfb, 0x18, 0xaa, 0xfb, 0x98, 0xf0, 0x60, 0x48, 0x13, 0x5e, - 0x57, 0x21, 0xcf, 0x42, 0x68, 0x14, 0x68, 0xdd, 0x60, 0xed, 0x8e, 0x49, 0x83, 0xa5, 0x16, 0xea, - 0x4e, 0x65, 0xed, 0x33, 0x06, 0x6f, 0x96, 0x86, 0x91, 0x2f, 0x62, 0xb7, 0xc6, 0x35, 0x32, 0x11, - 0x1a, 0x26, 0xbe, 0xce, 0xd9, 0xda, 0x18, 0xaa, 0xfd, 0xd9, 0x73, 0x4c, 0xf5, 0x59, 0x8c, 0x61, - 0x1b, 0x36, 0x1c, 0xe5, 0x7b, 0xdf, 0x20, 0x3f, 0x83, 0x4b, 0xfb, 0x98, 0x34, 0xa7, 0x53, 0x66, - 0x90, 0x9f, 0x6a, 0xde, 0xef, 0x42, 0x1d, 0x7f, 0x36, 0x9e, 0xce, 0x4c, 0x3c, 0x22, 0xce, 0xd9, - 0x91, 0x4f, 0x1c, 0x9b, 0xda, 0x45, 0xf5, 0x89, 0x10, 0xbf, 0x22, 0xf8, 0x43, 0xc9, 0xe6, 0xa3, - 0x69, 0xa7, 0xb0, 0x15, 0x1f, 0x3d, 0x95, 0x3f, 0x5e, 0x82, 0x5c, 0x30, 0xda, 0xfa, 0xa2, 0xe3, - 0x05, 0x53, 0xfb, 0x84, 0x45, 0x9b, 0x48, 0x58, 0x69, 0xe6, 0x79, 0x1d, 0x80, 0xa7, 0xb9, 0xd1, - 0x29, 0x9e, 0xb3, 0x99, 0x95, 0xf4, 0x02, 0xa7, 0x3c, 0xc2, 0x73, 0xed, 0xab, 0x0c, 0x6c, 0x46, - 0x06, 0x48, 0x35, 0x95, 0x30, 0xcf, 0x66, 0x9e, 0x96, 0x67, 0xd1, 0x1d, 0xc8, 0x4d, 0xb9, 0x56, - 0x1e, 0xd3, 0x25, 0x29, 0xd7, 0xc7, 0x54, 0x1b, 0xe7, 0x51, 0x29, 0x7f, 0x6a, 0x9c, 0x63, 0xbf, - 0xae, 0x32, 0xc7, 0x24, 0xa4, 0x38, 0x0f, 0xed, 0x00, 0x98, 0xce, 0x13, 0x7b, 0xe4, 0x62, 0xec, - 0xf9, 0xf5, 0x2c, 0x93, 0x14, 0x47, 0x0e, 0x95, 0xe3, 0x5b, 0xa4, 0x40, 0x45, 0x68, 0xd3, 0x47, - 0x6f, 0x41, 0xd9, 0xc5, 0xb6, 0x69, 0xd9, 0x13, 0xd1, 0x25, 0xb7, 0x44, 0x79, 0x49, 0x88, 0xb0, - 0x2e, 0xda, 0x4f, 0xd8, 0x3a, 0xf3, 0x39, 0xec, 0xce, 0xd3, 0xa5, 0x36, 0x74, 0x0d, 0x84, 0xb3, - 0xc3, 0x54, 0x92, 0xe7, 0x04, 0x9e, 0x4b, 0xd0, 0x60, 0x6c, 0xd8, 0x7c, 0x0c, 0x3f, 0xed, 0x00, - 0x3e, 0x31, 0x3c, 0x12, 0x59, 0xde, 0x3c, 0x23, 0x3c, 0xc2, 0x73, 0x7a, 0x5a, 0x4f, 0xad, 0x33, - 0x8b, 0x30, 0x87, 0x67, 0x75, 0xde, 0x40, 0xdb, 0xb0, 0x81, 0x6d, 0x93, 0x75, 0x50, 0x59, 0x87, - 0x1c, 0xb6, 0x4d, 0x1a, 0x0c, 0x5f, 0x2a, 0x70, 0x29, 0x66, 0x4f, 0xaa, 0x70, 0xb8, 0x0b, 0x1b, - 0x7c, 0x86, 0x32, 0xb4, 0x93, 0xf1, 0x20, 0xd9, 0xe8, 0x65, 0xd8, 0xe0, 0x8b, 0x4e, 0xb3, 0xdc, - 0xe2, 0x72, 0x48, 0xa6, 0xf6, 0x00, 0xb6, 0xf7, 0x31, 0x69, 0x71, 0x04, 0xd7, 0x72, 0xec, 0x63, - 0x6b, 0x92, 0xea, 0x9c, 0xf1, 0xa1, 0xbe, 0xa8, 0x27, 0xd5, 0x1c, 0x5f, 0x81, 0x0d, 0x01, 0x28, - 0x45, 0xcc, 0x57, 0xa5, 0xe5, 0x42, 0xbb, 0x2e, 0xf9, 0xda, 0xa7, 0xb0, 0xdd, 0x9f, 0x3d, 0xbf, - 0xf1, 0xdf, 0x64, 0xc8, 0x87, 0x50, 0x5f, 0x1c, 0x32, 0xcd, 0x3c, 0xb5, 0x5f, 0x64, 0x20, 0xf7, - 0x18, 0x9f, 0x1d, 0x61, 0x0f, 0x21, 0x50, 0x6d, 0xe3, 0x8c, 0x43, 0xe1, 0x82, 0xce, 0xbe, 0x69, - 0xf0, 0x9d, 0x31, 0x6e, 0x24, 0xba, 0x39, 0xa1, 0x63, 0x52, 0x26, 0xdd, 0x6a, 0xa3, 0x99, 0x37, - 0xe5, 0xeb, 0x5b, 0xd0, 0xf3, 0x94, 0x70, 0xe8, 0x4d, 0x7d, 0x74, 0x13, 0x8a, 0xe3, 0xa9, 0x85, - 0x6d, 0xc2, 0xd9, 0x2a, 0x63, 0x03, 0x27, 0x31, 0x81, 0xff, 0x83, 0x2a, 0x5f, 0xfe, 0x91, 0xeb, - 0x59, 0x8e, 0x67, 0x91, 0x79, 0x3d, 0xcb, 0x82, 0xb8, 0xc2, 0xc9, 0x7d, 0x41, 0xa5, 0x9a, 0x4c, - 0xec, 0x4e, 0x9d, 0xf9, 0xc8, 0x35, 0xc8, 0x49, 0x3d, 0xc7, 0xcc, 0x03, 0x4e, 0xea, 0x1b, 0xe4, - 0x04, 0xbd, 0x04, 0x95, 0x23, 0xcb, 0x36, 0xbc, 0xf9, 0xe8, 0x1c, 0x7b, 0x3e, 0x4d, 0x53, 0x1b, - 0x4c, 0xa6, 0xcc, 0xa9, 0x1f, 0x72, 0x22, 0x3d, 0xf3, 0x27, 0x16, 0x19, 0x9d, 0x18, 0xfe, 0x49, - 0x3d, 0xcf, 0x61, 0xfc, 0xc4, 0x22, 0x0f, 0x0d, 0xff, 0x44, 0xfb, 0x21, 0xcb, 0x91, 0xdc, 0x0f, - 0xa9, 0x76, 0xa9, 0xf6, 0x57, 0x05, 0x50, 0x54, 0x45, 0xca, 0x3c, 0xbb, 0xc1, 0x9d, 0x2b, 0x37, - 0x56, 0x89, 0x8b, 0x73, 0xad, 0xba, 0x64, 0x2e, 0xc9, 0xb3, 0x51, 0x31, 0x99, 0x67, 0x5f, 0x87, - 0x22, 0x26, 0x63, 0x73, 0x24, 0x44, 0xd5, 0x25, 0xa2, 0x40, 0x05, 0x0e, 0xf8, 0x0c, 0xfa, 0x50, - 0x08, 0x12, 0x2b, 0xba, 0x05, 0x2a, 0x5d, 0x49, 0x61, 0x75, 0x7c, 0xd7, 0x32, 0x0e, 0x7a, 0x11, - 0x4a, 0x2c, 0x3f, 0xfb, 0x78, 0xec, 0xd8, 0xa6, 0x2f, 0x82, 0xa3, 0x48, 0x69, 0x03, 0x4e, 0xd2, - 0xfe, 0xad, 0xc2, 0x15, 0x9e, 0x11, 0x1e, 0x62, 0xc3, 0x23, 0x47, 0xd8, 0x20, 0xa9, 0x36, 0xc6, - 0xb7, 0x7b, 0xfc, 0xc4, 0x0f, 0x16, 0xf5, 0x9b, 0x1f, 0x2c, 0xd9, 0x8b, 0x0e, 0x16, 0x74, 0x1b, - 0xca, 0x47, 0x73, 0x82, 0xfd, 0xd1, 0x13, 0xcf, 0x22, 0x04, 0xdb, 0x2c, 0x66, 0x55, 0xbd, 0xc4, - 0x88, 0x1f, 0x71, 0x1a, 0x3d, 0xb7, 0xb9, 0x90, 0x87, 0x0d, 0x93, 0x45, 0xac, 0xaa, 0x17, 0x18, - 0x45, 0xc7, 0x06, 0xbd, 0xc4, 0x96, 0x4e, 0xf1, 0x3c, 0x54, 0x91, 0xe7, 0xfe, 0xa5, 0x34, 0xa9, - 0xe1, 0x1a, 0x14, 0x98, 0x08, 0x53, 0x50, 0xe0, 0x9b, 0x93, 0x12, 0x58, 0xff, 0x57, 0xa0, 0x66, - 0xb8, 0xae, 0xe7, 0x7c, 0x66, 0x9d, 0x31, 0x40, 0x66, 0x7d, 0x8e, 0xeb, 0xc0, 0x64, 0xaa, 0x11, - 0xfa, 0xc0, 0xfa, 0x1c, 0xa3, 0x1d, 0xc8, 0x5b, 0x36, 0xc1, 0xde, 0xb9, 0x31, 0xad, 0x97, 0x98, - 0xe7, 0x50, 0x78, 0xb7, 0xeb, 0x08, 0x8e, 0x1e, 0xc8, 0x24, 0x55, 0xd3, 0x21, 0xeb, 0xe5, 0x05, - 0xd5, 0x8f, 0xf0, 0xdc, 0xa7, 0x39, 0x85, 0x60, 0xef, 0xac, 0x5e, 0x61, 0x6c, 0xf6, 0x8d, 0xfa, - 0x4b, 0x80, 0x62, 0x95, 0x0d, 0xfb, 0xd2, 0x22, 0x50, 0xe4, 0xa8, 0xe5, 0xe9, 0x70, 0xf1, 0x03, - 0x35, 0x5f, 0xac, 0x95, 0xb4, 0x13, 0x80, 0xd6, 0x89, 0x61, 0x4f, 0x30, 0x5d, 0x84, 0x67, 0x88, - 0xe0, 0x77, 0xa1, 0x38, 0x66, 0xf2, 0x23, 0x56, 0x01, 0xc8, 0xb0, 0x0a, 0xc0, 0xf6, 0x8e, 0xac, - 0x74, 0xd0, 0xb4, 0xca, 0xf5, 0xb1, 0x4a, 0x00, 0x8c, 0x83, 0x6f, 0xed, 0x1e, 0x54, 0x86, 0x9e, - 0x61, 0xfb, 0xc7, 0xd8, 0xe3, 0x9b, 0xe7, 0xe2, 0xd1, 0xb4, 0x37, 0x20, 0xfb, 0x18, 0x7b, 0x13, - 0x76, 0x69, 0x25, 0x86, 0x37, 0xc1, 0x44, 0x08, 0x2f, 0x44, 0x33, 0xe7, 0x6a, 0x07, 0x50, 0x1c, - 0xb8, 0x53, 0x4b, 0xe0, 0x13, 0xf4, 0x0a, 0xe4, 0x5c, 0x67, 0x6a, 0x8d, 0xe7, 0xa2, 0x54, 0xb1, - 0xc9, 0x97, 0xa8, 0x75, 0x82, 0xc7, 0xa7, 0x7d, 0xc6, 0xd0, 0x85, 0x00, 0x75, 0x3a, 0x5b, 0x13, - 0x9a, 0x43, 0x4a, 0x3a, 0xfb, 0xd6, 0xfe, 0xb8, 0x0e, 0xdb, 0x0b, 0x7b, 0x31, 0x55, 0x92, 0x7a, - 0x2b, 0x70, 0x1b, 0x9b, 0x71, 0x26, 0x7a, 0x7b, 0x09, 0xfd, 0x2f, 0xfd, 0xc5, 0xd6, 0xe2, 0x3d, - 0xa8, 0x12, 0xe1, 0xaf, 0x51, 0x6c, 0x87, 0x8a, 0x91, 0xe2, 0xce, 0xd4, 0x2b, 0x24, 0xee, 0xdc, - 0x18, 0xc4, 0x52, 0xe3, 0x10, 0x0b, 0xbd, 0x03, 0x25, 0xc1, 0xc4, 0xae, 0x33, 0x3e, 0x61, 0x67, - 0x08, 0xcd, 0x27, 0x31, 0xa7, 0xb6, 0x29, 0x4b, 0x2f, 0x7a, 0x61, 0x83, 0x66, 0x47, 0xee, 0x68, - 0x3e, 0x8d, 0xdc, 0x92, 0x85, 0x03, 0x2e, 0xd0, 0xe7, 0xe9, 0x2e, 0x7b, 0x46, 0x97, 0x8f, 0x6d, - 0xd4, 0xa0, 0xa6, 0xc4, 0x56, 0x54, 0xe7, 0x1c, 0x74, 0x1f, 0x4a, 0x3e, 0x5d, 0xb0, 0x91, 0x48, - 0x56, 0x79, 0x26, 0x29, 0xd6, 0x29, 0xb2, 0x94, 0x7a, 0xd1, 0x0f, 0x1b, 0xda, 0x31, 0x54, 0x9b, - 0xfe, 0xa9, 0x60, 0x7f, 0x77, 0xc9, 0x51, 0xfb, 0xa5, 0x02, 0xb5, 0x70, 0xa0, 0x94, 0x85, 0x82, - 0xb2, 0x8d, 0x9f, 0x8c, 0x92, 0x70, 0xb7, 0x68, 0xe3, 0x27, 0xba, 0x5c, 0x8e, 0x5b, 0x50, 0xa2, - 0x32, 0x0c, 0x17, 0x58, 0x26, 0x87, 0x05, 0xaa, 0x0e, 0x36, 0x7e, 0x42, 0xdd, 0xd8, 0x31, 0x7d, - 0xed, 0x37, 0x0a, 0x20, 0x1d, 0xbb, 0x8e, 0x47, 0xd2, 0x4f, 0x5a, 0x03, 0x75, 0x8a, 0x8f, 0xc9, - 0x8a, 0x29, 0x33, 0x1e, 0xba, 0x03, 0x59, 0xcf, 0x9a, 0x9c, 0x90, 0x15, 0xb5, 0x21, 0xce, 0xd4, - 0x5a, 0x70, 0x29, 0x66, 0x4c, 0x2a, 0x10, 0xf5, 0x85, 0x02, 0x5b, 0x4d, 0xff, 0x74, 0xd7, 0x20, - 0xe3, 0x93, 0xef, 0x7c, 0x25, 0x29, 0x1e, 0xe2, 0x71, 0xc6, 0xeb, 0x74, 0xeb, 0xac, 0x4e, 0x07, - 0x8c, 0xd4, 0x62, 0x35, 0xc4, 0x1e, 0x6c, 0x30, 0x2b, 0x3a, 0x7b, 0x8b, 0x4b, 0xa6, 0x5c, 0xbc, - 0x64, 0x99, 0x85, 0x25, 0x3b, 0x86, 0xcb, 0x89, 0xe9, 0xa5, 0x8a, 0x9f, 0x9b, 0xb0, 0x2e, 0xf5, - 0xd3, 0xeb, 0x70, 0xb8, 0x2f, 0x3a, 0x7b, 0x3a, 0xe5, 0x68, 0x2e, 0xcd, 0x51, 0x74, 0x31, 0x9e, - 0xd3, 0x93, 0xcf, 0x7c, 0x41, 0xa1, 0x40, 0x7a, 0x71, 0xc4, 0x54, 0x31, 0xf0, 0x63, 0x28, 0x45, - 0x8f, 0x4b, 0x0a, 0x6f, 0xf9, 0xb5, 0x2d, 0xac, 0x9b, 0x72, 0xdf, 0x57, 0x18, 0x39, 0x2c, 0xf2, - 0xde, 0x86, 0x32, 0xbd, 0xac, 0x85, 0x62, 0x7c, 0x57, 0x95, 0xb0, 0x6d, 0x06, 0x42, 0xda, 0x7d, - 0x00, 0x1d, 0x8f, 0x1d, 0xcf, 0xec, 0x1b, 0x96, 0x87, 0x6a, 0xb0, 0x4e, 0xef, 0x76, 0x1c, 0xa8, - 0xd3, 0x4f, 0x7a, 0x0f, 0x3c, 0x37, 0xa6, 0x33, 0x2c, 0x3a, 0xf3, 0x86, 0xf6, 0x9f, 0x2c, 0x40, - 0x58, 0x50, 0x8a, 0x15, 0xbd, 0x94, 0x58, 0xd1, 0x0b, 0x35, 0x20, 0x3f, 0x36, 0x5c, 0x63, 0x4c, - 0x51, 0xb8, 0x80, 0xf9, 0xb2, 0x8d, 0x5e, 0x80, 0x82, 0x71, 0x6e, 0x58, 0x53, 0xe3, 0x68, 0x8a, - 0x59, 0xb4, 0xa9, 0x7a, 0x48, 0xa0, 0x38, 0x45, 0x44, 0x17, 0x0f, 0x47, 0x95, 0x85, 0xa3, 0x48, - 0xb5, 0x2c, 0x1e, 0xd1, 0x6b, 0x80, 0x7c, 0x81, 0xa0, 0x7c, 0xdb, 0x70, 0x85, 0x60, 0x96, 0x09, - 0xd6, 0x04, 0x67, 0x60, 0x1b, 0x2e, 0x97, 0x7e, 0x13, 0xb6, 0x3c, 0x3c, 0xc6, 0xd6, 0x79, 0x42, - 0x3e, 0xc7, 0xe4, 0x51, 0xc0, 0x0b, 0x7b, 0x5c, 0x07, 0x08, 0x5d, 0xcd, 0x12, 0x74, 0x59, 0x2f, - 0x04, 0x5e, 0x46, 0x3b, 0x70, 0xc9, 0x70, 0xdd, 0xe9, 0x3c, 0xa1, 0x2f, 0xcf, 0xe4, 0x36, 0x25, - 0x2b, 0x54, 0xb7, 0x0d, 0x1b, 0x96, 0x3f, 0x3a, 0x9a, 0xf9, 0x73, 0x06, 0xaa, 0xf2, 0x7a, 0xce, - 0xf2, 0x77, 0x67, 0xfe, 0x9c, 0x9e, 0x43, 0x33, 0x1f, 0x9b, 0x51, 0x2c, 0x95, 0xa7, 0x04, 0x06, - 0xa2, 0x16, 0x30, 0x5f, 0x71, 0x09, 0xe6, 0x4b, 0x82, 0xba, 0xd2, 0x22, 0xa8, 0x8b, 0xc3, 0xc2, - 0x72, 0x12, 0x16, 0xc6, 0x30, 0x5f, 0x25, 0x81, 0xf9, 0xa2, 0x40, 0xae, 0xfa, 0x0c, 0x40, 0xee, - 0x0d, 0x80, 0xb1, 0x3b, 0x1b, 0xcd, 0x7c, 0x63, 0x82, 0xfd, 0x7a, 0x8d, 0x6d, 0x95, 0x9a, 0x8c, - 0x72, 0x19, 0x6d, 0x7a, 0x61, 0xec, 0xce, 0x0e, 0x99, 0x08, 0xba, 0x0f, 0x65, 0x3a, 0xf0, 0xc8, - 0x72, 0x46, 0x9e, 0x41, 0xb0, 0x5f, 0xdf, 0x5c, 0xd1, 0xa7, 0x48, 0xc5, 0x3a, 0x8e, 0x4e, 0x85, - 0xd0, 0x3b, 0x50, 0xa1, 0x13, 0xc6, 0x61, 0x37, 0xb4, 0xa2, 0x5b, 0x89, 0xc9, 0xc9, 0x7e, 0x6f, - 0x43, 0xc9, 0x71, 0x47, 0x53, 0x83, 0x60, 0x7b, 0x6c, 0x61, 0xbf, 0x7e, 0x69, 0xd5, 0x60, 0x8e, - 0x7b, 0x20, 0x85, 0xb4, 0x29, 0x5c, 0x66, 0x21, 0xff, 0xbc, 0x57, 0x0e, 0x51, 0x9c, 0xcd, 0x3c, - 0xbd, 0x38, 0xfb, 0x07, 0x05, 0xae, 0x24, 0x87, 0xfb, 0xde, 0xab, 0xa7, 0x7f, 0x56, 0x60, 0x6b, - 0x30, 0x36, 0x08, 0xc1, 0xde, 0x73, 0xd4, 0x15, 0x9f, 0x56, 0xd8, 0x7a, 0xd6, 0x97, 0x97, 0xc8, - 0x95, 0x4c, 0x5d, 0x7d, 0x25, 0xd3, 0xda, 0x70, 0x39, 0x61, 0x6f, 0xaa, 0x14, 0xbc, 0x07, 0x97, - 0xf7, 0x31, 0xd9, 0x6f, 0x0d, 0x8c, 0x63, 0xdc, 0x77, 0x2c, 0x3b, 0xd5, 0xd2, 0x6b, 0x18, 0xae, - 0x24, 0xb5, 0xa4, 0x5a, 0x51, 0x9a, 0x95, 0x8c, 0x63, 0x3c, 0x72, 0xa9, 0x0e, 0xe1, 0xc0, 0x82, - 0x2f, 0x95, 0x6a, 0xc7, 0x50, 0x3f, 0x74, 0x4d, 0x83, 0xe0, 0xe7, 0xb4, 0xf7, 0xa2, 0x71, 0x1c, - 0xb8, 0xba, 0x64, 0x9c, 0x54, 0x33, 0xba, 0x03, 0x15, 0x0a, 0x14, 0x16, 0x46, 0xa3, 0xf0, 0x21, - 0xd0, 0xad, 0xfd, 0x4e, 0xa1, 0x67, 0x15, 0x5d, 0x46, 0x1a, 0x8e, 0x8b, 0x79, 0x51, 0xb9, 0xf0, - 0x2e, 0x9c, 0xb9, 0xe8, 0x2e, 0xbc, 0x7e, 0xc1, 0x5d, 0x58, 0x8d, 0xe7, 0x45, 0xed, 0x57, 0x0a, - 0x6c, 0x0e, 0xe6, 0xf6, 0xf8, 0x39, 0x76, 0xc3, 0x1d, 0xc8, 0xf1, 0xea, 0x8b, 0xd8, 0x95, 0x89, - 0x92, 0x0b, 0xe7, 0x31, 0x68, 0xc6, 0x4e, 0x22, 0xcb, 0x36, 0xf1, 0x67, 0xc2, 0x4e, 0x7e, 0x38, - 0x75, 0x28, 0x45, 0xfb, 0xaf, 0x02, 0x28, 0x6a, 0xc9, 0x77, 0x5c, 0x7f, 0xbd, 0xc8, 0x1e, 0x9a, - 0x62, 0xc5, 0x26, 0xe7, 0xe9, 0x4e, 0x8d, 0xa7, 0x58, 0xb9, 0x8a, 0xf2, 0x3c, 0xe7, 0x38, 0xe2, - 0x6d, 0xa8, 0x88, 0x4e, 0xb2, 0xb8, 0xbb, 0xac, 0x24, 0x52, 0xe6, 0x32, 0x07, 0xa2, 0xc4, 0xfb, - 0x09, 0xab, 0x8f, 0xf5, 0x5c, 0xec, 0x19, 0xc4, 0xf1, 0xbe, 0xfd, 0x52, 0xfb, 0x5f, 0x14, 0xf6, - 0x66, 0x14, 0x0e, 0x90, 0xca, 0xb5, 0x4f, 0x4d, 0x7a, 0x08, 0x54, 0x13, 0xfb, 0x63, 0xe6, 0xc6, - 0x92, 0xce, 0xbe, 0xa9, 0x7a, 0x91, 0xad, 0x55, 0x76, 0x2d, 0x17, 0xea, 0xa5, 0x19, 0x22, 0x45, - 0x0b, 0x19, 0x76, 0x33, 0xb7, 0x6c, 0x93, 0x61, 0x1f, 0x7a, 0x33, 0xb7, 0x6c, 0xf3, 0xd5, 0x2f, - 0x15, 0x28, 0x04, 0x7f, 0x38, 0x40, 0x39, 0xc8, 0xf4, 0x1e, 0xd5, 0xd6, 0x50, 0x11, 0x36, 0x0e, - 0xbb, 0x8f, 0xba, 0xbd, 0x8f, 0xba, 0x35, 0x05, 0x6d, 0x41, 0xad, 0xdb, 0x1b, 0x8e, 0x76, 0x7b, - 0xbd, 0xe1, 0x60, 0xa8, 0x37, 0xfb, 0xfd, 0xf6, 0x5e, 0x2d, 0x83, 0x2e, 0x41, 0x75, 0x30, 0xec, - 0xe9, 0xed, 0xd1, 0xb0, 0xf7, 0x78, 0x77, 0x30, 0xec, 0x75, 0xdb, 0xb5, 0x75, 0x54, 0x87, 0xad, - 0xe6, 0x81, 0xde, 0x6e, 0xee, 0x7d, 0x1c, 0x17, 0x57, 0x29, 0xa7, 0xd3, 0x6d, 0xf5, 0x1e, 0xf7, - 0x9b, 0xc3, 0xce, 0xee, 0x41, 0x7b, 0xf4, 0x61, 0x5b, 0x1f, 0x74, 0x7a, 0xdd, 0x5a, 0x96, 0xaa, - 0xd7, 0xdb, 0xfb, 0x9d, 0x5e, 0x77, 0x44, 0x47, 0x79, 0xd0, 0x3b, 0xec, 0xee, 0xd5, 0x72, 0xaf, - 0xde, 0x87, 0x62, 0xa4, 0xb8, 0x80, 0xf2, 0xa0, 0x0e, 0x5a, 0xcd, 0x6e, 0x6d, 0x0d, 0x55, 0xa1, - 0xd8, 0xec, 0xf7, 0xf5, 0xde, 0x8f, 0x3a, 0x8f, 0x9b, 0xc3, 0x76, 0x4d, 0x41, 0x00, 0xb9, 0xc3, - 0x41, 0xfb, 0x51, 0xfb, 0xe3, 0x5a, 0xe6, 0xd5, 0x3e, 0x54, 0xe2, 0x73, 0xa7, 0x33, 0x19, 0x1c, - 0xb6, 0x5a, 0xed, 0xc1, 0x80, 0x4f, 0x6b, 0xd8, 0x79, 0xdc, 0xee, 0x1d, 0x0e, 0x79, 0xbf, 0x56, - 0xb3, 0xdb, 0x6a, 0x1f, 0xd4, 0x32, 0x94, 0xa1, 0xb7, 0xfb, 0x07, 0xcd, 0x16, 0x9d, 0x04, 0x6d, - 0x1c, 0x76, 0xbb, 0x9d, 0xee, 0x7e, 0x4d, 0xbd, 0xf7, 0xfb, 0x0a, 0x64, 0xfa, 0x7b, 0xa8, 0x09, - 0x10, 0xd6, 0x57, 0xd1, 0x36, 0x77, 0xf3, 0x42, 0xd1, 0xb6, 0x51, 0x5f, 0x64, 0xf0, 0x85, 0xd6, - 0xd6, 0xd0, 0x9b, 0xb0, 0x3e, 0xf4, 0x1d, 0x24, 0xa2, 0x3b, 0xfc, 0xdf, 0x46, 0x63, 0x33, 0x42, - 0x91, 0xd2, 0x77, 0x95, 0x37, 0x15, 0xf4, 0x3e, 0x14, 0x82, 0x07, 0x76, 0x74, 0x85, 0x4b, 0x25, - 0xff, 0xd7, 0xd0, 0xd8, 0x5e, 0xa0, 0x07, 0x23, 0x3e, 0x86, 0x4a, 0xfc, 0x89, 0x1e, 0x5d, 0xe3, - 0xc2, 0x4b, 0x9f, 0xff, 0x1b, 0x2f, 0x2c, 0x67, 0x06, 0xea, 0xde, 0x85, 0x0d, 0xf1, 0x8c, 0x8e, - 0x44, 0x9c, 0xc5, 0x1f, 0xe5, 0x1b, 0x97, 0x13, 0xd4, 0xa0, 0xe7, 0x0f, 0x20, 0x2f, 0xdf, 0xb4, - 0xd1, 0xe5, 0xc0, 0x45, 0xd1, 0x47, 0xe5, 0xc6, 0x95, 0x24, 0x39, 0xda, 0x59, 0xbe, 0x0d, 0xcb, - 0xce, 0x89, 0x17, 0x69, 0xd9, 0x39, 0xf9, 0x84, 0xac, 0xad, 0xa1, 0x7d, 0x28, 0x45, 0x1f, 0x53, - 0xd1, 0xd5, 0x60, 0x98, 0xe4, 0xf3, 0x6e, 0xa3, 0xb1, 0x8c, 0x15, 0xf5, 0x65, 0x1c, 0x69, 0x49, - 0x5f, 0x2e, 0x85, 0x7b, 0xd2, 0x97, 0xcb, 0xc1, 0x99, 0xb6, 0x86, 0x86, 0x50, 0x4d, 0xd4, 0xc3, - 0xd0, 0x0b, 0xd1, 0xb4, 0xb7, 0xa0, 0xf0, 0xfa, 0x0a, 0x6e, 0x32, 0x60, 0x82, 0x27, 0x45, 0x14, - 0x7a, 0x34, 0x76, 0xf0, 0x34, 0xb6, 0x17, 0xe8, 0x81, 0x55, 0xbb, 0x50, 0xde, 0xc7, 0xa4, 0xef, - 0xe1, 0xf3, 0xf4, 0x3a, 0x1e, 0x30, 0x1d, 0xe1, 0xb3, 0x26, 0x6a, 0x24, 0x64, 0x23, 0x6f, 0x9d, - 0x4f, 0xd3, 0xb3, 0x07, 0xc5, 0xc8, 0x5b, 0x21, 0x12, 0x3b, 0x6b, 0xf1, 0x39, 0xb3, 0x71, 0x75, - 0x09, 0x27, 0xd0, 0xf2, 0x3e, 0xe4, 0x65, 0xd9, 0x49, 0x06, 0x4f, 0xa2, 0xde, 0x25, 0x83, 0x27, - 0x59, 0x9d, 0xd2, 0xd6, 0x7f, 0x9d, 0x51, 0xd0, 0x3e, 0x14, 0x23, 0x05, 0x1a, 0x69, 0xc5, 0x62, - 0x01, 0x49, 0x5a, 0xb1, 0xa4, 0x9a, 0xc3, 0x15, 0x7d, 0x00, 0xe5, 0x58, 0x11, 0x43, 0xba, 0x65, - 0x59, 0xe1, 0xa6, 0x71, 0x6d, 0x29, 0x2f, 0x98, 0xd4, 0x00, 0x6a, 0xc9, 0xb2, 0x01, 0xba, 0x1e, - 0x1d, 0x7f, 0x51, 0xe3, 0x8d, 0x55, 0xec, 0xa8, 0xd2, 0xe4, 0xe3, 0xa5, 0x54, 0xba, 0xe2, 0x71, - 0x54, 0x2a, 0x5d, 0xf5, 0xe6, 0xc9, 0x95, 0x26, 0x5f, 0x0a, 0xa5, 0xd2, 0x15, 0x8f, 0x96, 0x52, - 0xe9, 0xaa, 0x07, 0x46, 0x6d, 0x8d, 0xba, 0x32, 0x86, 0xd7, 0xa5, 0x2b, 0x97, 0x5d, 0x3a, 0xa4, - 0x2b, 0x97, 0x02, 0x7c, 0xbe, 0xad, 0xe3, 0x70, 0x5b, 0x6e, 0xeb, 0xa5, 0x50, 0x5e, 0x6e, 0xeb, - 0xe5, 0x08, 0x5d, 0x5b, 0x43, 0x1f, 0xc2, 0xe6, 0x02, 0xdc, 0x45, 0x62, 0x46, 0xab, 0xf0, 0x76, - 0xe3, 0xe6, 0x4a, 0x7e, 0x64, 0x53, 0x15, 0x43, 0xdc, 0x16, 0x9c, 0x3f, 0x0b, 0xa0, 0x52, 0x9e, - 0x3f, 0x8b, 0x18, 0x4f, 0x24, 0x88, 0x3d, 0x28, 0x46, 0x50, 0x0a, 0x0a, 0x8f, 0xab, 0x04, 0x32, - 0x6a, 0x5c, 0x5d, 0xc2, 0x91, 0x9a, 0x76, 0x5f, 0xfe, 0xc7, 0x9f, 0xf2, 0xca, 0xdf, 0xbe, 0xbe, - 0xa1, 0xfc, 0xfd, 0xeb, 0x1b, 0xca, 0x3f, 0xbf, 0xbe, 0xa1, 0x7c, 0xf5, 0xaf, 0x1b, 0x6b, 0x50, - 0x73, 0xbc, 0xc9, 0x0e, 0xb1, 0x4e, 0xcf, 0x77, 0x4e, 0xcf, 0xd9, 0x5f, 0x2d, 0x8f, 0x72, 0xec, - 0xe7, 0xed, 0xff, 0x05, 0x00, 0x00, 0xff, 0xff, 0x22, 0x5e, 0x53, 0x10, 0xdf, 0x29, 0x00, 0x00, +func init() { proto.RegisterFile("pdpb.proto", fileDescriptor_pdpb_d3e161b7e0af7b49) } + +var fileDescriptor_pdpb_d3e161b7e0af7b49 = []byte{ + // 3119 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x3a, 0x4b, 0x6f, 0x23, 0xc7, + 0xd1, 0x1a, 0x6a, 0x48, 0x91, 0xc5, 0xa7, 0x7a, 0xb5, 0x2b, 0x2e, 0xd7, 0xfb, 0xf0, 0xec, 0xe3, + 0x5b, 0xbf, 0x64, 0x7b, 0xbd, 0x30, 0x0c, 0x7c, 0xb0, 0xf1, 0x51, 0x12, 0x57, 0x4b, 0xaf, 0x56, + 0x24, 0x86, 0x94, 0xfd, 0xf9, 0xc3, 0x07, 0x4f, 0x46, 0x64, 0x8b, 0x9a, 0x88, 0x9c, 0x19, 0xcf, + 0x34, 0xb5, 0xa6, 0x91, 0x43, 0x80, 0x00, 0x49, 0x80, 0x38, 0x40, 0x2e, 0x76, 0x7c, 0x08, 0x72, + 0x4d, 0x4e, 0x39, 0xe6, 0x9a, 0x6b, 0x8e, 0x39, 0xe6, 0x18, 0x38, 0xbf, 0x20, 0x97, 0xe4, 0x16, + 0x04, 0xfd, 0x9a, 0x17, 0xc9, 0xd5, 0x7a, 0xd6, 0x06, 0x7c, 0xe2, 0x74, 0x55, 0x75, 0x75, 0xbd, + 0xba, 0xba, 0xba, 0x9a, 0x00, 0xee, 0xd0, 0x3d, 0xda, 0x72, 0x3d, 0x87, 0x38, 0x48, 0xa5, 0xdf, + 0x8d, 0xd2, 0x04, 0x13, 0x53, 0xc2, 0x1a, 0x65, 0xec, 0x99, 0xc7, 0x24, 0x18, 0xd6, 0x3d, 0xec, + 0x8e, 0xad, 0x81, 0x49, 0x2c, 0xc7, 0x36, 0x26, 0xce, 0x10, 0x07, 0x98, 0x8d, 0x91, 0x33, 0x72, + 0xd8, 0xe7, 0xeb, 0xf4, 0x4b, 0x40, 0xab, 0xde, 0xd4, 0x27, 0xec, 0x93, 0x03, 0xb4, 0x2d, 0x28, + 0xeb, 0xf8, 0x93, 0x29, 0xf6, 0xc9, 0x43, 0x6c, 0x0e, 0xb1, 0x87, 0xae, 0x02, 0x0c, 0xc6, 0x53, + 0x9f, 0x60, 0xcf, 0xb0, 0x86, 0x75, 0xe5, 0x86, 0x72, 0x57, 0xd5, 0x0b, 0x02, 0xd2, 0x1e, 0x6a, + 0x3a, 0x54, 0x74, 0xec, 0xbb, 0x8e, 0xed, 0xe3, 0x67, 0x9a, 0x80, 0x5e, 0x84, 0x2c, 0xf6, 0x3c, + 0xc7, 0xab, 0x67, 0x6e, 0x28, 0x77, 0x8b, 0xf7, 0x8a, 0x5b, 0x4c, 0xc1, 0x16, 0x05, 0xe9, 0x1c, + 0xa3, 0x3d, 0x80, 0x2c, 0x1b, 0xa3, 0x9b, 0xa0, 0x92, 0x99, 0x8b, 0x19, 0x93, 0xca, 0xbd, 0x6a, + 0x84, 0xb4, 0x3f, 0x73, 0xb1, 0xce, 0x90, 0xa8, 0x0e, 0x6b, 0x13, 0xec, 0xfb, 0xe6, 0x08, 0x33, + 0x96, 0x05, 0x5d, 0x0e, 0xb5, 0x0e, 0x40, 0xdf, 0x77, 0x84, 0x3a, 0xe8, 0x15, 0xc8, 0x9d, 0x30, + 0x09, 0x19, 0xbb, 0xe2, 0xbd, 0x0b, 0x9c, 0x5d, 0x4c, 0x5b, 0x5d, 0x90, 0xa0, 0x0d, 0xc8, 0x0e, + 0x9c, 0xa9, 0x4d, 0x18, 0xcb, 0xb2, 0xce, 0x07, 0x5a, 0x13, 0x0a, 0x7d, 0x6b, 0x82, 0x7d, 0x62, + 0x4e, 0x5c, 0xd4, 0x80, 0xbc, 0x7b, 0x32, 0xf3, 0xad, 0x81, 0x39, 0x66, 0x1c, 0x57, 0xf5, 0x60, + 0x4c, 0x65, 0x1a, 0x3b, 0x23, 0x86, 0xca, 0x30, 0x94, 0x1c, 0x6a, 0x3f, 0x56, 0xa0, 0xc8, 0x84, + 0xe2, 0x36, 0x43, 0xaf, 0x26, 0xa4, 0xda, 0x90, 0x52, 0x45, 0x6d, 0xfa, 0x74, 0xb1, 0xd0, 0x6b, + 0x50, 0x20, 0x52, 0xac, 0xfa, 0x2a, 0x63, 0x23, 0x6c, 0x15, 0x48, 0xab, 0x87, 0x14, 0xda, 0xe7, + 0x0a, 0xd4, 0xb6, 0x1d, 0x87, 0xf8, 0xc4, 0x33, 0xdd, 0x54, 0xd6, 0xb9, 0x09, 0x59, 0x9f, 0x38, + 0x1e, 0x16, 0x3e, 0x2c, 0x6f, 0x89, 0x90, 0xec, 0x51, 0xa0, 0xce, 0x71, 0xe8, 0x0e, 0xe4, 0x3c, + 0x3c, 0xb2, 0x1c, 0x5b, 0x88, 0x54, 0x91, 0x54, 0x3a, 0x83, 0xea, 0x02, 0xab, 0xfd, 0x5a, 0x81, + 0xf5, 0x88, 0x38, 0xa9, 0xec, 0xd2, 0x07, 0x14, 0x0d, 0x7c, 0x9f, 0x98, 0x64, 0xea, 0x0b, 0xe9, + 0x6e, 0x6f, 0x2d, 0xd8, 0x13, 0x7a, 0x08, 0xea, 0x31, 0x62, 0x7d, 0xdd, 0x4b, 0x82, 0xb4, 0x5d, + 0xb8, 0xd8, 0xf6, 0x03, 0xd1, 0x5c, 0x3c, 0x4c, 0x63, 0x2c, 0xed, 0x87, 0x70, 0x29, 0xc9, 0x25, + 0x95, 0x8e, 0x1a, 0x94, 0x8e, 0x22, 0x5c, 0x98, 0x76, 0x79, 0x3d, 0x06, 0xd3, 0xde, 0x85, 0x4a, + 0x73, 0x3c, 0x76, 0x06, 0xed, 0xdd, 0x54, 0xa2, 0x76, 0xa0, 0x1a, 0x4c, 0x4f, 0x25, 0x63, 0x05, + 0x32, 0x16, 0x97, 0x4c, 0xd5, 0x33, 0xd6, 0x50, 0xfb, 0x08, 0xaa, 0x7b, 0x98, 0xf0, 0xb0, 0x48, + 0x13, 0x68, 0x97, 0x21, 0xcf, 0x82, 0xc9, 0x08, 0xb8, 0xae, 0xb1, 0x71, 0x7b, 0xa8, 0xfd, 0x52, + 0x81, 0x5a, 0xc8, 0x3b, 0x95, 0xb4, 0xcf, 0x18, 0xc6, 0x59, 0x1a, 0x4e, 0xbe, 0x88, 0xe2, 0x1a, + 0xe7, 0xc8, 0x48, 0x68, 0x98, 0xf8, 0x3a, 0x47, 0x6b, 0x03, 0xa8, 0x76, 0xa7, 0xcf, 0xa1, 0xea, + 0xb3, 0x08, 0xa3, 0x7d, 0xa9, 0x40, 0x2d, 0x5c, 0xe5, 0x7b, 0xb4, 0x55, 0x7e, 0x04, 0x17, 0xf6, + 0x30, 0x69, 0x8e, 0xc7, 0x4c, 0x34, 0x3f, 0x95, 0x05, 0xde, 0x81, 0x3a, 0xfe, 0x74, 0x30, 0x9e, + 0x0e, 0xb1, 0x41, 0x9c, 0xc9, 0x91, 0x4f, 0x1c, 0x1b, 0x1b, 0x4c, 0x6f, 0x5f, 0x04, 0xfb, 0x25, + 0x81, 0xef, 0x4b, 0x34, 0x5f, 0x4d, 0x3b, 0x85, 0x8d, 0xf8, 0xea, 0xa9, 0x2c, 0x73, 0x1b, 0x72, + 0xc1, 0x6a, 0xab, 0xf3, 0x2e, 0x10, 0x48, 0xed, 0x63, 0x16, 0x77, 0x22, 0x89, 0xa5, 0xd1, 0xf3, + 0x2a, 0x00, 0x4f, 0x7d, 0xc6, 0x29, 0x9e, 0x31, 0xcd, 0x4a, 0x7a, 0x81, 0x43, 0x1e, 0xe1, 0x99, + 0xf6, 0x55, 0x06, 0xd6, 0x23, 0x0b, 0xa4, 0x52, 0x25, 0xcc, 0xbd, 0x99, 0xa7, 0xe5, 0x5e, 0x74, + 0x0b, 0x72, 0x63, 0xce, 0x95, 0x47, 0x77, 0x49, 0xd2, 0x75, 0x31, 0xe5, 0xc6, 0x71, 0x94, 0xca, + 0x1f, 0x9b, 0x67, 0xd8, 0xaf, 0xab, 0xcc, 0x30, 0x09, 0x2a, 0x8e, 0x43, 0x5b, 0x00, 0x43, 0xe7, + 0x89, 0x6d, 0xb8, 0x18, 0x7b, 0x7e, 0x3d, 0xcb, 0x28, 0xc5, 0x31, 0x44, 0xe9, 0xf8, 0x66, 0x29, + 0x50, 0x12, 0x3a, 0xf4, 0xd1, 0x9b, 0x50, 0x76, 0xb1, 0x3d, 0xb4, 0xec, 0x91, 0x98, 0x92, 0x5b, + 0xc0, 0xbc, 0x24, 0x48, 0xd8, 0x14, 0xed, 0x07, 0xcc, 0xcf, 0x5c, 0x87, 0xed, 0x59, 0xba, 0x24, + 0x87, 0xae, 0x80, 0x30, 0x76, 0x98, 0x54, 0xf2, 0x1c, 0xc0, 0xb3, 0x0a, 0xea, 0x0d, 0x4c, 0x9b, + 0xaf, 0xe1, 0xa7, 0x5d, 0xc0, 0x27, 0xa6, 0x47, 0x22, 0xee, 0xcd, 0x33, 0xc0, 0x23, 0x3c, 0xa3, + 0x27, 0xf8, 0xd8, 0x9a, 0x58, 0x84, 0x19, 0x3c, 0xab, 0xf3, 0x01, 0xda, 0x84, 0x35, 0x6c, 0x0f, + 0xd9, 0x04, 0x95, 0x4d, 0xc8, 0x61, 0x7b, 0x48, 0x83, 0xe1, 0x0b, 0x05, 0x2e, 0xc4, 0xe4, 0x49, + 0x15, 0x0e, 0x77, 0x61, 0x8d, 0x6b, 0x28, 0x43, 0x3b, 0x19, 0x0f, 0x12, 0x8d, 0xee, 0xc0, 0x1a, + 0x77, 0x3a, 0xcd, 0x77, 0xf3, 0xee, 0x90, 0x48, 0xed, 0x01, 0x6c, 0xee, 0x61, 0xb2, 0xc3, 0xab, + 0xba, 0x1d, 0xc7, 0x3e, 0xb6, 0x46, 0xa9, 0x4e, 0x1c, 0x1f, 0xea, 0xf3, 0x7c, 0x52, 0xe9, 0xf8, + 0x12, 0xac, 0x89, 0x22, 0x53, 0xc4, 0x7c, 0x55, 0x4a, 0x2e, 0xb8, 0xeb, 0x12, 0xaf, 0x7d, 0x02, + 0x9b, 0xdd, 0xe9, 0xf3, 0x0b, 0xff, 0x4d, 0x96, 0x7c, 0x08, 0xf5, 0xf9, 0x25, 0xd3, 0xe8, 0xa9, + 0xfd, 0x24, 0x03, 0xb9, 0xc7, 0x78, 0x72, 0x84, 0x3d, 0x84, 0x40, 0xb5, 0xcd, 0x09, 0x2f, 0x8f, + 0x0b, 0x3a, 0xfb, 0xa6, 0xc1, 0x37, 0x61, 0xd8, 0x48, 0x74, 0x73, 0x40, 0x7b, 0x48, 0x91, 0x74, + 0xab, 0x19, 0x53, 0x6f, 0xcc, 0xfd, 0x5b, 0xd0, 0xf3, 0x14, 0x70, 0xe8, 0x8d, 0x7d, 0x74, 0x1d, + 0x8a, 0x83, 0xb1, 0x85, 0x6d, 0xc2, 0xd1, 0x2a, 0x43, 0x03, 0x07, 0x31, 0x82, 0xff, 0x82, 0x2a, + 0x77, 0xbf, 0xe1, 0x7a, 0x96, 0xe3, 0x59, 0x64, 0x56, 0xcf, 0xb2, 0x20, 0xae, 0x70, 0x70, 0x57, + 0x40, 0x29, 0xa7, 0x21, 0x76, 0xc7, 0xce, 0xcc, 0x70, 0x4d, 0x72, 0x52, 0xcf, 0x31, 0xf1, 0x80, + 0x83, 0xba, 0x26, 0x39, 0x41, 0xb7, 0xa1, 0x72, 0x64, 0xd9, 0xa6, 0x37, 0x33, 0xce, 0xb0, 0xe7, + 0xd3, 0x34, 0xb5, 0xc6, 0x68, 0xca, 0x1c, 0xfa, 0x01, 0x07, 0xd2, 0xd3, 0x7f, 0x64, 0x11, 0xe3, + 0xc4, 0xf4, 0x4f, 0xea, 0x79, 0x5e, 0xda, 0x8f, 0x2c, 0xf2, 0xd0, 0xf4, 0x4f, 0xb4, 0xff, 0x61, + 0x39, 0x92, 0xdb, 0x21, 0xd5, 0x2e, 0xd5, 0xfe, 0xa4, 0x00, 0x8a, 0xb2, 0x48, 0x99, 0x67, 0xd7, + 0xb8, 0x71, 0xe5, 0xc6, 0x2a, 0x71, 0x72, 0xce, 0x55, 0x97, 0xc8, 0x05, 0x79, 0x36, 0x4a, 0x26, + 0xf3, 0xec, 0x6b, 0x50, 0xc4, 0x64, 0x30, 0x34, 0x04, 0xa9, 0xba, 0x80, 0x14, 0x28, 0xc1, 0x3e, + 0xd7, 0xa0, 0x0b, 0x85, 0x20, 0xb1, 0xa2, 0x1b, 0xa0, 0x52, 0x4f, 0x0a, 0xa9, 0xe3, 0xbb, 0x96, + 0x61, 0xd0, 0x8b, 0x50, 0x62, 0xf9, 0xd9, 0xc7, 0x03, 0xc7, 0x1e, 0xfa, 0x22, 0x38, 0x8a, 0x14, + 0xd6, 0xe3, 0x20, 0xed, 0x9f, 0x2a, 0x5c, 0xe2, 0x19, 0xe1, 0x21, 0x36, 0x3d, 0x72, 0x84, 0x4d, + 0x92, 0x6a, 0x63, 0x7c, 0xbb, 0xc7, 0x4f, 0xfc, 0x60, 0x51, 0xbf, 0xf9, 0xc1, 0x92, 0x3d, 0xef, + 0x60, 0x41, 0x37, 0xa1, 0x7c, 0x34, 0x23, 0xd8, 0x37, 0x9e, 0x78, 0x16, 0x21, 0xd8, 0x66, 0x31, + 0xab, 0xea, 0x25, 0x06, 0xfc, 0x90, 0xc3, 0xe8, 0xb9, 0xcd, 0x89, 0x3c, 0x6c, 0x0e, 0x59, 0xc4, + 0xaa, 0x7a, 0x81, 0x41, 0x74, 0x6c, 0xd2, 0x8b, 0x6d, 0xe9, 0x14, 0xcf, 0x42, 0x16, 0x79, 0x6e, + 0x5f, 0x0a, 0x93, 0x1c, 0xae, 0x40, 0x81, 0x91, 0x30, 0x06, 0x05, 0xbe, 0x39, 0x29, 0x80, 0xcd, + 0x7f, 0x09, 0x6a, 0xa6, 0xeb, 0x7a, 0xce, 0xa7, 0xd6, 0xc4, 0x24, 0xd8, 0xf0, 0xad, 0xcf, 0x70, + 0x1d, 0x18, 0x4d, 0x35, 0x02, 0xef, 0x59, 0x9f, 0x61, 0xb4, 0x05, 0x79, 0xcb, 0x26, 0xd8, 0x3b, + 0x33, 0xc7, 0xf5, 0x12, 0xb3, 0x1c, 0x0a, 0xef, 0x7b, 0x6d, 0x81, 0xd1, 0x03, 0x9a, 0x24, 0x6b, + 0xba, 0x64, 0xbd, 0x3c, 0xc7, 0xfa, 0x11, 0x9e, 0xf9, 0x34, 0xa7, 0x10, 0xec, 0x4d, 0xea, 0x15, + 0x86, 0x66, 0xdf, 0xe8, 0xff, 0x16, 0x96, 0x8c, 0x55, 0xb6, 0xf0, 0x2b, 0x8b, 0x4b, 0x46, 0x5e, + 0xbb, 0x9c, 0x5f, 0x38, 0xbe, 0xaf, 0xe6, 0x8b, 0xb5, 0x92, 0x76, 0x02, 0xb0, 0x73, 0x62, 0xda, + 0x23, 0x4c, 0xdd, 0xf1, 0x0c, 0xb1, 0xfc, 0x0e, 0x14, 0x07, 0x8c, 0xde, 0x60, 0xfd, 0x81, 0x0c, + 0xeb, 0x0f, 0x6c, 0x6e, 0xc9, 0x5e, 0x08, 0x4d, 0xb0, 0x9c, 0x1f, 0xeb, 0x13, 0xc0, 0x20, 0xf8, + 0xd6, 0xee, 0x41, 0xa5, 0xef, 0x99, 0xb6, 0x7f, 0x8c, 0x3d, 0xbe, 0x8d, 0xce, 0x5f, 0x4d, 0x7b, + 0x1d, 0xb2, 0x8f, 0xb1, 0x37, 0x62, 0x57, 0x5a, 0x62, 0x7a, 0x23, 0x4c, 0x04, 0xf1, 0x5c, 0x5c, + 0x73, 0xac, 0xb6, 0x0f, 0xc5, 0x9e, 0x3b, 0xb6, 0x44, 0xa5, 0x82, 0x5e, 0x82, 0x9c, 0xeb, 0x8c, + 0xad, 0xc1, 0x4c, 0x34, 0x32, 0xd6, 0xb9, 0xb3, 0x76, 0x4e, 0xf0, 0xe0, 0xb4, 0xcb, 0x10, 0xba, + 0x20, 0xa0, 0xe6, 0x67, 0xde, 0xa1, 0xd9, 0xa4, 0xa4, 0xb3, 0x6f, 0xed, 0xcb, 0x55, 0xd8, 0x9c, + 0xdb, 0x95, 0xa9, 0xd2, 0xd5, 0x9b, 0x81, 0xd9, 0x98, 0xc6, 0x99, 0xe8, 0x8d, 0x26, 0xb4, 0xbf, + 0xb4, 0x17, 0xf3, 0xc5, 0xbb, 0x50, 0x25, 0xc2, 0x5e, 0x46, 0x6c, 0xaf, 0x8a, 0x95, 0xe2, 0xc6, + 0xd4, 0x2b, 0x24, 0x6e, 0xdc, 0x58, 0xb1, 0xa5, 0xc6, 0x8b, 0x2d, 0xf4, 0x36, 0x94, 0x04, 0x12, + 0xbb, 0xce, 0xe0, 0x84, 0x9d, 0x26, 0x34, 0xb3, 0xc4, 0x8c, 0xda, 0xa2, 0x28, 0xbd, 0xe8, 0x85, + 0x03, 0x9a, 0x27, 0xb9, 0xa1, 0xb9, 0x1a, 0xb9, 0x05, 0x8e, 0x03, 0x4e, 0xd0, 0xe5, 0x89, 0x2f, + 0x3b, 0xa1, 0xee, 0x63, 0x5b, 0x36, 0xe8, 0x38, 0x31, 0x8f, 0xea, 0x1c, 0x83, 0xee, 0x43, 0xc9, + 0xa7, 0x0e, 0x33, 0x44, 0xda, 0xca, 0x33, 0x4a, 0xe1, 0xa7, 0x88, 0x2b, 0xf5, 0xa2, 0x1f, 0x0e, + 0xb4, 0x63, 0xa8, 0x36, 0xfd, 0x53, 0x81, 0xfe, 0xee, 0xd2, 0xa4, 0xf6, 0x53, 0x05, 0x6a, 0xe1, + 0x42, 0x29, 0x9b, 0x07, 0x65, 0x1b, 0x3f, 0x31, 0x92, 0x85, 0x6f, 0xd1, 0xc6, 0x4f, 0x74, 0xe9, + 0x8e, 0x1b, 0x50, 0xa2, 0x34, 0xac, 0x42, 0xb0, 0x86, 0xbc, 0x40, 0x50, 0x75, 0xb0, 0xf1, 0x13, + 0x6a, 0xc6, 0xf6, 0xd0, 0xd7, 0x7e, 0xa1, 0x00, 0xd2, 0xb1, 0xeb, 0x78, 0x24, 0xbd, 0xd2, 0x1a, + 0xa8, 0x63, 0x7c, 0x4c, 0x96, 0xa8, 0xcc, 0x70, 0xe8, 0x16, 0x64, 0x3d, 0x6b, 0x74, 0x42, 0x96, + 0x74, 0x8e, 0x38, 0x52, 0xdb, 0x81, 0x0b, 0x31, 0x61, 0x52, 0x95, 0x53, 0x9f, 0x2b, 0xb0, 0xd1, + 0xf4, 0x4f, 0xb7, 0x4d, 0x32, 0x38, 0xf9, 0xce, 0x3d, 0x49, 0x2b, 0x23, 0x1e, 0x67, 0xbc, 0x8b, + 0xb7, 0xca, 0xba, 0x78, 0xc0, 0x40, 0x3b, 0xac, 0xc3, 0xd8, 0x81, 0x35, 0x26, 0x45, 0x7b, 0x77, + 0xde, 0x65, 0xca, 0xf9, 0x2e, 0xcb, 0xcc, 0xb9, 0xec, 0x18, 0x2e, 0x26, 0xd4, 0x4b, 0x15, 0x3f, + 0xd7, 0x61, 0x55, 0xf2, 0xa7, 0x17, 0xe3, 0x70, 0x5f, 0xb4, 0x77, 0x75, 0x8a, 0xd1, 0x5c, 0x9a, + 0xa3, 0xa8, 0x33, 0x9e, 0xd3, 0x92, 0xcf, 0x7c, 0x55, 0xa1, 0x25, 0xf5, 0xfc, 0x8a, 0xa9, 0x62, + 0xe0, 0xff, 0xa1, 0x14, 0x3d, 0x38, 0x69, 0xa1, 0xcb, 0x2f, 0x70, 0x61, 0x57, 0x95, 0xdb, 0xbe, + 0xc2, 0xc0, 0x61, 0x0b, 0xf8, 0x26, 0x94, 0xe9, 0xb5, 0x2d, 0x24, 0xe3, 0xbb, 0xaa, 0x84, 0xed, + 0x61, 0x40, 0xa4, 0xdd, 0x07, 0xd0, 0xf1, 0xc0, 0xf1, 0x86, 0x5d, 0xd3, 0xf2, 0x50, 0x0d, 0x56, + 0xe9, 0x2d, 0x8f, 0x97, 0xec, 0xf4, 0x93, 0xde, 0x08, 0xcf, 0xcc, 0xf1, 0x14, 0x8b, 0xc9, 0x7c, + 0xa0, 0xfd, 0x23, 0x0b, 0x10, 0x36, 0x99, 0x62, 0x8d, 0x30, 0x25, 0xd6, 0x08, 0x43, 0x0d, 0xc8, + 0x0f, 0x4c, 0xd7, 0x1c, 0xd0, 0x7a, 0x5c, 0x14, 0xfc, 0x72, 0x8c, 0x5e, 0x80, 0x82, 0x79, 0x66, + 0x5a, 0x63, 0xf3, 0x68, 0x8c, 0x59, 0xb4, 0xa9, 0x7a, 0x08, 0xa0, 0x15, 0x8b, 0x88, 0x2e, 0x1e, + 0x8e, 0x2a, 0x0b, 0x47, 0x91, 0x6a, 0x59, 0x3c, 0xa2, 0x57, 0x01, 0xf9, 0xa2, 0x96, 0xf2, 0x6d, + 0xd3, 0x15, 0x84, 0x59, 0x46, 0x58, 0x13, 0x98, 0x9e, 0x6d, 0xba, 0x9c, 0xfa, 0x0d, 0xd8, 0xf0, + 0xf0, 0x00, 0x5b, 0x67, 0x09, 0xfa, 0x1c, 0xa3, 0x47, 0x01, 0x2e, 0x9c, 0x71, 0x15, 0x20, 0x34, + 0x35, 0x4b, 0xd0, 0x65, 0xbd, 0x10, 0x58, 0x19, 0x6d, 0xc1, 0x05, 0xd3, 0x75, 0xc7, 0xb3, 0x04, + 0xbf, 0x3c, 0xa3, 0x5b, 0x97, 0xa8, 0x90, 0xdd, 0x26, 0xac, 0x59, 0xbe, 0x71, 0x34, 0xf5, 0x67, + 0xac, 0xbc, 0xca, 0xeb, 0x39, 0xcb, 0xdf, 0x9e, 0xfa, 0x33, 0x7a, 0x0e, 0x4d, 0x7d, 0x3c, 0x8c, + 0x56, 0x55, 0x79, 0x0a, 0x60, 0xe5, 0xd4, 0x5c, 0xf5, 0x57, 0x5c, 0x50, 0xfd, 0x25, 0xcb, 0xbb, + 0xd2, 0x7c, 0x79, 0x17, 0x2f, 0x10, 0xcb, 0xc9, 0x02, 0x31, 0x56, 0xfd, 0x55, 0x12, 0xd5, 0x5f, + 0xb4, 0xa4, 0xab, 0x3e, 0x43, 0x49, 0xf7, 0x3a, 0xc0, 0xc0, 0x9d, 0x1a, 0x53, 0xdf, 0x1c, 0x61, + 0xbf, 0x5e, 0x63, 0x5b, 0xa5, 0x26, 0xa3, 0x5c, 0x46, 0x9b, 0x5e, 0x18, 0xb8, 0xd3, 0x43, 0x46, + 0x82, 0xee, 0x43, 0x99, 0x2e, 0x6c, 0x58, 0x8e, 0xe1, 0x99, 0x04, 0xfb, 0xf5, 0xf5, 0x25, 0x73, + 0x8a, 0x94, 0xac, 0xed, 0xe8, 0x94, 0x08, 0xbd, 0x0d, 0x15, 0xaa, 0x30, 0x0e, 0xa7, 0xa1, 0x25, + 0xd3, 0x4a, 0x8c, 0x4e, 0xce, 0x7b, 0x0b, 0x4a, 0x8e, 0x6b, 0x8c, 0x4d, 0x82, 0xed, 0x81, 0x85, + 0xfd, 0xfa, 0x85, 0x65, 0x8b, 0x39, 0xee, 0xbe, 0x24, 0xd2, 0xc6, 0x70, 0x91, 0x85, 0xfc, 0xf3, + 0x5e, 0x3e, 0x44, 0xc3, 0x36, 0xf3, 0xf4, 0x86, 0xed, 0x6f, 0x14, 0xb8, 0x94, 0x5c, 0xee, 0x7b, + 0xd4, 0x51, 0xfd, 0x83, 0x02, 0x1b, 0xbd, 0x81, 0x49, 0x08, 0xf6, 0x9e, 0xa3, 0xd7, 0xf8, 0xb4, + 0x66, 0xd7, 0xb3, 0xbe, 0xd0, 0x44, 0xae, 0x69, 0xea, 0xf2, 0x6b, 0x9a, 0xd6, 0x82, 0x8b, 0x09, + 0x79, 0x53, 0x25, 0xe3, 0x5d, 0xb8, 0xb8, 0x87, 0xc9, 0xde, 0x4e, 0xcf, 0x3c, 0xc6, 0x5d, 0xc7, + 0xb2, 0x53, 0x05, 0x81, 0x86, 0xe1, 0x52, 0x92, 0x4b, 0x2a, 0xdf, 0xd2, 0xfc, 0x64, 0x1e, 0x63, + 0xc3, 0xa5, 0x3c, 0x84, 0x01, 0x0b, 0xbe, 0x64, 0xaa, 0x1d, 0x43, 0xfd, 0xd0, 0x1d, 0x9a, 0x04, + 0x3f, 0xa7, 0xbc, 0xe7, 0xad, 0xe3, 0xc0, 0xe5, 0x05, 0xeb, 0xa4, 0xd2, 0xe8, 0x16, 0x54, 0x68, + 0xc9, 0x30, 0xb7, 0x1a, 0x2d, 0x24, 0x02, 0xde, 0xda, 0x6f, 0x15, 0xb8, 0xce, 0x57, 0xec, 0x61, + 0xef, 0xcc, 0x1a, 0x7c, 0x2b, 0x0a, 0x72, 0x4e, 0x32, 0x12, 0x4b, 0x7a, 0x41, 0x40, 0xda, 0x43, + 0x7a, 0x2c, 0xf6, 0xfb, 0xfb, 0x2c, 0x0e, 0x57, 0x75, 0xfa, 0x99, 0xb0, 0x88, 0x9a, 0xb4, 0xc8, + 0xef, 0x14, 0xb8, 0xb1, 0x5c, 0xc0, 0xd4, 0xbe, 0xfe, 0x46, 0x22, 0xde, 0x82, 0xca, 0xc4, 0xb2, + 0x8d, 0x39, 0x31, 0x4b, 0x13, 0xcb, 0x0e, 0x4d, 0xf9, 0x2b, 0x85, 0x16, 0x00, 0x23, 0xb1, 0xb3, + 0xe7, 0x0f, 0x1b, 0xe5, 0xdc, 0x56, 0x43, 0xe6, 0xbc, 0x56, 0xc3, 0xea, 0x39, 0xad, 0x06, 0x35, + 0x7e, 0xd8, 0x68, 0x3f, 0x53, 0x60, 0xbd, 0x37, 0xb3, 0x07, 0xcf, 0x91, 0x58, 0x6e, 0x41, 0x8e, + 0x37, 0xb7, 0x44, 0xa2, 0x4b, 0x74, 0xb4, 0x38, 0x8e, 0xd5, 0xbb, 0xec, 0x78, 0xb7, 0xec, 0x21, + 0xfe, 0x54, 0xc8, 0xc9, 0x4f, 0xfc, 0x36, 0x85, 0x68, 0xff, 0x52, 0x00, 0x45, 0x25, 0xf9, 0x8e, + 0xdb, 0xdb, 0xe7, 0xc9, 0x43, 0xcf, 0x2d, 0x91, 0x2f, 0xf9, 0x19, 0xa2, 0xc6, 0xcf, 0x2d, 0xe9, + 0x45, 0x59, 0x24, 0xf1, 0xe2, 0xec, 0x2d, 0xa8, 0x88, 0x49, 0xb2, 0x77, 0xbe, 0xa8, 0xe3, 0x54, + 0xe6, 0x34, 0xfb, 0xa2, 0x83, 0xfe, 0x31, 0x6b, 0x3f, 0x76, 0x5c, 0xec, 0x99, 0xc4, 0xf1, 0xbe, + 0xfd, 0x97, 0x8c, 0x3f, 0x2a, 0xec, 0x49, 0x2e, 0x5c, 0x20, 0x95, 0x69, 0x9f, 0x7a, 0x7e, 0x20, + 0x50, 0x87, 0xd8, 0x1f, 0x30, 0x33, 0x96, 0x74, 0xf6, 0x4d, 0xd9, 0x8b, 0x03, 0x50, 0x65, 0xbd, + 0x0e, 0xc1, 0x5e, 0x8a, 0x21, 0xce, 0x3b, 0x41, 0xc3, 0xda, 0x1d, 0x96, 0x3d, 0x64, 0x05, 0x65, + 0x49, 0x67, 0xdf, 0x2f, 0x7f, 0xa1, 0x40, 0x21, 0xf8, 0x8f, 0x07, 0xca, 0x41, 0xa6, 0xf3, 0xa8, + 0xb6, 0x82, 0x8a, 0xb0, 0x76, 0x78, 0xf0, 0xe8, 0xa0, 0xf3, 0xe1, 0x41, 0x4d, 0x41, 0x1b, 0x50, + 0x3b, 0xe8, 0xf4, 0x8d, 0xed, 0x4e, 0xa7, 0xdf, 0xeb, 0xeb, 0xcd, 0x6e, 0xb7, 0xb5, 0x5b, 0xcb, + 0xa0, 0x0b, 0x50, 0xed, 0xf5, 0x3b, 0x7a, 0xcb, 0xe8, 0x77, 0x1e, 0x6f, 0xf7, 0xfa, 0x9d, 0x83, + 0x56, 0x6d, 0x15, 0xd5, 0x61, 0xa3, 0xb9, 0xaf, 0xb7, 0x9a, 0xbb, 0x1f, 0xc5, 0xc9, 0x55, 0x8a, + 0x69, 0x1f, 0xec, 0x74, 0x1e, 0x77, 0x9b, 0xfd, 0xf6, 0xf6, 0x7e, 0xcb, 0xf8, 0xa0, 0xa5, 0xf7, + 0xda, 0x9d, 0x83, 0x5a, 0x96, 0xb2, 0xd7, 0x5b, 0x7b, 0xed, 0xce, 0x81, 0x41, 0x57, 0x79, 0xd0, + 0x39, 0x3c, 0xd8, 0xad, 0xe5, 0x5e, 0xbe, 0x0f, 0xc5, 0x48, 0xc7, 0x06, 0xe5, 0x41, 0xed, 0xed, + 0x34, 0x0f, 0x6a, 0x2b, 0xa8, 0x0a, 0xc5, 0x66, 0xb7, 0xab, 0x77, 0xfe, 0xb7, 0xfd, 0xb8, 0xd9, + 0x6f, 0xd5, 0x14, 0x04, 0x90, 0x3b, 0xec, 0xb5, 0x1e, 0xb5, 0x3e, 0xaa, 0x65, 0x5e, 0xee, 0x42, + 0x25, 0xae, 0x3b, 0xd5, 0xa4, 0x77, 0xb8, 0xb3, 0xd3, 0xea, 0xf5, 0xb8, 0x5a, 0xfd, 0xf6, 0xe3, + 0x56, 0xe7, 0xb0, 0xcf, 0xe7, 0xed, 0x34, 0x0f, 0x76, 0x5a, 0xfb, 0xb5, 0x0c, 0x45, 0xe8, 0xad, + 0xee, 0x7e, 0x73, 0x87, 0x2a, 0x41, 0x07, 0x87, 0x07, 0x07, 0xed, 0x83, 0xbd, 0x9a, 0x7a, 0xef, + 0xdf, 0x15, 0xc8, 0x74, 0x77, 0x51, 0x13, 0x20, 0x6c, 0x5f, 0xa3, 0x4d, 0x6e, 0xe6, 0xb9, 0x9e, + 0x78, 0xa3, 0x3e, 0x8f, 0xe0, 0x8e, 0xd6, 0x56, 0xd0, 0x1b, 0xb0, 0xda, 0xf7, 0x1d, 0x24, 0xa2, + 0x3b, 0xfc, 0xab, 0x4c, 0x63, 0x3d, 0x02, 0x91, 0xd4, 0x77, 0x95, 0x37, 0x14, 0xf4, 0x1e, 0x14, + 0x82, 0x7f, 0x32, 0xa0, 0x4b, 0x9c, 0x2a, 0xf9, 0x57, 0x92, 0xc6, 0xe6, 0x1c, 0x3c, 0x58, 0xf1, + 0x31, 0x54, 0xe2, 0xff, 0x85, 0x40, 0x57, 0x38, 0xf1, 0xc2, 0xff, 0x59, 0x34, 0x5e, 0x58, 0x8c, + 0x0c, 0xd8, 0xbd, 0x03, 0x6b, 0xe2, 0xff, 0x0a, 0x48, 0xc4, 0x59, 0xfc, 0xdf, 0x0f, 0x8d, 0x8b, + 0x09, 0x68, 0x30, 0xf3, 0xbf, 0x21, 0x2f, 0xff, 0x3c, 0x80, 0x2e, 0x06, 0x26, 0x8a, 0xbe, 0xde, + 0x37, 0x2e, 0x25, 0xc1, 0xd1, 0xc9, 0xf2, 0x11, 0x5e, 0x4e, 0x4e, 0x3c, 0xfd, 0xcb, 0xc9, 0xc9, + 0xb7, 0x7a, 0x6d, 0x05, 0xed, 0x41, 0x29, 0xfa, 0x56, 0x8d, 0x2e, 0x07, 0xcb, 0x24, 0x5f, 0xcf, + 0x1b, 0x8d, 0x45, 0xa8, 0xa8, 0x2d, 0xe3, 0xe5, 0xab, 0xb4, 0xe5, 0xc2, 0x1a, 0x5a, 0xda, 0x72, + 0x71, 0xc5, 0xab, 0xad, 0xa0, 0x3e, 0x54, 0x13, 0x4d, 0x46, 0xf4, 0x42, 0x34, 0xed, 0xcd, 0x31, + 0xbc, 0xba, 0x04, 0x9b, 0x0c, 0x98, 0xe0, 0xc5, 0x16, 0x85, 0x16, 0x8d, 0x1d, 0x3c, 0x8d, 0xcd, + 0x39, 0x78, 0x20, 0xd5, 0x36, 0x94, 0xf7, 0x30, 0xe9, 0x7a, 0xf8, 0x2c, 0x3d, 0x8f, 0x07, 0x8c, + 0x47, 0xf8, 0x6a, 0x8c, 0x1a, 0x09, 0xda, 0xc8, 0x53, 0xf2, 0xd3, 0xf8, 0xec, 0x42, 0x31, 0xf2, + 0x14, 0x8b, 0xc4, 0xce, 0x9a, 0x7f, 0x2d, 0x6e, 0x5c, 0x5e, 0x80, 0x09, 0xb8, 0xbc, 0x07, 0x79, + 0xd9, 0xcb, 0x93, 0xc1, 0x93, 0x68, 0x22, 0xca, 0xe0, 0x49, 0xb6, 0xfc, 0xb4, 0xd5, 0x9f, 0x67, + 0x14, 0xb4, 0x07, 0xc5, 0x48, 0xd7, 0x4b, 0x4a, 0x31, 0xdf, 0x95, 0x93, 0x52, 0x2c, 0x68, 0x91, + 0x71, 0x46, 0xef, 0x43, 0x39, 0xd6, 0x19, 0x92, 0x66, 0x59, 0xd4, 0x0d, 0x6b, 0x5c, 0x59, 0x88, + 0x0b, 0x94, 0xea, 0x41, 0x2d, 0xd9, 0x8b, 0x41, 0x57, 0xa3, 0xeb, 0xcf, 0x73, 0xbc, 0xb6, 0x0c, + 0x1d, 0x65, 0x9a, 0x7c, 0x1b, 0x96, 0x4c, 0x97, 0xbc, 0x3d, 0x4b, 0xa6, 0xcb, 0x9e, 0x94, 0x39, + 0xd3, 0xe4, 0x43, 0xac, 0x64, 0xba, 0xe4, 0x4d, 0x58, 0x32, 0x5d, 0xf6, 0x7e, 0xab, 0xad, 0x50, + 0x53, 0xc6, 0xae, 0x3e, 0xd2, 0x94, 0x8b, 0xee, 0x6f, 0xd2, 0x94, 0x0b, 0xef, 0x4a, 0x7c, 0x5b, + 0xc7, 0x6f, 0x2e, 0x72, 0x5b, 0x2f, 0xbc, 0x15, 0xc9, 0x6d, 0xbd, 0xf8, 0xb2, 0xa3, 0xad, 0xa0, + 0x0f, 0x60, 0x7d, 0xee, 0xe6, 0x80, 0x84, 0x46, 0xcb, 0xae, 0x2e, 0x8d, 0xeb, 0x4b, 0xf1, 0x01, + 0xdf, 0x53, 0x79, 0xf3, 0x99, 0x2f, 0xbf, 0xd1, 0xed, 0xe8, 0xf4, 0xa5, 0xf7, 0x87, 0xc6, 0x9d, + 0xf3, 0xc8, 0x22, 0x3b, 0xb8, 0x18, 0x16, 0x89, 0xc1, 0x61, 0x37, 0x57, 0xc1, 0xca, 0xc3, 0x6e, + 0xbe, 0xa0, 0x14, 0xd9, 0x68, 0x17, 0x8a, 0x91, 0x92, 0x08, 0x85, 0x67, 0x63, 0xa2, 0x0c, 0x6b, + 0x5c, 0x5e, 0x80, 0x91, 0x9c, 0xb6, 0xef, 0xfc, 0xf5, 0xf7, 0x79, 0xe5, 0xcf, 0x5f, 0x5f, 0x53, + 0xfe, 0xf2, 0xf5, 0x35, 0xe5, 0x6f, 0x5f, 0x5f, 0x53, 0xbe, 0xfa, 0xfb, 0xb5, 0x15, 0xa8, 0x39, + 0xde, 0x68, 0x8b, 0x58, 0xa7, 0x67, 0x5b, 0xa7, 0x67, 0xec, 0xaf, 0xb4, 0x47, 0x39, 0xf6, 0xf3, + 0xd6, 0x7f, 0x02, 0x00, 0x00, 0xff, 0xff, 0x58, 0x1f, 0x07, 0x5e, 0xc3, 0x2b, 0x00, 0x00, } diff --git a/pkg/replicate_mode/replicate_mode.pb.go b/pkg/replicate_mode/replicate_mode.pb.go deleted file mode 100644 index a3a352464..000000000 --- a/pkg/replicate_mode/replicate_mode.pb.go +++ /dev/null @@ -1,938 +0,0 @@ -// Code generated by protoc-gen-gogo. DO NOT EDIT. -// source: replicate_mode.proto - -package replicate_mode - -import ( - "fmt" - "io" - "math" - - proto "github.com/golang/protobuf/proto" -) - -// Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf - -// This is a compile-time assertion to ensure that this generated file -// is compatible with the proto package it is being compiled against. -// A compilation error at this line likely means your copy of the -// proto package needs to be updated. -const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package - -type ReplicateStatus_Mode int32 - -const ( - ReplicateStatus_MAJORITY ReplicateStatus_Mode = 0 - ReplicateStatus_DR_AUTOSYNC ReplicateStatus_Mode = 1 -) - -var ReplicateStatus_Mode_name = map[int32]string{ - 0: "MAJORITY", - 1: "DR_AUTOSYNC", -} -var ReplicateStatus_Mode_value = map[string]int32{ - "MAJORITY": 0, - "DR_AUTOSYNC": 1, -} - -func (x ReplicateStatus_Mode) String() string { - return proto.EnumName(ReplicateStatus_Mode_name, int32(x)) -} -func (ReplicateStatus_Mode) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_replicate_mode_42b7bc2451599399, []int{0, 0} -} - -type DRAutoSync_State int32 - -const ( - DRAutoSync_SYNC DRAutoSync_State = 0 - DRAutoSync_ASYNC DRAutoSync_State = 1 - DRAutoSync_SYNC_RECOVER DRAutoSync_State = 2 -) - -var DRAutoSync_State_name = map[int32]string{ - 0: "SYNC", - 1: "ASYNC", - 2: "SYNC_RECOVER", -} -var DRAutoSync_State_value = map[string]int32{ - "SYNC": 0, - "ASYNC": 1, - "SYNC_RECOVER": 2, -} - -func (x DRAutoSync_State) String() string { - return proto.EnumName(DRAutoSync_State_name, int32(x)) -} -func (DRAutoSync_State) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_replicate_mode_42b7bc2451599399, []int{1, 0} -} - -type RegionReplicateStatus_State int32 - -const ( - RegionReplicateStatus_MAJORITY RegionReplicateStatus_State = 0 - RegionReplicateStatus_INTEGRITY_OVER_LABEL RegionReplicateStatus_State = 1 -) - -var RegionReplicateStatus_State_name = map[int32]string{ - 0: "MAJORITY", - 1: "INTEGRITY_OVER_LABEL", -} -var RegionReplicateStatus_State_value = map[string]int32{ - "MAJORITY": 0, - "INTEGRITY_OVER_LABEL": 1, -} - -func (x RegionReplicateStatus_State) String() string { - return proto.EnumName(RegionReplicateStatus_State_name, int32(x)) -} -func (RegionReplicateStatus_State) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_replicate_mode_42b7bc2451599399, []int{2, 0} -} - -// The replicate status sync from PD to TiKV. -type ReplicateStatus struct { - Mode ReplicateStatus_Mode `protobuf:"varint,1,opt,name=mode,proto3,enum=replicate_mode.ReplicateStatus_Mode" json:"mode,omitempty"` - DrAutosync *DRAutoSync `protobuf:"bytes,2,opt,name=dr_autosync,json=drAutosync" json:"dr_autosync,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *ReplicateStatus) Reset() { *m = ReplicateStatus{} } -func (m *ReplicateStatus) String() string { return proto.CompactTextString(m) } -func (*ReplicateStatus) ProtoMessage() {} -func (*ReplicateStatus) Descriptor() ([]byte, []int) { - return fileDescriptor_replicate_mode_42b7bc2451599399, []int{0} -} -func (m *ReplicateStatus) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *ReplicateStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_ReplicateStatus.Marshal(b, m, deterministic) - } else { - b = b[:cap(b)] - n, err := m.MarshalTo(b) - if err != nil { - return nil, err - } - return b[:n], nil - } -} -func (dst *ReplicateStatus) XXX_Merge(src proto.Message) { - xxx_messageInfo_ReplicateStatus.Merge(dst, src) -} -func (m *ReplicateStatus) XXX_Size() int { - return m.Size() -} -func (m *ReplicateStatus) XXX_DiscardUnknown() { - xxx_messageInfo_ReplicateStatus.DiscardUnknown(m) -} - -var xxx_messageInfo_ReplicateStatus proto.InternalMessageInfo - -func (m *ReplicateStatus) GetMode() ReplicateStatus_Mode { - if m != nil { - return m.Mode - } - return ReplicateStatus_MAJORITY -} - -func (m *ReplicateStatus) GetDrAutosync() *DRAutoSync { - if m != nil { - return m.DrAutosync - } - return nil -} - -// The status of dr-autosync mode. -type DRAutoSync struct { - LabelKey string `protobuf:"bytes,1,opt,name=label_key,json=labelKey,proto3" json:"label_key,omitempty"` - State DRAutoSync_State `protobuf:"varint,2,opt,name=state,proto3,enum=replicate_mode.DRAutoSync_State" json:"state,omitempty"` - RecoverId uint64 `protobuf:"varint,3,opt,name=recover_id,json=recoverId,proto3" json:"recover_id,omitempty"` - WaitSyncTimeoutHint int32 `protobuf:"varint,4,opt,name=wait_sync_timeout_hint,json=waitSyncTimeoutHint,proto3" json:"wait_sync_timeout_hint,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *DRAutoSync) Reset() { *m = DRAutoSync{} } -func (m *DRAutoSync) String() string { return proto.CompactTextString(m) } -func (*DRAutoSync) ProtoMessage() {} -func (*DRAutoSync) Descriptor() ([]byte, []int) { - return fileDescriptor_replicate_mode_42b7bc2451599399, []int{1} -} -func (m *DRAutoSync) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *DRAutoSync) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_DRAutoSync.Marshal(b, m, deterministic) - } else { - b = b[:cap(b)] - n, err := m.MarshalTo(b) - if err != nil { - return nil, err - } - return b[:n], nil - } -} -func (dst *DRAutoSync) XXX_Merge(src proto.Message) { - xxx_messageInfo_DRAutoSync.Merge(dst, src) -} -func (m *DRAutoSync) XXX_Size() int { - return m.Size() -} -func (m *DRAutoSync) XXX_DiscardUnknown() { - xxx_messageInfo_DRAutoSync.DiscardUnknown(m) -} - -var xxx_messageInfo_DRAutoSync proto.InternalMessageInfo - -func (m *DRAutoSync) GetLabelKey() string { - if m != nil { - return m.LabelKey - } - return "" -} - -func (m *DRAutoSync) GetState() DRAutoSync_State { - if m != nil { - return m.State - } - return DRAutoSync_SYNC -} - -func (m *DRAutoSync) GetRecoverId() uint64 { - if m != nil { - return m.RecoverId - } - return 0 -} - -func (m *DRAutoSync) GetWaitSyncTimeoutHint() int32 { - if m != nil { - return m.WaitSyncTimeoutHint - } - return 0 -} - -// The replicate status sync from TiKV to PD. -type RegionReplicateStatus struct { - State RegionReplicateStatus_State `protobuf:"varint,1,opt,name=state,proto3,enum=replicate_mode.RegionReplicateStatus_State" json:"state,omitempty"` - RecoverId uint64 `protobuf:"varint,2,opt,name=recover_id,json=recoverId,proto3" json:"recover_id,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *RegionReplicateStatus) Reset() { *m = RegionReplicateStatus{} } -func (m *RegionReplicateStatus) String() string { return proto.CompactTextString(m) } -func (*RegionReplicateStatus) ProtoMessage() {} -func (*RegionReplicateStatus) Descriptor() ([]byte, []int) { - return fileDescriptor_replicate_mode_42b7bc2451599399, []int{2} -} -func (m *RegionReplicateStatus) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *RegionReplicateStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_RegionReplicateStatus.Marshal(b, m, deterministic) - } else { - b = b[:cap(b)] - n, err := m.MarshalTo(b) - if err != nil { - return nil, err - } - return b[:n], nil - } -} -func (dst *RegionReplicateStatus) XXX_Merge(src proto.Message) { - xxx_messageInfo_RegionReplicateStatus.Merge(dst, src) -} -func (m *RegionReplicateStatus) XXX_Size() int { - return m.Size() -} -func (m *RegionReplicateStatus) XXX_DiscardUnknown() { - xxx_messageInfo_RegionReplicateStatus.DiscardUnknown(m) -} - -var xxx_messageInfo_RegionReplicateStatus proto.InternalMessageInfo - -func (m *RegionReplicateStatus) GetState() RegionReplicateStatus_State { - if m != nil { - return m.State - } - return RegionReplicateStatus_MAJORITY -} - -func (m *RegionReplicateStatus) GetRecoverId() uint64 { - if m != nil { - return m.RecoverId - } - return 0 -} - -func init() { - proto.RegisterType((*ReplicateStatus)(nil), "replicate_mode.ReplicateStatus") - proto.RegisterType((*DRAutoSync)(nil), "replicate_mode.DRAutoSync") - proto.RegisterType((*RegionReplicateStatus)(nil), "replicate_mode.RegionReplicateStatus") - proto.RegisterEnum("replicate_mode.ReplicateStatus_Mode", ReplicateStatus_Mode_name, ReplicateStatus_Mode_value) - proto.RegisterEnum("replicate_mode.DRAutoSync_State", DRAutoSync_State_name, DRAutoSync_State_value) - proto.RegisterEnum("replicate_mode.RegionReplicateStatus_State", RegionReplicateStatus_State_name, RegionReplicateStatus_State_value) -} -func (m *ReplicateStatus) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) - if err != nil { - return nil, err - } - return dAtA[:n], nil -} - -func (m *ReplicateStatus) MarshalTo(dAtA []byte) (int, error) { - var i int - _ = i - var l int - _ = l - if m.Mode != 0 { - dAtA[i] = 0x8 - i++ - i = encodeVarintReplicateMode(dAtA, i, uint64(m.Mode)) - } - if m.DrAutosync != nil { - dAtA[i] = 0x12 - i++ - i = encodeVarintReplicateMode(dAtA, i, uint64(m.DrAutosync.Size())) - n1, err := m.DrAutosync.MarshalTo(dAtA[i:]) - if err != nil { - return 0, err - } - i += n1 - } - if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) - } - return i, nil -} - -func (m *DRAutoSync) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) - if err != nil { - return nil, err - } - return dAtA[:n], nil -} - -func (m *DRAutoSync) MarshalTo(dAtA []byte) (int, error) { - var i int - _ = i - var l int - _ = l - if len(m.LabelKey) > 0 { - dAtA[i] = 0xa - i++ - i = encodeVarintReplicateMode(dAtA, i, uint64(len(m.LabelKey))) - i += copy(dAtA[i:], m.LabelKey) - } - if m.State != 0 { - dAtA[i] = 0x10 - i++ - i = encodeVarintReplicateMode(dAtA, i, uint64(m.State)) - } - if m.RecoverId != 0 { - dAtA[i] = 0x18 - i++ - i = encodeVarintReplicateMode(dAtA, i, uint64(m.RecoverId)) - } - if m.WaitSyncTimeoutHint != 0 { - dAtA[i] = 0x20 - i++ - i = encodeVarintReplicateMode(dAtA, i, uint64(m.WaitSyncTimeoutHint)) - } - if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) - } - return i, nil -} - -func (m *RegionReplicateStatus) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalTo(dAtA) - if err != nil { - return nil, err - } - return dAtA[:n], nil -} - -func (m *RegionReplicateStatus) MarshalTo(dAtA []byte) (int, error) { - var i int - _ = i - var l int - _ = l - if m.State != 0 { - dAtA[i] = 0x8 - i++ - i = encodeVarintReplicateMode(dAtA, i, uint64(m.State)) - } - if m.RecoverId != 0 { - dAtA[i] = 0x10 - i++ - i = encodeVarintReplicateMode(dAtA, i, uint64(m.RecoverId)) - } - if m.XXX_unrecognized != nil { - i += copy(dAtA[i:], m.XXX_unrecognized) - } - return i, nil -} - -func encodeVarintReplicateMode(dAtA []byte, offset int, v uint64) int { - for v >= 1<<7 { - dAtA[offset] = uint8(v&0x7f | 0x80) - v >>= 7 - offset++ - } - dAtA[offset] = uint8(v) - return offset + 1 -} -func (m *ReplicateStatus) Size() (n int) { - var l int - _ = l - if m.Mode != 0 { - n += 1 + sovReplicateMode(uint64(m.Mode)) - } - if m.DrAutosync != nil { - l = m.DrAutosync.Size() - n += 1 + l + sovReplicateMode(uint64(l)) - } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) - } - return n -} - -func (m *DRAutoSync) Size() (n int) { - var l int - _ = l - l = len(m.LabelKey) - if l > 0 { - n += 1 + l + sovReplicateMode(uint64(l)) - } - if m.State != 0 { - n += 1 + sovReplicateMode(uint64(m.State)) - } - if m.RecoverId != 0 { - n += 1 + sovReplicateMode(uint64(m.RecoverId)) - } - if m.WaitSyncTimeoutHint != 0 { - n += 1 + sovReplicateMode(uint64(m.WaitSyncTimeoutHint)) - } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) - } - return n -} - -func (m *RegionReplicateStatus) Size() (n int) { - var l int - _ = l - if m.State != 0 { - n += 1 + sovReplicateMode(uint64(m.State)) - } - if m.RecoverId != 0 { - n += 1 + sovReplicateMode(uint64(m.RecoverId)) - } - if m.XXX_unrecognized != nil { - n += len(m.XXX_unrecognized) - } - return n -} - -func sovReplicateMode(x uint64) (n int) { - for { - n++ - x >>= 7 - if x == 0 { - break - } - } - return n -} -func sozReplicateMode(x uint64) (n int) { - return sovReplicateMode(uint64((x << 1) ^ uint64((int64(x) >> 63)))) -} -func (m *ReplicateStatus) 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 ErrIntOverflowReplicateMode - } - 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: ReplicateStatus: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: ReplicateStatus: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Mode", wireType) - } - m.Mode = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowReplicateMode - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.Mode |= (ReplicateStatus_Mode(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field DrAutosync", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowReplicateMode - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= (int(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthReplicateMode - } - postIndex := iNdEx + msglen - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.DrAutosync == nil { - m.DrAutosync = &DRAutoSync{} - } - if err := m.DrAutosync.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipReplicateMode(dAtA[iNdEx:]) - if err != nil { - return err - } - if skippy < 0 { - return ErrInvalidLengthReplicateMode - } - 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 *DRAutoSync) 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 ErrIntOverflowReplicateMode - } - 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: DRAutoSync: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: DRAutoSync: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field LabelKey", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowReplicateMode - } - 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 ErrInvalidLengthReplicateMode - } - postIndex := iNdEx + intStringLen - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.LabelKey = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) - } - m.State = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowReplicateMode - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.State |= (DRAutoSync_State(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - case 3: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field RecoverId", wireType) - } - m.RecoverId = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowReplicateMode - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.RecoverId |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - case 4: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field WaitSyncTimeoutHint", wireType) - } - m.WaitSyncTimeoutHint = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowReplicateMode - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.WaitSyncTimeoutHint |= (int32(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - default: - iNdEx = preIndex - skippy, err := skipReplicateMode(dAtA[iNdEx:]) - if err != nil { - return err - } - if skippy < 0 { - return ErrInvalidLengthReplicateMode - } - 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 *RegionReplicateStatus) 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 ErrIntOverflowReplicateMode - } - 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: RegionReplicateStatus: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: RegionReplicateStatus: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) - } - m.State = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowReplicateMode - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.State |= (RegionReplicateStatus_State(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field RecoverId", wireType) - } - m.RecoverId = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowReplicateMode - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.RecoverId |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - default: - iNdEx = preIndex - skippy, err := skipReplicateMode(dAtA[iNdEx:]) - if err != nil { - return err - } - if skippy < 0 { - return ErrInvalidLengthReplicateMode - } - 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 skipReplicateMode(dAtA []byte) (n int, err error) { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return 0, ErrIntOverflowReplicateMode - } - if iNdEx >= l { - return 0, io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - wireType := int(wire & 0x7) - switch wireType { - case 0: - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return 0, ErrIntOverflowReplicateMode - } - if iNdEx >= l { - return 0, io.ErrUnexpectedEOF - } - iNdEx++ - if dAtA[iNdEx-1] < 0x80 { - break - } - } - return iNdEx, nil - case 1: - iNdEx += 8 - return iNdEx, nil - case 2: - var length int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return 0, ErrIntOverflowReplicateMode - } - if iNdEx >= l { - return 0, io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - length |= (int(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - iNdEx += length - if length < 0 { - return 0, ErrInvalidLengthReplicateMode - } - return iNdEx, nil - case 3: - for { - var innerWire uint64 - var start int = iNdEx - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return 0, ErrIntOverflowReplicateMode - } - if iNdEx >= l { - return 0, io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - innerWire |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - innerWireType := int(innerWire & 0x7) - if innerWireType == 4 { - break - } - next, err := skipReplicateMode(dAtA[start:]) - if err != nil { - return 0, err - } - iNdEx = start + next - } - return iNdEx, nil - case 4: - return iNdEx, nil - case 5: - iNdEx += 4 - return iNdEx, nil - default: - return 0, fmt.Errorf("proto: illegal wireType %d", wireType) - } - } - panic("unreachable") -} - -var ( - ErrInvalidLengthReplicateMode = fmt.Errorf("proto: negative length found during unmarshaling") - ErrIntOverflowReplicateMode = fmt.Errorf("proto: integer overflow") -) - -func init() { - proto.RegisterFile("replicate_mode.proto", fileDescriptor_replicate_mode_42b7bc2451599399) -} - -var fileDescriptor_replicate_mode_42b7bc2451599399 = []byte{ - // 400 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x52, 0xdf, 0xea, 0xd3, 0x30, - 0x18, 0x5d, 0x66, 0x2b, 0xeb, 0xb7, 0xb1, 0x95, 0x38, 0xa5, 0x28, 0x96, 0x52, 0x14, 0x0a, 0x42, - 0x85, 0x0d, 0x44, 0xf0, 0xaa, 0xdb, 0x8a, 0x4e, 0xf7, 0x07, 0xb2, 0x2a, 0xec, 0x2a, 0x74, 0x6d, - 0xd0, 0xe2, 0xd6, 0x8c, 0x2e, 0x55, 0xfa, 0x26, 0x3e, 0x83, 0x37, 0xbe, 0x86, 0x97, 0x3e, 0x82, - 0x4c, 0x7c, 0x0f, 0x49, 0xbb, 0x21, 0xeb, 0xef, 0xcf, 0x5d, 0x72, 0xbe, 0xf3, 0x9d, 0x9c, 0xc3, - 0x09, 0xf4, 0x33, 0xb6, 0xdf, 0x26, 0x51, 0x28, 0x18, 0xdd, 0xf1, 0x98, 0xb9, 0xfb, 0x8c, 0x0b, - 0x8e, 0xbb, 0x97, 0xa8, 0xfd, 0x03, 0x41, 0x8f, 0x9c, 0xa1, 0x95, 0x08, 0x45, 0x7e, 0xc0, 0x2f, - 0x41, 0x91, 0x33, 0x03, 0x59, 0xc8, 0xe9, 0x0e, 0x9e, 0xb8, 0x35, 0xa1, 0x1a, 0xdd, 0x9d, 0xf3, - 0x98, 0x91, 0x72, 0x03, 0xbf, 0x82, 0x76, 0x9c, 0xd1, 0x30, 0x17, 0xfc, 0x50, 0xa4, 0x91, 0xd1, - 0xb4, 0x90, 0xd3, 0x1e, 0x3c, 0xac, 0x0b, 0x4c, 0x88, 0x97, 0x0b, 0xbe, 0x2a, 0xd2, 0x88, 0x40, - 0x9c, 0x79, 0x27, 0xb6, 0xfd, 0x14, 0x14, 0x29, 0x85, 0x3b, 0xd0, 0x9a, 0x7b, 0x6f, 0x97, 0x64, - 0x1a, 0xac, 0xf5, 0x06, 0xee, 0x41, 0x7b, 0x42, 0xa8, 0xf7, 0x3e, 0x58, 0xae, 0xd6, 0x8b, 0xb1, - 0x8e, 0xec, 0xbf, 0x08, 0xe0, 0xbf, 0x02, 0x7e, 0x04, 0xda, 0x36, 0xdc, 0xb0, 0x2d, 0xfd, 0xcc, - 0x8a, 0xd2, 0xb1, 0x46, 0x5a, 0x25, 0xf0, 0x8e, 0x15, 0xf8, 0x05, 0xa8, 0x07, 0x11, 0x0a, 0x56, - 0x3a, 0xe9, 0x0e, 0xac, 0x9b, 0x9d, 0xb8, 0x32, 0x0c, 0x23, 0x15, 0x1d, 0x3f, 0x06, 0xc8, 0x58, - 0xc4, 0xbf, 0xb0, 0x8c, 0x26, 0xb1, 0x71, 0xc7, 0x42, 0x8e, 0x42, 0xb4, 0x13, 0x32, 0x8d, 0xf1, - 0x10, 0x1e, 0x7c, 0x0d, 0x13, 0x41, 0xa5, 0x6d, 0x2a, 0x92, 0x1d, 0xe3, 0xb9, 0xa0, 0x9f, 0x92, - 0x54, 0x18, 0x8a, 0x85, 0x1c, 0x95, 0xdc, 0x93, 0x53, 0xa9, 0x1a, 0x54, 0xb3, 0x37, 0x49, 0x2a, - 0x6c, 0x17, 0xd4, 0xf2, 0x0d, 0xdc, 0x02, 0xa5, 0x8c, 0xd2, 0xc0, 0x1a, 0xa8, 0x5e, 0x95, 0x0a, - 0xeb, 0xd0, 0x91, 0x27, 0x4a, 0xfc, 0xf1, 0xf2, 0x83, 0x4f, 0xf4, 0xa6, 0xfd, 0x1d, 0xc1, 0x7d, - 0xc2, 0x3e, 0x26, 0x3c, 0xad, 0xf7, 0xe3, 0x9d, 0x53, 0x55, 0x05, 0x3d, 0xbb, 0x5a, 0xd0, 0x35, - 0x5b, 0xb7, 0x05, 0x6c, 0xd6, 0x02, 0xda, 0xcf, 0xcf, 0x5e, 0x2f, 0xbb, 0x30, 0xa0, 0x3f, 0x5d, - 0x04, 0xfe, 0x6b, 0x79, 0xa5, 0xd2, 0x26, 0x9d, 0x79, 0x23, 0x7f, 0xa6, 0xa3, 0x91, 0xfe, 0xf3, - 0x68, 0xa2, 0x5f, 0x47, 0x13, 0xfd, 0x3e, 0x9a, 0xe8, 0xdb, 0x1f, 0xb3, 0xb1, 0xb9, 0x5b, 0xfe, - 0xb7, 0xe1, 0xbf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x81, 0x59, 0x60, 0xdb, 0x87, 0x02, 0x00, 0x00, -} diff --git a/pkg/replication_modepb/replication_modepb.pb.go b/pkg/replication_modepb/replication_modepb.pb.go new file mode 100644 index 000000000..36dcf0769 --- /dev/null +++ b/pkg/replication_modepb/replication_modepb.pb.go @@ -0,0 +1,955 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: replication_modepb.proto + +package replication_modepb + +import ( + "fmt" + "io" + "math" + + proto "github.com/golang/protobuf/proto" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package + +type ReplicationMode int32 + +const ( + // The standard mode. Replicate logs to majority peer. + ReplicationMode_MAJORITY ReplicationMode = 0 + // DR mode. Replicate logs among 2 DCs. + ReplicationMode_DR_AUTO_SYNC ReplicationMode = 1 +) + +var ReplicationMode_name = map[int32]string{ + 0: "MAJORITY", + 1: "DR_AUTO_SYNC", +} +var ReplicationMode_value = map[string]int32{ + "MAJORITY": 0, + "DR_AUTO_SYNC": 1, +} + +func (x ReplicationMode) String() string { + return proto.EnumName(ReplicationMode_name, int32(x)) +} +func (ReplicationMode) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_replication_modepb_5de8f3cc9358480b, []int{0} +} + +type DRAutoSyncState int32 + +const ( + // Raft logs need to sync between different DCs + DRAutoSyncState_SYNC DRAutoSyncState = 0 + // Raft logs need to sync to majority peers + DRAutoSyncState_ASYNC DRAutoSyncState = 1 + // Switching from ASYNC to SYNC mode + DRAutoSyncState_SYNC_RECOVER DRAutoSyncState = 2 +) + +var DRAutoSyncState_name = map[int32]string{ + 0: "SYNC", + 1: "ASYNC", + 2: "SYNC_RECOVER", +} +var DRAutoSyncState_value = map[string]int32{ + "SYNC": 0, + "ASYNC": 1, + "SYNC_RECOVER": 2, +} + +func (x DRAutoSyncState) String() string { + return proto.EnumName(DRAutoSyncState_name, int32(x)) +} +func (DRAutoSyncState) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_replication_modepb_5de8f3cc9358480b, []int{1} +} + +type RegionReplicationState int32 + +const ( + // The region's state is unknown + RegionReplicationState_UNKNOWN RegionReplicationState = 0 + // Logs sync to majority peers + RegionReplicationState_SIMPLE_MAJORITY RegionReplicationState = 1 + // Logs sync to different DCs + RegionReplicationState_INTEGRITY_OVER_LABEL RegionReplicationState = 2 +) + +var RegionReplicationState_name = map[int32]string{ + 0: "UNKNOWN", + 1: "SIMPLE_MAJORITY", + 2: "INTEGRITY_OVER_LABEL", +} +var RegionReplicationState_value = map[string]int32{ + "UNKNOWN": 0, + "SIMPLE_MAJORITY": 1, + "INTEGRITY_OVER_LABEL": 2, +} + +func (x RegionReplicationState) String() string { + return proto.EnumName(RegionReplicationState_name, int32(x)) +} +func (RegionReplicationState) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_replication_modepb_5de8f3cc9358480b, []int{2} +} + +// The replication status sync from PD to TiKV. +type ReplicationStatus struct { + Mode ReplicationMode `protobuf:"varint,1,opt,name=mode,proto3,enum=replication_modepb.ReplicationMode" json:"mode,omitempty"` + DrAutoSync *DRAutoSync `protobuf:"bytes,2,opt,name=dr_auto_sync,json=drAutoSync" json:"dr_auto_sync,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ReplicationStatus) Reset() { *m = ReplicationStatus{} } +func (m *ReplicationStatus) String() string { return proto.CompactTextString(m) } +func (*ReplicationStatus) ProtoMessage() {} +func (*ReplicationStatus) Descriptor() ([]byte, []int) { + return fileDescriptor_replication_modepb_5de8f3cc9358480b, []int{0} +} +func (m *ReplicationStatus) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ReplicationStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ReplicationStatus.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalTo(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (dst *ReplicationStatus) XXX_Merge(src proto.Message) { + xxx_messageInfo_ReplicationStatus.Merge(dst, src) +} +func (m *ReplicationStatus) XXX_Size() int { + return m.Size() +} +func (m *ReplicationStatus) XXX_DiscardUnknown() { + xxx_messageInfo_ReplicationStatus.DiscardUnknown(m) +} + +var xxx_messageInfo_ReplicationStatus proto.InternalMessageInfo + +func (m *ReplicationStatus) GetMode() ReplicationMode { + if m != nil { + return m.Mode + } + return ReplicationMode_MAJORITY +} + +func (m *ReplicationStatus) GetDrAutoSync() *DRAutoSync { + if m != nil { + return m.DrAutoSync + } + return nil +} + +// The status of dr-autosync mode. +type DRAutoSync struct { + // The key of the label that used for distinguish different DC. + LabelKey string `protobuf:"bytes,1,opt,name=label_key,json=labelKey,proto3" json:"label_key,omitempty"` + State DRAutoSyncState `protobuf:"varint,2,opt,name=state,proto3,enum=replication_modepb.DRAutoSyncState" json:"state,omitempty"` + // Unique ID of the state, it increases after each state transfer. + StateId uint64 `protobuf:"varint,3,opt,name=state_id,json=stateId,proto3" json:"state_id,omitempty"` + // Duration to wait before switching to SYNC by force (in seconds) + WaitSyncTimeoutHint int32 `protobuf:"varint,4,opt,name=wait_sync_timeout_hint,json=waitSyncTimeoutHint,proto3" json:"wait_sync_timeout_hint,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *DRAutoSync) Reset() { *m = DRAutoSync{} } +func (m *DRAutoSync) String() string { return proto.CompactTextString(m) } +func (*DRAutoSync) ProtoMessage() {} +func (*DRAutoSync) Descriptor() ([]byte, []int) { + return fileDescriptor_replication_modepb_5de8f3cc9358480b, []int{1} +} +func (m *DRAutoSync) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *DRAutoSync) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_DRAutoSync.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalTo(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (dst *DRAutoSync) XXX_Merge(src proto.Message) { + xxx_messageInfo_DRAutoSync.Merge(dst, src) +} +func (m *DRAutoSync) XXX_Size() int { + return m.Size() +} +func (m *DRAutoSync) XXX_DiscardUnknown() { + xxx_messageInfo_DRAutoSync.DiscardUnknown(m) +} + +var xxx_messageInfo_DRAutoSync proto.InternalMessageInfo + +func (m *DRAutoSync) GetLabelKey() string { + if m != nil { + return m.LabelKey + } + return "" +} + +func (m *DRAutoSync) GetState() DRAutoSyncState { + if m != nil { + return m.State + } + return DRAutoSyncState_SYNC +} + +func (m *DRAutoSync) GetStateId() uint64 { + if m != nil { + return m.StateId + } + return 0 +} + +func (m *DRAutoSync) GetWaitSyncTimeoutHint() int32 { + if m != nil { + return m.WaitSyncTimeoutHint + } + return 0 +} + +// The replication status sync from TiKV to PD. +type RegionReplicationStatus struct { + State RegionReplicationState `protobuf:"varint,1,opt,name=state,proto3,enum=replication_modepb.RegionReplicationState" json:"state,omitempty"` + // Unique ID of the state, it increases after each state transfer. + StateId uint64 `protobuf:"varint,2,opt,name=state_id,json=stateId,proto3" json:"state_id,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RegionReplicationStatus) Reset() { *m = RegionReplicationStatus{} } +func (m *RegionReplicationStatus) String() string { return proto.CompactTextString(m) } +func (*RegionReplicationStatus) ProtoMessage() {} +func (*RegionReplicationStatus) Descriptor() ([]byte, []int) { + return fileDescriptor_replication_modepb_5de8f3cc9358480b, []int{2} +} +func (m *RegionReplicationStatus) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RegionReplicationStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RegionReplicationStatus.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalTo(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (dst *RegionReplicationStatus) XXX_Merge(src proto.Message) { + xxx_messageInfo_RegionReplicationStatus.Merge(dst, src) +} +func (m *RegionReplicationStatus) XXX_Size() int { + return m.Size() +} +func (m *RegionReplicationStatus) XXX_DiscardUnknown() { + xxx_messageInfo_RegionReplicationStatus.DiscardUnknown(m) +} + +var xxx_messageInfo_RegionReplicationStatus proto.InternalMessageInfo + +func (m *RegionReplicationStatus) GetState() RegionReplicationState { + if m != nil { + return m.State + } + return RegionReplicationState_UNKNOWN +} + +func (m *RegionReplicationStatus) GetStateId() uint64 { + if m != nil { + return m.StateId + } + return 0 +} + +func init() { + proto.RegisterType((*ReplicationStatus)(nil), "replication_modepb.ReplicationStatus") + proto.RegisterType((*DRAutoSync)(nil), "replication_modepb.DRAutoSync") + proto.RegisterType((*RegionReplicationStatus)(nil), "replication_modepb.RegionReplicationStatus") + proto.RegisterEnum("replication_modepb.ReplicationMode", ReplicationMode_name, ReplicationMode_value) + proto.RegisterEnum("replication_modepb.DRAutoSyncState", DRAutoSyncState_name, DRAutoSyncState_value) + proto.RegisterEnum("replication_modepb.RegionReplicationState", RegionReplicationState_name, RegionReplicationState_value) +} +func (m *ReplicationStatus) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ReplicationStatus) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Mode != 0 { + dAtA[i] = 0x8 + i++ + i = encodeVarintReplicationModepb(dAtA, i, uint64(m.Mode)) + } + if m.DrAutoSync != nil { + dAtA[i] = 0x12 + i++ + i = encodeVarintReplicationModepb(dAtA, i, uint64(m.DrAutoSync.Size())) + n1, err := m.DrAutoSync.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n1 + } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *DRAutoSync) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *DRAutoSync) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.LabelKey) > 0 { + dAtA[i] = 0xa + i++ + i = encodeVarintReplicationModepb(dAtA, i, uint64(len(m.LabelKey))) + i += copy(dAtA[i:], m.LabelKey) + } + if m.State != 0 { + dAtA[i] = 0x10 + i++ + i = encodeVarintReplicationModepb(dAtA, i, uint64(m.State)) + } + if m.StateId != 0 { + dAtA[i] = 0x18 + i++ + i = encodeVarintReplicationModepb(dAtA, i, uint64(m.StateId)) + } + if m.WaitSyncTimeoutHint != 0 { + dAtA[i] = 0x20 + i++ + i = encodeVarintReplicationModepb(dAtA, i, uint64(m.WaitSyncTimeoutHint)) + } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *RegionReplicationStatus) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *RegionReplicationStatus) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.State != 0 { + dAtA[i] = 0x8 + i++ + i = encodeVarintReplicationModepb(dAtA, i, uint64(m.State)) + } + if m.StateId != 0 { + dAtA[i] = 0x10 + i++ + i = encodeVarintReplicationModepb(dAtA, i, uint64(m.StateId)) + } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } + return i, nil +} + +func encodeVarintReplicationModepb(dAtA []byte, offset int, v uint64) int { + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return offset + 1 +} +func (m *ReplicationStatus) Size() (n int) { + var l int + _ = l + if m.Mode != 0 { + n += 1 + sovReplicationModepb(uint64(m.Mode)) + } + if m.DrAutoSync != nil { + l = m.DrAutoSync.Size() + n += 1 + l + sovReplicationModepb(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *DRAutoSync) Size() (n int) { + var l int + _ = l + l = len(m.LabelKey) + if l > 0 { + n += 1 + l + sovReplicationModepb(uint64(l)) + } + if m.State != 0 { + n += 1 + sovReplicationModepb(uint64(m.State)) + } + if m.StateId != 0 { + n += 1 + sovReplicationModepb(uint64(m.StateId)) + } + if m.WaitSyncTimeoutHint != 0 { + n += 1 + sovReplicationModepb(uint64(m.WaitSyncTimeoutHint)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *RegionReplicationStatus) Size() (n int) { + var l int + _ = l + if m.State != 0 { + n += 1 + sovReplicationModepb(uint64(m.State)) + } + if m.StateId != 0 { + n += 1 + sovReplicationModepb(uint64(m.StateId)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func sovReplicationModepb(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozReplicationModepb(x uint64) (n int) { + return sovReplicationModepb(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *ReplicationStatus) 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 ErrIntOverflowReplicationModepb + } + 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: ReplicationStatus: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ReplicationStatus: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Mode", wireType) + } + m.Mode = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowReplicationModepb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Mode |= (ReplicationMode(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DrAutoSync", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowReplicationModepb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthReplicationModepb + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.DrAutoSync == nil { + m.DrAutoSync = &DRAutoSync{} + } + if err := m.DrAutoSync.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipReplicationModepb(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthReplicationModepb + } + 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 *DRAutoSync) 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 ErrIntOverflowReplicationModepb + } + 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: DRAutoSync: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DRAutoSync: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LabelKey", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowReplicationModepb + } + 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 ErrInvalidLengthReplicationModepb + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.LabelKey = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) + } + m.State = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowReplicationModepb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.State |= (DRAutoSyncState(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field StateId", wireType) + } + m.StateId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowReplicationModepb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.StateId |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field WaitSyncTimeoutHint", wireType) + } + m.WaitSyncTimeoutHint = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowReplicationModepb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.WaitSyncTimeoutHint |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipReplicationModepb(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthReplicationModepb + } + 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 *RegionReplicationStatus) 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 ErrIntOverflowReplicationModepb + } + 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: RegionReplicationStatus: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RegionReplicationStatus: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) + } + m.State = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowReplicationModepb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.State |= (RegionReplicationState(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field StateId", wireType) + } + m.StateId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowReplicationModepb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.StateId |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipReplicationModepb(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthReplicationModepb + } + 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 skipReplicationModepb(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowReplicationModepb + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowReplicationModepb + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowReplicationModepb + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthReplicationModepb + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowReplicationModepb + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipReplicationModepb(dAtA[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthReplicationModepb = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowReplicationModepb = fmt.Errorf("proto: integer overflow") +) + +func init() { + proto.RegisterFile("replication_modepb.proto", fileDescriptor_replication_modepb_5de8f3cc9358480b) +} + +var fileDescriptor_replication_modepb_5de8f3cc9358480b = []byte{ + // 421 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x52, 0xd1, 0x6e, 0xd3, 0x30, + 0x14, 0xad, 0x4b, 0xca, 0xd2, 0xbb, 0x8a, 0x06, 0x0f, 0x8d, 0x20, 0xa4, 0x28, 0x2a, 0x2f, 0x51, + 0x1e, 0x26, 0xb1, 0x3d, 0x00, 0x6f, 0xcb, 0xb6, 0x08, 0xc2, 0xda, 0x04, 0x39, 0x19, 0x68, 0x4f, + 0x56, 0xda, 0x58, 0x60, 0xd1, 0xc5, 0x55, 0xea, 0x80, 0xf2, 0x13, 0x3c, 0xf3, 0x21, 0x7c, 0x04, + 0x8f, 0x7c, 0x02, 0x2a, 0x3f, 0x82, 0xec, 0x68, 0x14, 0xb6, 0xf0, 0x76, 0xef, 0x3d, 0x3e, 0xc7, + 0xe7, 0x1e, 0x1b, 0xec, 0x8a, 0xad, 0x96, 0x7c, 0x91, 0x4b, 0x2e, 0x4a, 0x7a, 0x25, 0x0a, 0xb6, + 0x9a, 0x1f, 0xac, 0x2a, 0x21, 0x05, 0xc6, 0xb7, 0x91, 0xc9, 0x17, 0x04, 0xf7, 0xc9, 0x76, 0x9c, + 0xca, 0x5c, 0xd6, 0x6b, 0xfc, 0x0c, 0x0c, 0x85, 0xdb, 0xc8, 0x45, 0xde, 0xbd, 0xc3, 0x27, 0x07, + 0x1d, 0x92, 0x7f, 0x91, 0x66, 0xa2, 0x60, 0x44, 0x13, 0xf0, 0x31, 0x8c, 0x8a, 0x8a, 0xe6, 0xb5, + 0x14, 0x74, 0xdd, 0x94, 0x0b, 0xbb, 0xef, 0x22, 0x6f, 0xf7, 0xd0, 0xe9, 0x12, 0x38, 0x23, 0x41, + 0x2d, 0x45, 0xda, 0x94, 0x0b, 0x02, 0x45, 0x75, 0x5d, 0x4f, 0xbe, 0x21, 0x80, 0x2d, 0x84, 0x1f, + 0xc3, 0x70, 0x99, 0xcf, 0xd9, 0x92, 0x7e, 0x64, 0x8d, 0xb6, 0x33, 0x24, 0xa6, 0x1e, 0x9c, 0xb3, + 0x06, 0xbf, 0x80, 0xc1, 0x5a, 0xe6, 0x92, 0xe9, 0x6b, 0xfe, 0xe3, 0x73, 0xab, 0xa5, 0x76, 0x63, + 0xa4, 0x65, 0xe0, 0x47, 0x60, 0xea, 0x82, 0xf2, 0xc2, 0xbe, 0xe3, 0x22, 0xcf, 0x20, 0x3b, 0xba, + 0x8f, 0x0a, 0x7c, 0x04, 0xfb, 0x9f, 0x73, 0x2e, 0xf5, 0x02, 0x54, 0xf2, 0x2b, 0x26, 0x6a, 0x49, + 0x3f, 0xf0, 0x52, 0xda, 0x86, 0x8b, 0xbc, 0x01, 0xd9, 0x53, 0xa8, 0x12, 0xcc, 0x5a, 0xec, 0x15, + 0x2f, 0xe5, 0xe4, 0x13, 0x3c, 0x24, 0xec, 0x3d, 0x17, 0xe5, 0xed, 0x30, 0x8f, 0xaf, 0x5d, 0xb6, + 0x69, 0xfa, 0xdd, 0x69, 0x76, 0x70, 0x3b, 0xcd, 0xf6, 0xff, 0x31, 0xeb, 0x3f, 0x85, 0xf1, 0x8d, + 0x97, 0xc0, 0x23, 0x30, 0x67, 0xc1, 0xeb, 0x84, 0x44, 0xd9, 0xa5, 0xd5, 0xc3, 0x16, 0x8c, 0xce, + 0x08, 0x0d, 0x2e, 0xb2, 0x84, 0xa6, 0x97, 0xf1, 0xa9, 0x85, 0xfc, 0xe7, 0x30, 0xbe, 0x11, 0x0a, + 0x36, 0xc1, 0xd0, 0x60, 0x0f, 0x0f, 0x61, 0x10, 0xb4, 0xe7, 0x14, 0x53, 0x55, 0x94, 0x84, 0xa7, + 0xc9, 0xdb, 0x90, 0x58, 0x7d, 0x3f, 0x83, 0xfd, 0x6e, 0xa3, 0x78, 0x17, 0x76, 0x2e, 0xe2, 0xf3, + 0x38, 0x79, 0x17, 0x5b, 0x3d, 0xbc, 0x07, 0xe3, 0x34, 0x9a, 0xbd, 0x99, 0x86, 0xf4, 0x8f, 0x0f, + 0x84, 0x6d, 0x78, 0x10, 0xc5, 0x59, 0xf8, 0x52, 0xb5, 0x54, 0xe9, 0xd1, 0x69, 0x70, 0x12, 0x4e, + 0xad, 0xfe, 0x89, 0xf5, 0x7d, 0xe3, 0xa0, 0x1f, 0x1b, 0x07, 0xfd, 0xdc, 0x38, 0xe8, 0xeb, 0x2f, + 0xa7, 0x37, 0xbf, 0xab, 0xff, 0xeb, 0xd1, 0xef, 0x00, 0x00, 0x00, 0xff, 0xff, 0xaa, 0x43, 0xe2, + 0xbf, 0xcb, 0x02, 0x00, 0x00, +} diff --git a/pkg/tikvpb/tikvpb.pb.go b/pkg/tikvpb/tikvpb.pb.go index 127c9bd69..9497c44bc 100644 --- a/pkg/tikvpb/tikvpb.pb.go +++ b/pkg/tikvpb/tikvpb.pb.go @@ -46,7 +46,7 @@ func (m *BatchCommandsRequest) Reset() { *m = BatchCommandsRequest{} } func (m *BatchCommandsRequest) String() string { return proto.CompactTextString(m) } func (*BatchCommandsRequest) ProtoMessage() {} func (*BatchCommandsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_tikvpb_c29457cf83ba741e, []int{0} + return fileDescriptor_tikvpb_90bf9910f92409ea, []int{0} } func (m *BatchCommandsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -128,7 +128,7 @@ func (m *BatchCommandsRequest_Request) Reset() { *m = BatchCommandsReque func (m *BatchCommandsRequest_Request) String() string { return proto.CompactTextString(m) } func (*BatchCommandsRequest_Request) ProtoMessage() {} func (*BatchCommandsRequest_Request) Descriptor() ([]byte, []int) { - return fileDescriptor_tikvpb_c29457cf83ba741e, []int{0, 0} + return fileDescriptor_tikvpb_90bf9910f92409ea, []int{0, 0} } func (m *BatchCommandsRequest_Request) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1032,7 +1032,7 @@ func (m *BatchCommandsResponse) Reset() { *m = BatchCommandsResponse{} } func (m *BatchCommandsResponse) String() string { return proto.CompactTextString(m) } func (*BatchCommandsResponse) ProtoMessage() {} func (*BatchCommandsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_tikvpb_c29457cf83ba741e, []int{1} + return fileDescriptor_tikvpb_90bf9910f92409ea, []int{1} } func (m *BatchCommandsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1121,7 +1121,7 @@ func (m *BatchCommandsResponse_Response) Reset() { *m = BatchCommandsRes func (m *BatchCommandsResponse_Response) String() string { return proto.CompactTextString(m) } func (*BatchCommandsResponse_Response) ProtoMessage() {} func (*BatchCommandsResponse_Response) Descriptor() ([]byte, []int) { - return fileDescriptor_tikvpb_c29457cf83ba741e, []int{1, 0} + return fileDescriptor_tikvpb_90bf9910f92409ea, []int{1, 0} } func (m *BatchCommandsResponse_Response) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2022,7 +2022,7 @@ func (m *BatchRaftMessage) Reset() { *m = BatchRaftMessage{} } func (m *BatchRaftMessage) String() string { return proto.CompactTextString(m) } func (*BatchRaftMessage) ProtoMessage() {} func (*BatchRaftMessage) Descriptor() ([]byte, []int) { - return fileDescriptor_tikvpb_c29457cf83ba741e, []int{2} + return fileDescriptor_tikvpb_90bf9910f92409ea, []int{2} } func (m *BatchRaftMessage) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2072,7 +2072,7 @@ func (m *BatchCommandsEmptyRequest) Reset() { *m = BatchCommandsEmptyReq func (m *BatchCommandsEmptyRequest) String() string { return proto.CompactTextString(m) } func (*BatchCommandsEmptyRequest) ProtoMessage() {} func (*BatchCommandsEmptyRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_tikvpb_c29457cf83ba741e, []int{3} + return fileDescriptor_tikvpb_90bf9910f92409ea, []int{3} } func (m *BatchCommandsEmptyRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2127,7 +2127,7 @@ func (m *BatchCommandsEmptyResponse) Reset() { *m = BatchCommandsEmptyRe func (m *BatchCommandsEmptyResponse) String() string { return proto.CompactTextString(m) } func (*BatchCommandsEmptyResponse) ProtoMessage() {} func (*BatchCommandsEmptyResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_tikvpb_c29457cf83ba741e, []int{4} + return fileDescriptor_tikvpb_90bf9910f92409ea, []int{4} } func (m *BatchCommandsEmptyResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2220,6 +2220,7 @@ type TikvClient interface { // SQL push down commands. Coprocessor(ctx context.Context, in *coprocessor.Request, opts ...grpc.CallOption) (*coprocessor.Response, error) CoprocessorStream(ctx context.Context, in *coprocessor.Request, opts ...grpc.CallOption) (Tikv_CoprocessorStreamClient, error) + BatchCoprocessor(ctx context.Context, in *coprocessor.BatchRequest, opts ...grpc.CallOption) (Tikv_BatchCoprocessorClient, error) // Raft commands (tikv <-> tikv). Raft(ctx context.Context, opts ...grpc.CallOption) (Tikv_RaftClient, error) BatchRaft(ctx context.Context, opts ...grpc.CallOption) (Tikv_BatchRaftClient, error) @@ -2552,8 +2553,40 @@ func (x *tikvCoprocessorStreamClient) Recv() (*coprocessor.Response, error) { return m, nil } +func (c *tikvClient) BatchCoprocessor(ctx context.Context, in *coprocessor.BatchRequest, opts ...grpc.CallOption) (Tikv_BatchCoprocessorClient, error) { + stream, err := c.cc.NewStream(ctx, &_Tikv_serviceDesc.Streams[1], "/tikvpb.Tikv/BatchCoprocessor", opts...) + if err != nil { + return nil, err + } + x := &tikvBatchCoprocessorClient{stream} + if err := x.ClientStream.SendMsg(in); err != nil { + return nil, err + } + if err := x.ClientStream.CloseSend(); err != nil { + return nil, err + } + return x, nil +} + +type Tikv_BatchCoprocessorClient interface { + Recv() (*coprocessor.BatchResponse, error) + grpc.ClientStream +} + +type tikvBatchCoprocessorClient struct { + grpc.ClientStream +} + +func (x *tikvBatchCoprocessorClient) Recv() (*coprocessor.BatchResponse, error) { + m := new(coprocessor.BatchResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + func (c *tikvClient) Raft(ctx context.Context, opts ...grpc.CallOption) (Tikv_RaftClient, error) { - stream, err := c.cc.NewStream(ctx, &_Tikv_serviceDesc.Streams[1], "/tikvpb.Tikv/Raft", opts...) + stream, err := c.cc.NewStream(ctx, &_Tikv_serviceDesc.Streams[2], "/tikvpb.Tikv/Raft", opts...) if err != nil { return nil, err } @@ -2587,7 +2620,7 @@ func (x *tikvRaftClient) CloseAndRecv() (*raft_serverpb.Done, error) { } func (c *tikvClient) BatchRaft(ctx context.Context, opts ...grpc.CallOption) (Tikv_BatchRaftClient, error) { - stream, err := c.cc.NewStream(ctx, &_Tikv_serviceDesc.Streams[2], "/tikvpb.Tikv/BatchRaft", opts...) + stream, err := c.cc.NewStream(ctx, &_Tikv_serviceDesc.Streams[3], "/tikvpb.Tikv/BatchRaft", opts...) if err != nil { return nil, err } @@ -2621,7 +2654,7 @@ func (x *tikvBatchRaftClient) CloseAndRecv() (*raft_serverpb.Done, error) { } func (c *tikvClient) Snapshot(ctx context.Context, opts ...grpc.CallOption) (Tikv_SnapshotClient, error) { - stream, err := c.cc.NewStream(ctx, &_Tikv_serviceDesc.Streams[3], "/tikvpb.Tikv/Snapshot", opts...) + stream, err := c.cc.NewStream(ctx, &_Tikv_serviceDesc.Streams[4], "/tikvpb.Tikv/Snapshot", opts...) if err != nil { return nil, err } @@ -2691,7 +2724,7 @@ func (c *tikvClient) MvccGetByStartTs(ctx context.Context, in *kvrpcpb.MvccGetBy } func (c *tikvClient) BatchCommands(ctx context.Context, opts ...grpc.CallOption) (Tikv_BatchCommandsClient, error) { - stream, err := c.cc.NewStream(ctx, &_Tikv_serviceDesc.Streams[4], "/tikvpb.Tikv/BatchCommands", opts...) + stream, err := c.cc.NewStream(ctx, &_Tikv_serviceDesc.Streams[5], "/tikvpb.Tikv/BatchCommands", opts...) if err != nil { return nil, err } @@ -2760,6 +2793,7 @@ type TikvServer interface { // SQL push down commands. Coprocessor(context.Context, *coprocessor.Request) (*coprocessor.Response, error) CoprocessorStream(*coprocessor.Request, Tikv_CoprocessorStreamServer) error + BatchCoprocessor(*coprocessor.BatchRequest, Tikv_BatchCoprocessorServer) error // Raft commands (tikv <-> tikv). Raft(Tikv_RaftServer) error BatchRaft(Tikv_BatchRaftServer) error @@ -3356,6 +3390,27 @@ func (x *tikvCoprocessorStreamServer) Send(m *coprocessor.Response) error { return x.ServerStream.SendMsg(m) } +func _Tikv_BatchCoprocessor_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(coprocessor.BatchRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(TikvServer).BatchCoprocessor(m, &tikvBatchCoprocessorServer{stream}) +} + +type Tikv_BatchCoprocessorServer interface { + Send(*coprocessor.BatchResponse) error + grpc.ServerStream +} + +type tikvBatchCoprocessorServer struct { + grpc.ServerStream +} + +func (x *tikvBatchCoprocessorServer) Send(m *coprocessor.BatchResponse) error { + return x.ServerStream.SendMsg(m) +} + func _Tikv_Raft_Handler(srv interface{}, stream grpc.ServerStream) error { return srv.(TikvServer).Raft(&tikvRaftServer{stream}) } @@ -3683,6 +3738,11 @@ var _Tikv_serviceDesc = grpc.ServiceDesc{ Handler: _Tikv_CoprocessorStream_Handler, ServerStreams: true, }, + { + StreamName: "BatchCoprocessor", + Handler: _Tikv_BatchCoprocessor_Handler, + ServerStreams: true, + }, { StreamName: "Raft", Handler: _Tikv_Raft_Handler, @@ -7867,123 +7927,124 @@ var ( ErrIntOverflowTikvpb = fmt.Errorf("proto: integer overflow") ) -func init() { proto.RegisterFile("tikvpb.proto", fileDescriptor_tikvpb_c29457cf83ba741e) } - -var fileDescriptor_tikvpb_c29457cf83ba741e = []byte{ - // 1834 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x99, 0x5d, 0x72, 0xdb, 0xb6, - 0x16, 0xc7, 0x29, 0x5b, 0xfe, 0x82, 0xbf, 0x61, 0x3b, 0xa2, 0x71, 0xfd, 0x15, 0xc6, 0xc9, 0xf5, - 0xdc, 0x3b, 0xa3, 0x6b, 0x27, 0xb9, 0x75, 0x93, 0xb4, 0xa9, 0x6b, 0x39, 0x75, 0x1c, 0x39, 0x13, - 0x0f, 0xe5, 0xb4, 0xe9, 0x4c, 0x67, 0x3c, 0xb4, 0x84, 0xc8, 0x1a, 0x7d, 0x50, 0x25, 0x29, 0x3a, - 0x5e, 0x42, 0x77, 0xd0, 0x25, 0x74, 0x11, 0x5d, 0x40, 0x1f, 0xfb, 0xd4, 0xe9, 0x63, 0x27, 0x7d, - 0xea, 0x43, 0xd7, 0xd0, 0x0e, 0x40, 0x12, 0x04, 0x40, 0x80, 0x4a, 0x9f, 0xc2, 0x9c, 0x73, 0xfe, - 0xe7, 0x00, 0x20, 0x88, 0xdf, 0x11, 0x0c, 0x66, 0x82, 0x56, 0x3b, 0xec, 0x5f, 0x96, 0xfb, 0x9e, - 0x1b, 0xb8, 0x70, 0x3c, 0xfa, 0x1f, 0x5a, 0xac, 0xbb, 0x7d, 0xcf, 0xad, 0x63, 0xdf, 0x77, 0xbd, - 0xc8, 0x85, 0x66, 0xdb, 0xa1, 0xd7, 0xaf, 0x27, 0x91, 0x68, 0xc9, 0x73, 0xde, 0x06, 0x17, 0x3e, - 0xf6, 0x42, 0xec, 0x31, 0xe3, 0x72, 0xd3, 0x6d, 0xba, 0xf4, 0xf1, 0x7f, 0xe4, 0x29, 0xb6, 0xce, - 0x7b, 0x03, 0x3f, 0xa0, 0x8f, 0x91, 0xc1, 0xfa, 0x63, 0x16, 0x2c, 0x1f, 0x3a, 0x41, 0xfd, 0xaa, - 0xe2, 0x76, 0xbb, 0x4e, 0xaf, 0xe1, 0xdb, 0xf8, 0xdb, 0x01, 0xf6, 0x03, 0x78, 0x00, 0x26, 0xbd, - 0xe8, 0xd1, 0x37, 0x0b, 0x5b, 0xa3, 0x3b, 0xd3, 0xf7, 0xb7, 0xcb, 0xf1, 0xf8, 0x54, 0xf1, 0xe5, - 0xf8, 0x5f, 0x9b, 0xa9, 0xe0, 0x26, 0x98, 0x8e, 0x9f, 0x2f, 0x5a, 0x0d, 0xdf, 0x1c, 0xd9, 0x1a, - 0xdd, 0x29, 0xda, 0x20, 0x36, 0x9d, 0x34, 0x7c, 0xf4, 0xe7, 0x0c, 0x98, 0x48, 0xca, 0xfd, 0x1b, - 0x8c, 0x1e, 0xe3, 0xc0, 0x2c, 0x6c, 0x15, 0x76, 0xa6, 0xef, 0x2f, 0x95, 0x93, 0x09, 0x1e, 0xe3, - 0x20, 0x8e, 0x78, 0x6e, 0xd8, 0x24, 0x02, 0xfe, 0x07, 0x14, 0x6b, 0x75, 0xa7, 0x67, 0x8e, 0xd0, - 0xc8, 0x65, 0x16, 0x49, 0x8c, 0x69, 0x28, 0x8d, 0x81, 0x1f, 0x81, 0xc9, 0x33, 0x0f, 0x5f, 0x7b, - 0xad, 0x00, 0x9b, 0xa3, 0x34, 0xde, 0x64, 0xf1, 0x89, 0x23, 0xd5, 0xb0, 0x58, 0xb8, 0x0b, 0xc6, - 0xc9, 0xf4, 0x5a, 0x81, 0x59, 0xa4, 0xaa, 0x5b, 0x4c, 0x15, 0x99, 0x53, 0x4d, 0x1c, 0x47, 0x14, - 0x27, 0xdd, 0xbe, 0xeb, 0x05, 0xe6, 0x98, 0xa4, 0x88, 0xcc, 0x9c, 0x22, 0x32, 0xc0, 0x07, 0x60, - 0xa2, 0xd2, 0xc1, 0x4e, 0x6f, 0xd0, 0x37, 0xc7, 0xa9, 0xa4, 0x94, 0x16, 0x89, 0xec, 0xa9, 0x26, - 0x89, 0x24, 0x13, 0xa2, 0x8b, 0x4f, 0x96, 0x6a, 0x42, 0x9a, 0x50, 0xe2, 0xe0, 0x26, 0x94, 0x98, - 0xe0, 0x33, 0x30, 0x4b, 0x9f, 0x6d, 0xb7, 0xd3, 0xb9, 0x74, 0xea, 0x6d, 0x73, 0x92, 0x8a, 0xd7, - 0x45, 0x71, 0xe2, 0x4d, 0x33, 0x88, 0x2a, 0x52, 0x9e, 0xac, 0xeb, 0xa9, 0x5b, 0x6f, 0x9b, 0x53, - 0x52, 0xf9, 0xc4, 0xc1, 0x95, 0x4f, 0x4c, 0xf0, 0x33, 0x30, 0x6d, 0x63, 0xdf, 0xed, 0x84, 0x98, - 0x4a, 0x01, 0x95, 0xfe, 0x8b, 0x49, 0x39, 0x5f, 0xaa, 0xe6, 0x15, 0x70, 0x1b, 0x8c, 0x1c, 0x57, - 0xcc, 0x69, 0xaa, 0x83, 0xe9, 0xe6, 0xa8, 0xa4, 0xe1, 0x23, 0xc7, 0x15, 0x52, 0xe6, 0x08, 0x77, - 0x70, 0x80, 0x6d, 0xa7, 0xd7, 0xc4, 0xe6, 0x8c, 0x54, 0x86, 0xf3, 0x71, 0x65, 0x38, 0x2b, 0x79, - 0x8b, 0xb6, 0x73, 0x4d, 0x16, 0x77, 0x56, 0x7a, 0x8b, 0x91, 0x99, 0x7b, 0x8b, 0x91, 0x81, 0xce, - 0xcc, 0xb9, 0x66, 0xef, 0x64, 0x4e, 0x9e, 0x59, 0xea, 0xe3, 0x67, 0x96, 0x5a, 0xe3, 0x92, 0x67, - 0x83, 0xc0, 0x9c, 0xcf, 0x96, 0x3c, 0x1b, 0x48, 0x25, 0xcf, 0x06, 0x42, 0x49, 0x22, 0x5b, 0xd0, - 0x94, 0x14, 0xb4, 0xbc, 0x02, 0x3e, 0x02, 0x53, 0xb6, 0x73, 0x1d, 0xcd, 0xdb, 0x5c, 0xa4, 0xf2, - 0x55, 0x5e, 0x1e, 0xaf, 0x08, 0x13, 0xa7, 0xd1, 0xf0, 0x39, 0x98, 0x4b, 0x32, 0xc5, 0x7a, 0x48, - 0xf5, 0x1b, 0x99, 0xf2, 0x72, 0x12, 0x49, 0x47, 0xb6, 0xbf, 0xed, 0x5c, 0xd3, 0x2f, 0x79, 0x49, - 0xda, 0xfe, 0xb1, 0x9d, 0xdb, 0xfe, 0xb1, 0x25, 0x2e, 0xcf, 0xbf, 0xe3, 0xe5, 0x6c, 0x79, 0xe5, - 0x6b, 0x96, 0x74, 0xf0, 0x10, 0xcc, 0x24, 0x03, 0xa2, 0x63, 0x58, 0xa1, 0x79, 0xd6, 0x32, 0xd3, - 0x10, 0x07, 0x22, 0x68, 0xe0, 0xc7, 0x60, 0xba, 0x92, 0x1e, 0xcd, 0xe6, 0xad, 0xf8, 0x40, 0xe2, - 0x8f, 0x6b, 0xee, 0x0d, 0x70, 0xa1, 0xb0, 0x0a, 0xe6, 0xcf, 0xb0, 0xef, 0xb7, 0xba, 0x2d, 0x3f, - 0x68, 0xd5, 0xe9, 0x37, 0x51, 0xa2, 0xea, 0xcd, 0xf4, 0x78, 0x12, 0xfd, 0x69, 0x22, 0x59, 0x09, - 0xbf, 0x02, 0x4b, 0x9c, 0x89, 0x7d, 0xe1, 0x26, 0x4d, 0x78, 0x47, 0x95, 0x30, 0xfb, 0x9d, 0xab, - 0x32, 0x90, 0xd5, 0xae, 0x5c, 0xe1, 0x7a, 0xfb, 0xfc, 0x5d, 0xaf, 0x16, 0x38, 0xc1, 0xc0, 0x37, - 0x57, 0xa5, 0xd5, 0x16, 0xdd, 0xdc, 0x6a, 0x8b, 0x0e, 0xb2, 0xda, 0xe7, 0xef, 0x7a, 0xcf, 0xb1, - 0xe3, 0x05, 0x87, 0xd8, 0x09, 0x4c, 0x24, 0xad, 0x36, 0xef, 0xe4, 0x56, 0x9b, 0x37, 0xc3, 0xc7, - 0x60, 0xec, 0x59, 0xb7, 0x1f, 0xdc, 0x98, 0x7f, 0x45, 0x8c, 0xb8, 0xad, 0xa4, 0x11, 0x0d, 0x49, - 0x53, 0x44, 0x92, 0xc3, 0x31, 0x30, 0x5a, 0xef, 0x36, 0xac, 0x1f, 0xe7, 0xc0, 0x8a, 0xc4, 0x2e, - 0xbf, 0xef, 0xf6, 0x7c, 0x0c, 0x8f, 0xc0, 0x94, 0x17, 0x3f, 0x27, 0xb4, 0xbb, 0xa7, 0xa1, 0x5d, - 0x14, 0x55, 0x4e, 0x1e, 0xec, 0x54, 0x38, 0x14, 0x78, 0x70, 0x17, 0x2c, 0x07, 0x9e, 0xd3, 0xf3, - 0x09, 0x00, 0x2e, 0x3a, 0xce, 0x0d, 0xf6, 0x2e, 0x3a, 0xae, 0xd3, 0xa0, 0x6c, 0x2a, 0xda, 0x90, - 0xf9, 0x4e, 0x89, 0xeb, 0xd4, 0x75, 0x1a, 0xe8, 0xbb, 0x59, 0x30, 0xc9, 0x46, 0xb9, 0xc3, 0x33, - 0x72, 0x59, 0x64, 0x64, 0x14, 0x92, 0x40, 0xf2, 0xbf, 0x02, 0x24, 0x57, 0x24, 0x48, 0xb2, 0xd8, - 0x88, 0x92, 0xfb, 0x19, 0x4a, 0xae, 0x2a, 0x28, 0xc9, 0x44, 0x29, 0x26, 0xf7, 0x24, 0x4c, 0x96, - 0x32, 0x98, 0x64, 0xa2, 0x84, 0x93, 0x7b, 0x12, 0x27, 0x4b, 0x19, 0x4e, 0xa6, 0x92, 0x18, 0x94, - 0x0f, 0x65, 0x50, 0x9a, 0x59, 0x50, 0x32, 0x11, 0x23, 0xe5, 0x7e, 0x86, 0x94, 0xab, 0x0a, 0x52, - 0xa6, 0x93, 0x62, 0x07, 0xf2, 0x17, 0x6a, 0x54, 0x6e, 0xe8, 0x50, 0xc9, 0x52, 0x48, 0xac, 0xdc, - 0xcf, 0xb0, 0x72, 0x55, 0xc1, 0xca, 0x74, 0x00, 0x0c, 0x96, 0x07, 0x2a, 0x58, 0xae, 0xa9, 0x61, - 0xc9, 0xe4, 0x02, 0x2d, 0xef, 0x72, 0xb4, 0x5c, 0x12, 0x68, 0xc9, 0xe2, 0x09, 0x2e, 0x0f, 0x54, - 0xb8, 0x5c, 0x53, 0xe3, 0x32, 0x2d, 0xc4, 0x9f, 0xa2, 0x7b, 0x12, 0x2f, 0x4b, 0x19, 0x5e, 0xa6, - 0x6f, 0x33, 0x06, 0xe6, 0x81, 0x0a, 0x98, 0x6b, 0x6a, 0x60, 0x72, 0xb3, 0xe3, 0x88, 0xb9, 0x27, - 0x11, 0xb3, 0x94, 0x21, 0xa6, 0x50, 0x94, 0x10, 0xef, 0x40, 0x85, 0xcc, 0x35, 0x35, 0x32, 0xb3, - 0x45, 0x49, 0x86, 0xc7, 0x59, 0x66, 0x22, 0x15, 0x33, 0x99, 0x9a, 0x83, 0xe6, 0x89, 0x06, 0x9a, - 0x9b, 0x5a, 0x68, 0xb2, 0x2c, 0x32, 0x35, 0x1f, 0xca, 0xd4, 0x34, 0xb3, 0xd4, 0x4c, 0xbf, 0x85, - 0x04, 0x9b, 0x27, 0x1a, 0x6c, 0x6e, 0x6a, 0xb1, 0x29, 0x0c, 0x80, 0x7f, 0xe3, 0x15, 0x25, 0x37, - 0xd7, 0x35, 0xdc, 0x64, 0x69, 0x44, 0x70, 0x3e, 0x52, 0x81, 0x73, 0x45, 0x02, 0x67, 0xfa, 0x1e, - 0x78, 0x72, 0x9e, 0xea, 0xc8, 0xb9, 0xa5, 0x27, 0x27, 0xcb, 0x94, 0x41, 0xe7, 0x9b, 0x3c, 0x74, - 0x6e, 0xe7, 0xa3, 0x93, 0x65, 0x55, 0xb2, 0xf3, 0x44, 0xc3, 0xce, 0x4d, 0x2d, 0x3b, 0xd3, 0x25, - 0x97, 0xe0, 0x59, 0x51, 0xc2, 0x73, 0x5d, 0x03, 0xcf, 0x74, 0xc9, 0x05, 0x7a, 0x3e, 0x91, 0xe8, - 0x69, 0xe5, 0xd1, 0x93, 0xe5, 0x10, 0xf1, 0x79, 0x08, 0x16, 0xa2, 0x23, 0xce, 0x79, 0x1b, 0xbc, - 0xc4, 0xbe, 0xef, 0x34, 0x31, 0x2c, 0x83, 0x62, 0xd7, 0x6f, 0x26, 0xcc, 0x44, 0x65, 0xf1, 0x97, - 0x28, 0x17, 0x69, 0xd3, 0x38, 0xab, 0x06, 0x56, 0xb5, 0xbc, 0x86, 0x25, 0x30, 0x11, 0x44, 0xf0, - 0xa4, 0x8c, 0x2b, 0xda, 0xe3, 0x01, 0x05, 0x27, 0x5c, 0x07, 0xa0, 0x81, 0x3b, 0xce, 0xcd, 0x45, - 0xd0, 0xea, 0x62, 0x0a, 0xb5, 0xa2, 0x3d, 0x45, 0x2d, 0xe7, 0xad, 0x2e, 0xb6, 0xfe, 0x0f, 0x90, - 0x7e, 0x1a, 0xda, 0xac, 0xf7, 0x7f, 0x29, 0x81, 0xe2, 0x79, 0xab, 0x1d, 0xc2, 0x87, 0x60, 0xac, - 0x1a, 0x92, 0xa3, 0x45, 0xf5, 0xbb, 0x13, 0x29, 0x41, 0x6b, 0x19, 0x70, 0x1f, 0x8c, 0x57, 0x43, - 0xba, 0x9f, 0x95, 0x3f, 0x42, 0x91, 0x9a, 0xba, 0x96, 0x01, 0x2b, 0x00, 0x54, 0x43, 0x06, 0x51, - 0xed, 0x2f, 0x52, 0xa4, 0xa7, 0xb0, 0x65, 0xc0, 0x37, 0x60, 0xb1, 0x1a, 0xca, 0xfb, 0x79, 0x58, - 0xfb, 0x88, 0x86, 0x7e, 0x25, 0x96, 0x01, 0x1b, 0x60, 0xa5, 0xfa, 0xa5, 0x6a, 0x4f, 0x7f, 0x48, - 0x2f, 0x89, 0x3e, 0xe8, 0xab, 0xb1, 0x0c, 0xf8, 0x0a, 0xcc, 0x55, 0x43, 0x61, 0x8b, 0xe6, 0xb6, - 0x83, 0x28, 0x7f, 0xbf, 0x5b, 0x06, 0x7c, 0x0d, 0x16, 0xaa, 0xa1, 0xf4, 0xe9, 0x0c, 0xe9, 0x54, - 0xd1, 0xb0, 0xaf, 0xd1, 0x32, 0xe0, 0xa7, 0x60, 0xb2, 0x1a, 0xc6, 0xcd, 0x8b, 0xe6, 0x1a, 0x00, - 0xe9, 0xfa, 0x9e, 0x44, 0x1e, 0x37, 0x32, 0x9a, 0x3b, 0x01, 0xa4, 0xeb, 0x81, 0x2c, 0x03, 0x1e, - 0x80, 0xa9, 0x6a, 0x98, 0xb4, 0x34, 0xba, 0x0b, 0x02, 0xa4, 0x6d, 0x88, 0x92, 0xcd, 0xc6, 0xd8, - 0xa9, 0xbd, 0x2d, 0x40, 0xfa, 0xee, 0xc8, 0x32, 0xa0, 0x0d, 0xe6, 0xe3, 0x24, 0x6c, 0x33, 0xe4, - 0x5f, 0x1d, 0xa0, 0x21, 0xed, 0x52, 0x32, 0x30, 0xd6, 0xf4, 0x68, 0xef, 0x11, 0x90, 0xbe, 0x6b, - 0xb2, 0x0c, 0x78, 0x0a, 0x66, 0xab, 0x21, 0xdf, 0xfa, 0xe4, 0x5d, 0x2a, 0xa0, 0xdc, 0x26, 0xca, - 0x32, 0xe0, 0x1e, 0x28, 0x56, 0xc3, 0xe3, 0x0a, 0x54, 0xdc, 0x30, 0x20, 0x55, 0x1f, 0x95, 0x0c, - 0x80, 0x07, 0x64, 0xde, 0x75, 0x03, 0xca, 0x6d, 0xae, 0x2c, 0x03, 0x3e, 0x49, 0xfa, 0x29, 0xa8, - 0xb9, 0x79, 0x40, 0xba, 0x0e, 0xcb, 0x32, 0xe0, 0x0b, 0xa1, 0xb3, 0x82, 0x79, 0x97, 0x10, 0x28, - 0xb7, 0xe1, 0x62, 0x03, 0x21, 0x8d, 0x8f, 0xe6, 0x3e, 0x02, 0xe9, 0xba, 0x2e, 0x71, 0x20, 0x24, - 0x43, 0xde, 0xd5, 0x04, 0xca, 0x6d, 0xc2, 0x2c, 0x83, 0xfc, 0x30, 0x4b, 0x1b, 0x29, 0xfd, 0x2d, - 0x05, 0xca, 0x69, 0xc6, 0x2c, 0x03, 0xd6, 0xe4, 0x0e, 0x0c, 0x0e, 0xb9, 0xb0, 0x40, 0xc3, 0x7a, - 0x33, 0xcb, 0x80, 0x4f, 0x59, 0x2f, 0x06, 0x75, 0x77, 0x17, 0x48, 0xdb, 0x9e, 0xb1, 0x41, 0xf1, - 0x7b, 0x67, 0xc8, 0x35, 0x06, 0x1a, 0xd6, 0xaf, 0x59, 0x06, 0x7c, 0x29, 0xf6, 0x67, 0x30, 0xf7, - 0x46, 0x03, 0xe5, 0xf7, 0x6d, 0x96, 0x01, 0x2f, 0x00, 0x7c, 0xdd, 0xf3, 0x9d, 0xb7, 0xf8, 0x08, - 0xfb, 0x81, 0xe7, 0xde, 0x44, 0xe3, 0xb4, 0x98, 0x2c, 0xeb, 0x4c, 0x52, 0xdf, 0xc9, 0x8d, 0x61, - 0x05, 0x30, 0x58, 0xb6, 0x71, 0xb3, 0xe5, 0x07, 0xe4, 0xf7, 0x6e, 0xbd, 0xfd, 0xea, 0x32, 0xea, - 0x1d, 0xe0, 0x36, 0xf7, 0xa9, 0x66, 0xdd, 0x49, 0x91, 0xbb, 0x43, 0xa2, 0x58, 0x99, 0x6f, 0xc0, - 0x22, 0x3d, 0xe1, 0x85, 0x1a, 0xb7, 0xc5, 0xd3, 0x5f, 0x55, 0xc0, 0xca, 0x0b, 0xe1, 0x57, 0xc9, - 0xc6, 0x5d, 0x37, 0x3a, 0x4f, 0x58, 0x7a, 0x8b, 0x1b, 0x9c, 0xec, 0xcc, 0xae, 0x92, 0x2a, 0x86, - 0x15, 0xf8, 0x1a, 0x2c, 0x9c, 0x5d, 0xdd, 0xf8, 0xad, 0xba, 0xd3, 0x61, 0x27, 0x26, 0x87, 0x72, - 0xc9, 0x95, 0x24, 0xbf, 0x9d, 0x13, 0xc1, 0x52, 0x7f, 0x22, 0xf4, 0xe2, 0x50, 0x79, 0x7d, 0x85, - 0xd4, 0xbd, 0x39, 0xfd, 0x3c, 0x17, 0x39, 0x75, 0x2d, 0xf0, 0xb0, 0xd3, 0xfd, 0x87, 0x39, 0x76, - 0x0b, 0xf0, 0x09, 0x28, 0x92, 0x4e, 0x11, 0xe6, 0xb4, 0x8f, 0x68, 0x49, 0xf2, 0x1d, 0xb9, 0x3d, - 0x6c, 0x19, 0x3b, 0x05, 0xf8, 0x14, 0x4c, 0xb1, 0xae, 0x14, 0x9a, 0x42, 0x5b, 0xfb, 0x41, 0xfa, - 0xcf, 0xc1, 0x64, 0xad, 0xe7, 0xf4, 0xfd, 0x2b, 0x97, 0xb4, 0x20, 0x62, 0x50, 0xe2, 0xa8, 0x5c, - 0x0d, 0x7a, 0x6d, 0x7d, 0x8a, 0x17, 0x60, 0xba, 0xd6, 0xef, 0x10, 0xee, 0x37, 0x5b, 0x6e, 0x8f, - 0x3b, 0xf0, 0x38, 0x6b, 0xf6, 0xc0, 0x13, 0x9c, 0xc2, 0x81, 0x87, 0x9d, 0xc6, 0x49, 0xaf, 0x81, - 0xdf, 0xf1, 0x07, 0x5e, 0x62, 0x53, 0x1c, 0x78, 0xa9, 0x8b, 0x3f, 0x06, 0x5e, 0x86, 0xf5, 0xfa, - 0x31, 0x0e, 0x0e, 0x6f, 0xaa, 0xf8, 0x86, 0x3b, 0x06, 0x78, 0x73, 0xf6, 0x18, 0x10, 0xbd, 0xfc, - 0xfe, 0x63, 0x9e, 0x5a, 0xe0, 0x78, 0xc1, 0xb9, 0xcf, 0xed, 0x3f, 0xd9, 0x95, 0xdd, 0x7f, 0xd9, - 0x08, 0xae, 0xb5, 0x98, 0x15, 0x7a, 0x77, 0xb8, 0x96, 0xf7, 0x57, 0x26, 0xb4, 0x9e, 0x7b, 0x2b, - 0x47, 0xde, 0xc6, 0x6e, 0xe1, 0xf0, 0xde, 0xaf, 0x3f, 0x4c, 0x16, 0x7e, 0x7a, 0xbf, 0x51, 0xf8, - 0xf9, 0xfd, 0x46, 0xe1, 0xb7, 0xf7, 0x1b, 0x85, 0xef, 0x7f, 0xdf, 0x30, 0xc0, 0x82, 0xeb, 0x35, - 0xa9, 0xba, 0xdc, 0x0e, 0xe9, 0xdf, 0xbe, 0x2e, 0xc7, 0xe9, 0x3f, 0x0f, 0xfe, 0x0e, 0x00, 0x00, - 0xff, 0xff, 0x3e, 0x7a, 0x87, 0xc5, 0x78, 0x1b, 0x00, 0x00, +func init() { proto.RegisterFile("tikvpb.proto", fileDescriptor_tikvpb_90bf9910f92409ea) } + +var fileDescriptor_tikvpb_90bf9910f92409ea = []byte{ + // 1848 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x99, 0xdb, 0x72, 0xdc, 0xb4, + 0x1f, 0xc7, 0xbd, 0xc9, 0xe6, 0xa4, 0x9c, 0x95, 0xa4, 0x71, 0xf4, 0xcf, 0xa9, 0x6e, 0xda, 0x7f, + 0x06, 0x66, 0x96, 0xa4, 0x2d, 0x84, 0xb6, 0x50, 0x42, 0x36, 0x25, 0x4d, 0x37, 0x99, 0x66, 0xbc, + 0x29, 0x94, 0x19, 0x66, 0x32, 0xce, 0xae, 0xba, 0xd9, 0xd9, 0x83, 0x17, 0xdb, 0xeb, 0x34, 0x8f, + 0xc0, 0x1b, 0xf0, 0x02, 0xcc, 0xf0, 0x10, 0x3c, 0x00, 0x97, 0x5c, 0x72, 0xc9, 0x94, 0x2b, 0x2e, + 0x78, 0x06, 0x18, 0xc9, 0xb6, 0x2c, 0xc9, 0x92, 0xb7, 0x5c, 0xc5, 0xd1, 0xef, 0x24, 0xc9, 0x92, + 0x3e, 0x5f, 0x6b, 0xc1, 0x54, 0xd0, 0x6c, 0x85, 0xbd, 0xcb, 0x52, 0xcf, 0x73, 0x03, 0x17, 0x8e, + 0x46, 0xff, 0xa1, 0xf9, 0x9a, 0xdb, 0xf3, 0xdc, 0x1a, 0xf6, 0x7d, 0xd7, 0x8b, 0x4c, 0x68, 0xba, + 0x15, 0x7a, 0xbd, 0x5a, 0xe2, 0x89, 0x16, 0x3c, 0xe7, 0x4d, 0x70, 0xe1, 0x63, 0x2f, 0xc4, 0x1e, + 0x6b, 0x5c, 0x6c, 0xb8, 0x0d, 0x97, 0x3e, 0x7e, 0x44, 0x9e, 0xe2, 0xd6, 0x59, 0xaf, 0xef, 0x07, + 0xf4, 0x31, 0x6a, 0xb0, 0xfe, 0x9a, 0x06, 0x8b, 0x07, 0x4e, 0x50, 0xbb, 0x2a, 0xbb, 0x9d, 0x8e, + 0xd3, 0xad, 0xfb, 0x36, 0xfe, 0xbe, 0x8f, 0xfd, 0x00, 0xee, 0x83, 0x71, 0x2f, 0x7a, 0xf4, 0xcd, + 0xc2, 0xe6, 0xf0, 0xf6, 0xe4, 0xfd, 0xad, 0x52, 0xdc, 0x3f, 0x95, 0x7f, 0x29, 0xfe, 0x6b, 0xb3, + 0x28, 0xb8, 0x01, 0x26, 0xe3, 0xe7, 0x8b, 0x66, 0xdd, 0x37, 0x87, 0x36, 0x87, 0xb7, 0x8b, 0x36, + 0x88, 0x9b, 0x8e, 0xeb, 0x3e, 0xfa, 0x7b, 0x0a, 0x8c, 0x25, 0xe5, 0xfe, 0x0f, 0x86, 0x8f, 0x70, + 0x60, 0x16, 0x36, 0x0b, 0xdb, 0x93, 0xf7, 0x17, 0x4a, 0xc9, 0x00, 0x8f, 0x70, 0x10, 0x7b, 0x3c, + 0x37, 0x6c, 0xe2, 0x01, 0x3f, 0x00, 0xc5, 0x6a, 0xcd, 0xe9, 0x9a, 0x43, 0xd4, 0x73, 0x91, 0x79, + 0x92, 0xc6, 0xd4, 0x95, 0xfa, 0xc0, 0x4f, 0xc0, 0xf8, 0x99, 0x87, 0xaf, 0xbd, 0x66, 0x80, 0xcd, + 0x61, 0xea, 0x6f, 0x32, 0xff, 0xc4, 0x90, 0xc6, 0x30, 0x5f, 0xb8, 0x03, 0x46, 0xc9, 0xf0, 0x9a, + 0x81, 0x59, 0xa4, 0x51, 0xb7, 0x58, 0x54, 0xd4, 0x9c, 0xc6, 0xc4, 0x7e, 0x24, 0xe2, 0xb8, 0xd3, + 0x73, 0xbd, 0xc0, 0x1c, 0x91, 0x22, 0xa2, 0x66, 0x2e, 0x22, 0x6a, 0x80, 0x0f, 0xc0, 0x58, 0xb9, + 0x8d, 0x9d, 0x6e, 0xbf, 0x67, 0x8e, 0xd2, 0x90, 0xe5, 0xb4, 0x48, 0xd4, 0x9e, 0xc6, 0x24, 0x9e, + 0x64, 0x40, 0x74, 0xf2, 0xc9, 0x54, 0x8d, 0x49, 0x03, 0x4a, 0x0c, 0xdc, 0x80, 0x92, 0x26, 0xf8, + 0x0c, 0x4c, 0xd3, 0x67, 0xdb, 0x6d, 0xb7, 0x2f, 0x9d, 0x5a, 0xcb, 0x1c, 0xa7, 0xc1, 0x6b, 0x62, + 0x70, 0x62, 0x4d, 0x33, 0x88, 0x51, 0xa4, 0x3c, 0x99, 0xd7, 0x13, 0xb7, 0xd6, 0x32, 0x27, 0xa4, + 0xf2, 0x89, 0x81, 0x2b, 0x9f, 0x34, 0xc1, 0x2f, 0xc0, 0xa4, 0x8d, 0x7d, 0xb7, 0x1d, 0x62, 0x1a, + 0x0a, 0x68, 0xe8, 0xff, 0x58, 0x28, 0x67, 0x4b, 0xa3, 0xf9, 0x08, 0xb8, 0x05, 0x86, 0x8e, 0xca, + 0xe6, 0x24, 0x8d, 0x83, 0xe9, 0xe2, 0x28, 0xa7, 0xee, 0x43, 0x47, 0x65, 0x52, 0xe6, 0x10, 0xb7, + 0x71, 0x80, 0x6d, 0xa7, 0xdb, 0xc0, 0xe6, 0x94, 0x54, 0x86, 0xb3, 0x71, 0x65, 0xb8, 0x56, 0xf2, + 0x16, 0x6d, 0xe7, 0x9a, 0x4c, 0xee, 0xb4, 0xf4, 0x16, 0xa3, 0x66, 0xee, 0x2d, 0x46, 0x0d, 0x74, + 0x64, 0xce, 0x35, 0x7b, 0x27, 0x33, 0xf2, 0xc8, 0x52, 0x1b, 0x3f, 0xb2, 0xb4, 0x35, 0x2e, 0x79, + 0xd6, 0x0f, 0xcc, 0xd9, 0x6c, 0xc9, 0xb3, 0xbe, 0x54, 0xf2, 0xac, 0x2f, 0x94, 0x24, 0x61, 0x73, + 0x9a, 0x92, 0x42, 0x2c, 0x1f, 0x01, 0x1f, 0x81, 0x09, 0xdb, 0xb9, 0x8e, 0xc6, 0x6d, 0xce, 0xd3, + 0xf0, 0x15, 0x3e, 0x3c, 0x9e, 0x11, 0x16, 0x9c, 0x7a, 0xc3, 0xe7, 0x60, 0x26, 0xc9, 0x14, 0xc7, + 0x43, 0x1a, 0xbf, 0x9e, 0x29, 0x2f, 0x27, 0x91, 0xe2, 0xc8, 0xf2, 0xb7, 0x9d, 0x6b, 0xba, 0x93, + 0x17, 0xa4, 0xe5, 0x1f, 0xb7, 0x73, 0xcb, 0x3f, 0x6e, 0x89, 0xcb, 0xf3, 0xef, 0x78, 0x31, 0x5b, + 0x5e, 0xf9, 0x9a, 0xa5, 0x38, 0x78, 0x00, 0xa6, 0x92, 0x0e, 0xd1, 0x3e, 0x2c, 0xd1, 0x3c, 0xab, + 0x99, 0x61, 0x88, 0x1d, 0x11, 0x62, 0xe0, 0xa7, 0x60, 0xb2, 0x9c, 0x1e, 0xcd, 0xe6, 0xad, 0xf8, + 0x40, 0xe2, 0x8f, 0x6b, 0xee, 0x0d, 0x70, 0xae, 0xb0, 0x02, 0x66, 0xcf, 0xb0, 0xef, 0x37, 0x3b, + 0x4d, 0x3f, 0x68, 0xd6, 0xe8, 0x9e, 0x58, 0xa6, 0xd1, 0x1b, 0xe9, 0xf1, 0x24, 0xda, 0xd3, 0x44, + 0x72, 0x24, 0xfc, 0x06, 0x2c, 0x70, 0x4d, 0x6c, 0x87, 0x9b, 0x34, 0xe1, 0x1d, 0x55, 0xc2, 0xec, + 0x3e, 0x57, 0x65, 0x20, 0xb3, 0x5d, 0xbe, 0xc2, 0xb5, 0xd6, 0xf9, 0xdb, 0x6e, 0x35, 0x70, 0x82, + 0xbe, 0x6f, 0xae, 0x48, 0xb3, 0x2d, 0x9a, 0xb9, 0xd9, 0x16, 0x0d, 0x64, 0xb6, 0xcf, 0xdf, 0x76, + 0x9f, 0x63, 0xc7, 0x0b, 0x0e, 0xb0, 0x13, 0x98, 0x48, 0x9a, 0x6d, 0xde, 0xc8, 0xcd, 0x36, 0xdf, + 0x0c, 0x1f, 0x83, 0x91, 0x67, 0x9d, 0x5e, 0x70, 0x63, 0xfe, 0x13, 0x31, 0xe2, 0xb6, 0x92, 0x46, + 0xd4, 0x25, 0x4d, 0x11, 0x85, 0x1c, 0x8c, 0x80, 0xe1, 0x5a, 0xa7, 0x6e, 0xfd, 0x32, 0x03, 0x96, + 0x24, 0x76, 0xf9, 0x3d, 0xb7, 0xeb, 0x63, 0x78, 0x08, 0x26, 0xbc, 0xf8, 0x39, 0xa1, 0xdd, 0x3d, + 0x0d, 0xed, 0x22, 0xaf, 0x52, 0xf2, 0x60, 0xa7, 0x81, 0x03, 0x81, 0x07, 0x77, 0xc0, 0x62, 0xe0, + 0x39, 0x5d, 0x9f, 0x00, 0xe0, 0xa2, 0xed, 0xdc, 0x60, 0xef, 0xa2, 0xed, 0x3a, 0x75, 0xca, 0xa6, + 0xa2, 0x0d, 0x99, 0xed, 0x84, 0x98, 0x4e, 0x5c, 0xa7, 0x8e, 0x7e, 0x98, 0x06, 0xe3, 0xac, 0x97, + 0xdb, 0x3c, 0x23, 0x17, 0x45, 0x46, 0x46, 0x2e, 0x09, 0x24, 0x3f, 0x14, 0x20, 0xb9, 0x24, 0x41, + 0x92, 0xf9, 0x46, 0x94, 0xdc, 0xcb, 0x50, 0x72, 0x45, 0x41, 0x49, 0x16, 0x94, 0x62, 0x72, 0x57, + 0xc2, 0xe4, 0x72, 0x06, 0x93, 0x2c, 0x28, 0xe1, 0xe4, 0xae, 0xc4, 0xc9, 0xe5, 0x0c, 0x27, 0xd3, + 0x90, 0x18, 0x94, 0x0f, 0x65, 0x50, 0x9a, 0x59, 0x50, 0xb2, 0x20, 0x46, 0xca, 0xbd, 0x0c, 0x29, + 0x57, 0x14, 0xa4, 0x4c, 0x07, 0xc5, 0x0e, 0xe4, 0xaf, 0xd4, 0xa8, 0x5c, 0xd7, 0xa1, 0x92, 0xa5, + 0x90, 0x58, 0xb9, 0x97, 0x61, 0xe5, 0x8a, 0x82, 0x95, 0x69, 0x07, 0x18, 0x2c, 0xf7, 0x55, 0xb0, + 0x5c, 0x55, 0xc3, 0x92, 0x85, 0x0b, 0xb4, 0xbc, 0xcb, 0xd1, 0x72, 0x41, 0xa0, 0x25, 0xf3, 0x27, + 0xb8, 0xdc, 0x57, 0xe1, 0x72, 0x55, 0x8d, 0xcb, 0xb4, 0x10, 0x7f, 0x8a, 0xee, 0x4a, 0xbc, 0x5c, + 0xce, 0xf0, 0x32, 0x7d, 0x9b, 0x31, 0x30, 0xf7, 0x55, 0xc0, 0x5c, 0x55, 0x03, 0x93, 0x1b, 0x1d, + 0x47, 0xcc, 0x5d, 0x89, 0x98, 0xcb, 0x19, 0x62, 0x0a, 0x45, 0x09, 0xf1, 0xf6, 0x55, 0xc8, 0x5c, + 0x55, 0x23, 0x33, 0x5b, 0x94, 0x64, 0x78, 0x9c, 0x65, 0x26, 0x52, 0x31, 0x93, 0x45, 0x73, 0xd0, + 0x3c, 0xd6, 0x40, 0x73, 0x43, 0x0b, 0x4d, 0x96, 0x45, 0xa6, 0xe6, 0x43, 0x99, 0x9a, 0x66, 0x96, + 0x9a, 0xe9, 0x5e, 0x48, 0xb0, 0x79, 0xac, 0xc1, 0xe6, 0x86, 0x16, 0x9b, 0x42, 0x07, 0xf8, 0x37, + 0x5e, 0x56, 0x72, 0x73, 0x4d, 0xc3, 0x4d, 0x96, 0x46, 0x04, 0xe7, 0x23, 0x15, 0x38, 0x97, 0x24, + 0x70, 0xa6, 0xef, 0x81, 0x27, 0xe7, 0x89, 0x8e, 0x9c, 0x9b, 0x7a, 0x72, 0xb2, 0x4c, 0x19, 0x74, + 0xbe, 0xce, 0x43, 0xe7, 0x56, 0x3e, 0x3a, 0x59, 0x56, 0x25, 0x3b, 0x8f, 0x35, 0xec, 0xdc, 0xd0, + 0xb2, 0x33, 0x9d, 0x72, 0x09, 0x9e, 0x65, 0x25, 0x3c, 0xd7, 0x34, 0xf0, 0x4c, 0xa7, 0x5c, 0xa0, + 0xe7, 0x13, 0x89, 0x9e, 0x56, 0x1e, 0x3d, 0x59, 0x0e, 0x11, 0x9f, 0x07, 0x60, 0x2e, 0x3a, 0xe2, + 0x9c, 0x37, 0xc1, 0x29, 0xf6, 0x7d, 0xa7, 0x81, 0x61, 0x09, 0x14, 0x3b, 0x7e, 0x23, 0x61, 0x26, + 0x2a, 0x89, 0x5f, 0xa2, 0x9c, 0xa7, 0x4d, 0xfd, 0xac, 0x2a, 0x58, 0xd1, 0xf2, 0x1a, 0x2e, 0x83, + 0xb1, 0x20, 0x82, 0x27, 0x65, 0x5c, 0xd1, 0x1e, 0x0d, 0x28, 0x38, 0xe1, 0x1a, 0x00, 0x75, 0xdc, + 0x76, 0x6e, 0x2e, 0x82, 0x66, 0x07, 0x53, 0xa8, 0x15, 0xed, 0x09, 0xda, 0x72, 0xde, 0xec, 0x60, + 0xeb, 0x63, 0x80, 0xf4, 0xc3, 0xd0, 0x66, 0xbd, 0xff, 0x93, 0x09, 0x8a, 0xe7, 0xcd, 0x56, 0x08, + 0x1f, 0x82, 0x91, 0x4a, 0x48, 0x8e, 0x16, 0xd5, 0x77, 0x27, 0x52, 0x82, 0xd6, 0x32, 0xe0, 0x1e, + 0x18, 0xad, 0x84, 0x74, 0x3d, 0x2b, 0x3f, 0x42, 0x91, 0x9a, 0xba, 0x96, 0x01, 0xcb, 0x00, 0x54, + 0x42, 0x06, 0x51, 0xed, 0x17, 0x29, 0xd2, 0x53, 0xd8, 0x32, 0xe0, 0x6b, 0x30, 0x5f, 0x09, 0xe5, + 0xf5, 0x3c, 0x48, 0x3e, 0xa2, 0x81, 0xbb, 0xc4, 0x32, 0x60, 0x1d, 0x2c, 0x55, 0xbe, 0x56, 0xad, + 0xe9, 0xf7, 0xd1, 0x92, 0xe8, 0xbd, 0x76, 0x8d, 0x65, 0xc0, 0x97, 0x60, 0xa6, 0x12, 0x0a, 0x4b, + 0x34, 0x57, 0x0e, 0xa2, 0xfc, 0xf5, 0x6e, 0x19, 0xf0, 0x15, 0x98, 0xab, 0x84, 0xd2, 0xd6, 0x19, + 0xa0, 0x54, 0xd1, 0xa0, 0xdd, 0x68, 0x19, 0xf0, 0x73, 0x30, 0x5e, 0x09, 0x63, 0xf1, 0xa2, 0xb9, + 0x06, 0x40, 0x3a, 0xdd, 0x93, 0x84, 0xc7, 0x42, 0x46, 0x73, 0x27, 0x80, 0x74, 0x1a, 0xc8, 0x32, + 0xe0, 0x3e, 0x98, 0xa8, 0x84, 0x89, 0xa4, 0xd1, 0x5d, 0x10, 0x20, 0xad, 0x20, 0x4a, 0x16, 0x1b, + 0x63, 0xa7, 0xf6, 0xb6, 0x00, 0xe9, 0xd5, 0x91, 0x65, 0x40, 0x1b, 0xcc, 0xc6, 0x49, 0xd8, 0x62, + 0xc8, 0xbf, 0x3a, 0x40, 0x03, 0xe4, 0x52, 0xd2, 0x31, 0x26, 0x7a, 0xb4, 0xf7, 0x08, 0x48, 0xaf, + 0x9a, 0x2c, 0x03, 0x9e, 0x80, 0xe9, 0x4a, 0xc8, 0x4b, 0x9f, 0xbc, 0x4b, 0x05, 0x94, 0x2b, 0xa2, + 0x2c, 0x03, 0xee, 0x82, 0x62, 0x25, 0x3c, 0x2a, 0x43, 0xc5, 0x0d, 0x03, 0x52, 0xe9, 0xa8, 0xa4, + 0x03, 0x3c, 0x20, 0xf3, 0xae, 0x1b, 0x50, 0xae, 0xb8, 0xb2, 0x0c, 0xf8, 0x24, 0xd1, 0x53, 0x50, + 0x73, 0xf3, 0x80, 0x74, 0x0a, 0xcb, 0x32, 0xe0, 0x0b, 0x41, 0x59, 0xc1, 0xbc, 0x4b, 0x08, 0x94, + 0x2b, 0xb8, 0x58, 0x47, 0x88, 0xf0, 0xd1, 0xdc, 0x47, 0x20, 0x9d, 0xea, 0x12, 0x3b, 0x42, 0x32, + 0xe4, 0x5d, 0x4d, 0xa0, 0x5c, 0x11, 0x66, 0x19, 0xe4, 0xc3, 0x2c, 0x15, 0x52, 0xfa, 0x5b, 0x0a, + 0x94, 0x23, 0xc6, 0x2c, 0x03, 0x56, 0x65, 0x05, 0x06, 0x07, 0x5c, 0x58, 0xa0, 0x41, 0xda, 0xcc, + 0x32, 0xe0, 0x53, 0xa6, 0xc5, 0xa0, 0xee, 0xee, 0x02, 0x69, 0xe5, 0x19, 0xeb, 0x14, 0xbf, 0x76, + 0x06, 0x5c, 0x63, 0xa0, 0x41, 0x7a, 0xcd, 0x32, 0xe0, 0xa9, 0xa8, 0xcf, 0x60, 0xee, 0x8d, 0x06, + 0xca, 0xd7, 0x6d, 0x96, 0x01, 0x2f, 0x00, 0x7c, 0xd5, 0xf5, 0x9d, 0x37, 0xf8, 0x10, 0xfb, 0x81, + 0xe7, 0xde, 0x44, 0xfd, 0xb4, 0x58, 0x58, 0xd6, 0x98, 0xa4, 0xbe, 0x93, 0xeb, 0xc3, 0x0a, 0x60, + 0xb0, 0x68, 0xe3, 0x46, 0xd3, 0x0f, 0xc8, 0xf7, 0x6e, 0xad, 0xf5, 0xf2, 0x32, 0xd2, 0x0e, 0x70, + 0x8b, 0xdb, 0xaa, 0x59, 0x73, 0x52, 0xe4, 0xee, 0x00, 0x2f, 0x56, 0xe6, 0x3b, 0x30, 0x4f, 0x4f, + 0x78, 0xa1, 0xc6, 0x6d, 0xf1, 0xf4, 0x57, 0x15, 0xb0, 0xf2, 0x5c, 0xf8, 0x59, 0xb2, 0x71, 0xc7, + 0x8d, 0xce, 0x13, 0x96, 0xde, 0xe2, 0x3a, 0x27, 0x1b, 0xb3, 0xb3, 0xa4, 0xf2, 0x61, 0x05, 0xbe, + 0x05, 0x73, 0x67, 0x57, 0x37, 0x7e, 0xb3, 0xe6, 0xb4, 0xd9, 0x89, 0xc9, 0xa1, 0x5c, 0x32, 0x25, + 0xc9, 0x6f, 0xe7, 0x78, 0xb0, 0xd4, 0x9f, 0x09, 0x5a, 0x1c, 0x2a, 0xaf, 0xaf, 0x90, 0x5a, 0x9b, + 0xd3, 0xed, 0x39, 0xcf, 0x45, 0x57, 0x03, 0x0f, 0x3b, 0x9d, 0xff, 0x98, 0x63, 0xa7, 0x00, 0x4f, + 0x63, 0x61, 0xc9, 0x77, 0x64, 0x45, 0x70, 0x8f, 0x20, 0xc2, 0xf6, 0xba, 0xc2, 0xc4, 0xa5, 0x7b, + 0x02, 0x8a, 0x44, 0x78, 0xc2, 0x1c, 0x35, 0x8a, 0x16, 0x24, 0xdb, 0xa1, 0xdb, 0xc5, 0x96, 0xb1, + 0x5d, 0x80, 0x4f, 0xc1, 0x04, 0x13, 0xb9, 0xd0, 0x14, 0x54, 0xf2, 0x7b, 0xc5, 0x7f, 0x09, 0xc6, + 0xab, 0x5d, 0xa7, 0xe7, 0x5f, 0xb9, 0x44, 0xd1, 0x88, 0x4e, 0x89, 0xa1, 0x7c, 0xd5, 0xef, 0xb6, + 0xf4, 0x29, 0x5e, 0x80, 0xc9, 0x6a, 0xaf, 0x4d, 0x64, 0x44, 0xa3, 0xe9, 0x76, 0xb9, 0xf3, 0x93, + 0x6b, 0xcd, 0x9e, 0x9f, 0x82, 0x51, 0x38, 0x3f, 0xb1, 0x53, 0x3f, 0xee, 0xd6, 0xf1, 0x5b, 0xfe, + 0xfc, 0x4c, 0xda, 0x14, 0xe7, 0x67, 0x6a, 0xe2, 0x4f, 0x95, 0xd3, 0xb0, 0x56, 0x3b, 0xc2, 0xc1, + 0xc1, 0x4d, 0x05, 0xdf, 0x70, 0xa7, 0x0a, 0xdf, 0x9c, 0x3d, 0x55, 0x44, 0x2b, 0xbf, 0x9c, 0x99, + 0xa5, 0x1a, 0x38, 0x5e, 0x70, 0xee, 0x73, 0xcb, 0x59, 0x36, 0x65, 0x97, 0x73, 0xd6, 0x83, 0x53, + 0x2a, 0xd3, 0xc2, 0xa7, 0x00, 0x5c, 0xcd, 0xfb, 0xd1, 0x0a, 0xad, 0xe5, 0x5e, 0xf2, 0x91, 0xb7, + 0xb1, 0x53, 0x38, 0xb8, 0xf7, 0xfb, 0xcf, 0xe3, 0x85, 0x5f, 0xdf, 0xad, 0x17, 0x7e, 0x7b, 0xb7, + 0x5e, 0xf8, 0xe3, 0xdd, 0x7a, 0xe1, 0xc7, 0x3f, 0xd7, 0x0d, 0x30, 0xe7, 0x7a, 0x0d, 0x1a, 0x5d, + 0x6a, 0x85, 0xf4, 0xa7, 0xb4, 0xcb, 0x51, 0xfa, 0xe7, 0xc1, 0xbf, 0x01, 0x00, 0x00, 0xff, 0xff, + 0x91, 0xcf, 0x54, 0x88, 0xc7, 0x1b, 0x00, 0x00, } diff --git a/proto/coprocessor.proto b/proto/coprocessor.proto index de7b719ca..71e46fb1b 100644 --- a/proto/coprocessor.proto +++ b/proto/coprocessor.proto @@ -5,6 +5,7 @@ import "errorpb.proto"; import "kvrpcpb.proto"; import "gogoproto/gogo.proto"; import "rustproto.proto"; +import "metapb.proto"; option (gogoproto.marshaler_all) = true; option (gogoproto.sizer_all) = true; @@ -47,3 +48,25 @@ message Response { uint64 cache_last_version = 8; bool can_be_cached = 9; } + +message RegionInfo { + uint64 region_id = 1; + metapb.RegionEpoch region_epoch = 2; + repeated KeyRange ranges = 3; +} + +message BatchRequest { + kvrpcpb.Context context = 1; + int64 tp = 2; + bytes data = 3; + repeated RegionInfo regions = 4; + uint64 start_ts = 5; + // Any schema-ful storage to validate schema correctness if necessary. + int64 schema_ver = 6; +} + +message BatchResponse { + bytes data = 1 [(gogoproto.customtype) = "github.com/pingcap/kvproto/pkg/sharedbytes.SharedBytes", (gogoproto.nullable) = false]; + string other_error = 2; + kvrpcpb.ExecDetails exec_details = 3; +} diff --git a/proto/import_sstpb.proto b/proto/import_sstpb.proto index df106ad1c..02f227bb0 100644 --- a/proto/import_sstpb.proto +++ b/proto/import_sstpb.proto @@ -75,6 +75,7 @@ message SSTMeta { string cf_name = 5; uint64 region_id = 6; metapb.RegionEpoch region_epoch = 7; + bool end_key_exclusive = 8; } // A rewrite rule is applied on the *encoded* keys (the internal storage @@ -144,6 +145,8 @@ message DownloadRequest { RewriteRule rewrite_rule = 13 [(gogoproto.nullable) = false]; backup.StorageBackend storage_backend = 14; + + bool is_raw_kv = 15; } // For now it is just used for distinguishing the error of the request with the error diff --git a/proto/pdpb.proto b/proto/pdpb.proto index d70a54734..7cab35dc7 100644 --- a/proto/pdpb.proto +++ b/proto/pdpb.proto @@ -3,7 +3,7 @@ package pdpb; import "metapb.proto"; import "eraftpb.proto"; -import "replicate_mode.proto"; +import "replication_modepb.proto"; import "gogoproto/gogo.proto"; import "rustproto.proto"; @@ -70,6 +70,8 @@ service PD { rpc UpdateGCSafePoint(UpdateGCSafePointRequest) returns (UpdateGCSafePointResponse) {} + rpc UpdateServiceGCSafePoint(UpdateServiceGCSafePointRequest) returns (UpdateServiceGCSafePointResponse) {} + rpc SyncRegions(stream SyncRegionRequest) returns (stream SyncRegionResponse) {} rpc GetOperator(GetOperatorRequest) returns (GetOperatorResponse) {} @@ -128,7 +130,7 @@ message BootstrapRequest { message BootstrapResponse { ResponseHeader header = 1; - replicate_mode.ReplicateStatus replicate_status = 2; + replication_modepb.ReplicationStatus replication_status = 2; } message IsBootstrappedRequest { @@ -172,7 +174,7 @@ message PutStoreRequest { message PutStoreResponse { ResponseHeader header = 1; - replicate_mode.ReplicateStatus replicate_status = 2; + replication_modepb.ReplicationStatus replication_status = 2; } message GetAllStoresRequest { @@ -305,7 +307,7 @@ message RegionHeartbeatRequest { uint64 approximate_keys = 13; // Term is the term of raft group. uint64 term = 14; - replicate_mode.RegionReplicateStatus replicate_status = 15; + replication_modepb.RegionReplicationStatus replication_status = 15; } message ChangePeer { @@ -478,7 +480,7 @@ message StoreHeartbeatRequest { message StoreHeartbeatResponse { ResponseHeader header = 1; - replicate_mode.ReplicateStatus replicate_status = 2; + replication_modepb.ReplicationStatus replication_status = 2; } message ScatterRegionRequest { @@ -518,6 +520,22 @@ message UpdateGCSafePointResponse { uint64 new_safe_point = 2; } +message UpdateServiceGCSafePointRequest { + RequestHeader header = 1; + + bytes service_id = 2; + int64 TTL = 3; + uint64 safe_point = 4; +} + +message UpdateServiceGCSafePointResponse { + ResponseHeader header = 1; + + bytes service_id = 2; + int64 TTL = 3; + uint64 min_safe_point = 4; +} + message RegionStat { // Bytes read/written during this period. uint64 bytes_written = 1; diff --git a/proto/replicate_mode.proto b/proto/replicate_mode.proto deleted file mode 100644 index ab6a5fb25..000000000 --- a/proto/replicate_mode.proto +++ /dev/null @@ -1,35 +0,0 @@ -syntax = "proto3"; -package replicate_mode; - -// The replicate status sync from PD to TiKV. -message ReplicateStatus { - enum Mode { - MAJORITY = 0; // the standard mode. Replicate logs to majority peer. - DR_AUTOSYNC = 1; // DR mode. Replicate logs among 2 DCs. - } - Mode mode = 1; - DRAutoSync dr_autosync = 2; -} - -// The status of dr-autosync mode. -message DRAutoSync { - enum State { - SYNC = 0; // raft logs need to sync between different DCs - ASYNC = 1; // raft logs need to sync to majority peers - SYNC_RECOVER = 2; // switching from ASYNC to SYNC mode - } - string label_key = 1; // the key of the label that used for distinguish different DC. - State state = 2; - uint64 recover_id = 3; // Unique ID for a recovery - int32 wait_sync_timeout_hint = 4; // Duration to wait before switching to SYNC by force (in seconds) -} - -// The replicate status sync from TiKV to PD. -message RegionReplicateStatus { - enum State { - MAJORITY = 0; // Logs sync to majority peers - INTEGRITY_OVER_LABEL = 1; // Logs sync to different DCs - } - State state = 1; - uint64 recover_id = 2; // Unique ID for a recovery -} diff --git a/proto/replication_modepb.proto b/proto/replication_modepb.proto new file mode 100644 index 000000000..9bfb8814d --- /dev/null +++ b/proto/replication_modepb.proto @@ -0,0 +1,51 @@ +syntax = "proto3"; +package replication_modepb; + +enum ReplicationMode { + // The standard mode. Replicate logs to majority peer. + MAJORITY = 0; + // DR mode. Replicate logs among 2 DCs. + DR_AUTO_SYNC = 1; +} + +// The replication status sync from PD to TiKV. +message ReplicationStatus { + ReplicationMode mode = 1; + DRAutoSync dr_auto_sync = 2; +} + +enum DRAutoSyncState { + // Raft logs need to sync between different DCs + SYNC = 0; + // Raft logs need to sync to majority peers + ASYNC = 1; + // Switching from ASYNC to SYNC mode + SYNC_RECOVER = 2; +} + +// The status of dr-autosync mode. +message DRAutoSync { + // The key of the label that used for distinguish different DC. + string label_key = 1; + DRAutoSyncState state = 2; + // Unique ID of the state, it increases after each state transfer. + uint64 state_id = 3; + // Duration to wait before switching to SYNC by force (in seconds) + int32 wait_sync_timeout_hint = 4; +} + +enum RegionReplicationState { + // The region's state is unknown + UNKNOWN = 0; + // Logs sync to majority peers + SIMPLE_MAJORITY = 1; + // Logs sync to different DCs + INTEGRITY_OVER_LABEL = 2; +} + +// The replication status sync from TiKV to PD. +message RegionReplicationStatus { + RegionReplicationState state = 1; + // Unique ID of the state, it increases after each state transfer. + uint64 state_id = 2; +} diff --git a/proto/tikvpb.proto b/proto/tikvpb.proto index 798b25762..3ca0172a3 100644 --- a/proto/tikvpb.proto +++ b/proto/tikvpb.proto @@ -56,6 +56,7 @@ service Tikv { // SQL push down commands. rpc Coprocessor(coprocessor.Request) returns (coprocessor.Response) {} rpc CoprocessorStream(coprocessor.Request) returns (stream coprocessor.Response) {} + rpc BatchCoprocessor(coprocessor.BatchRequest) returns (stream coprocessor.BatchResponse) {} // Raft commands (tikv <-> tikv). rpc Raft(stream raft_serverpb.RaftMessage) returns (raft_serverpb.Done) {} diff --git a/scripts/generate_cpp.sh b/scripts/generate_cpp.sh index 9adb9f853..00ee95c6f 100755 --- a/scripts/generate_cpp.sh +++ b/scripts/generate_cpp.sh @@ -24,7 +24,7 @@ protoc -I${GRPC_INCLUDE} --grpc_out ../cpp/kvproto --plugin=protoc-gen-grpc=`whi pop push include -protoc -I${GRPC_INCLUDE} --cpp_out ../cpp/kvproto *.proto || exit $? +protoc -I${GRPC_INCLUDE} --cpp_out ../cpp/kvproto *.proto google/api/http.proto google/api/annotations.proto || exit $? pop rm -rf proto-cpp diff --git a/scripts/generate_go.sh b/scripts/generate_go.sh index f13e35974..7eedef7a1 100755 --- a/scripts/generate_go.sh +++ b/scripts/generate_go.sh @@ -48,7 +48,7 @@ ret=0 function gen() { base_name=$(basename $1 ".proto") - protoc -I.:../include -I$GOPATH/src/github.com/grpc-ecosystem/grpc-gateway/third_party/googleapis --grpc-gateway_out=logtostderr=true:../pkg/$base_name --gofast_out=plugins=grpc,$GO_OUT_M:../pkg/$base_name $1 || ret=$? + protoc -I.:../include --grpc-gateway_out=logtostderr=true:../pkg/$base_name --gofast_out=plugins=grpc,$GO_OUT_M:../pkg/$base_name $1 || ret=$? cd ../pkg/$base_name sed_inplace -E 's/import _ \"gogoproto\"//g' *.pb*.go sed_inplace -E 's/import fmt \"fmt\"//g' *.pb*.go