From 8f24d6fd17d92f2fc9fde14333701a55ca6c043d Mon Sep 17 00:00:00 2001 From: MyonKeminta Date: Sun, 28 Oct 2018 17:36:24 +0800 Subject: [PATCH 01/17] Update vendor Signed-off-by: MyonKeminta --- Gopkg.lock | 22 +- Gopkg.toml | 3 +- .../github.com/gogo/protobuf/gogoproto/doc.go | 169 + .../gogo/protobuf/gogoproto/gogo.pb.go | 817 ++++ .../gogo/protobuf/gogoproto/helper.go | 358 ++ .../protoc-gen-gogo/descriptor/descriptor.go | 118 + .../descriptor/descriptor.pb.go | 2806 ++++++++++++ .../descriptor/descriptor_gostring.gen.go | 744 ++++ .../protoc-gen-gogo/descriptor/helper.go | 390 ++ vendor/github.com/golang/protobuf/LICENSE | 3 - .../golang/protobuf/jsonpb/jsonpb.go | 60 +- .../golang/protobuf/proto/encode.go | 18 - .../github.com/golang/protobuf/proto/lib.go | 62 +- .../golang/protobuf/proto/properties.go | 16 +- .../golang/protobuf/proto/table_marshal.go | 184 +- .../golang/protobuf/proto/table_unmarshal.go | 142 +- .../github.com/golang/protobuf/proto/text.go | 4 +- .../golang/protobuf/proto/text_parser.go | 6 +- .../github.com/golang/protobuf/ptypes/any.go | 10 +- .../golang/protobuf/ptypes/any/any.pb.go | 2 +- .../protobuf/ptypes/duration/duration.pb.go | 4 +- .../protobuf/ptypes/struct/struct.pb.go | 32 +- .../protobuf/ptypes/timestamp/timestamp.pb.go | 4 +- .../kvproto/pkg/coprocessor/coprocessor.pb.go | 200 +- .../pingcap/kvproto/pkg/eraftpb/eraftpb.pb.go | 484 +- .../pingcap/kvproto/pkg/errorpb/errorpb.pb.go | 506 ++- .../pingcap/kvproto/pkg/kvrpcpb/kvrpcpb.pb.go | 3920 ++++++++++++++--- .../pingcap/kvproto/pkg/metapb/metapb.pb.go | 355 +- .../pingcap/kvproto/pkg/pdpb/pdpb.pb.go | 3747 +++++++++++++--- .../pkg/raft_serverpb/raft_serverpb.pb.go | 706 ++- .../pingcap/kvproto/pkg/tikvpb/tikvpb.pb.go | 75 +- 31 files changed, 13985 insertions(+), 1982 deletions(-) create mode 100644 vendor/github.com/gogo/protobuf/gogoproto/doc.go create mode 100644 vendor/github.com/gogo/protobuf/gogoproto/gogo.pb.go create mode 100644 vendor/github.com/gogo/protobuf/gogoproto/helper.go create mode 100644 vendor/github.com/gogo/protobuf/protoc-gen-gogo/descriptor/descriptor.go create mode 100644 vendor/github.com/gogo/protobuf/protoc-gen-gogo/descriptor/descriptor.pb.go create mode 100644 vendor/github.com/gogo/protobuf/protoc-gen-gogo/descriptor/descriptor_gostring.gen.go create mode 100644 vendor/github.com/gogo/protobuf/protoc-gen-gogo/descriptor/helper.go diff --git a/Gopkg.lock b/Gopkg.lock index cd8226d284c46..230e6994bfe06 100644 --- a/Gopkg.lock +++ b/Gopkg.lock @@ -86,15 +86,19 @@ revision = "3955978caca48c1658a4bb7a9c6a0f084e326af3" [[projects]] - digest = "1:38e684375ef5b55e812332266d63f9fc5b6329ab303067c4cdda051db6d29ca4" + digest = "1:700c0988d24fac04439828af2aab8e7d1638cea3bc91ff20d2a2befc970ff165" name = "github.com/gogo/protobuf" - packages = ["proto"] + packages = [ + "gogoproto", + "proto", + "protoc-gen-gogo/descriptor", + ] pruneopts = "NUT" revision = "636bf0302bc95575d69441b25a2603156ffdddf1" version = "v1.1.1" [[projects]] - digest = "1:6aef947ba53156da1a66ee891d70d61835e0dcfc9f0d728ae1132db651e81c22" + digest = "1:9b117ac202b9de210a7093bca0c29d0d2424e4c9235c9e025ae0d6ef6b121c82" name = "github.com/golang/protobuf" packages = [ "jsonpb", @@ -107,8 +111,8 @@ "ptypes/timestamp", ] pruneopts = "NUT" - revision = "b4deda0973fb4c70b50d226b1af49f3da59f5265" - version = "v1.1.0" + revision = "aa810b61a9c79d51363740d207bb46cf8e620ed5" + version = "v1.2.0" [[projects]] digest = "1:c6dfb6c55c1989f1d89622b3c45b786127f76f47322c50e487585f823cb12543" @@ -260,8 +264,8 @@ revision = "8d44bfdf1030639ae7130922c95df12d6d4da3b6" [[projects]] - branch = "master" - digest = "1:84db0209caf3c48beaec43d15bd22ca6256d958b807c2ac626e2425e232e92c4" + branch = "misono/add-end-key" + digest = "1:74fee443fa1ea35bae6c976bb6576940beafdb89319441a92447f5500ed0e902" name = "github.com/pingcap/kvproto" packages = [ "pkg/coprocessor", @@ -274,7 +278,8 @@ "pkg/tikvpb", ] pruneopts = "NUT" - revision = "529c652955d8fa74faf56f91b2f428d5779fd7d5" + revision = "53f20daae5e3207abf4ea41f8b4cdaa7b04e2b5a" + source = "https://github.com/MyonKeminta/kvproto" [[projects]] branch = "master" @@ -574,6 +579,7 @@ "github.com/pingcap/parser/terror", "github.com/pingcap/parser/types", "github.com/pingcap/pd/client", + "github.com/pingcap/tidb-tools/tidb-binlog/node", "github.com/pingcap/tidb-tools/tidb-binlog/pump_client", "github.com/pingcap/tipb/go-binlog", "github.com/pingcap/tipb/go-tipb", diff --git a/Gopkg.toml b/Gopkg.toml index 57a9061159479..2013c06f6444d 100644 --- a/Gopkg.toml +++ b/Gopkg.toml @@ -70,7 +70,8 @@ required = ["github.com/golang/protobuf/jsonpb"] [[constraint]] name = "github.com/pingcap/kvproto" - branch = "master" + source = "https://github.com/MyonKeminta/kvproto" + branch = "misono/add-end-key" [[constraint]] name = "gopkg.in/natefinch/lumberjack.v2" diff --git a/vendor/github.com/gogo/protobuf/gogoproto/doc.go b/vendor/github.com/gogo/protobuf/gogoproto/doc.go new file mode 100644 index 0000000000000..147b5ecc62fda --- /dev/null +++ b/vendor/github.com/gogo/protobuf/gogoproto/doc.go @@ -0,0 +1,169 @@ +// Protocol Buffers for Go with Gadgets +// +// Copyright (c) 2013, The GoGo Authors. All rights reserved. +// http://github.com/gogo/protobuf +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +/* +Package gogoproto provides extensions for protocol buffers to achieve: + + - fast marshalling and unmarshalling. + - peace of mind by optionally generating test and benchmark code. + - more canonical Go structures. + - less typing by optionally generating extra helper code. + - goprotobuf compatibility + +More Canonical Go Structures + +A lot of time working with a goprotobuf struct will lead you to a place where you create another struct that is easier to work with and then have a function to copy the values between the two structs. +You might also find that basic structs that started their life as part of an API need to be sent over the wire. With gob, you could just send it. With goprotobuf, you need to make a parallel struct. +Gogoprotobuf tries to fix these problems with the nullable, embed, customtype and customname field extensions. + + - nullable, if false, a field is generated without a pointer (see warning below). + - embed, if true, the field is generated as an embedded field. + - customtype, It works with the Marshal and Unmarshal methods, to allow you to have your own types in your struct, but marshal to bytes. For example, custom.Uuid or custom.Fixed128 + - customname (beta), Changes the generated fieldname. This is especially useful when generated methods conflict with fieldnames. + - casttype (beta), Changes the generated fieldtype. All generated code assumes that this type is castable to the protocol buffer field type. It does not work for structs or enums. + - castkey (beta), Changes the generated fieldtype for a map key. All generated code assumes that this type is castable to the protocol buffer field type. Only supported on maps. + - castvalue (beta), Changes the generated fieldtype for a map value. All generated code assumes that this type is castable to the protocol buffer field type. Only supported on maps. + +Warning about nullable: According to the Protocol Buffer specification, you should be able to tell whether a field is set or unset. With the option nullable=false this feature is lost, since your non-nullable fields will always be set. It can be seen as a layer on top of Protocol Buffers, where before and after marshalling all non-nullable fields are set and they cannot be unset. + +Let us look at: + + github.com/gogo/protobuf/test/example/example.proto + +for a quicker overview. + +The following message: + + package test; + + import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + + message A { + optional string Description = 1 [(gogoproto.nullable) = false]; + optional int64 Number = 2 [(gogoproto.nullable) = false]; + optional bytes Id = 3 [(gogoproto.customtype) = "github.com/gogo/protobuf/test/custom.Uuid", (gogoproto.nullable) = false]; + } + +Will generate a go struct which looks a lot like this: + + type A struct { + Description string + Number int64 + Id github_com_gogo_protobuf_test_custom.Uuid + } + +You will see there are no pointers, since all fields are non-nullable. +You will also see a custom type which marshals to a string. +Be warned it is your responsibility to test your custom types thoroughly. +You should think of every possible empty and nil case for your marshaling, unmarshaling and size methods. + +Next we will embed the message A in message B. + + message B { + optional A A = 1 [(gogoproto.nullable) = false, (gogoproto.embed) = true]; + repeated bytes G = 2 [(gogoproto.customtype) = "github.com/gogo/protobuf/test/custom.Uint128", (gogoproto.nullable) = false]; + } + +See below that A is embedded in B. + + type B struct { + A + G []github_com_gogo_protobuf_test_custom.Uint128 + } + +Also see the repeated custom type. + + type Uint128 [2]uint64 + +Next we will create a custom name for one of our fields. + + message C { + optional int64 size = 1 [(gogoproto.customname) = "MySize"]; + } + +See below that the field's name is MySize and not Size. + + type C struct { + MySize *int64 + } + +The is useful when having a protocol buffer message with a field name which conflicts with a generated method. +As an example, having a field name size and using the sizer plugin to generate a Size method will cause a go compiler error. +Using customname you can fix this error without changing the field name. +This is typically useful when working with a protocol buffer that was designed before these methods and/or the go language were avialable. + +Gogoprotobuf also has some more subtle changes, these could be changed back: + + - the generated package name for imports do not have the extra /filename.pb, + but are actually the imports specified in the .proto file. + +Gogoprotobuf also has lost some features which should be brought back with time: + + - Marshalling and unmarshalling with reflect and without the unsafe package, + this requires work in pointer_reflect.go + +Why does nullable break protocol buffer specifications: + +The protocol buffer specification states, somewhere, that you should be able to tell whether a +field is set or unset. With the option nullable=false this feature is lost, +since your non-nullable fields will always be set. It can be seen as a layer on top of +protocol buffers, where before and after marshalling all non-nullable fields are set +and they cannot be unset. + +Goprotobuf Compatibility: + +Gogoprotobuf is compatible with Goprotobuf, because it is compatible with protocol buffers. +Gogoprotobuf generates the same code as goprotobuf if no extensions are used. +The enumprefix, getters and stringer extensions can be used to remove some of the unnecessary code generated by goprotobuf: + + - gogoproto_import, if false, the generated code imports github.com/golang/protobuf/proto instead of github.com/gogo/protobuf/proto. + - goproto_enum_prefix, if false, generates the enum constant names without the messagetype prefix + - goproto_enum_stringer (experimental), if false, the enum is generated without the default string method, this is useful for rather using enum_stringer, or allowing you to write your own string method. + - goproto_getters, if false, the message is generated without get methods, this is useful when you would rather want to use face + - goproto_stringer, if false, the message is generated without the default string method, this is useful for rather using stringer, or allowing you to write your own string method. + - goproto_extensions_map (beta), if false, the extensions field is generated as type []byte instead of type map[int32]proto.Extension + - goproto_unrecognized (beta), if false, XXX_unrecognized field is not generated. This is useful in conjunction with gogoproto.nullable=false, to generate structures completely devoid of pointers and reduce GC pressure at the cost of losing information about unrecognized fields. + - goproto_registration (beta), if true, the generated files will register all messages and types against both gogo/protobuf and golang/protobuf. This is necessary when using third-party packages which read registrations from golang/protobuf (such as the grpc-gateway). + +Less Typing and Peace of Mind is explained in their specific plugin folders godoc: + + - github.com/gogo/protobuf/plugin/ + +If you do not use any of these extension the code that is generated +will be the same as if goprotobuf has generated it. + +The most complete way to see examples is to look at + + github.com/gogo/protobuf/test/thetest.proto + +Gogoprototest is a seperate project, +because we want to keep gogoprotobuf independant of goprotobuf, +but we still want to test it thoroughly. + +*/ +package gogoproto diff --git a/vendor/github.com/gogo/protobuf/gogoproto/gogo.pb.go b/vendor/github.com/gogo/protobuf/gogoproto/gogo.pb.go new file mode 100644 index 0000000000000..97843b2448c75 --- /dev/null +++ b/vendor/github.com/gogo/protobuf/gogoproto/gogo.pb.go @@ -0,0 +1,817 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: gogo.proto + +package gogoproto // import "github.com/gogo/protobuf/gogoproto" + +import proto "github.com/gogo/protobuf/proto" +import fmt "fmt" +import math "math" +import descriptor "github.com/gogo/protobuf/protoc-gen-gogo/descriptor" + +// 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.GoGoProtoPackageIsVersion2 // please upgrade the proto package + +var E_GoprotoEnumPrefix = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.EnumOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 62001, + Name: "gogoproto.goproto_enum_prefix", + Tag: "varint,62001,opt,name=goproto_enum_prefix,json=goprotoEnumPrefix", + Filename: "gogo.proto", +} + +var E_GoprotoEnumStringer = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.EnumOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 62021, + Name: "gogoproto.goproto_enum_stringer", + Tag: "varint,62021,opt,name=goproto_enum_stringer,json=goprotoEnumStringer", + Filename: "gogo.proto", +} + +var E_EnumStringer = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.EnumOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 62022, + Name: "gogoproto.enum_stringer", + Tag: "varint,62022,opt,name=enum_stringer,json=enumStringer", + Filename: "gogo.proto", +} + +var E_EnumCustomname = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.EnumOptions)(nil), + ExtensionType: (*string)(nil), + Field: 62023, + Name: "gogoproto.enum_customname", + Tag: "bytes,62023,opt,name=enum_customname,json=enumCustomname", + Filename: "gogo.proto", +} + +var E_Enumdecl = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.EnumOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 62024, + Name: "gogoproto.enumdecl", + Tag: "varint,62024,opt,name=enumdecl", + Filename: "gogo.proto", +} + +var E_EnumvalueCustomname = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.EnumValueOptions)(nil), + ExtensionType: (*string)(nil), + Field: 66001, + Name: "gogoproto.enumvalue_customname", + Tag: "bytes,66001,opt,name=enumvalue_customname,json=enumvalueCustomname", + Filename: "gogo.proto", +} + +var E_GoprotoGettersAll = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63001, + Name: "gogoproto.goproto_getters_all", + Tag: "varint,63001,opt,name=goproto_getters_all,json=goprotoGettersAll", + Filename: "gogo.proto", +} + +var E_GoprotoEnumPrefixAll = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63002, + Name: "gogoproto.goproto_enum_prefix_all", + Tag: "varint,63002,opt,name=goproto_enum_prefix_all,json=goprotoEnumPrefixAll", + Filename: "gogo.proto", +} + +var E_GoprotoStringerAll = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63003, + Name: "gogoproto.goproto_stringer_all", + Tag: "varint,63003,opt,name=goproto_stringer_all,json=goprotoStringerAll", + Filename: "gogo.proto", +} + +var E_VerboseEqualAll = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63004, + Name: "gogoproto.verbose_equal_all", + Tag: "varint,63004,opt,name=verbose_equal_all,json=verboseEqualAll", + Filename: "gogo.proto", +} + +var E_FaceAll = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63005, + Name: "gogoproto.face_all", + Tag: "varint,63005,opt,name=face_all,json=faceAll", + Filename: "gogo.proto", +} + +var E_GostringAll = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63006, + Name: "gogoproto.gostring_all", + Tag: "varint,63006,opt,name=gostring_all,json=gostringAll", + Filename: "gogo.proto", +} + +var E_PopulateAll = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63007, + Name: "gogoproto.populate_all", + Tag: "varint,63007,opt,name=populate_all,json=populateAll", + Filename: "gogo.proto", +} + +var E_StringerAll = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63008, + Name: "gogoproto.stringer_all", + Tag: "varint,63008,opt,name=stringer_all,json=stringerAll", + Filename: "gogo.proto", +} + +var E_OnlyoneAll = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63009, + Name: "gogoproto.onlyone_all", + Tag: "varint,63009,opt,name=onlyone_all,json=onlyoneAll", + Filename: "gogo.proto", +} + +var E_EqualAll = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63013, + Name: "gogoproto.equal_all", + Tag: "varint,63013,opt,name=equal_all,json=equalAll", + Filename: "gogo.proto", +} + +var E_DescriptionAll = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63014, + Name: "gogoproto.description_all", + Tag: "varint,63014,opt,name=description_all,json=descriptionAll", + Filename: "gogo.proto", +} + +var E_TestgenAll = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63015, + Name: "gogoproto.testgen_all", + Tag: "varint,63015,opt,name=testgen_all,json=testgenAll", + Filename: "gogo.proto", +} + +var E_BenchgenAll = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63016, + Name: "gogoproto.benchgen_all", + Tag: "varint,63016,opt,name=benchgen_all,json=benchgenAll", + Filename: "gogo.proto", +} + +var E_MarshalerAll = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63017, + Name: "gogoproto.marshaler_all", + Tag: "varint,63017,opt,name=marshaler_all,json=marshalerAll", + Filename: "gogo.proto", +} + +var E_UnmarshalerAll = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63018, + Name: "gogoproto.unmarshaler_all", + Tag: "varint,63018,opt,name=unmarshaler_all,json=unmarshalerAll", + Filename: "gogo.proto", +} + +var E_StableMarshalerAll = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63019, + Name: "gogoproto.stable_marshaler_all", + Tag: "varint,63019,opt,name=stable_marshaler_all,json=stableMarshalerAll", + Filename: "gogo.proto", +} + +var E_SizerAll = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63020, + Name: "gogoproto.sizer_all", + Tag: "varint,63020,opt,name=sizer_all,json=sizerAll", + Filename: "gogo.proto", +} + +var E_GoprotoEnumStringerAll = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63021, + Name: "gogoproto.goproto_enum_stringer_all", + Tag: "varint,63021,opt,name=goproto_enum_stringer_all,json=goprotoEnumStringerAll", + Filename: "gogo.proto", +} + +var E_EnumStringerAll = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63022, + Name: "gogoproto.enum_stringer_all", + Tag: "varint,63022,opt,name=enum_stringer_all,json=enumStringerAll", + Filename: "gogo.proto", +} + +var E_UnsafeMarshalerAll = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63023, + Name: "gogoproto.unsafe_marshaler_all", + Tag: "varint,63023,opt,name=unsafe_marshaler_all,json=unsafeMarshalerAll", + Filename: "gogo.proto", +} + +var E_UnsafeUnmarshalerAll = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63024, + Name: "gogoproto.unsafe_unmarshaler_all", + Tag: "varint,63024,opt,name=unsafe_unmarshaler_all,json=unsafeUnmarshalerAll", + Filename: "gogo.proto", +} + +var E_GoprotoExtensionsMapAll = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63025, + Name: "gogoproto.goproto_extensions_map_all", + Tag: "varint,63025,opt,name=goproto_extensions_map_all,json=goprotoExtensionsMapAll", + Filename: "gogo.proto", +} + +var E_GoprotoUnrecognizedAll = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63026, + Name: "gogoproto.goproto_unrecognized_all", + Tag: "varint,63026,opt,name=goproto_unrecognized_all,json=goprotoUnrecognizedAll", + Filename: "gogo.proto", +} + +var E_GogoprotoImport = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63027, + Name: "gogoproto.gogoproto_import", + Tag: "varint,63027,opt,name=gogoproto_import,json=gogoprotoImport", + Filename: "gogo.proto", +} + +var E_ProtosizerAll = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63028, + Name: "gogoproto.protosizer_all", + Tag: "varint,63028,opt,name=protosizer_all,json=protosizerAll", + Filename: "gogo.proto", +} + +var E_CompareAll = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63029, + Name: "gogoproto.compare_all", + Tag: "varint,63029,opt,name=compare_all,json=compareAll", + Filename: "gogo.proto", +} + +var E_TypedeclAll = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63030, + Name: "gogoproto.typedecl_all", + Tag: "varint,63030,opt,name=typedecl_all,json=typedeclAll", + Filename: "gogo.proto", +} + +var E_EnumdeclAll = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63031, + Name: "gogoproto.enumdecl_all", + Tag: "varint,63031,opt,name=enumdecl_all,json=enumdeclAll", + Filename: "gogo.proto", +} + +var E_GoprotoRegistration = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63032, + Name: "gogoproto.goproto_registration", + Tag: "varint,63032,opt,name=goproto_registration,json=goprotoRegistration", + Filename: "gogo.proto", +} + +var E_MessagenameAll = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63033, + Name: "gogoproto.messagename_all", + Tag: "varint,63033,opt,name=messagename_all,json=messagenameAll", + Filename: "gogo.proto", +} + +var E_GoprotoGetters = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.MessageOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 64001, + Name: "gogoproto.goproto_getters", + Tag: "varint,64001,opt,name=goproto_getters,json=goprotoGetters", + Filename: "gogo.proto", +} + +var E_GoprotoStringer = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.MessageOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 64003, + Name: "gogoproto.goproto_stringer", + Tag: "varint,64003,opt,name=goproto_stringer,json=goprotoStringer", + Filename: "gogo.proto", +} + +var E_VerboseEqual = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.MessageOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 64004, + Name: "gogoproto.verbose_equal", + Tag: "varint,64004,opt,name=verbose_equal,json=verboseEqual", + Filename: "gogo.proto", +} + +var E_Face = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.MessageOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 64005, + Name: "gogoproto.face", + Tag: "varint,64005,opt,name=face", + Filename: "gogo.proto", +} + +var E_Gostring = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.MessageOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 64006, + Name: "gogoproto.gostring", + Tag: "varint,64006,opt,name=gostring", + Filename: "gogo.proto", +} + +var E_Populate = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.MessageOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 64007, + Name: "gogoproto.populate", + Tag: "varint,64007,opt,name=populate", + Filename: "gogo.proto", +} + +var E_Stringer = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.MessageOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 67008, + Name: "gogoproto.stringer", + Tag: "varint,67008,opt,name=stringer", + Filename: "gogo.proto", +} + +var E_Onlyone = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.MessageOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 64009, + Name: "gogoproto.onlyone", + Tag: "varint,64009,opt,name=onlyone", + Filename: "gogo.proto", +} + +var E_Equal = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.MessageOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 64013, + Name: "gogoproto.equal", + Tag: "varint,64013,opt,name=equal", + Filename: "gogo.proto", +} + +var E_Description = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.MessageOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 64014, + Name: "gogoproto.description", + Tag: "varint,64014,opt,name=description", + Filename: "gogo.proto", +} + +var E_Testgen = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.MessageOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 64015, + Name: "gogoproto.testgen", + Tag: "varint,64015,opt,name=testgen", + Filename: "gogo.proto", +} + +var E_Benchgen = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.MessageOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 64016, + Name: "gogoproto.benchgen", + Tag: "varint,64016,opt,name=benchgen", + Filename: "gogo.proto", +} + +var E_Marshaler = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.MessageOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 64017, + Name: "gogoproto.marshaler", + Tag: "varint,64017,opt,name=marshaler", + Filename: "gogo.proto", +} + +var E_Unmarshaler = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.MessageOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 64018, + Name: "gogoproto.unmarshaler", + Tag: "varint,64018,opt,name=unmarshaler", + Filename: "gogo.proto", +} + +var E_StableMarshaler = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.MessageOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 64019, + Name: "gogoproto.stable_marshaler", + Tag: "varint,64019,opt,name=stable_marshaler,json=stableMarshaler", + Filename: "gogo.proto", +} + +var E_Sizer = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.MessageOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 64020, + Name: "gogoproto.sizer", + Tag: "varint,64020,opt,name=sizer", + Filename: "gogo.proto", +} + +var E_UnsafeMarshaler = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.MessageOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 64023, + Name: "gogoproto.unsafe_marshaler", + Tag: "varint,64023,opt,name=unsafe_marshaler,json=unsafeMarshaler", + Filename: "gogo.proto", +} + +var E_UnsafeUnmarshaler = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.MessageOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 64024, + Name: "gogoproto.unsafe_unmarshaler", + Tag: "varint,64024,opt,name=unsafe_unmarshaler,json=unsafeUnmarshaler", + Filename: "gogo.proto", +} + +var E_GoprotoExtensionsMap = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.MessageOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 64025, + Name: "gogoproto.goproto_extensions_map", + Tag: "varint,64025,opt,name=goproto_extensions_map,json=goprotoExtensionsMap", + Filename: "gogo.proto", +} + +var E_GoprotoUnrecognized = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.MessageOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 64026, + Name: "gogoproto.goproto_unrecognized", + Tag: "varint,64026,opt,name=goproto_unrecognized,json=goprotoUnrecognized", + Filename: "gogo.proto", +} + +var E_Protosizer = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.MessageOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 64028, + Name: "gogoproto.protosizer", + Tag: "varint,64028,opt,name=protosizer", + Filename: "gogo.proto", +} + +var E_Compare = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.MessageOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 64029, + Name: "gogoproto.compare", + Tag: "varint,64029,opt,name=compare", + Filename: "gogo.proto", +} + +var E_Typedecl = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.MessageOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 64030, + Name: "gogoproto.typedecl", + Tag: "varint,64030,opt,name=typedecl", + Filename: "gogo.proto", +} + +var E_Messagename = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.MessageOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 64033, + Name: "gogoproto.messagename", + Tag: "varint,64033,opt,name=messagename", + Filename: "gogo.proto", +} + +var E_Nullable = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.FieldOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 65001, + Name: "gogoproto.nullable", + Tag: "varint,65001,opt,name=nullable", + Filename: "gogo.proto", +} + +var E_Embed = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.FieldOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 65002, + Name: "gogoproto.embed", + Tag: "varint,65002,opt,name=embed", + Filename: "gogo.proto", +} + +var E_Customtype = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.FieldOptions)(nil), + ExtensionType: (*string)(nil), + Field: 65003, + Name: "gogoproto.customtype", + Tag: "bytes,65003,opt,name=customtype", + Filename: "gogo.proto", +} + +var E_Customname = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.FieldOptions)(nil), + ExtensionType: (*string)(nil), + Field: 65004, + Name: "gogoproto.customname", + Tag: "bytes,65004,opt,name=customname", + Filename: "gogo.proto", +} + +var E_Jsontag = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.FieldOptions)(nil), + ExtensionType: (*string)(nil), + Field: 65005, + Name: "gogoproto.jsontag", + Tag: "bytes,65005,opt,name=jsontag", + Filename: "gogo.proto", +} + +var E_Moretags = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.FieldOptions)(nil), + ExtensionType: (*string)(nil), + Field: 65006, + Name: "gogoproto.moretags", + Tag: "bytes,65006,opt,name=moretags", + Filename: "gogo.proto", +} + +var E_Casttype = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.FieldOptions)(nil), + ExtensionType: (*string)(nil), + Field: 65007, + Name: "gogoproto.casttype", + Tag: "bytes,65007,opt,name=casttype", + Filename: "gogo.proto", +} + +var E_Castkey = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.FieldOptions)(nil), + ExtensionType: (*string)(nil), + Field: 65008, + Name: "gogoproto.castkey", + Tag: "bytes,65008,opt,name=castkey", + Filename: "gogo.proto", +} + +var E_Castvalue = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.FieldOptions)(nil), + ExtensionType: (*string)(nil), + Field: 65009, + Name: "gogoproto.castvalue", + Tag: "bytes,65009,opt,name=castvalue", + Filename: "gogo.proto", +} + +var E_Stdtime = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.FieldOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 65010, + Name: "gogoproto.stdtime", + Tag: "varint,65010,opt,name=stdtime", + Filename: "gogo.proto", +} + +var E_Stdduration = &proto.ExtensionDesc{ + ExtendedType: (*descriptor.FieldOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 65011, + Name: "gogoproto.stdduration", + Tag: "varint,65011,opt,name=stdduration", + Filename: "gogo.proto", +} + +func init() { + proto.RegisterExtension(E_GoprotoEnumPrefix) + proto.RegisterExtension(E_GoprotoEnumStringer) + proto.RegisterExtension(E_EnumStringer) + proto.RegisterExtension(E_EnumCustomname) + proto.RegisterExtension(E_Enumdecl) + proto.RegisterExtension(E_EnumvalueCustomname) + proto.RegisterExtension(E_GoprotoGettersAll) + proto.RegisterExtension(E_GoprotoEnumPrefixAll) + proto.RegisterExtension(E_GoprotoStringerAll) + proto.RegisterExtension(E_VerboseEqualAll) + proto.RegisterExtension(E_FaceAll) + proto.RegisterExtension(E_GostringAll) + proto.RegisterExtension(E_PopulateAll) + proto.RegisterExtension(E_StringerAll) + proto.RegisterExtension(E_OnlyoneAll) + proto.RegisterExtension(E_EqualAll) + proto.RegisterExtension(E_DescriptionAll) + proto.RegisterExtension(E_TestgenAll) + proto.RegisterExtension(E_BenchgenAll) + proto.RegisterExtension(E_MarshalerAll) + proto.RegisterExtension(E_UnmarshalerAll) + proto.RegisterExtension(E_StableMarshalerAll) + proto.RegisterExtension(E_SizerAll) + proto.RegisterExtension(E_GoprotoEnumStringerAll) + proto.RegisterExtension(E_EnumStringerAll) + proto.RegisterExtension(E_UnsafeMarshalerAll) + proto.RegisterExtension(E_UnsafeUnmarshalerAll) + proto.RegisterExtension(E_GoprotoExtensionsMapAll) + proto.RegisterExtension(E_GoprotoUnrecognizedAll) + proto.RegisterExtension(E_GogoprotoImport) + proto.RegisterExtension(E_ProtosizerAll) + proto.RegisterExtension(E_CompareAll) + proto.RegisterExtension(E_TypedeclAll) + proto.RegisterExtension(E_EnumdeclAll) + proto.RegisterExtension(E_GoprotoRegistration) + proto.RegisterExtension(E_MessagenameAll) + proto.RegisterExtension(E_GoprotoGetters) + proto.RegisterExtension(E_GoprotoStringer) + proto.RegisterExtension(E_VerboseEqual) + proto.RegisterExtension(E_Face) + proto.RegisterExtension(E_Gostring) + proto.RegisterExtension(E_Populate) + proto.RegisterExtension(E_Stringer) + proto.RegisterExtension(E_Onlyone) + proto.RegisterExtension(E_Equal) + proto.RegisterExtension(E_Description) + proto.RegisterExtension(E_Testgen) + proto.RegisterExtension(E_Benchgen) + proto.RegisterExtension(E_Marshaler) + proto.RegisterExtension(E_Unmarshaler) + proto.RegisterExtension(E_StableMarshaler) + proto.RegisterExtension(E_Sizer) + proto.RegisterExtension(E_UnsafeMarshaler) + proto.RegisterExtension(E_UnsafeUnmarshaler) + proto.RegisterExtension(E_GoprotoExtensionsMap) + proto.RegisterExtension(E_GoprotoUnrecognized) + proto.RegisterExtension(E_Protosizer) + proto.RegisterExtension(E_Compare) + proto.RegisterExtension(E_Typedecl) + proto.RegisterExtension(E_Messagename) + proto.RegisterExtension(E_Nullable) + proto.RegisterExtension(E_Embed) + proto.RegisterExtension(E_Customtype) + proto.RegisterExtension(E_Customname) + proto.RegisterExtension(E_Jsontag) + proto.RegisterExtension(E_Moretags) + proto.RegisterExtension(E_Casttype) + proto.RegisterExtension(E_Castkey) + proto.RegisterExtension(E_Castvalue) + proto.RegisterExtension(E_Stdtime) + proto.RegisterExtension(E_Stdduration) +} + +func init() { proto.RegisterFile("gogo.proto", fileDescriptor_gogo_68790841c0f79064) } + +var fileDescriptor_gogo_68790841c0f79064 = []byte{ + // 1246 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x98, 0x49, 0x6f, 0x1c, 0x45, + 0x14, 0x80, 0x85, 0x70, 0x64, 0xcf, 0xf3, 0x86, 0xc7, 0xc6, 0x84, 0x08, 0x44, 0xe0, 0xc4, 0xc9, + 0x3e, 0x45, 0x28, 0x65, 0x45, 0x96, 0x63, 0x39, 0x56, 0x10, 0x06, 0x63, 0xe2, 0xb0, 0x1d, 0x46, + 0x3d, 0x33, 0xe5, 0x76, 0x43, 0x77, 0xd7, 0xd0, 0x5d, 0x1d, 0xc5, 0xb9, 0xa1, 0xb0, 0x08, 0x21, + 0x76, 0x24, 0x48, 0x48, 0x02, 0x39, 0xb0, 0xaf, 0x61, 0xe7, 0xc6, 0x85, 0xe5, 0xca, 0x7f, 0xe0, + 0x02, 0x98, 0xdd, 0x37, 0x5f, 0xa2, 0xd7, 0xfd, 0x5e, 0x4f, 0xcd, 0x78, 0xa4, 0xaa, 0xb9, 0xb5, + 0xed, 0xfa, 0x3e, 0x57, 0xbf, 0x57, 0xf5, 0xde, 0x9b, 0x01, 0xf0, 0x95, 0xaf, 0x66, 0x5a, 0x89, + 0xd2, 0xaa, 0x5a, 0xc1, 0xe7, 0xfc, 0xf1, 0xc0, 0x41, 0x5f, 0x29, 0x3f, 0x94, 0xb3, 0xf9, 0x4f, + 0xf5, 0x6c, 0x63, 0xb6, 0x29, 0xd3, 0x46, 0x12, 0xb4, 0xb4, 0x4a, 0x8a, 0xc5, 0xe2, 0x6e, 0x98, + 0xa4, 0xc5, 0x35, 0x19, 0x67, 0x51, 0xad, 0x95, 0xc8, 0x8d, 0xe0, 0x74, 0xf5, 0xa6, 0x99, 0x82, + 0x9c, 0x61, 0x72, 0x66, 0x29, 0xce, 0xa2, 0x7b, 0x5a, 0x3a, 0x50, 0x71, 0xba, 0xff, 0xca, 0xaf, + 0xd7, 0x1e, 0xbc, 0xe6, 0xf6, 0xa1, 0xb5, 0x09, 0x42, 0xf1, 0x6f, 0xab, 0x39, 0x28, 0xd6, 0xe0, + 0xfa, 0x0e, 0x5f, 0xaa, 0x93, 0x20, 0xf6, 0x65, 0x62, 0x31, 0xfe, 0x40, 0xc6, 0x49, 0xc3, 0x78, + 0x1f, 0xa1, 0x62, 0x11, 0x46, 0xfb, 0x71, 0xfd, 0x48, 0xae, 0x11, 0x69, 0x4a, 0x96, 0x61, 0x3c, + 0x97, 0x34, 0xb2, 0x54, 0xab, 0x28, 0xf6, 0x22, 0x69, 0xd1, 0xfc, 0x94, 0x6b, 0x2a, 0x6b, 0x63, + 0x88, 0x2d, 0x96, 0x94, 0x10, 0x30, 0x84, 0xbf, 0x69, 0xca, 0x46, 0x68, 0x31, 0xfc, 0x4c, 0x1b, + 0x29, 0xd7, 0x8b, 0x93, 0x30, 0x85, 0xcf, 0xa7, 0xbc, 0x30, 0x93, 0xe6, 0x4e, 0x6e, 0xed, 0xe9, + 0x39, 0x89, 0xcb, 0x58, 0xf6, 0xcb, 0xd9, 0x81, 0x7c, 0x3b, 0x93, 0xa5, 0xc0, 0xd8, 0x93, 0x91, + 0x45, 0x5f, 0x6a, 0x2d, 0x93, 0xb4, 0xe6, 0x85, 0xbd, 0xb6, 0x77, 0x2c, 0x08, 0x4b, 0xe3, 0xb9, + 0xed, 0xce, 0x2c, 0x2e, 0x17, 0xe4, 0x42, 0x18, 0x8a, 0x75, 0xb8, 0xa1, 0xc7, 0xa9, 0x70, 0x70, + 0x9e, 0x27, 0xe7, 0xd4, 0x9e, 0x93, 0x81, 0xda, 0x55, 0xe0, 0xdf, 0x97, 0xb9, 0x74, 0x70, 0xbe, + 0x41, 0xce, 0x2a, 0xb1, 0x9c, 0x52, 0x34, 0xde, 0x09, 0x13, 0xa7, 0x64, 0x52, 0x57, 0xa9, 0xac, + 0xc9, 0xc7, 0x32, 0x2f, 0x74, 0xd0, 0x5d, 0x20, 0xdd, 0x38, 0x81, 0x4b, 0xc8, 0xa1, 0xeb, 0x30, + 0x0c, 0x6d, 0x78, 0x0d, 0xe9, 0xa0, 0xb8, 0x48, 0x8a, 0x41, 0x5c, 0x8f, 0xe8, 0x02, 0x8c, 0xf8, + 0xaa, 0x78, 0x25, 0x07, 0xfc, 0x12, 0xe1, 0xc3, 0xcc, 0x90, 0xa2, 0xa5, 0x5a, 0x59, 0xe8, 0x69, + 0x97, 0x1d, 0xbc, 0xc9, 0x0a, 0x66, 0x48, 0xd1, 0x47, 0x58, 0xdf, 0x62, 0x45, 0x6a, 0xc4, 0x73, + 0x1e, 0x86, 0x55, 0x1c, 0x6e, 0xa9, 0xd8, 0x65, 0x13, 0x97, 0xc9, 0x00, 0x84, 0xa0, 0x60, 0x0e, + 0x2a, 0xae, 0x89, 0x78, 0x7b, 0x9b, 0xaf, 0x07, 0x67, 0x60, 0x19, 0xc6, 0xb9, 0x40, 0x05, 0x2a, + 0x76, 0x50, 0xbc, 0x43, 0x8a, 0x31, 0x03, 0xa3, 0xd7, 0xd0, 0x32, 0xd5, 0xbe, 0x74, 0x91, 0xbc, + 0xcb, 0xaf, 0x41, 0x08, 0x85, 0xb2, 0x2e, 0xe3, 0xc6, 0xa6, 0x9b, 0xe1, 0x3d, 0x0e, 0x25, 0x33, + 0xa8, 0x58, 0x84, 0xd1, 0xc8, 0x4b, 0xd2, 0x4d, 0x2f, 0x74, 0x4a, 0xc7, 0xfb, 0xe4, 0x18, 0x29, + 0x21, 0x8a, 0x48, 0x16, 0xf7, 0xa3, 0xf9, 0x80, 0x23, 0x62, 0x60, 0x74, 0xf5, 0x52, 0xed, 0xd5, + 0x43, 0x59, 0xeb, 0xc7, 0xf6, 0x21, 0x5f, 0xbd, 0x82, 0x5d, 0x31, 0x8d, 0x73, 0x50, 0x49, 0x83, + 0x33, 0x4e, 0x9a, 0x8f, 0x38, 0xd3, 0x39, 0x80, 0xf0, 0x83, 0x70, 0x63, 0xcf, 0x36, 0xe1, 0x20, + 0xfb, 0x98, 0x64, 0xd3, 0x3d, 0x5a, 0x05, 0x95, 0x84, 0x7e, 0x95, 0x9f, 0x70, 0x49, 0x90, 0x5d, + 0xae, 0x55, 0x98, 0xca, 0xe2, 0xd4, 0xdb, 0xe8, 0x2f, 0x6a, 0x9f, 0x72, 0xd4, 0x0a, 0xb6, 0x23, + 0x6a, 0x27, 0x60, 0x9a, 0x8c, 0xfd, 0xe5, 0xf5, 0x33, 0x2e, 0xac, 0x05, 0xbd, 0xde, 0x99, 0xdd, + 0x87, 0xe1, 0x40, 0x19, 0xce, 0xd3, 0x5a, 0xc6, 0x29, 0x32, 0xb5, 0xc8, 0x6b, 0x39, 0x98, 0xaf, + 0x90, 0x99, 0x2b, 0xfe, 0x52, 0x29, 0x58, 0xf1, 0x5a, 0x28, 0x7f, 0x00, 0xf6, 0xb3, 0x3c, 0x8b, + 0x13, 0xd9, 0x50, 0x7e, 0x1c, 0x9c, 0x91, 0x4d, 0x07, 0xf5, 0xe7, 0x5d, 0xa9, 0x5a, 0x37, 0x70, + 0x34, 0x1f, 0x87, 0xeb, 0xca, 0x59, 0xa5, 0x16, 0x44, 0x2d, 0x95, 0x68, 0x8b, 0xf1, 0x0b, 0xce, + 0x54, 0xc9, 0x1d, 0xcf, 0x31, 0xb1, 0x04, 0x63, 0xf9, 0x8f, 0xae, 0x47, 0xf2, 0x4b, 0x12, 0x8d, + 0xb6, 0x29, 0x2a, 0x1c, 0x0d, 0x15, 0xb5, 0xbc, 0xc4, 0xa5, 0xfe, 0x7d, 0xc5, 0x85, 0x83, 0x10, + 0x2a, 0x1c, 0x7a, 0xab, 0x25, 0xb1, 0xdb, 0x3b, 0x18, 0xbe, 0xe6, 0xc2, 0xc1, 0x0c, 0x29, 0x78, + 0x60, 0x70, 0x50, 0x7c, 0xc3, 0x0a, 0x66, 0x50, 0x71, 0x6f, 0xbb, 0xd1, 0x26, 0xd2, 0x0f, 0x52, + 0x9d, 0x78, 0xb8, 0xda, 0xa2, 0xfa, 0x76, 0xbb, 0x73, 0x08, 0x5b, 0x33, 0x50, 0xac, 0x44, 0x91, + 0x4c, 0x53, 0xcf, 0x97, 0x38, 0x71, 0x38, 0x6c, 0xec, 0x3b, 0xae, 0x44, 0x06, 0x56, 0xdc, 0xcf, + 0xf1, 0xae, 0x59, 0xa5, 0x7a, 0xcb, 0x1e, 0xd1, 0x4a, 0xc1, 0xb0, 0xeb, 0xf1, 0x1d, 0x72, 0x75, + 0x8e, 0x2a, 0xe2, 0x2e, 0x3c, 0x40, 0x9d, 0x03, 0x85, 0x5d, 0x76, 0x76, 0xa7, 0x3c, 0x43, 0x1d, + 0xf3, 0x84, 0x38, 0x06, 0xa3, 0x1d, 0xc3, 0x84, 0x5d, 0xf5, 0x04, 0xa9, 0x46, 0xcc, 0x59, 0x42, + 0x1c, 0x82, 0x01, 0x1c, 0x0c, 0xec, 0xf8, 0x93, 0x84, 0xe7, 0xcb, 0xc5, 0x11, 0x18, 0xe2, 0x81, + 0xc0, 0x8e, 0x3e, 0x45, 0x68, 0x89, 0x20, 0xce, 0xc3, 0x80, 0x1d, 0x7f, 0x9a, 0x71, 0x46, 0x10, + 0x77, 0x0f, 0xe1, 0xf7, 0xcf, 0x0e, 0x50, 0x41, 0xe7, 0xd8, 0xcd, 0xc1, 0x20, 0x4d, 0x01, 0x76, + 0xfa, 0x19, 0xfa, 0xe7, 0x4c, 0x88, 0x3b, 0x60, 0x9f, 0x63, 0xc0, 0x9f, 0x23, 0xb4, 0x58, 0x2f, + 0x16, 0x61, 0xd8, 0xe8, 0xfc, 0x76, 0xfc, 0x79, 0xc2, 0x4d, 0x0a, 0xb7, 0x4e, 0x9d, 0xdf, 0x2e, + 0x78, 0x81, 0xb7, 0x4e, 0x04, 0x86, 0x8d, 0x9b, 0xbe, 0x9d, 0x7e, 0x91, 0xa3, 0xce, 0x88, 0x98, + 0x87, 0x4a, 0x59, 0xc8, 0xed, 0xfc, 0x4b, 0xc4, 0xb7, 0x19, 0x8c, 0x80, 0xd1, 0x48, 0xec, 0x8a, + 0x97, 0x39, 0x02, 0x06, 0x85, 0xd7, 0xa8, 0x7b, 0x38, 0xb0, 0x9b, 0x5e, 0xe1, 0x6b, 0xd4, 0x35, + 0x1b, 0x60, 0x36, 0xf3, 0x7a, 0x6a, 0x57, 0xbc, 0xca, 0xd9, 0xcc, 0xd7, 0xe3, 0x36, 0xba, 0xbb, + 0xad, 0xdd, 0xf1, 0x1a, 0x6f, 0xa3, 0xab, 0xd9, 0x8a, 0x55, 0xa8, 0xee, 0xed, 0xb4, 0x76, 0xdf, + 0xeb, 0xe4, 0x9b, 0xd8, 0xd3, 0x68, 0xc5, 0xfd, 0x30, 0xdd, 0xbb, 0xcb, 0xda, 0xad, 0xe7, 0x76, + 0xba, 0x3e, 0x17, 0x99, 0x4d, 0x56, 0x9c, 0x68, 0x97, 0x6b, 0xb3, 0xc3, 0xda, 0xb5, 0xe7, 0x77, + 0x3a, 0x2b, 0xb6, 0xd9, 0x60, 0xc5, 0x02, 0x40, 0xbb, 0xb9, 0xd9, 0x5d, 0x17, 0xc8, 0x65, 0x40, + 0x78, 0x35, 0xa8, 0xb7, 0xd9, 0xf9, 0x8b, 0x7c, 0x35, 0x88, 0xc0, 0xab, 0xc1, 0x6d, 0xcd, 0x4e, + 0x5f, 0xe2, 0xab, 0xc1, 0x08, 0x9e, 0x6c, 0xa3, 0x73, 0xd8, 0x0d, 0x97, 0xf9, 0x64, 0x1b, 0x94, + 0x98, 0x83, 0xa1, 0x38, 0x0b, 0x43, 0x3c, 0xa0, 0xd5, 0x9b, 0x7b, 0xb4, 0x2b, 0x19, 0x36, 0x99, + 0xff, 0x6d, 0x97, 0x76, 0xc0, 0x80, 0x38, 0x04, 0xfb, 0x64, 0x54, 0x97, 0x4d, 0x1b, 0xf9, 0xfb, + 0x2e, 0x17, 0x25, 0x5c, 0x2d, 0xe6, 0x01, 0x8a, 0x8f, 0xf6, 0xf8, 0x2a, 0x36, 0xf6, 0x8f, 0xdd, + 0xe2, 0x5b, 0x06, 0x03, 0x69, 0x0b, 0xf2, 0x17, 0xb7, 0x08, 0xb6, 0x3b, 0x05, 0xf9, 0x5b, 0x1f, + 0x86, 0xc1, 0x47, 0x52, 0x15, 0x6b, 0xcf, 0xb7, 0xd1, 0x7f, 0x12, 0xcd, 0xeb, 0x31, 0x60, 0x91, + 0x4a, 0xa4, 0xf6, 0xfc, 0xd4, 0xc6, 0xfe, 0x45, 0x6c, 0x09, 0x20, 0xdc, 0xf0, 0x52, 0xed, 0xf2, + 0xde, 0x7f, 0x33, 0xcc, 0x00, 0x6e, 0x1a, 0x9f, 0x1f, 0x95, 0x5b, 0x36, 0xf6, 0x1f, 0xde, 0x34, + 0xad, 0x17, 0x47, 0xa0, 0x82, 0x8f, 0xf9, 0xb7, 0x22, 0x36, 0xf8, 0x5f, 0x82, 0xdb, 0x04, 0xfe, + 0xe7, 0x54, 0x37, 0x75, 0x60, 0x0f, 0xf6, 0x7f, 0x94, 0x69, 0x5e, 0x2f, 0x16, 0x60, 0x38, 0xd5, + 0xcd, 0x66, 0x46, 0xf3, 0x95, 0x05, 0xff, 0x7f, 0xb7, 0xfc, 0xc8, 0x5d, 0x32, 0x47, 0x97, 0x60, + 0xb2, 0xa1, 0xa2, 0x6e, 0xf0, 0x28, 0x2c, 0xab, 0x65, 0xb5, 0x9a, 0x5f, 0xc5, 0x87, 0x6e, 0xf3, + 0x03, 0xbd, 0x99, 0xd5, 0x67, 0x1a, 0x2a, 0x9a, 0xc5, 0xc1, 0xb7, 0xfd, 0x7d, 0x5e, 0x39, 0x06, + 0x5f, 0x0d, 0x00, 0x00, 0xff, 0xff, 0x51, 0xf0, 0xa5, 0x95, 0x02, 0x14, 0x00, 0x00, +} diff --git a/vendor/github.com/gogo/protobuf/gogoproto/helper.go b/vendor/github.com/gogo/protobuf/gogoproto/helper.go new file mode 100644 index 0000000000000..22910c6d4f1a9 --- /dev/null +++ b/vendor/github.com/gogo/protobuf/gogoproto/helper.go @@ -0,0 +1,358 @@ +// Protocol Buffers for Go with Gadgets +// +// Copyright (c) 2013, The GoGo Authors. All rights reserved. +// http://github.com/gogo/protobuf +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +package gogoproto + +import google_protobuf "github.com/gogo/protobuf/protoc-gen-gogo/descriptor" +import proto "github.com/gogo/protobuf/proto" + +func IsEmbed(field *google_protobuf.FieldDescriptorProto) bool { + return proto.GetBoolExtension(field.Options, E_Embed, false) +} + +func IsNullable(field *google_protobuf.FieldDescriptorProto) bool { + return proto.GetBoolExtension(field.Options, E_Nullable, true) +} + +func IsStdTime(field *google_protobuf.FieldDescriptorProto) bool { + return proto.GetBoolExtension(field.Options, E_Stdtime, false) +} + +func IsStdDuration(field *google_protobuf.FieldDescriptorProto) bool { + return proto.GetBoolExtension(field.Options, E_Stdduration, false) +} + +func NeedsNilCheck(proto3 bool, field *google_protobuf.FieldDescriptorProto) bool { + nullable := IsNullable(field) + if field.IsMessage() || IsCustomType(field) { + return nullable + } + if proto3 { + return false + } + return nullable || *field.Type == google_protobuf.FieldDescriptorProto_TYPE_BYTES +} + +func IsCustomType(field *google_protobuf.FieldDescriptorProto) bool { + typ := GetCustomType(field) + if len(typ) > 0 { + return true + } + return false +} + +func IsCastType(field *google_protobuf.FieldDescriptorProto) bool { + typ := GetCastType(field) + if len(typ) > 0 { + return true + } + return false +} + +func IsCastKey(field *google_protobuf.FieldDescriptorProto) bool { + typ := GetCastKey(field) + if len(typ) > 0 { + return true + } + return false +} + +func IsCastValue(field *google_protobuf.FieldDescriptorProto) bool { + typ := GetCastValue(field) + if len(typ) > 0 { + return true + } + return false +} + +func HasEnumDecl(file *google_protobuf.FileDescriptorProto, enum *google_protobuf.EnumDescriptorProto) bool { + return proto.GetBoolExtension(enum.Options, E_Enumdecl, proto.GetBoolExtension(file.Options, E_EnumdeclAll, true)) +} + +func HasTypeDecl(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool { + return proto.GetBoolExtension(message.Options, E_Typedecl, proto.GetBoolExtension(file.Options, E_TypedeclAll, true)) +} + +func GetCustomType(field *google_protobuf.FieldDescriptorProto) string { + if field == nil { + return "" + } + if field.Options != nil { + v, err := proto.GetExtension(field.Options, E_Customtype) + if err == nil && v.(*string) != nil { + return *(v.(*string)) + } + } + return "" +} + +func GetCastType(field *google_protobuf.FieldDescriptorProto) string { + if field == nil { + return "" + } + if field.Options != nil { + v, err := proto.GetExtension(field.Options, E_Casttype) + if err == nil && v.(*string) != nil { + return *(v.(*string)) + } + } + return "" +} + +func GetCastKey(field *google_protobuf.FieldDescriptorProto) string { + if field == nil { + return "" + } + if field.Options != nil { + v, err := proto.GetExtension(field.Options, E_Castkey) + if err == nil && v.(*string) != nil { + return *(v.(*string)) + } + } + return "" +} + +func GetCastValue(field *google_protobuf.FieldDescriptorProto) string { + if field == nil { + return "" + } + if field.Options != nil { + v, err := proto.GetExtension(field.Options, E_Castvalue) + if err == nil && v.(*string) != nil { + return *(v.(*string)) + } + } + return "" +} + +func IsCustomName(field *google_protobuf.FieldDescriptorProto) bool { + name := GetCustomName(field) + if len(name) > 0 { + return true + } + return false +} + +func IsEnumCustomName(field *google_protobuf.EnumDescriptorProto) bool { + name := GetEnumCustomName(field) + if len(name) > 0 { + return true + } + return false +} + +func IsEnumValueCustomName(field *google_protobuf.EnumValueDescriptorProto) bool { + name := GetEnumValueCustomName(field) + if len(name) > 0 { + return true + } + return false +} + +func GetCustomName(field *google_protobuf.FieldDescriptorProto) string { + if field == nil { + return "" + } + if field.Options != nil { + v, err := proto.GetExtension(field.Options, E_Customname) + if err == nil && v.(*string) != nil { + return *(v.(*string)) + } + } + return "" +} + +func GetEnumCustomName(field *google_protobuf.EnumDescriptorProto) string { + if field == nil { + return "" + } + if field.Options != nil { + v, err := proto.GetExtension(field.Options, E_EnumCustomname) + if err == nil && v.(*string) != nil { + return *(v.(*string)) + } + } + return "" +} + +func GetEnumValueCustomName(field *google_protobuf.EnumValueDescriptorProto) string { + if field == nil { + return "" + } + if field.Options != nil { + v, err := proto.GetExtension(field.Options, E_EnumvalueCustomname) + if err == nil && v.(*string) != nil { + return *(v.(*string)) + } + } + return "" +} + +func GetJsonTag(field *google_protobuf.FieldDescriptorProto) *string { + if field == nil { + return nil + } + if field.Options != nil { + v, err := proto.GetExtension(field.Options, E_Jsontag) + if err == nil && v.(*string) != nil { + return (v.(*string)) + } + } + return nil +} + +func GetMoreTags(field *google_protobuf.FieldDescriptorProto) *string { + if field == nil { + return nil + } + if field.Options != nil { + v, err := proto.GetExtension(field.Options, E_Moretags) + if err == nil && v.(*string) != nil { + return (v.(*string)) + } + } + return nil +} + +type EnableFunc func(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool + +func EnabledGoEnumPrefix(file *google_protobuf.FileDescriptorProto, enum *google_protobuf.EnumDescriptorProto) bool { + return proto.GetBoolExtension(enum.Options, E_GoprotoEnumPrefix, proto.GetBoolExtension(file.Options, E_GoprotoEnumPrefixAll, true)) +} + +func EnabledGoStringer(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool { + return proto.GetBoolExtension(message.Options, E_GoprotoStringer, proto.GetBoolExtension(file.Options, E_GoprotoStringerAll, true)) +} + +func HasGoGetters(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool { + return proto.GetBoolExtension(message.Options, E_GoprotoGetters, proto.GetBoolExtension(file.Options, E_GoprotoGettersAll, true)) +} + +func IsUnion(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool { + return proto.GetBoolExtension(message.Options, E_Onlyone, proto.GetBoolExtension(file.Options, E_OnlyoneAll, false)) +} + +func HasGoString(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool { + return proto.GetBoolExtension(message.Options, E_Gostring, proto.GetBoolExtension(file.Options, E_GostringAll, false)) +} + +func HasEqual(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool { + return proto.GetBoolExtension(message.Options, E_Equal, proto.GetBoolExtension(file.Options, E_EqualAll, false)) +} + +func HasVerboseEqual(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool { + return proto.GetBoolExtension(message.Options, E_VerboseEqual, proto.GetBoolExtension(file.Options, E_VerboseEqualAll, false)) +} + +func IsStringer(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool { + return proto.GetBoolExtension(message.Options, E_Stringer, proto.GetBoolExtension(file.Options, E_StringerAll, false)) +} + +func IsFace(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool { + return proto.GetBoolExtension(message.Options, E_Face, proto.GetBoolExtension(file.Options, E_FaceAll, false)) +} + +func HasDescription(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool { + return proto.GetBoolExtension(message.Options, E_Description, proto.GetBoolExtension(file.Options, E_DescriptionAll, false)) +} + +func HasPopulate(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool { + return proto.GetBoolExtension(message.Options, E_Populate, proto.GetBoolExtension(file.Options, E_PopulateAll, false)) +} + +func HasTestGen(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool { + return proto.GetBoolExtension(message.Options, E_Testgen, proto.GetBoolExtension(file.Options, E_TestgenAll, false)) +} + +func HasBenchGen(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool { + return proto.GetBoolExtension(message.Options, E_Benchgen, proto.GetBoolExtension(file.Options, E_BenchgenAll, false)) +} + +func IsMarshaler(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool { + return proto.GetBoolExtension(message.Options, E_Marshaler, proto.GetBoolExtension(file.Options, E_MarshalerAll, false)) +} + +func IsUnmarshaler(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool { + return proto.GetBoolExtension(message.Options, E_Unmarshaler, proto.GetBoolExtension(file.Options, E_UnmarshalerAll, false)) +} + +func IsStableMarshaler(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool { + return proto.GetBoolExtension(message.Options, E_StableMarshaler, proto.GetBoolExtension(file.Options, E_StableMarshalerAll, false)) +} + +func IsSizer(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool { + return proto.GetBoolExtension(message.Options, E_Sizer, proto.GetBoolExtension(file.Options, E_SizerAll, false)) +} + +func IsProtoSizer(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool { + return proto.GetBoolExtension(message.Options, E_Protosizer, proto.GetBoolExtension(file.Options, E_ProtosizerAll, false)) +} + +func IsGoEnumStringer(file *google_protobuf.FileDescriptorProto, enum *google_protobuf.EnumDescriptorProto) bool { + return proto.GetBoolExtension(enum.Options, E_GoprotoEnumStringer, proto.GetBoolExtension(file.Options, E_GoprotoEnumStringerAll, true)) +} + +func IsEnumStringer(file *google_protobuf.FileDescriptorProto, enum *google_protobuf.EnumDescriptorProto) bool { + return proto.GetBoolExtension(enum.Options, E_EnumStringer, proto.GetBoolExtension(file.Options, E_EnumStringerAll, false)) +} + +func IsUnsafeMarshaler(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool { + return proto.GetBoolExtension(message.Options, E_UnsafeMarshaler, proto.GetBoolExtension(file.Options, E_UnsafeMarshalerAll, false)) +} + +func IsUnsafeUnmarshaler(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool { + return proto.GetBoolExtension(message.Options, E_UnsafeUnmarshaler, proto.GetBoolExtension(file.Options, E_UnsafeUnmarshalerAll, false)) +} + +func HasExtensionsMap(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool { + return proto.GetBoolExtension(message.Options, E_GoprotoExtensionsMap, proto.GetBoolExtension(file.Options, E_GoprotoExtensionsMapAll, true)) +} + +func HasUnrecognized(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool { + return proto.GetBoolExtension(message.Options, E_GoprotoUnrecognized, proto.GetBoolExtension(file.Options, E_GoprotoUnrecognizedAll, true)) +} + +func IsProto3(file *google_protobuf.FileDescriptorProto) bool { + return file.GetSyntax() == "proto3" +} + +func ImportsGoGoProto(file *google_protobuf.FileDescriptorProto) bool { + return proto.GetBoolExtension(file.Options, E_GogoprotoImport, true) +} + +func HasCompare(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool { + return proto.GetBoolExtension(message.Options, E_Compare, proto.GetBoolExtension(file.Options, E_CompareAll, false)) +} + +func RegistersGolangProto(file *google_protobuf.FileDescriptorProto) bool { + return proto.GetBoolExtension(file.Options, E_GoprotoRegistration, false) +} + +func HasMessageName(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool { + return proto.GetBoolExtension(message.Options, E_Messagename, proto.GetBoolExtension(file.Options, E_MessagenameAll, false)) +} diff --git a/vendor/github.com/gogo/protobuf/protoc-gen-gogo/descriptor/descriptor.go b/vendor/github.com/gogo/protobuf/protoc-gen-gogo/descriptor/descriptor.go new file mode 100644 index 0000000000000..a85bf1984c646 --- /dev/null +++ b/vendor/github.com/gogo/protobuf/protoc-gen-gogo/descriptor/descriptor.go @@ -0,0 +1,118 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2016 The Go Authors. All rights reserved. +// https://github.com/golang/protobuf +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Package descriptor provides functions for obtaining protocol buffer +// descriptors for generated Go types. +// +// These functions cannot go in package proto because they depend on the +// generated protobuf descriptor messages, which themselves depend on proto. +package descriptor + +import ( + "bytes" + "compress/gzip" + "fmt" + "io/ioutil" + + "github.com/gogo/protobuf/proto" +) + +// extractFile extracts a FileDescriptorProto from a gzip'd buffer. +func extractFile(gz []byte) (*FileDescriptorProto, error) { + r, err := gzip.NewReader(bytes.NewReader(gz)) + if err != nil { + return nil, fmt.Errorf("failed to open gzip reader: %v", err) + } + defer r.Close() + + b, err := ioutil.ReadAll(r) + if err != nil { + return nil, fmt.Errorf("failed to uncompress descriptor: %v", err) + } + + fd := new(FileDescriptorProto) + if err := proto.Unmarshal(b, fd); err != nil { + return nil, fmt.Errorf("malformed FileDescriptorProto: %v", err) + } + + return fd, nil +} + +// Message is a proto.Message with a method to return its descriptor. +// +// Message types generated by the protocol compiler always satisfy +// the Message interface. +type Message interface { + proto.Message + Descriptor() ([]byte, []int) +} + +// ForMessage returns a FileDescriptorProto and a DescriptorProto from within it +// describing the given message. +func ForMessage(msg Message) (fd *FileDescriptorProto, md *DescriptorProto) { + gz, path := msg.Descriptor() + fd, err := extractFile(gz) + if err != nil { + panic(fmt.Sprintf("invalid FileDescriptorProto for %T: %v", msg, err)) + } + + md = fd.MessageType[path[0]] + for _, i := range path[1:] { + md = md.NestedType[i] + } + return fd, md +} + +// Is this field a scalar numeric type? +func (field *FieldDescriptorProto) IsScalar() bool { + if field.Type == nil { + return false + } + switch *field.Type { + case FieldDescriptorProto_TYPE_DOUBLE, + FieldDescriptorProto_TYPE_FLOAT, + FieldDescriptorProto_TYPE_INT64, + FieldDescriptorProto_TYPE_UINT64, + FieldDescriptorProto_TYPE_INT32, + FieldDescriptorProto_TYPE_FIXED64, + FieldDescriptorProto_TYPE_FIXED32, + FieldDescriptorProto_TYPE_BOOL, + FieldDescriptorProto_TYPE_UINT32, + FieldDescriptorProto_TYPE_ENUM, + FieldDescriptorProto_TYPE_SFIXED32, + FieldDescriptorProto_TYPE_SFIXED64, + FieldDescriptorProto_TYPE_SINT32, + FieldDescriptorProto_TYPE_SINT64: + return true + default: + return false + } +} diff --git a/vendor/github.com/gogo/protobuf/protoc-gen-gogo/descriptor/descriptor.pb.go b/vendor/github.com/gogo/protobuf/protoc-gen-gogo/descriptor/descriptor.pb.go new file mode 100644 index 0000000000000..44f893b777c4b --- /dev/null +++ b/vendor/github.com/gogo/protobuf/protoc-gen-gogo/descriptor/descriptor.pb.go @@ -0,0 +1,2806 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: descriptor.proto + +package descriptor + +import proto "github.com/gogo/protobuf/proto" +import fmt "fmt" +import math "math" + +// 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.GoGoProtoPackageIsVersion2 // please upgrade the proto package + +type FieldDescriptorProto_Type int32 + +const ( + // 0 is reserved for errors. + // Order is weird for historical reasons. + FieldDescriptorProto_TYPE_DOUBLE FieldDescriptorProto_Type = 1 + FieldDescriptorProto_TYPE_FLOAT FieldDescriptorProto_Type = 2 + // Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT64 if + // negative values are likely. + FieldDescriptorProto_TYPE_INT64 FieldDescriptorProto_Type = 3 + FieldDescriptorProto_TYPE_UINT64 FieldDescriptorProto_Type = 4 + // Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT32 if + // negative values are likely. + FieldDescriptorProto_TYPE_INT32 FieldDescriptorProto_Type = 5 + FieldDescriptorProto_TYPE_FIXED64 FieldDescriptorProto_Type = 6 + FieldDescriptorProto_TYPE_FIXED32 FieldDescriptorProto_Type = 7 + FieldDescriptorProto_TYPE_BOOL FieldDescriptorProto_Type = 8 + FieldDescriptorProto_TYPE_STRING FieldDescriptorProto_Type = 9 + // Tag-delimited aggregate. + // Group type is deprecated and not supported in proto3. However, Proto3 + // implementations should still be able to parse the group wire format and + // treat group fields as unknown fields. + FieldDescriptorProto_TYPE_GROUP FieldDescriptorProto_Type = 10 + FieldDescriptorProto_TYPE_MESSAGE FieldDescriptorProto_Type = 11 + // New in version 2. + FieldDescriptorProto_TYPE_BYTES FieldDescriptorProto_Type = 12 + FieldDescriptorProto_TYPE_UINT32 FieldDescriptorProto_Type = 13 + FieldDescriptorProto_TYPE_ENUM FieldDescriptorProto_Type = 14 + FieldDescriptorProto_TYPE_SFIXED32 FieldDescriptorProto_Type = 15 + FieldDescriptorProto_TYPE_SFIXED64 FieldDescriptorProto_Type = 16 + FieldDescriptorProto_TYPE_SINT32 FieldDescriptorProto_Type = 17 + FieldDescriptorProto_TYPE_SINT64 FieldDescriptorProto_Type = 18 +) + +var FieldDescriptorProto_Type_name = map[int32]string{ + 1: "TYPE_DOUBLE", + 2: "TYPE_FLOAT", + 3: "TYPE_INT64", + 4: "TYPE_UINT64", + 5: "TYPE_INT32", + 6: "TYPE_FIXED64", + 7: "TYPE_FIXED32", + 8: "TYPE_BOOL", + 9: "TYPE_STRING", + 10: "TYPE_GROUP", + 11: "TYPE_MESSAGE", + 12: "TYPE_BYTES", + 13: "TYPE_UINT32", + 14: "TYPE_ENUM", + 15: "TYPE_SFIXED32", + 16: "TYPE_SFIXED64", + 17: "TYPE_SINT32", + 18: "TYPE_SINT64", +} +var FieldDescriptorProto_Type_value = map[string]int32{ + "TYPE_DOUBLE": 1, + "TYPE_FLOAT": 2, + "TYPE_INT64": 3, + "TYPE_UINT64": 4, + "TYPE_INT32": 5, + "TYPE_FIXED64": 6, + "TYPE_FIXED32": 7, + "TYPE_BOOL": 8, + "TYPE_STRING": 9, + "TYPE_GROUP": 10, + "TYPE_MESSAGE": 11, + "TYPE_BYTES": 12, + "TYPE_UINT32": 13, + "TYPE_ENUM": 14, + "TYPE_SFIXED32": 15, + "TYPE_SFIXED64": 16, + "TYPE_SINT32": 17, + "TYPE_SINT64": 18, +} + +func (x FieldDescriptorProto_Type) Enum() *FieldDescriptorProto_Type { + p := new(FieldDescriptorProto_Type) + *p = x + return p +} +func (x FieldDescriptorProto_Type) String() string { + return proto.EnumName(FieldDescriptorProto_Type_name, int32(x)) +} +func (x *FieldDescriptorProto_Type) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(FieldDescriptorProto_Type_value, data, "FieldDescriptorProto_Type") + if err != nil { + return err + } + *x = FieldDescriptorProto_Type(value) + return nil +} +func (FieldDescriptorProto_Type) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_descriptor_9588782fb9cbecd6, []int{4, 0} +} + +type FieldDescriptorProto_Label int32 + +const ( + // 0 is reserved for errors + FieldDescriptorProto_LABEL_OPTIONAL FieldDescriptorProto_Label = 1 + FieldDescriptorProto_LABEL_REQUIRED FieldDescriptorProto_Label = 2 + FieldDescriptorProto_LABEL_REPEATED FieldDescriptorProto_Label = 3 +) + +var FieldDescriptorProto_Label_name = map[int32]string{ + 1: "LABEL_OPTIONAL", + 2: "LABEL_REQUIRED", + 3: "LABEL_REPEATED", +} +var FieldDescriptorProto_Label_value = map[string]int32{ + "LABEL_OPTIONAL": 1, + "LABEL_REQUIRED": 2, + "LABEL_REPEATED": 3, +} + +func (x FieldDescriptorProto_Label) Enum() *FieldDescriptorProto_Label { + p := new(FieldDescriptorProto_Label) + *p = x + return p +} +func (x FieldDescriptorProto_Label) String() string { + return proto.EnumName(FieldDescriptorProto_Label_name, int32(x)) +} +func (x *FieldDescriptorProto_Label) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(FieldDescriptorProto_Label_value, data, "FieldDescriptorProto_Label") + if err != nil { + return err + } + *x = FieldDescriptorProto_Label(value) + return nil +} +func (FieldDescriptorProto_Label) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_descriptor_9588782fb9cbecd6, []int{4, 1} +} + +// Generated classes can be optimized for speed or code size. +type FileOptions_OptimizeMode int32 + +const ( + FileOptions_SPEED FileOptions_OptimizeMode = 1 + // etc. + FileOptions_CODE_SIZE FileOptions_OptimizeMode = 2 + FileOptions_LITE_RUNTIME FileOptions_OptimizeMode = 3 +) + +var FileOptions_OptimizeMode_name = map[int32]string{ + 1: "SPEED", + 2: "CODE_SIZE", + 3: "LITE_RUNTIME", +} +var FileOptions_OptimizeMode_value = map[string]int32{ + "SPEED": 1, + "CODE_SIZE": 2, + "LITE_RUNTIME": 3, +} + +func (x FileOptions_OptimizeMode) Enum() *FileOptions_OptimizeMode { + p := new(FileOptions_OptimizeMode) + *p = x + return p +} +func (x FileOptions_OptimizeMode) String() string { + return proto.EnumName(FileOptions_OptimizeMode_name, int32(x)) +} +func (x *FileOptions_OptimizeMode) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(FileOptions_OptimizeMode_value, data, "FileOptions_OptimizeMode") + if err != nil { + return err + } + *x = FileOptions_OptimizeMode(value) + return nil +} +func (FileOptions_OptimizeMode) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_descriptor_9588782fb9cbecd6, []int{10, 0} +} + +type FieldOptions_CType int32 + +const ( + // Default mode. + FieldOptions_STRING FieldOptions_CType = 0 + FieldOptions_CORD FieldOptions_CType = 1 + FieldOptions_STRING_PIECE FieldOptions_CType = 2 +) + +var FieldOptions_CType_name = map[int32]string{ + 0: "STRING", + 1: "CORD", + 2: "STRING_PIECE", +} +var FieldOptions_CType_value = map[string]int32{ + "STRING": 0, + "CORD": 1, + "STRING_PIECE": 2, +} + +func (x FieldOptions_CType) Enum() *FieldOptions_CType { + p := new(FieldOptions_CType) + *p = x + return p +} +func (x FieldOptions_CType) String() string { + return proto.EnumName(FieldOptions_CType_name, int32(x)) +} +func (x *FieldOptions_CType) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(FieldOptions_CType_value, data, "FieldOptions_CType") + if err != nil { + return err + } + *x = FieldOptions_CType(value) + return nil +} +func (FieldOptions_CType) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_descriptor_9588782fb9cbecd6, []int{12, 0} +} + +type FieldOptions_JSType int32 + +const ( + // Use the default type. + FieldOptions_JS_NORMAL FieldOptions_JSType = 0 + // Use JavaScript strings. + FieldOptions_JS_STRING FieldOptions_JSType = 1 + // Use JavaScript numbers. + FieldOptions_JS_NUMBER FieldOptions_JSType = 2 +) + +var FieldOptions_JSType_name = map[int32]string{ + 0: "JS_NORMAL", + 1: "JS_STRING", + 2: "JS_NUMBER", +} +var FieldOptions_JSType_value = map[string]int32{ + "JS_NORMAL": 0, + "JS_STRING": 1, + "JS_NUMBER": 2, +} + +func (x FieldOptions_JSType) Enum() *FieldOptions_JSType { + p := new(FieldOptions_JSType) + *p = x + return p +} +func (x FieldOptions_JSType) String() string { + return proto.EnumName(FieldOptions_JSType_name, int32(x)) +} +func (x *FieldOptions_JSType) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(FieldOptions_JSType_value, data, "FieldOptions_JSType") + if err != nil { + return err + } + *x = FieldOptions_JSType(value) + return nil +} +func (FieldOptions_JSType) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_descriptor_9588782fb9cbecd6, []int{12, 1} +} + +// Is this method side-effect-free (or safe in HTTP parlance), or idempotent, +// or neither? HTTP based RPC implementation may choose GET verb for safe +// methods, and PUT verb for idempotent methods instead of the default POST. +type MethodOptions_IdempotencyLevel int32 + +const ( + MethodOptions_IDEMPOTENCY_UNKNOWN MethodOptions_IdempotencyLevel = 0 + MethodOptions_NO_SIDE_EFFECTS MethodOptions_IdempotencyLevel = 1 + MethodOptions_IDEMPOTENT MethodOptions_IdempotencyLevel = 2 +) + +var MethodOptions_IdempotencyLevel_name = map[int32]string{ + 0: "IDEMPOTENCY_UNKNOWN", + 1: "NO_SIDE_EFFECTS", + 2: "IDEMPOTENT", +} +var MethodOptions_IdempotencyLevel_value = map[string]int32{ + "IDEMPOTENCY_UNKNOWN": 0, + "NO_SIDE_EFFECTS": 1, + "IDEMPOTENT": 2, +} + +func (x MethodOptions_IdempotencyLevel) Enum() *MethodOptions_IdempotencyLevel { + p := new(MethodOptions_IdempotencyLevel) + *p = x + return p +} +func (x MethodOptions_IdempotencyLevel) String() string { + return proto.EnumName(MethodOptions_IdempotencyLevel_name, int32(x)) +} +func (x *MethodOptions_IdempotencyLevel) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(MethodOptions_IdempotencyLevel_value, data, "MethodOptions_IdempotencyLevel") + if err != nil { + return err + } + *x = MethodOptions_IdempotencyLevel(value) + return nil +} +func (MethodOptions_IdempotencyLevel) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_descriptor_9588782fb9cbecd6, []int{17, 0} +} + +// The protocol compiler can output a FileDescriptorSet containing the .proto +// files it parses. +type FileDescriptorSet struct { + File []*FileDescriptorProto `protobuf:"bytes,1,rep,name=file" json:"file,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *FileDescriptorSet) Reset() { *m = FileDescriptorSet{} } +func (m *FileDescriptorSet) String() string { return proto.CompactTextString(m) } +func (*FileDescriptorSet) ProtoMessage() {} +func (*FileDescriptorSet) Descriptor() ([]byte, []int) { + return fileDescriptor_descriptor_9588782fb9cbecd6, []int{0} +} +func (m *FileDescriptorSet) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_FileDescriptorSet.Unmarshal(m, b) +} +func (m *FileDescriptorSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_FileDescriptorSet.Marshal(b, m, deterministic) +} +func (dst *FileDescriptorSet) XXX_Merge(src proto.Message) { + xxx_messageInfo_FileDescriptorSet.Merge(dst, src) +} +func (m *FileDescriptorSet) XXX_Size() int { + return xxx_messageInfo_FileDescriptorSet.Size(m) +} +func (m *FileDescriptorSet) XXX_DiscardUnknown() { + xxx_messageInfo_FileDescriptorSet.DiscardUnknown(m) +} + +var xxx_messageInfo_FileDescriptorSet proto.InternalMessageInfo + +func (m *FileDescriptorSet) GetFile() []*FileDescriptorProto { + if m != nil { + return m.File + } + return nil +} + +// Describes a complete .proto file. +type FileDescriptorProto struct { + Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + Package *string `protobuf:"bytes,2,opt,name=package" json:"package,omitempty"` + // Names of files imported by this file. + Dependency []string `protobuf:"bytes,3,rep,name=dependency" json:"dependency,omitempty"` + // Indexes of the public imported files in the dependency list above. + PublicDependency []int32 `protobuf:"varint,10,rep,name=public_dependency,json=publicDependency" json:"public_dependency,omitempty"` + // Indexes of the weak imported files in the dependency list. + // For Google-internal migration only. Do not use. + WeakDependency []int32 `protobuf:"varint,11,rep,name=weak_dependency,json=weakDependency" json:"weak_dependency,omitempty"` + // All top-level definitions in this file. + MessageType []*DescriptorProto `protobuf:"bytes,4,rep,name=message_type,json=messageType" json:"message_type,omitempty"` + EnumType []*EnumDescriptorProto `protobuf:"bytes,5,rep,name=enum_type,json=enumType" json:"enum_type,omitempty"` + Service []*ServiceDescriptorProto `protobuf:"bytes,6,rep,name=service" json:"service,omitempty"` + Extension []*FieldDescriptorProto `protobuf:"bytes,7,rep,name=extension" json:"extension,omitempty"` + Options *FileOptions `protobuf:"bytes,8,opt,name=options" json:"options,omitempty"` + // This field contains optional information about the original source code. + // You may safely remove this entire field without harming runtime + // functionality of the descriptors -- the information is needed only by + // development tools. + SourceCodeInfo *SourceCodeInfo `protobuf:"bytes,9,opt,name=source_code_info,json=sourceCodeInfo" json:"source_code_info,omitempty"` + // The syntax of the proto file. + // The supported values are "proto2" and "proto3". + Syntax *string `protobuf:"bytes,12,opt,name=syntax" json:"syntax,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *FileDescriptorProto) Reset() { *m = FileDescriptorProto{} } +func (m *FileDescriptorProto) String() string { return proto.CompactTextString(m) } +func (*FileDescriptorProto) ProtoMessage() {} +func (*FileDescriptorProto) Descriptor() ([]byte, []int) { + return fileDescriptor_descriptor_9588782fb9cbecd6, []int{1} +} +func (m *FileDescriptorProto) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_FileDescriptorProto.Unmarshal(m, b) +} +func (m *FileDescriptorProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_FileDescriptorProto.Marshal(b, m, deterministic) +} +func (dst *FileDescriptorProto) XXX_Merge(src proto.Message) { + xxx_messageInfo_FileDescriptorProto.Merge(dst, src) +} +func (m *FileDescriptorProto) XXX_Size() int { + return xxx_messageInfo_FileDescriptorProto.Size(m) +} +func (m *FileDescriptorProto) XXX_DiscardUnknown() { + xxx_messageInfo_FileDescriptorProto.DiscardUnknown(m) +} + +var xxx_messageInfo_FileDescriptorProto proto.InternalMessageInfo + +func (m *FileDescriptorProto) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *FileDescriptorProto) GetPackage() string { + if m != nil && m.Package != nil { + return *m.Package + } + return "" +} + +func (m *FileDescriptorProto) GetDependency() []string { + if m != nil { + return m.Dependency + } + return nil +} + +func (m *FileDescriptorProto) GetPublicDependency() []int32 { + if m != nil { + return m.PublicDependency + } + return nil +} + +func (m *FileDescriptorProto) GetWeakDependency() []int32 { + if m != nil { + return m.WeakDependency + } + return nil +} + +func (m *FileDescriptorProto) GetMessageType() []*DescriptorProto { + if m != nil { + return m.MessageType + } + return nil +} + +func (m *FileDescriptorProto) GetEnumType() []*EnumDescriptorProto { + if m != nil { + return m.EnumType + } + return nil +} + +func (m *FileDescriptorProto) GetService() []*ServiceDescriptorProto { + if m != nil { + return m.Service + } + return nil +} + +func (m *FileDescriptorProto) GetExtension() []*FieldDescriptorProto { + if m != nil { + return m.Extension + } + return nil +} + +func (m *FileDescriptorProto) GetOptions() *FileOptions { + if m != nil { + return m.Options + } + return nil +} + +func (m *FileDescriptorProto) GetSourceCodeInfo() *SourceCodeInfo { + if m != nil { + return m.SourceCodeInfo + } + return nil +} + +func (m *FileDescriptorProto) GetSyntax() string { + if m != nil && m.Syntax != nil { + return *m.Syntax + } + return "" +} + +// Describes a message type. +type DescriptorProto struct { + Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + Field []*FieldDescriptorProto `protobuf:"bytes,2,rep,name=field" json:"field,omitempty"` + Extension []*FieldDescriptorProto `protobuf:"bytes,6,rep,name=extension" json:"extension,omitempty"` + NestedType []*DescriptorProto `protobuf:"bytes,3,rep,name=nested_type,json=nestedType" json:"nested_type,omitempty"` + EnumType []*EnumDescriptorProto `protobuf:"bytes,4,rep,name=enum_type,json=enumType" json:"enum_type,omitempty"` + ExtensionRange []*DescriptorProto_ExtensionRange `protobuf:"bytes,5,rep,name=extension_range,json=extensionRange" json:"extension_range,omitempty"` + OneofDecl []*OneofDescriptorProto `protobuf:"bytes,8,rep,name=oneof_decl,json=oneofDecl" json:"oneof_decl,omitempty"` + Options *MessageOptions `protobuf:"bytes,7,opt,name=options" json:"options,omitempty"` + ReservedRange []*DescriptorProto_ReservedRange `protobuf:"bytes,9,rep,name=reserved_range,json=reservedRange" json:"reserved_range,omitempty"` + // Reserved field names, which may not be used by fields in the same message. + // A given name may only be reserved once. + ReservedName []string `protobuf:"bytes,10,rep,name=reserved_name,json=reservedName" json:"reserved_name,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *DescriptorProto) Reset() { *m = DescriptorProto{} } +func (m *DescriptorProto) String() string { return proto.CompactTextString(m) } +func (*DescriptorProto) ProtoMessage() {} +func (*DescriptorProto) Descriptor() ([]byte, []int) { + return fileDescriptor_descriptor_9588782fb9cbecd6, []int{2} +} +func (m *DescriptorProto) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_DescriptorProto.Unmarshal(m, b) +} +func (m *DescriptorProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_DescriptorProto.Marshal(b, m, deterministic) +} +func (dst *DescriptorProto) XXX_Merge(src proto.Message) { + xxx_messageInfo_DescriptorProto.Merge(dst, src) +} +func (m *DescriptorProto) XXX_Size() int { + return xxx_messageInfo_DescriptorProto.Size(m) +} +func (m *DescriptorProto) XXX_DiscardUnknown() { + xxx_messageInfo_DescriptorProto.DiscardUnknown(m) +} + +var xxx_messageInfo_DescriptorProto proto.InternalMessageInfo + +func (m *DescriptorProto) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *DescriptorProto) GetField() []*FieldDescriptorProto { + if m != nil { + return m.Field + } + return nil +} + +func (m *DescriptorProto) GetExtension() []*FieldDescriptorProto { + if m != nil { + return m.Extension + } + return nil +} + +func (m *DescriptorProto) GetNestedType() []*DescriptorProto { + if m != nil { + return m.NestedType + } + return nil +} + +func (m *DescriptorProto) GetEnumType() []*EnumDescriptorProto { + if m != nil { + return m.EnumType + } + return nil +} + +func (m *DescriptorProto) GetExtensionRange() []*DescriptorProto_ExtensionRange { + if m != nil { + return m.ExtensionRange + } + return nil +} + +func (m *DescriptorProto) GetOneofDecl() []*OneofDescriptorProto { + if m != nil { + return m.OneofDecl + } + return nil +} + +func (m *DescriptorProto) GetOptions() *MessageOptions { + if m != nil { + return m.Options + } + return nil +} + +func (m *DescriptorProto) GetReservedRange() []*DescriptorProto_ReservedRange { + if m != nil { + return m.ReservedRange + } + return nil +} + +func (m *DescriptorProto) GetReservedName() []string { + if m != nil { + return m.ReservedName + } + return nil +} + +type DescriptorProto_ExtensionRange struct { + Start *int32 `protobuf:"varint,1,opt,name=start" json:"start,omitempty"` + End *int32 `protobuf:"varint,2,opt,name=end" json:"end,omitempty"` + Options *ExtensionRangeOptions `protobuf:"bytes,3,opt,name=options" json:"options,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *DescriptorProto_ExtensionRange) Reset() { *m = DescriptorProto_ExtensionRange{} } +func (m *DescriptorProto_ExtensionRange) String() string { return proto.CompactTextString(m) } +func (*DescriptorProto_ExtensionRange) ProtoMessage() {} +func (*DescriptorProto_ExtensionRange) Descriptor() ([]byte, []int) { + return fileDescriptor_descriptor_9588782fb9cbecd6, []int{2, 0} +} +func (m *DescriptorProto_ExtensionRange) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_DescriptorProto_ExtensionRange.Unmarshal(m, b) +} +func (m *DescriptorProto_ExtensionRange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_DescriptorProto_ExtensionRange.Marshal(b, m, deterministic) +} +func (dst *DescriptorProto_ExtensionRange) XXX_Merge(src proto.Message) { + xxx_messageInfo_DescriptorProto_ExtensionRange.Merge(dst, src) +} +func (m *DescriptorProto_ExtensionRange) XXX_Size() int { + return xxx_messageInfo_DescriptorProto_ExtensionRange.Size(m) +} +func (m *DescriptorProto_ExtensionRange) XXX_DiscardUnknown() { + xxx_messageInfo_DescriptorProto_ExtensionRange.DiscardUnknown(m) +} + +var xxx_messageInfo_DescriptorProto_ExtensionRange proto.InternalMessageInfo + +func (m *DescriptorProto_ExtensionRange) GetStart() int32 { + if m != nil && m.Start != nil { + return *m.Start + } + return 0 +} + +func (m *DescriptorProto_ExtensionRange) GetEnd() int32 { + if m != nil && m.End != nil { + return *m.End + } + return 0 +} + +func (m *DescriptorProto_ExtensionRange) GetOptions() *ExtensionRangeOptions { + if m != nil { + return m.Options + } + return nil +} + +// Range of reserved tag numbers. Reserved tag numbers may not be used by +// fields or extension ranges in the same message. Reserved ranges may +// not overlap. +type DescriptorProto_ReservedRange struct { + Start *int32 `protobuf:"varint,1,opt,name=start" json:"start,omitempty"` + End *int32 `protobuf:"varint,2,opt,name=end" json:"end,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *DescriptorProto_ReservedRange) Reset() { *m = DescriptorProto_ReservedRange{} } +func (m *DescriptorProto_ReservedRange) String() string { return proto.CompactTextString(m) } +func (*DescriptorProto_ReservedRange) ProtoMessage() {} +func (*DescriptorProto_ReservedRange) Descriptor() ([]byte, []int) { + return fileDescriptor_descriptor_9588782fb9cbecd6, []int{2, 1} +} +func (m *DescriptorProto_ReservedRange) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_DescriptorProto_ReservedRange.Unmarshal(m, b) +} +func (m *DescriptorProto_ReservedRange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_DescriptorProto_ReservedRange.Marshal(b, m, deterministic) +} +func (dst *DescriptorProto_ReservedRange) XXX_Merge(src proto.Message) { + xxx_messageInfo_DescriptorProto_ReservedRange.Merge(dst, src) +} +func (m *DescriptorProto_ReservedRange) XXX_Size() int { + return xxx_messageInfo_DescriptorProto_ReservedRange.Size(m) +} +func (m *DescriptorProto_ReservedRange) XXX_DiscardUnknown() { + xxx_messageInfo_DescriptorProto_ReservedRange.DiscardUnknown(m) +} + +var xxx_messageInfo_DescriptorProto_ReservedRange proto.InternalMessageInfo + +func (m *DescriptorProto_ReservedRange) GetStart() int32 { + if m != nil && m.Start != nil { + return *m.Start + } + return 0 +} + +func (m *DescriptorProto_ReservedRange) GetEnd() int32 { + if m != nil && m.End != nil { + return *m.End + } + return 0 +} + +type ExtensionRangeOptions struct { + // The parser stores options it doesn't recognize here. See above. + UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + proto.XXX_InternalExtensions `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ExtensionRangeOptions) Reset() { *m = ExtensionRangeOptions{} } +func (m *ExtensionRangeOptions) String() string { return proto.CompactTextString(m) } +func (*ExtensionRangeOptions) ProtoMessage() {} +func (*ExtensionRangeOptions) Descriptor() ([]byte, []int) { + return fileDescriptor_descriptor_9588782fb9cbecd6, []int{3} +} + +var extRange_ExtensionRangeOptions = []proto.ExtensionRange{ + {Start: 1000, End: 536870911}, +} + +func (*ExtensionRangeOptions) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_ExtensionRangeOptions +} +func (m *ExtensionRangeOptions) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ExtensionRangeOptions.Unmarshal(m, b) +} +func (m *ExtensionRangeOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ExtensionRangeOptions.Marshal(b, m, deterministic) +} +func (dst *ExtensionRangeOptions) XXX_Merge(src proto.Message) { + xxx_messageInfo_ExtensionRangeOptions.Merge(dst, src) +} +func (m *ExtensionRangeOptions) XXX_Size() int { + return xxx_messageInfo_ExtensionRangeOptions.Size(m) +} +func (m *ExtensionRangeOptions) XXX_DiscardUnknown() { + xxx_messageInfo_ExtensionRangeOptions.DiscardUnknown(m) +} + +var xxx_messageInfo_ExtensionRangeOptions proto.InternalMessageInfo + +func (m *ExtensionRangeOptions) GetUninterpretedOption() []*UninterpretedOption { + if m != nil { + return m.UninterpretedOption + } + return nil +} + +// Describes a field within a message. +type FieldDescriptorProto struct { + Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + Number *int32 `protobuf:"varint,3,opt,name=number" json:"number,omitempty"` + Label *FieldDescriptorProto_Label `protobuf:"varint,4,opt,name=label,enum=google.protobuf.FieldDescriptorProto_Label" json:"label,omitempty"` + // If type_name is set, this need not be set. If both this and type_name + // are set, this must be one of TYPE_ENUM, TYPE_MESSAGE or TYPE_GROUP. + Type *FieldDescriptorProto_Type `protobuf:"varint,5,opt,name=type,enum=google.protobuf.FieldDescriptorProto_Type" json:"type,omitempty"` + // For message and enum types, this is the name of the type. If the name + // starts with a '.', it is fully-qualified. Otherwise, C++-like scoping + // rules are used to find the type (i.e. first the nested types within this + // message are searched, then within the parent, on up to the root + // namespace). + TypeName *string `protobuf:"bytes,6,opt,name=type_name,json=typeName" json:"type_name,omitempty"` + // For extensions, this is the name of the type being extended. It is + // resolved in the same manner as type_name. + Extendee *string `protobuf:"bytes,2,opt,name=extendee" json:"extendee,omitempty"` + // For numeric types, contains the original text representation of the value. + // For booleans, "true" or "false". + // For strings, contains the default text contents (not escaped in any way). + // For bytes, contains the C escaped value. All bytes >= 128 are escaped. + // TODO(kenton): Base-64 encode? + DefaultValue *string `protobuf:"bytes,7,opt,name=default_value,json=defaultValue" json:"default_value,omitempty"` + // If set, gives the index of a oneof in the containing type's oneof_decl + // list. This field is a member of that oneof. + OneofIndex *int32 `protobuf:"varint,9,opt,name=oneof_index,json=oneofIndex" json:"oneof_index,omitempty"` + // JSON name of this field. The value is set by protocol compiler. If the + // user has set a "json_name" option on this field, that option's value + // will be used. Otherwise, it's deduced from the field's name by converting + // it to camelCase. + JsonName *string `protobuf:"bytes,10,opt,name=json_name,json=jsonName" json:"json_name,omitempty"` + Options *FieldOptions `protobuf:"bytes,8,opt,name=options" json:"options,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *FieldDescriptorProto) Reset() { *m = FieldDescriptorProto{} } +func (m *FieldDescriptorProto) String() string { return proto.CompactTextString(m) } +func (*FieldDescriptorProto) ProtoMessage() {} +func (*FieldDescriptorProto) Descriptor() ([]byte, []int) { + return fileDescriptor_descriptor_9588782fb9cbecd6, []int{4} +} +func (m *FieldDescriptorProto) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_FieldDescriptorProto.Unmarshal(m, b) +} +func (m *FieldDescriptorProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_FieldDescriptorProto.Marshal(b, m, deterministic) +} +func (dst *FieldDescriptorProto) XXX_Merge(src proto.Message) { + xxx_messageInfo_FieldDescriptorProto.Merge(dst, src) +} +func (m *FieldDescriptorProto) XXX_Size() int { + return xxx_messageInfo_FieldDescriptorProto.Size(m) +} +func (m *FieldDescriptorProto) XXX_DiscardUnknown() { + xxx_messageInfo_FieldDescriptorProto.DiscardUnknown(m) +} + +var xxx_messageInfo_FieldDescriptorProto proto.InternalMessageInfo + +func (m *FieldDescriptorProto) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *FieldDescriptorProto) GetNumber() int32 { + if m != nil && m.Number != nil { + return *m.Number + } + return 0 +} + +func (m *FieldDescriptorProto) GetLabel() FieldDescriptorProto_Label { + if m != nil && m.Label != nil { + return *m.Label + } + return FieldDescriptorProto_LABEL_OPTIONAL +} + +func (m *FieldDescriptorProto) GetType() FieldDescriptorProto_Type { + if m != nil && m.Type != nil { + return *m.Type + } + return FieldDescriptorProto_TYPE_DOUBLE +} + +func (m *FieldDescriptorProto) GetTypeName() string { + if m != nil && m.TypeName != nil { + return *m.TypeName + } + return "" +} + +func (m *FieldDescriptorProto) GetExtendee() string { + if m != nil && m.Extendee != nil { + return *m.Extendee + } + return "" +} + +func (m *FieldDescriptorProto) GetDefaultValue() string { + if m != nil && m.DefaultValue != nil { + return *m.DefaultValue + } + return "" +} + +func (m *FieldDescriptorProto) GetOneofIndex() int32 { + if m != nil && m.OneofIndex != nil { + return *m.OneofIndex + } + return 0 +} + +func (m *FieldDescriptorProto) GetJsonName() string { + if m != nil && m.JsonName != nil { + return *m.JsonName + } + return "" +} + +func (m *FieldDescriptorProto) GetOptions() *FieldOptions { + if m != nil { + return m.Options + } + return nil +} + +// Describes a oneof. +type OneofDescriptorProto struct { + Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + Options *OneofOptions `protobuf:"bytes,2,opt,name=options" json:"options,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *OneofDescriptorProto) Reset() { *m = OneofDescriptorProto{} } +func (m *OneofDescriptorProto) String() string { return proto.CompactTextString(m) } +func (*OneofDescriptorProto) ProtoMessage() {} +func (*OneofDescriptorProto) Descriptor() ([]byte, []int) { + return fileDescriptor_descriptor_9588782fb9cbecd6, []int{5} +} +func (m *OneofDescriptorProto) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_OneofDescriptorProto.Unmarshal(m, b) +} +func (m *OneofDescriptorProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_OneofDescriptorProto.Marshal(b, m, deterministic) +} +func (dst *OneofDescriptorProto) XXX_Merge(src proto.Message) { + xxx_messageInfo_OneofDescriptorProto.Merge(dst, src) +} +func (m *OneofDescriptorProto) XXX_Size() int { + return xxx_messageInfo_OneofDescriptorProto.Size(m) +} +func (m *OneofDescriptorProto) XXX_DiscardUnknown() { + xxx_messageInfo_OneofDescriptorProto.DiscardUnknown(m) +} + +var xxx_messageInfo_OneofDescriptorProto proto.InternalMessageInfo + +func (m *OneofDescriptorProto) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *OneofDescriptorProto) GetOptions() *OneofOptions { + if m != nil { + return m.Options + } + return nil +} + +// Describes an enum type. +type EnumDescriptorProto struct { + Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + Value []*EnumValueDescriptorProto `protobuf:"bytes,2,rep,name=value" json:"value,omitempty"` + Options *EnumOptions `protobuf:"bytes,3,opt,name=options" json:"options,omitempty"` + // Range of reserved numeric values. Reserved numeric values may not be used + // by enum values in the same enum declaration. Reserved ranges may not + // overlap. + ReservedRange []*EnumDescriptorProto_EnumReservedRange `protobuf:"bytes,4,rep,name=reserved_range,json=reservedRange" json:"reserved_range,omitempty"` + // Reserved enum value names, which may not be reused. A given name may only + // be reserved once. + ReservedName []string `protobuf:"bytes,5,rep,name=reserved_name,json=reservedName" json:"reserved_name,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *EnumDescriptorProto) Reset() { *m = EnumDescriptorProto{} } +func (m *EnumDescriptorProto) String() string { return proto.CompactTextString(m) } +func (*EnumDescriptorProto) ProtoMessage() {} +func (*EnumDescriptorProto) Descriptor() ([]byte, []int) { + return fileDescriptor_descriptor_9588782fb9cbecd6, []int{6} +} +func (m *EnumDescriptorProto) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_EnumDescriptorProto.Unmarshal(m, b) +} +func (m *EnumDescriptorProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_EnumDescriptorProto.Marshal(b, m, deterministic) +} +func (dst *EnumDescriptorProto) XXX_Merge(src proto.Message) { + xxx_messageInfo_EnumDescriptorProto.Merge(dst, src) +} +func (m *EnumDescriptorProto) XXX_Size() int { + return xxx_messageInfo_EnumDescriptorProto.Size(m) +} +func (m *EnumDescriptorProto) XXX_DiscardUnknown() { + xxx_messageInfo_EnumDescriptorProto.DiscardUnknown(m) +} + +var xxx_messageInfo_EnumDescriptorProto proto.InternalMessageInfo + +func (m *EnumDescriptorProto) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *EnumDescriptorProto) GetValue() []*EnumValueDescriptorProto { + if m != nil { + return m.Value + } + return nil +} + +func (m *EnumDescriptorProto) GetOptions() *EnumOptions { + if m != nil { + return m.Options + } + return nil +} + +func (m *EnumDescriptorProto) GetReservedRange() []*EnumDescriptorProto_EnumReservedRange { + if m != nil { + return m.ReservedRange + } + return nil +} + +func (m *EnumDescriptorProto) GetReservedName() []string { + if m != nil { + return m.ReservedName + } + return nil +} + +// Range of reserved numeric values. Reserved values may not be used by +// entries in the same enum. Reserved ranges may not overlap. +// +// Note that this is distinct from DescriptorProto.ReservedRange in that it +// is inclusive such that it can appropriately represent the entire int32 +// domain. +type EnumDescriptorProto_EnumReservedRange struct { + Start *int32 `protobuf:"varint,1,opt,name=start" json:"start,omitempty"` + End *int32 `protobuf:"varint,2,opt,name=end" json:"end,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *EnumDescriptorProto_EnumReservedRange) Reset() { *m = EnumDescriptorProto_EnumReservedRange{} } +func (m *EnumDescriptorProto_EnumReservedRange) String() string { return proto.CompactTextString(m) } +func (*EnumDescriptorProto_EnumReservedRange) ProtoMessage() {} +func (*EnumDescriptorProto_EnumReservedRange) Descriptor() ([]byte, []int) { + return fileDescriptor_descriptor_9588782fb9cbecd6, []int{6, 0} +} +func (m *EnumDescriptorProto_EnumReservedRange) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_EnumDescriptorProto_EnumReservedRange.Unmarshal(m, b) +} +func (m *EnumDescriptorProto_EnumReservedRange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_EnumDescriptorProto_EnumReservedRange.Marshal(b, m, deterministic) +} +func (dst *EnumDescriptorProto_EnumReservedRange) XXX_Merge(src proto.Message) { + xxx_messageInfo_EnumDescriptorProto_EnumReservedRange.Merge(dst, src) +} +func (m *EnumDescriptorProto_EnumReservedRange) XXX_Size() int { + return xxx_messageInfo_EnumDescriptorProto_EnumReservedRange.Size(m) +} +func (m *EnumDescriptorProto_EnumReservedRange) XXX_DiscardUnknown() { + xxx_messageInfo_EnumDescriptorProto_EnumReservedRange.DiscardUnknown(m) +} + +var xxx_messageInfo_EnumDescriptorProto_EnumReservedRange proto.InternalMessageInfo + +func (m *EnumDescriptorProto_EnumReservedRange) GetStart() int32 { + if m != nil && m.Start != nil { + return *m.Start + } + return 0 +} + +func (m *EnumDescriptorProto_EnumReservedRange) GetEnd() int32 { + if m != nil && m.End != nil { + return *m.End + } + return 0 +} + +// Describes a value within an enum. +type EnumValueDescriptorProto struct { + Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + Number *int32 `protobuf:"varint,2,opt,name=number" json:"number,omitempty"` + Options *EnumValueOptions `protobuf:"bytes,3,opt,name=options" json:"options,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *EnumValueDescriptorProto) Reset() { *m = EnumValueDescriptorProto{} } +func (m *EnumValueDescriptorProto) String() string { return proto.CompactTextString(m) } +func (*EnumValueDescriptorProto) ProtoMessage() {} +func (*EnumValueDescriptorProto) Descriptor() ([]byte, []int) { + return fileDescriptor_descriptor_9588782fb9cbecd6, []int{7} +} +func (m *EnumValueDescriptorProto) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_EnumValueDescriptorProto.Unmarshal(m, b) +} +func (m *EnumValueDescriptorProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_EnumValueDescriptorProto.Marshal(b, m, deterministic) +} +func (dst *EnumValueDescriptorProto) XXX_Merge(src proto.Message) { + xxx_messageInfo_EnumValueDescriptorProto.Merge(dst, src) +} +func (m *EnumValueDescriptorProto) XXX_Size() int { + return xxx_messageInfo_EnumValueDescriptorProto.Size(m) +} +func (m *EnumValueDescriptorProto) XXX_DiscardUnknown() { + xxx_messageInfo_EnumValueDescriptorProto.DiscardUnknown(m) +} + +var xxx_messageInfo_EnumValueDescriptorProto proto.InternalMessageInfo + +func (m *EnumValueDescriptorProto) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *EnumValueDescriptorProto) GetNumber() int32 { + if m != nil && m.Number != nil { + return *m.Number + } + return 0 +} + +func (m *EnumValueDescriptorProto) GetOptions() *EnumValueOptions { + if m != nil { + return m.Options + } + return nil +} + +// Describes a service. +type ServiceDescriptorProto struct { + Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + Method []*MethodDescriptorProto `protobuf:"bytes,2,rep,name=method" json:"method,omitempty"` + Options *ServiceOptions `protobuf:"bytes,3,opt,name=options" json:"options,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ServiceDescriptorProto) Reset() { *m = ServiceDescriptorProto{} } +func (m *ServiceDescriptorProto) String() string { return proto.CompactTextString(m) } +func (*ServiceDescriptorProto) ProtoMessage() {} +func (*ServiceDescriptorProto) Descriptor() ([]byte, []int) { + return fileDescriptor_descriptor_9588782fb9cbecd6, []int{8} +} +func (m *ServiceDescriptorProto) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ServiceDescriptorProto.Unmarshal(m, b) +} +func (m *ServiceDescriptorProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ServiceDescriptorProto.Marshal(b, m, deterministic) +} +func (dst *ServiceDescriptorProto) XXX_Merge(src proto.Message) { + xxx_messageInfo_ServiceDescriptorProto.Merge(dst, src) +} +func (m *ServiceDescriptorProto) XXX_Size() int { + return xxx_messageInfo_ServiceDescriptorProto.Size(m) +} +func (m *ServiceDescriptorProto) XXX_DiscardUnknown() { + xxx_messageInfo_ServiceDescriptorProto.DiscardUnknown(m) +} + +var xxx_messageInfo_ServiceDescriptorProto proto.InternalMessageInfo + +func (m *ServiceDescriptorProto) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *ServiceDescriptorProto) GetMethod() []*MethodDescriptorProto { + if m != nil { + return m.Method + } + return nil +} + +func (m *ServiceDescriptorProto) GetOptions() *ServiceOptions { + if m != nil { + return m.Options + } + return nil +} + +// Describes a method of a service. +type MethodDescriptorProto struct { + Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + // Input and output type names. These are resolved in the same way as + // FieldDescriptorProto.type_name, but must refer to a message type. + InputType *string `protobuf:"bytes,2,opt,name=input_type,json=inputType" json:"input_type,omitempty"` + OutputType *string `protobuf:"bytes,3,opt,name=output_type,json=outputType" json:"output_type,omitempty"` + Options *MethodOptions `protobuf:"bytes,4,opt,name=options" json:"options,omitempty"` + // Identifies if client streams multiple client messages + ClientStreaming *bool `protobuf:"varint,5,opt,name=client_streaming,json=clientStreaming,def=0" json:"client_streaming,omitempty"` + // Identifies if server streams multiple server messages + ServerStreaming *bool `protobuf:"varint,6,opt,name=server_streaming,json=serverStreaming,def=0" json:"server_streaming,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *MethodDescriptorProto) Reset() { *m = MethodDescriptorProto{} } +func (m *MethodDescriptorProto) String() string { return proto.CompactTextString(m) } +func (*MethodDescriptorProto) ProtoMessage() {} +func (*MethodDescriptorProto) Descriptor() ([]byte, []int) { + return fileDescriptor_descriptor_9588782fb9cbecd6, []int{9} +} +func (m *MethodDescriptorProto) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_MethodDescriptorProto.Unmarshal(m, b) +} +func (m *MethodDescriptorProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_MethodDescriptorProto.Marshal(b, m, deterministic) +} +func (dst *MethodDescriptorProto) XXX_Merge(src proto.Message) { + xxx_messageInfo_MethodDescriptorProto.Merge(dst, src) +} +func (m *MethodDescriptorProto) XXX_Size() int { + return xxx_messageInfo_MethodDescriptorProto.Size(m) +} +func (m *MethodDescriptorProto) XXX_DiscardUnknown() { + xxx_messageInfo_MethodDescriptorProto.DiscardUnknown(m) +} + +var xxx_messageInfo_MethodDescriptorProto proto.InternalMessageInfo + +const Default_MethodDescriptorProto_ClientStreaming bool = false +const Default_MethodDescriptorProto_ServerStreaming bool = false + +func (m *MethodDescriptorProto) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *MethodDescriptorProto) GetInputType() string { + if m != nil && m.InputType != nil { + return *m.InputType + } + return "" +} + +func (m *MethodDescriptorProto) GetOutputType() string { + if m != nil && m.OutputType != nil { + return *m.OutputType + } + return "" +} + +func (m *MethodDescriptorProto) GetOptions() *MethodOptions { + if m != nil { + return m.Options + } + return nil +} + +func (m *MethodDescriptorProto) GetClientStreaming() bool { + if m != nil && m.ClientStreaming != nil { + return *m.ClientStreaming + } + return Default_MethodDescriptorProto_ClientStreaming +} + +func (m *MethodDescriptorProto) GetServerStreaming() bool { + if m != nil && m.ServerStreaming != nil { + return *m.ServerStreaming + } + return Default_MethodDescriptorProto_ServerStreaming +} + +type FileOptions struct { + // Sets the Java package where classes generated from this .proto will be + // placed. By default, the proto package is used, but this is often + // inappropriate because proto packages do not normally start with backwards + // domain names. + JavaPackage *string `protobuf:"bytes,1,opt,name=java_package,json=javaPackage" json:"java_package,omitempty"` + // If set, all the classes from the .proto file are wrapped in a single + // outer class with the given name. This applies to both Proto1 + // (equivalent to the old "--one_java_file" option) and Proto2 (where + // a .proto always translates to a single class, but you may want to + // explicitly choose the class name). + JavaOuterClassname *string `protobuf:"bytes,8,opt,name=java_outer_classname,json=javaOuterClassname" json:"java_outer_classname,omitempty"` + // If set true, then the Java code generator will generate a separate .java + // file for each top-level message, enum, and service defined in the .proto + // file. Thus, these types will *not* be nested inside the outer class + // named by java_outer_classname. However, the outer class will still be + // generated to contain the file's getDescriptor() method as well as any + // top-level extensions defined in the file. + JavaMultipleFiles *bool `protobuf:"varint,10,opt,name=java_multiple_files,json=javaMultipleFiles,def=0" json:"java_multiple_files,omitempty"` + // This option does nothing. + JavaGenerateEqualsAndHash *bool `protobuf:"varint,20,opt,name=java_generate_equals_and_hash,json=javaGenerateEqualsAndHash" json:"java_generate_equals_and_hash,omitempty"` // Deprecated: Do not use. + // If set true, then the Java2 code generator will generate code that + // throws an exception whenever an attempt is made to assign a non-UTF-8 + // byte sequence to a string field. + // Message reflection will do the same. + // However, an extension field still accepts non-UTF-8 byte sequences. + // This option has no effect on when used with the lite runtime. + JavaStringCheckUtf8 *bool `protobuf:"varint,27,opt,name=java_string_check_utf8,json=javaStringCheckUtf8,def=0" json:"java_string_check_utf8,omitempty"` + OptimizeFor *FileOptions_OptimizeMode `protobuf:"varint,9,opt,name=optimize_for,json=optimizeFor,enum=google.protobuf.FileOptions_OptimizeMode,def=1" json:"optimize_for,omitempty"` + // Sets the Go package where structs generated from this .proto will be + // placed. If omitted, the Go package will be derived from the following: + // - The basename of the package import path, if provided. + // - Otherwise, the package statement in the .proto file, if present. + // - Otherwise, the basename of the .proto file, without extension. + GoPackage *string `protobuf:"bytes,11,opt,name=go_package,json=goPackage" json:"go_package,omitempty"` + // Should generic services be generated in each language? "Generic" services + // are not specific to any particular RPC system. They are generated by the + // main code generators in each language (without additional plugins). + // Generic services were the only kind of service generation supported by + // early versions of google.protobuf. + // + // Generic services are now considered deprecated in favor of using plugins + // that generate code specific to your particular RPC system. Therefore, + // these default to false. Old code which depends on generic services should + // explicitly set them to true. + CcGenericServices *bool `protobuf:"varint,16,opt,name=cc_generic_services,json=ccGenericServices,def=0" json:"cc_generic_services,omitempty"` + JavaGenericServices *bool `protobuf:"varint,17,opt,name=java_generic_services,json=javaGenericServices,def=0" json:"java_generic_services,omitempty"` + PyGenericServices *bool `protobuf:"varint,18,opt,name=py_generic_services,json=pyGenericServices,def=0" json:"py_generic_services,omitempty"` + PhpGenericServices *bool `protobuf:"varint,42,opt,name=php_generic_services,json=phpGenericServices,def=0" json:"php_generic_services,omitempty"` + // Is this file deprecated? + // Depending on the target platform, this can emit Deprecated annotations + // for everything in the file, or it will be completely ignored; in the very + // least, this is a formalization for deprecating files. + Deprecated *bool `protobuf:"varint,23,opt,name=deprecated,def=0" json:"deprecated,omitempty"` + // Enables the use of arenas for the proto messages in this file. This applies + // only to generated classes for C++. + CcEnableArenas *bool `protobuf:"varint,31,opt,name=cc_enable_arenas,json=ccEnableArenas,def=0" json:"cc_enable_arenas,omitempty"` + // Sets the objective c class prefix which is prepended to all objective c + // generated classes from this .proto. There is no default. + ObjcClassPrefix *string `protobuf:"bytes,36,opt,name=objc_class_prefix,json=objcClassPrefix" json:"objc_class_prefix,omitempty"` + // Namespace for generated classes; defaults to the package. + CsharpNamespace *string `protobuf:"bytes,37,opt,name=csharp_namespace,json=csharpNamespace" json:"csharp_namespace,omitempty"` + // By default Swift generators will take the proto package and CamelCase it + // replacing '.' with underscore and use that to prefix the types/symbols + // defined. When this options is provided, they will use this value instead + // to prefix the types/symbols defined. + SwiftPrefix *string `protobuf:"bytes,39,opt,name=swift_prefix,json=swiftPrefix" json:"swift_prefix,omitempty"` + // Sets the php class prefix which is prepended to all php generated classes + // from this .proto. Default is empty. + PhpClassPrefix *string `protobuf:"bytes,40,opt,name=php_class_prefix,json=phpClassPrefix" json:"php_class_prefix,omitempty"` + // Use this option to change the namespace of php generated classes. Default + // is empty. When this option is empty, the package name will be used for + // determining the namespace. + PhpNamespace *string `protobuf:"bytes,41,opt,name=php_namespace,json=phpNamespace" json:"php_namespace,omitempty"` + // The parser stores options it doesn't recognize here. + // See the documentation for the "Options" section above. + UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + proto.XXX_InternalExtensions `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *FileOptions) Reset() { *m = FileOptions{} } +func (m *FileOptions) String() string { return proto.CompactTextString(m) } +func (*FileOptions) ProtoMessage() {} +func (*FileOptions) Descriptor() ([]byte, []int) { + return fileDescriptor_descriptor_9588782fb9cbecd6, []int{10} +} + +var extRange_FileOptions = []proto.ExtensionRange{ + {Start: 1000, End: 536870911}, +} + +func (*FileOptions) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_FileOptions +} +func (m *FileOptions) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_FileOptions.Unmarshal(m, b) +} +func (m *FileOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_FileOptions.Marshal(b, m, deterministic) +} +func (dst *FileOptions) XXX_Merge(src proto.Message) { + xxx_messageInfo_FileOptions.Merge(dst, src) +} +func (m *FileOptions) XXX_Size() int { + return xxx_messageInfo_FileOptions.Size(m) +} +func (m *FileOptions) XXX_DiscardUnknown() { + xxx_messageInfo_FileOptions.DiscardUnknown(m) +} + +var xxx_messageInfo_FileOptions proto.InternalMessageInfo + +const Default_FileOptions_JavaMultipleFiles bool = false +const Default_FileOptions_JavaStringCheckUtf8 bool = false +const Default_FileOptions_OptimizeFor FileOptions_OptimizeMode = FileOptions_SPEED +const Default_FileOptions_CcGenericServices bool = false +const Default_FileOptions_JavaGenericServices bool = false +const Default_FileOptions_PyGenericServices bool = false +const Default_FileOptions_PhpGenericServices bool = false +const Default_FileOptions_Deprecated bool = false +const Default_FileOptions_CcEnableArenas bool = false + +func (m *FileOptions) GetJavaPackage() string { + if m != nil && m.JavaPackage != nil { + return *m.JavaPackage + } + return "" +} + +func (m *FileOptions) GetJavaOuterClassname() string { + if m != nil && m.JavaOuterClassname != nil { + return *m.JavaOuterClassname + } + return "" +} + +func (m *FileOptions) GetJavaMultipleFiles() bool { + if m != nil && m.JavaMultipleFiles != nil { + return *m.JavaMultipleFiles + } + return Default_FileOptions_JavaMultipleFiles +} + +// Deprecated: Do not use. +func (m *FileOptions) GetJavaGenerateEqualsAndHash() bool { + if m != nil && m.JavaGenerateEqualsAndHash != nil { + return *m.JavaGenerateEqualsAndHash + } + return false +} + +func (m *FileOptions) GetJavaStringCheckUtf8() bool { + if m != nil && m.JavaStringCheckUtf8 != nil { + return *m.JavaStringCheckUtf8 + } + return Default_FileOptions_JavaStringCheckUtf8 +} + +func (m *FileOptions) GetOptimizeFor() FileOptions_OptimizeMode { + if m != nil && m.OptimizeFor != nil { + return *m.OptimizeFor + } + return Default_FileOptions_OptimizeFor +} + +func (m *FileOptions) GetGoPackage() string { + if m != nil && m.GoPackage != nil { + return *m.GoPackage + } + return "" +} + +func (m *FileOptions) GetCcGenericServices() bool { + if m != nil && m.CcGenericServices != nil { + return *m.CcGenericServices + } + return Default_FileOptions_CcGenericServices +} + +func (m *FileOptions) GetJavaGenericServices() bool { + if m != nil && m.JavaGenericServices != nil { + return *m.JavaGenericServices + } + return Default_FileOptions_JavaGenericServices +} + +func (m *FileOptions) GetPyGenericServices() bool { + if m != nil && m.PyGenericServices != nil { + return *m.PyGenericServices + } + return Default_FileOptions_PyGenericServices +} + +func (m *FileOptions) GetPhpGenericServices() bool { + if m != nil && m.PhpGenericServices != nil { + return *m.PhpGenericServices + } + return Default_FileOptions_PhpGenericServices +} + +func (m *FileOptions) GetDeprecated() bool { + if m != nil && m.Deprecated != nil { + return *m.Deprecated + } + return Default_FileOptions_Deprecated +} + +func (m *FileOptions) GetCcEnableArenas() bool { + if m != nil && m.CcEnableArenas != nil { + return *m.CcEnableArenas + } + return Default_FileOptions_CcEnableArenas +} + +func (m *FileOptions) GetObjcClassPrefix() string { + if m != nil && m.ObjcClassPrefix != nil { + return *m.ObjcClassPrefix + } + return "" +} + +func (m *FileOptions) GetCsharpNamespace() string { + if m != nil && m.CsharpNamespace != nil { + return *m.CsharpNamespace + } + return "" +} + +func (m *FileOptions) GetSwiftPrefix() string { + if m != nil && m.SwiftPrefix != nil { + return *m.SwiftPrefix + } + return "" +} + +func (m *FileOptions) GetPhpClassPrefix() string { + if m != nil && m.PhpClassPrefix != nil { + return *m.PhpClassPrefix + } + return "" +} + +func (m *FileOptions) GetPhpNamespace() string { + if m != nil && m.PhpNamespace != nil { + return *m.PhpNamespace + } + return "" +} + +func (m *FileOptions) GetUninterpretedOption() []*UninterpretedOption { + if m != nil { + return m.UninterpretedOption + } + return nil +} + +type MessageOptions struct { + // Set true to use the old proto1 MessageSet wire format for extensions. + // This is provided for backwards-compatibility with the MessageSet wire + // format. You should not use this for any other reason: It's less + // efficient, has fewer features, and is more complicated. + // + // The message must be defined exactly as follows: + // message Foo { + // option message_set_wire_format = true; + // extensions 4 to max; + // } + // Note that the message cannot have any defined fields; MessageSets only + // have extensions. + // + // All extensions of your type must be singular messages; e.g. they cannot + // be int32s, enums, or repeated messages. + // + // Because this is an option, the above two restrictions are not enforced by + // the protocol compiler. + MessageSetWireFormat *bool `protobuf:"varint,1,opt,name=message_set_wire_format,json=messageSetWireFormat,def=0" json:"message_set_wire_format,omitempty"` + // Disables the generation of the standard "descriptor()" accessor, which can + // conflict with a field of the same name. This is meant to make migration + // from proto1 easier; new code should avoid fields named "descriptor". + NoStandardDescriptorAccessor *bool `protobuf:"varint,2,opt,name=no_standard_descriptor_accessor,json=noStandardDescriptorAccessor,def=0" json:"no_standard_descriptor_accessor,omitempty"` + // Is this message deprecated? + // Depending on the target platform, this can emit Deprecated annotations + // for the message, or it will be completely ignored; in the very least, + // this is a formalization for deprecating messages. + Deprecated *bool `protobuf:"varint,3,opt,name=deprecated,def=0" json:"deprecated,omitempty"` + // Whether the message is an automatically generated map entry type for the + // maps field. + // + // For maps fields: + // map map_field = 1; + // The parsed descriptor looks like: + // message MapFieldEntry { + // option map_entry = true; + // optional KeyType key = 1; + // optional ValueType value = 2; + // } + // repeated MapFieldEntry map_field = 1; + // + // Implementations may choose not to generate the map_entry=true message, but + // use a native map in the target language to hold the keys and values. + // The reflection APIs in such implementions still need to work as + // if the field is a repeated message field. + // + // NOTE: Do not set the option in .proto files. Always use the maps syntax + // instead. The option should only be implicitly set by the proto compiler + // parser. + MapEntry *bool `protobuf:"varint,7,opt,name=map_entry,json=mapEntry" json:"map_entry,omitempty"` + // The parser stores options it doesn't recognize here. See above. + UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + proto.XXX_InternalExtensions `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *MessageOptions) Reset() { *m = MessageOptions{} } +func (m *MessageOptions) String() string { return proto.CompactTextString(m) } +func (*MessageOptions) ProtoMessage() {} +func (*MessageOptions) Descriptor() ([]byte, []int) { + return fileDescriptor_descriptor_9588782fb9cbecd6, []int{11} +} + +var extRange_MessageOptions = []proto.ExtensionRange{ + {Start: 1000, End: 536870911}, +} + +func (*MessageOptions) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_MessageOptions +} +func (m *MessageOptions) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_MessageOptions.Unmarshal(m, b) +} +func (m *MessageOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_MessageOptions.Marshal(b, m, deterministic) +} +func (dst *MessageOptions) XXX_Merge(src proto.Message) { + xxx_messageInfo_MessageOptions.Merge(dst, src) +} +func (m *MessageOptions) XXX_Size() int { + return xxx_messageInfo_MessageOptions.Size(m) +} +func (m *MessageOptions) XXX_DiscardUnknown() { + xxx_messageInfo_MessageOptions.DiscardUnknown(m) +} + +var xxx_messageInfo_MessageOptions proto.InternalMessageInfo + +const Default_MessageOptions_MessageSetWireFormat bool = false +const Default_MessageOptions_NoStandardDescriptorAccessor bool = false +const Default_MessageOptions_Deprecated bool = false + +func (m *MessageOptions) GetMessageSetWireFormat() bool { + if m != nil && m.MessageSetWireFormat != nil { + return *m.MessageSetWireFormat + } + return Default_MessageOptions_MessageSetWireFormat +} + +func (m *MessageOptions) GetNoStandardDescriptorAccessor() bool { + if m != nil && m.NoStandardDescriptorAccessor != nil { + return *m.NoStandardDescriptorAccessor + } + return Default_MessageOptions_NoStandardDescriptorAccessor +} + +func (m *MessageOptions) GetDeprecated() bool { + if m != nil && m.Deprecated != nil { + return *m.Deprecated + } + return Default_MessageOptions_Deprecated +} + +func (m *MessageOptions) GetMapEntry() bool { + if m != nil && m.MapEntry != nil { + return *m.MapEntry + } + return false +} + +func (m *MessageOptions) GetUninterpretedOption() []*UninterpretedOption { + if m != nil { + return m.UninterpretedOption + } + return nil +} + +type FieldOptions struct { + // The ctype option instructs the C++ code generator to use a different + // representation of the field than it normally would. See the specific + // options below. This option is not yet implemented in the open source + // release -- sorry, we'll try to include it in a future version! + Ctype *FieldOptions_CType `protobuf:"varint,1,opt,name=ctype,enum=google.protobuf.FieldOptions_CType,def=0" json:"ctype,omitempty"` + // The packed option can be enabled for repeated primitive fields to enable + // a more efficient representation on the wire. Rather than repeatedly + // writing the tag and type for each element, the entire array is encoded as + // a single length-delimited blob. In proto3, only explicit setting it to + // false will avoid using packed encoding. + Packed *bool `protobuf:"varint,2,opt,name=packed" json:"packed,omitempty"` + // The jstype option determines the JavaScript type used for values of the + // field. The option is permitted only for 64 bit integral and fixed types + // (int64, uint64, sint64, fixed64, sfixed64). A field with jstype JS_STRING + // is represented as JavaScript string, which avoids loss of precision that + // can happen when a large value is converted to a floating point JavaScript. + // Specifying JS_NUMBER for the jstype causes the generated JavaScript code to + // use the JavaScript "number" type. The behavior of the default option + // JS_NORMAL is implementation dependent. + // + // This option is an enum to permit additional types to be added, e.g. + // goog.math.Integer. + Jstype *FieldOptions_JSType `protobuf:"varint,6,opt,name=jstype,enum=google.protobuf.FieldOptions_JSType,def=0" json:"jstype,omitempty"` + // Should this field be parsed lazily? Lazy applies only to message-type + // fields. It means that when the outer message is initially parsed, the + // inner message's contents will not be parsed but instead stored in encoded + // form. The inner message will actually be parsed when it is first accessed. + // + // This is only a hint. Implementations are free to choose whether to use + // eager or lazy parsing regardless of the value of this option. However, + // setting this option true suggests that the protocol author believes that + // using lazy parsing on this field is worth the additional bookkeeping + // overhead typically needed to implement it. + // + // This option does not affect the public interface of any generated code; + // all method signatures remain the same. Furthermore, thread-safety of the + // interface is not affected by this option; const methods remain safe to + // call from multiple threads concurrently, while non-const methods continue + // to require exclusive access. + // + // + // Note that implementations may choose not to check required fields within + // a lazy sub-message. That is, calling IsInitialized() on the outer message + // may return true even if the inner message has missing required fields. + // This is necessary because otherwise the inner message would have to be + // parsed in order to perform the check, defeating the purpose of lazy + // parsing. An implementation which chooses not to check required fields + // must be consistent about it. That is, for any particular sub-message, the + // implementation must either *always* check its required fields, or *never* + // check its required fields, regardless of whether or not the message has + // been parsed. + Lazy *bool `protobuf:"varint,5,opt,name=lazy,def=0" json:"lazy,omitempty"` + // Is this field deprecated? + // Depending on the target platform, this can emit Deprecated annotations + // for accessors, or it will be completely ignored; in the very least, this + // is a formalization for deprecating fields. + Deprecated *bool `protobuf:"varint,3,opt,name=deprecated,def=0" json:"deprecated,omitempty"` + // For Google-internal migration only. Do not use. + Weak *bool `protobuf:"varint,10,opt,name=weak,def=0" json:"weak,omitempty"` + // The parser stores options it doesn't recognize here. See above. + UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + proto.XXX_InternalExtensions `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *FieldOptions) Reset() { *m = FieldOptions{} } +func (m *FieldOptions) String() string { return proto.CompactTextString(m) } +func (*FieldOptions) ProtoMessage() {} +func (*FieldOptions) Descriptor() ([]byte, []int) { + return fileDescriptor_descriptor_9588782fb9cbecd6, []int{12} +} + +var extRange_FieldOptions = []proto.ExtensionRange{ + {Start: 1000, End: 536870911}, +} + +func (*FieldOptions) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_FieldOptions +} +func (m *FieldOptions) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_FieldOptions.Unmarshal(m, b) +} +func (m *FieldOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_FieldOptions.Marshal(b, m, deterministic) +} +func (dst *FieldOptions) XXX_Merge(src proto.Message) { + xxx_messageInfo_FieldOptions.Merge(dst, src) +} +func (m *FieldOptions) XXX_Size() int { + return xxx_messageInfo_FieldOptions.Size(m) +} +func (m *FieldOptions) XXX_DiscardUnknown() { + xxx_messageInfo_FieldOptions.DiscardUnknown(m) +} + +var xxx_messageInfo_FieldOptions proto.InternalMessageInfo + +const Default_FieldOptions_Ctype FieldOptions_CType = FieldOptions_STRING +const Default_FieldOptions_Jstype FieldOptions_JSType = FieldOptions_JS_NORMAL +const Default_FieldOptions_Lazy bool = false +const Default_FieldOptions_Deprecated bool = false +const Default_FieldOptions_Weak bool = false + +func (m *FieldOptions) GetCtype() FieldOptions_CType { + if m != nil && m.Ctype != nil { + return *m.Ctype + } + return Default_FieldOptions_Ctype +} + +func (m *FieldOptions) GetPacked() bool { + if m != nil && m.Packed != nil { + return *m.Packed + } + return false +} + +func (m *FieldOptions) GetJstype() FieldOptions_JSType { + if m != nil && m.Jstype != nil { + return *m.Jstype + } + return Default_FieldOptions_Jstype +} + +func (m *FieldOptions) GetLazy() bool { + if m != nil && m.Lazy != nil { + return *m.Lazy + } + return Default_FieldOptions_Lazy +} + +func (m *FieldOptions) GetDeprecated() bool { + if m != nil && m.Deprecated != nil { + return *m.Deprecated + } + return Default_FieldOptions_Deprecated +} + +func (m *FieldOptions) GetWeak() bool { + if m != nil && m.Weak != nil { + return *m.Weak + } + return Default_FieldOptions_Weak +} + +func (m *FieldOptions) GetUninterpretedOption() []*UninterpretedOption { + if m != nil { + return m.UninterpretedOption + } + return nil +} + +type OneofOptions struct { + // The parser stores options it doesn't recognize here. See above. + UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + proto.XXX_InternalExtensions `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *OneofOptions) Reset() { *m = OneofOptions{} } +func (m *OneofOptions) String() string { return proto.CompactTextString(m) } +func (*OneofOptions) ProtoMessage() {} +func (*OneofOptions) Descriptor() ([]byte, []int) { + return fileDescriptor_descriptor_9588782fb9cbecd6, []int{13} +} + +var extRange_OneofOptions = []proto.ExtensionRange{ + {Start: 1000, End: 536870911}, +} + +func (*OneofOptions) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_OneofOptions +} +func (m *OneofOptions) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_OneofOptions.Unmarshal(m, b) +} +func (m *OneofOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_OneofOptions.Marshal(b, m, deterministic) +} +func (dst *OneofOptions) XXX_Merge(src proto.Message) { + xxx_messageInfo_OneofOptions.Merge(dst, src) +} +func (m *OneofOptions) XXX_Size() int { + return xxx_messageInfo_OneofOptions.Size(m) +} +func (m *OneofOptions) XXX_DiscardUnknown() { + xxx_messageInfo_OneofOptions.DiscardUnknown(m) +} + +var xxx_messageInfo_OneofOptions proto.InternalMessageInfo + +func (m *OneofOptions) GetUninterpretedOption() []*UninterpretedOption { + if m != nil { + return m.UninterpretedOption + } + return nil +} + +type EnumOptions struct { + // Set this option to true to allow mapping different tag names to the same + // value. + AllowAlias *bool `protobuf:"varint,2,opt,name=allow_alias,json=allowAlias" json:"allow_alias,omitempty"` + // Is this enum deprecated? + // Depending on the target platform, this can emit Deprecated annotations + // for the enum, or it will be completely ignored; in the very least, this + // is a formalization for deprecating enums. + Deprecated *bool `protobuf:"varint,3,opt,name=deprecated,def=0" json:"deprecated,omitempty"` + // The parser stores options it doesn't recognize here. See above. + UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + proto.XXX_InternalExtensions `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *EnumOptions) Reset() { *m = EnumOptions{} } +func (m *EnumOptions) String() string { return proto.CompactTextString(m) } +func (*EnumOptions) ProtoMessage() {} +func (*EnumOptions) Descriptor() ([]byte, []int) { + return fileDescriptor_descriptor_9588782fb9cbecd6, []int{14} +} + +var extRange_EnumOptions = []proto.ExtensionRange{ + {Start: 1000, End: 536870911}, +} + +func (*EnumOptions) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_EnumOptions +} +func (m *EnumOptions) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_EnumOptions.Unmarshal(m, b) +} +func (m *EnumOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_EnumOptions.Marshal(b, m, deterministic) +} +func (dst *EnumOptions) XXX_Merge(src proto.Message) { + xxx_messageInfo_EnumOptions.Merge(dst, src) +} +func (m *EnumOptions) XXX_Size() int { + return xxx_messageInfo_EnumOptions.Size(m) +} +func (m *EnumOptions) XXX_DiscardUnknown() { + xxx_messageInfo_EnumOptions.DiscardUnknown(m) +} + +var xxx_messageInfo_EnumOptions proto.InternalMessageInfo + +const Default_EnumOptions_Deprecated bool = false + +func (m *EnumOptions) GetAllowAlias() bool { + if m != nil && m.AllowAlias != nil { + return *m.AllowAlias + } + return false +} + +func (m *EnumOptions) GetDeprecated() bool { + if m != nil && m.Deprecated != nil { + return *m.Deprecated + } + return Default_EnumOptions_Deprecated +} + +func (m *EnumOptions) GetUninterpretedOption() []*UninterpretedOption { + if m != nil { + return m.UninterpretedOption + } + return nil +} + +type EnumValueOptions struct { + // Is this enum value deprecated? + // Depending on the target platform, this can emit Deprecated annotations + // for the enum value, or it will be completely ignored; in the very least, + // this is a formalization for deprecating enum values. + Deprecated *bool `protobuf:"varint,1,opt,name=deprecated,def=0" json:"deprecated,omitempty"` + // The parser stores options it doesn't recognize here. See above. + UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + proto.XXX_InternalExtensions `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *EnumValueOptions) Reset() { *m = EnumValueOptions{} } +func (m *EnumValueOptions) String() string { return proto.CompactTextString(m) } +func (*EnumValueOptions) ProtoMessage() {} +func (*EnumValueOptions) Descriptor() ([]byte, []int) { + return fileDescriptor_descriptor_9588782fb9cbecd6, []int{15} +} + +var extRange_EnumValueOptions = []proto.ExtensionRange{ + {Start: 1000, End: 536870911}, +} + +func (*EnumValueOptions) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_EnumValueOptions +} +func (m *EnumValueOptions) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_EnumValueOptions.Unmarshal(m, b) +} +func (m *EnumValueOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_EnumValueOptions.Marshal(b, m, deterministic) +} +func (dst *EnumValueOptions) XXX_Merge(src proto.Message) { + xxx_messageInfo_EnumValueOptions.Merge(dst, src) +} +func (m *EnumValueOptions) XXX_Size() int { + return xxx_messageInfo_EnumValueOptions.Size(m) +} +func (m *EnumValueOptions) XXX_DiscardUnknown() { + xxx_messageInfo_EnumValueOptions.DiscardUnknown(m) +} + +var xxx_messageInfo_EnumValueOptions proto.InternalMessageInfo + +const Default_EnumValueOptions_Deprecated bool = false + +func (m *EnumValueOptions) GetDeprecated() bool { + if m != nil && m.Deprecated != nil { + return *m.Deprecated + } + return Default_EnumValueOptions_Deprecated +} + +func (m *EnumValueOptions) GetUninterpretedOption() []*UninterpretedOption { + if m != nil { + return m.UninterpretedOption + } + return nil +} + +type ServiceOptions struct { + // Is this service deprecated? + // Depending on the target platform, this can emit Deprecated annotations + // for the service, or it will be completely ignored; in the very least, + // this is a formalization for deprecating services. + Deprecated *bool `protobuf:"varint,33,opt,name=deprecated,def=0" json:"deprecated,omitempty"` + // The parser stores options it doesn't recognize here. See above. + UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + proto.XXX_InternalExtensions `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ServiceOptions) Reset() { *m = ServiceOptions{} } +func (m *ServiceOptions) String() string { return proto.CompactTextString(m) } +func (*ServiceOptions) ProtoMessage() {} +func (*ServiceOptions) Descriptor() ([]byte, []int) { + return fileDescriptor_descriptor_9588782fb9cbecd6, []int{16} +} + +var extRange_ServiceOptions = []proto.ExtensionRange{ + {Start: 1000, End: 536870911}, +} + +func (*ServiceOptions) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_ServiceOptions +} +func (m *ServiceOptions) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ServiceOptions.Unmarshal(m, b) +} +func (m *ServiceOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ServiceOptions.Marshal(b, m, deterministic) +} +func (dst *ServiceOptions) XXX_Merge(src proto.Message) { + xxx_messageInfo_ServiceOptions.Merge(dst, src) +} +func (m *ServiceOptions) XXX_Size() int { + return xxx_messageInfo_ServiceOptions.Size(m) +} +func (m *ServiceOptions) XXX_DiscardUnknown() { + xxx_messageInfo_ServiceOptions.DiscardUnknown(m) +} + +var xxx_messageInfo_ServiceOptions proto.InternalMessageInfo + +const Default_ServiceOptions_Deprecated bool = false + +func (m *ServiceOptions) GetDeprecated() bool { + if m != nil && m.Deprecated != nil { + return *m.Deprecated + } + return Default_ServiceOptions_Deprecated +} + +func (m *ServiceOptions) GetUninterpretedOption() []*UninterpretedOption { + if m != nil { + return m.UninterpretedOption + } + return nil +} + +type MethodOptions struct { + // Is this method deprecated? + // Depending on the target platform, this can emit Deprecated annotations + // for the method, or it will be completely ignored; in the very least, + // this is a formalization for deprecating methods. + Deprecated *bool `protobuf:"varint,33,opt,name=deprecated,def=0" json:"deprecated,omitempty"` + IdempotencyLevel *MethodOptions_IdempotencyLevel `protobuf:"varint,34,opt,name=idempotency_level,json=idempotencyLevel,enum=google.protobuf.MethodOptions_IdempotencyLevel,def=0" json:"idempotency_level,omitempty"` + // The parser stores options it doesn't recognize here. See above. + UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + proto.XXX_InternalExtensions `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *MethodOptions) Reset() { *m = MethodOptions{} } +func (m *MethodOptions) String() string { return proto.CompactTextString(m) } +func (*MethodOptions) ProtoMessage() {} +func (*MethodOptions) Descriptor() ([]byte, []int) { + return fileDescriptor_descriptor_9588782fb9cbecd6, []int{17} +} + +var extRange_MethodOptions = []proto.ExtensionRange{ + {Start: 1000, End: 536870911}, +} + +func (*MethodOptions) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_MethodOptions +} +func (m *MethodOptions) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_MethodOptions.Unmarshal(m, b) +} +func (m *MethodOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_MethodOptions.Marshal(b, m, deterministic) +} +func (dst *MethodOptions) XXX_Merge(src proto.Message) { + xxx_messageInfo_MethodOptions.Merge(dst, src) +} +func (m *MethodOptions) XXX_Size() int { + return xxx_messageInfo_MethodOptions.Size(m) +} +func (m *MethodOptions) XXX_DiscardUnknown() { + xxx_messageInfo_MethodOptions.DiscardUnknown(m) +} + +var xxx_messageInfo_MethodOptions proto.InternalMessageInfo + +const Default_MethodOptions_Deprecated bool = false +const Default_MethodOptions_IdempotencyLevel MethodOptions_IdempotencyLevel = MethodOptions_IDEMPOTENCY_UNKNOWN + +func (m *MethodOptions) GetDeprecated() bool { + if m != nil && m.Deprecated != nil { + return *m.Deprecated + } + return Default_MethodOptions_Deprecated +} + +func (m *MethodOptions) GetIdempotencyLevel() MethodOptions_IdempotencyLevel { + if m != nil && m.IdempotencyLevel != nil { + return *m.IdempotencyLevel + } + return Default_MethodOptions_IdempotencyLevel +} + +func (m *MethodOptions) GetUninterpretedOption() []*UninterpretedOption { + if m != nil { + return m.UninterpretedOption + } + return nil +} + +// A message representing a option the parser does not recognize. This only +// appears in options protos created by the compiler::Parser class. +// DescriptorPool resolves these when building Descriptor objects. Therefore, +// options protos in descriptor objects (e.g. returned by Descriptor::options(), +// or produced by Descriptor::CopyTo()) will never have UninterpretedOptions +// in them. +type UninterpretedOption struct { + Name []*UninterpretedOption_NamePart `protobuf:"bytes,2,rep,name=name" json:"name,omitempty"` + // The value of the uninterpreted option, in whatever type the tokenizer + // identified it as during parsing. Exactly one of these should be set. + IdentifierValue *string `protobuf:"bytes,3,opt,name=identifier_value,json=identifierValue" json:"identifier_value,omitempty"` + PositiveIntValue *uint64 `protobuf:"varint,4,opt,name=positive_int_value,json=positiveIntValue" json:"positive_int_value,omitempty"` + NegativeIntValue *int64 `protobuf:"varint,5,opt,name=negative_int_value,json=negativeIntValue" json:"negative_int_value,omitempty"` + DoubleValue *float64 `protobuf:"fixed64,6,opt,name=double_value,json=doubleValue" json:"double_value,omitempty"` + StringValue []byte `protobuf:"bytes,7,opt,name=string_value,json=stringValue" json:"string_value,omitempty"` + AggregateValue *string `protobuf:"bytes,8,opt,name=aggregate_value,json=aggregateValue" json:"aggregate_value,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *UninterpretedOption) Reset() { *m = UninterpretedOption{} } +func (m *UninterpretedOption) String() string { return proto.CompactTextString(m) } +func (*UninterpretedOption) ProtoMessage() {} +func (*UninterpretedOption) Descriptor() ([]byte, []int) { + return fileDescriptor_descriptor_9588782fb9cbecd6, []int{18} +} +func (m *UninterpretedOption) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_UninterpretedOption.Unmarshal(m, b) +} +func (m *UninterpretedOption) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_UninterpretedOption.Marshal(b, m, deterministic) +} +func (dst *UninterpretedOption) XXX_Merge(src proto.Message) { + xxx_messageInfo_UninterpretedOption.Merge(dst, src) +} +func (m *UninterpretedOption) XXX_Size() int { + return xxx_messageInfo_UninterpretedOption.Size(m) +} +func (m *UninterpretedOption) XXX_DiscardUnknown() { + xxx_messageInfo_UninterpretedOption.DiscardUnknown(m) +} + +var xxx_messageInfo_UninterpretedOption proto.InternalMessageInfo + +func (m *UninterpretedOption) GetName() []*UninterpretedOption_NamePart { + if m != nil { + return m.Name + } + return nil +} + +func (m *UninterpretedOption) GetIdentifierValue() string { + if m != nil && m.IdentifierValue != nil { + return *m.IdentifierValue + } + return "" +} + +func (m *UninterpretedOption) GetPositiveIntValue() uint64 { + if m != nil && m.PositiveIntValue != nil { + return *m.PositiveIntValue + } + return 0 +} + +func (m *UninterpretedOption) GetNegativeIntValue() int64 { + if m != nil && m.NegativeIntValue != nil { + return *m.NegativeIntValue + } + return 0 +} + +func (m *UninterpretedOption) GetDoubleValue() float64 { + if m != nil && m.DoubleValue != nil { + return *m.DoubleValue + } + return 0 +} + +func (m *UninterpretedOption) GetStringValue() []byte { + if m != nil { + return m.StringValue + } + return nil +} + +func (m *UninterpretedOption) GetAggregateValue() string { + if m != nil && m.AggregateValue != nil { + return *m.AggregateValue + } + return "" +} + +// The name of the uninterpreted option. Each string represents a segment in +// a dot-separated name. is_extension is true iff a segment represents an +// extension (denoted with parentheses in options specs in .proto files). +// E.g.,{ ["foo", false], ["bar.baz", true], ["qux", false] } represents +// "foo.(bar.baz).qux". +type UninterpretedOption_NamePart struct { + NamePart *string `protobuf:"bytes,1,req,name=name_part,json=namePart" json:"name_part,omitempty"` + IsExtension *bool `protobuf:"varint,2,req,name=is_extension,json=isExtension" json:"is_extension,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *UninterpretedOption_NamePart) Reset() { *m = UninterpretedOption_NamePart{} } +func (m *UninterpretedOption_NamePart) String() string { return proto.CompactTextString(m) } +func (*UninterpretedOption_NamePart) ProtoMessage() {} +func (*UninterpretedOption_NamePart) Descriptor() ([]byte, []int) { + return fileDescriptor_descriptor_9588782fb9cbecd6, []int{18, 0} +} +func (m *UninterpretedOption_NamePart) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_UninterpretedOption_NamePart.Unmarshal(m, b) +} +func (m *UninterpretedOption_NamePart) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_UninterpretedOption_NamePart.Marshal(b, m, deterministic) +} +func (dst *UninterpretedOption_NamePart) XXX_Merge(src proto.Message) { + xxx_messageInfo_UninterpretedOption_NamePart.Merge(dst, src) +} +func (m *UninterpretedOption_NamePart) XXX_Size() int { + return xxx_messageInfo_UninterpretedOption_NamePart.Size(m) +} +func (m *UninterpretedOption_NamePart) XXX_DiscardUnknown() { + xxx_messageInfo_UninterpretedOption_NamePart.DiscardUnknown(m) +} + +var xxx_messageInfo_UninterpretedOption_NamePart proto.InternalMessageInfo + +func (m *UninterpretedOption_NamePart) GetNamePart() string { + if m != nil && m.NamePart != nil { + return *m.NamePart + } + return "" +} + +func (m *UninterpretedOption_NamePart) GetIsExtension() bool { + if m != nil && m.IsExtension != nil { + return *m.IsExtension + } + return false +} + +// Encapsulates information about the original source file from which a +// FileDescriptorProto was generated. +type SourceCodeInfo struct { + // A Location identifies a piece of source code in a .proto file which + // corresponds to a particular definition. This information is intended + // to be useful to IDEs, code indexers, documentation generators, and similar + // tools. + // + // For example, say we have a file like: + // message Foo { + // optional string foo = 1; + // } + // Let's look at just the field definition: + // optional string foo = 1; + // ^ ^^ ^^ ^ ^^^ + // a bc de f ghi + // We have the following locations: + // span path represents + // [a,i) [ 4, 0, 2, 0 ] The whole field definition. + // [a,b) [ 4, 0, 2, 0, 4 ] The label (optional). + // [c,d) [ 4, 0, 2, 0, 5 ] The type (string). + // [e,f) [ 4, 0, 2, 0, 1 ] The name (foo). + // [g,h) [ 4, 0, 2, 0, 3 ] The number (1). + // + // Notes: + // - A location may refer to a repeated field itself (i.e. not to any + // particular index within it). This is used whenever a set of elements are + // logically enclosed in a single code segment. For example, an entire + // extend block (possibly containing multiple extension definitions) will + // have an outer location whose path refers to the "extensions" repeated + // field without an index. + // - Multiple locations may have the same path. This happens when a single + // logical declaration is spread out across multiple places. The most + // obvious example is the "extend" block again -- there may be multiple + // extend blocks in the same scope, each of which will have the same path. + // - A location's span is not always a subset of its parent's span. For + // example, the "extendee" of an extension declaration appears at the + // beginning of the "extend" block and is shared by all extensions within + // the block. + // - Just because a location's span is a subset of some other location's span + // does not mean that it is a descendent. For example, a "group" defines + // both a type and a field in a single declaration. Thus, the locations + // corresponding to the type and field and their components will overlap. + // - Code which tries to interpret locations should probably be designed to + // ignore those that it doesn't understand, as more types of locations could + // be recorded in the future. + Location []*SourceCodeInfo_Location `protobuf:"bytes,1,rep,name=location" json:"location,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *SourceCodeInfo) Reset() { *m = SourceCodeInfo{} } +func (m *SourceCodeInfo) String() string { return proto.CompactTextString(m) } +func (*SourceCodeInfo) ProtoMessage() {} +func (*SourceCodeInfo) Descriptor() ([]byte, []int) { + return fileDescriptor_descriptor_9588782fb9cbecd6, []int{19} +} +func (m *SourceCodeInfo) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_SourceCodeInfo.Unmarshal(m, b) +} +func (m *SourceCodeInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_SourceCodeInfo.Marshal(b, m, deterministic) +} +func (dst *SourceCodeInfo) XXX_Merge(src proto.Message) { + xxx_messageInfo_SourceCodeInfo.Merge(dst, src) +} +func (m *SourceCodeInfo) XXX_Size() int { + return xxx_messageInfo_SourceCodeInfo.Size(m) +} +func (m *SourceCodeInfo) XXX_DiscardUnknown() { + xxx_messageInfo_SourceCodeInfo.DiscardUnknown(m) +} + +var xxx_messageInfo_SourceCodeInfo proto.InternalMessageInfo + +func (m *SourceCodeInfo) GetLocation() []*SourceCodeInfo_Location { + if m != nil { + return m.Location + } + return nil +} + +type SourceCodeInfo_Location struct { + // Identifies which part of the FileDescriptorProto was defined at this + // location. + // + // Each element is a field number or an index. They form a path from + // the root FileDescriptorProto to the place where the definition. For + // example, this path: + // [ 4, 3, 2, 7, 1 ] + // refers to: + // file.message_type(3) // 4, 3 + // .field(7) // 2, 7 + // .name() // 1 + // This is because FileDescriptorProto.message_type has field number 4: + // repeated DescriptorProto message_type = 4; + // and DescriptorProto.field has field number 2: + // repeated FieldDescriptorProto field = 2; + // and FieldDescriptorProto.name has field number 1: + // optional string name = 1; + // + // Thus, the above path gives the location of a field name. If we removed + // the last element: + // [ 4, 3, 2, 7 ] + // this path refers to the whole field declaration (from the beginning + // of the label to the terminating semicolon). + Path []int32 `protobuf:"varint,1,rep,packed,name=path" json:"path,omitempty"` + // Always has exactly three or four elements: start line, start column, + // end line (optional, otherwise assumed same as start line), end column. + // These are packed into a single field for efficiency. Note that line + // and column numbers are zero-based -- typically you will want to add + // 1 to each before displaying to a user. + Span []int32 `protobuf:"varint,2,rep,packed,name=span" json:"span,omitempty"` + // If this SourceCodeInfo represents a complete declaration, these are any + // comments appearing before and after the declaration which appear to be + // attached to the declaration. + // + // A series of line comments appearing on consecutive lines, with no other + // tokens appearing on those lines, will be treated as a single comment. + // + // leading_detached_comments will keep paragraphs of comments that appear + // before (but not connected to) the current element. Each paragraph, + // separated by empty lines, will be one comment element in the repeated + // field. + // + // Only the comment content is provided; comment markers (e.g. //) are + // stripped out. For block comments, leading whitespace and an asterisk + // will be stripped from the beginning of each line other than the first. + // Newlines are included in the output. + // + // Examples: + // + // optional int32 foo = 1; // Comment attached to foo. + // // Comment attached to bar. + // optional int32 bar = 2; + // + // optional string baz = 3; + // // Comment attached to baz. + // // Another line attached to baz. + // + // // Comment attached to qux. + // // + // // Another line attached to qux. + // optional double qux = 4; + // + // // Detached comment for corge. This is not leading or trailing comments + // // to qux or corge because there are blank lines separating it from + // // both. + // + // // Detached comment for corge paragraph 2. + // + // optional string corge = 5; + // /* Block comment attached + // * to corge. Leading asterisks + // * will be removed. */ + // /* Block comment attached to + // * grault. */ + // optional int32 grault = 6; + // + // // ignored detached comments. + LeadingComments *string `protobuf:"bytes,3,opt,name=leading_comments,json=leadingComments" json:"leading_comments,omitempty"` + TrailingComments *string `protobuf:"bytes,4,opt,name=trailing_comments,json=trailingComments" json:"trailing_comments,omitempty"` + LeadingDetachedComments []string `protobuf:"bytes,6,rep,name=leading_detached_comments,json=leadingDetachedComments" json:"leading_detached_comments,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *SourceCodeInfo_Location) Reset() { *m = SourceCodeInfo_Location{} } +func (m *SourceCodeInfo_Location) String() string { return proto.CompactTextString(m) } +func (*SourceCodeInfo_Location) ProtoMessage() {} +func (*SourceCodeInfo_Location) Descriptor() ([]byte, []int) { + return fileDescriptor_descriptor_9588782fb9cbecd6, []int{19, 0} +} +func (m *SourceCodeInfo_Location) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_SourceCodeInfo_Location.Unmarshal(m, b) +} +func (m *SourceCodeInfo_Location) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_SourceCodeInfo_Location.Marshal(b, m, deterministic) +} +func (dst *SourceCodeInfo_Location) XXX_Merge(src proto.Message) { + xxx_messageInfo_SourceCodeInfo_Location.Merge(dst, src) +} +func (m *SourceCodeInfo_Location) XXX_Size() int { + return xxx_messageInfo_SourceCodeInfo_Location.Size(m) +} +func (m *SourceCodeInfo_Location) XXX_DiscardUnknown() { + xxx_messageInfo_SourceCodeInfo_Location.DiscardUnknown(m) +} + +var xxx_messageInfo_SourceCodeInfo_Location proto.InternalMessageInfo + +func (m *SourceCodeInfo_Location) GetPath() []int32 { + if m != nil { + return m.Path + } + return nil +} + +func (m *SourceCodeInfo_Location) GetSpan() []int32 { + if m != nil { + return m.Span + } + return nil +} + +func (m *SourceCodeInfo_Location) GetLeadingComments() string { + if m != nil && m.LeadingComments != nil { + return *m.LeadingComments + } + return "" +} + +func (m *SourceCodeInfo_Location) GetTrailingComments() string { + if m != nil && m.TrailingComments != nil { + return *m.TrailingComments + } + return "" +} + +func (m *SourceCodeInfo_Location) GetLeadingDetachedComments() []string { + if m != nil { + return m.LeadingDetachedComments + } + return nil +} + +// Describes the relationship between generated code and its original source +// file. A GeneratedCodeInfo message is associated with only one generated +// source file, but may contain references to different source .proto files. +type GeneratedCodeInfo struct { + // An Annotation connects some span of text in generated code to an element + // of its generating .proto file. + Annotation []*GeneratedCodeInfo_Annotation `protobuf:"bytes,1,rep,name=annotation" json:"annotation,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *GeneratedCodeInfo) Reset() { *m = GeneratedCodeInfo{} } +func (m *GeneratedCodeInfo) String() string { return proto.CompactTextString(m) } +func (*GeneratedCodeInfo) ProtoMessage() {} +func (*GeneratedCodeInfo) Descriptor() ([]byte, []int) { + return fileDescriptor_descriptor_9588782fb9cbecd6, []int{20} +} +func (m *GeneratedCodeInfo) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_GeneratedCodeInfo.Unmarshal(m, b) +} +func (m *GeneratedCodeInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_GeneratedCodeInfo.Marshal(b, m, deterministic) +} +func (dst *GeneratedCodeInfo) XXX_Merge(src proto.Message) { + xxx_messageInfo_GeneratedCodeInfo.Merge(dst, src) +} +func (m *GeneratedCodeInfo) XXX_Size() int { + return xxx_messageInfo_GeneratedCodeInfo.Size(m) +} +func (m *GeneratedCodeInfo) XXX_DiscardUnknown() { + xxx_messageInfo_GeneratedCodeInfo.DiscardUnknown(m) +} + +var xxx_messageInfo_GeneratedCodeInfo proto.InternalMessageInfo + +func (m *GeneratedCodeInfo) GetAnnotation() []*GeneratedCodeInfo_Annotation { + if m != nil { + return m.Annotation + } + return nil +} + +type GeneratedCodeInfo_Annotation struct { + // Identifies the element in the original source .proto file. This field + // is formatted the same as SourceCodeInfo.Location.path. + Path []int32 `protobuf:"varint,1,rep,packed,name=path" json:"path,omitempty"` + // Identifies the filesystem path to the original source .proto. + SourceFile *string `protobuf:"bytes,2,opt,name=source_file,json=sourceFile" json:"source_file,omitempty"` + // Identifies the starting offset in bytes in the generated code + // that relates to the identified object. + Begin *int32 `protobuf:"varint,3,opt,name=begin" json:"begin,omitempty"` + // Identifies the ending offset in bytes in the generated code that + // relates to the identified offset. The end offset should be one past + // the last relevant byte (so the length of the text = end - begin). + End *int32 `protobuf:"varint,4,opt,name=end" json:"end,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *GeneratedCodeInfo_Annotation) Reset() { *m = GeneratedCodeInfo_Annotation{} } +func (m *GeneratedCodeInfo_Annotation) String() string { return proto.CompactTextString(m) } +func (*GeneratedCodeInfo_Annotation) ProtoMessage() {} +func (*GeneratedCodeInfo_Annotation) Descriptor() ([]byte, []int) { + return fileDescriptor_descriptor_9588782fb9cbecd6, []int{20, 0} +} +func (m *GeneratedCodeInfo_Annotation) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_GeneratedCodeInfo_Annotation.Unmarshal(m, b) +} +func (m *GeneratedCodeInfo_Annotation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_GeneratedCodeInfo_Annotation.Marshal(b, m, deterministic) +} +func (dst *GeneratedCodeInfo_Annotation) XXX_Merge(src proto.Message) { + xxx_messageInfo_GeneratedCodeInfo_Annotation.Merge(dst, src) +} +func (m *GeneratedCodeInfo_Annotation) XXX_Size() int { + return xxx_messageInfo_GeneratedCodeInfo_Annotation.Size(m) +} +func (m *GeneratedCodeInfo_Annotation) XXX_DiscardUnknown() { + xxx_messageInfo_GeneratedCodeInfo_Annotation.DiscardUnknown(m) +} + +var xxx_messageInfo_GeneratedCodeInfo_Annotation proto.InternalMessageInfo + +func (m *GeneratedCodeInfo_Annotation) GetPath() []int32 { + if m != nil { + return m.Path + } + return nil +} + +func (m *GeneratedCodeInfo_Annotation) GetSourceFile() string { + if m != nil && m.SourceFile != nil { + return *m.SourceFile + } + return "" +} + +func (m *GeneratedCodeInfo_Annotation) GetBegin() int32 { + if m != nil && m.Begin != nil { + return *m.Begin + } + return 0 +} + +func (m *GeneratedCodeInfo_Annotation) GetEnd() int32 { + if m != nil && m.End != nil { + return *m.End + } + return 0 +} + +func init() { + proto.RegisterType((*FileDescriptorSet)(nil), "google.protobuf.FileDescriptorSet") + proto.RegisterType((*FileDescriptorProto)(nil), "google.protobuf.FileDescriptorProto") + proto.RegisterType((*DescriptorProto)(nil), "google.protobuf.DescriptorProto") + proto.RegisterType((*DescriptorProto_ExtensionRange)(nil), "google.protobuf.DescriptorProto.ExtensionRange") + proto.RegisterType((*DescriptorProto_ReservedRange)(nil), "google.protobuf.DescriptorProto.ReservedRange") + proto.RegisterType((*ExtensionRangeOptions)(nil), "google.protobuf.ExtensionRangeOptions") + proto.RegisterType((*FieldDescriptorProto)(nil), "google.protobuf.FieldDescriptorProto") + proto.RegisterType((*OneofDescriptorProto)(nil), "google.protobuf.OneofDescriptorProto") + proto.RegisterType((*EnumDescriptorProto)(nil), "google.protobuf.EnumDescriptorProto") + proto.RegisterType((*EnumDescriptorProto_EnumReservedRange)(nil), "google.protobuf.EnumDescriptorProto.EnumReservedRange") + proto.RegisterType((*EnumValueDescriptorProto)(nil), "google.protobuf.EnumValueDescriptorProto") + proto.RegisterType((*ServiceDescriptorProto)(nil), "google.protobuf.ServiceDescriptorProto") + proto.RegisterType((*MethodDescriptorProto)(nil), "google.protobuf.MethodDescriptorProto") + proto.RegisterType((*FileOptions)(nil), "google.protobuf.FileOptions") + proto.RegisterType((*MessageOptions)(nil), "google.protobuf.MessageOptions") + proto.RegisterType((*FieldOptions)(nil), "google.protobuf.FieldOptions") + proto.RegisterType((*OneofOptions)(nil), "google.protobuf.OneofOptions") + proto.RegisterType((*EnumOptions)(nil), "google.protobuf.EnumOptions") + proto.RegisterType((*EnumValueOptions)(nil), "google.protobuf.EnumValueOptions") + proto.RegisterType((*ServiceOptions)(nil), "google.protobuf.ServiceOptions") + proto.RegisterType((*MethodOptions)(nil), "google.protobuf.MethodOptions") + proto.RegisterType((*UninterpretedOption)(nil), "google.protobuf.UninterpretedOption") + proto.RegisterType((*UninterpretedOption_NamePart)(nil), "google.protobuf.UninterpretedOption.NamePart") + proto.RegisterType((*SourceCodeInfo)(nil), "google.protobuf.SourceCodeInfo") + proto.RegisterType((*SourceCodeInfo_Location)(nil), "google.protobuf.SourceCodeInfo.Location") + proto.RegisterType((*GeneratedCodeInfo)(nil), "google.protobuf.GeneratedCodeInfo") + proto.RegisterType((*GeneratedCodeInfo_Annotation)(nil), "google.protobuf.GeneratedCodeInfo.Annotation") + proto.RegisterEnum("google.protobuf.FieldDescriptorProto_Type", FieldDescriptorProto_Type_name, FieldDescriptorProto_Type_value) + proto.RegisterEnum("google.protobuf.FieldDescriptorProto_Label", FieldDescriptorProto_Label_name, FieldDescriptorProto_Label_value) + proto.RegisterEnum("google.protobuf.FileOptions_OptimizeMode", FileOptions_OptimizeMode_name, FileOptions_OptimizeMode_value) + proto.RegisterEnum("google.protobuf.FieldOptions_CType", FieldOptions_CType_name, FieldOptions_CType_value) + proto.RegisterEnum("google.protobuf.FieldOptions_JSType", FieldOptions_JSType_name, FieldOptions_JSType_value) + proto.RegisterEnum("google.protobuf.MethodOptions_IdempotencyLevel", MethodOptions_IdempotencyLevel_name, MethodOptions_IdempotencyLevel_value) +} + +func init() { proto.RegisterFile("descriptor.proto", fileDescriptor_descriptor_9588782fb9cbecd6) } + +var fileDescriptor_descriptor_9588782fb9cbecd6 = []byte{ + // 2487 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x59, 0xcd, 0x6f, 0xdb, 0xc8, + 0x15, 0x5f, 0x7d, 0x5a, 0x7a, 0x92, 0xe5, 0xf1, 0xd8, 0x9b, 0x30, 0xde, 0x8f, 0x38, 0xda, 0x8f, + 0x38, 0x49, 0xab, 0x2c, 0x9c, 0xc4, 0xc9, 0x3a, 0xc5, 0xb6, 0xb2, 0xc4, 0x78, 0x95, 0xca, 0x92, + 0x4a, 0xc9, 0xdd, 0x64, 0x8b, 0x82, 0x18, 0x93, 0x23, 0x89, 0x09, 0x45, 0x72, 0x49, 0x2a, 0x89, + 0x83, 0x1e, 0x02, 0xf4, 0xd4, 0xff, 0xa0, 0x28, 0x8a, 0x1e, 0x7a, 0x59, 0xa0, 0xd7, 0x02, 0x05, + 0xda, 0x7b, 0xaf, 0x05, 0x7a, 0xef, 0xa1, 0x40, 0x0b, 0xb4, 0x7f, 0x42, 0x8f, 0xc5, 0xcc, 0x90, + 0x14, 0xf5, 0x95, 0x78, 0x17, 0x48, 0xf6, 0x64, 0xcf, 0xef, 0xfd, 0xde, 0xe3, 0x9b, 0x37, 0x6f, + 0xde, 0xbc, 0x19, 0x01, 0xd2, 0xa9, 0xa7, 0xb9, 0x86, 0xe3, 0xdb, 0x6e, 0xc5, 0x71, 0x6d, 0xdf, + 0xc6, 0x6b, 0x03, 0xdb, 0x1e, 0x98, 0x54, 0x8c, 0x4e, 0xc6, 0xfd, 0xf2, 0x11, 0xac, 0xdf, 0x33, + 0x4c, 0x5a, 0x8f, 0x88, 0x5d, 0xea, 0xe3, 0x3b, 0x90, 0xee, 0x1b, 0x26, 0x95, 0x12, 0xdb, 0xa9, + 0x9d, 0xc2, 0xee, 0x87, 0x95, 0x19, 0xa5, 0xca, 0xb4, 0x46, 0x87, 0xc1, 0x0a, 0xd7, 0x28, 0xff, + 0x3b, 0x0d, 0x1b, 0x0b, 0xa4, 0x18, 0x43, 0xda, 0x22, 0x23, 0x66, 0x31, 0xb1, 0x93, 0x57, 0xf8, + 0xff, 0x58, 0x82, 0x15, 0x87, 0x68, 0x8f, 0xc9, 0x80, 0x4a, 0x49, 0x0e, 0x87, 0x43, 0xfc, 0x3e, + 0x80, 0x4e, 0x1d, 0x6a, 0xe9, 0xd4, 0xd2, 0x4e, 0xa5, 0xd4, 0x76, 0x6a, 0x27, 0xaf, 0xc4, 0x10, + 0x7c, 0x0d, 0xd6, 0x9d, 0xf1, 0x89, 0x69, 0x68, 0x6a, 0x8c, 0x06, 0xdb, 0xa9, 0x9d, 0x8c, 0x82, + 0x84, 0xa0, 0x3e, 0x21, 0x5f, 0x86, 0xb5, 0xa7, 0x94, 0x3c, 0x8e, 0x53, 0x0b, 0x9c, 0x5a, 0x62, + 0x70, 0x8c, 0x58, 0x83, 0xe2, 0x88, 0x7a, 0x1e, 0x19, 0x50, 0xd5, 0x3f, 0x75, 0xa8, 0x94, 0xe6, + 0xb3, 0xdf, 0x9e, 0x9b, 0xfd, 0xec, 0xcc, 0x0b, 0x81, 0x56, 0xef, 0xd4, 0xa1, 0xb8, 0x0a, 0x79, + 0x6a, 0x8d, 0x47, 0xc2, 0x42, 0x66, 0x49, 0xfc, 0x64, 0x6b, 0x3c, 0x9a, 0xb5, 0x92, 0x63, 0x6a, + 0x81, 0x89, 0x15, 0x8f, 0xba, 0x4f, 0x0c, 0x8d, 0x4a, 0x59, 0x6e, 0xe0, 0xf2, 0x9c, 0x81, 0xae, + 0x90, 0xcf, 0xda, 0x08, 0xf5, 0x70, 0x0d, 0xf2, 0xf4, 0x99, 0x4f, 0x2d, 0xcf, 0xb0, 0x2d, 0x69, + 0x85, 0x1b, 0xf9, 0x68, 0xc1, 0x2a, 0x52, 0x53, 0x9f, 0x35, 0x31, 0xd1, 0xc3, 0x7b, 0xb0, 0x62, + 0x3b, 0xbe, 0x61, 0x5b, 0x9e, 0x94, 0xdb, 0x4e, 0xec, 0x14, 0x76, 0xdf, 0x5d, 0x98, 0x08, 0x6d, + 0xc1, 0x51, 0x42, 0x32, 0x6e, 0x00, 0xf2, 0xec, 0xb1, 0xab, 0x51, 0x55, 0xb3, 0x75, 0xaa, 0x1a, + 0x56, 0xdf, 0x96, 0xf2, 0xdc, 0xc0, 0xc5, 0xf9, 0x89, 0x70, 0x62, 0xcd, 0xd6, 0x69, 0xc3, 0xea, + 0xdb, 0x4a, 0xc9, 0x9b, 0x1a, 0xe3, 0x73, 0x90, 0xf5, 0x4e, 0x2d, 0x9f, 0x3c, 0x93, 0x8a, 0x3c, + 0x43, 0x82, 0x51, 0xf9, 0xcf, 0x59, 0x58, 0x3b, 0x4b, 0x8a, 0xdd, 0x85, 0x4c, 0x9f, 0xcd, 0x52, + 0x4a, 0x7e, 0x93, 0x18, 0x08, 0x9d, 0xe9, 0x20, 0x66, 0xbf, 0x65, 0x10, 0xab, 0x50, 0xb0, 0xa8, + 0xe7, 0x53, 0x5d, 0x64, 0x44, 0xea, 0x8c, 0x39, 0x05, 0x42, 0x69, 0x3e, 0xa5, 0xd2, 0xdf, 0x2a, + 0xa5, 0x1e, 0xc0, 0x5a, 0xe4, 0x92, 0xea, 0x12, 0x6b, 0x10, 0xe6, 0xe6, 0xf5, 0x57, 0x79, 0x52, + 0x91, 0x43, 0x3d, 0x85, 0xa9, 0x29, 0x25, 0x3a, 0x35, 0xc6, 0x75, 0x00, 0xdb, 0xa2, 0x76, 0x5f, + 0xd5, 0xa9, 0x66, 0x4a, 0xb9, 0x25, 0x51, 0x6a, 0x33, 0xca, 0x5c, 0x94, 0x6c, 0x81, 0x6a, 0x26, + 0xfe, 0x74, 0x92, 0x6a, 0x2b, 0x4b, 0x32, 0xe5, 0x48, 0x6c, 0xb2, 0xb9, 0x6c, 0x3b, 0x86, 0x92, + 0x4b, 0x59, 0xde, 0x53, 0x3d, 0x98, 0x59, 0x9e, 0x3b, 0x51, 0x79, 0xe5, 0xcc, 0x94, 0x40, 0x4d, + 0x4c, 0x6c, 0xd5, 0x8d, 0x0f, 0xf1, 0x07, 0x10, 0x01, 0x2a, 0x4f, 0x2b, 0xe0, 0x55, 0xa8, 0x18, + 0x82, 0x2d, 0x32, 0xa2, 0x5b, 0xcf, 0xa1, 0x34, 0x1d, 0x1e, 0xbc, 0x09, 0x19, 0xcf, 0x27, 0xae, + 0xcf, 0xb3, 0x30, 0xa3, 0x88, 0x01, 0x46, 0x90, 0xa2, 0x96, 0xce, 0xab, 0x5c, 0x46, 0x61, 0xff, + 0xe2, 0x1f, 0x4d, 0x26, 0x9c, 0xe2, 0x13, 0xfe, 0x78, 0x7e, 0x45, 0xa7, 0x2c, 0xcf, 0xce, 0x7b, + 0xeb, 0x36, 0xac, 0x4e, 0x4d, 0xe0, 0xac, 0x9f, 0x2e, 0xff, 0x02, 0xde, 0x5e, 0x68, 0x1a, 0x3f, + 0x80, 0xcd, 0xb1, 0x65, 0x58, 0x3e, 0x75, 0x1d, 0x97, 0xb2, 0x8c, 0x15, 0x9f, 0x92, 0xfe, 0xb3, + 0xb2, 0x24, 0xe7, 0x8e, 0xe3, 0x6c, 0x61, 0x45, 0xd9, 0x18, 0xcf, 0x83, 0x57, 0xf3, 0xb9, 0xff, + 0xae, 0xa0, 0x17, 0x2f, 0x5e, 0xbc, 0x48, 0x96, 0x7f, 0x9d, 0x85, 0xcd, 0x45, 0x7b, 0x66, 0xe1, + 0xf6, 0x3d, 0x07, 0x59, 0x6b, 0x3c, 0x3a, 0xa1, 0x2e, 0x0f, 0x52, 0x46, 0x09, 0x46, 0xb8, 0x0a, + 0x19, 0x93, 0x9c, 0x50, 0x53, 0x4a, 0x6f, 0x27, 0x76, 0x4a, 0xbb, 0xd7, 0xce, 0xb4, 0x2b, 0x2b, + 0x4d, 0xa6, 0xa2, 0x08, 0x4d, 0xfc, 0x19, 0xa4, 0x83, 0x12, 0xcd, 0x2c, 0x5c, 0x3d, 0x9b, 0x05, + 0xb6, 0x97, 0x14, 0xae, 0x87, 0xdf, 0x81, 0x3c, 0xfb, 0x2b, 0x72, 0x23, 0xcb, 0x7d, 0xce, 0x31, + 0x80, 0xe5, 0x05, 0xde, 0x82, 0x1c, 0xdf, 0x26, 0x3a, 0x0d, 0x8f, 0xb6, 0x68, 0xcc, 0x12, 0x4b, + 0xa7, 0x7d, 0x32, 0x36, 0x7d, 0xf5, 0x09, 0x31, 0xc7, 0x94, 0x27, 0x7c, 0x5e, 0x29, 0x06, 0xe0, + 0x4f, 0x19, 0x86, 0x2f, 0x42, 0x41, 0xec, 0x2a, 0xc3, 0xd2, 0xe9, 0x33, 0x5e, 0x3d, 0x33, 0x8a, + 0xd8, 0x68, 0x0d, 0x86, 0xb0, 0xcf, 0x3f, 0xf2, 0x6c, 0x2b, 0x4c, 0x4d, 0xfe, 0x09, 0x06, 0xf0, + 0xcf, 0xdf, 0x9e, 0x2d, 0xdc, 0xef, 0x2d, 0x9e, 0xde, 0x6c, 0x4e, 0x95, 0xff, 0x94, 0x84, 0x34, + 0xaf, 0x17, 0x6b, 0x50, 0xe8, 0x3d, 0xec, 0xc8, 0x6a, 0xbd, 0x7d, 0x7c, 0xd0, 0x94, 0x51, 0x02, + 0x97, 0x00, 0x38, 0x70, 0xaf, 0xd9, 0xae, 0xf6, 0x50, 0x32, 0x1a, 0x37, 0x5a, 0xbd, 0xbd, 0x9b, + 0x28, 0x15, 0x29, 0x1c, 0x0b, 0x20, 0x1d, 0x27, 0xdc, 0xd8, 0x45, 0x19, 0x8c, 0xa0, 0x28, 0x0c, + 0x34, 0x1e, 0xc8, 0xf5, 0xbd, 0x9b, 0x28, 0x3b, 0x8d, 0xdc, 0xd8, 0x45, 0x2b, 0x78, 0x15, 0xf2, + 0x1c, 0x39, 0x68, 0xb7, 0x9b, 0x28, 0x17, 0xd9, 0xec, 0xf6, 0x94, 0x46, 0xeb, 0x10, 0xe5, 0x23, + 0x9b, 0x87, 0x4a, 0xfb, 0xb8, 0x83, 0x20, 0xb2, 0x70, 0x24, 0x77, 0xbb, 0xd5, 0x43, 0x19, 0x15, + 0x22, 0xc6, 0xc1, 0xc3, 0x9e, 0xdc, 0x45, 0xc5, 0x29, 0xb7, 0x6e, 0xec, 0xa2, 0xd5, 0xe8, 0x13, + 0x72, 0xeb, 0xf8, 0x08, 0x95, 0xf0, 0x3a, 0xac, 0x8a, 0x4f, 0x84, 0x4e, 0xac, 0xcd, 0x40, 0x7b, + 0x37, 0x11, 0x9a, 0x38, 0x22, 0xac, 0xac, 0x4f, 0x01, 0x7b, 0x37, 0x11, 0x2e, 0xd7, 0x20, 0xc3, + 0xb3, 0x0b, 0x63, 0x28, 0x35, 0xab, 0x07, 0x72, 0x53, 0x6d, 0x77, 0x7a, 0x8d, 0x76, 0xab, 0xda, + 0x44, 0x89, 0x09, 0xa6, 0xc8, 0x3f, 0x39, 0x6e, 0x28, 0x72, 0x1d, 0x25, 0xe3, 0x58, 0x47, 0xae, + 0xf6, 0xe4, 0x3a, 0x4a, 0x95, 0x35, 0xd8, 0x5c, 0x54, 0x27, 0x17, 0xee, 0x8c, 0xd8, 0x12, 0x27, + 0x97, 0x2c, 0x31, 0xb7, 0x35, 0xb7, 0xc4, 0xff, 0x4a, 0xc2, 0xc6, 0x82, 0xb3, 0x62, 0xe1, 0x47, + 0x7e, 0x08, 0x19, 0x91, 0xa2, 0xe2, 0xf4, 0xbc, 0xb2, 0xf0, 0xd0, 0xe1, 0x09, 0x3b, 0x77, 0x82, + 0x72, 0xbd, 0x78, 0x07, 0x91, 0x5a, 0xd2, 0x41, 0x30, 0x13, 0x73, 0x35, 0xfd, 0xe7, 0x73, 0x35, + 0x5d, 0x1c, 0x7b, 0x7b, 0x67, 0x39, 0xf6, 0x38, 0xf6, 0xcd, 0x6a, 0x7b, 0x66, 0x41, 0x6d, 0xbf, + 0x0b, 0xeb, 0x73, 0x86, 0xce, 0x5c, 0x63, 0x7f, 0x99, 0x00, 0x69, 0x59, 0x70, 0x5e, 0x51, 0xe9, + 0x92, 0x53, 0x95, 0xee, 0xee, 0x6c, 0x04, 0x2f, 0x2d, 0x5f, 0x84, 0xb9, 0xb5, 0xfe, 0x3a, 0x01, + 0xe7, 0x16, 0x77, 0x8a, 0x0b, 0x7d, 0xf8, 0x0c, 0xb2, 0x23, 0xea, 0x0f, 0xed, 0xb0, 0x5b, 0xfa, + 0x78, 0xc1, 0x19, 0xcc, 0xc4, 0xb3, 0x8b, 0x1d, 0x68, 0xc5, 0x0f, 0xf1, 0xd4, 0xb2, 0x76, 0x4f, + 0x78, 0x33, 0xe7, 0xe9, 0xaf, 0x92, 0xf0, 0xf6, 0x42, 0xe3, 0x0b, 0x1d, 0x7d, 0x0f, 0xc0, 0xb0, + 0x9c, 0xb1, 0x2f, 0x3a, 0x22, 0x51, 0x60, 0xf3, 0x1c, 0xe1, 0xc5, 0x8b, 0x15, 0xcf, 0xb1, 0x1f, + 0xc9, 0x53, 0x5c, 0x0e, 0x02, 0xe2, 0x84, 0x3b, 0x13, 0x47, 0xd3, 0xdc, 0xd1, 0xf7, 0x97, 0xcc, + 0x74, 0x2e, 0x31, 0x3f, 0x01, 0xa4, 0x99, 0x06, 0xb5, 0x7c, 0xd5, 0xf3, 0x5d, 0x4a, 0x46, 0x86, + 0x35, 0xe0, 0x27, 0x48, 0x6e, 0x3f, 0xd3, 0x27, 0xa6, 0x47, 0x95, 0x35, 0x21, 0xee, 0x86, 0x52, + 0xa6, 0xc1, 0x13, 0xc8, 0x8d, 0x69, 0x64, 0xa7, 0x34, 0x84, 0x38, 0xd2, 0x28, 0xff, 0x31, 0x07, + 0x85, 0x58, 0x5f, 0x8d, 0x2f, 0x41, 0xf1, 0x11, 0x79, 0x42, 0xd4, 0xf0, 0xae, 0x24, 0x22, 0x51, + 0x60, 0x58, 0x27, 0xb8, 0x2f, 0x7d, 0x02, 0x9b, 0x9c, 0x62, 0x8f, 0x7d, 0xea, 0xaa, 0x9a, 0x49, + 0x3c, 0x8f, 0x07, 0x2d, 0xc7, 0xa9, 0x98, 0xc9, 0xda, 0x4c, 0x54, 0x0b, 0x25, 0xf8, 0x16, 0x6c, + 0x70, 0x8d, 0xd1, 0xd8, 0xf4, 0x0d, 0xc7, 0xa4, 0x2a, 0xbb, 0xbd, 0x79, 0xfc, 0x24, 0x89, 0x3c, + 0x5b, 0x67, 0x8c, 0xa3, 0x80, 0xc0, 0x3c, 0xf2, 0x70, 0x1d, 0xde, 0xe3, 0x6a, 0x03, 0x6a, 0x51, + 0x97, 0xf8, 0x54, 0xa5, 0x5f, 0x8d, 0x89, 0xe9, 0xa9, 0xc4, 0xd2, 0xd5, 0x21, 0xf1, 0x86, 0xd2, + 0x26, 0x33, 0x70, 0x90, 0x94, 0x12, 0xca, 0x05, 0x46, 0x3c, 0x0c, 0x78, 0x32, 0xa7, 0x55, 0x2d, + 0xfd, 0x73, 0xe2, 0x0d, 0xf1, 0x3e, 0x9c, 0xe3, 0x56, 0x3c, 0xdf, 0x35, 0xac, 0x81, 0xaa, 0x0d, + 0xa9, 0xf6, 0x58, 0x1d, 0xfb, 0xfd, 0x3b, 0xd2, 0x3b, 0xf1, 0xef, 0x73, 0x0f, 0xbb, 0x9c, 0x53, + 0x63, 0x94, 0x63, 0xbf, 0x7f, 0x07, 0x77, 0xa1, 0xc8, 0x16, 0x63, 0x64, 0x3c, 0xa7, 0x6a, 0xdf, + 0x76, 0xf9, 0xd1, 0x58, 0x5a, 0x50, 0x9a, 0x62, 0x11, 0xac, 0xb4, 0x03, 0x85, 0x23, 0x5b, 0xa7, + 0xfb, 0x99, 0x6e, 0x47, 0x96, 0xeb, 0x4a, 0x21, 0xb4, 0x72, 0xcf, 0x76, 0x59, 0x42, 0x0d, 0xec, + 0x28, 0xc0, 0x05, 0x91, 0x50, 0x03, 0x3b, 0x0c, 0xef, 0x2d, 0xd8, 0xd0, 0x34, 0x31, 0x67, 0x43, + 0x53, 0x83, 0x3b, 0x96, 0x27, 0xa1, 0xa9, 0x60, 0x69, 0xda, 0xa1, 0x20, 0x04, 0x39, 0xee, 0xe1, + 0x4f, 0xe1, 0xed, 0x49, 0xb0, 0xe2, 0x8a, 0xeb, 0x73, 0xb3, 0x9c, 0x55, 0xbd, 0x05, 0x1b, 0xce, + 0xe9, 0xbc, 0x22, 0x9e, 0xfa, 0xa2, 0x73, 0x3a, 0xab, 0x76, 0x1b, 0x36, 0x9d, 0xa1, 0x33, 0xaf, + 0x77, 0x35, 0xae, 0x87, 0x9d, 0xa1, 0x33, 0xab, 0xf8, 0x11, 0xbf, 0x70, 0xbb, 0x54, 0x23, 0x3e, + 0xd5, 0xa5, 0xf3, 0x71, 0x7a, 0x4c, 0x80, 0xaf, 0x03, 0xd2, 0x34, 0x95, 0x5a, 0xe4, 0xc4, 0xa4, + 0x2a, 0x71, 0xa9, 0x45, 0x3c, 0xe9, 0x62, 0x9c, 0x5c, 0xd2, 0x34, 0x99, 0x4b, 0xab, 0x5c, 0x88, + 0xaf, 0xc2, 0xba, 0x7d, 0xf2, 0x48, 0x13, 0x29, 0xa9, 0x3a, 0x2e, 0xed, 0x1b, 0xcf, 0xa4, 0x0f, + 0x79, 0x7c, 0xd7, 0x98, 0x80, 0x27, 0x64, 0x87, 0xc3, 0xf8, 0x0a, 0x20, 0xcd, 0x1b, 0x12, 0xd7, + 0xe1, 0x35, 0xd9, 0x73, 0x88, 0x46, 0xa5, 0x8f, 0x04, 0x55, 0xe0, 0xad, 0x10, 0x66, 0x5b, 0xc2, + 0x7b, 0x6a, 0xf4, 0xfd, 0xd0, 0xe2, 0x65, 0xb1, 0x25, 0x38, 0x16, 0x58, 0xdb, 0x01, 0xc4, 0x42, + 0x31, 0xf5, 0xe1, 0x1d, 0x4e, 0x2b, 0x39, 0x43, 0x27, 0xfe, 0xdd, 0x0f, 0x60, 0x95, 0x31, 0x27, + 0x1f, 0xbd, 0x22, 0x1a, 0x32, 0x67, 0x18, 0xfb, 0xe2, 0x6b, 0xeb, 0x8d, 0xcb, 0xfb, 0x50, 0x8c, + 0xe7, 0x27, 0xce, 0x83, 0xc8, 0x50, 0x94, 0x60, 0xcd, 0x4a, 0xad, 0x5d, 0x67, 0x6d, 0xc6, 0x97, + 0x32, 0x4a, 0xb2, 0x76, 0xa7, 0xd9, 0xe8, 0xc9, 0xaa, 0x72, 0xdc, 0xea, 0x35, 0x8e, 0x64, 0x94, + 0x8a, 0xf7, 0xd5, 0x7f, 0x4d, 0x42, 0x69, 0xfa, 0x8a, 0x84, 0x7f, 0x00, 0xe7, 0xc3, 0xf7, 0x0c, + 0x8f, 0xfa, 0xea, 0x53, 0xc3, 0xe5, 0x5b, 0x66, 0x44, 0xc4, 0xf1, 0x15, 0x2d, 0xda, 0x66, 0xc0, + 0xea, 0x52, 0xff, 0x0b, 0xc3, 0x65, 0x1b, 0x62, 0x44, 0x7c, 0xdc, 0x84, 0x8b, 0x96, 0xad, 0x7a, + 0x3e, 0xb1, 0x74, 0xe2, 0xea, 0xea, 0xe4, 0x25, 0x49, 0x25, 0x9a, 0x46, 0x3d, 0xcf, 0x16, 0x47, + 0x55, 0x64, 0xe5, 0x5d, 0xcb, 0xee, 0x06, 0xe4, 0x49, 0x0d, 0xaf, 0x06, 0xd4, 0x99, 0x04, 0x4b, + 0x2d, 0x4b, 0xb0, 0x77, 0x20, 0x3f, 0x22, 0x8e, 0x4a, 0x2d, 0xdf, 0x3d, 0xe5, 0x8d, 0x71, 0x4e, + 0xc9, 0x8d, 0x88, 0x23, 0xb3, 0xf1, 0x9b, 0xb9, 0x9f, 0xfc, 0x23, 0x05, 0xc5, 0x78, 0x73, 0xcc, + 0xee, 0x1a, 0x1a, 0x3f, 0x47, 0x12, 0xbc, 0xd2, 0x7c, 0xf0, 0xd2, 0x56, 0xba, 0x52, 0x63, 0x07, + 0xcc, 0x7e, 0x56, 0xb4, 0xac, 0x8a, 0xd0, 0x64, 0x87, 0x3b, 0xab, 0x2d, 0x54, 0xb4, 0x08, 0x39, + 0x25, 0x18, 0xe1, 0x43, 0xc8, 0x3e, 0xf2, 0xb8, 0xed, 0x2c, 0xb7, 0xfd, 0xe1, 0xcb, 0x6d, 0xdf, + 0xef, 0x72, 0xe3, 0xf9, 0xfb, 0x5d, 0xb5, 0xd5, 0x56, 0x8e, 0xaa, 0x4d, 0x25, 0x50, 0xc7, 0x17, + 0x20, 0x6d, 0x92, 0xe7, 0xa7, 0xd3, 0x47, 0x11, 0x87, 0xce, 0x1a, 0xf8, 0x0b, 0x90, 0x7e, 0x4a, + 0xc9, 0xe3, 0xe9, 0x03, 0x80, 0x43, 0xaf, 0x31, 0xf5, 0xaf, 0x43, 0x86, 0xc7, 0x0b, 0x03, 0x04, + 0x11, 0x43, 0x6f, 0xe1, 0x1c, 0xa4, 0x6b, 0x6d, 0x85, 0xa5, 0x3f, 0x82, 0xa2, 0x40, 0xd5, 0x4e, + 0x43, 0xae, 0xc9, 0x28, 0x59, 0xbe, 0x05, 0x59, 0x11, 0x04, 0xb6, 0x35, 0xa2, 0x30, 0xa0, 0xb7, + 0x82, 0x61, 0x60, 0x23, 0x11, 0x4a, 0x8f, 0x8f, 0x0e, 0x64, 0x05, 0x25, 0xe3, 0xcb, 0xeb, 0x41, + 0x31, 0xde, 0x17, 0xbf, 0x99, 0x9c, 0xfa, 0x4b, 0x02, 0x0a, 0xb1, 0x3e, 0x97, 0x35, 0x28, 0xc4, + 0x34, 0xed, 0xa7, 0x2a, 0x31, 0x0d, 0xe2, 0x05, 0x49, 0x01, 0x1c, 0xaa, 0x32, 0xe4, 0xac, 0x8b, + 0xf6, 0x46, 0x9c, 0xff, 0x5d, 0x02, 0xd0, 0x6c, 0x8b, 0x39, 0xe3, 0x60, 0xe2, 0x3b, 0x75, 0xf0, + 0xb7, 0x09, 0x28, 0x4d, 0xf7, 0x95, 0x33, 0xee, 0x5d, 0xfa, 0x4e, 0xdd, 0xfb, 0x67, 0x12, 0x56, + 0xa7, 0xba, 0xc9, 0xb3, 0x7a, 0xf7, 0x15, 0xac, 0x1b, 0x3a, 0x1d, 0x39, 0xb6, 0x4f, 0x2d, 0xed, + 0x54, 0x35, 0xe9, 0x13, 0x6a, 0x4a, 0x65, 0x5e, 0x28, 0xae, 0xbf, 0xbc, 0x5f, 0xad, 0x34, 0x26, + 0x7a, 0x4d, 0xa6, 0xb6, 0xbf, 0xd1, 0xa8, 0xcb, 0x47, 0x9d, 0x76, 0x4f, 0x6e, 0xd5, 0x1e, 0xaa, + 0xc7, 0xad, 0x1f, 0xb7, 0xda, 0x5f, 0xb4, 0x14, 0x64, 0xcc, 0xd0, 0x5e, 0xe3, 0x56, 0xef, 0x00, + 0x9a, 0x75, 0x0a, 0x9f, 0x87, 0x45, 0x6e, 0xa1, 0xb7, 0xf0, 0x06, 0xac, 0xb5, 0xda, 0x6a, 0xb7, + 0x51, 0x97, 0x55, 0xf9, 0xde, 0x3d, 0xb9, 0xd6, 0xeb, 0x8a, 0x17, 0x88, 0x88, 0xdd, 0x9b, 0xde, + 0xd4, 0xbf, 0x49, 0xc1, 0xc6, 0x02, 0x4f, 0x70, 0x35, 0xb8, 0x3b, 0x88, 0xeb, 0xcc, 0xf7, 0xcf, + 0xe2, 0x7d, 0x85, 0x1d, 0xf9, 0x1d, 0xe2, 0xfa, 0xc1, 0x55, 0xe3, 0x0a, 0xb0, 0x28, 0x59, 0xbe, + 0xd1, 0x37, 0xa8, 0x1b, 0x3c, 0xd8, 0x88, 0x0b, 0xc5, 0xda, 0x04, 0x17, 0x6f, 0x36, 0xdf, 0x03, + 0xec, 0xd8, 0x9e, 0xe1, 0x1b, 0x4f, 0xa8, 0x6a, 0x58, 0xe1, 0xeb, 0x0e, 0xbb, 0x60, 0xa4, 0x15, + 0x14, 0x4a, 0x1a, 0x96, 0x1f, 0xb1, 0x2d, 0x3a, 0x20, 0x33, 0x6c, 0x56, 0xc0, 0x53, 0x0a, 0x0a, + 0x25, 0x11, 0xfb, 0x12, 0x14, 0x75, 0x7b, 0xcc, 0xba, 0x2e, 0xc1, 0x63, 0xe7, 0x45, 0x42, 0x29, + 0x08, 0x2c, 0xa2, 0x04, 0xfd, 0xf4, 0xe4, 0x59, 0xa9, 0xa8, 0x14, 0x04, 0x26, 0x28, 0x97, 0x61, + 0x8d, 0x0c, 0x06, 0x2e, 0x33, 0x1e, 0x1a, 0x12, 0x37, 0x84, 0x52, 0x04, 0x73, 0xe2, 0xd6, 0x7d, + 0xc8, 0x85, 0x71, 0x60, 0x47, 0x32, 0x8b, 0x84, 0xea, 0x88, 0x6b, 0x6f, 0x72, 0x27, 0xaf, 0xe4, + 0xac, 0x50, 0x78, 0x09, 0x8a, 0x86, 0xa7, 0x4e, 0x5e, 0xc9, 0x93, 0xdb, 0xc9, 0x9d, 0x9c, 0x52, + 0x30, 0xbc, 0xe8, 0x85, 0xb1, 0xfc, 0x75, 0x12, 0x4a, 0xd3, 0xaf, 0xfc, 0xb8, 0x0e, 0x39, 0xd3, + 0xd6, 0x08, 0x4f, 0x2d, 0xf1, 0x13, 0xd3, 0xce, 0x2b, 0x7e, 0x18, 0xa8, 0x34, 0x03, 0xbe, 0x12, + 0x69, 0x6e, 0xfd, 0x2d, 0x01, 0xb9, 0x10, 0xc6, 0xe7, 0x20, 0xed, 0x10, 0x7f, 0xc8, 0xcd, 0x65, + 0x0e, 0x92, 0x28, 0xa1, 0xf0, 0x31, 0xc3, 0x3d, 0x87, 0x58, 0x3c, 0x05, 0x02, 0x9c, 0x8d, 0xd9, + 0xba, 0x9a, 0x94, 0xe8, 0xfc, 0xfa, 0x61, 0x8f, 0x46, 0xd4, 0xf2, 0xbd, 0x70, 0x5d, 0x03, 0xbc, + 0x16, 0xc0, 0xf8, 0x1a, 0xac, 0xfb, 0x2e, 0x31, 0xcc, 0x29, 0x6e, 0x9a, 0x73, 0x51, 0x28, 0x88, + 0xc8, 0xfb, 0x70, 0x21, 0xb4, 0xab, 0x53, 0x9f, 0x68, 0x43, 0xaa, 0x4f, 0x94, 0xb2, 0xfc, 0x99, + 0xe1, 0x7c, 0x40, 0xa8, 0x07, 0xf2, 0x50, 0xb7, 0xfc, 0xf7, 0x04, 0xac, 0x87, 0x17, 0x26, 0x3d, + 0x0a, 0xd6, 0x11, 0x00, 0xb1, 0x2c, 0xdb, 0x8f, 0x87, 0x6b, 0x3e, 0x95, 0xe7, 0xf4, 0x2a, 0xd5, + 0x48, 0x49, 0x89, 0x19, 0xd8, 0x1a, 0x01, 0x4c, 0x24, 0x4b, 0xc3, 0x76, 0x11, 0x0a, 0xc1, 0x4f, + 0x38, 0xfc, 0x77, 0x40, 0x71, 0xc5, 0x06, 0x01, 0xb1, 0x9b, 0x15, 0xde, 0x84, 0xcc, 0x09, 0x1d, + 0x18, 0x56, 0xf0, 0x30, 0x2b, 0x06, 0xe1, 0x43, 0x48, 0x3a, 0x7a, 0x08, 0x39, 0xf8, 0x19, 0x6c, + 0x68, 0xf6, 0x68, 0xd6, 0xdd, 0x03, 0x34, 0x73, 0xcd, 0xf7, 0x3e, 0x4f, 0x7c, 0x09, 0x93, 0x16, + 0xf3, 0x7f, 0x89, 0xc4, 0xef, 0x93, 0xa9, 0xc3, 0xce, 0xc1, 0x1f, 0x92, 0x5b, 0x87, 0x42, 0xb5, + 0x13, 0xce, 0x54, 0xa1, 0x7d, 0x93, 0x6a, 0xcc, 0xfb, 0xff, 0x07, 0x00, 0x00, 0xff, 0xff, 0xa3, + 0x58, 0x22, 0x30, 0xdf, 0x1c, 0x00, 0x00, +} diff --git a/vendor/github.com/gogo/protobuf/protoc-gen-gogo/descriptor/descriptor_gostring.gen.go b/vendor/github.com/gogo/protobuf/protoc-gen-gogo/descriptor/descriptor_gostring.gen.go new file mode 100644 index 0000000000000..ec6eb168d6a79 --- /dev/null +++ b/vendor/github.com/gogo/protobuf/protoc-gen-gogo/descriptor/descriptor_gostring.gen.go @@ -0,0 +1,744 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: descriptor.proto + +package descriptor + +import fmt "fmt" +import strings "strings" +import github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto" +import sort "sort" +import strconv "strconv" +import reflect "reflect" +import proto "github.com/gogo/protobuf/proto" +import math "math" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +func (this *FileDescriptorSet) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&descriptor.FileDescriptorSet{") + if this.File != nil { + s = append(s, "File: "+fmt.Sprintf("%#v", this.File)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *FileDescriptorProto) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 16) + s = append(s, "&descriptor.FileDescriptorProto{") + if this.Name != nil { + s = append(s, "Name: "+valueToGoStringDescriptor(this.Name, "string")+",\n") + } + if this.Package != nil { + s = append(s, "Package: "+valueToGoStringDescriptor(this.Package, "string")+",\n") + } + if this.Dependency != nil { + s = append(s, "Dependency: "+fmt.Sprintf("%#v", this.Dependency)+",\n") + } + if this.PublicDependency != nil { + s = append(s, "PublicDependency: "+fmt.Sprintf("%#v", this.PublicDependency)+",\n") + } + if this.WeakDependency != nil { + s = append(s, "WeakDependency: "+fmt.Sprintf("%#v", this.WeakDependency)+",\n") + } + if this.MessageType != nil { + s = append(s, "MessageType: "+fmt.Sprintf("%#v", this.MessageType)+",\n") + } + if this.EnumType != nil { + s = append(s, "EnumType: "+fmt.Sprintf("%#v", this.EnumType)+",\n") + } + if this.Service != nil { + s = append(s, "Service: "+fmt.Sprintf("%#v", this.Service)+",\n") + } + if this.Extension != nil { + s = append(s, "Extension: "+fmt.Sprintf("%#v", this.Extension)+",\n") + } + if this.Options != nil { + s = append(s, "Options: "+fmt.Sprintf("%#v", this.Options)+",\n") + } + if this.SourceCodeInfo != nil { + s = append(s, "SourceCodeInfo: "+fmt.Sprintf("%#v", this.SourceCodeInfo)+",\n") + } + if this.Syntax != nil { + s = append(s, "Syntax: "+valueToGoStringDescriptor(this.Syntax, "string")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *DescriptorProto) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 14) + s = append(s, "&descriptor.DescriptorProto{") + if this.Name != nil { + s = append(s, "Name: "+valueToGoStringDescriptor(this.Name, "string")+",\n") + } + if this.Field != nil { + s = append(s, "Field: "+fmt.Sprintf("%#v", this.Field)+",\n") + } + if this.Extension != nil { + s = append(s, "Extension: "+fmt.Sprintf("%#v", this.Extension)+",\n") + } + if this.NestedType != nil { + s = append(s, "NestedType: "+fmt.Sprintf("%#v", this.NestedType)+",\n") + } + if this.EnumType != nil { + s = append(s, "EnumType: "+fmt.Sprintf("%#v", this.EnumType)+",\n") + } + if this.ExtensionRange != nil { + s = append(s, "ExtensionRange: "+fmt.Sprintf("%#v", this.ExtensionRange)+",\n") + } + if this.OneofDecl != nil { + s = append(s, "OneofDecl: "+fmt.Sprintf("%#v", this.OneofDecl)+",\n") + } + if this.Options != nil { + s = append(s, "Options: "+fmt.Sprintf("%#v", this.Options)+",\n") + } + if this.ReservedRange != nil { + s = append(s, "ReservedRange: "+fmt.Sprintf("%#v", this.ReservedRange)+",\n") + } + if this.ReservedName != nil { + s = append(s, "ReservedName: "+fmt.Sprintf("%#v", this.ReservedName)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *DescriptorProto_ExtensionRange) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&descriptor.DescriptorProto_ExtensionRange{") + if this.Start != nil { + s = append(s, "Start: "+valueToGoStringDescriptor(this.Start, "int32")+",\n") + } + if this.End != nil { + s = append(s, "End: "+valueToGoStringDescriptor(this.End, "int32")+",\n") + } + if this.Options != nil { + s = append(s, "Options: "+fmt.Sprintf("%#v", this.Options)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *DescriptorProto_ReservedRange) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&descriptor.DescriptorProto_ReservedRange{") + if this.Start != nil { + s = append(s, "Start: "+valueToGoStringDescriptor(this.Start, "int32")+",\n") + } + if this.End != nil { + s = append(s, "End: "+valueToGoStringDescriptor(this.End, "int32")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *ExtensionRangeOptions) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&descriptor.ExtensionRangeOptions{") + if this.UninterpretedOption != nil { + s = append(s, "UninterpretedOption: "+fmt.Sprintf("%#v", this.UninterpretedOption)+",\n") + } + s = append(s, "XXX_InternalExtensions: "+extensionToGoStringDescriptor(this)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *FieldDescriptorProto) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 14) + s = append(s, "&descriptor.FieldDescriptorProto{") + if this.Name != nil { + s = append(s, "Name: "+valueToGoStringDescriptor(this.Name, "string")+",\n") + } + if this.Number != nil { + s = append(s, "Number: "+valueToGoStringDescriptor(this.Number, "int32")+",\n") + } + if this.Label != nil { + s = append(s, "Label: "+valueToGoStringDescriptor(this.Label, "FieldDescriptorProto_Label")+",\n") + } + if this.Type != nil { + s = append(s, "Type: "+valueToGoStringDescriptor(this.Type, "FieldDescriptorProto_Type")+",\n") + } + if this.TypeName != nil { + s = append(s, "TypeName: "+valueToGoStringDescriptor(this.TypeName, "string")+",\n") + } + if this.Extendee != nil { + s = append(s, "Extendee: "+valueToGoStringDescriptor(this.Extendee, "string")+",\n") + } + if this.DefaultValue != nil { + s = append(s, "DefaultValue: "+valueToGoStringDescriptor(this.DefaultValue, "string")+",\n") + } + if this.OneofIndex != nil { + s = append(s, "OneofIndex: "+valueToGoStringDescriptor(this.OneofIndex, "int32")+",\n") + } + if this.JsonName != nil { + s = append(s, "JsonName: "+valueToGoStringDescriptor(this.JsonName, "string")+",\n") + } + if this.Options != nil { + s = append(s, "Options: "+fmt.Sprintf("%#v", this.Options)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *OneofDescriptorProto) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&descriptor.OneofDescriptorProto{") + if this.Name != nil { + s = append(s, "Name: "+valueToGoStringDescriptor(this.Name, "string")+",\n") + } + if this.Options != nil { + s = append(s, "Options: "+fmt.Sprintf("%#v", this.Options)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *EnumDescriptorProto) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 9) + s = append(s, "&descriptor.EnumDescriptorProto{") + if this.Name != nil { + s = append(s, "Name: "+valueToGoStringDescriptor(this.Name, "string")+",\n") + } + if this.Value != nil { + s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n") + } + if this.Options != nil { + s = append(s, "Options: "+fmt.Sprintf("%#v", this.Options)+",\n") + } + if this.ReservedRange != nil { + s = append(s, "ReservedRange: "+fmt.Sprintf("%#v", this.ReservedRange)+",\n") + } + if this.ReservedName != nil { + s = append(s, "ReservedName: "+fmt.Sprintf("%#v", this.ReservedName)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *EnumDescriptorProto_EnumReservedRange) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&descriptor.EnumDescriptorProto_EnumReservedRange{") + if this.Start != nil { + s = append(s, "Start: "+valueToGoStringDescriptor(this.Start, "int32")+",\n") + } + if this.End != nil { + s = append(s, "End: "+valueToGoStringDescriptor(this.End, "int32")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *EnumValueDescriptorProto) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&descriptor.EnumValueDescriptorProto{") + if this.Name != nil { + s = append(s, "Name: "+valueToGoStringDescriptor(this.Name, "string")+",\n") + } + if this.Number != nil { + s = append(s, "Number: "+valueToGoStringDescriptor(this.Number, "int32")+",\n") + } + if this.Options != nil { + s = append(s, "Options: "+fmt.Sprintf("%#v", this.Options)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *ServiceDescriptorProto) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&descriptor.ServiceDescriptorProto{") + if this.Name != nil { + s = append(s, "Name: "+valueToGoStringDescriptor(this.Name, "string")+",\n") + } + if this.Method != nil { + s = append(s, "Method: "+fmt.Sprintf("%#v", this.Method)+",\n") + } + if this.Options != nil { + s = append(s, "Options: "+fmt.Sprintf("%#v", this.Options)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *MethodDescriptorProto) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 10) + s = append(s, "&descriptor.MethodDescriptorProto{") + if this.Name != nil { + s = append(s, "Name: "+valueToGoStringDescriptor(this.Name, "string")+",\n") + } + if this.InputType != nil { + s = append(s, "InputType: "+valueToGoStringDescriptor(this.InputType, "string")+",\n") + } + if this.OutputType != nil { + s = append(s, "OutputType: "+valueToGoStringDescriptor(this.OutputType, "string")+",\n") + } + if this.Options != nil { + s = append(s, "Options: "+fmt.Sprintf("%#v", this.Options)+",\n") + } + if this.ClientStreaming != nil { + s = append(s, "ClientStreaming: "+valueToGoStringDescriptor(this.ClientStreaming, "bool")+",\n") + } + if this.ServerStreaming != nil { + s = append(s, "ServerStreaming: "+valueToGoStringDescriptor(this.ServerStreaming, "bool")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *FileOptions) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 23) + s = append(s, "&descriptor.FileOptions{") + if this.JavaPackage != nil { + s = append(s, "JavaPackage: "+valueToGoStringDescriptor(this.JavaPackage, "string")+",\n") + } + if this.JavaOuterClassname != nil { + s = append(s, "JavaOuterClassname: "+valueToGoStringDescriptor(this.JavaOuterClassname, "string")+",\n") + } + if this.JavaMultipleFiles != nil { + s = append(s, "JavaMultipleFiles: "+valueToGoStringDescriptor(this.JavaMultipleFiles, "bool")+",\n") + } + if this.JavaGenerateEqualsAndHash != nil { + s = append(s, "JavaGenerateEqualsAndHash: "+valueToGoStringDescriptor(this.JavaGenerateEqualsAndHash, "bool")+",\n") + } + if this.JavaStringCheckUtf8 != nil { + s = append(s, "JavaStringCheckUtf8: "+valueToGoStringDescriptor(this.JavaStringCheckUtf8, "bool")+",\n") + } + if this.OptimizeFor != nil { + s = append(s, "OptimizeFor: "+valueToGoStringDescriptor(this.OptimizeFor, "FileOptions_OptimizeMode")+",\n") + } + if this.GoPackage != nil { + s = append(s, "GoPackage: "+valueToGoStringDescriptor(this.GoPackage, "string")+",\n") + } + if this.CcGenericServices != nil { + s = append(s, "CcGenericServices: "+valueToGoStringDescriptor(this.CcGenericServices, "bool")+",\n") + } + if this.JavaGenericServices != nil { + s = append(s, "JavaGenericServices: "+valueToGoStringDescriptor(this.JavaGenericServices, "bool")+",\n") + } + if this.PyGenericServices != nil { + s = append(s, "PyGenericServices: "+valueToGoStringDescriptor(this.PyGenericServices, "bool")+",\n") + } + if this.PhpGenericServices != nil { + s = append(s, "PhpGenericServices: "+valueToGoStringDescriptor(this.PhpGenericServices, "bool")+",\n") + } + if this.Deprecated != nil { + s = append(s, "Deprecated: "+valueToGoStringDescriptor(this.Deprecated, "bool")+",\n") + } + if this.CcEnableArenas != nil { + s = append(s, "CcEnableArenas: "+valueToGoStringDescriptor(this.CcEnableArenas, "bool")+",\n") + } + if this.ObjcClassPrefix != nil { + s = append(s, "ObjcClassPrefix: "+valueToGoStringDescriptor(this.ObjcClassPrefix, "string")+",\n") + } + if this.CsharpNamespace != nil { + s = append(s, "CsharpNamespace: "+valueToGoStringDescriptor(this.CsharpNamespace, "string")+",\n") + } + if this.SwiftPrefix != nil { + s = append(s, "SwiftPrefix: "+valueToGoStringDescriptor(this.SwiftPrefix, "string")+",\n") + } + if this.PhpClassPrefix != nil { + s = append(s, "PhpClassPrefix: "+valueToGoStringDescriptor(this.PhpClassPrefix, "string")+",\n") + } + if this.PhpNamespace != nil { + s = append(s, "PhpNamespace: "+valueToGoStringDescriptor(this.PhpNamespace, "string")+",\n") + } + if this.UninterpretedOption != nil { + s = append(s, "UninterpretedOption: "+fmt.Sprintf("%#v", this.UninterpretedOption)+",\n") + } + s = append(s, "XXX_InternalExtensions: "+extensionToGoStringDescriptor(this)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *MessageOptions) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 9) + s = append(s, "&descriptor.MessageOptions{") + if this.MessageSetWireFormat != nil { + s = append(s, "MessageSetWireFormat: "+valueToGoStringDescriptor(this.MessageSetWireFormat, "bool")+",\n") + } + if this.NoStandardDescriptorAccessor != nil { + s = append(s, "NoStandardDescriptorAccessor: "+valueToGoStringDescriptor(this.NoStandardDescriptorAccessor, "bool")+",\n") + } + if this.Deprecated != nil { + s = append(s, "Deprecated: "+valueToGoStringDescriptor(this.Deprecated, "bool")+",\n") + } + if this.MapEntry != nil { + s = append(s, "MapEntry: "+valueToGoStringDescriptor(this.MapEntry, "bool")+",\n") + } + if this.UninterpretedOption != nil { + s = append(s, "UninterpretedOption: "+fmt.Sprintf("%#v", this.UninterpretedOption)+",\n") + } + s = append(s, "XXX_InternalExtensions: "+extensionToGoStringDescriptor(this)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *FieldOptions) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 11) + s = append(s, "&descriptor.FieldOptions{") + if this.Ctype != nil { + s = append(s, "Ctype: "+valueToGoStringDescriptor(this.Ctype, "FieldOptions_CType")+",\n") + } + if this.Packed != nil { + s = append(s, "Packed: "+valueToGoStringDescriptor(this.Packed, "bool")+",\n") + } + if this.Jstype != nil { + s = append(s, "Jstype: "+valueToGoStringDescriptor(this.Jstype, "FieldOptions_JSType")+",\n") + } + if this.Lazy != nil { + s = append(s, "Lazy: "+valueToGoStringDescriptor(this.Lazy, "bool")+",\n") + } + if this.Deprecated != nil { + s = append(s, "Deprecated: "+valueToGoStringDescriptor(this.Deprecated, "bool")+",\n") + } + if this.Weak != nil { + s = append(s, "Weak: "+valueToGoStringDescriptor(this.Weak, "bool")+",\n") + } + if this.UninterpretedOption != nil { + s = append(s, "UninterpretedOption: "+fmt.Sprintf("%#v", this.UninterpretedOption)+",\n") + } + s = append(s, "XXX_InternalExtensions: "+extensionToGoStringDescriptor(this)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *OneofOptions) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&descriptor.OneofOptions{") + if this.UninterpretedOption != nil { + s = append(s, "UninterpretedOption: "+fmt.Sprintf("%#v", this.UninterpretedOption)+",\n") + } + s = append(s, "XXX_InternalExtensions: "+extensionToGoStringDescriptor(this)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *EnumOptions) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&descriptor.EnumOptions{") + if this.AllowAlias != nil { + s = append(s, "AllowAlias: "+valueToGoStringDescriptor(this.AllowAlias, "bool")+",\n") + } + if this.Deprecated != nil { + s = append(s, "Deprecated: "+valueToGoStringDescriptor(this.Deprecated, "bool")+",\n") + } + if this.UninterpretedOption != nil { + s = append(s, "UninterpretedOption: "+fmt.Sprintf("%#v", this.UninterpretedOption)+",\n") + } + s = append(s, "XXX_InternalExtensions: "+extensionToGoStringDescriptor(this)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *EnumValueOptions) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&descriptor.EnumValueOptions{") + if this.Deprecated != nil { + s = append(s, "Deprecated: "+valueToGoStringDescriptor(this.Deprecated, "bool")+",\n") + } + if this.UninterpretedOption != nil { + s = append(s, "UninterpretedOption: "+fmt.Sprintf("%#v", this.UninterpretedOption)+",\n") + } + s = append(s, "XXX_InternalExtensions: "+extensionToGoStringDescriptor(this)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *ServiceOptions) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&descriptor.ServiceOptions{") + if this.Deprecated != nil { + s = append(s, "Deprecated: "+valueToGoStringDescriptor(this.Deprecated, "bool")+",\n") + } + if this.UninterpretedOption != nil { + s = append(s, "UninterpretedOption: "+fmt.Sprintf("%#v", this.UninterpretedOption)+",\n") + } + s = append(s, "XXX_InternalExtensions: "+extensionToGoStringDescriptor(this)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *MethodOptions) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&descriptor.MethodOptions{") + if this.Deprecated != nil { + s = append(s, "Deprecated: "+valueToGoStringDescriptor(this.Deprecated, "bool")+",\n") + } + if this.IdempotencyLevel != nil { + s = append(s, "IdempotencyLevel: "+valueToGoStringDescriptor(this.IdempotencyLevel, "MethodOptions_IdempotencyLevel")+",\n") + } + if this.UninterpretedOption != nil { + s = append(s, "UninterpretedOption: "+fmt.Sprintf("%#v", this.UninterpretedOption)+",\n") + } + s = append(s, "XXX_InternalExtensions: "+extensionToGoStringDescriptor(this)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *UninterpretedOption) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 11) + s = append(s, "&descriptor.UninterpretedOption{") + if this.Name != nil { + s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n") + } + if this.IdentifierValue != nil { + s = append(s, "IdentifierValue: "+valueToGoStringDescriptor(this.IdentifierValue, "string")+",\n") + } + if this.PositiveIntValue != nil { + s = append(s, "PositiveIntValue: "+valueToGoStringDescriptor(this.PositiveIntValue, "uint64")+",\n") + } + if this.NegativeIntValue != nil { + s = append(s, "NegativeIntValue: "+valueToGoStringDescriptor(this.NegativeIntValue, "int64")+",\n") + } + if this.DoubleValue != nil { + s = append(s, "DoubleValue: "+valueToGoStringDescriptor(this.DoubleValue, "float64")+",\n") + } + if this.StringValue != nil { + s = append(s, "StringValue: "+valueToGoStringDescriptor(this.StringValue, "byte")+",\n") + } + if this.AggregateValue != nil { + s = append(s, "AggregateValue: "+valueToGoStringDescriptor(this.AggregateValue, "string")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *UninterpretedOption_NamePart) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&descriptor.UninterpretedOption_NamePart{") + if this.NamePart != nil { + s = append(s, "NamePart: "+valueToGoStringDescriptor(this.NamePart, "string")+",\n") + } + if this.IsExtension != nil { + s = append(s, "IsExtension: "+valueToGoStringDescriptor(this.IsExtension, "bool")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *SourceCodeInfo) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&descriptor.SourceCodeInfo{") + if this.Location != nil { + s = append(s, "Location: "+fmt.Sprintf("%#v", this.Location)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *SourceCodeInfo_Location) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 9) + s = append(s, "&descriptor.SourceCodeInfo_Location{") + if this.Path != nil { + s = append(s, "Path: "+fmt.Sprintf("%#v", this.Path)+",\n") + } + if this.Span != nil { + s = append(s, "Span: "+fmt.Sprintf("%#v", this.Span)+",\n") + } + if this.LeadingComments != nil { + s = append(s, "LeadingComments: "+valueToGoStringDescriptor(this.LeadingComments, "string")+",\n") + } + if this.TrailingComments != nil { + s = append(s, "TrailingComments: "+valueToGoStringDescriptor(this.TrailingComments, "string")+",\n") + } + if this.LeadingDetachedComments != nil { + s = append(s, "LeadingDetachedComments: "+fmt.Sprintf("%#v", this.LeadingDetachedComments)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *GeneratedCodeInfo) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&descriptor.GeneratedCodeInfo{") + if this.Annotation != nil { + s = append(s, "Annotation: "+fmt.Sprintf("%#v", this.Annotation)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *GeneratedCodeInfo_Annotation) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 8) + s = append(s, "&descriptor.GeneratedCodeInfo_Annotation{") + if this.Path != nil { + s = append(s, "Path: "+fmt.Sprintf("%#v", this.Path)+",\n") + } + if this.SourceFile != nil { + s = append(s, "SourceFile: "+valueToGoStringDescriptor(this.SourceFile, "string")+",\n") + } + if this.Begin != nil { + s = append(s, "Begin: "+valueToGoStringDescriptor(this.Begin, "int32")+",\n") + } + if this.End != nil { + s = append(s, "End: "+valueToGoStringDescriptor(this.End, "int32")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func valueToGoStringDescriptor(v interface{}, typ string) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv) +} +func extensionToGoStringDescriptor(m github_com_gogo_protobuf_proto.Message) string { + e := github_com_gogo_protobuf_proto.GetUnsafeExtensionsMap(m) + if e == nil { + return "nil" + } + s := "proto.NewUnsafeXXX_InternalExtensions(map[int32]proto.Extension{" + keys := make([]int, 0, len(e)) + for k := range e { + keys = append(keys, int(k)) + } + sort.Ints(keys) + ss := []string{} + for _, k := range keys { + ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString()) + } + s += strings.Join(ss, ",") + "})" + return s +} diff --git a/vendor/github.com/gogo/protobuf/protoc-gen-gogo/descriptor/helper.go b/vendor/github.com/gogo/protobuf/protoc-gen-gogo/descriptor/helper.go new file mode 100644 index 0000000000000..e0846a357d59e --- /dev/null +++ b/vendor/github.com/gogo/protobuf/protoc-gen-gogo/descriptor/helper.go @@ -0,0 +1,390 @@ +// Protocol Buffers for Go with Gadgets +// +// Copyright (c) 2013, The GoGo Authors. All rights reserved. +// http://github.com/gogo/protobuf +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +package descriptor + +import ( + "strings" +) + +func (msg *DescriptorProto) GetMapFields() (*FieldDescriptorProto, *FieldDescriptorProto) { + if !msg.GetOptions().GetMapEntry() { + return nil, nil + } + return msg.GetField()[0], msg.GetField()[1] +} + +func dotToUnderscore(r rune) rune { + if r == '.' { + return '_' + } + return r +} + +func (field *FieldDescriptorProto) WireType() (wire int) { + switch *field.Type { + case FieldDescriptorProto_TYPE_DOUBLE: + return 1 + case FieldDescriptorProto_TYPE_FLOAT: + return 5 + case FieldDescriptorProto_TYPE_INT64: + return 0 + case FieldDescriptorProto_TYPE_UINT64: + return 0 + case FieldDescriptorProto_TYPE_INT32: + return 0 + case FieldDescriptorProto_TYPE_UINT32: + return 0 + case FieldDescriptorProto_TYPE_FIXED64: + return 1 + case FieldDescriptorProto_TYPE_FIXED32: + return 5 + case FieldDescriptorProto_TYPE_BOOL: + return 0 + case FieldDescriptorProto_TYPE_STRING: + return 2 + case FieldDescriptorProto_TYPE_GROUP: + return 2 + case FieldDescriptorProto_TYPE_MESSAGE: + return 2 + case FieldDescriptorProto_TYPE_BYTES: + return 2 + case FieldDescriptorProto_TYPE_ENUM: + return 0 + case FieldDescriptorProto_TYPE_SFIXED32: + return 5 + case FieldDescriptorProto_TYPE_SFIXED64: + return 1 + case FieldDescriptorProto_TYPE_SINT32: + return 0 + case FieldDescriptorProto_TYPE_SINT64: + return 0 + } + panic("unreachable") +} + +func (field *FieldDescriptorProto) GetKeyUint64() (x uint64) { + packed := field.IsPacked() + wireType := field.WireType() + fieldNumber := field.GetNumber() + if packed { + wireType = 2 + } + x = uint64(uint32(fieldNumber)<<3 | uint32(wireType)) + return x +} + +func (field *FieldDescriptorProto) GetKey3Uint64() (x uint64) { + packed := field.IsPacked3() + wireType := field.WireType() + fieldNumber := field.GetNumber() + if packed { + wireType = 2 + } + x = uint64(uint32(fieldNumber)<<3 | uint32(wireType)) + return x +} + +func (field *FieldDescriptorProto) GetKey() []byte { + x := field.GetKeyUint64() + i := 0 + keybuf := make([]byte, 0) + for i = 0; x > 127; i++ { + keybuf = append(keybuf, 0x80|uint8(x&0x7F)) + x >>= 7 + } + keybuf = append(keybuf, uint8(x)) + return keybuf +} + +func (field *FieldDescriptorProto) GetKey3() []byte { + x := field.GetKey3Uint64() + i := 0 + keybuf := make([]byte, 0) + for i = 0; x > 127; i++ { + keybuf = append(keybuf, 0x80|uint8(x&0x7F)) + x >>= 7 + } + keybuf = append(keybuf, uint8(x)) + return keybuf +} + +func (desc *FileDescriptorSet) GetField(packageName, messageName, fieldName string) *FieldDescriptorProto { + msg := desc.GetMessage(packageName, messageName) + if msg == nil { + return nil + } + for _, field := range msg.GetField() { + if field.GetName() == fieldName { + return field + } + } + return nil +} + +func (file *FileDescriptorProto) GetMessage(typeName string) *DescriptorProto { + for _, msg := range file.GetMessageType() { + if msg.GetName() == typeName { + return msg + } + nes := file.GetNestedMessage(msg, strings.TrimPrefix(typeName, msg.GetName()+".")) + if nes != nil { + return nes + } + } + return nil +} + +func (file *FileDescriptorProto) GetNestedMessage(msg *DescriptorProto, typeName string) *DescriptorProto { + for _, nes := range msg.GetNestedType() { + if nes.GetName() == typeName { + return nes + } + res := file.GetNestedMessage(nes, strings.TrimPrefix(typeName, nes.GetName()+".")) + if res != nil { + return res + } + } + return nil +} + +func (desc *FileDescriptorSet) GetMessage(packageName string, typeName string) *DescriptorProto { + for _, file := range desc.GetFile() { + if strings.Map(dotToUnderscore, file.GetPackage()) != strings.Map(dotToUnderscore, packageName) { + continue + } + for _, msg := range file.GetMessageType() { + if msg.GetName() == typeName { + return msg + } + } + for _, msg := range file.GetMessageType() { + for _, nes := range msg.GetNestedType() { + if nes.GetName() == typeName { + return nes + } + if msg.GetName()+"."+nes.GetName() == typeName { + return nes + } + } + } + } + return nil +} + +func (desc *FileDescriptorSet) IsProto3(packageName string, typeName string) bool { + for _, file := range desc.GetFile() { + if strings.Map(dotToUnderscore, file.GetPackage()) != strings.Map(dotToUnderscore, packageName) { + continue + } + for _, msg := range file.GetMessageType() { + if msg.GetName() == typeName { + return file.GetSyntax() == "proto3" + } + } + for _, msg := range file.GetMessageType() { + for _, nes := range msg.GetNestedType() { + if nes.GetName() == typeName { + return file.GetSyntax() == "proto3" + } + if msg.GetName()+"."+nes.GetName() == typeName { + return file.GetSyntax() == "proto3" + } + } + } + } + return false +} + +func (msg *DescriptorProto) IsExtendable() bool { + return len(msg.GetExtensionRange()) > 0 +} + +func (desc *FileDescriptorSet) FindExtension(packageName string, typeName string, fieldName string) (extPackageName string, field *FieldDescriptorProto) { + parent := desc.GetMessage(packageName, typeName) + if parent == nil { + return "", nil + } + if !parent.IsExtendable() { + return "", nil + } + extendee := "." + packageName + "." + typeName + for _, file := range desc.GetFile() { + for _, ext := range file.GetExtension() { + if strings.Map(dotToUnderscore, file.GetPackage()) == strings.Map(dotToUnderscore, packageName) { + if !(ext.GetExtendee() == typeName || ext.GetExtendee() == extendee) { + continue + } + } else { + if ext.GetExtendee() != extendee { + continue + } + } + if ext.GetName() == fieldName { + return file.GetPackage(), ext + } + } + } + return "", nil +} + +func (desc *FileDescriptorSet) FindExtensionByFieldNumber(packageName string, typeName string, fieldNum int32) (extPackageName string, field *FieldDescriptorProto) { + parent := desc.GetMessage(packageName, typeName) + if parent == nil { + return "", nil + } + if !parent.IsExtendable() { + return "", nil + } + extendee := "." + packageName + "." + typeName + for _, file := range desc.GetFile() { + for _, ext := range file.GetExtension() { + if strings.Map(dotToUnderscore, file.GetPackage()) == strings.Map(dotToUnderscore, packageName) { + if !(ext.GetExtendee() == typeName || ext.GetExtendee() == extendee) { + continue + } + } else { + if ext.GetExtendee() != extendee { + continue + } + } + if ext.GetNumber() == fieldNum { + return file.GetPackage(), ext + } + } + } + return "", nil +} + +func (desc *FileDescriptorSet) FindMessage(packageName string, typeName string, fieldName string) (msgPackageName string, msgName string) { + parent := desc.GetMessage(packageName, typeName) + if parent == nil { + return "", "" + } + field := parent.GetFieldDescriptor(fieldName) + if field == nil { + var extPackageName string + extPackageName, field = desc.FindExtension(packageName, typeName, fieldName) + if field == nil { + return "", "" + } + packageName = extPackageName + } + typeNames := strings.Split(field.GetTypeName(), ".") + if len(typeNames) == 1 { + msg := desc.GetMessage(packageName, typeName) + if msg == nil { + return "", "" + } + return packageName, msg.GetName() + } + if len(typeNames) > 2 { + for i := 1; i < len(typeNames)-1; i++ { + packageName = strings.Join(typeNames[1:len(typeNames)-i], ".") + typeName = strings.Join(typeNames[len(typeNames)-i:], ".") + msg := desc.GetMessage(packageName, typeName) + if msg != nil { + typeNames := strings.Split(msg.GetName(), ".") + if len(typeNames) == 1 { + return packageName, msg.GetName() + } + return strings.Join(typeNames[1:len(typeNames)-1], "."), typeNames[len(typeNames)-1] + } + } + } + return "", "" +} + +func (msg *DescriptorProto) GetFieldDescriptor(fieldName string) *FieldDescriptorProto { + for _, field := range msg.GetField() { + if field.GetName() == fieldName { + return field + } + } + return nil +} + +func (desc *FileDescriptorSet) GetEnum(packageName string, typeName string) *EnumDescriptorProto { + for _, file := range desc.GetFile() { + if strings.Map(dotToUnderscore, file.GetPackage()) != strings.Map(dotToUnderscore, packageName) { + continue + } + for _, enum := range file.GetEnumType() { + if enum.GetName() == typeName { + return enum + } + } + } + return nil +} + +func (f *FieldDescriptorProto) IsEnum() bool { + return *f.Type == FieldDescriptorProto_TYPE_ENUM +} + +func (f *FieldDescriptorProto) IsMessage() bool { + return *f.Type == FieldDescriptorProto_TYPE_MESSAGE +} + +func (f *FieldDescriptorProto) IsBytes() bool { + return *f.Type == FieldDescriptorProto_TYPE_BYTES +} + +func (f *FieldDescriptorProto) IsRepeated() bool { + return f.Label != nil && *f.Label == FieldDescriptorProto_LABEL_REPEATED +} + +func (f *FieldDescriptorProto) IsString() bool { + return *f.Type == FieldDescriptorProto_TYPE_STRING +} + +func (f *FieldDescriptorProto) IsBool() bool { + return *f.Type == FieldDescriptorProto_TYPE_BOOL +} + +func (f *FieldDescriptorProto) IsRequired() bool { + return f.Label != nil && *f.Label == FieldDescriptorProto_LABEL_REQUIRED +} + +func (f *FieldDescriptorProto) IsPacked() bool { + return f.Options != nil && f.GetOptions().GetPacked() +} + +func (f *FieldDescriptorProto) IsPacked3() bool { + if f.IsRepeated() && f.IsScalar() { + if f.Options == nil || f.GetOptions().Packed == nil { + return true + } + return f.Options != nil && f.GetOptions().GetPacked() + } + return false +} + +func (m *DescriptorProto) HasExtension() bool { + return len(m.ExtensionRange) > 0 +} diff --git a/vendor/github.com/golang/protobuf/LICENSE b/vendor/github.com/golang/protobuf/LICENSE index 1b1b1921efa6d..0f646931a4627 100644 --- a/vendor/github.com/golang/protobuf/LICENSE +++ b/vendor/github.com/golang/protobuf/LICENSE @@ -1,7 +1,4 @@ -Go support for Protocol Buffers - Google's data interchange format - Copyright 2010 The Go Authors. All rights reserved. -https://github.com/golang/protobuf Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are diff --git a/vendor/github.com/golang/protobuf/jsonpb/jsonpb.go b/vendor/github.com/golang/protobuf/jsonpb/jsonpb.go index ff368f33c546d..ada2b78e89d65 100644 --- a/vendor/github.com/golang/protobuf/jsonpb/jsonpb.go +++ b/vendor/github.com/golang/protobuf/jsonpb/jsonpb.go @@ -106,6 +106,9 @@ func defaultResolveAny(typeUrl string) (proto.Message, error) { // way they are marshaled to JSON. Messages that implement this should // also implement JSONPBUnmarshaler so that the custom format can be // parsed. +// +// The JSON marshaling must follow the proto to JSON specification: +// https://developers.google.com/protocol-buffers/docs/proto3#json type JSONPBMarshaler interface { MarshalJSONPB(*Marshaler) ([]byte, error) } @@ -114,6 +117,9 @@ type JSONPBMarshaler interface { // the way they are unmarshaled from JSON. Messages that implement this // should also implement JSONPBMarshaler so that the custom format can be // produced. +// +// The JSON unmarshaling must follow the JSON to proto specification: +// https://developers.google.com/protocol-buffers/docs/proto3#json type JSONPBUnmarshaler interface { UnmarshalJSONPB(*Unmarshaler, []byte) error } @@ -565,6 +571,7 @@ func (m *Marshaler) marshalValue(out *errWriter, prop *proto.Properties, v refle out.write(m.Indent) } + // TODO handle map key prop properly b, err := json.Marshal(k.Interface()) if err != nil { return err @@ -586,7 +593,11 @@ func (m *Marshaler) marshalValue(out *errWriter, prop *proto.Properties, v refle out.write(` `) } - if err := m.marshalValue(out, prop, v.MapIndex(k), indent+m.Indent); err != nil { + vprop := prop + if prop != nil && prop.MapValProp != nil { + vprop = prop.MapValProp + } + if err := m.marshalValue(out, vprop, v.MapIndex(k), indent+m.Indent); err != nil { return err } } @@ -778,7 +789,7 @@ func (u *Unmarshaler) unmarshalValue(target reflect.Value, inputValue json.RawMe return nil case "Duration": - unq, err := strconv.Unquote(string(inputValue)) + unq, err := unquote(string(inputValue)) if err != nil { return err } @@ -795,7 +806,7 @@ func (u *Unmarshaler) unmarshalValue(target reflect.Value, inputValue json.RawMe target.Field(1).SetInt(ns) return nil case "Timestamp": - unq, err := strconv.Unquote(string(inputValue)) + unq, err := unquote(string(inputValue)) if err != nil { return err } @@ -842,7 +853,7 @@ func (u *Unmarshaler) unmarshalValue(target reflect.Value, inputValue json.RawMe target.Field(0).Set(reflect.ValueOf(&stpb.Value_NullValue{})) } else if v, err := strconv.ParseFloat(ivStr, 0); err == nil { target.Field(0).Set(reflect.ValueOf(&stpb.Value_NumberValue{v})) - } else if v, err := strconv.Unquote(ivStr); err == nil { + } else if v, err := unquote(ivStr); err == nil { target.Field(0).Set(reflect.ValueOf(&stpb.Value_StringValue{v})) } else if v, err := strconv.ParseBool(ivStr); err == nil { target.Field(0).Set(reflect.ValueOf(&stpb.Value_BoolValue{v})) @@ -878,6 +889,9 @@ func (u *Unmarshaler) unmarshalValue(target reflect.Value, inputValue json.RawMe target.Set(reflect.New(targetType.Elem())) target = target.Elem() } + if targetType.Kind() != reflect.Int32 { + return fmt.Errorf("invalid target %q for enum %s", targetType.Kind(), prop.Enum) + } target.SetInt(int64(n)) return nil } @@ -1007,16 +1021,22 @@ func (u *Unmarshaler) unmarshalValue(target reflect.Value, inputValue json.RawMe k = reflect.ValueOf(ks) } else { k = reflect.New(targetType.Key()).Elem() - // TODO: pass the correct Properties if needed. - if err := u.unmarshalValue(k, json.RawMessage(ks), nil); err != nil { + var kprop *proto.Properties + if prop != nil && prop.MapKeyProp != nil { + kprop = prop.MapKeyProp + } + if err := u.unmarshalValue(k, json.RawMessage(ks), kprop); err != nil { return err } } // Unmarshal map value. v := reflect.New(targetType.Elem()).Elem() - // TODO: pass the correct Properties if needed. - if err := u.unmarshalValue(v, raw, nil); err != nil { + var vprop *proto.Properties + if prop != nil && prop.MapValProp != nil { + vprop = prop.MapValProp + } + if err := u.unmarshalValue(v, raw, vprop); err != nil { return err } target.SetMapIndex(k, v) @@ -1025,13 +1045,6 @@ func (u *Unmarshaler) unmarshalValue(target reflect.Value, inputValue json.RawMe return nil } - // 64-bit integers can be encoded as strings. In this case we drop - // the quotes and proceed as normal. - isNum := targetType.Kind() == reflect.Int64 || targetType.Kind() == reflect.Uint64 - if isNum && strings.HasPrefix(string(inputValue), `"`) { - inputValue = inputValue[1 : len(inputValue)-1] - } - // Non-finite numbers can be encoded as strings. isFloat := targetType.Kind() == reflect.Float32 || targetType.Kind() == reflect.Float64 if isFloat { @@ -1041,10 +1054,25 @@ func (u *Unmarshaler) unmarshalValue(target reflect.Value, inputValue json.RawMe } } + // integers & floats can be encoded as strings. In this case we drop + // the quotes and proceed as normal. + isNum := targetType.Kind() == reflect.Int64 || targetType.Kind() == reflect.Uint64 || + targetType.Kind() == reflect.Int32 || targetType.Kind() == reflect.Uint32 || + targetType.Kind() == reflect.Float32 || targetType.Kind() == reflect.Float64 + if isNum && strings.HasPrefix(string(inputValue), `"`) { + inputValue = inputValue[1 : len(inputValue)-1] + } + // Use the encoding/json for parsing other value types. return json.Unmarshal(inputValue, target.Addr().Interface()) } +func unquote(s string) (string, error) { + var ret string + err := json.Unmarshal([]byte(s), &ret) + return ret, err +} + // jsonProperties returns parsed proto.Properties for the field and corrects JSONName attribute. func jsonProperties(f reflect.StructField, origName bool) *proto.Properties { var prop proto.Properties @@ -1094,6 +1122,8 @@ func (s mapKeys) Swap(i, j int) { s[i], s[j] = s[j], s[i] } func (s mapKeys) Less(i, j int) bool { if k := s[i].Kind(); k == s[j].Kind() { switch k { + case reflect.String: + return s[i].String() < s[j].String() case reflect.Int32, reflect.Int64: return s[i].Int() < s[j].Int() case reflect.Uint32, reflect.Uint64: diff --git a/vendor/github.com/golang/protobuf/proto/encode.go b/vendor/github.com/golang/protobuf/proto/encode.go index c27d35f866bb0..3abfed2cff04b 100644 --- a/vendor/github.com/golang/protobuf/proto/encode.go +++ b/vendor/github.com/golang/protobuf/proto/encode.go @@ -37,27 +37,9 @@ package proto import ( "errors" - "fmt" "reflect" ) -// RequiredNotSetError is the error returned if Marshal is called with -// a protocol buffer struct whose required fields have not -// all been initialized. It is also the error returned if Unmarshal is -// called with an encoded protocol buffer that does not include all the -// required fields. -// -// When printed, RequiredNotSetError reports the first unset required field in a -// message. If the field cannot be precisely determined, it is reported as -// "{Unknown}". -type RequiredNotSetError struct { - field string -} - -func (e *RequiredNotSetError) Error() string { - return fmt.Sprintf("proto: required field %q not set", e.field) -} - var ( // errRepeatedHasNil is the error returned if Marshal is called with // a struct with a repeated field containing a nil element. diff --git a/vendor/github.com/golang/protobuf/proto/lib.go b/vendor/github.com/golang/protobuf/proto/lib.go index 0e2191b8ada36..75565cc6dcf41 100644 --- a/vendor/github.com/golang/protobuf/proto/lib.go +++ b/vendor/github.com/golang/protobuf/proto/lib.go @@ -265,7 +265,6 @@ package proto import ( "encoding/json" - "errors" "fmt" "log" "reflect" @@ -274,7 +273,66 @@ import ( "sync" ) -var errInvalidUTF8 = errors.New("proto: invalid UTF-8 string") +// RequiredNotSetError is an error type returned by either Marshal or Unmarshal. +// Marshal reports this when a required field is not initialized. +// Unmarshal reports this when a required field is missing from the wire data. +type RequiredNotSetError struct{ field string } + +func (e *RequiredNotSetError) Error() string { + if e.field == "" { + return fmt.Sprintf("proto: required field not set") + } + return fmt.Sprintf("proto: required field %q not set", e.field) +} +func (e *RequiredNotSetError) RequiredNotSet() bool { + return true +} + +type invalidUTF8Error struct{ field string } + +func (e *invalidUTF8Error) Error() string { + if e.field == "" { + return "proto: invalid UTF-8 detected" + } + return fmt.Sprintf("proto: field %q contains invalid UTF-8", e.field) +} +func (e *invalidUTF8Error) InvalidUTF8() bool { + return true +} + +// errInvalidUTF8 is a sentinel error to identify fields with invalid UTF-8. +// This error should not be exposed to the external API as such errors should +// be recreated with the field information. +var errInvalidUTF8 = &invalidUTF8Error{} + +// isNonFatal reports whether the error is either a RequiredNotSet error +// or a InvalidUTF8 error. +func isNonFatal(err error) bool { + if re, ok := err.(interface{ RequiredNotSet() bool }); ok && re.RequiredNotSet() { + return true + } + if re, ok := err.(interface{ InvalidUTF8() bool }); ok && re.InvalidUTF8() { + return true + } + return false +} + +type nonFatal struct{ E error } + +// Merge merges err into nf and reports whether it was successful. +// Otherwise it returns false for any fatal non-nil errors. +func (nf *nonFatal) Merge(err error) (ok bool) { + if err == nil { + return true // not an error + } + if !isNonFatal(err) { + return false // fatal error + } + if nf.E == nil { + nf.E = err // store first instance of non-fatal error + } + return true +} // Message is implemented by generated protocol buffer messages. type Message interface { diff --git a/vendor/github.com/golang/protobuf/proto/properties.go b/vendor/github.com/golang/protobuf/proto/properties.go index f710adab09246..50b99b83a8c79 100644 --- a/vendor/github.com/golang/protobuf/proto/properties.go +++ b/vendor/github.com/golang/protobuf/proto/properties.go @@ -139,7 +139,7 @@ type Properties struct { Repeated bool Packed bool // relevant for repeated primitives only Enum string // set for enum types only - proto3 bool // whether this is known to be a proto3 field; set for []byte only + proto3 bool // whether this is known to be a proto3 field oneof bool // whether this is a oneof field Default string // default value @@ -148,9 +148,9 @@ type Properties struct { stype reflect.Type // set for struct types only sprop *StructProperties // set for struct types only - mtype reflect.Type // set for map types only - mkeyprop *Properties // set for map types only - mvalprop *Properties // set for map types only + mtype reflect.Type // set for map types only + MapKeyProp *Properties // set for map types only + MapValProp *Properties // set for map types only } // String formats the properties in the protobuf struct field tag style. @@ -275,16 +275,16 @@ func (p *Properties) setFieldProps(typ reflect.Type, f *reflect.StructField, loc case reflect.Map: p.mtype = t1 - p.mkeyprop = &Properties{} - p.mkeyprop.init(reflect.PtrTo(p.mtype.Key()), "Key", f.Tag.Get("protobuf_key"), nil, lockGetProp) - p.mvalprop = &Properties{} + p.MapKeyProp = &Properties{} + p.MapKeyProp.init(reflect.PtrTo(p.mtype.Key()), "Key", f.Tag.Get("protobuf_key"), nil, lockGetProp) + p.MapValProp = &Properties{} vtype := p.mtype.Elem() if vtype.Kind() != reflect.Ptr && vtype.Kind() != reflect.Slice { // The value type is not a message (*T) or bytes ([]byte), // so we need encoders for the pointer to this type. vtype = reflect.PtrTo(vtype) } - p.mvalprop.init(vtype, "Value", f.Tag.Get("protobuf_val"), nil, lockGetProp) + p.MapValProp.init(vtype, "Value", f.Tag.Get("protobuf_val"), nil, lockGetProp) } if p.stype != nil { diff --git a/vendor/github.com/golang/protobuf/proto/table_marshal.go b/vendor/github.com/golang/protobuf/proto/table_marshal.go index 0f212b3029d2d..b16794496f5f1 100644 --- a/vendor/github.com/golang/protobuf/proto/table_marshal.go +++ b/vendor/github.com/golang/protobuf/proto/table_marshal.go @@ -231,7 +231,7 @@ func (u *marshalInfo) marshal(b []byte, ptr pointer, deterministic bool) ([]byte return b, err } - var err, errreq error + var err, errLater error // The old marshaler encodes extensions at beginning. if u.extensions.IsValid() { e := ptr.offset(u.extensions).toExtensions() @@ -252,11 +252,13 @@ func (u *marshalInfo) marshal(b []byte, ptr pointer, deterministic bool) ([]byte } } for _, f := range u.fields { - if f.required && errreq == nil { + if f.required { if ptr.offset(f.field).getPointer().isNil() { // Required field is not set. // We record the error but keep going, to give a complete marshaling. - errreq = &RequiredNotSetError{f.name} + if errLater == nil { + errLater = &RequiredNotSetError{f.name} + } continue } } @@ -269,14 +271,21 @@ func (u *marshalInfo) marshal(b []byte, ptr pointer, deterministic bool) ([]byte if err1, ok := err.(*RequiredNotSetError); ok { // Required field in submessage is not set. // We record the error but keep going, to give a complete marshaling. - if errreq == nil { - errreq = &RequiredNotSetError{f.name + "." + err1.field} + if errLater == nil { + errLater = &RequiredNotSetError{f.name + "." + err1.field} } continue } if err == errRepeatedHasNil { err = errors.New("proto: repeated field " + f.name + " has nil element") } + if err == errInvalidUTF8 { + if errLater == nil { + fullName := revProtoTypes[reflect.PtrTo(u.typ)] + "." + f.name + errLater = &invalidUTF8Error{fullName} + } + continue + } return b, err } } @@ -284,7 +293,7 @@ func (u *marshalInfo) marshal(b []byte, ptr pointer, deterministic bool) ([]byte s := *ptr.offset(u.unrecognized).toBytes() b = append(b, s...) } - return b, errreq + return b, errLater } // computeMarshalInfo initializes the marshal info. @@ -530,6 +539,7 @@ func typeMarshaler(t reflect.Type, tags []string, nozero, oneof bool) (sizer, ma packed := false proto3 := false + validateUTF8 := true for i := 2; i < len(tags); i++ { if tags[i] == "packed" { packed = true @@ -538,6 +548,7 @@ func typeMarshaler(t reflect.Type, tags []string, nozero, oneof bool) (sizer, ma proto3 = true } } + validateUTF8 = validateUTF8 && proto3 switch t.Kind() { case reflect.Bool: @@ -735,6 +746,18 @@ func typeMarshaler(t reflect.Type, tags []string, nozero, oneof bool) (sizer, ma } return sizeFloat64Value, appendFloat64Value case reflect.String: + if validateUTF8 { + if pointer { + return sizeStringPtr, appendUTF8StringPtr + } + if slice { + return sizeStringSlice, appendUTF8StringSlice + } + if nozero { + return sizeStringValueNoZero, appendUTF8StringValueNoZero + } + return sizeStringValue, appendUTF8StringValue + } if pointer { return sizeStringPtr, appendStringPtr } @@ -1983,52 +2006,105 @@ func appendBoolPackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byt return b, nil } func appendStringValue(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) { + v := *ptr.toString() + b = appendVarint(b, wiretag) + b = appendVarint(b, uint64(len(v))) + b = append(b, v...) + return b, nil +} +func appendStringValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) { + v := *ptr.toString() + if v == "" { + return b, nil + } + b = appendVarint(b, wiretag) + b = appendVarint(b, uint64(len(v))) + b = append(b, v...) + return b, nil +} +func appendStringPtr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) { + p := *ptr.toStringPtr() + if p == nil { + return b, nil + } + v := *p + b = appendVarint(b, wiretag) + b = appendVarint(b, uint64(len(v))) + b = append(b, v...) + return b, nil +} +func appendStringSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) { + s := *ptr.toStringSlice() + for _, v := range s { + b = appendVarint(b, wiretag) + b = appendVarint(b, uint64(len(v))) + b = append(b, v...) + } + return b, nil +} +func appendUTF8StringValue(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) { + var invalidUTF8 bool v := *ptr.toString() if !utf8.ValidString(v) { - return nil, errInvalidUTF8 + invalidUTF8 = true } b = appendVarint(b, wiretag) b = appendVarint(b, uint64(len(v))) b = append(b, v...) + if invalidUTF8 { + return b, errInvalidUTF8 + } return b, nil } -func appendStringValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) { +func appendUTF8StringValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) { + var invalidUTF8 bool v := *ptr.toString() if v == "" { return b, nil } if !utf8.ValidString(v) { - return nil, errInvalidUTF8 + invalidUTF8 = true } b = appendVarint(b, wiretag) b = appendVarint(b, uint64(len(v))) b = append(b, v...) + if invalidUTF8 { + return b, errInvalidUTF8 + } return b, nil } -func appendStringPtr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) { +func appendUTF8StringPtr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) { + var invalidUTF8 bool p := *ptr.toStringPtr() if p == nil { return b, nil } v := *p if !utf8.ValidString(v) { - return nil, errInvalidUTF8 + invalidUTF8 = true } b = appendVarint(b, wiretag) b = appendVarint(b, uint64(len(v))) b = append(b, v...) + if invalidUTF8 { + return b, errInvalidUTF8 + } return b, nil } -func appendStringSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) { +func appendUTF8StringSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) { + var invalidUTF8 bool s := *ptr.toStringSlice() for _, v := range s { if !utf8.ValidString(v) { - return nil, errInvalidUTF8 + invalidUTF8 = true } b = appendVarint(b, wiretag) b = appendVarint(b, uint64(len(v))) b = append(b, v...) } + if invalidUTF8 { + return b, errInvalidUTF8 + } return b, nil } func appendBytes(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) { @@ -2107,7 +2183,8 @@ func makeGroupSliceMarshaler(u *marshalInfo) (sizer, marshaler) { }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) { s := ptr.getPointerSlice() - var err, errreq error + var err error + var nerr nonFatal for _, v := range s { if v.isNil() { return b, errRepeatedHasNil @@ -2115,22 +2192,14 @@ func makeGroupSliceMarshaler(u *marshalInfo) (sizer, marshaler) { b = appendVarint(b, wiretag) // start group b, err = u.marshal(b, v, deterministic) b = appendVarint(b, wiretag+(WireEndGroup-WireStartGroup)) // end group - if err != nil { - if _, ok := err.(*RequiredNotSetError); ok { - // Required field in submessage is not set. - // We record the error but keep going, to give a complete marshaling. - if errreq == nil { - errreq = err - } - continue - } + if !nerr.Merge(err) { if err == ErrNil { err = errRepeatedHasNil } return b, err } } - return b, errreq + return b, nerr.E } } @@ -2174,7 +2243,8 @@ func makeMessageSliceMarshaler(u *marshalInfo) (sizer, marshaler) { }, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) { s := ptr.getPointerSlice() - var err, errreq error + var err error + var nerr nonFatal for _, v := range s { if v.isNil() { return b, errRepeatedHasNil @@ -2184,22 +2254,14 @@ func makeMessageSliceMarshaler(u *marshalInfo) (sizer, marshaler) { b = appendVarint(b, uint64(siz)) b, err = u.marshal(b, v, deterministic) - if err != nil { - if _, ok := err.(*RequiredNotSetError); ok { - // Required field in submessage is not set. - // We record the error but keep going, to give a complete marshaling. - if errreq == nil { - errreq = err - } - continue - } + if !nerr.Merge(err) { if err == ErrNil { err = errRepeatedHasNil } return b, err } } - return b, errreq + return b, nerr.E } } @@ -2223,6 +2285,25 @@ func makeMapMarshaler(f *reflect.StructField) (sizer, marshaler) { // value. // Key cannot be pointer-typed. valIsPtr := valType.Kind() == reflect.Ptr + + // If value is a message with nested maps, calling + // valSizer in marshal may be quadratic. We should use + // cached version in marshal (but not in size). + // If value is not message type, we don't have size cache, + // but it cannot be nested either. Just use valSizer. + valCachedSizer := valSizer + if valIsPtr && valType.Elem().Kind() == reflect.Struct { + u := getMarshalInfo(valType.Elem()) + valCachedSizer = func(ptr pointer, tagsize int) int { + // Same as message sizer, but use cache. + p := ptr.getPointer() + if p.isNil() { + return 0 + } + siz := u.cachedsize(p) + return siz + SizeVarint(uint64(siz)) + tagsize + } + } return func(ptr pointer, tagsize int) int { m := ptr.asPointerTo(t).Elem() // the map n := 0 @@ -2243,24 +2324,26 @@ func makeMapMarshaler(f *reflect.StructField) (sizer, marshaler) { if len(keys) > 1 && deterministic { sort.Sort(mapKeys(keys)) } + + var nerr nonFatal for _, k := range keys { ki := k.Interface() vi := m.MapIndex(k).Interface() kaddr := toAddrPointer(&ki, false) // pointer to key vaddr := toAddrPointer(&vi, valIsPtr) // pointer to value b = appendVarint(b, tag) - siz := keySizer(kaddr, 1) + valSizer(vaddr, 1) // tag of key = 1 (size=1), tag of val = 2 (size=1) + siz := keySizer(kaddr, 1) + valCachedSizer(vaddr, 1) // tag of key = 1 (size=1), tag of val = 2 (size=1) b = appendVarint(b, uint64(siz)) b, err = keyMarshaler(b, kaddr, keyWireTag, deterministic) - if err != nil { + if !nerr.Merge(err) { return b, err } b, err = valMarshaler(b, vaddr, valWireTag, deterministic) - if err != nil && err != ErrNil { // allow nil value in map + if err != ErrNil && !nerr.Merge(err) { // allow nil value in map return b, err } } - return b, nil + return b, nerr.E } } @@ -2333,6 +2416,7 @@ func (u *marshalInfo) appendExtensions(b []byte, ext *XXX_InternalExtensions, de defer mu.Unlock() var err error + var nerr nonFatal // Fast-path for common cases: zero or one extensions. // Don't bother sorting the keys. @@ -2352,11 +2436,11 @@ func (u *marshalInfo) appendExtensions(b []byte, ext *XXX_InternalExtensions, de v := e.value p := toAddrPointer(&v, ei.isptr) b, err = ei.marshaler(b, p, ei.wiretag, deterministic) - if err != nil { + if !nerr.Merge(err) { return b, err } } - return b, nil + return b, nerr.E } // Sort the keys to provide a deterministic encoding. @@ -2383,11 +2467,11 @@ func (u *marshalInfo) appendExtensions(b []byte, ext *XXX_InternalExtensions, de v := e.value p := toAddrPointer(&v, ei.isptr) b, err = ei.marshaler(b, p, ei.wiretag, deterministic) - if err != nil { + if !nerr.Merge(err) { return b, err } } - return b, nil + return b, nerr.E } // message set format is: @@ -2444,6 +2528,7 @@ func (u *marshalInfo) appendMessageSet(b []byte, ext *XXX_InternalExtensions, de defer mu.Unlock() var err error + var nerr nonFatal // Fast-path for common cases: zero or one extensions. // Don't bother sorting the keys. @@ -2470,12 +2555,12 @@ func (u *marshalInfo) appendMessageSet(b []byte, ext *XXX_InternalExtensions, de v := e.value p := toAddrPointer(&v, ei.isptr) b, err = ei.marshaler(b, p, 3<<3|WireBytes, deterministic) - if err != nil { + if !nerr.Merge(err) { return b, err } b = append(b, 1<<3|WireEndGroup) } - return b, nil + return b, nerr.E } // Sort the keys to provide a deterministic encoding. @@ -2509,11 +2594,11 @@ func (u *marshalInfo) appendMessageSet(b []byte, ext *XXX_InternalExtensions, de p := toAddrPointer(&v, ei.isptr) b, err = ei.marshaler(b, p, 3<<3|WireBytes, deterministic) b = append(b, 1<<3|WireEndGroup) - if err != nil { + if !nerr.Merge(err) { return b, err } } - return b, nil + return b, nerr.E } // sizeV1Extensions computes the size of encoded data for a V1-API extension field. @@ -2556,6 +2641,7 @@ func (u *marshalInfo) appendV1Extensions(b []byte, m map[int32]Extension, determ sort.Ints(keys) var err error + var nerr nonFatal for _, k := range keys { e := m[int32(k)] if e.value == nil || e.desc == nil { @@ -2572,11 +2658,11 @@ func (u *marshalInfo) appendV1Extensions(b []byte, m map[int32]Extension, determ v := e.value p := toAddrPointer(&v, ei.isptr) b, err = ei.marshaler(b, p, ei.wiretag, deterministic) - if err != nil { + if !nerr.Merge(err) { return b, err } } - return b, nil + return b, nerr.E } // newMarshaler is the interface representing objects that can marshal themselves. diff --git a/vendor/github.com/golang/protobuf/proto/table_unmarshal.go b/vendor/github.com/golang/protobuf/proto/table_unmarshal.go index 55f0340a3fde2..ebf1caa56a268 100644 --- a/vendor/github.com/golang/protobuf/proto/table_unmarshal.go +++ b/vendor/github.com/golang/protobuf/proto/table_unmarshal.go @@ -97,6 +97,8 @@ type unmarshalFieldInfo struct { // if a required field, contains a single set bit at this field's index in the required field list. reqMask uint64 + + name string // name of the field, for error reporting } var ( @@ -136,8 +138,8 @@ func (u *unmarshalInfo) unmarshal(m pointer, b []byte) error { if u.isMessageSet { return UnmarshalMessageSet(b, m.offset(u.extensions).toExtensions()) } - var reqMask uint64 // bitmask of required fields we've seen. - var rnse *RequiredNotSetError // an instance of a RequiredNotSetError returned by a submessage. + var reqMask uint64 // bitmask of required fields we've seen. + var errLater error for len(b) > 0 { // Read tag and wire type. // Special case 1 and 2 byte varints. @@ -176,11 +178,20 @@ func (u *unmarshalInfo) unmarshal(m pointer, b []byte) error { if r, ok := err.(*RequiredNotSetError); ok { // Remember this error, but keep parsing. We need to produce // a full parse even if a required field is missing. - rnse = r + if errLater == nil { + errLater = r + } reqMask |= f.reqMask continue } if err != errInternalBadWireType { + if err == errInvalidUTF8 { + if errLater == nil { + fullName := revProtoTypes[reflect.PtrTo(u.typ)] + "." + f.name + errLater = &invalidUTF8Error{fullName} + } + continue + } return err } // Fragments with bad wire type are treated as unknown fields. @@ -239,20 +250,16 @@ func (u *unmarshalInfo) unmarshal(m pointer, b []byte) error { emap[int32(tag)] = e } } - if rnse != nil { - // A required field of a submessage/group is missing. Return that error. - return rnse - } - if reqMask != u.reqMask { + if reqMask != u.reqMask && errLater == nil { // A required field of this message is missing. for _, n := range u.reqFields { if reqMask&1 == 0 { - return &RequiredNotSetError{n} + errLater = &RequiredNotSetError{n} } reqMask >>= 1 } } - return nil + return errLater } // computeUnmarshalInfo fills in u with information for use @@ -351,7 +358,7 @@ func (u *unmarshalInfo) computeUnmarshalInfo() { } // Store the info in the correct slot in the message. - u.setTag(tag, toField(&f), unmarshal, reqMask) + u.setTag(tag, toField(&f), unmarshal, reqMask, name) } // Find any types associated with oneof fields. @@ -366,10 +373,17 @@ func (u *unmarshalInfo) computeUnmarshalInfo() { f := typ.Field(0) // oneof implementers have one field baseUnmarshal := fieldUnmarshaler(&f) - tagstr := strings.Split(f.Tag.Get("protobuf"), ",")[1] - tag, err := strconv.Atoi(tagstr) + tags := strings.Split(f.Tag.Get("protobuf"), ",") + fieldNum, err := strconv.Atoi(tags[1]) if err != nil { - panic("protobuf tag field not an integer: " + tagstr) + panic("protobuf tag field not an integer: " + tags[1]) + } + var name string + for _, tag := range tags { + if strings.HasPrefix(tag, "name=") { + name = strings.TrimPrefix(tag, "name=") + break + } } // Find the oneof field that this struct implements. @@ -380,7 +394,7 @@ func (u *unmarshalInfo) computeUnmarshalInfo() { // That lets us know where this struct should be stored // when we encounter it during unmarshaling. unmarshal := makeUnmarshalOneof(typ, of.ityp, baseUnmarshal) - u.setTag(tag, of.field, unmarshal, 0) + u.setTag(fieldNum, of.field, unmarshal, 0, name) } } } @@ -401,7 +415,7 @@ func (u *unmarshalInfo) computeUnmarshalInfo() { // [0 0] is [tag=0/wiretype=varint varint-encoded-0]. u.setTag(0, zeroField, func(b []byte, f pointer, w int) ([]byte, error) { return nil, fmt.Errorf("proto: %s: illegal tag 0 (wire type %d)", t, w) - }, 0) + }, 0, "") // Set mask for required field check. u.reqMask = uint64(1)<= 0 && (tag < 16 || tag < 2*n) { // TODO: what are the right numbers here? for len(u.dense) <= tag { @@ -442,11 +457,17 @@ func typeUnmarshaler(t reflect.Type, tags string) unmarshaler { tagArray := strings.Split(tags, ",") encoding := tagArray[0] name := "unknown" + proto3 := false + validateUTF8 := true for _, tag := range tagArray[3:] { if strings.HasPrefix(tag, "name=") { name = tag[5:] } + if tag == "proto3" { + proto3 = true + } } + validateUTF8 = validateUTF8 && proto3 // Figure out packaging (pointer, slice, or both) slice := false @@ -594,6 +615,15 @@ func typeUnmarshaler(t reflect.Type, tags string) unmarshaler { } return unmarshalBytesValue case reflect.String: + if validateUTF8 { + if pointer { + return unmarshalUTF8StringPtr + } + if slice { + return unmarshalUTF8StringSlice + } + return unmarshalUTF8StringValue + } if pointer { return unmarshalStringPtr } @@ -1448,9 +1478,6 @@ func unmarshalStringValue(b []byte, f pointer, w int) ([]byte, error) { return nil, io.ErrUnexpectedEOF } v := string(b[:x]) - if !utf8.ValidString(v) { - return nil, errInvalidUTF8 - } *f.toString() = v return b[x:], nil } @@ -1468,9 +1495,6 @@ func unmarshalStringPtr(b []byte, f pointer, w int) ([]byte, error) { return nil, io.ErrUnexpectedEOF } v := string(b[:x]) - if !utf8.ValidString(v) { - return nil, errInvalidUTF8 - } *f.toStringPtr() = &v return b[x:], nil } @@ -1488,11 +1512,69 @@ func unmarshalStringSlice(b []byte, f pointer, w int) ([]byte, error) { return nil, io.ErrUnexpectedEOF } v := string(b[:x]) + s := f.toStringSlice() + *s = append(*s, v) + return b[x:], nil +} + +func unmarshalUTF8StringValue(b []byte, f pointer, w int) ([]byte, error) { + if w != WireBytes { + return b, errInternalBadWireType + } + x, n := decodeVarint(b) + if n == 0 { + return nil, io.ErrUnexpectedEOF + } + b = b[n:] + if x > uint64(len(b)) { + return nil, io.ErrUnexpectedEOF + } + v := string(b[:x]) + *f.toString() = v if !utf8.ValidString(v) { - return nil, errInvalidUTF8 + return b[x:], errInvalidUTF8 } + return b[x:], nil +} + +func unmarshalUTF8StringPtr(b []byte, f pointer, w int) ([]byte, error) { + if w != WireBytes { + return b, errInternalBadWireType + } + x, n := decodeVarint(b) + if n == 0 { + return nil, io.ErrUnexpectedEOF + } + b = b[n:] + if x > uint64(len(b)) { + return nil, io.ErrUnexpectedEOF + } + v := string(b[:x]) + *f.toStringPtr() = &v + if !utf8.ValidString(v) { + return b[x:], errInvalidUTF8 + } + return b[x:], nil +} + +func unmarshalUTF8StringSlice(b []byte, f pointer, w int) ([]byte, error) { + if w != WireBytes { + return b, errInternalBadWireType + } + x, n := decodeVarint(b) + if n == 0 { + return nil, io.ErrUnexpectedEOF + } + b = b[n:] + if x > uint64(len(b)) { + return nil, io.ErrUnexpectedEOF + } + v := string(b[:x]) s := f.toStringSlice() *s = append(*s, v) + if !utf8.ValidString(v) { + return b[x:], errInvalidUTF8 + } return b[x:], nil } @@ -1674,6 +1756,7 @@ func makeUnmarshalMap(f *reflect.StructField) unmarshaler { // Maps will be somewhat slow. Oh well. // Read key and value from data. + var nerr nonFatal k := reflect.New(kt) v := reflect.New(vt) for len(b) > 0 { @@ -1694,7 +1777,7 @@ func makeUnmarshalMap(f *reflect.StructField) unmarshaler { err = errInternalBadWireType // skip unknown tag } - if err == nil { + if nerr.Merge(err) { continue } if err != errInternalBadWireType { @@ -1717,7 +1800,7 @@ func makeUnmarshalMap(f *reflect.StructField) unmarshaler { // Insert into map. m.SetMapIndex(k.Elem(), v.Elem()) - return r, nil + return r, nerr.E } } @@ -1743,15 +1826,16 @@ func makeUnmarshalOneof(typ, ityp reflect.Type, unmarshal unmarshaler) unmarshal // Unmarshal data into holder. // We unmarshal into the first field of the holder object. var err error + var nerr nonFatal b, err = unmarshal(b, valToPointer(v).offset(field0), w) - if err != nil { + if !nerr.Merge(err) { return nil, err } // Write pointer to holder into target field. f.asPointerTo(ityp).Elem().Set(v) - return b, nil + return b, nerr.E } } diff --git a/vendor/github.com/golang/protobuf/proto/text.go b/vendor/github.com/golang/protobuf/proto/text.go index 2205fdaadf84c..1aaee725b45b3 100644 --- a/vendor/github.com/golang/protobuf/proto/text.go +++ b/vendor/github.com/golang/protobuf/proto/text.go @@ -353,7 +353,7 @@ func (tm *TextMarshaler) writeStruct(w *textWriter, sv reflect.Value) error { return err } } - if err := tm.writeAny(w, key, props.mkeyprop); err != nil { + if err := tm.writeAny(w, key, props.MapKeyProp); err != nil { return err } if err := w.WriteByte('\n'); err != nil { @@ -370,7 +370,7 @@ func (tm *TextMarshaler) writeStruct(w *textWriter, sv reflect.Value) error { return err } } - if err := tm.writeAny(w, val, props.mvalprop); err != nil { + if err := tm.writeAny(w, val, props.MapValProp); err != nil { return err } if err := w.WriteByte('\n'); err != nil { diff --git a/vendor/github.com/golang/protobuf/proto/text_parser.go b/vendor/github.com/golang/protobuf/proto/text_parser.go index 0685bae36d507..bb55a3af27694 100644 --- a/vendor/github.com/golang/protobuf/proto/text_parser.go +++ b/vendor/github.com/golang/protobuf/proto/text_parser.go @@ -630,17 +630,17 @@ func (p *textParser) readStruct(sv reflect.Value, terminator string) error { if err := p.consumeToken(":"); err != nil { return err } - if err := p.readAny(key, props.mkeyprop); err != nil { + if err := p.readAny(key, props.MapKeyProp); err != nil { return err } if err := p.consumeOptionalSeparator(); err != nil { return err } case "value": - if err := p.checkForColon(props.mvalprop, dst.Type().Elem()); err != nil { + if err := p.checkForColon(props.MapValProp, dst.Type().Elem()); err != nil { return err } - if err := p.readAny(val, props.mvalprop); err != nil { + if err := p.readAny(val, props.MapValProp); err != nil { return err } if err := p.consumeOptionalSeparator(); err != nil { diff --git a/vendor/github.com/golang/protobuf/ptypes/any.go b/vendor/github.com/golang/protobuf/ptypes/any.go index b2af97f4a9823..70276e8f5c946 100644 --- a/vendor/github.com/golang/protobuf/ptypes/any.go +++ b/vendor/github.com/golang/protobuf/ptypes/any.go @@ -130,10 +130,12 @@ func UnmarshalAny(any *any.Any, pb proto.Message) error { // Is returns true if any value contains a given message type. func Is(any *any.Any, pb proto.Message) bool { - aname, err := AnyMessageName(any) - if err != nil { + // The following is equivalent to AnyMessageName(any) == proto.MessageName(pb), + // but it avoids scanning TypeUrl for the slash. + if any == nil { return false } - - return aname == proto.MessageName(pb) + name := proto.MessageName(pb) + prefix := len(any.TypeUrl) - len(name) + return prefix >= 1 && any.TypeUrl[prefix-1] == '/' && any.TypeUrl[prefix:] == name } diff --git a/vendor/github.com/golang/protobuf/ptypes/any/any.pb.go b/vendor/github.com/golang/protobuf/ptypes/any/any.pb.go index f67edc7dc2bfc..e3c56d3ffa2a0 100644 --- a/vendor/github.com/golang/protobuf/ptypes/any/any.pb.go +++ b/vendor/github.com/golang/protobuf/ptypes/any/any.pb.go @@ -121,7 +121,7 @@ type Any struct { // Schemes other than `http`, `https` (or the empty scheme) might be // used with implementation specific semantics. // - TypeUrl string `protobuf:"bytes,1,opt,name=type_url,json=typeUrl" json:"type_url,omitempty"` + TypeUrl string `protobuf:"bytes,1,opt,name=type_url,json=typeUrl,proto3" json:"type_url,omitempty"` // Must be a valid serialized protocol buffer of the above specified type. Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` diff --git a/vendor/github.com/golang/protobuf/ptypes/duration/duration.pb.go b/vendor/github.com/golang/protobuf/ptypes/duration/duration.pb.go index 4d75473b8b2bf..a7beb2c41468e 100644 --- a/vendor/github.com/golang/protobuf/ptypes/duration/duration.pb.go +++ b/vendor/github.com/golang/protobuf/ptypes/duration/duration.pb.go @@ -82,14 +82,14 @@ type Duration struct { // Signed seconds of the span of time. Must be from -315,576,000,000 // to +315,576,000,000 inclusive. Note: these bounds are computed from: // 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years - Seconds int64 `protobuf:"varint,1,opt,name=seconds" json:"seconds,omitempty"` + Seconds int64 `protobuf:"varint,1,opt,name=seconds,proto3" json:"seconds,omitempty"` // Signed fractions of a second at nanosecond resolution of the span // of time. Durations less than one second are represented with a 0 // `seconds` field and a positive or negative `nanos` field. For durations // of one second or more, a non-zero value for the `nanos` field must be // of the same sign as the `seconds` field. Must be from -999,999,999 // to +999,999,999 inclusive. - Nanos int32 `protobuf:"varint,2,opt,name=nanos" json:"nanos,omitempty"` + Nanos int32 `protobuf:"varint,2,opt,name=nanos,proto3" json:"nanos,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` diff --git a/vendor/github.com/golang/protobuf/ptypes/struct/struct.pb.go b/vendor/github.com/golang/protobuf/ptypes/struct/struct.pb.go index 442c0e0999ca7..ee6382e1433ca 100644 --- a/vendor/github.com/golang/protobuf/ptypes/struct/struct.pb.go +++ b/vendor/github.com/golang/protobuf/ptypes/struct/struct.pb.go @@ -54,7 +54,7 @@ func (NullValue) XXX_WellKnownType() string { return "NullValue" } // The JSON representation for `Struct` is JSON object. type Struct struct { // Unordered map of dynamically typed values. - Fields map[string]*Value `protobuf:"bytes,1,rep,name=fields" json:"fields,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + Fields map[string]*Value `protobuf:"bytes,1,rep,name=fields,proto3" json:"fields,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` @@ -144,30 +144,40 @@ type isValue_Kind interface { } type Value_NullValue struct { - NullValue NullValue `protobuf:"varint,1,opt,name=null_value,json=nullValue,enum=google.protobuf.NullValue,oneof"` + NullValue NullValue `protobuf:"varint,1,opt,name=null_value,json=nullValue,proto3,enum=google.protobuf.NullValue,oneof"` } + type Value_NumberValue struct { - NumberValue float64 `protobuf:"fixed64,2,opt,name=number_value,json=numberValue,oneof"` + NumberValue float64 `protobuf:"fixed64,2,opt,name=number_value,json=numberValue,proto3,oneof"` } + type Value_StringValue struct { - StringValue string `protobuf:"bytes,3,opt,name=string_value,json=stringValue,oneof"` + StringValue string `protobuf:"bytes,3,opt,name=string_value,json=stringValue,proto3,oneof"` } + type Value_BoolValue struct { - BoolValue bool `protobuf:"varint,4,opt,name=bool_value,json=boolValue,oneof"` + BoolValue bool `protobuf:"varint,4,opt,name=bool_value,json=boolValue,proto3,oneof"` } + type Value_StructValue struct { - StructValue *Struct `protobuf:"bytes,5,opt,name=struct_value,json=structValue,oneof"` + StructValue *Struct `protobuf:"bytes,5,opt,name=struct_value,json=structValue,proto3,oneof"` } + type Value_ListValue struct { - ListValue *ListValue `protobuf:"bytes,6,opt,name=list_value,json=listValue,oneof"` + ListValue *ListValue `protobuf:"bytes,6,opt,name=list_value,json=listValue,proto3,oneof"` } -func (*Value_NullValue) isValue_Kind() {} +func (*Value_NullValue) isValue_Kind() {} + func (*Value_NumberValue) isValue_Kind() {} + func (*Value_StringValue) isValue_Kind() {} -func (*Value_BoolValue) isValue_Kind() {} + +func (*Value_BoolValue) isValue_Kind() {} + func (*Value_StructValue) isValue_Kind() {} -func (*Value_ListValue) isValue_Kind() {} + +func (*Value_ListValue) isValue_Kind() {} func (m *Value) GetKind() isValue_Kind { if m != nil { @@ -358,7 +368,7 @@ func _Value_OneofSizer(msg proto.Message) (n int) { // The JSON representation for `ListValue` is JSON array. type ListValue struct { // Repeated field of dynamically typed values. - Values []*Value `protobuf:"bytes,1,rep,name=values" json:"values,omitempty"` + Values []*Value `protobuf:"bytes,1,rep,name=values,proto3" json:"values,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` diff --git a/vendor/github.com/golang/protobuf/ptypes/timestamp/timestamp.pb.go b/vendor/github.com/golang/protobuf/ptypes/timestamp/timestamp.pb.go index e9c2222821664..8e76ae9763e79 100644 --- a/vendor/github.com/golang/protobuf/ptypes/timestamp/timestamp.pb.go +++ b/vendor/github.com/golang/protobuf/ptypes/timestamp/timestamp.pb.go @@ -100,12 +100,12 @@ type Timestamp struct { // Represents seconds of UTC time since Unix epoch // 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to // 9999-12-31T23:59:59Z inclusive. - Seconds int64 `protobuf:"varint,1,opt,name=seconds" json:"seconds,omitempty"` + Seconds int64 `protobuf:"varint,1,opt,name=seconds,proto3" json:"seconds,omitempty"` // Non-negative fractions of a second at nanosecond resolution. Negative // second values with fractions must still have non-negative nanos values // that count forward in time. Must be from 0 to 999,999,999 // inclusive. - Nanos int32 `protobuf:"varint,2,opt,name=nanos" json:"nanos,omitempty"` + Nanos int32 `protobuf:"varint,2,opt,name=nanos,proto3" json:"nanos,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` diff --git a/vendor/github.com/pingcap/kvproto/pkg/coprocessor/coprocessor.pb.go b/vendor/github.com/pingcap/kvproto/pkg/coprocessor/coprocessor.pb.go index 03a1644d7f451..448eb82b845f0 100644 --- a/vendor/github.com/pingcap/kvproto/pkg/coprocessor/coprocessor.pb.go +++ b/vendor/github.com/pingcap/kvproto/pkg/coprocessor/coprocessor.pb.go @@ -1,18 +1,6 @@ -// Code generated by protoc-gen-gogo. +// Code generated by protoc-gen-gogo. DO NOT EDIT. // source: coprocessor.proto -// DO NOT EDIT! -/* - Package coprocessor is a generated protocol buffer package. - - It is generated from these files: - coprocessor.proto - - It has these top-level messages: - KeyRange - Request - Response -*/ package coprocessor import ( @@ -22,6 +10,8 @@ import ( proto "github.com/golang/protobuf/proto" + _ "github.com/gogo/protobuf/gogoproto" + errorpb "github.com/pingcap/kvproto/pkg/errorpb" kvrpcpb "github.com/pingcap/kvproto/pkg/kvrpcpb" @@ -42,14 +32,45 @@ const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package // [start, end) type KeyRange struct { - Start []byte `protobuf:"bytes,1,opt,name=start,proto3" json:"start,omitempty"` - End []byte `protobuf:"bytes,2,opt,name=end,proto3" json:"end,omitempty"` + Start []byte `protobuf:"bytes,1,opt,name=start,proto3" json:"start,omitempty"` + End []byte `protobuf:"bytes,2,opt,name=end,proto3" json:"end,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +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_41d6509a8e4b8130, []int{0} +} +func (m *KeyRange) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *KeyRange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_KeyRange.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 *KeyRange) XXX_Merge(src proto.Message) { + xxx_messageInfo_KeyRange.Merge(dst, src) +} +func (m *KeyRange) XXX_Size() int { + return m.Size() +} +func (m *KeyRange) XXX_DiscardUnknown() { + xxx_messageInfo_KeyRange.DiscardUnknown(m) } -func (m *KeyRange) Reset() { *m = KeyRange{} } -func (m *KeyRange) String() string { return proto.CompactTextString(m) } -func (*KeyRange) ProtoMessage() {} -func (*KeyRange) Descriptor() ([]byte, []int) { return fileDescriptorCoprocessor, []int{0} } +var xxx_messageInfo_KeyRange proto.InternalMessageInfo func (m *KeyRange) GetStart() []byte { if m != nil { @@ -66,16 +87,47 @@ func (m *KeyRange) GetEnd() []byte { } type Request 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"` - Ranges []*KeyRange `protobuf:"bytes,4,rep,name=ranges" json:"ranges,omitempty"` + 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"` + Ranges []*KeyRange `protobuf:"bytes,4,rep,name=ranges" json:"ranges,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } -func (m *Request) Reset() { *m = Request{} } -func (m *Request) String() string { return proto.CompactTextString(m) } -func (*Request) ProtoMessage() {} -func (*Request) Descriptor() ([]byte, []int) { return fileDescriptorCoprocessor, []int{1} } +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_41d6509a8e4b8130, []int{1} +} +func (m *Request) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Request.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 *Request) XXX_Merge(src proto.Message) { + xxx_messageInfo_Request.Merge(dst, src) +} +func (m *Request) XXX_Size() int { + return m.Size() +} +func (m *Request) XXX_DiscardUnknown() { + xxx_messageInfo_Request.DiscardUnknown(m) +} + +var xxx_messageInfo_Request proto.InternalMessageInfo func (m *Request) GetContext() *kvrpcpb.Context { if m != nil { @@ -106,18 +158,49 @@ func (m *Request) GetRanges() []*KeyRange { } type Response struct { - Data github_com_pingcap_tipb_sharedbytes.SharedBytes `protobuf:"bytes,1,opt,name=data,proto3,customtype=github.com/pingcap/tipb/sharedbytes.SharedBytes" json:"data"` - RegionError *errorpb.Error `protobuf:"bytes,2,opt,name=region_error,json=regionError" json:"region_error,omitempty"` - Locked *kvrpcpb.LockInfo `protobuf:"bytes,3,opt,name=locked" json:"locked,omitempty"` - OtherError string `protobuf:"bytes,4,opt,name=other_error,json=otherError,proto3" json:"other_error,omitempty"` - Range *KeyRange `protobuf:"bytes,5,opt,name=range" json:"range,omitempty"` - ExecDetails *kvrpcpb.ExecDetails `protobuf:"bytes,6,opt,name=exec_details,json=execDetails" json:"exec_details,omitempty"` + Data github_com_pingcap_tipb_sharedbytes.SharedBytes `protobuf:"bytes,1,opt,name=data,proto3,customtype=github.com/pingcap/tipb/sharedbytes.SharedBytes" json:"data"` + RegionError *errorpb.Error `protobuf:"bytes,2,opt,name=region_error,json=regionError" json:"region_error,omitempty"` + Locked *kvrpcpb.LockInfo `protobuf:"bytes,3,opt,name=locked" json:"locked,omitempty"` + OtherError string `protobuf:"bytes,4,opt,name=other_error,json=otherError,proto3" json:"other_error,omitempty"` + Range *KeyRange `protobuf:"bytes,5,opt,name=range" json:"range,omitempty"` + ExecDetails *kvrpcpb.ExecDetails `protobuf:"bytes,6,opt,name=exec_details,json=execDetails" json:"exec_details,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +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_41d6509a8e4b8130, []int{2} +} +func (m *Response) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Response) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Response.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 *Response) XXX_Merge(src proto.Message) { + xxx_messageInfo_Response.Merge(dst, src) +} +func (m *Response) XXX_Size() int { + return m.Size() +} +func (m *Response) XXX_DiscardUnknown() { + xxx_messageInfo_Response.DiscardUnknown(m) } -func (m *Response) Reset() { *m = Response{} } -func (m *Response) String() string { return proto.CompactTextString(m) } -func (*Response) ProtoMessage() {} -func (*Response) Descriptor() ([]byte, []int) { return fileDescriptorCoprocessor, []int{2} } +var xxx_messageInfo_Response proto.InternalMessageInfo func (m *Response) GetRegionError() *errorpb.Error { if m != nil { @@ -186,6 +269,9 @@ func (m *KeyRange) MarshalTo(dAtA []byte) (int, error) { i = encodeVarintCoprocessor(dAtA, i, uint64(len(m.End))) i += copy(dAtA[i:], m.End) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -237,6 +323,9 @@ func (m *Request) MarshalTo(dAtA []byte) (int, error) { i += n } } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -309,27 +398,12 @@ func (m *Response) MarshalTo(dAtA []byte) (int, error) { } i += n6 } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } -func encodeFixed64Coprocessor(dAtA []byte, offset int, v uint64) int { - dAtA[offset] = uint8(v) - dAtA[offset+1] = uint8(v >> 8) - dAtA[offset+2] = uint8(v >> 16) - dAtA[offset+3] = uint8(v >> 24) - dAtA[offset+4] = uint8(v >> 32) - dAtA[offset+5] = uint8(v >> 40) - dAtA[offset+6] = uint8(v >> 48) - dAtA[offset+7] = uint8(v >> 56) - return offset + 8 -} -func encodeFixed32Coprocessor(dAtA []byte, offset int, v uint32) int { - dAtA[offset] = uint8(v) - dAtA[offset+1] = uint8(v >> 8) - dAtA[offset+2] = uint8(v >> 16) - dAtA[offset+3] = uint8(v >> 24) - return offset + 4 -} func encodeVarintCoprocessor(dAtA []byte, offset int, v uint64) int { for v >= 1<<7 { dAtA[offset] = uint8(v&0x7f | 0x80) @@ -350,6 +424,9 @@ func (m *KeyRange) Size() (n int) { if l > 0 { n += 1 + l + sovCoprocessor(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -373,6 +450,9 @@ func (m *Request) Size() (n int) { n += 1 + l + sovCoprocessor(uint64(l)) } } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -401,6 +481,9 @@ func (m *Response) Size() (n int) { l = m.ExecDetails.Size() n += 1 + l + sovCoprocessor(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -520,6 +603,7 @@ func (m *KeyRange) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -684,6 +768,7 @@ func (m *Request) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -925,6 +1010,7 @@ func (m *Response) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -1039,9 +1125,9 @@ var ( ErrIntOverflowCoprocessor = fmt.Errorf("proto: integer overflow") ) -func init() { proto.RegisterFile("coprocessor.proto", fileDescriptorCoprocessor) } +func init() { proto.RegisterFile("coprocessor.proto", fileDescriptor_coprocessor_41d6509a8e4b8130) } -var fileDescriptorCoprocessor = []byte{ +var fileDescriptor_coprocessor_41d6509a8e4b8130 = []byte{ // 424 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x52, 0x4b, 0x6e, 0xdb, 0x30, 0x14, 0x8c, 0xfc, 0x4b, 0x4a, 0x39, 0x41, 0x42, 0xb8, 0x80, 0x90, 0x85, 0x6d, 0x78, 0xe5, 0xa6, diff --git a/vendor/github.com/pingcap/kvproto/pkg/eraftpb/eraftpb.pb.go b/vendor/github.com/pingcap/kvproto/pkg/eraftpb/eraftpb.pb.go index 5d35067351034..bb4c5d04ee8ac 100644 --- a/vendor/github.com/pingcap/kvproto/pkg/eraftpb/eraftpb.pb.go +++ b/vendor/github.com/pingcap/kvproto/pkg/eraftpb/eraftpb.pb.go @@ -1,22 +1,6 @@ -// Code generated by protoc-gen-gogo. +// Code generated by protoc-gen-gogo. DO NOT EDIT. // source: eraftpb.proto -// DO NOT EDIT! - -/* - Package eraftpb is a generated protocol buffer package. - - It is generated from these files: - eraftpb.proto - - It has these top-level messages: - Entry - SnapshotMetadata - Snapshot - Message - HardState - ConfState - ConfChange -*/ + package eraftpb import ( @@ -57,7 +41,9 @@ var EntryType_value = map[string]int32{ func (x EntryType) String() string { return proto.EnumName(EntryType_name, int32(x)) } -func (EntryType) EnumDescriptor() ([]byte, []int) { return fileDescriptorEraftpb, []int{0} } +func (EntryType) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_eraftpb_ebbdfaa85573a86c, []int{0} +} type MessageType int32 @@ -129,7 +115,9 @@ var MessageType_value = map[string]int32{ func (x MessageType) String() string { return proto.EnumName(MessageType_name, int32(x)) } -func (MessageType) EnumDescriptor() ([]byte, []int) { return fileDescriptorEraftpb, []int{1} } +func (MessageType) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_eraftpb_ebbdfaa85573a86c, []int{1} +} type ConfChangeType int32 @@ -153,7 +141,9 @@ var ConfChangeType_value = map[string]int32{ func (x ConfChangeType) String() string { return proto.EnumName(ConfChangeType_name, int32(x)) } -func (ConfChangeType) EnumDescriptor() ([]byte, []int) { return fileDescriptorEraftpb, []int{2} } +func (ConfChangeType) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_eraftpb_ebbdfaa85573a86c, []int{2} +} type Entry struct { EntryType EntryType `protobuf:"varint,1,opt,name=entry_type,json=entryType,proto3,enum=eraftpb.EntryType" json:"entry_type,omitempty"` @@ -163,13 +153,44 @@ type Entry struct { Context []byte `protobuf:"bytes,6,opt,name=context,proto3" json:"context,omitempty"` // Deprecated! It is kept for backward compatibility. // TODO: remove it in the next major release. - SyncLog bool `protobuf:"varint,5,opt,name=sync_log,json=syncLog,proto3" json:"sync_log,omitempty"` + SyncLog bool `protobuf:"varint,5,opt,name=sync_log,json=syncLog,proto3" json:"sync_log,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *Entry) Reset() { *m = Entry{} } +func (m *Entry) String() string { return proto.CompactTextString(m) } +func (*Entry) ProtoMessage() {} +func (*Entry) Descriptor() ([]byte, []int) { + return fileDescriptor_eraftpb_ebbdfaa85573a86c, []int{0} +} +func (m *Entry) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Entry) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Entry.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 *Entry) XXX_Merge(src proto.Message) { + xxx_messageInfo_Entry.Merge(dst, src) +} +func (m *Entry) XXX_Size() int { + return m.Size() +} +func (m *Entry) XXX_DiscardUnknown() { + xxx_messageInfo_Entry.DiscardUnknown(m) } -func (m *Entry) Reset() { *m = Entry{} } -func (m *Entry) String() string { return proto.CompactTextString(m) } -func (*Entry) ProtoMessage() {} -func (*Entry) Descriptor() ([]byte, []int) { return fileDescriptorEraftpb, []int{0} } +var xxx_messageInfo_Entry proto.InternalMessageInfo func (m *Entry) GetEntryType() EntryType { if m != nil { @@ -214,15 +235,46 @@ func (m *Entry) GetSyncLog() bool { } type SnapshotMetadata struct { - ConfState *ConfState `protobuf:"bytes,1,opt,name=conf_state,json=confState" json:"conf_state,omitempty"` - Index uint64 `protobuf:"varint,2,opt,name=index,proto3" json:"index,omitempty"` - Term uint64 `protobuf:"varint,3,opt,name=term,proto3" json:"term,omitempty"` + ConfState *ConfState `protobuf:"bytes,1,opt,name=conf_state,json=confState" json:"conf_state,omitempty"` + Index uint64 `protobuf:"varint,2,opt,name=index,proto3" json:"index,omitempty"` + Term uint64 `protobuf:"varint,3,opt,name=term,proto3" json:"term,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *SnapshotMetadata) Reset() { *m = SnapshotMetadata{} } +func (m *SnapshotMetadata) String() string { return proto.CompactTextString(m) } +func (*SnapshotMetadata) ProtoMessage() {} +func (*SnapshotMetadata) Descriptor() ([]byte, []int) { + return fileDescriptor_eraftpb_ebbdfaa85573a86c, []int{1} +} +func (m *SnapshotMetadata) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SnapshotMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_SnapshotMetadata.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 *SnapshotMetadata) XXX_Merge(src proto.Message) { + xxx_messageInfo_SnapshotMetadata.Merge(dst, src) +} +func (m *SnapshotMetadata) XXX_Size() int { + return m.Size() +} +func (m *SnapshotMetadata) XXX_DiscardUnknown() { + xxx_messageInfo_SnapshotMetadata.DiscardUnknown(m) } -func (m *SnapshotMetadata) Reset() { *m = SnapshotMetadata{} } -func (m *SnapshotMetadata) String() string { return proto.CompactTextString(m) } -func (*SnapshotMetadata) ProtoMessage() {} -func (*SnapshotMetadata) Descriptor() ([]byte, []int) { return fileDescriptorEraftpb, []int{1} } +var xxx_messageInfo_SnapshotMetadata proto.InternalMessageInfo func (m *SnapshotMetadata) GetConfState() *ConfState { if m != nil { @@ -246,14 +298,45 @@ func (m *SnapshotMetadata) GetTerm() uint64 { } type Snapshot struct { - Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"` - Metadata *SnapshotMetadata `protobuf:"bytes,2,opt,name=metadata" json:"metadata,omitempty"` + Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"` + Metadata *SnapshotMetadata `protobuf:"bytes,2,opt,name=metadata" json:"metadata,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *Snapshot) Reset() { *m = Snapshot{} } +func (m *Snapshot) String() string { return proto.CompactTextString(m) } +func (*Snapshot) ProtoMessage() {} +func (*Snapshot) Descriptor() ([]byte, []int) { + return fileDescriptor_eraftpb_ebbdfaa85573a86c, []int{2} +} +func (m *Snapshot) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Snapshot) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Snapshot.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 *Snapshot) XXX_Merge(src proto.Message) { + xxx_messageInfo_Snapshot.Merge(dst, src) +} +func (m *Snapshot) XXX_Size() int { + return m.Size() +} +func (m *Snapshot) XXX_DiscardUnknown() { + xxx_messageInfo_Snapshot.DiscardUnknown(m) } -func (m *Snapshot) Reset() { *m = Snapshot{} } -func (m *Snapshot) String() string { return proto.CompactTextString(m) } -func (*Snapshot) ProtoMessage() {} -func (*Snapshot) Descriptor() ([]byte, []int) { return fileDescriptorEraftpb, []int{2} } +var xxx_messageInfo_Snapshot proto.InternalMessageInfo func (m *Snapshot) GetData() []byte { if m != nil { @@ -270,24 +353,55 @@ func (m *Snapshot) GetMetadata() *SnapshotMetadata { } type Message struct { - MsgType MessageType `protobuf:"varint,1,opt,name=msg_type,json=msgType,proto3,enum=eraftpb.MessageType" json:"msg_type,omitempty"` - To uint64 `protobuf:"varint,2,opt,name=to,proto3" json:"to,omitempty"` - From uint64 `protobuf:"varint,3,opt,name=from,proto3" json:"from,omitempty"` - Term uint64 `protobuf:"varint,4,opt,name=term,proto3" json:"term,omitempty"` - LogTerm uint64 `protobuf:"varint,5,opt,name=log_term,json=logTerm,proto3" json:"log_term,omitempty"` - Index uint64 `protobuf:"varint,6,opt,name=index,proto3" json:"index,omitempty"` - Entries []*Entry `protobuf:"bytes,7,rep,name=entries" json:"entries,omitempty"` - Commit uint64 `protobuf:"varint,8,opt,name=commit,proto3" json:"commit,omitempty"` - Snapshot *Snapshot `protobuf:"bytes,9,opt,name=snapshot" json:"snapshot,omitempty"` - Reject bool `protobuf:"varint,10,opt,name=reject,proto3" json:"reject,omitempty"` - RejectHint uint64 `protobuf:"varint,11,opt,name=reject_hint,json=rejectHint,proto3" json:"reject_hint,omitempty"` - Context []byte `protobuf:"bytes,12,opt,name=context,proto3" json:"context,omitempty"` -} - -func (m *Message) Reset() { *m = Message{} } -func (m *Message) String() string { return proto.CompactTextString(m) } -func (*Message) ProtoMessage() {} -func (*Message) Descriptor() ([]byte, []int) { return fileDescriptorEraftpb, []int{3} } + MsgType MessageType `protobuf:"varint,1,opt,name=msg_type,json=msgType,proto3,enum=eraftpb.MessageType" json:"msg_type,omitempty"` + To uint64 `protobuf:"varint,2,opt,name=to,proto3" json:"to,omitempty"` + From uint64 `protobuf:"varint,3,opt,name=from,proto3" json:"from,omitempty"` + Term uint64 `protobuf:"varint,4,opt,name=term,proto3" json:"term,omitempty"` + LogTerm uint64 `protobuf:"varint,5,opt,name=log_term,json=logTerm,proto3" json:"log_term,omitempty"` + Index uint64 `protobuf:"varint,6,opt,name=index,proto3" json:"index,omitempty"` + Entries []*Entry `protobuf:"bytes,7,rep,name=entries" json:"entries,omitempty"` + Commit uint64 `protobuf:"varint,8,opt,name=commit,proto3" json:"commit,omitempty"` + Snapshot *Snapshot `protobuf:"bytes,9,opt,name=snapshot" json:"snapshot,omitempty"` + Reject bool `protobuf:"varint,10,opt,name=reject,proto3" json:"reject,omitempty"` + RejectHint uint64 `protobuf:"varint,11,opt,name=reject_hint,json=rejectHint,proto3" json:"reject_hint,omitempty"` + Context []byte `protobuf:"bytes,12,opt,name=context,proto3" json:"context,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *Message) Reset() { *m = Message{} } +func (m *Message) String() string { return proto.CompactTextString(m) } +func (*Message) ProtoMessage() {} +func (*Message) Descriptor() ([]byte, []int) { + return fileDescriptor_eraftpb_ebbdfaa85573a86c, []int{3} +} +func (m *Message) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Message) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Message.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 *Message) XXX_Merge(src proto.Message) { + xxx_messageInfo_Message.Merge(dst, src) +} +func (m *Message) XXX_Size() int { + return m.Size() +} +func (m *Message) XXX_DiscardUnknown() { + xxx_messageInfo_Message.DiscardUnknown(m) +} + +var xxx_messageInfo_Message proto.InternalMessageInfo func (m *Message) GetMsgType() MessageType { if m != nil { @@ -374,15 +488,46 @@ func (m *Message) GetContext() []byte { } type HardState struct { - Term uint64 `protobuf:"varint,1,opt,name=term,proto3" json:"term,omitempty"` - Vote uint64 `protobuf:"varint,2,opt,name=vote,proto3" json:"vote,omitempty"` - Commit uint64 `protobuf:"varint,3,opt,name=commit,proto3" json:"commit,omitempty"` + Term uint64 `protobuf:"varint,1,opt,name=term,proto3" json:"term,omitempty"` + Vote uint64 `protobuf:"varint,2,opt,name=vote,proto3" json:"vote,omitempty"` + Commit uint64 `protobuf:"varint,3,opt,name=commit,proto3" json:"commit,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *HardState) Reset() { *m = HardState{} } +func (m *HardState) String() string { return proto.CompactTextString(m) } +func (*HardState) ProtoMessage() {} +func (*HardState) Descriptor() ([]byte, []int) { + return fileDescriptor_eraftpb_ebbdfaa85573a86c, []int{4} +} +func (m *HardState) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *HardState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_HardState.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 *HardState) XXX_Merge(src proto.Message) { + xxx_messageInfo_HardState.Merge(dst, src) +} +func (m *HardState) XXX_Size() int { + return m.Size() +} +func (m *HardState) XXX_DiscardUnknown() { + xxx_messageInfo_HardState.DiscardUnknown(m) } -func (m *HardState) Reset() { *m = HardState{} } -func (m *HardState) String() string { return proto.CompactTextString(m) } -func (*HardState) ProtoMessage() {} -func (*HardState) Descriptor() ([]byte, []int) { return fileDescriptorEraftpb, []int{4} } +var xxx_messageInfo_HardState proto.InternalMessageInfo func (m *HardState) GetTerm() uint64 { if m != nil { @@ -406,14 +551,45 @@ func (m *HardState) GetCommit() uint64 { } type ConfState struct { - Nodes []uint64 `protobuf:"varint,1,rep,packed,name=nodes" json:"nodes,omitempty"` - Learners []uint64 `protobuf:"varint,2,rep,packed,name=learners" json:"learners,omitempty"` + Nodes []uint64 `protobuf:"varint,1,rep,packed,name=nodes" json:"nodes,omitempty"` + Learners []uint64 `protobuf:"varint,2,rep,packed,name=learners" json:"learners,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ConfState) Reset() { *m = ConfState{} } +func (m *ConfState) String() string { return proto.CompactTextString(m) } +func (*ConfState) ProtoMessage() {} +func (*ConfState) Descriptor() ([]byte, []int) { + return fileDescriptor_eraftpb_ebbdfaa85573a86c, []int{5} +} +func (m *ConfState) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ConfState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ConfState.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 *ConfState) XXX_Merge(src proto.Message) { + xxx_messageInfo_ConfState.Merge(dst, src) +} +func (m *ConfState) XXX_Size() int { + return m.Size() +} +func (m *ConfState) XXX_DiscardUnknown() { + xxx_messageInfo_ConfState.DiscardUnknown(m) } -func (m *ConfState) Reset() { *m = ConfState{} } -func (m *ConfState) String() string { return proto.CompactTextString(m) } -func (*ConfState) ProtoMessage() {} -func (*ConfState) Descriptor() ([]byte, []int) { return fileDescriptorEraftpb, []int{5} } +var xxx_messageInfo_ConfState proto.InternalMessageInfo func (m *ConfState) GetNodes() []uint64 { if m != nil { @@ -430,16 +606,47 @@ func (m *ConfState) GetLearners() []uint64 { } type ConfChange struct { - Id uint64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` - ChangeType ConfChangeType `protobuf:"varint,2,opt,name=change_type,json=changeType,proto3,enum=eraftpb.ConfChangeType" json:"change_type,omitempty"` - NodeId uint64 `protobuf:"varint,3,opt,name=node_id,json=nodeId,proto3" json:"node_id,omitempty"` - Context []byte `protobuf:"bytes,4,opt,name=context,proto3" json:"context,omitempty"` + Id uint64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` + ChangeType ConfChangeType `protobuf:"varint,2,opt,name=change_type,json=changeType,proto3,enum=eraftpb.ConfChangeType" json:"change_type,omitempty"` + NodeId uint64 `protobuf:"varint,3,opt,name=node_id,json=nodeId,proto3" json:"node_id,omitempty"` + Context []byte `protobuf:"bytes,4,opt,name=context,proto3" json:"context,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ConfChange) Reset() { *m = ConfChange{} } +func (m *ConfChange) String() string { return proto.CompactTextString(m) } +func (*ConfChange) ProtoMessage() {} +func (*ConfChange) Descriptor() ([]byte, []int) { + return fileDescriptor_eraftpb_ebbdfaa85573a86c, []int{6} +} +func (m *ConfChange) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ConfChange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ConfChange.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 *ConfChange) XXX_Merge(src proto.Message) { + xxx_messageInfo_ConfChange.Merge(dst, src) +} +func (m *ConfChange) XXX_Size() int { + return m.Size() +} +func (m *ConfChange) XXX_DiscardUnknown() { + xxx_messageInfo_ConfChange.DiscardUnknown(m) } -func (m *ConfChange) Reset() { *m = ConfChange{} } -func (m *ConfChange) String() string { return proto.CompactTextString(m) } -func (*ConfChange) ProtoMessage() {} -func (*ConfChange) Descriptor() ([]byte, []int) { return fileDescriptorEraftpb, []int{6} } +var xxx_messageInfo_ConfChange proto.InternalMessageInfo func (m *ConfChange) GetId() uint64 { if m != nil { @@ -533,6 +740,9 @@ func (m *Entry) MarshalTo(dAtA []byte) (int, error) { i = encodeVarintEraftpb(dAtA, i, uint64(len(m.Context))) i += copy(dAtA[i:], m.Context) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -571,6 +781,9 @@ func (m *SnapshotMetadata) MarshalTo(dAtA []byte) (int, error) { i++ i = encodeVarintEraftpb(dAtA, i, uint64(m.Term)) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -605,6 +818,9 @@ func (m *Snapshot) MarshalTo(dAtA []byte) (int, error) { } i += n2 } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -701,6 +917,9 @@ func (m *Message) MarshalTo(dAtA []byte) (int, error) { i = encodeVarintEraftpb(dAtA, i, uint64(len(m.Context))) i += copy(dAtA[i:], m.Context) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -734,6 +953,9 @@ func (m *HardState) MarshalTo(dAtA []byte) (int, error) { i++ i = encodeVarintEraftpb(dAtA, i, uint64(m.Commit)) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -786,6 +1008,9 @@ func (m *ConfState) MarshalTo(dAtA []byte) (int, error) { i = encodeVarintEraftpb(dAtA, i, uint64(j6)) i += copy(dAtA[i:], dAtA7[:j6]) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -825,27 +1050,12 @@ func (m *ConfChange) MarshalTo(dAtA []byte) (int, error) { i = encodeVarintEraftpb(dAtA, i, uint64(len(m.Context))) i += copy(dAtA[i:], m.Context) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } -func encodeFixed64Eraftpb(dAtA []byte, offset int, v uint64) int { - dAtA[offset] = uint8(v) - dAtA[offset+1] = uint8(v >> 8) - dAtA[offset+2] = uint8(v >> 16) - dAtA[offset+3] = uint8(v >> 24) - dAtA[offset+4] = uint8(v >> 32) - dAtA[offset+5] = uint8(v >> 40) - dAtA[offset+6] = uint8(v >> 48) - dAtA[offset+7] = uint8(v >> 56) - return offset + 8 -} -func encodeFixed32Eraftpb(dAtA []byte, offset int, v uint32) int { - dAtA[offset] = uint8(v) - dAtA[offset+1] = uint8(v >> 8) - dAtA[offset+2] = uint8(v >> 16) - dAtA[offset+3] = uint8(v >> 24) - return offset + 4 -} func encodeVarintEraftpb(dAtA []byte, offset int, v uint64) int { for v >= 1<<7 { dAtA[offset] = uint8(v&0x7f | 0x80) @@ -878,6 +1088,9 @@ func (m *Entry) Size() (n int) { if l > 0 { n += 1 + l + sovEraftpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -894,6 +1107,9 @@ func (m *SnapshotMetadata) Size() (n int) { if m.Term != 0 { n += 1 + sovEraftpb(uint64(m.Term)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -908,6 +1124,9 @@ func (m *Snapshot) Size() (n int) { l = m.Metadata.Size() n += 1 + l + sovEraftpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -955,6 +1174,9 @@ func (m *Message) Size() (n int) { if l > 0 { n += 1 + l + sovEraftpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -970,6 +1192,9 @@ func (m *HardState) Size() (n int) { if m.Commit != 0 { n += 1 + sovEraftpb(uint64(m.Commit)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -990,6 +1215,9 @@ func (m *ConfState) Size() (n int) { } n += 1 + sovEraftpb(uint64(l)) + l } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -1009,6 +1237,9 @@ func (m *ConfChange) Size() (n int) { if l > 0 { n += 1 + l + sovEraftpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -1205,6 +1436,7 @@ func (m *Entry) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -1326,6 +1558,7 @@ func (m *SnapshotMetadata) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -1440,6 +1673,7 @@ func (m *Snapshot) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -1757,6 +1991,7 @@ func (m *Message) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -1864,6 +2099,7 @@ func (m *HardState) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -1903,7 +2139,24 @@ func (m *ConfState) Unmarshal(dAtA []byte) error { } switch fieldNum { case 1: - if wireType == 2 { + if wireType == 0 { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEraftpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Nodes = append(m.Nodes, v) + } else if wireType == 2 { var packedLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { @@ -1944,7 +2197,11 @@ func (m *ConfState) Unmarshal(dAtA []byte) error { } m.Nodes = append(m.Nodes, v) } - } else if wireType == 0 { + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Nodes", wireType) + } + case 2: + if wireType == 0 { var v uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { @@ -1960,12 +2217,8 @@ func (m *ConfState) Unmarshal(dAtA []byte) error { break } } - m.Nodes = append(m.Nodes, v) - } else { - return fmt.Errorf("proto: wrong wireType = %d for field Nodes", wireType) - } - case 2: - if wireType == 2 { + m.Learners = append(m.Learners, v) + } else if wireType == 2 { var packedLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { @@ -2006,23 +2259,6 @@ func (m *ConfState) Unmarshal(dAtA []byte) error { } m.Learners = append(m.Learners, v) } - } else if wireType == 0 { - var v uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowEraftpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - v |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - m.Learners = append(m.Learners, v) } else { return fmt.Errorf("proto: wrong wireType = %d for field Learners", wireType) } @@ -2038,6 +2274,7 @@ func (m *ConfState) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -2176,6 +2413,7 @@ func (m *ConfChange) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -2290,9 +2528,9 @@ var ( ErrIntOverflowEraftpb = fmt.Errorf("proto: integer overflow") ) -func init() { proto.RegisterFile("eraftpb.proto", fileDescriptorEraftpb) } +func init() { proto.RegisterFile("eraftpb.proto", fileDescriptor_eraftpb_ebbdfaa85573a86c) } -var fileDescriptorEraftpb = []byte{ +var fileDescriptor_eraftpb_ebbdfaa85573a86c = []byte{ // 821 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x64, 0x55, 0xcd, 0x6e, 0xe4, 0x44, 0x10, 0x8e, 0x3d, 0x3f, 0xf6, 0x94, 0x93, 0x49, 0xa7, 0x08, 0xbb, 0xce, 0x4a, 0x84, 0xd1, 0x9c, diff --git a/vendor/github.com/pingcap/kvproto/pkg/errorpb/errorpb.pb.go b/vendor/github.com/pingcap/kvproto/pkg/errorpb/errorpb.pb.go index 4e18d72fb9f74..f467dea39712b 100644 --- a/vendor/github.com/pingcap/kvproto/pkg/errorpb/errorpb.pb.go +++ b/vendor/github.com/pingcap/kvproto/pkg/errorpb/errorpb.pb.go @@ -1,24 +1,6 @@ -// Code generated by protoc-gen-gogo. +// Code generated by protoc-gen-gogo. DO NOT EDIT. // source: errorpb.proto -// DO NOT EDIT! - -/* - Package errorpb is a generated protocol buffer package. - - It is generated from these files: - errorpb.proto - - It has these top-level messages: - NotLeader - StoreNotMatch - RegionNotFound - KeyNotInRegion - StaleEpoch - ServerIsBusy - StaleCommand - RaftEntryTooLarge - Error -*/ + package errorpb import ( @@ -28,6 +10,8 @@ import ( proto "github.com/golang/protobuf/proto" + _ "github.com/gogo/protobuf/gogoproto" + metapb "github.com/pingcap/kvproto/pkg/metapb" ) @@ -43,14 +27,45 @@ var _ = math.Inf const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package type NotLeader struct { - RegionId uint64 `protobuf:"varint,1,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty"` - Leader *metapb.Peer `protobuf:"bytes,2,opt,name=leader" json:"leader,omitempty"` + RegionId uint64 `protobuf:"varint,1,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty"` + Leader *metapb.Peer `protobuf:"bytes,2,opt,name=leader" json:"leader,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *NotLeader) Reset() { *m = NotLeader{} } +func (m *NotLeader) String() string { return proto.CompactTextString(m) } +func (*NotLeader) ProtoMessage() {} +func (*NotLeader) Descriptor() ([]byte, []int) { + return fileDescriptor_errorpb_a319c927e4bfaf71, []int{0} +} +func (m *NotLeader) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *NotLeader) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_NotLeader.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 *NotLeader) XXX_Merge(src proto.Message) { + xxx_messageInfo_NotLeader.Merge(dst, src) +} +func (m *NotLeader) XXX_Size() int { + return m.Size() +} +func (m *NotLeader) XXX_DiscardUnknown() { + xxx_messageInfo_NotLeader.DiscardUnknown(m) } -func (m *NotLeader) Reset() { *m = NotLeader{} } -func (m *NotLeader) String() string { return proto.CompactTextString(m) } -func (*NotLeader) ProtoMessage() {} -func (*NotLeader) Descriptor() ([]byte, []int) { return fileDescriptorErrorpb, []int{0} } +var xxx_messageInfo_NotLeader proto.InternalMessageInfo func (m *NotLeader) GetRegionId() uint64 { if m != nil { @@ -67,21 +82,83 @@ func (m *NotLeader) GetLeader() *metapb.Peer { } type StoreNotMatch struct { + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *StoreNotMatch) Reset() { *m = StoreNotMatch{} } +func (m *StoreNotMatch) String() string { return proto.CompactTextString(m) } +func (*StoreNotMatch) ProtoMessage() {} +func (*StoreNotMatch) Descriptor() ([]byte, []int) { + return fileDescriptor_errorpb_a319c927e4bfaf71, []int{1} +} +func (m *StoreNotMatch) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *StoreNotMatch) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_StoreNotMatch.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 *StoreNotMatch) XXX_Merge(src proto.Message) { + xxx_messageInfo_StoreNotMatch.Merge(dst, src) +} +func (m *StoreNotMatch) XXX_Size() int { + return m.Size() +} +func (m *StoreNotMatch) XXX_DiscardUnknown() { + xxx_messageInfo_StoreNotMatch.DiscardUnknown(m) } -func (m *StoreNotMatch) Reset() { *m = StoreNotMatch{} } -func (m *StoreNotMatch) String() string { return proto.CompactTextString(m) } -func (*StoreNotMatch) ProtoMessage() {} -func (*StoreNotMatch) Descriptor() ([]byte, []int) { return fileDescriptorErrorpb, []int{1} } +var xxx_messageInfo_StoreNotMatch proto.InternalMessageInfo type RegionNotFound struct { - RegionId uint64 `protobuf:"varint,1,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty"` + RegionId uint64 `protobuf:"varint,1,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RegionNotFound) Reset() { *m = RegionNotFound{} } +func (m *RegionNotFound) String() string { return proto.CompactTextString(m) } +func (*RegionNotFound) ProtoMessage() {} +func (*RegionNotFound) Descriptor() ([]byte, []int) { + return fileDescriptor_errorpb_a319c927e4bfaf71, []int{2} +} +func (m *RegionNotFound) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RegionNotFound) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RegionNotFound.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 *RegionNotFound) XXX_Merge(src proto.Message) { + xxx_messageInfo_RegionNotFound.Merge(dst, src) +} +func (m *RegionNotFound) XXX_Size() int { + return m.Size() +} +func (m *RegionNotFound) XXX_DiscardUnknown() { + xxx_messageInfo_RegionNotFound.DiscardUnknown(m) } -func (m *RegionNotFound) Reset() { *m = RegionNotFound{} } -func (m *RegionNotFound) String() string { return proto.CompactTextString(m) } -func (*RegionNotFound) ProtoMessage() {} -func (*RegionNotFound) Descriptor() ([]byte, []int) { return fileDescriptorErrorpb, []int{2} } +var xxx_messageInfo_RegionNotFound proto.InternalMessageInfo func (m *RegionNotFound) GetRegionId() uint64 { if m != nil { @@ -91,16 +168,47 @@ func (m *RegionNotFound) GetRegionId() uint64 { } type KeyNotInRegion struct { - Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` - RegionId uint64 `protobuf:"varint,2,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty"` - StartKey []byte `protobuf:"bytes,3,opt,name=start_key,json=startKey,proto3" json:"start_key,omitempty"` - EndKey []byte `protobuf:"bytes,4,opt,name=end_key,json=endKey,proto3" json:"end_key,omitempty"` + Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + RegionId uint64 `protobuf:"varint,2,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty"` + StartKey []byte `protobuf:"bytes,3,opt,name=start_key,json=startKey,proto3" json:"start_key,omitempty"` + EndKey []byte `protobuf:"bytes,4,opt,name=end_key,json=endKey,proto3" json:"end_key,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *KeyNotInRegion) Reset() { *m = KeyNotInRegion{} } +func (m *KeyNotInRegion) String() string { return proto.CompactTextString(m) } +func (*KeyNotInRegion) ProtoMessage() {} +func (*KeyNotInRegion) Descriptor() ([]byte, []int) { + return fileDescriptor_errorpb_a319c927e4bfaf71, []int{3} +} +func (m *KeyNotInRegion) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *KeyNotInRegion) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_KeyNotInRegion.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 *KeyNotInRegion) XXX_Merge(src proto.Message) { + xxx_messageInfo_KeyNotInRegion.Merge(dst, src) +} +func (m *KeyNotInRegion) XXX_Size() int { + return m.Size() +} +func (m *KeyNotInRegion) XXX_DiscardUnknown() { + xxx_messageInfo_KeyNotInRegion.DiscardUnknown(m) } -func (m *KeyNotInRegion) Reset() { *m = KeyNotInRegion{} } -func (m *KeyNotInRegion) String() string { return proto.CompactTextString(m) } -func (*KeyNotInRegion) ProtoMessage() {} -func (*KeyNotInRegion) Descriptor() ([]byte, []int) { return fileDescriptorErrorpb, []int{3} } +var xxx_messageInfo_KeyNotInRegion proto.InternalMessageInfo func (m *KeyNotInRegion) GetKey() []byte { if m != nil { @@ -131,13 +239,44 @@ func (m *KeyNotInRegion) GetEndKey() []byte { } type StaleEpoch struct { - NewRegions []*metapb.Region `protobuf:"bytes,1,rep,name=new_regions,json=newRegions" json:"new_regions,omitempty"` + NewRegions []*metapb.Region `protobuf:"bytes,1,rep,name=new_regions,json=newRegions" json:"new_regions,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *StaleEpoch) Reset() { *m = StaleEpoch{} } +func (m *StaleEpoch) String() string { return proto.CompactTextString(m) } +func (*StaleEpoch) ProtoMessage() {} +func (*StaleEpoch) Descriptor() ([]byte, []int) { + return fileDescriptor_errorpb_a319c927e4bfaf71, []int{4} +} +func (m *StaleEpoch) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *StaleEpoch) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_StaleEpoch.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 *StaleEpoch) XXX_Merge(src proto.Message) { + xxx_messageInfo_StaleEpoch.Merge(dst, src) +} +func (m *StaleEpoch) XXX_Size() int { + return m.Size() +} +func (m *StaleEpoch) XXX_DiscardUnknown() { + xxx_messageInfo_StaleEpoch.DiscardUnknown(m) } -func (m *StaleEpoch) Reset() { *m = StaleEpoch{} } -func (m *StaleEpoch) String() string { return proto.CompactTextString(m) } -func (*StaleEpoch) ProtoMessage() {} -func (*StaleEpoch) Descriptor() ([]byte, []int) { return fileDescriptorErrorpb, []int{4} } +var xxx_messageInfo_StaleEpoch proto.InternalMessageInfo func (m *StaleEpoch) GetNewRegions() []*metapb.Region { if m != nil { @@ -147,14 +286,45 @@ func (m *StaleEpoch) GetNewRegions() []*metapb.Region { } type ServerIsBusy struct { - Reason string `protobuf:"bytes,1,opt,name=reason,proto3" json:"reason,omitempty"` - BackoffMs uint64 `protobuf:"varint,2,opt,name=backoff_ms,json=backoffMs,proto3" json:"backoff_ms,omitempty"` + Reason string `protobuf:"bytes,1,opt,name=reason,proto3" json:"reason,omitempty"` + BackoffMs uint64 `protobuf:"varint,2,opt,name=backoff_ms,json=backoffMs,proto3" json:"backoff_ms,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ServerIsBusy) Reset() { *m = ServerIsBusy{} } +func (m *ServerIsBusy) String() string { return proto.CompactTextString(m) } +func (*ServerIsBusy) ProtoMessage() {} +func (*ServerIsBusy) Descriptor() ([]byte, []int) { + return fileDescriptor_errorpb_a319c927e4bfaf71, []int{5} +} +func (m *ServerIsBusy) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ServerIsBusy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ServerIsBusy.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 *ServerIsBusy) XXX_Merge(src proto.Message) { + xxx_messageInfo_ServerIsBusy.Merge(dst, src) +} +func (m *ServerIsBusy) XXX_Size() int { + return m.Size() +} +func (m *ServerIsBusy) XXX_DiscardUnknown() { + xxx_messageInfo_ServerIsBusy.DiscardUnknown(m) } -func (m *ServerIsBusy) Reset() { *m = ServerIsBusy{} } -func (m *ServerIsBusy) String() string { return proto.CompactTextString(m) } -func (*ServerIsBusy) ProtoMessage() {} -func (*ServerIsBusy) Descriptor() ([]byte, []int) { return fileDescriptorErrorpb, []int{5} } +var xxx_messageInfo_ServerIsBusy proto.InternalMessageInfo func (m *ServerIsBusy) GetReason() string { if m != nil { @@ -171,22 +341,84 @@ func (m *ServerIsBusy) GetBackoffMs() uint64 { } type StaleCommand struct { + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *StaleCommand) Reset() { *m = StaleCommand{} } +func (m *StaleCommand) String() string { return proto.CompactTextString(m) } +func (*StaleCommand) ProtoMessage() {} +func (*StaleCommand) Descriptor() ([]byte, []int) { + return fileDescriptor_errorpb_a319c927e4bfaf71, []int{6} +} +func (m *StaleCommand) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *StaleCommand) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_StaleCommand.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 *StaleCommand) XXX_Merge(src proto.Message) { + xxx_messageInfo_StaleCommand.Merge(dst, src) +} +func (m *StaleCommand) XXX_Size() int { + return m.Size() +} +func (m *StaleCommand) XXX_DiscardUnknown() { + xxx_messageInfo_StaleCommand.DiscardUnknown(m) } -func (m *StaleCommand) Reset() { *m = StaleCommand{} } -func (m *StaleCommand) String() string { return proto.CompactTextString(m) } -func (*StaleCommand) ProtoMessage() {} -func (*StaleCommand) Descriptor() ([]byte, []int) { return fileDescriptorErrorpb, []int{6} } +var xxx_messageInfo_StaleCommand proto.InternalMessageInfo type RaftEntryTooLarge struct { - RegionId uint64 `protobuf:"varint,1,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty"` - EntrySize uint64 `protobuf:"varint,2,opt,name=entry_size,json=entrySize,proto3" json:"entry_size,omitempty"` + RegionId uint64 `protobuf:"varint,1,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty"` + EntrySize uint64 `protobuf:"varint,2,opt,name=entry_size,json=entrySize,proto3" json:"entry_size,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RaftEntryTooLarge) Reset() { *m = RaftEntryTooLarge{} } +func (m *RaftEntryTooLarge) String() string { return proto.CompactTextString(m) } +func (*RaftEntryTooLarge) ProtoMessage() {} +func (*RaftEntryTooLarge) Descriptor() ([]byte, []int) { + return fileDescriptor_errorpb_a319c927e4bfaf71, []int{7} +} +func (m *RaftEntryTooLarge) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RaftEntryTooLarge) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RaftEntryTooLarge.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 *RaftEntryTooLarge) XXX_Merge(src proto.Message) { + xxx_messageInfo_RaftEntryTooLarge.Merge(dst, src) +} +func (m *RaftEntryTooLarge) XXX_Size() int { + return m.Size() +} +func (m *RaftEntryTooLarge) XXX_DiscardUnknown() { + xxx_messageInfo_RaftEntryTooLarge.DiscardUnknown(m) } -func (m *RaftEntryTooLarge) Reset() { *m = RaftEntryTooLarge{} } -func (m *RaftEntryTooLarge) String() string { return proto.CompactTextString(m) } -func (*RaftEntryTooLarge) ProtoMessage() {} -func (*RaftEntryTooLarge) Descriptor() ([]byte, []int) { return fileDescriptorErrorpb, []int{7} } +var xxx_messageInfo_RaftEntryTooLarge proto.InternalMessageInfo func (m *RaftEntryTooLarge) GetRegionId() uint64 { if m != nil { @@ -203,21 +435,52 @@ func (m *RaftEntryTooLarge) GetEntrySize() uint64 { } type Error struct { - Message string `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"` - NotLeader *NotLeader `protobuf:"bytes,2,opt,name=not_leader,json=notLeader" json:"not_leader,omitempty"` - RegionNotFound *RegionNotFound `protobuf:"bytes,3,opt,name=region_not_found,json=regionNotFound" json:"region_not_found,omitempty"` - KeyNotInRegion *KeyNotInRegion `protobuf:"bytes,4,opt,name=key_not_in_region,json=keyNotInRegion" json:"key_not_in_region,omitempty"` - StaleEpoch *StaleEpoch `protobuf:"bytes,5,opt,name=stale_epoch,json=staleEpoch" json:"stale_epoch,omitempty"` - ServerIsBusy *ServerIsBusy `protobuf:"bytes,6,opt,name=server_is_busy,json=serverIsBusy" json:"server_is_busy,omitempty"` - StaleCommand *StaleCommand `protobuf:"bytes,7,opt,name=stale_command,json=staleCommand" json:"stale_command,omitempty"` - StoreNotMatch *StoreNotMatch `protobuf:"bytes,8,opt,name=store_not_match,json=storeNotMatch" json:"store_not_match,omitempty"` - RaftEntryTooLarge *RaftEntryTooLarge `protobuf:"bytes,9,opt,name=raft_entry_too_large,json=raftEntryTooLarge" json:"raft_entry_too_large,omitempty"` -} - -func (m *Error) Reset() { *m = Error{} } -func (m *Error) String() string { return proto.CompactTextString(m) } -func (*Error) ProtoMessage() {} -func (*Error) Descriptor() ([]byte, []int) { return fileDescriptorErrorpb, []int{8} } + Message string `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"` + NotLeader *NotLeader `protobuf:"bytes,2,opt,name=not_leader,json=notLeader" json:"not_leader,omitempty"` + RegionNotFound *RegionNotFound `protobuf:"bytes,3,opt,name=region_not_found,json=regionNotFound" json:"region_not_found,omitempty"` + KeyNotInRegion *KeyNotInRegion `protobuf:"bytes,4,opt,name=key_not_in_region,json=keyNotInRegion" json:"key_not_in_region,omitempty"` + StaleEpoch *StaleEpoch `protobuf:"bytes,5,opt,name=stale_epoch,json=staleEpoch" json:"stale_epoch,omitempty"` + ServerIsBusy *ServerIsBusy `protobuf:"bytes,6,opt,name=server_is_busy,json=serverIsBusy" json:"server_is_busy,omitempty"` + StaleCommand *StaleCommand `protobuf:"bytes,7,opt,name=stale_command,json=staleCommand" json:"stale_command,omitempty"` + StoreNotMatch *StoreNotMatch `protobuf:"bytes,8,opt,name=store_not_match,json=storeNotMatch" json:"store_not_match,omitempty"` + RaftEntryTooLarge *RaftEntryTooLarge `protobuf:"bytes,9,opt,name=raft_entry_too_large,json=raftEntryTooLarge" json:"raft_entry_too_large,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +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_errorpb_a319c927e4bfaf71, []int{8} +} +func (m *Error) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Error) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Error.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 *Error) XXX_Merge(src proto.Message) { + xxx_messageInfo_Error.Merge(dst, src) +} +func (m *Error) XXX_Size() int { + return m.Size() +} +func (m *Error) XXX_DiscardUnknown() { + xxx_messageInfo_Error.DiscardUnknown(m) +} + +var xxx_messageInfo_Error proto.InternalMessageInfo func (m *Error) GetMessage() string { if m != nil { @@ -323,6 +586,9 @@ func (m *NotLeader) MarshalTo(dAtA []byte) (int, error) { } i += n1 } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -341,6 +607,9 @@ func (m *StoreNotMatch) MarshalTo(dAtA []byte) (int, error) { _ = i var l int _ = l + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -364,6 +633,9 @@ func (m *RegionNotFound) MarshalTo(dAtA []byte) (int, error) { i++ i = encodeVarintErrorpb(dAtA, i, uint64(m.RegionId)) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -405,6 +677,9 @@ func (m *KeyNotInRegion) MarshalTo(dAtA []byte) (int, error) { i = encodeVarintErrorpb(dAtA, i, uint64(len(m.EndKey))) i += copy(dAtA[i:], m.EndKey) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -435,6 +710,9 @@ func (m *StaleEpoch) MarshalTo(dAtA []byte) (int, error) { i += n } } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -464,6 +742,9 @@ func (m *ServerIsBusy) MarshalTo(dAtA []byte) (int, error) { i++ i = encodeVarintErrorpb(dAtA, i, uint64(m.BackoffMs)) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -482,6 +763,9 @@ func (m *StaleCommand) MarshalTo(dAtA []byte) (int, error) { _ = i var l int _ = l + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -510,6 +794,9 @@ func (m *RaftEntryTooLarge) MarshalTo(dAtA []byte) (int, error) { i++ i = encodeVarintErrorpb(dAtA, i, uint64(m.EntrySize)) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -614,27 +901,12 @@ func (m *Error) MarshalTo(dAtA []byte) (int, error) { } i += n9 } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } -func encodeFixed64Errorpb(dAtA []byte, offset int, v uint64) int { - dAtA[offset] = uint8(v) - dAtA[offset+1] = uint8(v >> 8) - dAtA[offset+2] = uint8(v >> 16) - dAtA[offset+3] = uint8(v >> 24) - dAtA[offset+4] = uint8(v >> 32) - dAtA[offset+5] = uint8(v >> 40) - dAtA[offset+6] = uint8(v >> 48) - dAtA[offset+7] = uint8(v >> 56) - return offset + 8 -} -func encodeFixed32Errorpb(dAtA []byte, offset int, v uint32) int { - dAtA[offset] = uint8(v) - dAtA[offset+1] = uint8(v >> 8) - dAtA[offset+2] = uint8(v >> 16) - dAtA[offset+3] = uint8(v >> 24) - return offset + 4 -} func encodeVarintErrorpb(dAtA []byte, offset int, v uint64) int { for v >= 1<<7 { dAtA[offset] = uint8(v&0x7f | 0x80) @@ -654,12 +926,18 @@ func (m *NotLeader) Size() (n int) { l = m.Leader.Size() n += 1 + l + sovErrorpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } func (m *StoreNotMatch) Size() (n int) { var l int _ = l + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -669,6 +947,9 @@ func (m *RegionNotFound) Size() (n int) { if m.RegionId != 0 { n += 1 + sovErrorpb(uint64(m.RegionId)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -690,6 +971,9 @@ func (m *KeyNotInRegion) Size() (n int) { if l > 0 { n += 1 + l + sovErrorpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -702,6 +986,9 @@ func (m *StaleEpoch) Size() (n int) { n += 1 + l + sovErrorpb(uint64(l)) } } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -715,12 +1002,18 @@ func (m *ServerIsBusy) Size() (n int) { if m.BackoffMs != 0 { n += 1 + sovErrorpb(uint64(m.BackoffMs)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } func (m *StaleCommand) Size() (n int) { var l int _ = l + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -733,6 +1026,9 @@ func (m *RaftEntryTooLarge) Size() (n int) { if m.EntrySize != 0 { n += 1 + sovErrorpb(uint64(m.EntrySize)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -775,6 +1071,9 @@ func (m *Error) Size() (n int) { l = m.RaftEntryTooLarge.Size() n += 1 + l + sovErrorpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -884,6 +1183,7 @@ func (m *NotLeader) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -934,6 +1234,7 @@ func (m *StoreNotMatch) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -1003,6 +1304,7 @@ func (m *RegionNotFound) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -1165,6 +1467,7 @@ func (m *KeyNotInRegion) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -1246,6 +1549,7 @@ func (m *StaleEpoch) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -1344,6 +1648,7 @@ func (m *ServerIsBusy) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -1394,6 +1699,7 @@ func (m *StaleCommand) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -1482,6 +1788,7 @@ func (m *RaftEntryTooLarge) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -1825,6 +2132,7 @@ func (m *Error) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -1939,9 +2247,9 @@ var ( ErrIntOverflowErrorpb = fmt.Errorf("proto: integer overflow") ) -func init() { proto.RegisterFile("errorpb.proto", fileDescriptorErrorpb) } +func init() { proto.RegisterFile("errorpb.proto", fileDescriptor_errorpb_a319c927e4bfaf71) } -var fileDescriptorErrorpb = []byte{ +var fileDescriptor_errorpb_a319c927e4bfaf71 = []byte{ // 604 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x54, 0xdd, 0x6e, 0xd3, 0x30, 0x14, 0x26, 0xfb, 0x69, 0x97, 0xd3, 0x34, 0xdb, 0xcc, 0xd8, 0xa2, 0x4d, 0xab, 0xa6, 0x88, 0x8b, diff --git a/vendor/github.com/pingcap/kvproto/pkg/kvrpcpb/kvrpcpb.pb.go b/vendor/github.com/pingcap/kvproto/pkg/kvrpcpb/kvrpcpb.pb.go index 5b221822b95f9..87a37967693e4 100644 --- a/vendor/github.com/pingcap/kvproto/pkg/kvrpcpb/kvrpcpb.pb.go +++ b/vendor/github.com/pingcap/kvproto/pkg/kvrpcpb/kvrpcpb.pb.go @@ -1,81 +1,6 @@ -// Code generated by protoc-gen-gogo. +// Code generated by protoc-gen-gogo. DO NOT EDIT. // source: kvrpcpb.proto -// DO NOT EDIT! - -/* - Package kvrpcpb is a generated protocol buffer package. - - It is generated from these files: - kvrpcpb.proto - - It has these top-level messages: - LockInfo - KeyError - WriteConflict - Context - HandleTime - ScanInfo - ScanDetail - ExecDetails - GetRequest - GetResponse - ScanRequest - KvPair - ScanResponse - Mutation - PrewriteRequest - PrewriteResponse - CommitRequest - CommitResponse - ImportRequest - ImportResponse - BatchRollbackRequest - BatchRollbackResponse - CleanupRequest - CleanupResponse - BatchGetRequest - BatchGetResponse - ScanLockRequest - ScanLockResponse - TxnInfo - ResolveLockRequest - ResolveLockResponse - GCRequest - GCResponse - RawGetRequest - RawGetResponse - RawPutRequest - RawPutResponse - RawBatchPutRequest - RawBatchPutResponse - RawBatchGetRequest - RawBatchGetResponse - RawDeleteRequest - RawDeleteResponse - RawBatchDeleteRequest - RawBatchDeleteResponse - DeleteRangeRequest - DeleteRangeResponse - RawDeleteRangeRequest - RawDeleteRangeResponse - RawScanRequest - RawScanResponse - KeyRange - RawBatchScanRequest - RawBatchScanResponse - MvccWrite - MvccValue - MvccLock - MvccInfo - MvccGetByKeyRequest - MvccGetByKeyResponse - MvccGetByStartTsRequest - MvccGetByStartTsResponse - SplitRegionRequest - SplitRegionResponse - UnsafeDestroyRangeRequest - UnsafeDestroyRangeResponse -*/ + package kvrpcpb import ( @@ -85,9 +10,11 @@ import ( proto "github.com/golang/protobuf/proto" - metapb "github.com/pingcap/kvproto/pkg/metapb" + _ "github.com/gogo/protobuf/gogoproto" errorpb "github.com/pingcap/kvproto/pkg/errorpb" + + metapb "github.com/pingcap/kvproto/pkg/metapb" ) // Reference imports to suppress errors if they are not otherwise used. @@ -123,7 +50,9 @@ var CommandPri_value = map[string]int32{ func (x CommandPri) String() string { return proto.EnumName(CommandPri_name, int32(x)) } -func (CommandPri) EnumDescriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{0} } +func (CommandPri) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{0} +} type IsolationLevel int32 @@ -144,7 +73,9 @@ var IsolationLevel_value = map[string]int32{ func (x IsolationLevel) String() string { return proto.EnumName(IsolationLevel_name, int32(x)) } -func (IsolationLevel) EnumDescriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{1} } +func (IsolationLevel) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{1} +} type Op int32 @@ -171,19 +102,52 @@ var Op_value = map[string]int32{ func (x Op) String() string { return proto.EnumName(Op_name, int32(x)) } -func (Op) EnumDescriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{2} } +func (Op) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{2} +} type LockInfo struct { - PrimaryLock []byte `protobuf:"bytes,1,opt,name=primary_lock,json=primaryLock,proto3" json:"primary_lock,omitempty"` - LockVersion uint64 `protobuf:"varint,2,opt,name=lock_version,json=lockVersion,proto3" json:"lock_version,omitempty"` - Key []byte `protobuf:"bytes,3,opt,name=key,proto3" json:"key,omitempty"` - LockTtl uint64 `protobuf:"varint,4,opt,name=lock_ttl,json=lockTtl,proto3" json:"lock_ttl,omitempty"` + PrimaryLock []byte `protobuf:"bytes,1,opt,name=primary_lock,json=primaryLock,proto3" json:"primary_lock,omitempty"` + LockVersion uint64 `protobuf:"varint,2,opt,name=lock_version,json=lockVersion,proto3" json:"lock_version,omitempty"` + Key []byte `protobuf:"bytes,3,opt,name=key,proto3" json:"key,omitempty"` + LockTtl uint64 `protobuf:"varint,4,opt,name=lock_ttl,json=lockTtl,proto3" json:"lock_ttl,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *LockInfo) Reset() { *m = LockInfo{} } +func (m *LockInfo) String() string { return proto.CompactTextString(m) } +func (*LockInfo) ProtoMessage() {} +func (*LockInfo) Descriptor() ([]byte, []int) { + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{0} +} +func (m *LockInfo) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *LockInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_LockInfo.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 *LockInfo) XXX_Merge(src proto.Message) { + xxx_messageInfo_LockInfo.Merge(dst, src) +} +func (m *LockInfo) XXX_Size() int { + return m.Size() +} +func (m *LockInfo) XXX_DiscardUnknown() { + xxx_messageInfo_LockInfo.DiscardUnknown(m) } -func (m *LockInfo) Reset() { *m = LockInfo{} } -func (m *LockInfo) String() string { return proto.CompactTextString(m) } -func (*LockInfo) ProtoMessage() {} -func (*LockInfo) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{0} } +var xxx_messageInfo_LockInfo proto.InternalMessageInfo func (m *LockInfo) GetPrimaryLock() []byte { if m != nil { @@ -214,16 +178,47 @@ func (m *LockInfo) GetLockTtl() uint64 { } type KeyError struct { - Locked *LockInfo `protobuf:"bytes,1,opt,name=locked" json:"locked,omitempty"` - Retryable string `protobuf:"bytes,2,opt,name=retryable,proto3" json:"retryable,omitempty"` - Abort string `protobuf:"bytes,3,opt,name=abort,proto3" json:"abort,omitempty"` - Conflict *WriteConflict `protobuf:"bytes,4,opt,name=conflict" json:"conflict,omitempty"` + Locked *LockInfo `protobuf:"bytes,1,opt,name=locked" json:"locked,omitempty"` + Retryable string `protobuf:"bytes,2,opt,name=retryable,proto3" json:"retryable,omitempty"` + Abort string `protobuf:"bytes,3,opt,name=abort,proto3" json:"abort,omitempty"` + Conflict *WriteConflict `protobuf:"bytes,4,opt,name=conflict" json:"conflict,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *KeyError) Reset() { *m = KeyError{} } +func (m *KeyError) String() string { return proto.CompactTextString(m) } +func (*KeyError) ProtoMessage() {} +func (*KeyError) Descriptor() ([]byte, []int) { + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{1} +} +func (m *KeyError) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *KeyError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_KeyError.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 *KeyError) XXX_Merge(src proto.Message) { + xxx_messageInfo_KeyError.Merge(dst, src) +} +func (m *KeyError) XXX_Size() int { + return m.Size() +} +func (m *KeyError) XXX_DiscardUnknown() { + xxx_messageInfo_KeyError.DiscardUnknown(m) } -func (m *KeyError) Reset() { *m = KeyError{} } -func (m *KeyError) String() string { return proto.CompactTextString(m) } -func (*KeyError) ProtoMessage() {} -func (*KeyError) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{1} } +var xxx_messageInfo_KeyError proto.InternalMessageInfo func (m *KeyError) GetLocked() *LockInfo { if m != nil { @@ -254,16 +249,47 @@ func (m *KeyError) GetConflict() *WriteConflict { } type WriteConflict struct { - StartTs uint64 `protobuf:"varint,1,opt,name=start_ts,json=startTs,proto3" json:"start_ts,omitempty"` - ConflictTs uint64 `protobuf:"varint,2,opt,name=conflict_ts,json=conflictTs,proto3" json:"conflict_ts,omitempty"` - Key []byte `protobuf:"bytes,3,opt,name=key,proto3" json:"key,omitempty"` - Primary []byte `protobuf:"bytes,4,opt,name=primary,proto3" json:"primary,omitempty"` + StartTs uint64 `protobuf:"varint,1,opt,name=start_ts,json=startTs,proto3" json:"start_ts,omitempty"` + ConflictTs uint64 `protobuf:"varint,2,opt,name=conflict_ts,json=conflictTs,proto3" json:"conflict_ts,omitempty"` + Key []byte `protobuf:"bytes,3,opt,name=key,proto3" json:"key,omitempty"` + Primary []byte `protobuf:"bytes,4,opt,name=primary,proto3" json:"primary,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *WriteConflict) Reset() { *m = WriteConflict{} } +func (m *WriteConflict) String() string { return proto.CompactTextString(m) } +func (*WriteConflict) ProtoMessage() {} +func (*WriteConflict) Descriptor() ([]byte, []int) { + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{2} +} +func (m *WriteConflict) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *WriteConflict) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_WriteConflict.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 *WriteConflict) XXX_Merge(src proto.Message) { + xxx_messageInfo_WriteConflict.Merge(dst, src) +} +func (m *WriteConflict) XXX_Size() int { + return m.Size() +} +func (m *WriteConflict) XXX_DiscardUnknown() { + xxx_messageInfo_WriteConflict.DiscardUnknown(m) } -func (m *WriteConflict) Reset() { *m = WriteConflict{} } -func (m *WriteConflict) String() string { return proto.CompactTextString(m) } -func (*WriteConflict) ProtoMessage() {} -func (*WriteConflict) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{2} } +var xxx_messageInfo_WriteConflict proto.InternalMessageInfo func (m *WriteConflict) GetStartTs() uint64 { if m != nil { @@ -294,22 +320,53 @@ func (m *WriteConflict) GetPrimary() []byte { } type Context 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"` - Peer *metapb.Peer `protobuf:"bytes,3,opt,name=peer" json:"peer,omitempty"` - Term uint64 `protobuf:"varint,5,opt,name=term,proto3" json:"term,omitempty"` - Priority CommandPri `protobuf:"varint,6,opt,name=priority,proto3,enum=kvrpcpb.CommandPri" json:"priority,omitempty"` - IsolationLevel IsolationLevel `protobuf:"varint,7,opt,name=isolation_level,json=isolationLevel,proto3,enum=kvrpcpb.IsolationLevel" json:"isolation_level,omitempty"` - NotFillCache bool `protobuf:"varint,8,opt,name=not_fill_cache,json=notFillCache,proto3" json:"not_fill_cache,omitempty"` - SyncLog bool `protobuf:"varint,9,opt,name=sync_log,json=syncLog,proto3" json:"sync_log,omitempty"` - HandleTime bool `protobuf:"varint,10,opt,name=handle_time,json=handleTime,proto3" json:"handle_time,omitempty"` - ScanDetail bool `protobuf:"varint,11,opt,name=scan_detail,json=scanDetail,proto3" json:"scan_detail,omitempty"` -} - -func (m *Context) Reset() { *m = Context{} } -func (m *Context) String() string { return proto.CompactTextString(m) } -func (*Context) ProtoMessage() {} -func (*Context) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{3} } + 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"` + Peer *metapb.Peer `protobuf:"bytes,3,opt,name=peer" json:"peer,omitempty"` + Term uint64 `protobuf:"varint,5,opt,name=term,proto3" json:"term,omitempty"` + Priority CommandPri `protobuf:"varint,6,opt,name=priority,proto3,enum=kvrpcpb.CommandPri" json:"priority,omitempty"` + IsolationLevel IsolationLevel `protobuf:"varint,7,opt,name=isolation_level,json=isolationLevel,proto3,enum=kvrpcpb.IsolationLevel" json:"isolation_level,omitempty"` + NotFillCache bool `protobuf:"varint,8,opt,name=not_fill_cache,json=notFillCache,proto3" json:"not_fill_cache,omitempty"` + SyncLog bool `protobuf:"varint,9,opt,name=sync_log,json=syncLog,proto3" json:"sync_log,omitempty"` + HandleTime bool `protobuf:"varint,10,opt,name=handle_time,json=handleTime,proto3" json:"handle_time,omitempty"` + ScanDetail bool `protobuf:"varint,11,opt,name=scan_detail,json=scanDetail,proto3" json:"scan_detail,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *Context) Reset() { *m = Context{} } +func (m *Context) String() string { return proto.CompactTextString(m) } +func (*Context) ProtoMessage() {} +func (*Context) Descriptor() ([]byte, []int) { + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{3} +} +func (m *Context) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Context) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Context.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 *Context) XXX_Merge(src proto.Message) { + xxx_messageInfo_Context.Merge(dst, src) +} +func (m *Context) XXX_Size() int { + return m.Size() +} +func (m *Context) XXX_DiscardUnknown() { + xxx_messageInfo_Context.DiscardUnknown(m) +} + +var xxx_messageInfo_Context proto.InternalMessageInfo func (m *Context) GetRegionId() uint64 { if m != nil { @@ -382,14 +439,45 @@ func (m *Context) GetScanDetail() bool { } type HandleTime struct { - WaitMs int64 `protobuf:"varint,1,opt,name=wait_ms,json=waitMs,proto3" json:"wait_ms,omitempty"` - ProcessMs int64 `protobuf:"varint,2,opt,name=process_ms,json=processMs,proto3" json:"process_ms,omitempty"` + WaitMs int64 `protobuf:"varint,1,opt,name=wait_ms,json=waitMs,proto3" json:"wait_ms,omitempty"` + ProcessMs int64 `protobuf:"varint,2,opt,name=process_ms,json=processMs,proto3" json:"process_ms,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *HandleTime) Reset() { *m = HandleTime{} } +func (m *HandleTime) String() string { return proto.CompactTextString(m) } +func (*HandleTime) ProtoMessage() {} +func (*HandleTime) Descriptor() ([]byte, []int) { + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{4} +} +func (m *HandleTime) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *HandleTime) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_HandleTime.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 *HandleTime) XXX_Merge(src proto.Message) { + xxx_messageInfo_HandleTime.Merge(dst, src) +} +func (m *HandleTime) XXX_Size() int { + return m.Size() +} +func (m *HandleTime) XXX_DiscardUnknown() { + xxx_messageInfo_HandleTime.DiscardUnknown(m) } -func (m *HandleTime) Reset() { *m = HandleTime{} } -func (m *HandleTime) String() string { return proto.CompactTextString(m) } -func (*HandleTime) ProtoMessage() {} -func (*HandleTime) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{4} } +var xxx_messageInfo_HandleTime proto.InternalMessageInfo func (m *HandleTime) GetWaitMs() int64 { if m != nil { @@ -406,14 +494,45 @@ func (m *HandleTime) GetProcessMs() int64 { } type ScanInfo struct { - Total int64 `protobuf:"varint,1,opt,name=total,proto3" json:"total,omitempty"` - Processed int64 `protobuf:"varint,2,opt,name=processed,proto3" json:"processed,omitempty"` + Total int64 `protobuf:"varint,1,opt,name=total,proto3" json:"total,omitempty"` + Processed int64 `protobuf:"varint,2,opt,name=processed,proto3" json:"processed,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ScanInfo) Reset() { *m = ScanInfo{} } +func (m *ScanInfo) String() string { return proto.CompactTextString(m) } +func (*ScanInfo) ProtoMessage() {} +func (*ScanInfo) Descriptor() ([]byte, []int) { + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{5} +} +func (m *ScanInfo) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ScanInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ScanInfo.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 *ScanInfo) XXX_Merge(src proto.Message) { + xxx_messageInfo_ScanInfo.Merge(dst, src) +} +func (m *ScanInfo) XXX_Size() int { + return m.Size() +} +func (m *ScanInfo) XXX_DiscardUnknown() { + xxx_messageInfo_ScanInfo.DiscardUnknown(m) } -func (m *ScanInfo) Reset() { *m = ScanInfo{} } -func (m *ScanInfo) String() string { return proto.CompactTextString(m) } -func (*ScanInfo) ProtoMessage() {} -func (*ScanInfo) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{5} } +var xxx_messageInfo_ScanInfo proto.InternalMessageInfo func (m *ScanInfo) GetTotal() int64 { if m != nil { @@ -430,15 +549,46 @@ func (m *ScanInfo) GetProcessed() int64 { } type ScanDetail struct { - Write *ScanInfo `protobuf:"bytes,1,opt,name=write" json:"write,omitempty"` - Lock *ScanInfo `protobuf:"bytes,2,opt,name=lock" json:"lock,omitempty"` - Data *ScanInfo `protobuf:"bytes,3,opt,name=data" json:"data,omitempty"` + Write *ScanInfo `protobuf:"bytes,1,opt,name=write" json:"write,omitempty"` + Lock *ScanInfo `protobuf:"bytes,2,opt,name=lock" json:"lock,omitempty"` + Data *ScanInfo `protobuf:"bytes,3,opt,name=data" json:"data,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ScanDetail) Reset() { *m = ScanDetail{} } +func (m *ScanDetail) String() string { return proto.CompactTextString(m) } +func (*ScanDetail) ProtoMessage() {} +func (*ScanDetail) Descriptor() ([]byte, []int) { + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{6} +} +func (m *ScanDetail) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ScanDetail) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ScanDetail.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 *ScanDetail) XXX_Merge(src proto.Message) { + xxx_messageInfo_ScanDetail.Merge(dst, src) +} +func (m *ScanDetail) XXX_Size() int { + return m.Size() +} +func (m *ScanDetail) XXX_DiscardUnknown() { + xxx_messageInfo_ScanDetail.DiscardUnknown(m) } -func (m *ScanDetail) Reset() { *m = ScanDetail{} } -func (m *ScanDetail) String() string { return proto.CompactTextString(m) } -func (*ScanDetail) ProtoMessage() {} -func (*ScanDetail) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{6} } +var xxx_messageInfo_ScanDetail proto.InternalMessageInfo func (m *ScanDetail) GetWrite() *ScanInfo { if m != nil { @@ -462,14 +612,45 @@ func (m *ScanDetail) GetData() *ScanInfo { } type ExecDetails struct { - HandleTime *HandleTime `protobuf:"bytes,1,opt,name=handle_time,json=handleTime" json:"handle_time,omitempty"` - ScanDetail *ScanDetail `protobuf:"bytes,2,opt,name=scan_detail,json=scanDetail" json:"scan_detail,omitempty"` + HandleTime *HandleTime `protobuf:"bytes,1,opt,name=handle_time,json=handleTime" json:"handle_time,omitempty"` + ScanDetail *ScanDetail `protobuf:"bytes,2,opt,name=scan_detail,json=scanDetail" json:"scan_detail,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ExecDetails) Reset() { *m = ExecDetails{} } +func (m *ExecDetails) String() string { return proto.CompactTextString(m) } +func (*ExecDetails) ProtoMessage() {} +func (*ExecDetails) Descriptor() ([]byte, []int) { + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{7} +} +func (m *ExecDetails) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ExecDetails) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ExecDetails.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 *ExecDetails) XXX_Merge(src proto.Message) { + xxx_messageInfo_ExecDetails.Merge(dst, src) +} +func (m *ExecDetails) XXX_Size() int { + return m.Size() +} +func (m *ExecDetails) XXX_DiscardUnknown() { + xxx_messageInfo_ExecDetails.DiscardUnknown(m) } -func (m *ExecDetails) Reset() { *m = ExecDetails{} } -func (m *ExecDetails) String() string { return proto.CompactTextString(m) } -func (*ExecDetails) ProtoMessage() {} -func (*ExecDetails) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{7} } +var xxx_messageInfo_ExecDetails proto.InternalMessageInfo func (m *ExecDetails) GetHandleTime() *HandleTime { if m != nil { @@ -486,15 +667,46 @@ func (m *ExecDetails) GetScanDetail() *ScanDetail { } type GetRequest struct { - Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` - Key []byte `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` - Version uint64 `protobuf:"varint,3,opt,name=version,proto3" json:"version,omitempty"` + Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` + Key []byte `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` + Version uint64 `protobuf:"varint,3,opt,name=version,proto3" json:"version,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *GetRequest) Reset() { *m = GetRequest{} } +func (m *GetRequest) String() string { return proto.CompactTextString(m) } +func (*GetRequest) ProtoMessage() {} +func (*GetRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{8} +} +func (m *GetRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GetRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GetRequest.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 *GetRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetRequest.Merge(dst, src) +} +func (m *GetRequest) XXX_Size() int { + return m.Size() +} +func (m *GetRequest) XXX_DiscardUnknown() { + xxx_messageInfo_GetRequest.DiscardUnknown(m) } -func (m *GetRequest) Reset() { *m = GetRequest{} } -func (m *GetRequest) String() string { return proto.CompactTextString(m) } -func (*GetRequest) ProtoMessage() {} -func (*GetRequest) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{8} } +var xxx_messageInfo_GetRequest proto.InternalMessageInfo func (m *GetRequest) GetContext() *Context { if m != nil { @@ -518,15 +730,46 @@ func (m *GetRequest) GetVersion() uint64 { } type GetResponse struct { - RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` - Error *KeyError `protobuf:"bytes,2,opt,name=error" json:"error,omitempty"` - Value []byte `protobuf:"bytes,3,opt,name=value,proto3" json:"value,omitempty"` + RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` + Error *KeyError `protobuf:"bytes,2,opt,name=error" json:"error,omitempty"` + Value []byte `protobuf:"bytes,3,opt,name=value,proto3" json:"value,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *GetResponse) Reset() { *m = GetResponse{} } +func (m *GetResponse) String() string { return proto.CompactTextString(m) } +func (*GetResponse) ProtoMessage() {} +func (*GetResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{9} +} +func (m *GetResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GetResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GetResponse.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 *GetResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetResponse.Merge(dst, src) +} +func (m *GetResponse) XXX_Size() int { + return m.Size() +} +func (m *GetResponse) XXX_DiscardUnknown() { + xxx_messageInfo_GetResponse.DiscardUnknown(m) } -func (m *GetResponse) Reset() { *m = GetResponse{} } -func (m *GetResponse) String() string { return proto.CompactTextString(m) } -func (*GetResponse) ProtoMessage() {} -func (*GetResponse) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{9} } +var xxx_messageInfo_GetResponse proto.InternalMessageInfo func (m *GetResponse) GetRegionError() *errorpb.Error { if m != nil { @@ -556,12 +799,47 @@ type ScanRequest struct { Version uint64 `protobuf:"varint,4,opt,name=version,proto3" json:"version,omitempty"` KeyOnly bool `protobuf:"varint,5,opt,name=key_only,json=keyOnly,proto3" json:"key_only,omitempty"` Reverse bool `protobuf:"varint,6,opt,name=reverse,proto3" json:"reverse,omitempty"` + // For compatibility, when scanning forward, `start_key` is the inclusive lower_bound and `end_key` + // is the exclusive upper_bound; when scanning backward, `start_key` is the exclusive upper_bound + // and `end_key` is the inclusive lower_bound. + EndKey []byte `protobuf:"bytes,7,opt,name=end_key,json=endKey,proto3" json:"end_key,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ScanRequest) Reset() { *m = ScanRequest{} } +func (m *ScanRequest) String() string { return proto.CompactTextString(m) } +func (*ScanRequest) ProtoMessage() {} +func (*ScanRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{10} +} +func (m *ScanRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ScanRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ScanRequest.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 *ScanRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ScanRequest.Merge(dst, src) +} +func (m *ScanRequest) XXX_Size() int { + return m.Size() +} +func (m *ScanRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ScanRequest.DiscardUnknown(m) } -func (m *ScanRequest) Reset() { *m = ScanRequest{} } -func (m *ScanRequest) String() string { return proto.CompactTextString(m) } -func (*ScanRequest) ProtoMessage() {} -func (*ScanRequest) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{10} } +var xxx_messageInfo_ScanRequest proto.InternalMessageInfo func (m *ScanRequest) GetContext() *Context { if m != nil { @@ -605,16 +883,54 @@ func (m *ScanRequest) GetReverse() bool { return false } +func (m *ScanRequest) GetEndKey() []byte { + if m != nil { + return m.EndKey + } + return nil +} + type KvPair struct { - Error *KeyError `protobuf:"bytes,1,opt,name=error" json:"error,omitempty"` - Key []byte `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` - Value []byte `protobuf:"bytes,3,opt,name=value,proto3" json:"value,omitempty"` + Error *KeyError `protobuf:"bytes,1,opt,name=error" json:"error,omitempty"` + Key []byte `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` + Value []byte `protobuf:"bytes,3,opt,name=value,proto3" json:"value,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *KvPair) Reset() { *m = KvPair{} } +func (m *KvPair) String() string { return proto.CompactTextString(m) } +func (*KvPair) ProtoMessage() {} +func (*KvPair) Descriptor() ([]byte, []int) { + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{11} +} +func (m *KvPair) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *KvPair) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_KvPair.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 *KvPair) XXX_Merge(src proto.Message) { + xxx_messageInfo_KvPair.Merge(dst, src) +} +func (m *KvPair) XXX_Size() int { + return m.Size() +} +func (m *KvPair) XXX_DiscardUnknown() { + xxx_messageInfo_KvPair.DiscardUnknown(m) } -func (m *KvPair) Reset() { *m = KvPair{} } -func (m *KvPair) String() string { return proto.CompactTextString(m) } -func (*KvPair) ProtoMessage() {} -func (*KvPair) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{11} } +var xxx_messageInfo_KvPair proto.InternalMessageInfo func (m *KvPair) GetError() *KeyError { if m != nil { @@ -638,14 +954,45 @@ func (m *KvPair) GetValue() []byte { } type ScanResponse struct { - RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` - Pairs []*KvPair `protobuf:"bytes,2,rep,name=pairs" json:"pairs,omitempty"` + RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` + Pairs []*KvPair `protobuf:"bytes,2,rep,name=pairs" json:"pairs,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ScanResponse) Reset() { *m = ScanResponse{} } +func (m *ScanResponse) String() string { return proto.CompactTextString(m) } +func (*ScanResponse) ProtoMessage() {} +func (*ScanResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{12} +} +func (m *ScanResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ScanResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ScanResponse.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 *ScanResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ScanResponse.Merge(dst, src) +} +func (m *ScanResponse) XXX_Size() int { + return m.Size() +} +func (m *ScanResponse) XXX_DiscardUnknown() { + xxx_messageInfo_ScanResponse.DiscardUnknown(m) } -func (m *ScanResponse) Reset() { *m = ScanResponse{} } -func (m *ScanResponse) String() string { return proto.CompactTextString(m) } -func (*ScanResponse) ProtoMessage() {} -func (*ScanResponse) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{12} } +var xxx_messageInfo_ScanResponse proto.InternalMessageInfo func (m *ScanResponse) GetRegionError() *errorpb.Error { if m != nil { @@ -662,15 +1009,46 @@ func (m *ScanResponse) GetPairs() []*KvPair { } type Mutation struct { - Op Op `protobuf:"varint,1,opt,name=op,proto3,enum=kvrpcpb.Op" json:"op,omitempty"` - Key []byte `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` - Value []byte `protobuf:"bytes,3,opt,name=value,proto3" json:"value,omitempty"` + Op Op `protobuf:"varint,1,opt,name=op,proto3,enum=kvrpcpb.Op" json:"op,omitempty"` + Key []byte `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` + Value []byte `protobuf:"bytes,3,opt,name=value,proto3" json:"value,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *Mutation) Reset() { *m = Mutation{} } +func (m *Mutation) String() string { return proto.CompactTextString(m) } +func (*Mutation) ProtoMessage() {} +func (*Mutation) Descriptor() ([]byte, []int) { + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{13} +} +func (m *Mutation) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Mutation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Mutation.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 *Mutation) XXX_Merge(src proto.Message) { + xxx_messageInfo_Mutation.Merge(dst, src) +} +func (m *Mutation) XXX_Size() int { + return m.Size() +} +func (m *Mutation) XXX_DiscardUnknown() { + xxx_messageInfo_Mutation.DiscardUnknown(m) } -func (m *Mutation) Reset() { *m = Mutation{} } -func (m *Mutation) String() string { return proto.CompactTextString(m) } -func (*Mutation) ProtoMessage() {} -func (*Mutation) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{13} } +var xxx_messageInfo_Mutation proto.InternalMessageInfo func (m *Mutation) GetOp() Op { if m != nil { @@ -697,16 +1075,47 @@ type PrewriteRequest struct { Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` Mutations []*Mutation `protobuf:"bytes,2,rep,name=mutations" json:"mutations,omitempty"` // primary_lock_key - PrimaryLock []byte `protobuf:"bytes,3,opt,name=primary_lock,json=primaryLock,proto3" json:"primary_lock,omitempty"` - StartVersion uint64 `protobuf:"varint,4,opt,name=start_version,json=startVersion,proto3" json:"start_version,omitempty"` - LockTtl uint64 `protobuf:"varint,5,opt,name=lock_ttl,json=lockTtl,proto3" json:"lock_ttl,omitempty"` - SkipConstraintCheck bool `protobuf:"varint,6,opt,name=skip_constraint_check,json=skipConstraintCheck,proto3" json:"skip_constraint_check,omitempty"` + PrimaryLock []byte `protobuf:"bytes,3,opt,name=primary_lock,json=primaryLock,proto3" json:"primary_lock,omitempty"` + StartVersion uint64 `protobuf:"varint,4,opt,name=start_version,json=startVersion,proto3" json:"start_version,omitempty"` + LockTtl uint64 `protobuf:"varint,5,opt,name=lock_ttl,json=lockTtl,proto3" json:"lock_ttl,omitempty"` + SkipConstraintCheck bool `protobuf:"varint,6,opt,name=skip_constraint_check,json=skipConstraintCheck,proto3" json:"skip_constraint_check,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *PrewriteRequest) Reset() { *m = PrewriteRequest{} } +func (m *PrewriteRequest) String() string { return proto.CompactTextString(m) } +func (*PrewriteRequest) ProtoMessage() {} +func (*PrewriteRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{14} +} +func (m *PrewriteRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *PrewriteRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_PrewriteRequest.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 *PrewriteRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_PrewriteRequest.Merge(dst, src) +} +func (m *PrewriteRequest) XXX_Size() int { + return m.Size() +} +func (m *PrewriteRequest) XXX_DiscardUnknown() { + xxx_messageInfo_PrewriteRequest.DiscardUnknown(m) } -func (m *PrewriteRequest) Reset() { *m = PrewriteRequest{} } -func (m *PrewriteRequest) String() string { return proto.CompactTextString(m) } -func (*PrewriteRequest) ProtoMessage() {} -func (*PrewriteRequest) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{14} } +var xxx_messageInfo_PrewriteRequest proto.InternalMessageInfo func (m *PrewriteRequest) GetContext() *Context { if m != nil { @@ -751,14 +1160,45 @@ func (m *PrewriteRequest) GetSkipConstraintCheck() bool { } type PrewriteResponse struct { - RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` - Errors []*KeyError `protobuf:"bytes,2,rep,name=errors" json:"errors,omitempty"` + RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` + Errors []*KeyError `protobuf:"bytes,2,rep,name=errors" json:"errors,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *PrewriteResponse) Reset() { *m = PrewriteResponse{} } +func (m *PrewriteResponse) String() string { return proto.CompactTextString(m) } +func (*PrewriteResponse) ProtoMessage() {} +func (*PrewriteResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{15} +} +func (m *PrewriteResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *PrewriteResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_PrewriteResponse.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 *PrewriteResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_PrewriteResponse.Merge(dst, src) +} +func (m *PrewriteResponse) XXX_Size() int { + return m.Size() +} +func (m *PrewriteResponse) XXX_DiscardUnknown() { + xxx_messageInfo_PrewriteResponse.DiscardUnknown(m) } -func (m *PrewriteResponse) Reset() { *m = PrewriteResponse{} } -func (m *PrewriteResponse) String() string { return proto.CompactTextString(m) } -func (*PrewriteResponse) ProtoMessage() {} -func (*PrewriteResponse) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{15} } +var xxx_messageInfo_PrewriteResponse proto.InternalMessageInfo func (m *PrewriteResponse) GetRegionError() *errorpb.Error { if m != nil { @@ -775,16 +1215,47 @@ func (m *PrewriteResponse) GetErrors() []*KeyError { } type CommitRequest struct { - Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` - StartVersion uint64 `protobuf:"varint,2,opt,name=start_version,json=startVersion,proto3" json:"start_version,omitempty"` - Keys [][]byte `protobuf:"bytes,3,rep,name=keys" json:"keys,omitempty"` - CommitVersion uint64 `protobuf:"varint,4,opt,name=commit_version,json=commitVersion,proto3" json:"commit_version,omitempty"` + Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` + StartVersion uint64 `protobuf:"varint,2,opt,name=start_version,json=startVersion,proto3" json:"start_version,omitempty"` + Keys [][]byte `protobuf:"bytes,3,rep,name=keys" json:"keys,omitempty"` + CommitVersion uint64 `protobuf:"varint,4,opt,name=commit_version,json=commitVersion,proto3" json:"commit_version,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *CommitRequest) Reset() { *m = CommitRequest{} } +func (m *CommitRequest) String() string { return proto.CompactTextString(m) } +func (*CommitRequest) ProtoMessage() {} +func (*CommitRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{16} +} +func (m *CommitRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *CommitRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_CommitRequest.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 *CommitRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_CommitRequest.Merge(dst, src) +} +func (m *CommitRequest) XXX_Size() int { + return m.Size() +} +func (m *CommitRequest) XXX_DiscardUnknown() { + xxx_messageInfo_CommitRequest.DiscardUnknown(m) } -func (m *CommitRequest) Reset() { *m = CommitRequest{} } -func (m *CommitRequest) String() string { return proto.CompactTextString(m) } -func (*CommitRequest) ProtoMessage() {} -func (*CommitRequest) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{16} } +var xxx_messageInfo_CommitRequest proto.InternalMessageInfo func (m *CommitRequest) GetContext() *Context { if m != nil { @@ -815,14 +1286,45 @@ func (m *CommitRequest) GetCommitVersion() uint64 { } type CommitResponse struct { - RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` - Error *KeyError `protobuf:"bytes,2,opt,name=error" json:"error,omitempty"` + RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` + Error *KeyError `protobuf:"bytes,2,opt,name=error" json:"error,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *CommitResponse) Reset() { *m = CommitResponse{} } +func (m *CommitResponse) String() string { return proto.CompactTextString(m) } +func (*CommitResponse) ProtoMessage() {} +func (*CommitResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{17} +} +func (m *CommitResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *CommitResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_CommitResponse.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 *CommitResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_CommitResponse.Merge(dst, src) +} +func (m *CommitResponse) XXX_Size() int { + return m.Size() +} +func (m *CommitResponse) XXX_DiscardUnknown() { + xxx_messageInfo_CommitResponse.DiscardUnknown(m) } -func (m *CommitResponse) Reset() { *m = CommitResponse{} } -func (m *CommitResponse) String() string { return proto.CompactTextString(m) } -func (*CommitResponse) ProtoMessage() {} -func (*CommitResponse) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{17} } +var xxx_messageInfo_CommitResponse proto.InternalMessageInfo func (m *CommitResponse) GetRegionError() *errorpb.Error { if m != nil { @@ -839,14 +1341,45 @@ func (m *CommitResponse) GetError() *KeyError { } type ImportRequest struct { - Mutations []*Mutation `protobuf:"bytes,1,rep,name=mutations" json:"mutations,omitempty"` - CommitVersion uint64 `protobuf:"varint,2,opt,name=commit_version,json=commitVersion,proto3" json:"commit_version,omitempty"` + Mutations []*Mutation `protobuf:"bytes,1,rep,name=mutations" json:"mutations,omitempty"` + CommitVersion uint64 `protobuf:"varint,2,opt,name=commit_version,json=commitVersion,proto3" json:"commit_version,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ImportRequest) Reset() { *m = ImportRequest{} } +func (m *ImportRequest) String() string { return proto.CompactTextString(m) } +func (*ImportRequest) ProtoMessage() {} +func (*ImportRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{18} +} +func (m *ImportRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ImportRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ImportRequest.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 *ImportRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ImportRequest.Merge(dst, src) +} +func (m *ImportRequest) XXX_Size() int { + return m.Size() +} +func (m *ImportRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ImportRequest.DiscardUnknown(m) } -func (m *ImportRequest) Reset() { *m = ImportRequest{} } -func (m *ImportRequest) String() string { return proto.CompactTextString(m) } -func (*ImportRequest) ProtoMessage() {} -func (*ImportRequest) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{18} } +var xxx_messageInfo_ImportRequest proto.InternalMessageInfo func (m *ImportRequest) GetMutations() []*Mutation { if m != nil { @@ -863,14 +1396,45 @@ func (m *ImportRequest) GetCommitVersion() uint64 { } type ImportResponse struct { - RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` - Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"` + RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` + Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ImportResponse) Reset() { *m = ImportResponse{} } +func (m *ImportResponse) String() string { return proto.CompactTextString(m) } +func (*ImportResponse) ProtoMessage() {} +func (*ImportResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{19} +} +func (m *ImportResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ImportResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ImportResponse.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 *ImportResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ImportResponse.Merge(dst, src) +} +func (m *ImportResponse) XXX_Size() int { + return m.Size() +} +func (m *ImportResponse) XXX_DiscardUnknown() { + xxx_messageInfo_ImportResponse.DiscardUnknown(m) } -func (m *ImportResponse) Reset() { *m = ImportResponse{} } -func (m *ImportResponse) String() string { return proto.CompactTextString(m) } -func (*ImportResponse) ProtoMessage() {} -func (*ImportResponse) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{19} } +var xxx_messageInfo_ImportResponse proto.InternalMessageInfo func (m *ImportResponse) GetRegionError() *errorpb.Error { if m != nil { @@ -887,15 +1451,46 @@ func (m *ImportResponse) GetError() string { } type BatchRollbackRequest struct { - Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` - StartVersion uint64 `protobuf:"varint,2,opt,name=start_version,json=startVersion,proto3" json:"start_version,omitempty"` - Keys [][]byte `protobuf:"bytes,3,rep,name=keys" json:"keys,omitempty"` + Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` + StartVersion uint64 `protobuf:"varint,2,opt,name=start_version,json=startVersion,proto3" json:"start_version,omitempty"` + Keys [][]byte `protobuf:"bytes,3,rep,name=keys" json:"keys,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *BatchRollbackRequest) Reset() { *m = BatchRollbackRequest{} } +func (m *BatchRollbackRequest) String() string { return proto.CompactTextString(m) } +func (*BatchRollbackRequest) ProtoMessage() {} +func (*BatchRollbackRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{20} +} +func (m *BatchRollbackRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *BatchRollbackRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_BatchRollbackRequest.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 *BatchRollbackRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_BatchRollbackRequest.Merge(dst, src) +} +func (m *BatchRollbackRequest) XXX_Size() int { + return m.Size() +} +func (m *BatchRollbackRequest) XXX_DiscardUnknown() { + xxx_messageInfo_BatchRollbackRequest.DiscardUnknown(m) } -func (m *BatchRollbackRequest) Reset() { *m = BatchRollbackRequest{} } -func (m *BatchRollbackRequest) String() string { return proto.CompactTextString(m) } -func (*BatchRollbackRequest) ProtoMessage() {} -func (*BatchRollbackRequest) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{20} } +var xxx_messageInfo_BatchRollbackRequest proto.InternalMessageInfo func (m *BatchRollbackRequest) GetContext() *Context { if m != nil { @@ -919,14 +1514,45 @@ func (m *BatchRollbackRequest) GetKeys() [][]byte { } type BatchRollbackResponse struct { - RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` - Error *KeyError `protobuf:"bytes,2,opt,name=error" json:"error,omitempty"` + RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` + Error *KeyError `protobuf:"bytes,2,opt,name=error" json:"error,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *BatchRollbackResponse) Reset() { *m = BatchRollbackResponse{} } +func (m *BatchRollbackResponse) String() string { return proto.CompactTextString(m) } +func (*BatchRollbackResponse) ProtoMessage() {} +func (*BatchRollbackResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{21} +} +func (m *BatchRollbackResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *BatchRollbackResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_BatchRollbackResponse.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 *BatchRollbackResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_BatchRollbackResponse.Merge(dst, src) +} +func (m *BatchRollbackResponse) XXX_Size() int { + return m.Size() +} +func (m *BatchRollbackResponse) XXX_DiscardUnknown() { + xxx_messageInfo_BatchRollbackResponse.DiscardUnknown(m) } -func (m *BatchRollbackResponse) Reset() { *m = BatchRollbackResponse{} } -func (m *BatchRollbackResponse) String() string { return proto.CompactTextString(m) } -func (*BatchRollbackResponse) ProtoMessage() {} -func (*BatchRollbackResponse) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{21} } +var xxx_messageInfo_BatchRollbackResponse proto.InternalMessageInfo func (m *BatchRollbackResponse) GetRegionError() *errorpb.Error { if m != nil { @@ -943,15 +1569,46 @@ func (m *BatchRollbackResponse) GetError() *KeyError { } type CleanupRequest struct { - Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` - Key []byte `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` - StartVersion uint64 `protobuf:"varint,3,opt,name=start_version,json=startVersion,proto3" json:"start_version,omitempty"` + Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` + Key []byte `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` + StartVersion uint64 `protobuf:"varint,3,opt,name=start_version,json=startVersion,proto3" json:"start_version,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *CleanupRequest) Reset() { *m = CleanupRequest{} } +func (m *CleanupRequest) String() string { return proto.CompactTextString(m) } +func (*CleanupRequest) ProtoMessage() {} +func (*CleanupRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{22} +} +func (m *CleanupRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *CleanupRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_CleanupRequest.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 *CleanupRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_CleanupRequest.Merge(dst, src) +} +func (m *CleanupRequest) XXX_Size() int { + return m.Size() +} +func (m *CleanupRequest) XXX_DiscardUnknown() { + xxx_messageInfo_CleanupRequest.DiscardUnknown(m) } -func (m *CleanupRequest) Reset() { *m = CleanupRequest{} } -func (m *CleanupRequest) String() string { return proto.CompactTextString(m) } -func (*CleanupRequest) ProtoMessage() {} -func (*CleanupRequest) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{22} } +var xxx_messageInfo_CleanupRequest proto.InternalMessageInfo func (m *CleanupRequest) GetContext() *Context { if m != nil { @@ -975,15 +1632,46 @@ func (m *CleanupRequest) GetStartVersion() uint64 { } type CleanupResponse struct { - RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` - Error *KeyError `protobuf:"bytes,2,opt,name=error" json:"error,omitempty"` - CommitVersion uint64 `protobuf:"varint,3,opt,name=commit_version,json=commitVersion,proto3" json:"commit_version,omitempty"` + RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` + Error *KeyError `protobuf:"bytes,2,opt,name=error" json:"error,omitempty"` + CommitVersion uint64 `protobuf:"varint,3,opt,name=commit_version,json=commitVersion,proto3" json:"commit_version,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *CleanupResponse) Reset() { *m = CleanupResponse{} } +func (m *CleanupResponse) String() string { return proto.CompactTextString(m) } +func (*CleanupResponse) ProtoMessage() {} +func (*CleanupResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{23} +} +func (m *CleanupResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *CleanupResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_CleanupResponse.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 *CleanupResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_CleanupResponse.Merge(dst, src) +} +func (m *CleanupResponse) XXX_Size() int { + return m.Size() +} +func (m *CleanupResponse) XXX_DiscardUnknown() { + xxx_messageInfo_CleanupResponse.DiscardUnknown(m) } -func (m *CleanupResponse) Reset() { *m = CleanupResponse{} } -func (m *CleanupResponse) String() string { return proto.CompactTextString(m) } -func (*CleanupResponse) ProtoMessage() {} -func (*CleanupResponse) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{23} } +var xxx_messageInfo_CleanupResponse proto.InternalMessageInfo func (m *CleanupResponse) GetRegionError() *errorpb.Error { if m != nil { @@ -1007,15 +1695,46 @@ func (m *CleanupResponse) GetCommitVersion() uint64 { } type BatchGetRequest struct { - Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` - Keys [][]byte `protobuf:"bytes,2,rep,name=keys" json:"keys,omitempty"` - Version uint64 `protobuf:"varint,3,opt,name=version,proto3" json:"version,omitempty"` + Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` + Keys [][]byte `protobuf:"bytes,2,rep,name=keys" json:"keys,omitempty"` + Version uint64 `protobuf:"varint,3,opt,name=version,proto3" json:"version,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *BatchGetRequest) Reset() { *m = BatchGetRequest{} } +func (m *BatchGetRequest) String() string { return proto.CompactTextString(m) } +func (*BatchGetRequest) ProtoMessage() {} +func (*BatchGetRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{24} +} +func (m *BatchGetRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *BatchGetRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_BatchGetRequest.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 *BatchGetRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_BatchGetRequest.Merge(dst, src) +} +func (m *BatchGetRequest) XXX_Size() int { + return m.Size() +} +func (m *BatchGetRequest) XXX_DiscardUnknown() { + xxx_messageInfo_BatchGetRequest.DiscardUnknown(m) } -func (m *BatchGetRequest) Reset() { *m = BatchGetRequest{} } -func (m *BatchGetRequest) String() string { return proto.CompactTextString(m) } -func (*BatchGetRequest) ProtoMessage() {} -func (*BatchGetRequest) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{24} } +var xxx_messageInfo_BatchGetRequest proto.InternalMessageInfo func (m *BatchGetRequest) GetContext() *Context { if m != nil { @@ -1039,14 +1758,45 @@ func (m *BatchGetRequest) GetVersion() uint64 { } type BatchGetResponse struct { - RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` - Pairs []*KvPair `protobuf:"bytes,2,rep,name=pairs" json:"pairs,omitempty"` + RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` + Pairs []*KvPair `protobuf:"bytes,2,rep,name=pairs" json:"pairs,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *BatchGetResponse) Reset() { *m = BatchGetResponse{} } +func (m *BatchGetResponse) String() string { return proto.CompactTextString(m) } +func (*BatchGetResponse) ProtoMessage() {} +func (*BatchGetResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{25} +} +func (m *BatchGetResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *BatchGetResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_BatchGetResponse.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 *BatchGetResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_BatchGetResponse.Merge(dst, src) +} +func (m *BatchGetResponse) XXX_Size() int { + return m.Size() +} +func (m *BatchGetResponse) XXX_DiscardUnknown() { + xxx_messageInfo_BatchGetResponse.DiscardUnknown(m) } -func (m *BatchGetResponse) Reset() { *m = BatchGetResponse{} } -func (m *BatchGetResponse) String() string { return proto.CompactTextString(m) } -func (*BatchGetResponse) ProtoMessage() {} -func (*BatchGetResponse) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{25} } +var xxx_messageInfo_BatchGetResponse proto.InternalMessageInfo func (m *BatchGetResponse) GetRegionError() *errorpb.Error { if m != nil { @@ -1063,16 +1813,47 @@ func (m *BatchGetResponse) GetPairs() []*KvPair { } type ScanLockRequest struct { - Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` - MaxVersion uint64 `protobuf:"varint,2,opt,name=max_version,json=maxVersion,proto3" json:"max_version,omitempty"` - StartKey []byte `protobuf:"bytes,3,opt,name=start_key,json=startKey,proto3" json:"start_key,omitempty"` - Limit uint32 `protobuf:"varint,4,opt,name=limit,proto3" json:"limit,omitempty"` + Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` + MaxVersion uint64 `protobuf:"varint,2,opt,name=max_version,json=maxVersion,proto3" json:"max_version,omitempty"` + StartKey []byte `protobuf:"bytes,3,opt,name=start_key,json=startKey,proto3" json:"start_key,omitempty"` + Limit uint32 `protobuf:"varint,4,opt,name=limit,proto3" json:"limit,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ScanLockRequest) Reset() { *m = ScanLockRequest{} } +func (m *ScanLockRequest) String() string { return proto.CompactTextString(m) } +func (*ScanLockRequest) ProtoMessage() {} +func (*ScanLockRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{26} +} +func (m *ScanLockRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ScanLockRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ScanLockRequest.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 *ScanLockRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ScanLockRequest.Merge(dst, src) +} +func (m *ScanLockRequest) XXX_Size() int { + return m.Size() +} +func (m *ScanLockRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ScanLockRequest.DiscardUnknown(m) } -func (m *ScanLockRequest) Reset() { *m = ScanLockRequest{} } -func (m *ScanLockRequest) String() string { return proto.CompactTextString(m) } -func (*ScanLockRequest) ProtoMessage() {} -func (*ScanLockRequest) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{26} } +var xxx_messageInfo_ScanLockRequest proto.InternalMessageInfo func (m *ScanLockRequest) GetContext() *Context { if m != nil { @@ -1103,15 +1884,46 @@ func (m *ScanLockRequest) GetLimit() uint32 { } type ScanLockResponse struct { - RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` - Error *KeyError `protobuf:"bytes,2,opt,name=error" json:"error,omitempty"` - Locks []*LockInfo `protobuf:"bytes,3,rep,name=locks" json:"locks,omitempty"` + RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` + Error *KeyError `protobuf:"bytes,2,opt,name=error" json:"error,omitempty"` + Locks []*LockInfo `protobuf:"bytes,3,rep,name=locks" json:"locks,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ScanLockResponse) Reset() { *m = ScanLockResponse{} } +func (m *ScanLockResponse) String() string { return proto.CompactTextString(m) } +func (*ScanLockResponse) ProtoMessage() {} +func (*ScanLockResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{27} +} +func (m *ScanLockResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ScanLockResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ScanLockResponse.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 *ScanLockResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ScanLockResponse.Merge(dst, src) +} +func (m *ScanLockResponse) XXX_Size() int { + return m.Size() +} +func (m *ScanLockResponse) XXX_DiscardUnknown() { + xxx_messageInfo_ScanLockResponse.DiscardUnknown(m) } -func (m *ScanLockResponse) Reset() { *m = ScanLockResponse{} } -func (m *ScanLockResponse) String() string { return proto.CompactTextString(m) } -func (*ScanLockResponse) ProtoMessage() {} -func (*ScanLockResponse) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{27} } +var xxx_messageInfo_ScanLockResponse proto.InternalMessageInfo func (m *ScanLockResponse) GetRegionError() *errorpb.Error { if m != nil { @@ -1135,14 +1947,45 @@ func (m *ScanLockResponse) GetLocks() []*LockInfo { } type TxnInfo struct { - Txn uint64 `protobuf:"varint,1,opt,name=txn,proto3" json:"txn,omitempty"` - Status uint64 `protobuf:"varint,2,opt,name=status,proto3" json:"status,omitempty"` + Txn uint64 `protobuf:"varint,1,opt,name=txn,proto3" json:"txn,omitempty"` + Status uint64 `protobuf:"varint,2,opt,name=status,proto3" json:"status,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *TxnInfo) Reset() { *m = TxnInfo{} } +func (m *TxnInfo) String() string { return proto.CompactTextString(m) } +func (*TxnInfo) ProtoMessage() {} +func (*TxnInfo) Descriptor() ([]byte, []int) { + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{28} +} +func (m *TxnInfo) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *TxnInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_TxnInfo.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 *TxnInfo) XXX_Merge(src proto.Message) { + xxx_messageInfo_TxnInfo.Merge(dst, src) +} +func (m *TxnInfo) XXX_Size() int { + return m.Size() +} +func (m *TxnInfo) XXX_DiscardUnknown() { + xxx_messageInfo_TxnInfo.DiscardUnknown(m) } -func (m *TxnInfo) Reset() { *m = TxnInfo{} } -func (m *TxnInfo) String() string { return proto.CompactTextString(m) } -func (*TxnInfo) ProtoMessage() {} -func (*TxnInfo) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{28} } +var xxx_messageInfo_TxnInfo proto.InternalMessageInfo func (m *TxnInfo) GetTxn() uint64 { if m != nil { @@ -1162,14 +2005,45 @@ type ResolveLockRequest struct { Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` StartVersion uint64 `protobuf:"varint,2,opt,name=start_version,json=startVersion,proto3" json:"start_version,omitempty"` // If the txn is rolled back, do not set it. - CommitVersion uint64 `protobuf:"varint,3,opt,name=commit_version,json=commitVersion,proto3" json:"commit_version,omitempty"` - TxnInfos []*TxnInfo `protobuf:"bytes,4,rep,name=txn_infos,json=txnInfos" json:"txn_infos,omitempty"` + CommitVersion uint64 `protobuf:"varint,3,opt,name=commit_version,json=commitVersion,proto3" json:"commit_version,omitempty"` + TxnInfos []*TxnInfo `protobuf:"bytes,4,rep,name=txn_infos,json=txnInfos" json:"txn_infos,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ResolveLockRequest) Reset() { *m = ResolveLockRequest{} } +func (m *ResolveLockRequest) String() string { return proto.CompactTextString(m) } +func (*ResolveLockRequest) ProtoMessage() {} +func (*ResolveLockRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{29} +} +func (m *ResolveLockRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ResolveLockRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ResolveLockRequest.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 *ResolveLockRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ResolveLockRequest.Merge(dst, src) +} +func (m *ResolveLockRequest) XXX_Size() int { + return m.Size() +} +func (m *ResolveLockRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ResolveLockRequest.DiscardUnknown(m) } -func (m *ResolveLockRequest) Reset() { *m = ResolveLockRequest{} } -func (m *ResolveLockRequest) String() string { return proto.CompactTextString(m) } -func (*ResolveLockRequest) ProtoMessage() {} -func (*ResolveLockRequest) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{29} } +var xxx_messageInfo_ResolveLockRequest proto.InternalMessageInfo func (m *ResolveLockRequest) GetContext() *Context { if m != nil { @@ -1200,14 +2074,45 @@ func (m *ResolveLockRequest) GetTxnInfos() []*TxnInfo { } type ResolveLockResponse struct { - RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` - Error *KeyError `protobuf:"bytes,2,opt,name=error" json:"error,omitempty"` + RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` + Error *KeyError `protobuf:"bytes,2,opt,name=error" json:"error,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ResolveLockResponse) Reset() { *m = ResolveLockResponse{} } +func (m *ResolveLockResponse) String() string { return proto.CompactTextString(m) } +func (*ResolveLockResponse) ProtoMessage() {} +func (*ResolveLockResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{30} +} +func (m *ResolveLockResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ResolveLockResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ResolveLockResponse.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 *ResolveLockResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ResolveLockResponse.Merge(dst, src) +} +func (m *ResolveLockResponse) XXX_Size() int { + return m.Size() +} +func (m *ResolveLockResponse) XXX_DiscardUnknown() { + xxx_messageInfo_ResolveLockResponse.DiscardUnknown(m) } -func (m *ResolveLockResponse) Reset() { *m = ResolveLockResponse{} } -func (m *ResolveLockResponse) String() string { return proto.CompactTextString(m) } -func (*ResolveLockResponse) ProtoMessage() {} -func (*ResolveLockResponse) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{30} } +var xxx_messageInfo_ResolveLockResponse proto.InternalMessageInfo func (m *ResolveLockResponse) GetRegionError() *errorpb.Error { if m != nil { @@ -1224,14 +2129,45 @@ func (m *ResolveLockResponse) GetError() *KeyError { } type GCRequest struct { - Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` - SafePoint uint64 `protobuf:"varint,2,opt,name=safe_point,json=safePoint,proto3" json:"safe_point,omitempty"` + Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` + SafePoint uint64 `protobuf:"varint,2,opt,name=safe_point,json=safePoint,proto3" json:"safe_point,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *GCRequest) Reset() { *m = GCRequest{} } +func (m *GCRequest) String() string { return proto.CompactTextString(m) } +func (*GCRequest) ProtoMessage() {} +func (*GCRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{31} +} +func (m *GCRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GCRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GCRequest.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 *GCRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_GCRequest.Merge(dst, src) +} +func (m *GCRequest) XXX_Size() int { + return m.Size() +} +func (m *GCRequest) XXX_DiscardUnknown() { + xxx_messageInfo_GCRequest.DiscardUnknown(m) } -func (m *GCRequest) Reset() { *m = GCRequest{} } -func (m *GCRequest) String() string { return proto.CompactTextString(m) } -func (*GCRequest) ProtoMessage() {} -func (*GCRequest) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{31} } +var xxx_messageInfo_GCRequest proto.InternalMessageInfo func (m *GCRequest) GetContext() *Context { if m != nil { @@ -1248,14 +2184,45 @@ func (m *GCRequest) GetSafePoint() uint64 { } type GCResponse struct { - RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` - Error *KeyError `protobuf:"bytes,2,opt,name=error" json:"error,omitempty"` + RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` + Error *KeyError `protobuf:"bytes,2,opt,name=error" json:"error,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *GCResponse) Reset() { *m = GCResponse{} } +func (m *GCResponse) String() string { return proto.CompactTextString(m) } +func (*GCResponse) ProtoMessage() {} +func (*GCResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{32} +} +func (m *GCResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GCResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GCResponse.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 *GCResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_GCResponse.Merge(dst, src) +} +func (m *GCResponse) XXX_Size() int { + return m.Size() +} +func (m *GCResponse) XXX_DiscardUnknown() { + xxx_messageInfo_GCResponse.DiscardUnknown(m) } -func (m *GCResponse) Reset() { *m = GCResponse{} } -func (m *GCResponse) String() string { return proto.CompactTextString(m) } -func (*GCResponse) ProtoMessage() {} -func (*GCResponse) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{32} } +var xxx_messageInfo_GCResponse proto.InternalMessageInfo func (m *GCResponse) GetRegionError() *errorpb.Error { if m != nil { @@ -1272,15 +2239,46 @@ func (m *GCResponse) GetError() *KeyError { } type RawGetRequest struct { - Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` - Key []byte `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` - Cf string `protobuf:"bytes,3,opt,name=cf,proto3" json:"cf,omitempty"` + Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` + Key []byte `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` + Cf string `protobuf:"bytes,3,opt,name=cf,proto3" json:"cf,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RawGetRequest) Reset() { *m = RawGetRequest{} } +func (m *RawGetRequest) String() string { return proto.CompactTextString(m) } +func (*RawGetRequest) ProtoMessage() {} +func (*RawGetRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{33} +} +func (m *RawGetRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RawGetRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RawGetRequest.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 *RawGetRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_RawGetRequest.Merge(dst, src) +} +func (m *RawGetRequest) XXX_Size() int { + return m.Size() +} +func (m *RawGetRequest) XXX_DiscardUnknown() { + xxx_messageInfo_RawGetRequest.DiscardUnknown(m) } -func (m *RawGetRequest) Reset() { *m = RawGetRequest{} } -func (m *RawGetRequest) String() string { return proto.CompactTextString(m) } -func (*RawGetRequest) ProtoMessage() {} -func (*RawGetRequest) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{33} } +var xxx_messageInfo_RawGetRequest proto.InternalMessageInfo func (m *RawGetRequest) GetContext() *Context { if m != nil { @@ -1304,15 +2302,46 @@ func (m *RawGetRequest) GetCf() string { } type RawGetResponse struct { - RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` - Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"` - Value []byte `protobuf:"bytes,3,opt,name=value,proto3" json:"value,omitempty"` + RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` + Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"` + Value []byte `protobuf:"bytes,3,opt,name=value,proto3" json:"value,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RawGetResponse) Reset() { *m = RawGetResponse{} } +func (m *RawGetResponse) String() string { return proto.CompactTextString(m) } +func (*RawGetResponse) ProtoMessage() {} +func (*RawGetResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{34} +} +func (m *RawGetResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RawGetResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RawGetResponse.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 *RawGetResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_RawGetResponse.Merge(dst, src) +} +func (m *RawGetResponse) XXX_Size() int { + return m.Size() +} +func (m *RawGetResponse) XXX_DiscardUnknown() { + xxx_messageInfo_RawGetResponse.DiscardUnknown(m) } -func (m *RawGetResponse) Reset() { *m = RawGetResponse{} } -func (m *RawGetResponse) String() string { return proto.CompactTextString(m) } -func (*RawGetResponse) ProtoMessage() {} -func (*RawGetResponse) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{34} } +var xxx_messageInfo_RawGetResponse proto.InternalMessageInfo func (m *RawGetResponse) GetRegionError() *errorpb.Error { if m != nil { @@ -1336,16 +2365,47 @@ func (m *RawGetResponse) GetValue() []byte { } type RawPutRequest struct { - Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` - Key []byte `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` - Value []byte `protobuf:"bytes,3,opt,name=value,proto3" json:"value,omitempty"` - Cf string `protobuf:"bytes,4,opt,name=cf,proto3" json:"cf,omitempty"` + Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` + Key []byte `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` + Value []byte `protobuf:"bytes,3,opt,name=value,proto3" json:"value,omitempty"` + Cf string `protobuf:"bytes,4,opt,name=cf,proto3" json:"cf,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RawPutRequest) Reset() { *m = RawPutRequest{} } +func (m *RawPutRequest) String() string { return proto.CompactTextString(m) } +func (*RawPutRequest) ProtoMessage() {} +func (*RawPutRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{35} +} +func (m *RawPutRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RawPutRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RawPutRequest.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 *RawPutRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_RawPutRequest.Merge(dst, src) +} +func (m *RawPutRequest) XXX_Size() int { + return m.Size() +} +func (m *RawPutRequest) XXX_DiscardUnknown() { + xxx_messageInfo_RawPutRequest.DiscardUnknown(m) } -func (m *RawPutRequest) Reset() { *m = RawPutRequest{} } -func (m *RawPutRequest) String() string { return proto.CompactTextString(m) } -func (*RawPutRequest) ProtoMessage() {} -func (*RawPutRequest) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{35} } +var xxx_messageInfo_RawPutRequest proto.InternalMessageInfo func (m *RawPutRequest) GetContext() *Context { if m != nil { @@ -1376,14 +2436,45 @@ func (m *RawPutRequest) GetCf() string { } type RawPutResponse struct { - RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` - Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"` + RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` + Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RawPutResponse) Reset() { *m = RawPutResponse{} } +func (m *RawPutResponse) String() string { return proto.CompactTextString(m) } +func (*RawPutResponse) ProtoMessage() {} +func (*RawPutResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{36} +} +func (m *RawPutResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RawPutResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RawPutResponse.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 *RawPutResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_RawPutResponse.Merge(dst, src) +} +func (m *RawPutResponse) XXX_Size() int { + return m.Size() +} +func (m *RawPutResponse) XXX_DiscardUnknown() { + xxx_messageInfo_RawPutResponse.DiscardUnknown(m) } -func (m *RawPutResponse) Reset() { *m = RawPutResponse{} } -func (m *RawPutResponse) String() string { return proto.CompactTextString(m) } -func (*RawPutResponse) ProtoMessage() {} -func (*RawPutResponse) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{36} } +var xxx_messageInfo_RawPutResponse proto.InternalMessageInfo func (m *RawPutResponse) GetRegionError() *errorpb.Error { if m != nil { @@ -1400,15 +2491,46 @@ func (m *RawPutResponse) GetError() string { } type RawBatchPutRequest struct { - Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` - Pairs []*KvPair `protobuf:"bytes,2,rep,name=pairs" json:"pairs,omitempty"` - Cf string `protobuf:"bytes,3,opt,name=cf,proto3" json:"cf,omitempty"` + Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` + Pairs []*KvPair `protobuf:"bytes,2,rep,name=pairs" json:"pairs,omitempty"` + Cf string `protobuf:"bytes,3,opt,name=cf,proto3" json:"cf,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RawBatchPutRequest) Reset() { *m = RawBatchPutRequest{} } +func (m *RawBatchPutRequest) String() string { return proto.CompactTextString(m) } +func (*RawBatchPutRequest) ProtoMessage() {} +func (*RawBatchPutRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{37} +} +func (m *RawBatchPutRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RawBatchPutRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RawBatchPutRequest.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 *RawBatchPutRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_RawBatchPutRequest.Merge(dst, src) +} +func (m *RawBatchPutRequest) XXX_Size() int { + return m.Size() +} +func (m *RawBatchPutRequest) XXX_DiscardUnknown() { + xxx_messageInfo_RawBatchPutRequest.DiscardUnknown(m) } -func (m *RawBatchPutRequest) Reset() { *m = RawBatchPutRequest{} } -func (m *RawBatchPutRequest) String() string { return proto.CompactTextString(m) } -func (*RawBatchPutRequest) ProtoMessage() {} -func (*RawBatchPutRequest) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{37} } +var xxx_messageInfo_RawBatchPutRequest proto.InternalMessageInfo func (m *RawBatchPutRequest) GetContext() *Context { if m != nil { @@ -1432,14 +2554,45 @@ func (m *RawBatchPutRequest) GetCf() string { } type RawBatchPutResponse struct { - RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` - Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"` + RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` + Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RawBatchPutResponse) Reset() { *m = RawBatchPutResponse{} } +func (m *RawBatchPutResponse) String() string { return proto.CompactTextString(m) } +func (*RawBatchPutResponse) ProtoMessage() {} +func (*RawBatchPutResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{38} +} +func (m *RawBatchPutResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RawBatchPutResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RawBatchPutResponse.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 *RawBatchPutResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_RawBatchPutResponse.Merge(dst, src) +} +func (m *RawBatchPutResponse) XXX_Size() int { + return m.Size() +} +func (m *RawBatchPutResponse) XXX_DiscardUnknown() { + xxx_messageInfo_RawBatchPutResponse.DiscardUnknown(m) } -func (m *RawBatchPutResponse) Reset() { *m = RawBatchPutResponse{} } -func (m *RawBatchPutResponse) String() string { return proto.CompactTextString(m) } -func (*RawBatchPutResponse) ProtoMessage() {} -func (*RawBatchPutResponse) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{38} } +var xxx_messageInfo_RawBatchPutResponse proto.InternalMessageInfo func (m *RawBatchPutResponse) GetRegionError() *errorpb.Error { if m != nil { @@ -1456,15 +2609,46 @@ func (m *RawBatchPutResponse) GetError() string { } type RawBatchGetRequest struct { - Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` - Keys [][]byte `protobuf:"bytes,2,rep,name=keys" json:"keys,omitempty"` - Cf string `protobuf:"bytes,3,opt,name=cf,proto3" json:"cf,omitempty"` + Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` + Keys [][]byte `protobuf:"bytes,2,rep,name=keys" json:"keys,omitempty"` + Cf string `protobuf:"bytes,3,opt,name=cf,proto3" json:"cf,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RawBatchGetRequest) Reset() { *m = RawBatchGetRequest{} } +func (m *RawBatchGetRequest) String() string { return proto.CompactTextString(m) } +func (*RawBatchGetRequest) ProtoMessage() {} +func (*RawBatchGetRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{39} +} +func (m *RawBatchGetRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RawBatchGetRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RawBatchGetRequest.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 *RawBatchGetRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_RawBatchGetRequest.Merge(dst, src) +} +func (m *RawBatchGetRequest) XXX_Size() int { + return m.Size() +} +func (m *RawBatchGetRequest) XXX_DiscardUnknown() { + xxx_messageInfo_RawBatchGetRequest.DiscardUnknown(m) } -func (m *RawBatchGetRequest) Reset() { *m = RawBatchGetRequest{} } -func (m *RawBatchGetRequest) String() string { return proto.CompactTextString(m) } -func (*RawBatchGetRequest) ProtoMessage() {} -func (*RawBatchGetRequest) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{39} } +var xxx_messageInfo_RawBatchGetRequest proto.InternalMessageInfo func (m *RawBatchGetRequest) GetContext() *Context { if m != nil { @@ -1488,14 +2672,45 @@ func (m *RawBatchGetRequest) GetCf() string { } type RawBatchGetResponse struct { - RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` - Pairs []*KvPair `protobuf:"bytes,2,rep,name=pairs" json:"pairs,omitempty"` + RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` + Pairs []*KvPair `protobuf:"bytes,2,rep,name=pairs" json:"pairs,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RawBatchGetResponse) Reset() { *m = RawBatchGetResponse{} } +func (m *RawBatchGetResponse) String() string { return proto.CompactTextString(m) } +func (*RawBatchGetResponse) ProtoMessage() {} +func (*RawBatchGetResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{40} +} +func (m *RawBatchGetResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RawBatchGetResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RawBatchGetResponse.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 *RawBatchGetResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_RawBatchGetResponse.Merge(dst, src) +} +func (m *RawBatchGetResponse) XXX_Size() int { + return m.Size() +} +func (m *RawBatchGetResponse) XXX_DiscardUnknown() { + xxx_messageInfo_RawBatchGetResponse.DiscardUnknown(m) } -func (m *RawBatchGetResponse) Reset() { *m = RawBatchGetResponse{} } -func (m *RawBatchGetResponse) String() string { return proto.CompactTextString(m) } -func (*RawBatchGetResponse) ProtoMessage() {} -func (*RawBatchGetResponse) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{40} } +var xxx_messageInfo_RawBatchGetResponse proto.InternalMessageInfo func (m *RawBatchGetResponse) GetRegionError() *errorpb.Error { if m != nil { @@ -1512,15 +2727,46 @@ func (m *RawBatchGetResponse) GetPairs() []*KvPair { } type RawDeleteRequest struct { - Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` - Key []byte `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` - Cf string `protobuf:"bytes,3,opt,name=cf,proto3" json:"cf,omitempty"` + Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` + Key []byte `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` + Cf string `protobuf:"bytes,3,opt,name=cf,proto3" json:"cf,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RawDeleteRequest) Reset() { *m = RawDeleteRequest{} } +func (m *RawDeleteRequest) String() string { return proto.CompactTextString(m) } +func (*RawDeleteRequest) ProtoMessage() {} +func (*RawDeleteRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{41} +} +func (m *RawDeleteRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RawDeleteRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RawDeleteRequest.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 *RawDeleteRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_RawDeleteRequest.Merge(dst, src) +} +func (m *RawDeleteRequest) XXX_Size() int { + return m.Size() +} +func (m *RawDeleteRequest) XXX_DiscardUnknown() { + xxx_messageInfo_RawDeleteRequest.DiscardUnknown(m) } -func (m *RawDeleteRequest) Reset() { *m = RawDeleteRequest{} } -func (m *RawDeleteRequest) String() string { return proto.CompactTextString(m) } -func (*RawDeleteRequest) ProtoMessage() {} -func (*RawDeleteRequest) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{41} } +var xxx_messageInfo_RawDeleteRequest proto.InternalMessageInfo func (m *RawDeleteRequest) GetContext() *Context { if m != nil { @@ -1544,14 +2790,45 @@ func (m *RawDeleteRequest) GetCf() string { } type RawDeleteResponse struct { - RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` - Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"` + RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` + Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RawDeleteResponse) Reset() { *m = RawDeleteResponse{} } +func (m *RawDeleteResponse) String() string { return proto.CompactTextString(m) } +func (*RawDeleteResponse) ProtoMessage() {} +func (*RawDeleteResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{42} +} +func (m *RawDeleteResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RawDeleteResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RawDeleteResponse.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 *RawDeleteResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_RawDeleteResponse.Merge(dst, src) +} +func (m *RawDeleteResponse) XXX_Size() int { + return m.Size() +} +func (m *RawDeleteResponse) XXX_DiscardUnknown() { + xxx_messageInfo_RawDeleteResponse.DiscardUnknown(m) } -func (m *RawDeleteResponse) Reset() { *m = RawDeleteResponse{} } -func (m *RawDeleteResponse) String() string { return proto.CompactTextString(m) } -func (*RawDeleteResponse) ProtoMessage() {} -func (*RawDeleteResponse) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{42} } +var xxx_messageInfo_RawDeleteResponse proto.InternalMessageInfo func (m *RawDeleteResponse) GetRegionError() *errorpb.Error { if m != nil { @@ -1568,15 +2845,46 @@ func (m *RawDeleteResponse) GetError() string { } type RawBatchDeleteRequest struct { - Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` - Keys [][]byte `protobuf:"bytes,2,rep,name=keys" json:"keys,omitempty"` - Cf string `protobuf:"bytes,3,opt,name=cf,proto3" json:"cf,omitempty"` + Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` + Keys [][]byte `protobuf:"bytes,2,rep,name=keys" json:"keys,omitempty"` + Cf string `protobuf:"bytes,3,opt,name=cf,proto3" json:"cf,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RawBatchDeleteRequest) Reset() { *m = RawBatchDeleteRequest{} } +func (m *RawBatchDeleteRequest) String() string { return proto.CompactTextString(m) } +func (*RawBatchDeleteRequest) ProtoMessage() {} +func (*RawBatchDeleteRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{43} +} +func (m *RawBatchDeleteRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RawBatchDeleteRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RawBatchDeleteRequest.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 *RawBatchDeleteRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_RawBatchDeleteRequest.Merge(dst, src) +} +func (m *RawBatchDeleteRequest) XXX_Size() int { + return m.Size() +} +func (m *RawBatchDeleteRequest) XXX_DiscardUnknown() { + xxx_messageInfo_RawBatchDeleteRequest.DiscardUnknown(m) } -func (m *RawBatchDeleteRequest) Reset() { *m = RawBatchDeleteRequest{} } -func (m *RawBatchDeleteRequest) String() string { return proto.CompactTextString(m) } -func (*RawBatchDeleteRequest) ProtoMessage() {} -func (*RawBatchDeleteRequest) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{43} } +var xxx_messageInfo_RawBatchDeleteRequest proto.InternalMessageInfo func (m *RawBatchDeleteRequest) GetContext() *Context { if m != nil { @@ -1600,14 +2908,45 @@ func (m *RawBatchDeleteRequest) GetCf() string { } type RawBatchDeleteResponse struct { - RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` - Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"` + RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` + Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RawBatchDeleteResponse) Reset() { *m = RawBatchDeleteResponse{} } +func (m *RawBatchDeleteResponse) String() string { return proto.CompactTextString(m) } +func (*RawBatchDeleteResponse) ProtoMessage() {} +func (*RawBatchDeleteResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{44} +} +func (m *RawBatchDeleteResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RawBatchDeleteResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RawBatchDeleteResponse.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 *RawBatchDeleteResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_RawBatchDeleteResponse.Merge(dst, src) +} +func (m *RawBatchDeleteResponse) XXX_Size() int { + return m.Size() +} +func (m *RawBatchDeleteResponse) XXX_DiscardUnknown() { + xxx_messageInfo_RawBatchDeleteResponse.DiscardUnknown(m) } -func (m *RawBatchDeleteResponse) Reset() { *m = RawBatchDeleteResponse{} } -func (m *RawBatchDeleteResponse) String() string { return proto.CompactTextString(m) } -func (*RawBatchDeleteResponse) ProtoMessage() {} -func (*RawBatchDeleteResponse) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{44} } +var xxx_messageInfo_RawBatchDeleteResponse proto.InternalMessageInfo func (m *RawBatchDeleteResponse) GetRegionError() *errorpb.Error { if m != nil { @@ -1624,15 +2963,46 @@ func (m *RawBatchDeleteResponse) GetError() string { } type DeleteRangeRequest struct { - Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` - StartKey []byte `protobuf:"bytes,2,opt,name=start_key,json=startKey,proto3" json:"start_key,omitempty"` - EndKey []byte `protobuf:"bytes,3,opt,name=end_key,json=endKey,proto3" json:"end_key,omitempty"` + Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` + StartKey []byte `protobuf:"bytes,2,opt,name=start_key,json=startKey,proto3" json:"start_key,omitempty"` + EndKey []byte `protobuf:"bytes,3,opt,name=end_key,json=endKey,proto3" json:"end_key,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *DeleteRangeRequest) Reset() { *m = DeleteRangeRequest{} } +func (m *DeleteRangeRequest) String() string { return proto.CompactTextString(m) } +func (*DeleteRangeRequest) ProtoMessage() {} +func (*DeleteRangeRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{45} +} +func (m *DeleteRangeRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *DeleteRangeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_DeleteRangeRequest.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 *DeleteRangeRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_DeleteRangeRequest.Merge(dst, src) +} +func (m *DeleteRangeRequest) XXX_Size() int { + return m.Size() +} +func (m *DeleteRangeRequest) XXX_DiscardUnknown() { + xxx_messageInfo_DeleteRangeRequest.DiscardUnknown(m) } -func (m *DeleteRangeRequest) Reset() { *m = DeleteRangeRequest{} } -func (m *DeleteRangeRequest) String() string { return proto.CompactTextString(m) } -func (*DeleteRangeRequest) ProtoMessage() {} -func (*DeleteRangeRequest) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{45} } +var xxx_messageInfo_DeleteRangeRequest proto.InternalMessageInfo func (m *DeleteRangeRequest) GetContext() *Context { if m != nil { @@ -1656,14 +3026,45 @@ func (m *DeleteRangeRequest) GetEndKey() []byte { } type DeleteRangeResponse struct { - RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` - Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"` + RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` + Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *DeleteRangeResponse) Reset() { *m = DeleteRangeResponse{} } +func (m *DeleteRangeResponse) String() string { return proto.CompactTextString(m) } +func (*DeleteRangeResponse) ProtoMessage() {} +func (*DeleteRangeResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{46} +} +func (m *DeleteRangeResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *DeleteRangeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_DeleteRangeResponse.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 *DeleteRangeResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_DeleteRangeResponse.Merge(dst, src) +} +func (m *DeleteRangeResponse) XXX_Size() int { + return m.Size() +} +func (m *DeleteRangeResponse) XXX_DiscardUnknown() { + xxx_messageInfo_DeleteRangeResponse.DiscardUnknown(m) } -func (m *DeleteRangeResponse) Reset() { *m = DeleteRangeResponse{} } -func (m *DeleteRangeResponse) String() string { return proto.CompactTextString(m) } -func (*DeleteRangeResponse) ProtoMessage() {} -func (*DeleteRangeResponse) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{46} } +var xxx_messageInfo_DeleteRangeResponse proto.InternalMessageInfo func (m *DeleteRangeResponse) GetRegionError() *errorpb.Error { if m != nil { @@ -1680,16 +3081,47 @@ func (m *DeleteRangeResponse) GetError() string { } type RawDeleteRangeRequest struct { - Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` - StartKey []byte `protobuf:"bytes,2,opt,name=start_key,json=startKey,proto3" json:"start_key,omitempty"` - EndKey []byte `protobuf:"bytes,3,opt,name=end_key,json=endKey,proto3" json:"end_key,omitempty"` - Cf string `protobuf:"bytes,4,opt,name=cf,proto3" json:"cf,omitempty"` + Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` + StartKey []byte `protobuf:"bytes,2,opt,name=start_key,json=startKey,proto3" json:"start_key,omitempty"` + EndKey []byte `protobuf:"bytes,3,opt,name=end_key,json=endKey,proto3" json:"end_key,omitempty"` + Cf string `protobuf:"bytes,4,opt,name=cf,proto3" json:"cf,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RawDeleteRangeRequest) Reset() { *m = RawDeleteRangeRequest{} } +func (m *RawDeleteRangeRequest) String() string { return proto.CompactTextString(m) } +func (*RawDeleteRangeRequest) ProtoMessage() {} +func (*RawDeleteRangeRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{47} +} +func (m *RawDeleteRangeRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RawDeleteRangeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RawDeleteRangeRequest.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 *RawDeleteRangeRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_RawDeleteRangeRequest.Merge(dst, src) +} +func (m *RawDeleteRangeRequest) XXX_Size() int { + return m.Size() +} +func (m *RawDeleteRangeRequest) XXX_DiscardUnknown() { + xxx_messageInfo_RawDeleteRangeRequest.DiscardUnknown(m) } -func (m *RawDeleteRangeRequest) Reset() { *m = RawDeleteRangeRequest{} } -func (m *RawDeleteRangeRequest) String() string { return proto.CompactTextString(m) } -func (*RawDeleteRangeRequest) ProtoMessage() {} -func (*RawDeleteRangeRequest) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{47} } +var xxx_messageInfo_RawDeleteRangeRequest proto.InternalMessageInfo func (m *RawDeleteRangeRequest) GetContext() *Context { if m != nil { @@ -1720,14 +3152,45 @@ func (m *RawDeleteRangeRequest) GetCf() string { } type RawDeleteRangeResponse struct { - RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` - Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"` + RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` + Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RawDeleteRangeResponse) Reset() { *m = RawDeleteRangeResponse{} } +func (m *RawDeleteRangeResponse) String() string { return proto.CompactTextString(m) } +func (*RawDeleteRangeResponse) ProtoMessage() {} +func (*RawDeleteRangeResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{48} +} +func (m *RawDeleteRangeResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RawDeleteRangeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RawDeleteRangeResponse.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 *RawDeleteRangeResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_RawDeleteRangeResponse.Merge(dst, src) +} +func (m *RawDeleteRangeResponse) XXX_Size() int { + return m.Size() +} +func (m *RawDeleteRangeResponse) XXX_DiscardUnknown() { + xxx_messageInfo_RawDeleteRangeResponse.DiscardUnknown(m) } -func (m *RawDeleteRangeResponse) Reset() { *m = RawDeleteRangeResponse{} } -func (m *RawDeleteRangeResponse) String() string { return proto.CompactTextString(m) } -func (*RawDeleteRangeResponse) ProtoMessage() {} -func (*RawDeleteRangeResponse) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{48} } +var xxx_messageInfo_RawDeleteRangeResponse proto.InternalMessageInfo func (m *RawDeleteRangeResponse) GetRegionError() *errorpb.Error { if m != nil { @@ -1744,17 +3207,49 @@ func (m *RawDeleteRangeResponse) GetError() string { } type RawScanRequest struct { - Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` - StartKey []byte `protobuf:"bytes,2,opt,name=start_key,json=startKey,proto3" json:"start_key,omitempty"` - Limit uint32 `protobuf:"varint,3,opt,name=limit,proto3" json:"limit,omitempty"` - KeyOnly bool `protobuf:"varint,4,opt,name=key_only,json=keyOnly,proto3" json:"key_only,omitempty"` - Cf string `protobuf:"bytes,5,opt,name=cf,proto3" json:"cf,omitempty"` + Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` + StartKey []byte `protobuf:"bytes,2,opt,name=start_key,json=startKey,proto3" json:"start_key,omitempty"` + Limit uint32 `protobuf:"varint,3,opt,name=limit,proto3" json:"limit,omitempty"` + KeyOnly bool `protobuf:"varint,4,opt,name=key_only,json=keyOnly,proto3" json:"key_only,omitempty"` + Cf string `protobuf:"bytes,5,opt,name=cf,proto3" json:"cf,omitempty"` + Reverse bool `protobuf:"varint,6,opt,name=reverse,proto3" json:"reverse,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RawScanRequest) Reset() { *m = RawScanRequest{} } +func (m *RawScanRequest) String() string { return proto.CompactTextString(m) } +func (*RawScanRequest) ProtoMessage() {} +func (*RawScanRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{49} +} +func (m *RawScanRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RawScanRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RawScanRequest.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 *RawScanRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_RawScanRequest.Merge(dst, src) +} +func (m *RawScanRequest) XXX_Size() int { + return m.Size() +} +func (m *RawScanRequest) XXX_DiscardUnknown() { + xxx_messageInfo_RawScanRequest.DiscardUnknown(m) } -func (m *RawScanRequest) Reset() { *m = RawScanRequest{} } -func (m *RawScanRequest) String() string { return proto.CompactTextString(m) } -func (*RawScanRequest) ProtoMessage() {} -func (*RawScanRequest) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{49} } +var xxx_messageInfo_RawScanRequest proto.InternalMessageInfo func (m *RawScanRequest) GetContext() *Context { if m != nil { @@ -1791,15 +3286,53 @@ func (m *RawScanRequest) GetCf() string { return "" } +func (m *RawScanRequest) GetReverse() bool { + if m != nil { + return m.Reverse + } + return false +} + type RawScanResponse struct { - RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` - Kvs []*KvPair `protobuf:"bytes,2,rep,name=kvs" json:"kvs,omitempty"` + RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` + Kvs []*KvPair `protobuf:"bytes,2,rep,name=kvs" json:"kvs,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RawScanResponse) Reset() { *m = RawScanResponse{} } +func (m *RawScanResponse) String() string { return proto.CompactTextString(m) } +func (*RawScanResponse) ProtoMessage() {} +func (*RawScanResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{50} +} +func (m *RawScanResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RawScanResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RawScanResponse.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 *RawScanResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_RawScanResponse.Merge(dst, src) +} +func (m *RawScanResponse) XXX_Size() int { + return m.Size() +} +func (m *RawScanResponse) XXX_DiscardUnknown() { + xxx_messageInfo_RawScanResponse.DiscardUnknown(m) } -func (m *RawScanResponse) Reset() { *m = RawScanResponse{} } -func (m *RawScanResponse) String() string { return proto.CompactTextString(m) } -func (*RawScanResponse) ProtoMessage() {} -func (*RawScanResponse) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{50} } +var xxx_messageInfo_RawScanResponse proto.InternalMessageInfo func (m *RawScanResponse) GetRegionError() *errorpb.Error { if m != nil { @@ -1816,14 +3349,45 @@ func (m *RawScanResponse) GetKvs() []*KvPair { } type KeyRange struct { - StartKey []byte `protobuf:"bytes,1,opt,name=start_key,json=startKey,proto3" json:"start_key,omitempty"` - EndKey []byte `protobuf:"bytes,2,opt,name=end_key,json=endKey,proto3" json:"end_key,omitempty"` + StartKey []byte `protobuf:"bytes,1,opt,name=start_key,json=startKey,proto3" json:"start_key,omitempty"` + EndKey []byte `protobuf:"bytes,2,opt,name=end_key,json=endKey,proto3" json:"end_key,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +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_kvrpcpb_6c0dc0628fd5a3f8, []int{51} +} +func (m *KeyRange) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *KeyRange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_KeyRange.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 *KeyRange) XXX_Merge(src proto.Message) { + xxx_messageInfo_KeyRange.Merge(dst, src) +} +func (m *KeyRange) XXX_Size() int { + return m.Size() +} +func (m *KeyRange) XXX_DiscardUnknown() { + xxx_messageInfo_KeyRange.DiscardUnknown(m) } -func (m *KeyRange) Reset() { *m = KeyRange{} } -func (m *KeyRange) String() string { return proto.CompactTextString(m) } -func (*KeyRange) ProtoMessage() {} -func (*KeyRange) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{51} } +var xxx_messageInfo_KeyRange proto.InternalMessageInfo func (m *KeyRange) GetStartKey() []byte { if m != nil { @@ -1840,17 +3404,49 @@ func (m *KeyRange) GetEndKey() []byte { } type RawBatchScanRequest struct { - Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` - Ranges []*KeyRange `protobuf:"bytes,2,rep,name=ranges" json:"ranges,omitempty"` - EachLimit uint32 `protobuf:"varint,3,opt,name=each_limit,json=eachLimit,proto3" json:"each_limit,omitempty"` - KeyOnly bool `protobuf:"varint,4,opt,name=key_only,json=keyOnly,proto3" json:"key_only,omitempty"` - Cf string `protobuf:"bytes,5,opt,name=cf,proto3" json:"cf,omitempty"` + Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` + Ranges []*KeyRange `protobuf:"bytes,2,rep,name=ranges" json:"ranges,omitempty"` + EachLimit uint32 `protobuf:"varint,3,opt,name=each_limit,json=eachLimit,proto3" json:"each_limit,omitempty"` + KeyOnly bool `protobuf:"varint,4,opt,name=key_only,json=keyOnly,proto3" json:"key_only,omitempty"` + Cf string `protobuf:"bytes,5,opt,name=cf,proto3" json:"cf,omitempty"` + Reverse bool `protobuf:"varint,6,opt,name=reverse,proto3" json:"reverse,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RawBatchScanRequest) Reset() { *m = RawBatchScanRequest{} } +func (m *RawBatchScanRequest) String() string { return proto.CompactTextString(m) } +func (*RawBatchScanRequest) ProtoMessage() {} +func (*RawBatchScanRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{52} +} +func (m *RawBatchScanRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RawBatchScanRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RawBatchScanRequest.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 *RawBatchScanRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_RawBatchScanRequest.Merge(dst, src) +} +func (m *RawBatchScanRequest) XXX_Size() int { + return m.Size() +} +func (m *RawBatchScanRequest) XXX_DiscardUnknown() { + xxx_messageInfo_RawBatchScanRequest.DiscardUnknown(m) } -func (m *RawBatchScanRequest) Reset() { *m = RawBatchScanRequest{} } -func (m *RawBatchScanRequest) String() string { return proto.CompactTextString(m) } -func (*RawBatchScanRequest) ProtoMessage() {} -func (*RawBatchScanRequest) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{52} } +var xxx_messageInfo_RawBatchScanRequest proto.InternalMessageInfo func (m *RawBatchScanRequest) GetContext() *Context { if m != nil { @@ -1887,15 +3483,53 @@ func (m *RawBatchScanRequest) GetCf() string { return "" } +func (m *RawBatchScanRequest) GetReverse() bool { + if m != nil { + return m.Reverse + } + return false +} + type RawBatchScanResponse struct { - RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` - Kvs []*KvPair `protobuf:"bytes,2,rep,name=kvs" json:"kvs,omitempty"` + RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` + Kvs []*KvPair `protobuf:"bytes,2,rep,name=kvs" json:"kvs,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RawBatchScanResponse) Reset() { *m = RawBatchScanResponse{} } +func (m *RawBatchScanResponse) String() string { return proto.CompactTextString(m) } +func (*RawBatchScanResponse) ProtoMessage() {} +func (*RawBatchScanResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{53} +} +func (m *RawBatchScanResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RawBatchScanResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RawBatchScanResponse.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 *RawBatchScanResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_RawBatchScanResponse.Merge(dst, src) +} +func (m *RawBatchScanResponse) XXX_Size() int { + return m.Size() +} +func (m *RawBatchScanResponse) XXX_DiscardUnknown() { + xxx_messageInfo_RawBatchScanResponse.DiscardUnknown(m) } -func (m *RawBatchScanResponse) Reset() { *m = RawBatchScanResponse{} } -func (m *RawBatchScanResponse) String() string { return proto.CompactTextString(m) } -func (*RawBatchScanResponse) ProtoMessage() {} -func (*RawBatchScanResponse) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{53} } +var xxx_messageInfo_RawBatchScanResponse proto.InternalMessageInfo func (m *RawBatchScanResponse) GetRegionError() *errorpb.Error { if m != nil { @@ -1912,16 +3546,47 @@ func (m *RawBatchScanResponse) GetKvs() []*KvPair { } type MvccWrite struct { - Type Op `protobuf:"varint,1,opt,name=type,proto3,enum=kvrpcpb.Op" json:"type,omitempty"` - StartTs uint64 `protobuf:"varint,2,opt,name=start_ts,json=startTs,proto3" json:"start_ts,omitempty"` - CommitTs uint64 `protobuf:"varint,3,opt,name=commit_ts,json=commitTs,proto3" json:"commit_ts,omitempty"` - ShortValue []byte `protobuf:"bytes,4,opt,name=short_value,json=shortValue,proto3" json:"short_value,omitempty"` + Type Op `protobuf:"varint,1,opt,name=type,proto3,enum=kvrpcpb.Op" json:"type,omitempty"` + StartTs uint64 `protobuf:"varint,2,opt,name=start_ts,json=startTs,proto3" json:"start_ts,omitempty"` + CommitTs uint64 `protobuf:"varint,3,opt,name=commit_ts,json=commitTs,proto3" json:"commit_ts,omitempty"` + ShortValue []byte `protobuf:"bytes,4,opt,name=short_value,json=shortValue,proto3" json:"short_value,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *MvccWrite) Reset() { *m = MvccWrite{} } +func (m *MvccWrite) String() string { return proto.CompactTextString(m) } +func (*MvccWrite) ProtoMessage() {} +func (*MvccWrite) Descriptor() ([]byte, []int) { + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{54} +} +func (m *MvccWrite) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MvccWrite) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MvccWrite.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 *MvccWrite) XXX_Merge(src proto.Message) { + xxx_messageInfo_MvccWrite.Merge(dst, src) +} +func (m *MvccWrite) XXX_Size() int { + return m.Size() +} +func (m *MvccWrite) XXX_DiscardUnknown() { + xxx_messageInfo_MvccWrite.DiscardUnknown(m) } -func (m *MvccWrite) Reset() { *m = MvccWrite{} } -func (m *MvccWrite) String() string { return proto.CompactTextString(m) } -func (*MvccWrite) ProtoMessage() {} -func (*MvccWrite) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{54} } +var xxx_messageInfo_MvccWrite proto.InternalMessageInfo func (m *MvccWrite) GetType() Op { if m != nil { @@ -1952,14 +3617,45 @@ func (m *MvccWrite) GetShortValue() []byte { } type MvccValue struct { - StartTs uint64 `protobuf:"varint,1,opt,name=start_ts,json=startTs,proto3" json:"start_ts,omitempty"` - Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` + StartTs uint64 `protobuf:"varint,1,opt,name=start_ts,json=startTs,proto3" json:"start_ts,omitempty"` + Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *MvccValue) Reset() { *m = MvccValue{} } +func (m *MvccValue) String() string { return proto.CompactTextString(m) } +func (*MvccValue) ProtoMessage() {} +func (*MvccValue) Descriptor() ([]byte, []int) { + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{55} +} +func (m *MvccValue) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MvccValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MvccValue.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 *MvccValue) XXX_Merge(src proto.Message) { + xxx_messageInfo_MvccValue.Merge(dst, src) +} +func (m *MvccValue) XXX_Size() int { + return m.Size() +} +func (m *MvccValue) XXX_DiscardUnknown() { + xxx_messageInfo_MvccValue.DiscardUnknown(m) } -func (m *MvccValue) Reset() { *m = MvccValue{} } -func (m *MvccValue) String() string { return proto.CompactTextString(m) } -func (*MvccValue) ProtoMessage() {} -func (*MvccValue) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{55} } +var xxx_messageInfo_MvccValue proto.InternalMessageInfo func (m *MvccValue) GetStartTs() uint64 { if m != nil { @@ -1976,16 +3672,47 @@ func (m *MvccValue) GetValue() []byte { } type MvccLock struct { - Type Op `protobuf:"varint,1,opt,name=type,proto3,enum=kvrpcpb.Op" json:"type,omitempty"` - StartTs uint64 `protobuf:"varint,2,opt,name=start_ts,json=startTs,proto3" json:"start_ts,omitempty"` - Primary []byte `protobuf:"bytes,3,opt,name=primary,proto3" json:"primary,omitempty"` - ShortValue []byte `protobuf:"bytes,4,opt,name=short_value,json=shortValue,proto3" json:"short_value,omitempty"` + Type Op `protobuf:"varint,1,opt,name=type,proto3,enum=kvrpcpb.Op" json:"type,omitempty"` + StartTs uint64 `protobuf:"varint,2,opt,name=start_ts,json=startTs,proto3" json:"start_ts,omitempty"` + Primary []byte `protobuf:"bytes,3,opt,name=primary,proto3" json:"primary,omitempty"` + ShortValue []byte `protobuf:"bytes,4,opt,name=short_value,json=shortValue,proto3" json:"short_value,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *MvccLock) Reset() { *m = MvccLock{} } +func (m *MvccLock) String() string { return proto.CompactTextString(m) } +func (*MvccLock) ProtoMessage() {} +func (*MvccLock) Descriptor() ([]byte, []int) { + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{56} +} +func (m *MvccLock) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MvccLock) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MvccLock.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 *MvccLock) XXX_Merge(src proto.Message) { + xxx_messageInfo_MvccLock.Merge(dst, src) +} +func (m *MvccLock) XXX_Size() int { + return m.Size() +} +func (m *MvccLock) XXX_DiscardUnknown() { + xxx_messageInfo_MvccLock.DiscardUnknown(m) } -func (m *MvccLock) Reset() { *m = MvccLock{} } -func (m *MvccLock) String() string { return proto.CompactTextString(m) } -func (*MvccLock) ProtoMessage() {} -func (*MvccLock) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{56} } +var xxx_messageInfo_MvccLock proto.InternalMessageInfo func (m *MvccLock) GetType() Op { if m != nil { @@ -2016,15 +3743,46 @@ func (m *MvccLock) GetShortValue() []byte { } type MvccInfo struct { - Lock *MvccLock `protobuf:"bytes,1,opt,name=lock" json:"lock,omitempty"` - Writes []*MvccWrite `protobuf:"bytes,2,rep,name=writes" json:"writes,omitempty"` - Values []*MvccValue `protobuf:"bytes,3,rep,name=values" json:"values,omitempty"` + Lock *MvccLock `protobuf:"bytes,1,opt,name=lock" json:"lock,omitempty"` + Writes []*MvccWrite `protobuf:"bytes,2,rep,name=writes" json:"writes,omitempty"` + Values []*MvccValue `protobuf:"bytes,3,rep,name=values" json:"values,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *MvccInfo) Reset() { *m = MvccInfo{} } +func (m *MvccInfo) String() string { return proto.CompactTextString(m) } +func (*MvccInfo) ProtoMessage() {} +func (*MvccInfo) Descriptor() ([]byte, []int) { + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{57} +} +func (m *MvccInfo) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MvccInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MvccInfo.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 *MvccInfo) XXX_Merge(src proto.Message) { + xxx_messageInfo_MvccInfo.Merge(dst, src) +} +func (m *MvccInfo) XXX_Size() int { + return m.Size() +} +func (m *MvccInfo) XXX_DiscardUnknown() { + xxx_messageInfo_MvccInfo.DiscardUnknown(m) } -func (m *MvccInfo) Reset() { *m = MvccInfo{} } -func (m *MvccInfo) String() string { return proto.CompactTextString(m) } -func (*MvccInfo) ProtoMessage() {} -func (*MvccInfo) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{57} } +var xxx_messageInfo_MvccInfo proto.InternalMessageInfo func (m *MvccInfo) GetLock() *MvccLock { if m != nil { @@ -2048,14 +3806,45 @@ func (m *MvccInfo) GetValues() []*MvccValue { } type MvccGetByKeyRequest struct { - Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` - Key []byte `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` + Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` + Key []byte `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *MvccGetByKeyRequest) Reset() { *m = MvccGetByKeyRequest{} } +func (m *MvccGetByKeyRequest) String() string { return proto.CompactTextString(m) } +func (*MvccGetByKeyRequest) ProtoMessage() {} +func (*MvccGetByKeyRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{58} +} +func (m *MvccGetByKeyRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MvccGetByKeyRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MvccGetByKeyRequest.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 *MvccGetByKeyRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_MvccGetByKeyRequest.Merge(dst, src) +} +func (m *MvccGetByKeyRequest) XXX_Size() int { + return m.Size() +} +func (m *MvccGetByKeyRequest) XXX_DiscardUnknown() { + xxx_messageInfo_MvccGetByKeyRequest.DiscardUnknown(m) } -func (m *MvccGetByKeyRequest) Reset() { *m = MvccGetByKeyRequest{} } -func (m *MvccGetByKeyRequest) String() string { return proto.CompactTextString(m) } -func (*MvccGetByKeyRequest) ProtoMessage() {} -func (*MvccGetByKeyRequest) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{58} } +var xxx_messageInfo_MvccGetByKeyRequest proto.InternalMessageInfo func (m *MvccGetByKeyRequest) GetContext() *Context { if m != nil { @@ -2072,15 +3861,46 @@ func (m *MvccGetByKeyRequest) GetKey() []byte { } type MvccGetByKeyResponse struct { - RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` - Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"` - Info *MvccInfo `protobuf:"bytes,3,opt,name=info" json:"info,omitempty"` + RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` + Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"` + Info *MvccInfo `protobuf:"bytes,3,opt,name=info" json:"info,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *MvccGetByKeyResponse) Reset() { *m = MvccGetByKeyResponse{} } +func (m *MvccGetByKeyResponse) String() string { return proto.CompactTextString(m) } +func (*MvccGetByKeyResponse) ProtoMessage() {} +func (*MvccGetByKeyResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{59} +} +func (m *MvccGetByKeyResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MvccGetByKeyResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MvccGetByKeyResponse.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 *MvccGetByKeyResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MvccGetByKeyResponse.Merge(dst, src) +} +func (m *MvccGetByKeyResponse) XXX_Size() int { + return m.Size() +} +func (m *MvccGetByKeyResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MvccGetByKeyResponse.DiscardUnknown(m) } -func (m *MvccGetByKeyResponse) Reset() { *m = MvccGetByKeyResponse{} } -func (m *MvccGetByKeyResponse) String() string { return proto.CompactTextString(m) } -func (*MvccGetByKeyResponse) ProtoMessage() {} -func (*MvccGetByKeyResponse) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{59} } +var xxx_messageInfo_MvccGetByKeyResponse proto.InternalMessageInfo func (m *MvccGetByKeyResponse) GetRegionError() *errorpb.Error { if m != nil { @@ -2104,14 +3924,45 @@ func (m *MvccGetByKeyResponse) GetInfo() *MvccInfo { } type MvccGetByStartTsRequest struct { - Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` - StartTs uint64 `protobuf:"varint,2,opt,name=start_ts,json=startTs,proto3" json:"start_ts,omitempty"` + Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` + StartTs uint64 `protobuf:"varint,2,opt,name=start_ts,json=startTs,proto3" json:"start_ts,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *MvccGetByStartTsRequest) Reset() { *m = MvccGetByStartTsRequest{} } +func (m *MvccGetByStartTsRequest) String() string { return proto.CompactTextString(m) } +func (*MvccGetByStartTsRequest) ProtoMessage() {} +func (*MvccGetByStartTsRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{60} +} +func (m *MvccGetByStartTsRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MvccGetByStartTsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MvccGetByStartTsRequest.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 *MvccGetByStartTsRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_MvccGetByStartTsRequest.Merge(dst, src) +} +func (m *MvccGetByStartTsRequest) XXX_Size() int { + return m.Size() +} +func (m *MvccGetByStartTsRequest) XXX_DiscardUnknown() { + xxx_messageInfo_MvccGetByStartTsRequest.DiscardUnknown(m) } -func (m *MvccGetByStartTsRequest) Reset() { *m = MvccGetByStartTsRequest{} } -func (m *MvccGetByStartTsRequest) String() string { return proto.CompactTextString(m) } -func (*MvccGetByStartTsRequest) ProtoMessage() {} -func (*MvccGetByStartTsRequest) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{60} } +var xxx_messageInfo_MvccGetByStartTsRequest proto.InternalMessageInfo func (m *MvccGetByStartTsRequest) GetContext() *Context { if m != nil { @@ -2128,16 +3979,47 @@ func (m *MvccGetByStartTsRequest) GetStartTs() uint64 { } type MvccGetByStartTsResponse struct { - RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` - Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"` - Key []byte `protobuf:"bytes,3,opt,name=key,proto3" json:"key,omitempty"` - Info *MvccInfo `protobuf:"bytes,4,opt,name=info" json:"info,omitempty"` + RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` + Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"` + Key []byte `protobuf:"bytes,3,opt,name=key,proto3" json:"key,omitempty"` + Info *MvccInfo `protobuf:"bytes,4,opt,name=info" json:"info,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *MvccGetByStartTsResponse) Reset() { *m = MvccGetByStartTsResponse{} } +func (m *MvccGetByStartTsResponse) String() string { return proto.CompactTextString(m) } +func (*MvccGetByStartTsResponse) ProtoMessage() {} +func (*MvccGetByStartTsResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{61} +} +func (m *MvccGetByStartTsResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MvccGetByStartTsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MvccGetByStartTsResponse.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 *MvccGetByStartTsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MvccGetByStartTsResponse.Merge(dst, src) +} +func (m *MvccGetByStartTsResponse) XXX_Size() int { + return m.Size() +} +func (m *MvccGetByStartTsResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MvccGetByStartTsResponse.DiscardUnknown(m) } -func (m *MvccGetByStartTsResponse) Reset() { *m = MvccGetByStartTsResponse{} } -func (m *MvccGetByStartTsResponse) String() string { return proto.CompactTextString(m) } -func (*MvccGetByStartTsResponse) ProtoMessage() {} -func (*MvccGetByStartTsResponse) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{61} } +var xxx_messageInfo_MvccGetByStartTsResponse proto.InternalMessageInfo func (m *MvccGetByStartTsResponse) GetRegionError() *errorpb.Error { if m != nil { @@ -2168,14 +4050,45 @@ func (m *MvccGetByStartTsResponse) GetInfo() *MvccInfo { } type SplitRegionRequest struct { - Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` - SplitKey []byte `protobuf:"bytes,2,opt,name=split_key,json=splitKey,proto3" json:"split_key,omitempty"` + Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` + SplitKey []byte `protobuf:"bytes,2,opt,name=split_key,json=splitKey,proto3" json:"split_key,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *SplitRegionRequest) Reset() { *m = SplitRegionRequest{} } +func (m *SplitRegionRequest) String() string { return proto.CompactTextString(m) } +func (*SplitRegionRequest) ProtoMessage() {} +func (*SplitRegionRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{62} +} +func (m *SplitRegionRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SplitRegionRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_SplitRegionRequest.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 *SplitRegionRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_SplitRegionRequest.Merge(dst, src) +} +func (m *SplitRegionRequest) XXX_Size() int { + return m.Size() +} +func (m *SplitRegionRequest) XXX_DiscardUnknown() { + xxx_messageInfo_SplitRegionRequest.DiscardUnknown(m) } -func (m *SplitRegionRequest) Reset() { *m = SplitRegionRequest{} } -func (m *SplitRegionRequest) String() string { return proto.CompactTextString(m) } -func (*SplitRegionRequest) ProtoMessage() {} -func (*SplitRegionRequest) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{62} } +var xxx_messageInfo_SplitRegionRequest proto.InternalMessageInfo func (m *SplitRegionRequest) GetContext() *Context { if m != nil { @@ -2192,15 +4105,46 @@ func (m *SplitRegionRequest) GetSplitKey() []byte { } type SplitRegionResponse struct { - RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` - Left *metapb.Region `protobuf:"bytes,2,opt,name=left" json:"left,omitempty"` - Right *metapb.Region `protobuf:"bytes,3,opt,name=right" json:"right,omitempty"` + RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` + Left *metapb.Region `protobuf:"bytes,2,opt,name=left" json:"left,omitempty"` + Right *metapb.Region `protobuf:"bytes,3,opt,name=right" json:"right,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *SplitRegionResponse) Reset() { *m = SplitRegionResponse{} } +func (m *SplitRegionResponse) String() string { return proto.CompactTextString(m) } +func (*SplitRegionResponse) ProtoMessage() {} +func (*SplitRegionResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{63} +} +func (m *SplitRegionResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SplitRegionResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_SplitRegionResponse.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 *SplitRegionResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_SplitRegionResponse.Merge(dst, src) +} +func (m *SplitRegionResponse) XXX_Size() int { + return m.Size() +} +func (m *SplitRegionResponse) XXX_DiscardUnknown() { + xxx_messageInfo_SplitRegionResponse.DiscardUnknown(m) } -func (m *SplitRegionResponse) Reset() { *m = SplitRegionResponse{} } -func (m *SplitRegionResponse) String() string { return proto.CompactTextString(m) } -func (*SplitRegionResponse) ProtoMessage() {} -func (*SplitRegionResponse) Descriptor() ([]byte, []int) { return fileDescriptorKvrpcpb, []int{63} } +var xxx_messageInfo_SplitRegionResponse proto.InternalMessageInfo func (m *SplitRegionResponse) GetRegionError() *errorpb.Error { if m != nil { @@ -2224,18 +4168,47 @@ func (m *SplitRegionResponse) GetRight() *metapb.Region { } type UnsafeDestroyRangeRequest struct { - Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` - StartKey []byte `protobuf:"bytes,2,opt,name=start_key,json=startKey,proto3" json:"start_key,omitempty"` - EndKey []byte `protobuf:"bytes,3,opt,name=end_key,json=endKey,proto3" json:"end_key,omitempty"` + Context *Context `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` + StartKey []byte `protobuf:"bytes,2,opt,name=start_key,json=startKey,proto3" json:"start_key,omitempty"` + EndKey []byte `protobuf:"bytes,3,opt,name=end_key,json=endKey,proto3" json:"end_key,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *UnsafeDestroyRangeRequest) Reset() { *m = UnsafeDestroyRangeRequest{} } +func (m *UnsafeDestroyRangeRequest) String() string { return proto.CompactTextString(m) } +func (*UnsafeDestroyRangeRequest) ProtoMessage() {} +func (*UnsafeDestroyRangeRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{64} +} +func (m *UnsafeDestroyRangeRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *UnsafeDestroyRangeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_UnsafeDestroyRangeRequest.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 *UnsafeDestroyRangeRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_UnsafeDestroyRangeRequest.Merge(dst, src) +} +func (m *UnsafeDestroyRangeRequest) XXX_Size() int { + return m.Size() } - -func (m *UnsafeDestroyRangeRequest) Reset() { *m = UnsafeDestroyRangeRequest{} } -func (m *UnsafeDestroyRangeRequest) String() string { return proto.CompactTextString(m) } -func (*UnsafeDestroyRangeRequest) ProtoMessage() {} -func (*UnsafeDestroyRangeRequest) Descriptor() ([]byte, []int) { - return fileDescriptorKvrpcpb, []int{64} +func (m *UnsafeDestroyRangeRequest) XXX_DiscardUnknown() { + xxx_messageInfo_UnsafeDestroyRangeRequest.DiscardUnknown(m) } +var xxx_messageInfo_UnsafeDestroyRangeRequest proto.InternalMessageInfo + func (m *UnsafeDestroyRangeRequest) GetContext() *Context { if m != nil { return m.Context @@ -2258,17 +4231,46 @@ func (m *UnsafeDestroyRangeRequest) GetEndKey() []byte { } type UnsafeDestroyRangeResponse struct { - RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` - Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"` + RegionError *errorpb.Error `protobuf:"bytes,1,opt,name=region_error,json=regionError" json:"region_error,omitempty"` + Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } func (m *UnsafeDestroyRangeResponse) Reset() { *m = UnsafeDestroyRangeResponse{} } func (m *UnsafeDestroyRangeResponse) String() string { return proto.CompactTextString(m) } func (*UnsafeDestroyRangeResponse) ProtoMessage() {} func (*UnsafeDestroyRangeResponse) Descriptor() ([]byte, []int) { - return fileDescriptorKvrpcpb, []int{65} + return fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8, []int{65} +} +func (m *UnsafeDestroyRangeResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *UnsafeDestroyRangeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_UnsafeDestroyRangeResponse.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 *UnsafeDestroyRangeResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_UnsafeDestroyRangeResponse.Merge(dst, src) +} +func (m *UnsafeDestroyRangeResponse) XXX_Size() int { + return m.Size() +} +func (m *UnsafeDestroyRangeResponse) XXX_DiscardUnknown() { + xxx_messageInfo_UnsafeDestroyRangeResponse.DiscardUnknown(m) } +var xxx_messageInfo_UnsafeDestroyRangeResponse proto.InternalMessageInfo + func (m *UnsafeDestroyRangeResponse) GetRegionError() *errorpb.Error { if m != nil { return m.RegionError @@ -2391,6 +4393,9 @@ func (m *LockInfo) MarshalTo(dAtA []byte) (int, error) { i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.LockTtl)) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -2441,6 +4446,9 @@ func (m *KeyError) MarshalTo(dAtA []byte) (int, error) { } i += n2 } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -2481,6 +4489,9 @@ func (m *WriteConflict) MarshalTo(dAtA []byte) (int, error) { i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Primary))) i += copy(dAtA[i:], m.Primary) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -2579,6 +4590,9 @@ func (m *Context) MarshalTo(dAtA []byte) (int, error) { } i++ } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -2607,6 +4621,9 @@ func (m *HandleTime) MarshalTo(dAtA []byte) (int, error) { i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.ProcessMs)) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -2635,6 +4652,9 @@ func (m *ScanInfo) MarshalTo(dAtA []byte) (int, error) { i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Processed)) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -2683,6 +4703,9 @@ func (m *ScanDetail) MarshalTo(dAtA []byte) (int, error) { } i += n7 } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -2721,6 +4744,9 @@ func (m *ExecDetails) MarshalTo(dAtA []byte) (int, error) { } i += n9 } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -2760,6 +4786,9 @@ func (m *GetRequest) MarshalTo(dAtA []byte) (int, error) { i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Version)) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -2804,6 +4833,9 @@ func (m *GetResponse) MarshalTo(dAtA []byte) (int, error) { i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Value))) i += copy(dAtA[i:], m.Value) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -2868,6 +4900,15 @@ func (m *ScanRequest) MarshalTo(dAtA []byte) (int, error) { } i++ } + if len(m.EndKey) > 0 { + dAtA[i] = 0x3a + i++ + i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.EndKey))) + i += copy(dAtA[i:], m.EndKey) + } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -2908,6 +4949,9 @@ func (m *KvPair) MarshalTo(dAtA []byte) (int, error) { i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Value))) i += copy(dAtA[i:], m.Value) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -2948,6 +4992,9 @@ func (m *ScanResponse) MarshalTo(dAtA []byte) (int, error) { i += n } } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -2983,6 +5030,9 @@ func (m *Mutation) MarshalTo(dAtA []byte) (int, error) { i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Value))) i += copy(dAtA[i:], m.Value) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -3049,6 +5099,9 @@ func (m *PrewriteRequest) MarshalTo(dAtA []byte) (int, error) { } i++ } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -3089,6 +5142,9 @@ func (m *PrewriteResponse) MarshalTo(dAtA []byte) (int, error) { i += n } } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -3135,6 +5191,9 @@ func (m *CommitRequest) MarshalTo(dAtA []byte) (int, error) { i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.CommitVersion)) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -3173,6 +5232,9 @@ func (m *CommitResponse) MarshalTo(dAtA []byte) (int, error) { } i += n20 } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -3208,6 +5270,9 @@ func (m *ImportRequest) MarshalTo(dAtA []byte) (int, error) { i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.CommitVersion)) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -3242,6 +5307,9 @@ func (m *ImportResponse) MarshalTo(dAtA []byte) (int, error) { i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Error))) i += copy(dAtA[i:], m.Error) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -3283,6 +5351,9 @@ func (m *BatchRollbackRequest) MarshalTo(dAtA []byte) (int, error) { i += copy(dAtA[i:], b) } } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -3321,6 +5392,9 @@ func (m *BatchRollbackResponse) MarshalTo(dAtA []byte) (int, error) { } i += n24 } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -3360,6 +5434,9 @@ func (m *CleanupRequest) MarshalTo(dAtA []byte) (int, error) { i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.StartVersion)) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -3403,6 +5480,9 @@ func (m *CleanupResponse) MarshalTo(dAtA []byte) (int, error) { i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.CommitVersion)) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -3444,6 +5524,9 @@ func (m *BatchGetRequest) MarshalTo(dAtA []byte) (int, error) { i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Version)) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -3484,6 +5567,9 @@ func (m *BatchGetResponse) MarshalTo(dAtA []byte) (int, error) { i += n } } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -3528,6 +5614,9 @@ func (m *ScanLockRequest) MarshalTo(dAtA []byte) (int, error) { i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Limit)) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -3578,6 +5667,9 @@ func (m *ScanLockResponse) MarshalTo(dAtA []byte) (int, error) { i += n } } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -3606,6 +5698,9 @@ func (m *TxnInfo) MarshalTo(dAtA []byte) (int, error) { i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.Status)) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -3656,6 +5751,9 @@ func (m *ResolveLockRequest) MarshalTo(dAtA []byte) (int, error) { i += n } } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -3694,6 +5792,9 @@ func (m *ResolveLockResponse) MarshalTo(dAtA []byte) (int, error) { } i += n35 } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -3727,6 +5828,9 @@ func (m *GCRequest) MarshalTo(dAtA []byte) (int, error) { i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.SafePoint)) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -3765,6 +5869,9 @@ func (m *GCResponse) MarshalTo(dAtA []byte) (int, error) { } i += n38 } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -3805,6 +5912,9 @@ func (m *RawGetRequest) MarshalTo(dAtA []byte) (int, error) { i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Cf))) i += copy(dAtA[i:], m.Cf) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -3845,6 +5955,9 @@ func (m *RawGetResponse) MarshalTo(dAtA []byte) (int, error) { i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Value))) i += copy(dAtA[i:], m.Value) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -3891,6 +6004,9 @@ func (m *RawPutRequest) MarshalTo(dAtA []byte) (int, error) { i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Cf))) i += copy(dAtA[i:], m.Cf) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -3925,6 +6041,9 @@ func (m *RawPutResponse) MarshalTo(dAtA []byte) (int, error) { i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Error))) i += copy(dAtA[i:], m.Error) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -3971,6 +6090,9 @@ func (m *RawBatchPutRequest) MarshalTo(dAtA []byte) (int, error) { i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Cf))) i += copy(dAtA[i:], m.Cf) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -4005,6 +6127,9 @@ func (m *RawBatchPutResponse) MarshalTo(dAtA []byte) (int, error) { i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Error))) i += copy(dAtA[i:], m.Error) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -4047,6 +6172,9 @@ func (m *RawBatchGetRequest) MarshalTo(dAtA []byte) (int, error) { i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Cf))) i += copy(dAtA[i:], m.Cf) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -4087,6 +6215,9 @@ func (m *RawBatchGetResponse) MarshalTo(dAtA []byte) (int, error) { i += n } } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -4127,6 +6258,9 @@ func (m *RawDeleteRequest) MarshalTo(dAtA []byte) (int, error) { i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Cf))) i += copy(dAtA[i:], m.Cf) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -4161,6 +6295,9 @@ func (m *RawDeleteResponse) MarshalTo(dAtA []byte) (int, error) { i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Error))) i += copy(dAtA[i:], m.Error) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -4203,6 +6340,9 @@ func (m *RawBatchDeleteRequest) MarshalTo(dAtA []byte) (int, error) { i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Cf))) i += copy(dAtA[i:], m.Cf) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -4237,6 +6377,9 @@ func (m *RawBatchDeleteResponse) MarshalTo(dAtA []byte) (int, error) { i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Error))) i += copy(dAtA[i:], m.Error) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -4277,6 +6420,9 @@ func (m *DeleteRangeRequest) MarshalTo(dAtA []byte) (int, error) { i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.EndKey))) i += copy(dAtA[i:], m.EndKey) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -4311,6 +6457,9 @@ func (m *DeleteRangeResponse) MarshalTo(dAtA []byte) (int, error) { i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Error))) i += copy(dAtA[i:], m.Error) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -4357,6 +6506,9 @@ func (m *RawDeleteRangeRequest) MarshalTo(dAtA []byte) (int, error) { i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Cf))) i += copy(dAtA[i:], m.Cf) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -4391,6 +6543,9 @@ func (m *RawDeleteRangeResponse) MarshalTo(dAtA []byte) (int, error) { i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Error))) i += copy(dAtA[i:], m.Error) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -4446,6 +6601,19 @@ func (m *RawScanRequest) MarshalTo(dAtA []byte) (int, error) { i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Cf))) i += copy(dAtA[i:], m.Cf) } + if m.Reverse { + dAtA[i] = 0x30 + i++ + if m.Reverse { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i++ + } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -4486,6 +6654,9 @@ func (m *RawScanResponse) MarshalTo(dAtA []byte) (int, error) { i += n } } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -4516,6 +6687,9 @@ func (m *KeyRange) MarshalTo(dAtA []byte) (int, error) { i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.EndKey))) i += copy(dAtA[i:], m.EndKey) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -4577,6 +6751,19 @@ func (m *RawBatchScanRequest) MarshalTo(dAtA []byte) (int, error) { i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Cf))) i += copy(dAtA[i:], m.Cf) } + if m.Reverse { + dAtA[i] = 0x30 + i++ + if m.Reverse { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i++ + } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -4617,6 +6804,9 @@ func (m *RawBatchScanResponse) MarshalTo(dAtA []byte) (int, error) { i += n } } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -4656,6 +6846,9 @@ func (m *MvccWrite) MarshalTo(dAtA []byte) (int, error) { i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.ShortValue))) i += copy(dAtA[i:], m.ShortValue) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -4685,6 +6878,9 @@ func (m *MvccValue) MarshalTo(dAtA []byte) (int, error) { i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Value))) i += copy(dAtA[i:], m.Value) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -4725,6 +6921,9 @@ func (m *MvccLock) MarshalTo(dAtA []byte) (int, error) { i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.ShortValue))) i += copy(dAtA[i:], m.ShortValue) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -4777,6 +6976,9 @@ func (m *MvccInfo) MarshalTo(dAtA []byte) (int, error) { i += n } } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -4811,6 +7013,9 @@ func (m *MvccGetByKeyRequest) MarshalTo(dAtA []byte) (int, error) { i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Key))) i += copy(dAtA[i:], m.Key) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -4855,6 +7060,9 @@ func (m *MvccGetByKeyResponse) MarshalTo(dAtA []byte) (int, error) { } i += n62 } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -4888,6 +7096,9 @@ func (m *MvccGetByStartTsRequest) MarshalTo(dAtA []byte) (int, error) { i++ i = encodeVarintKvrpcpb(dAtA, i, uint64(m.StartTs)) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -4938,6 +7149,9 @@ func (m *MvccGetByStartTsResponse) MarshalTo(dAtA []byte) (int, error) { } i += n65 } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -4972,6 +7186,9 @@ func (m *SplitRegionRequest) MarshalTo(dAtA []byte) (int, error) { i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.SplitKey))) i += copy(dAtA[i:], m.SplitKey) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -5020,6 +7237,9 @@ func (m *SplitRegionResponse) MarshalTo(dAtA []byte) (int, error) { } i += n69 } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -5060,6 +7280,9 @@ func (m *UnsafeDestroyRangeRequest) MarshalTo(dAtA []byte) (int, error) { i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.EndKey))) i += copy(dAtA[i:], m.EndKey) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -5094,27 +7317,12 @@ func (m *UnsafeDestroyRangeResponse) MarshalTo(dAtA []byte) (int, error) { i = encodeVarintKvrpcpb(dAtA, i, uint64(len(m.Error))) i += copy(dAtA[i:], m.Error) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } -func encodeFixed64Kvrpcpb(dAtA []byte, offset int, v uint64) int { - dAtA[offset] = uint8(v) - dAtA[offset+1] = uint8(v >> 8) - dAtA[offset+2] = uint8(v >> 16) - dAtA[offset+3] = uint8(v >> 24) - dAtA[offset+4] = uint8(v >> 32) - dAtA[offset+5] = uint8(v >> 40) - dAtA[offset+6] = uint8(v >> 48) - dAtA[offset+7] = uint8(v >> 56) - return offset + 8 -} -func encodeFixed32Kvrpcpb(dAtA []byte, offset int, v uint32) int { - dAtA[offset] = uint8(v) - dAtA[offset+1] = uint8(v >> 8) - dAtA[offset+2] = uint8(v >> 16) - dAtA[offset+3] = uint8(v >> 24) - return offset + 4 -} func encodeVarintKvrpcpb(dAtA []byte, offset int, v uint64) int { for v >= 1<<7 { dAtA[offset] = uint8(v&0x7f | 0x80) @@ -5141,6 +7349,9 @@ func (m *LockInfo) Size() (n int) { if m.LockTtl != 0 { n += 1 + sovKvrpcpb(uint64(m.LockTtl)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5163,6 +7374,9 @@ func (m *KeyError) Size() (n int) { l = m.Conflict.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5183,6 +7397,9 @@ func (m *WriteConflict) Size() (n int) { if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5221,6 +7438,9 @@ func (m *Context) Size() (n int) { if m.ScanDetail { n += 2 } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5233,6 +7453,9 @@ func (m *HandleTime) Size() (n int) { if m.ProcessMs != 0 { n += 1 + sovKvrpcpb(uint64(m.ProcessMs)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5245,6 +7468,9 @@ func (m *ScanInfo) Size() (n int) { if m.Processed != 0 { n += 1 + sovKvrpcpb(uint64(m.Processed)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5263,6 +7489,9 @@ func (m *ScanDetail) Size() (n int) { l = m.Data.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5277,6 +7506,9 @@ func (m *ExecDetails) Size() (n int) { l = m.ScanDetail.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5294,6 +7526,9 @@ func (m *GetRequest) Size() (n int) { if m.Version != 0 { n += 1 + sovKvrpcpb(uint64(m.Version)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5312,6 +7547,9 @@ func (m *GetResponse) Size() (n int) { if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5338,6 +7576,13 @@ func (m *ScanRequest) Size() (n int) { if m.Reverse { n += 2 } + l = len(m.EndKey) + if l > 0 { + n += 1 + l + sovKvrpcpb(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5356,6 +7601,9 @@ func (m *KvPair) Size() (n int) { if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5372,6 +7620,9 @@ func (m *ScanResponse) Size() (n int) { n += 1 + l + sovKvrpcpb(uint64(l)) } } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5389,6 +7640,9 @@ func (m *Mutation) Size() (n int) { if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5418,6 +7672,9 @@ func (m *PrewriteRequest) Size() (n int) { if m.SkipConstraintCheck { n += 2 } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5434,6 +7691,9 @@ func (m *PrewriteResponse) Size() (n int) { n += 1 + l + sovKvrpcpb(uint64(l)) } } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5456,6 +7716,9 @@ func (m *CommitRequest) Size() (n int) { if m.CommitVersion != 0 { n += 1 + sovKvrpcpb(uint64(m.CommitVersion)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5470,6 +7733,9 @@ func (m *CommitResponse) Size() (n int) { l = m.Error.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5485,6 +7751,9 @@ func (m *ImportRequest) Size() (n int) { if m.CommitVersion != 0 { n += 1 + sovKvrpcpb(uint64(m.CommitVersion)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5499,6 +7768,9 @@ func (m *ImportResponse) Size() (n int) { if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5518,6 +7790,9 @@ func (m *BatchRollbackRequest) Size() (n int) { n += 1 + l + sovKvrpcpb(uint64(l)) } } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5532,6 +7807,9 @@ func (m *BatchRollbackResponse) Size() (n int) { l = m.Error.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5549,6 +7827,9 @@ func (m *CleanupRequest) Size() (n int) { if m.StartVersion != 0 { n += 1 + sovKvrpcpb(uint64(m.StartVersion)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5566,6 +7847,9 @@ func (m *CleanupResponse) Size() (n int) { if m.CommitVersion != 0 { n += 1 + sovKvrpcpb(uint64(m.CommitVersion)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5585,6 +7869,9 @@ func (m *BatchGetRequest) Size() (n int) { if m.Version != 0 { n += 1 + sovKvrpcpb(uint64(m.Version)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5601,6 +7888,9 @@ func (m *BatchGetResponse) Size() (n int) { n += 1 + l + sovKvrpcpb(uint64(l)) } } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5621,6 +7911,9 @@ func (m *ScanLockRequest) Size() (n int) { if m.Limit != 0 { n += 1 + sovKvrpcpb(uint64(m.Limit)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5641,6 +7934,9 @@ func (m *ScanLockResponse) Size() (n int) { n += 1 + l + sovKvrpcpb(uint64(l)) } } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5653,6 +7949,9 @@ func (m *TxnInfo) Size() (n int) { if m.Status != 0 { n += 1 + sovKvrpcpb(uint64(m.Status)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5675,6 +7974,9 @@ func (m *ResolveLockRequest) Size() (n int) { n += 1 + l + sovKvrpcpb(uint64(l)) } } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5689,6 +7991,9 @@ func (m *ResolveLockResponse) Size() (n int) { l = m.Error.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5702,6 +8007,9 @@ func (m *GCRequest) Size() (n int) { if m.SafePoint != 0 { n += 1 + sovKvrpcpb(uint64(m.SafePoint)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5716,6 +8024,9 @@ func (m *GCResponse) Size() (n int) { l = m.Error.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5734,6 +8045,9 @@ func (m *RawGetRequest) Size() (n int) { if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5752,6 +8066,9 @@ func (m *RawGetResponse) Size() (n int) { if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5774,6 +8091,9 @@ func (m *RawPutRequest) Size() (n int) { if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5788,6 +8108,9 @@ func (m *RawPutResponse) Size() (n int) { if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5808,6 +8131,9 @@ func (m *RawBatchPutRequest) Size() (n int) { if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5822,6 +8148,9 @@ func (m *RawBatchPutResponse) Size() (n int) { if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5842,6 +8171,9 @@ func (m *RawBatchGetRequest) Size() (n int) { if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5858,6 +8190,9 @@ func (m *RawBatchGetResponse) Size() (n int) { n += 1 + l + sovKvrpcpb(uint64(l)) } } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5876,6 +8211,9 @@ func (m *RawDeleteRequest) Size() (n int) { if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5890,6 +8228,9 @@ func (m *RawDeleteResponse) Size() (n int) { if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5910,6 +8251,9 @@ func (m *RawBatchDeleteRequest) Size() (n int) { if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5924,6 +8268,9 @@ func (m *RawBatchDeleteResponse) Size() (n int) { if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5942,6 +8289,9 @@ func (m *DeleteRangeRequest) Size() (n int) { if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5956,6 +8306,9 @@ func (m *DeleteRangeResponse) Size() (n int) { if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5978,6 +8331,9 @@ func (m *RawDeleteRangeRequest) Size() (n int) { if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5992,6 +8348,9 @@ func (m *RawDeleteRangeResponse) Size() (n int) { if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -6016,6 +8375,12 @@ func (m *RawScanRequest) Size() (n int) { if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } + if m.Reverse { + n += 2 + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -6032,6 +8397,9 @@ func (m *RawScanResponse) Size() (n int) { n += 1 + l + sovKvrpcpb(uint64(l)) } } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -6046,6 +8414,9 @@ func (m *KeyRange) Size() (n int) { if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -6072,6 +8443,12 @@ func (m *RawBatchScanRequest) Size() (n int) { if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } + if m.Reverse { + n += 2 + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -6088,6 +8465,9 @@ func (m *RawBatchScanResponse) Size() (n int) { n += 1 + l + sovKvrpcpb(uint64(l)) } } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -6107,6 +8487,9 @@ func (m *MvccWrite) Size() (n int) { if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -6120,6 +8503,9 @@ func (m *MvccValue) Size() (n int) { if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -6140,6 +8526,9 @@ func (m *MvccLock) Size() (n int) { if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -6162,6 +8551,9 @@ func (m *MvccInfo) Size() (n int) { n += 1 + l + sovKvrpcpb(uint64(l)) } } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -6176,6 +8568,9 @@ func (m *MvccGetByKeyRequest) Size() (n int) { if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -6194,6 +8589,9 @@ func (m *MvccGetByKeyResponse) Size() (n int) { l = m.Info.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -6207,6 +8605,9 @@ func (m *MvccGetByStartTsRequest) Size() (n int) { if m.StartTs != 0 { n += 1 + sovKvrpcpb(uint64(m.StartTs)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -6229,6 +8630,9 @@ func (m *MvccGetByStartTsResponse) Size() (n int) { l = m.Info.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -6243,6 +8647,9 @@ func (m *SplitRegionRequest) Size() (n int) { if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -6261,6 +8668,9 @@ func (m *SplitRegionResponse) Size() (n int) { l = m.Right.Size() n += 1 + l + sovKvrpcpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -6279,6 +8689,9 @@ func (m *UnsafeDestroyRangeRequest) Size() (n int) { if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -6293,6 +8706,9 @@ func (m *UnsafeDestroyRangeResponse) Size() (n int) { if l > 0 { n += 1 + l + sovKvrpcpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -6450,6 +8866,7 @@ func (m *LockInfo) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -6624,6 +9041,7 @@ func (m *KeyError) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -6774,6 +9192,7 @@ func (m *WriteConflict) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -7046,6 +9465,7 @@ func (m *Context) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -7134,6 +9554,7 @@ func (m *HandleTime) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -7222,6 +9643,7 @@ func (m *ScanInfo) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -7371,6 +9793,7 @@ func (m *ScanDetail) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -7487,6 +9910,7 @@ func (m *ExecDetails) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -7620,6 +10044,7 @@ func (m *GetRequest) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -7767,6 +10192,7 @@ func (m *GetResponse) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -7947,6 +10373,37 @@ func (m *ScanRequest) Unmarshal(dAtA []byte) error { } } m.Reverse = bool(v != 0) + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EndKey", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowKvrpcpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthKvrpcpb + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.EndKey = append(m.EndKey[:0], dAtA[iNdEx:postIndex]...) + if m.EndKey == nil { + m.EndKey = []byte{} + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) @@ -7959,6 +10416,7 @@ func (m *ScanRequest) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -8104,6 +10562,7 @@ func (m *KvPair) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -8218,6 +10677,7 @@ func (m *ScanResponse) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -8349,6 +10809,7 @@ func (m *Mutation) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -8552,6 +11013,7 @@ func (m *PrewriteRequest) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -8666,6 +11128,7 @@ func (m *PrewriteResponse) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -8816,6 +11279,7 @@ func (m *CommitRequest) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -8932,6 +11396,7 @@ func (m *CommitResponse) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -9032,6 +11497,7 @@ func (m *ImportRequest) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -9144,6 +11610,7 @@ func (m *ImportResponse) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -9275,6 +11742,7 @@ func (m *BatchRollbackRequest) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -9391,6 +11859,7 @@ func (m *BatchRollbackResponse) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -9524,6 +11993,7 @@ func (m *CleanupRequest) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -9659,6 +12129,7 @@ func (m *CleanupResponse) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -9790,6 +12261,7 @@ func (m *BatchGetRequest) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -9904,6 +12376,7 @@ func (m *BatchGetResponse) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -10056,6 +12529,7 @@ func (m *ScanLockRequest) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -10203,6 +12677,7 @@ func (m *ScanLockResponse) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -10291,6 +12766,7 @@ func (m *TxnInfo) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -10443,6 +12919,7 @@ func (m *ResolveLockRequest) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -10559,6 +13036,7 @@ func (m *ResolveLockResponse) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -10661,6 +13139,7 @@ func (m *GCRequest) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -10777,6 +13256,7 @@ func (m *GCResponse) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -10920,6 +13400,7 @@ func (m *RawGetRequest) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -11063,6 +13544,7 @@ func (m *RawGetResponse) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -11237,6 +13719,7 @@ func (m *RawPutRequest) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -11349,6 +13832,7 @@ func (m *RawPutResponse) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -11492,6 +13976,7 @@ func (m *RawBatchPutRequest) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -11604,6 +14089,7 @@ func (m *RawBatchPutResponse) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -11745,6 +14231,7 @@ func (m *RawBatchGetRequest) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -11859,6 +14346,7 @@ func (m *RawBatchGetResponse) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -12002,6 +14490,7 @@ func (m *RawDeleteRequest) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -12114,6 +14603,7 @@ func (m *RawDeleteResponse) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -12255,6 +14745,7 @@ func (m *RawBatchDeleteRequest) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -12367,6 +14858,7 @@ func (m *RawBatchDeleteResponse) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -12512,6 +15004,7 @@ func (m *DeleteRangeRequest) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -12624,6 +15117,7 @@ func (m *DeleteRangeResponse) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -12798,6 +15292,7 @@ func (m *RawDeleteRangeRequest) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -12910,6 +15405,7 @@ func (m *RawDeleteRangeResponse) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -13080,6 +15576,26 @@ func (m *RawScanRequest) Unmarshal(dAtA []byte) error { } m.Cf = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Reverse", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowKvrpcpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Reverse = bool(v != 0) default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) @@ -13092,6 +15608,7 @@ func (m *RawScanRequest) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -13206,6 +15723,7 @@ func (m *RawScanResponse) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -13318,6 +15836,7 @@ func (m *KeyRange) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -13488,6 +16007,26 @@ func (m *RawBatchScanRequest) Unmarshal(dAtA []byte) error { } m.Cf = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Reverse", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowKvrpcpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Reverse = bool(v != 0) default: iNdEx = preIndex skippy, err := skipKvrpcpb(dAtA[iNdEx:]) @@ -13500,6 +16039,7 @@ func (m *RawBatchScanRequest) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -13614,6 +16154,7 @@ func (m *RawBatchScanResponse) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -13752,6 +16293,7 @@ func (m *MvccWrite) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -13852,6 +16394,7 @@ func (m *MvccValue) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -14002,6 +16545,7 @@ func (m *MvccLock) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -14147,6 +16691,7 @@ func (m *MvccInfo) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -14261,6 +16806,7 @@ func (m *MvccGetByKeyRequest) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -14406,6 +16952,7 @@ func (m *MvccGetByKeyResponse) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -14508,6 +17055,7 @@ func (m *MvccGetByStartTsRequest) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -14684,6 +17232,7 @@ func (m *MvccGetByStartTsResponse) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -14798,6 +17347,7 @@ func (m *SplitRegionRequest) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -14947,6 +17497,7 @@ func (m *SplitRegionResponse) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -15092,6 +17643,7 @@ func (m *UnsafeDestroyRangeRequest) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -15204,6 +17756,7 @@ func (m *UnsafeDestroyRangeResponse) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -15318,136 +17871,137 @@ var ( ErrIntOverflowKvrpcpb = fmt.Errorf("proto: integer overflow") ) -func init() { proto.RegisterFile("kvrpcpb.proto", fileDescriptorKvrpcpb) } - -var fileDescriptorKvrpcpb = []byte{ - // 2036 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x5a, 0xef, 0x6e, 0x1b, 0xc7, - 0x11, 0xf7, 0x1d, 0x8f, 0xe4, 0x71, 0x48, 0x51, 0xcc, 0x4a, 0xb6, 0x19, 0xbb, 0xb1, 0x95, 0x6b, - 0x0c, 0xcb, 0x2a, 0x2a, 0xa3, 0x4a, 0xd0, 0x4f, 0x45, 0x11, 0x58, 0x76, 0x1d, 0xc5, 0x72, 0x2d, - 0xac, 0x54, 0x17, 0x06, 0x9a, 0x32, 0xab, 0xe3, 0x8a, 0x3c, 0xf0, 0x78, 0x7b, 0xbe, 0x5b, 0x52, - 0x22, 0x8a, 0xa0, 0x28, 0x8a, 0x14, 0xc8, 0xc7, 0x16, 0x05, 0x5a, 0x14, 0xcd, 0x03, 0xf4, 0x05, - 0xfa, 0xa5, 0x2f, 0xd0, 0x8f, 0x7d, 0x84, 0xc2, 0x7d, 0x91, 0x62, 0xff, 0xdc, 0x1d, 0x8f, 0xa4, - 0x62, 0xf5, 0x4a, 0x29, 0x9f, 0x78, 0x3b, 0x33, 0xbb, 0x33, 0xbf, 0x99, 0xd9, 0xd9, 0x7f, 0x84, - 0x95, 0xc1, 0x38, 0x0a, 0xdd, 0xf0, 0x78, 0x3b, 0x8c, 0x18, 0x67, 0xa8, 0xaa, 0x9b, 0xb7, 0x1a, - 0x43, 0xca, 0x49, 0x42, 0xbe, 0xb5, 0x42, 0xa3, 0x88, 0x45, 0x69, 0x73, 0xbd, 0xc7, 0x7a, 0x4c, - 0x7e, 0x3e, 0x14, 0x5f, 0x8a, 0xea, 0x7c, 0x01, 0xf6, 0x3e, 0x73, 0x07, 0x7b, 0xc1, 0x09, 0x43, - 0xef, 0x43, 0x23, 0x8c, 0xbc, 0x21, 0x89, 0x26, 0x1d, 0x9f, 0xb9, 0x83, 0xb6, 0xb1, 0x61, 0x6c, - 0x36, 0x70, 0x5d, 0xd3, 0x84, 0x98, 0x10, 0x11, 0xac, 0xce, 0x98, 0x46, 0xb1, 0xc7, 0x82, 0xb6, - 0xb9, 0x61, 0x6c, 0x5a, 0xb8, 0x2e, 0x68, 0x2f, 0x15, 0x09, 0xb5, 0xa0, 0x34, 0xa0, 0x93, 0x76, - 0x49, 0x76, 0x16, 0x9f, 0xe8, 0x5d, 0xb0, 0x65, 0x27, 0xce, 0xfd, 0xb6, 0x25, 0x3b, 0x54, 0x45, - 0xfb, 0x88, 0xfb, 0xce, 0xd7, 0x06, 0xd8, 0xcf, 0xe8, 0xe4, 0x89, 0xb0, 0x14, 0x3d, 0x80, 0x8a, - 0xa0, 0xd3, 0xae, 0xd4, 0x5c, 0xdf, 0x79, 0x67, 0x3b, 0xc1, 0x99, 0x98, 0x88, 0xb5, 0x00, 0xfa, - 0x0e, 0xd4, 0x22, 0xca, 0xa3, 0x09, 0x39, 0xf6, 0xa9, 0x34, 0xa2, 0x86, 0x33, 0x02, 0x5a, 0x87, - 0x32, 0x39, 0x66, 0x11, 0x97, 0x46, 0xd4, 0xb0, 0x6a, 0xa0, 0x1d, 0xb0, 0x5d, 0x16, 0x9c, 0xf8, - 0x9e, 0xcb, 0xa5, 0x19, 0xf5, 0x9d, 0x1b, 0xa9, 0x82, 0x9f, 0x47, 0x1e, 0xa7, 0xbb, 0x9a, 0x8b, - 0x53, 0x39, 0xe7, 0x14, 0x56, 0x72, 0x2c, 0x81, 0x25, 0xe6, 0x24, 0xe2, 0x1d, 0x1e, 0x4b, 0x2b, - 0x2d, 0x5c, 0x95, 0xed, 0xa3, 0x18, 0xdd, 0x85, 0x7a, 0xd2, 0x4f, 0x70, 0x95, 0x6b, 0x20, 0x21, - 0x1d, 0xc5, 0x0b, 0x3c, 0xd3, 0x86, 0xaa, 0xf6, 0xae, 0xb4, 0xa8, 0x81, 0x93, 0xa6, 0xf3, 0x75, - 0x09, 0xaa, 0xbb, 0x2c, 0xe0, 0xf4, 0x8c, 0xa3, 0xdb, 0x02, 0x6c, 0xcf, 0x63, 0x41, 0xc7, 0xeb, - 0x6a, 0xa5, 0xb6, 0x22, 0xec, 0x75, 0xd1, 0x0f, 0xa1, 0xa1, 0x99, 0x34, 0x64, 0x6e, 0x5f, 0xaa, - 0xad, 0xef, 0xac, 0x6d, 0xeb, 0x54, 0xc0, 0x92, 0xf7, 0x44, 0xb0, 0x70, 0x3d, 0xca, 0x1a, 0x68, - 0x03, 0xac, 0x90, 0xd2, 0x48, 0x5a, 0x53, 0xdf, 0x69, 0x24, 0xf2, 0x07, 0x94, 0x46, 0x58, 0x72, - 0x10, 0x02, 0x8b, 0xd3, 0x68, 0xd8, 0x2e, 0x4b, 0x8d, 0xf2, 0x1b, 0x3d, 0x04, 0x3b, 0x8c, 0x3c, - 0x16, 0x79, 0x7c, 0xd2, 0xae, 0x6c, 0x18, 0x9b, 0xcd, 0x9d, 0xb5, 0xd4, 0x87, 0xbb, 0x6c, 0x38, - 0x24, 0x41, 0xf7, 0x20, 0xf2, 0x70, 0x2a, 0x84, 0x3e, 0x86, 0x55, 0x2f, 0x66, 0x3e, 0xe1, 0xc2, - 0x42, 0x9f, 0x8e, 0xa9, 0xdf, 0xae, 0xca, 0x7e, 0x37, 0xd3, 0x7e, 0x7b, 0x09, 0x7f, 0x5f, 0xb0, - 0x71, 0xd3, 0xcb, 0xb5, 0xd1, 0x07, 0xd0, 0x0c, 0x18, 0xef, 0x9c, 0x78, 0xbe, 0xdf, 0x71, 0x89, - 0xdb, 0xa7, 0x6d, 0x7b, 0xc3, 0xd8, 0xb4, 0x71, 0x23, 0x60, 0xfc, 0x27, 0x9e, 0xef, 0xef, 0x0a, - 0x9a, 0x8c, 0xcb, 0x24, 0x70, 0x3b, 0x3e, 0xeb, 0xb5, 0x6b, 0x92, 0x5f, 0x15, 0xed, 0x7d, 0xd6, - 0x13, 0x71, 0xe9, 0x93, 0xa0, 0xeb, 0xd3, 0x0e, 0xf7, 0x86, 0xb4, 0x0d, 0x92, 0x0b, 0x8a, 0x74, - 0xe4, 0x0d, 0xa9, 0x10, 0x88, 0x5d, 0x12, 0x74, 0xba, 0x94, 0x13, 0xcf, 0x6f, 0xd7, 0x95, 0x80, - 0x20, 0x3d, 0x96, 0x94, 0x4f, 0x2d, 0xdb, 0x6a, 0x95, 0x85, 0xfb, 0x48, 0xb7, 0xf3, 0x7a, 0xc4, - 0xa2, 0xd1, 0xd0, 0x79, 0x0c, 0xf0, 0x49, 0x36, 0xc2, 0x4d, 0xa8, 0x9e, 0x12, 0x8f, 0x77, 0x86, - 0x2a, 0x29, 0x4a, 0xb8, 0x22, 0x9a, 0xcf, 0x63, 0xf4, 0x1e, 0x40, 0x18, 0x31, 0x97, 0xc6, 0xb1, - 0xe0, 0x99, 0x92, 0x57, 0xd3, 0x94, 0xe7, 0xb1, 0xf3, 0x63, 0xb0, 0x0f, 0x5d, 0x12, 0xc8, 0xd9, - 0xb7, 0x0e, 0x65, 0xce, 0x38, 0xf1, 0xf5, 0x08, 0xaa, 0x21, 0x12, 0x5d, 0x8b, 0xd3, 0xee, 0x4c, - 0x7f, 0xda, 0x75, 0x7e, 0x6b, 0x00, 0x1c, 0xa6, 0x76, 0xa2, 0xfb, 0x50, 0x3e, 0x15, 0xd9, 0x3a, - 0x37, 0x7f, 0x12, 0x25, 0x58, 0xf1, 0xd1, 0x3d, 0xb0, 0xe4, 0x0c, 0x37, 0xcf, 0x93, 0x93, 0x6c, - 0x21, 0xd6, 0x25, 0x9c, 0xe8, 0x1c, 0x59, 0x24, 0x26, 0xd8, 0xce, 0x04, 0xea, 0x4f, 0xce, 0xa8, - 0xab, 0x8c, 0x88, 0xd1, 0x47, 0x79, 0x7f, 0x1b, 0x3a, 0x21, 0x93, 0xce, 0x99, 0xdb, 0x72, 0x41, - 0xf8, 0x28, 0x1f, 0x04, 0x73, 0xa6, 0x57, 0x86, 0x72, 0x3a, 0x32, 0x4e, 0x17, 0xe0, 0x29, 0xe5, - 0x98, 0xbe, 0x1e, 0xd1, 0x98, 0xa3, 0x2d, 0xa8, 0xba, 0x6a, 0xce, 0x68, 0xad, 0xad, 0xa9, 0xe4, - 0x94, 0x74, 0x9c, 0x08, 0x24, 0x93, 0xd1, 0xcc, 0x4d, 0xc6, 0xa4, 0xac, 0x95, 0xd4, 0xcc, 0xd6, - 0x4d, 0xe7, 0xd7, 0x50, 0x97, 0x5a, 0xe2, 0x90, 0x05, 0x31, 0x45, 0x3f, 0xc8, 0xa6, 0x9c, 0xa8, - 0x5b, 0x5a, 0x57, 0x73, 0x3b, 0xa9, 0xb7, 0xb2, 0x9a, 0xa5, 0xb3, 0x4d, 0x96, 0xb6, 0xfb, 0x50, - 0x56, 0xb2, 0xb3, 0x1e, 0x4f, 0x8a, 0x1f, 0x56, 0x7c, 0x91, 0x05, 0x63, 0xe2, 0x8f, 0xa8, 0xae, - 0x12, 0xaa, 0xe1, 0xfc, 0xc3, 0x80, 0xba, 0xf0, 0x40, 0x11, 0xa0, 0xb7, 0xa1, 0xa6, 0x2a, 0x56, - 0x06, 0x57, 0x95, 0xb0, 0x67, 0x74, 0x22, 0xd4, 0xf9, 0xde, 0xd0, 0x53, 0x95, 0x72, 0x05, 0xab, - 0xc6, 0xb4, 0x27, 0xac, 0x9c, 0x27, 0xc4, 0x34, 0x1b, 0xd0, 0x49, 0x87, 0x05, 0xfe, 0x44, 0xd6, - 0x05, 0x1b, 0x57, 0x07, 0x74, 0xf2, 0x22, 0xf0, 0xa5, 0xfb, 0x22, 0x2a, 0xe4, 0xa8, 0xac, 0x0c, - 0x36, 0x4e, 0x9a, 0xce, 0x2b, 0xa8, 0x3c, 0x1b, 0x1f, 0x10, 0x6f, 0xca, 0x0d, 0xc6, 0x5b, 0xdc, - 0x30, 0x1f, 0x9d, 0xc5, 0x8e, 0xe9, 0x43, 0x43, 0xf9, 0xa5, 0x78, 0x68, 0xee, 0x41, 0x39, 0x24, - 0x5e, 0x24, 0x66, 0x67, 0x69, 0xb3, 0xbe, 0xb3, 0x9a, 0xd9, 0x24, 0x6d, 0xc6, 0x8a, 0xeb, 0xbc, - 0x00, 0xfb, 0xf9, 0x88, 0xcb, 0xba, 0x84, 0x6e, 0x83, 0xc9, 0x42, 0x39, 0x76, 0x73, 0xa7, 0x9e, - 0xca, 0xbf, 0x08, 0xb1, 0xc9, 0xc2, 0x0b, 0x9b, 0xfe, 0xa5, 0x09, 0xab, 0x07, 0x11, 0x95, 0x13, - 0xb2, 0x48, 0x5c, 0x1f, 0x42, 0x6d, 0xa8, 0x0d, 0x4a, 0x6c, 0xcf, 0xfc, 0x99, 0x98, 0x8a, 0x33, - 0x99, 0xb9, 0xe5, 0xbd, 0x34, 0xbf, 0xbc, 0x7f, 0x17, 0x56, 0x54, 0xae, 0xe4, 0xc3, 0xdf, 0x90, - 0xc4, 0x97, 0x59, 0x0e, 0xa4, 0xcb, 0x79, 0x39, 0xb7, 0x9c, 0xa3, 0x1d, 0xb8, 0x1e, 0x0f, 0xbc, - 0xb0, 0xe3, 0xb2, 0x20, 0xe6, 0x11, 0xf1, 0x02, 0xde, 0x71, 0xfb, 0xd4, 0x1d, 0xe8, 0x8c, 0x58, - 0x13, 0xcc, 0xdd, 0x94, 0xb7, 0x2b, 0x58, 0x4e, 0x08, 0xad, 0xcc, 0x0d, 0xc5, 0xc3, 0xf8, 0x00, - 0x2a, 0x92, 0x3b, 0xef, 0x8b, 0x34, 0xb7, 0xb4, 0x80, 0xf3, 0x37, 0x03, 0x56, 0xc4, 0x62, 0xe5, - 0x15, 0x2a, 0x1c, 0x73, 0x3e, 0x32, 0x17, 0xf8, 0x08, 0x81, 0x35, 0xa0, 0x93, 0xb8, 0x5d, 0xda, - 0x28, 0x6d, 0x36, 0xb0, 0xfc, 0x46, 0xf7, 0xa0, 0xe9, 0x4a, 0xad, 0x33, 0xde, 0x5d, 0x51, 0x54, - 0xdd, 0xf5, 0x53, 0xcb, 0x2e, 0xb7, 0x2a, 0xb8, 0x72, 0xec, 0x05, 0x3e, 0xeb, 0x39, 0x3e, 0x34, - 0x13, 0x53, 0x2f, 0xbf, 0xfa, 0x38, 0x3d, 0x58, 0xd9, 0x1b, 0x86, 0x2c, 0x4a, 0x1d, 0x93, 0x4b, - 0x32, 0xe3, 0x02, 0x49, 0x36, 0x0f, 0xd2, 0x5c, 0x00, 0xd2, 0x79, 0x05, 0xcd, 0x44, 0x51, 0x71, - 0x58, 0xeb, 0xd3, 0xb0, 0x6a, 0x09, 0x86, 0x5f, 0xc1, 0xfa, 0x23, 0xc2, 0xdd, 0x3e, 0x66, 0xbe, - 0x7f, 0x4c, 0xdc, 0xc1, 0x55, 0xc6, 0xd8, 0x89, 0xe1, 0xfa, 0x8c, 0xf2, 0x2b, 0x88, 0x5a, 0x0c, - 0xcd, 0x5d, 0x9f, 0x92, 0x60, 0x14, 0x2e, 0x67, 0x21, 0x9c, 0x43, 0x5f, 0x9a, 0x47, 0xef, 0xfc, - 0xd1, 0x80, 0xd5, 0x54, 0xeb, 0x15, 0x2c, 0x8c, 0xf3, 0x89, 0x55, 0x5a, 0x94, 0x58, 0x03, 0x58, - 0x95, 0x01, 0x28, 0xb8, 0x2b, 0x48, 0x62, 0x6a, 0x4e, 0xcd, 0xdb, 0xf3, 0xf7, 0x05, 0x3e, 0xb4, - 0x32, 0x65, 0x97, 0xbe, 0x02, 0xfd, 0xde, 0x80, 0x55, 0xb1, 0xd8, 0x89, 0x4a, 0x5d, 0x04, 0xdb, - 0x5d, 0xa8, 0x0f, 0xc9, 0xd9, 0x4c, 0x4a, 0xc3, 0x90, 0x9c, 0x25, 0x09, 0x9d, 0xdb, 0x29, 0x94, - 0xce, 0xdb, 0x29, 0x58, 0x53, 0x3b, 0x05, 0xe7, 0x4f, 0x06, 0xb4, 0x32, 0x9b, 0xae, 0x20, 0x0d, - 0xee, 0x43, 0x59, 0x2c, 0x36, 0x6a, 0xd6, 0x2d, 0x3c, 0x22, 0x2a, 0xbe, 0xf3, 0x21, 0x54, 0x8f, - 0xce, 0xd4, 0xce, 0xba, 0x05, 0x25, 0x7e, 0x16, 0xe8, 0x93, 0x93, 0xf8, 0x44, 0x37, 0xa0, 0x12, - 0x73, 0xc2, 0x47, 0xc9, 0x29, 0x4d, 0xb7, 0xc4, 0x3e, 0x0b, 0x61, 0x1a, 0x33, 0x7f, 0x4c, 0x8b, - 0x7a, 0xf9, 0x42, 0xa5, 0xe3, 0x62, 0xc9, 0x8c, 0xbe, 0x0f, 0x35, 0x7e, 0x16, 0x74, 0xbc, 0xe0, - 0x84, 0xc5, 0x6d, 0x4b, 0x02, 0xce, 0x34, 0x6b, 0x74, 0xd8, 0xe6, 0xea, 0x23, 0x76, 0x5e, 0xc3, - 0x5a, 0xce, 0xf8, 0x2b, 0x28, 0x3d, 0x2f, 0xa1, 0xf6, 0x74, 0xb7, 0x88, 0x9b, 0xde, 0x03, 0x88, - 0xc9, 0x09, 0xed, 0x84, 0xcc, 0x0b, 0xb8, 0xf6, 0x51, 0x4d, 0x50, 0x0e, 0x04, 0xc1, 0xe9, 0x03, - 0x88, 0x71, 0xaf, 0x00, 0xc1, 0x67, 0xb0, 0x82, 0xc9, 0xe9, 0xd2, 0x0e, 0x11, 0x4d, 0x30, 0xdd, - 0x13, 0x7d, 0xef, 0x60, 0xba, 0x27, 0x0e, 0x83, 0x66, 0x32, 0xfc, 0x92, 0x17, 0xba, 0x73, 0xb6, - 0x95, 0xb1, 0xc4, 0x73, 0x30, 0x5a, 0x12, 0x9e, 0x85, 0x4a, 0x34, 0x4a, 0x2b, 0x45, 0xf9, 0x4a, - 0xa2, 0x94, 0x4a, 0x97, 0xbd, 0x9c, 0x9f, 0x02, 0xc2, 0xe4, 0x54, 0x96, 0xd9, 0x82, 0xa0, 0x2e, - 0x56, 0x5e, 0xe7, 0x22, 0xf7, 0x4b, 0x58, 0xcb, 0x29, 0x5e, 0x36, 0xb0, 0x6e, 0x06, 0x6c, 0x89, - 0x8b, 0xd5, 0x7c, 0xfe, 0xad, 0xe5, 0xb4, 0x5c, 0xfa, 0x2a, 0xf5, 0x39, 0xb4, 0x30, 0x39, 0x7d, - 0x4c, 0x7d, 0x5a, 0xec, 0x58, 0xf3, 0xf6, 0x29, 0xf5, 0x0b, 0x78, 0x67, 0x4a, 0xc3, 0xb2, 0xc3, - 0xd2, 0x83, 0xeb, 0x89, 0xc3, 0x8a, 0x83, 0xb8, 0x48, 0x64, 0x08, 0xdc, 0x98, 0x55, 0xb4, 0x6c, - 0x2c, 0x63, 0x40, 0x7a, 0x68, 0x12, 0xf4, 0xe8, 0xd2, 0x2f, 0x0f, 0x6e, 0x42, 0x95, 0x06, 0xdd, - 0xa9, 0xdd, 0x42, 0x85, 0x06, 0xdd, 0x67, 0x74, 0x22, 0xa6, 0x4e, 0x4e, 0xef, 0xb2, 0x71, 0x7d, - 0x65, 0xc8, 0x20, 0x7d, 0x1b, 0xd8, 0xe6, 0x4a, 0x9f, 0x0a, 0xe3, 0xa5, 0xc2, 0xfd, 0x8b, 0x21, - 0xcb, 0xeb, 0x15, 0x5e, 0x00, 0x4d, 0x5f, 0xf3, 0x58, 0xf9, 0x6b, 0x1e, 0x85, 0xbf, 0x9c, 0xe2, - 0xef, 0xc1, 0x6a, 0x6a, 0x5b, 0x71, 0xe0, 0xef, 0x43, 0x69, 0x30, 0x3e, 0xb7, 0xb4, 0x08, 0x9e, - 0xf3, 0xb1, 0x7c, 0x29, 0x90, 0x2e, 0xce, 0x43, 0x32, 0xce, 0x0f, 0x9d, 0x99, 0x4b, 0xcb, 0xbf, - 0x1b, 0x59, 0x31, 0x2c, 0xea, 0xcc, 0x07, 0x50, 0x89, 0x84, 0x09, 0x0b, 0xaf, 0x19, 0x54, 0xfc, - 0xb5, 0x80, 0xd8, 0xe2, 0x50, 0xe2, 0xf6, 0x3b, 0xd3, 0xfe, 0xad, 0x09, 0xca, 0xfe, 0xff, 0xea, - 0x63, 0x1f, 0xd6, 0xf3, 0x76, 0x5f, 0xaa, 0xa3, 0xbf, 0x34, 0xa0, 0xf6, 0x7c, 0xec, 0xba, 0xf2, - 0xe1, 0x03, 0xdd, 0x05, 0x8b, 0x4f, 0x42, 0xba, 0xe8, 0xb6, 0x4b, 0x32, 0x72, 0x2f, 0x22, 0x66, - 0xfe, 0x45, 0xe4, 0x36, 0xd4, 0xf4, 0x36, 0x97, 0xc7, 0x7a, 0x87, 0x6b, 0x2b, 0x82, 0x7a, 0x2e, - 0x89, 0xfb, 0x4c, 0x6c, 0x94, 0xe5, 0xfe, 0x42, 0xbd, 0x7f, 0x80, 0x24, 0xbd, 0x94, 0x3b, 0x99, - 0x1f, 0x29, 0x33, 0x64, 0xe3, 0x9b, 0xde, 0x5d, 0xd2, 0x2d, 0x8a, 0x39, 0xbd, 0x0f, 0xfa, 0x8d, - 0x01, 0xb6, 0xe8, 0x2e, 0xef, 0xb5, 0xfe, 0x1f, 0x10, 0x53, 0x6f, 0x34, 0xa5, 0xdc, 0x1b, 0xcd, - 0xdb, 0x11, 0x7c, 0xa5, 0x6d, 0x90, 0xa7, 0x90, 0xe4, 0xce, 0x7d, 0xf6, 0xea, 0x33, 0x31, 0x52, - 0xdf, 0xb9, 0x6f, 0x41, 0x45, 0xde, 0x85, 0x25, 0x31, 0x42, 0x39, 0x41, 0x19, 0x13, 0xac, 0x25, - 0x84, 0xac, 0x54, 0x9d, 0x9c, 0x86, 0xf2, 0xb2, 0xd2, 0x06, 0xac, 0x25, 0x9c, 0x43, 0x58, 0x13, - 0xc4, 0xa7, 0x94, 0x3f, 0x9a, 0x88, 0x54, 0x5d, 0xc6, 0xd2, 0xec, 0xfc, 0xce, 0x80, 0xf5, 0xfc, - 0xa8, 0xcb, 0xde, 0xe4, 0xde, 0x03, 0x4b, 0x1c, 0x7f, 0xe6, 0x9e, 0x20, 0x12, 0xb7, 0x62, 0xc9, - 0x76, 0x3e, 0x87, 0x9b, 0xa9, 0x1d, 0x87, 0x2a, 0x70, 0x45, 0x10, 0x9e, 0x9f, 0x06, 0xce, 0x5f, - 0x0d, 0x68, 0xcf, 0xab, 0x58, 0x36, 0xdc, 0xf9, 0x27, 0xc2, 0xc4, 0x01, 0xd6, 0x37, 0x3b, 0xe0, - 0x33, 0x40, 0x87, 0xa1, 0xef, 0x71, 0xf5, 0xde, 0x57, 0x74, 0x99, 0x10, 0x23, 0xe4, 0x96, 0x09, - 0x41, 0x10, 0xa5, 0xf3, 0x0f, 0x06, 0xac, 0xe5, 0xc6, 0x2f, 0x0e, 0xdc, 0x01, 0xcb, 0xa7, 0x27, - 0x5c, 0x1f, 0xcc, 0x9a, 0xf9, 0x87, 0x4a, 0x2c, 0x79, 0xe8, 0x03, 0x28, 0x47, 0x5e, 0xaf, 0xcf, - 0x75, 0xd8, 0x67, 0x85, 0x14, 0xd3, 0xf9, 0x02, 0xde, 0xfd, 0x59, 0x20, 0xce, 0x8c, 0x8f, 0x69, - 0xcc, 0x23, 0x36, 0xb9, 0xe2, 0x5d, 0x0e, 0x85, 0x5b, 0x8b, 0xd4, 0x2f, 0x39, 0x25, 0xb6, 0xbe, - 0x07, 0x90, 0xbd, 0xac, 0x22, 0x80, 0xca, 0x4f, 0x59, 0x34, 0x24, 0x7e, 0xeb, 0x1a, 0xaa, 0x42, - 0x69, 0x9f, 0x9d, 0xb6, 0x0c, 0x64, 0x83, 0xf5, 0x89, 0xd7, 0xeb, 0xb7, 0xcc, 0xad, 0x0d, 0x68, - 0xe6, 0x9f, 0x53, 0x51, 0x05, 0xcc, 0xc3, 0xbd, 0xd6, 0x35, 0xf1, 0x8b, 0x77, 0x5b, 0xc6, 0xd6, - 0x36, 0x98, 0x2f, 0x42, 0xd1, 0xf5, 0x60, 0xc4, 0xd5, 0x18, 0x8f, 0xa9, 0xaf, 0xc6, 0x10, 0x55, - 0xa8, 0x65, 0xa2, 0x06, 0xd8, 0xc9, 0xf5, 0x65, 0xab, 0xf4, 0x68, 0xeb, 0x9f, 0x6f, 0xee, 0x18, - 0xff, 0x7a, 0x73, 0xc7, 0xf8, 0xf7, 0x9b, 0x3b, 0xc6, 0x9f, 0xff, 0x73, 0xe7, 0x1a, 0xb4, 0x5d, - 0x36, 0xdc, 0x0e, 0xbd, 0xa0, 0xe7, 0x92, 0x70, 0x9b, 0x7b, 0x83, 0xf1, 0xf6, 0x60, 0x2c, 0xff, - 0x4c, 0x70, 0x5c, 0x91, 0x3f, 0x1f, 0xfe, 0x37, 0x00, 0x00, 0xff, 0xff, 0xc3, 0x3e, 0x6a, 0x3d, - 0xa0, 0x20, 0x00, 0x00, +func init() { proto.RegisterFile("kvrpcpb.proto", fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8) } + +var fileDescriptor_kvrpcpb_6c0dc0628fd5a3f8 = []byte{ + // 2050 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x5a, 0x5f, 0x6f, 0x1b, 0xc7, + 0x11, 0xf7, 0xfd, 0x21, 0x79, 0x1c, 0x52, 0x14, 0xb3, 0x92, 0x6d, 0xc6, 0x6e, 0x6c, 0xe5, 0x1a, + 0xc3, 0xb2, 0x8a, 0xca, 0xa8, 0x12, 0xf4, 0xa9, 0x28, 0x02, 0xcb, 0xae, 0xa3, 0x58, 0xae, 0x85, + 0x95, 0xea, 0xc2, 0x40, 0x13, 0x66, 0x75, 0x5c, 0x91, 0x07, 0x1e, 0x6f, 0xcf, 0x77, 0x2b, 0x4a, + 0x44, 0x11, 0x14, 0x45, 0x91, 0x02, 0x79, 0x6c, 0x51, 0xa0, 0x7d, 0x68, 0x3e, 0x40, 0xdf, 0xfb, + 0xd6, 0x2f, 0xd0, 0xc7, 0x3c, 0xf4, 0x03, 0x14, 0xee, 0x17, 0x29, 0xf6, 0xcf, 0xdd, 0xf1, 0x44, + 0x2a, 0x16, 0xae, 0x94, 0xfa, 0xc4, 0xdb, 0x99, 0xd9, 0x9d, 0xf9, 0xcd, 0xcc, 0xce, 0xfe, 0x23, + 0x2c, 0x0d, 0xc7, 0x71, 0xe4, 0x45, 0x87, 0x9b, 0x51, 0xcc, 0x38, 0x43, 0x35, 0xdd, 0xbc, 0xd5, + 0x1c, 0x51, 0x4e, 0x52, 0xf2, 0xad, 0x25, 0x1a, 0xc7, 0x2c, 0xce, 0x9a, 0xab, 0x7d, 0xd6, 0x67, + 0xf2, 0xf3, 0xa1, 0xf8, 0x52, 0x54, 0xf7, 0x4b, 0x70, 0x76, 0x99, 0x37, 0xdc, 0x09, 0x8f, 0x18, + 0x7a, 0x1f, 0x9a, 0x51, 0xec, 0x8f, 0x48, 0x3c, 0xe9, 0x06, 0xcc, 0x1b, 0x76, 0x8c, 0x35, 0x63, + 0xbd, 0x89, 0x1b, 0x9a, 0x26, 0xc4, 0x84, 0x88, 0x60, 0x75, 0xc7, 0x34, 0x4e, 0x7c, 0x16, 0x76, + 0xcc, 0x35, 0x63, 0xdd, 0xc6, 0x0d, 0x41, 0x7b, 0xa9, 0x48, 0xa8, 0x0d, 0xd6, 0x90, 0x4e, 0x3a, + 0x96, 0xec, 0x2c, 0x3e, 0xd1, 0xbb, 0xe0, 0xc8, 0x4e, 0x9c, 0x07, 0x1d, 0x5b, 0x76, 0xa8, 0x89, + 0xf6, 0x01, 0x0f, 0xdc, 0x6f, 0x0c, 0x70, 0x9e, 0xd1, 0xc9, 0x13, 0x61, 0x29, 0x7a, 0x00, 0x55, + 0x41, 0xa7, 0x3d, 0xa9, 0xb9, 0xb1, 0xf5, 0xce, 0x66, 0x8a, 0x33, 0x35, 0x11, 0x6b, 0x01, 0xf4, + 0x3d, 0xa8, 0xc7, 0x94, 0xc7, 0x13, 0x72, 0x18, 0x50, 0x69, 0x44, 0x1d, 0xe7, 0x04, 0xb4, 0x0a, + 0x15, 0x72, 0xc8, 0x62, 0x2e, 0x8d, 0xa8, 0x63, 0xd5, 0x40, 0x5b, 0xe0, 0x78, 0x2c, 0x3c, 0x0a, + 0x7c, 0x8f, 0x4b, 0x33, 0x1a, 0x5b, 0x37, 0x32, 0x05, 0xbf, 0x8c, 0x7d, 0x4e, 0xb7, 0x35, 0x17, + 0x67, 0x72, 0xee, 0x09, 0x2c, 0x15, 0x58, 0x02, 0x4b, 0xc2, 0x49, 0xcc, 0xbb, 0x3c, 0x91, 0x56, + 0xda, 0xb8, 0x26, 0xdb, 0x07, 0x09, 0xba, 0x0b, 0x8d, 0xb4, 0x9f, 0xe0, 0x2a, 0xd7, 0x40, 0x4a, + 0x3a, 0x48, 0xe6, 0x78, 0xa6, 0x03, 0x35, 0xed, 0x5d, 0x69, 0x51, 0x13, 0xa7, 0x4d, 0xf7, 0x1b, + 0x0b, 0x6a, 0xdb, 0x2c, 0xe4, 0xf4, 0x94, 0xa3, 0xdb, 0x02, 0x6c, 0xdf, 0x67, 0x61, 0xd7, 0xef, + 0x69, 0xa5, 0x8e, 0x22, 0xec, 0xf4, 0xd0, 0x8f, 0xa1, 0xa9, 0x99, 0x34, 0x62, 0xde, 0x40, 0xaa, + 0x6d, 0x6c, 0xad, 0x6c, 0xea, 0x54, 0xc0, 0x92, 0xf7, 0x44, 0xb0, 0x70, 0x23, 0xce, 0x1b, 0x68, + 0x0d, 0xec, 0x88, 0xd2, 0x58, 0x5a, 0xd3, 0xd8, 0x6a, 0xa6, 0xf2, 0x7b, 0x94, 0xc6, 0x58, 0x72, + 0x10, 0x02, 0x9b, 0xd3, 0x78, 0xd4, 0xa9, 0x48, 0x8d, 0xf2, 0x1b, 0x3d, 0x04, 0x27, 0x8a, 0x7d, + 0x16, 0xfb, 0x7c, 0xd2, 0xa9, 0xae, 0x19, 0xeb, 0xad, 0xad, 0x95, 0xcc, 0x87, 0xdb, 0x6c, 0x34, + 0x22, 0x61, 0x6f, 0x2f, 0xf6, 0x71, 0x26, 0x84, 0x3e, 0x86, 0x65, 0x3f, 0x61, 0x01, 0xe1, 0xc2, + 0xc2, 0x80, 0x8e, 0x69, 0xd0, 0xa9, 0xc9, 0x7e, 0x37, 0xb3, 0x7e, 0x3b, 0x29, 0x7f, 0x57, 0xb0, + 0x71, 0xcb, 0x2f, 0xb4, 0xd1, 0x07, 0xd0, 0x0a, 0x19, 0xef, 0x1e, 0xf9, 0x41, 0xd0, 0xf5, 0x88, + 0x37, 0xa0, 0x1d, 0x67, 0xcd, 0x58, 0x77, 0x70, 0x33, 0x64, 0xfc, 0x67, 0x7e, 0x10, 0x6c, 0x0b, + 0x9a, 0x8c, 0xcb, 0x24, 0xf4, 0xba, 0x01, 0xeb, 0x77, 0xea, 0x92, 0x5f, 0x13, 0xed, 0x5d, 0xd6, + 0x17, 0x71, 0x19, 0x90, 0xb0, 0x17, 0xd0, 0x2e, 0xf7, 0x47, 0xb4, 0x03, 0x92, 0x0b, 0x8a, 0x74, + 0xe0, 0x8f, 0xa8, 0x10, 0x48, 0x3c, 0x12, 0x76, 0x7b, 0x94, 0x13, 0x3f, 0xe8, 0x34, 0x94, 0x80, + 0x20, 0x3d, 0x96, 0x94, 0x4f, 0x6d, 0xc7, 0x6e, 0x57, 0x84, 0xfb, 0x48, 0xaf, 0xfb, 0xfa, 0x98, + 0xc5, 0xc7, 0x23, 0xf7, 0x31, 0xc0, 0x27, 0xf9, 0x08, 0x37, 0xa1, 0x76, 0x42, 0x7c, 0xde, 0x1d, + 0xa9, 0xa4, 0xb0, 0x70, 0x55, 0x34, 0x9f, 0x27, 0xe8, 0x3d, 0x80, 0x28, 0x66, 0x1e, 0x4d, 0x12, + 0xc1, 0x33, 0x25, 0xaf, 0xae, 0x29, 0xcf, 0x13, 0xf7, 0xa7, 0xe0, 0xec, 0x7b, 0x24, 0x94, 0xb3, + 0x6f, 0x15, 0x2a, 0x9c, 0x71, 0x12, 0xe8, 0x11, 0x54, 0x43, 0x24, 0xba, 0x16, 0xa7, 0xbd, 0x33, + 0xfd, 0x69, 0xcf, 0xfd, 0x9d, 0x01, 0xb0, 0x9f, 0xd9, 0x89, 0xee, 0x43, 0xe5, 0x44, 0x64, 0xeb, + 0xcc, 0xfc, 0x49, 0x95, 0x60, 0xc5, 0x47, 0xf7, 0xc0, 0x96, 0x33, 0xdc, 0x3c, 0x4f, 0x4e, 0xb2, + 0x85, 0x58, 0x8f, 0x70, 0xa2, 0x73, 0x64, 0x9e, 0x98, 0x60, 0xbb, 0x13, 0x68, 0x3c, 0x39, 0xa5, + 0x9e, 0x32, 0x22, 0x41, 0x1f, 0x15, 0xfd, 0x6d, 0xe8, 0x84, 0x4c, 0x3b, 0xe7, 0x6e, 0x2b, 0x04, + 0xe1, 0xa3, 0x62, 0x10, 0xcc, 0x33, 0xbd, 0x72, 0x94, 0xd3, 0x91, 0x71, 0x7b, 0x00, 0x4f, 0x29, + 0xc7, 0xf4, 0xf5, 0x31, 0x4d, 0x38, 0xda, 0x80, 0x9a, 0xa7, 0xe6, 0x8c, 0xd6, 0xda, 0x9e, 0x4a, + 0x4e, 0x49, 0xc7, 0xa9, 0x40, 0x3a, 0x19, 0xcd, 0xc2, 0x64, 0x4c, 0xcb, 0x9a, 0xa5, 0x66, 0xb6, + 0x6e, 0xba, 0xbf, 0x81, 0x86, 0xd4, 0x92, 0x44, 0x2c, 0x4c, 0x28, 0xfa, 0x51, 0x3e, 0xe5, 0x44, + 0xdd, 0xd2, 0xba, 0x5a, 0x9b, 0x69, 0xbd, 0x95, 0xd5, 0x2c, 0x9b, 0x6d, 0xb2, 0xb4, 0xdd, 0x87, + 0x8a, 0x92, 0x3d, 0xeb, 0xf1, 0xb4, 0xf8, 0x61, 0xc5, 0x17, 0x59, 0x30, 0x26, 0xc1, 0x31, 0xd5, + 0x55, 0x42, 0x35, 0xdc, 0x7f, 0x19, 0xd0, 0x10, 0x1e, 0x28, 0x03, 0xf4, 0x36, 0xd4, 0x55, 0xc5, + 0xca, 0xe1, 0xaa, 0x12, 0xf6, 0x8c, 0x4e, 0x84, 0xba, 0xc0, 0x1f, 0xf9, 0xaa, 0x52, 0x2e, 0x61, + 0xd5, 0x98, 0xf6, 0x84, 0x5d, 0xf0, 0x84, 0x98, 0x66, 0x43, 0x3a, 0xe9, 0xb2, 0x30, 0x98, 0xc8, + 0xba, 0xe0, 0xe0, 0xda, 0x90, 0x4e, 0x5e, 0x84, 0x81, 0x74, 0x5f, 0x4c, 0x85, 0x1c, 0x95, 0x95, + 0xc1, 0xc1, 0x69, 0x53, 0xcc, 0x0e, 0x1a, 0xf6, 0xa4, 0xfe, 0x9a, 0xd4, 0x5f, 0xa5, 0x61, 0xef, + 0x19, 0x9d, 0xb8, 0xaf, 0xa0, 0xfa, 0x6c, 0xbc, 0x47, 0xfc, 0x29, 0xff, 0x18, 0x6f, 0xf1, 0xcf, + 0x6c, 0xd8, 0xe6, 0x7b, 0x6c, 0x00, 0x4d, 0xe5, 0xb0, 0xf2, 0x31, 0xbb, 0x07, 0x95, 0x88, 0xf8, + 0xb1, 0x98, 0xb6, 0xd6, 0x7a, 0x63, 0x6b, 0x39, 0xb7, 0x49, 0xda, 0x8c, 0x15, 0xd7, 0x7d, 0x01, + 0xce, 0xf3, 0x63, 0x2e, 0x0b, 0x16, 0xba, 0x0d, 0x26, 0x8b, 0xe4, 0xd8, 0xad, 0xad, 0x46, 0x26, + 0xff, 0x22, 0xc2, 0x26, 0x8b, 0x2e, 0x6c, 0xfa, 0x57, 0x26, 0x2c, 0xef, 0xc5, 0x54, 0xce, 0xd4, + 0x32, 0x01, 0x7f, 0x08, 0xf5, 0x91, 0x36, 0x28, 0xb5, 0x3d, 0xf7, 0x67, 0x6a, 0x2a, 0xce, 0x65, + 0x66, 0xd6, 0x7d, 0x6b, 0x76, 0xdd, 0xff, 0x3e, 0x2c, 0xa9, 0x24, 0x2a, 0xe6, 0x45, 0x53, 0x12, + 0x5f, 0xe6, 0xc9, 0x91, 0xad, 0xf3, 0x95, 0xc2, 0x3a, 0x8f, 0xb6, 0xe0, 0x7a, 0x32, 0xf4, 0xa3, + 0xae, 0xc7, 0xc2, 0x84, 0xc7, 0xc4, 0x0f, 0x79, 0xd7, 0x1b, 0x50, 0x6f, 0xa8, 0x53, 0x65, 0x45, + 0x30, 0xb7, 0x33, 0xde, 0xb6, 0x60, 0xb9, 0x11, 0xb4, 0x73, 0x37, 0x94, 0x0f, 0xe3, 0x03, 0xa8, + 0x4a, 0xee, 0xac, 0x2f, 0xb2, 0xdc, 0xd2, 0x02, 0xee, 0xdf, 0x0c, 0x58, 0x12, 0xab, 0x98, 0x5f, + 0xaa, 0xa2, 0xcc, 0xf8, 0xc8, 0x9c, 0xe3, 0x23, 0x04, 0xf6, 0x90, 0x4e, 0x92, 0x8e, 0xb5, 0x66, + 0xad, 0x37, 0xb1, 0xfc, 0x46, 0xf7, 0xa0, 0xe5, 0x49, 0xad, 0x67, 0xbc, 0xbb, 0xa4, 0xa8, 0xba, + 0xeb, 0xa7, 0xb6, 0x53, 0x69, 0x57, 0x71, 0xf5, 0xd0, 0x0f, 0x03, 0xd6, 0x77, 0x03, 0x68, 0xa5, + 0xa6, 0x5e, 0x7e, 0x59, 0x72, 0xfb, 0xb0, 0xb4, 0x33, 0x8a, 0x58, 0x9c, 0x39, 0xa6, 0x90, 0x64, + 0xc6, 0x05, 0x92, 0x6c, 0x16, 0xa4, 0x39, 0x07, 0xa4, 0xfb, 0x0a, 0x5a, 0xa9, 0xa2, 0xf2, 0xb0, + 0x56, 0xa7, 0x61, 0xd5, 0x53, 0x0c, 0xbf, 0x86, 0xd5, 0x47, 0x84, 0x7b, 0x03, 0xcc, 0x82, 0xe0, + 0x90, 0x78, 0xc3, 0xab, 0x8c, 0xb1, 0x9b, 0xc0, 0xf5, 0x33, 0xca, 0xaf, 0x20, 0x6a, 0x09, 0xb4, + 0xb6, 0x03, 0x4a, 0xc2, 0xe3, 0x68, 0x31, 0x2b, 0xe4, 0x0c, 0x7a, 0x6b, 0x16, 0xbd, 0xfb, 0x27, + 0x03, 0x96, 0x33, 0xad, 0x57, 0xb0, 0x62, 0xce, 0x26, 0x96, 0x35, 0x2f, 0xb1, 0x86, 0xb0, 0x2c, + 0x03, 0x50, 0x72, 0xbb, 0x90, 0xc6, 0xd4, 0x9c, 0x9a, 0xb7, 0xe7, 0x6f, 0x18, 0x02, 0x68, 0xe7, + 0xca, 0x2e, 0x7d, 0x05, 0xfa, 0x83, 0x01, 0xcb, 0x62, 0xb1, 0x13, 0x95, 0xba, 0x0c, 0xb6, 0xbb, + 0xd0, 0x18, 0x91, 0xd3, 0x33, 0x29, 0x0d, 0x23, 0x72, 0x9a, 0x26, 0x74, 0x61, 0x0b, 0x61, 0x9d, + 0xb7, 0x85, 0xb0, 0xa7, 0xb6, 0x10, 0xee, 0x9f, 0x0d, 0x68, 0xe7, 0x36, 0x5d, 0x41, 0x1a, 0xdc, + 0x87, 0x8a, 0x58, 0x6c, 0xd4, 0xac, 0x9b, 0x7b, 0x76, 0x54, 0x7c, 0xf7, 0x43, 0xa8, 0x1d, 0x9c, + 0xaa, 0x2d, 0x77, 0x1b, 0x2c, 0x7e, 0x1a, 0xea, 0x23, 0x95, 0xf8, 0x44, 0x37, 0xa0, 0x9a, 0x70, + 0xc2, 0x8f, 0xd3, 0xe3, 0x9b, 0x6e, 0xb9, 0xff, 0x30, 0x00, 0x61, 0x9a, 0xb0, 0x60, 0x4c, 0xcb, + 0x7a, 0xf9, 0x42, 0xa5, 0xe3, 0x62, 0xc9, 0x8c, 0x7e, 0x08, 0x75, 0x7e, 0x1a, 0x76, 0xfd, 0xf0, + 0x88, 0x25, 0x1d, 0x5b, 0x02, 0xce, 0x35, 0x6b, 0x74, 0xd8, 0xe1, 0xea, 0x23, 0x71, 0x5f, 0xc3, + 0x4a, 0xc1, 0xf8, 0x2b, 0x28, 0x3d, 0x2f, 0xa1, 0xfe, 0x74, 0xbb, 0x8c, 0x9b, 0xde, 0x03, 0x48, + 0xc8, 0x11, 0xed, 0x46, 0xcc, 0x0f, 0xb9, 0xf6, 0x51, 0x5d, 0x50, 0xf6, 0x04, 0xc1, 0x1d, 0x00, + 0x88, 0x71, 0xaf, 0x00, 0xc1, 0x67, 0xb0, 0x84, 0xc9, 0xc9, 0xc2, 0x4e, 0x17, 0x2d, 0x30, 0xbd, + 0x23, 0x7d, 0x21, 0x61, 0x7a, 0x47, 0x2e, 0x83, 0x56, 0x3a, 0xfc, 0x82, 0x17, 0xba, 0x73, 0xb6, + 0x95, 0x89, 0xc4, 0xb3, 0x77, 0xbc, 0x20, 0x3c, 0x73, 0x95, 0x68, 0x94, 0x76, 0x86, 0xf2, 0x95, + 0x44, 0x29, 0x95, 0x2e, 0x7a, 0x39, 0x3f, 0x01, 0x84, 0xc9, 0x89, 0x2c, 0xb3, 0x25, 0x41, 0x5d, + 0xac, 0xbc, 0xce, 0x44, 0xee, 0x73, 0x58, 0x29, 0x28, 0x5e, 0x34, 0xb0, 0x5e, 0x0e, 0x6c, 0x81, + 0x8b, 0xd5, 0x6c, 0xfe, 0xad, 0x14, 0xb4, 0x5c, 0xfa, 0x2a, 0xf5, 0x05, 0xb4, 0x31, 0x39, 0x79, + 0x4c, 0x03, 0x5a, 0xee, 0x58, 0xf3, 0xf6, 0x29, 0xf5, 0x2b, 0x78, 0x67, 0x4a, 0xc3, 0xa2, 0xc3, + 0xd2, 0x87, 0xeb, 0xa9, 0xc3, 0xca, 0x83, 0xb8, 0x48, 0x64, 0x08, 0xdc, 0x38, 0xab, 0x68, 0xd1, + 0x58, 0xc6, 0x80, 0xf4, 0xd0, 0x24, 0xec, 0xd3, 0x85, 0xdf, 0x2a, 0x4c, 0x1d, 0xf8, 0xad, 0xc2, + 0x81, 0xff, 0x73, 0x58, 0x29, 0xe8, 0x5d, 0x34, 0xae, 0xaf, 0x0d, 0x19, 0xa4, 0xff, 0x07, 0xb6, + 0x99, 0xd2, 0xa7, 0xc2, 0x78, 0xa9, 0x70, 0xff, 0x6e, 0xc8, 0xf2, 0x7a, 0x85, 0x37, 0x43, 0xd3, + 0xf7, 0x3f, 0x76, 0xf1, 0xfe, 0x47, 0xe1, 0xaf, 0xa4, 0xf8, 0xcf, 0xbf, 0x0f, 0x72, 0xfb, 0xb0, + 0x9c, 0x59, 0x5d, 0xde, 0x25, 0xef, 0x83, 0x35, 0x1c, 0x9f, 0x5b, 0x74, 0x04, 0xcf, 0xfd, 0x58, + 0x3e, 0x2e, 0x48, 0xe7, 0x17, 0xc1, 0x1a, 0xe7, 0x07, 0xd5, 0x2c, 0x24, 0xec, 0xb7, 0x46, 0x5e, + 0x26, 0xcb, 0xba, 0xf9, 0x01, 0x54, 0x63, 0x61, 0xc2, 0xdc, 0x0b, 0x08, 0x95, 0x19, 0x5a, 0x40, + 0x6c, 0x7e, 0x28, 0xf1, 0x06, 0xdd, 0x69, 0xcf, 0xd7, 0x05, 0x65, 0x77, 0x71, 0xde, 0x0f, 0x60, + 0xb5, 0x88, 0xe8, 0x52, 0x43, 0xf0, 0x95, 0x01, 0xf5, 0xe7, 0x63, 0xcf, 0x93, 0xaf, 0x28, 0xe8, + 0x2e, 0xd8, 0x7c, 0x12, 0xd1, 0x79, 0x37, 0x64, 0x92, 0x51, 0x78, 0x5e, 0x31, 0x8b, 0xcf, 0x2b, + 0xb7, 0xa1, 0xae, 0xb7, 0xc6, 0x3c, 0xd1, 0xbb, 0x62, 0x47, 0x11, 0xd4, 0xdb, 0x4b, 0x32, 0x60, + 0x62, 0x73, 0x2d, 0xf7, 0x24, 0xea, 0x31, 0x05, 0x24, 0xe9, 0xa5, 0xdc, 0xfd, 0xfc, 0x44, 0x99, + 0x21, 0x1b, 0xdf, 0xf5, 0x88, 0x93, 0x6d, 0x6b, 0xcc, 0xe9, 0xbd, 0xd3, 0x6f, 0x0d, 0x70, 0x44, + 0x77, 0x79, 0x17, 0xf6, 0xbf, 0x80, 0x98, 0x7a, 0xf0, 0xb1, 0x0a, 0x0f, 0x3e, 0x6f, 0x47, 0xf0, + 0xb5, 0xb6, 0x41, 0x9e, 0x5c, 0xd2, 0x0b, 0xfc, 0xb3, 0xd7, 0xa5, 0xa9, 0x91, 0xfa, 0x02, 0x7f, + 0x03, 0xaa, 0xf2, 0xfe, 0x2c, 0x8d, 0x11, 0x2a, 0x08, 0xca, 0x98, 0x60, 0x2d, 0x21, 0x64, 0xa5, + 0xea, 0xf4, 0x04, 0x55, 0x94, 0x95, 0x36, 0x60, 0x2d, 0xe1, 0xee, 0xc3, 0x8a, 0x20, 0x3e, 0xa5, + 0xfc, 0xd1, 0x44, 0x24, 0xf1, 0x22, 0x96, 0x73, 0xf7, 0xf7, 0x06, 0xac, 0x16, 0x47, 0x5d, 0xf4, + 0xc6, 0xf8, 0x1e, 0xd8, 0xe2, 0xc8, 0x34, 0xf3, 0x9e, 0x91, 0xba, 0x15, 0x4b, 0xb6, 0xfb, 0x05, + 0xdc, 0xcc, 0xec, 0xd8, 0x57, 0x81, 0x2b, 0x83, 0xf0, 0xfc, 0x34, 0x70, 0xff, 0x6a, 0x40, 0x67, + 0x56, 0xc5, 0xa2, 0xe1, 0xce, 0xbe, 0x37, 0xa6, 0x0e, 0xb0, 0xbf, 0xdb, 0x01, 0x9f, 0x01, 0xda, + 0x8f, 0x02, 0x9f, 0xab, 0xc7, 0xc3, 0xb2, 0x4b, 0x8b, 0x18, 0xa1, 0xb0, 0xb4, 0x08, 0x82, 0x28, + 0xaa, 0x7f, 0x34, 0x60, 0xa5, 0x30, 0x7e, 0x79, 0xe0, 0x2e, 0xd8, 0x01, 0x3d, 0xe2, 0xfa, 0x30, + 0xd7, 0x2a, 0xbe, 0x7a, 0x62, 0xc9, 0x43, 0x1f, 0x40, 0x25, 0xf6, 0xfb, 0x03, 0xae, 0xc3, 0x7e, + 0x56, 0x48, 0x31, 0xdd, 0x2f, 0xe1, 0xdd, 0x5f, 0x84, 0xe2, 0x9c, 0xf9, 0x98, 0x26, 0x3c, 0x66, + 0x93, 0x2b, 0xde, 0x19, 0x51, 0xb8, 0x35, 0x4f, 0xfd, 0x82, 0x53, 0x62, 0xe3, 0x07, 0x00, 0xf9, + 0x33, 0x2d, 0x02, 0xa8, 0xfe, 0x9c, 0xc5, 0x23, 0x12, 0xb4, 0xaf, 0xa1, 0x1a, 0x58, 0xbb, 0xec, + 0xa4, 0x6d, 0x20, 0x07, 0xec, 0x4f, 0xfc, 0xfe, 0xa0, 0x6d, 0x6e, 0xac, 0x41, 0xab, 0xf8, 0x36, + 0x8b, 0xaa, 0x60, 0xee, 0xef, 0xb4, 0xaf, 0x89, 0x5f, 0xbc, 0xdd, 0x36, 0x36, 0x36, 0xc1, 0x7c, + 0x11, 0x89, 0xae, 0x7b, 0xc7, 0x5c, 0x8d, 0xf1, 0x98, 0x06, 0x6a, 0x0c, 0x51, 0x85, 0xda, 0x26, + 0x6a, 0x82, 0x93, 0x5e, 0x79, 0xb6, 0xad, 0x47, 0x1b, 0xff, 0x7c, 0x73, 0xc7, 0xf8, 0xf6, 0xcd, + 0x1d, 0xe3, 0xdf, 0x6f, 0xee, 0x18, 0x7f, 0xf9, 0xcf, 0x9d, 0x6b, 0xd0, 0xf1, 0xd8, 0x68, 0x33, + 0xf2, 0xc3, 0xbe, 0x47, 0xa2, 0x4d, 0xee, 0x0f, 0xc7, 0x9b, 0xc3, 0xb1, 0xfc, 0x67, 0xc2, 0x61, + 0x55, 0xfe, 0x7c, 0xf8, 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xbd, 0xe9, 0x34, 0x4f, 0xed, 0x20, + 0x00, 0x00, } diff --git a/vendor/github.com/pingcap/kvproto/pkg/metapb/metapb.pb.go b/vendor/github.com/pingcap/kvproto/pkg/metapb/metapb.pb.go index 3479ceed1358c..820001893a939 100644 --- a/vendor/github.com/pingcap/kvproto/pkg/metapb/metapb.pb.go +++ b/vendor/github.com/pingcap/kvproto/pkg/metapb/metapb.pb.go @@ -1,21 +1,6 @@ -// Code generated by protoc-gen-gogo. +// Code generated by protoc-gen-gogo. DO NOT EDIT. // source: metapb.proto -// DO NOT EDIT! - -/* - Package metapb is a generated protocol buffer package. - - It is generated from these files: - metapb.proto - - It has these top-level messages: - Cluster - StoreLabel - Store - RegionEpoch - Region - Peer -*/ + package metapb import ( @@ -24,6 +9,8 @@ import ( "math" proto "github.com/golang/protobuf/proto" + + _ "github.com/gogo/protobuf/gogoproto" ) // Reference imports to suppress errors if they are not otherwise used. @@ -59,19 +46,52 @@ var StoreState_value = map[string]int32{ func (x StoreState) String() string { return proto.EnumName(StoreState_name, int32(x)) } -func (StoreState) EnumDescriptor() ([]byte, []int) { return fileDescriptorMetapb, []int{0} } +func (StoreState) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_metapb_3f810cf7445fc1b4, []int{0} +} type Cluster struct { Id uint64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` // max peer count for a region. // pd will do the auto-balance if region peer count mismatches. - MaxPeerCount uint32 `protobuf:"varint,2,opt,name=max_peer_count,json=maxPeerCount,proto3" json:"max_peer_count,omitempty"` + MaxPeerCount uint32 `protobuf:"varint,2,opt,name=max_peer_count,json=maxPeerCount,proto3" json:"max_peer_count,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *Cluster) Reset() { *m = Cluster{} } +func (m *Cluster) String() string { return proto.CompactTextString(m) } +func (*Cluster) ProtoMessage() {} +func (*Cluster) Descriptor() ([]byte, []int) { + return fileDescriptor_metapb_3f810cf7445fc1b4, []int{0} +} +func (m *Cluster) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Cluster) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Cluster.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 *Cluster) XXX_Merge(src proto.Message) { + xxx_messageInfo_Cluster.Merge(dst, src) +} +func (m *Cluster) XXX_Size() int { + return m.Size() +} +func (m *Cluster) XXX_DiscardUnknown() { + xxx_messageInfo_Cluster.DiscardUnknown(m) } -func (m *Cluster) Reset() { *m = Cluster{} } -func (m *Cluster) String() string { return proto.CompactTextString(m) } -func (*Cluster) ProtoMessage() {} -func (*Cluster) Descriptor() ([]byte, []int) { return fileDescriptorMetapb, []int{0} } +var xxx_messageInfo_Cluster proto.InternalMessageInfo func (m *Cluster) GetId() uint64 { if m != nil { @@ -89,14 +109,45 @@ func (m *Cluster) GetMaxPeerCount() uint32 { // Case insensitive key/value for replica constraints. type StoreLabel struct { - Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` - Value string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Value string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } -func (m *StoreLabel) Reset() { *m = StoreLabel{} } -func (m *StoreLabel) String() string { return proto.CompactTextString(m) } -func (*StoreLabel) ProtoMessage() {} -func (*StoreLabel) Descriptor() ([]byte, []int) { return fileDescriptorMetapb, []int{1} } +func (m *StoreLabel) Reset() { *m = StoreLabel{} } +func (m *StoreLabel) String() string { return proto.CompactTextString(m) } +func (*StoreLabel) ProtoMessage() {} +func (*StoreLabel) Descriptor() ([]byte, []int) { + return fileDescriptor_metapb_3f810cf7445fc1b4, []int{1} +} +func (m *StoreLabel) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *StoreLabel) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_StoreLabel.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 *StoreLabel) XXX_Merge(src proto.Message) { + xxx_messageInfo_StoreLabel.Merge(dst, src) +} +func (m *StoreLabel) XXX_Size() int { + return m.Size() +} +func (m *StoreLabel) XXX_DiscardUnknown() { + xxx_messageInfo_StoreLabel.DiscardUnknown(m) +} + +var xxx_messageInfo_StoreLabel proto.InternalMessageInfo func (m *StoreLabel) GetKey() string { if m != nil { @@ -113,17 +164,48 @@ func (m *StoreLabel) GetValue() string { } type Store struct { - Id uint64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` - Address string `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"` - State StoreState `protobuf:"varint,3,opt,name=state,proto3,enum=metapb.StoreState" json:"state,omitempty"` - Labels []*StoreLabel `protobuf:"bytes,4,rep,name=labels" json:"labels,omitempty"` - Version string `protobuf:"bytes,5,opt,name=version,proto3" json:"version,omitempty"` + Id uint64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` + Address string `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"` + State StoreState `protobuf:"varint,3,opt,name=state,proto3,enum=metapb.StoreState" json:"state,omitempty"` + Labels []*StoreLabel `protobuf:"bytes,4,rep,name=labels" json:"labels,omitempty"` + Version string `protobuf:"bytes,5,opt,name=version,proto3" json:"version,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } -func (m *Store) Reset() { *m = Store{} } -func (m *Store) String() string { return proto.CompactTextString(m) } -func (*Store) ProtoMessage() {} -func (*Store) Descriptor() ([]byte, []int) { return fileDescriptorMetapb, []int{2} } +func (m *Store) Reset() { *m = Store{} } +func (m *Store) String() string { return proto.CompactTextString(m) } +func (*Store) ProtoMessage() {} +func (*Store) Descriptor() ([]byte, []int) { + return fileDescriptor_metapb_3f810cf7445fc1b4, []int{2} +} +func (m *Store) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Store) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Store.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 *Store) XXX_Merge(src proto.Message) { + xxx_messageInfo_Store.Merge(dst, src) +} +func (m *Store) XXX_Size() int { + return m.Size() +} +func (m *Store) XXX_DiscardUnknown() { + xxx_messageInfo_Store.DiscardUnknown(m) +} + +var xxx_messageInfo_Store proto.InternalMessageInfo func (m *Store) GetId() uint64 { if m != nil { @@ -164,13 +246,44 @@ type RegionEpoch struct { // Conf change version, auto increment when add or remove peer ConfVer uint64 `protobuf:"varint,1,opt,name=conf_ver,json=confVer,proto3" json:"conf_ver,omitempty"` // Region version, auto increment when split or merge - Version uint64 `protobuf:"varint,2,opt,name=version,proto3" json:"version,omitempty"` + Version uint64 `protobuf:"varint,2,opt,name=version,proto3" json:"version,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RegionEpoch) Reset() { *m = RegionEpoch{} } +func (m *RegionEpoch) String() string { return proto.CompactTextString(m) } +func (*RegionEpoch) ProtoMessage() {} +func (*RegionEpoch) Descriptor() ([]byte, []int) { + return fileDescriptor_metapb_3f810cf7445fc1b4, []int{3} +} +func (m *RegionEpoch) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RegionEpoch) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RegionEpoch.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 *RegionEpoch) XXX_Merge(src proto.Message) { + xxx_messageInfo_RegionEpoch.Merge(dst, src) +} +func (m *RegionEpoch) XXX_Size() int { + return m.Size() +} +func (m *RegionEpoch) XXX_DiscardUnknown() { + xxx_messageInfo_RegionEpoch.DiscardUnknown(m) } -func (m *RegionEpoch) Reset() { *m = RegionEpoch{} } -func (m *RegionEpoch) String() string { return proto.CompactTextString(m) } -func (*RegionEpoch) ProtoMessage() {} -func (*RegionEpoch) Descriptor() ([]byte, []int) { return fileDescriptorMetapb, []int{3} } +var xxx_messageInfo_RegionEpoch proto.InternalMessageInfo func (m *RegionEpoch) GetConfVer() uint64 { if m != nil { @@ -189,16 +302,47 @@ func (m *RegionEpoch) GetVersion() uint64 { type Region struct { Id uint64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` // Region key range [start_key, end_key). - StartKey []byte `protobuf:"bytes,2,opt,name=start_key,json=startKey,proto3" json:"start_key,omitempty"` - EndKey []byte `protobuf:"bytes,3,opt,name=end_key,json=endKey,proto3" json:"end_key,omitempty"` - RegionEpoch *RegionEpoch `protobuf:"bytes,4,opt,name=region_epoch,json=regionEpoch" json:"region_epoch,omitempty"` - Peers []*Peer `protobuf:"bytes,5,rep,name=peers" json:"peers,omitempty"` + StartKey []byte `protobuf:"bytes,2,opt,name=start_key,json=startKey,proto3" json:"start_key,omitempty"` + EndKey []byte `protobuf:"bytes,3,opt,name=end_key,json=endKey,proto3" json:"end_key,omitempty"` + RegionEpoch *RegionEpoch `protobuf:"bytes,4,opt,name=region_epoch,json=regionEpoch" json:"region_epoch,omitempty"` + Peers []*Peer `protobuf:"bytes,5,rep,name=peers" json:"peers,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *Region) Reset() { *m = Region{} } +func (m *Region) String() string { return proto.CompactTextString(m) } +func (*Region) ProtoMessage() {} +func (*Region) Descriptor() ([]byte, []int) { + return fileDescriptor_metapb_3f810cf7445fc1b4, []int{4} +} +func (m *Region) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Region) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Region.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 *Region) XXX_Merge(src proto.Message) { + xxx_messageInfo_Region.Merge(dst, src) +} +func (m *Region) XXX_Size() int { + return m.Size() +} +func (m *Region) XXX_DiscardUnknown() { + xxx_messageInfo_Region.DiscardUnknown(m) } -func (m *Region) Reset() { *m = Region{} } -func (m *Region) String() string { return proto.CompactTextString(m) } -func (*Region) ProtoMessage() {} -func (*Region) Descriptor() ([]byte, []int) { return fileDescriptorMetapb, []int{4} } +var xxx_messageInfo_Region proto.InternalMessageInfo func (m *Region) GetId() uint64 { if m != nil { @@ -236,15 +380,46 @@ func (m *Region) GetPeers() []*Peer { } type Peer struct { - Id uint64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` - StoreId uint64 `protobuf:"varint,2,opt,name=store_id,json=storeId,proto3" json:"store_id,omitempty"` - IsLearner bool `protobuf:"varint,3,opt,name=is_learner,json=isLearner,proto3" json:"is_learner,omitempty"` + Id uint64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` + StoreId uint64 `protobuf:"varint,2,opt,name=store_id,json=storeId,proto3" json:"store_id,omitempty"` + IsLearner bool `protobuf:"varint,3,opt,name=is_learner,json=isLearner,proto3" json:"is_learner,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } -func (m *Peer) Reset() { *m = Peer{} } -func (m *Peer) String() string { return proto.CompactTextString(m) } -func (*Peer) ProtoMessage() {} -func (*Peer) Descriptor() ([]byte, []int) { return fileDescriptorMetapb, []int{5} } +func (m *Peer) Reset() { *m = Peer{} } +func (m *Peer) String() string { return proto.CompactTextString(m) } +func (*Peer) ProtoMessage() {} +func (*Peer) Descriptor() ([]byte, []int) { + return fileDescriptor_metapb_3f810cf7445fc1b4, []int{5} +} +func (m *Peer) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Peer) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Peer.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 *Peer) XXX_Merge(src proto.Message) { + xxx_messageInfo_Peer.Merge(dst, src) +} +func (m *Peer) XXX_Size() int { + return m.Size() +} +func (m *Peer) XXX_DiscardUnknown() { + xxx_messageInfo_Peer.DiscardUnknown(m) +} + +var xxx_messageInfo_Peer proto.InternalMessageInfo func (m *Peer) GetId() uint64 { if m != nil { @@ -301,6 +476,9 @@ func (m *Cluster) MarshalTo(dAtA []byte) (int, error) { i++ i = encodeVarintMetapb(dAtA, i, uint64(m.MaxPeerCount)) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -331,6 +509,9 @@ func (m *StoreLabel) MarshalTo(dAtA []byte) (int, error) { i = encodeVarintMetapb(dAtA, i, uint64(len(m.Value))) i += copy(dAtA[i:], m.Value) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -383,6 +564,9 @@ func (m *Store) MarshalTo(dAtA []byte) (int, error) { i = encodeVarintMetapb(dAtA, i, uint64(len(m.Version))) i += copy(dAtA[i:], m.Version) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -411,6 +595,9 @@ func (m *RegionEpoch) MarshalTo(dAtA []byte) (int, error) { i++ i = encodeVarintMetapb(dAtA, i, uint64(m.Version)) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -468,6 +655,9 @@ func (m *Region) MarshalTo(dAtA []byte) (int, error) { i += n } } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -506,27 +696,12 @@ func (m *Peer) MarshalTo(dAtA []byte) (int, error) { } i++ } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } -func encodeFixed64Metapb(dAtA []byte, offset int, v uint64) int { - dAtA[offset] = uint8(v) - dAtA[offset+1] = uint8(v >> 8) - dAtA[offset+2] = uint8(v >> 16) - dAtA[offset+3] = uint8(v >> 24) - dAtA[offset+4] = uint8(v >> 32) - dAtA[offset+5] = uint8(v >> 40) - dAtA[offset+6] = uint8(v >> 48) - dAtA[offset+7] = uint8(v >> 56) - return offset + 8 -} -func encodeFixed32Metapb(dAtA []byte, offset int, v uint32) int { - dAtA[offset] = uint8(v) - dAtA[offset+1] = uint8(v >> 8) - dAtA[offset+2] = uint8(v >> 16) - dAtA[offset+3] = uint8(v >> 24) - return offset + 4 -} func encodeVarintMetapb(dAtA []byte, offset int, v uint64) int { for v >= 1<<7 { dAtA[offset] = uint8(v&0x7f | 0x80) @@ -545,6 +720,9 @@ func (m *Cluster) Size() (n int) { if m.MaxPeerCount != 0 { n += 1 + sovMetapb(uint64(m.MaxPeerCount)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -559,6 +737,9 @@ func (m *StoreLabel) Size() (n int) { if l > 0 { n += 1 + l + sovMetapb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -585,6 +766,9 @@ func (m *Store) Size() (n int) { if l > 0 { n += 1 + l + sovMetapb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -597,6 +781,9 @@ func (m *RegionEpoch) Size() (n int) { if m.Version != 0 { n += 1 + sovMetapb(uint64(m.Version)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -624,6 +811,9 @@ func (m *Region) Size() (n int) { n += 1 + l + sovMetapb(uint64(l)) } } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -639,6 +829,9 @@ func (m *Peer) Size() (n int) { if m.IsLearner { n += 2 } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -734,6 +927,7 @@ func (m *Cluster) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -842,6 +1036,7 @@ func (m *StoreLabel) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -1019,6 +1214,7 @@ func (m *Store) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -1107,6 +1303,7 @@ func (m *RegionEpoch) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -1302,6 +1499,7 @@ func (m *Region) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -1410,6 +1608,7 @@ func (m *Peer) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -1524,9 +1723,9 @@ var ( ErrIntOverflowMetapb = fmt.Errorf("proto: integer overflow") ) -func init() { proto.RegisterFile("metapb.proto", fileDescriptorMetapb) } +func init() { proto.RegisterFile("metapb.proto", fileDescriptor_metapb_3f810cf7445fc1b4) } -var fileDescriptorMetapb = []byte{ +var fileDescriptor_metapb_3f810cf7445fc1b4 = []byte{ // 479 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x64, 0x52, 0xc1, 0x8e, 0xd3, 0x3c, 0x10, 0x5e, 0xa7, 0x4d, 0xda, 0x4e, 0xbb, 0x55, 0xe5, 0x7f, 0xa5, 0x3f, 0x0b, 0xa2, 0xaa, 0x22, diff --git a/vendor/github.com/pingcap/kvproto/pkg/pdpb/pdpb.pb.go b/vendor/github.com/pingcap/kvproto/pkg/pdpb/pdpb.pb.go index e0a6dce3dca23..924f72057774b 100644 --- a/vendor/github.com/pingcap/kvproto/pkg/pdpb/pdpb.pb.go +++ b/vendor/github.com/pingcap/kvproto/pkg/pdpb/pdpb.pb.go @@ -1,69 +1,6 @@ -// Code generated by protoc-gen-gogo. +// Code generated by protoc-gen-gogo. DO NOT EDIT. // source: pdpb.proto -// DO NOT EDIT! - -/* - Package pdpb is a generated protocol buffer package. - - It is generated from these files: - pdpb.proto - - It has these top-level messages: - RequestHeader - ResponseHeader - Error - TsoRequest - Timestamp - TsoResponse - BootstrapRequest - BootstrapResponse - IsBootstrappedRequest - IsBootstrappedResponse - AllocIDRequest - AllocIDResponse - GetStoreRequest - GetStoreResponse - PutStoreRequest - PutStoreResponse - GetAllStoresRequest - GetAllStoresResponse - GetRegionRequest - GetRegionResponse - GetRegionByIDRequest - GetClusterConfigRequest - GetClusterConfigResponse - PutClusterConfigRequest - PutClusterConfigResponse - Member - GetMembersRequest - GetMembersResponse - PeerStats - RegionHeartbeatRequest - ChangePeer - TransferLeader - Merge - SplitRegion - RegionHeartbeatResponse - AskSplitRequest - AskSplitResponse - ReportSplitRequest - ReportSplitResponse - AskBatchSplitRequest - SplitID - AskBatchSplitResponse - ReportBatchSplitRequest - ReportBatchSplitResponse - TimeInterval - StoreStats - StoreHeartbeatRequest - StoreHeartbeatResponse - ScatterRegionRequest - ScatterRegionResponse - GetGCSafePointRequest - GetGCSafePointResponse - UpdateGCSafePointRequest - UpdateGCSafePointResponse -*/ + package pdpb import ( @@ -73,10 +10,12 @@ import ( proto "github.com/golang/protobuf/proto" - metapb "github.com/pingcap/kvproto/pkg/metapb" + _ "github.com/gogo/protobuf/gogoproto" eraftpb "github.com/pingcap/kvproto/pkg/eraftpb" + metapb "github.com/pingcap/kvproto/pkg/metapb" + context "golang.org/x/net/context" grpc "google.golang.org/grpc" @@ -124,7 +63,9 @@ var ErrorType_value = map[string]int32{ func (x ErrorType) String() string { return proto.EnumName(ErrorType_name, int32(x)) } -func (ErrorType) EnumDescriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{0} } +func (ErrorType) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_pdpb_151bd877a46a223e, []int{0} +} type CheckPolicy int32 @@ -145,17 +86,50 @@ var CheckPolicy_value = map[string]int32{ func (x CheckPolicy) String() string { return proto.EnumName(CheckPolicy_name, int32(x)) } -func (CheckPolicy) EnumDescriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{1} } +func (CheckPolicy) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_pdpb_151bd877a46a223e, []int{1} +} type RequestHeader struct { // cluster_id is the ID of the cluster which be sent to. - ClusterId uint64 `protobuf:"varint,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"` + ClusterId uint64 `protobuf:"varint,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +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_151bd877a46a223e, []int{0} +} +func (m *RequestHeader) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RequestHeader) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RequestHeader.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 *RequestHeader) XXX_Merge(src proto.Message) { + xxx_messageInfo_RequestHeader.Merge(dst, src) +} +func (m *RequestHeader) XXX_Size() int { + return m.Size() +} +func (m *RequestHeader) XXX_DiscardUnknown() { + xxx_messageInfo_RequestHeader.DiscardUnknown(m) } -func (m *RequestHeader) Reset() { *m = RequestHeader{} } -func (m *RequestHeader) String() string { return proto.CompactTextString(m) } -func (*RequestHeader) ProtoMessage() {} -func (*RequestHeader) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{0} } +var xxx_messageInfo_RequestHeader proto.InternalMessageInfo func (m *RequestHeader) GetClusterId() uint64 { if m != nil { @@ -166,14 +140,45 @@ func (m *RequestHeader) GetClusterId() uint64 { type ResponseHeader struct { // cluster_id is the ID of the cluster which sent the response. - ClusterId uint64 `protobuf:"varint,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"` - Error *Error `protobuf:"bytes,2,opt,name=error" json:"error,omitempty"` + ClusterId uint64 `protobuf:"varint,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"` + Error *Error `protobuf:"bytes,2,opt,name=error" json:"error,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +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_151bd877a46a223e, []int{1} +} +func (m *ResponseHeader) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ResponseHeader) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ResponseHeader.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 *ResponseHeader) XXX_Merge(src proto.Message) { + xxx_messageInfo_ResponseHeader.Merge(dst, src) +} +func (m *ResponseHeader) XXX_Size() int { + return m.Size() +} +func (m *ResponseHeader) XXX_DiscardUnknown() { + xxx_messageInfo_ResponseHeader.DiscardUnknown(m) } -func (m *ResponseHeader) Reset() { *m = ResponseHeader{} } -func (m *ResponseHeader) String() string { return proto.CompactTextString(m) } -func (*ResponseHeader) ProtoMessage() {} -func (*ResponseHeader) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{1} } +var xxx_messageInfo_ResponseHeader proto.InternalMessageInfo func (m *ResponseHeader) GetClusterId() uint64 { if m != nil { @@ -190,14 +195,45 @@ func (m *ResponseHeader) GetError() *Error { } type Error struct { - Type ErrorType `protobuf:"varint,1,opt,name=type,proto3,enum=pdpb.ErrorType" json:"type,omitempty"` - Message string `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"` + Type ErrorType `protobuf:"varint,1,opt,name=type,proto3,enum=pdpb.ErrorType" json:"type,omitempty"` + Message string `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +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_151bd877a46a223e, []int{2} +} +func (m *Error) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Error) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Error.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 *Error) XXX_Merge(src proto.Message) { + xxx_messageInfo_Error.Merge(dst, src) +} +func (m *Error) XXX_Size() int { + return m.Size() +} +func (m *Error) XXX_DiscardUnknown() { + xxx_messageInfo_Error.DiscardUnknown(m) } -func (m *Error) Reset() { *m = Error{} } -func (m *Error) String() string { return proto.CompactTextString(m) } -func (*Error) ProtoMessage() {} -func (*Error) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{2} } +var xxx_messageInfo_Error proto.InternalMessageInfo func (m *Error) GetType() ErrorType { if m != nil { @@ -214,14 +250,45 @@ func (m *Error) GetMessage() string { } type TsoRequest struct { - Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` - Count uint32 `protobuf:"varint,2,opt,name=count,proto3" json:"count,omitempty"` + Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + Count uint32 `protobuf:"varint,2,opt,name=count,proto3" json:"count,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +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_151bd877a46a223e, []int{3} +} +func (m *TsoRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *TsoRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_TsoRequest.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 *TsoRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_TsoRequest.Merge(dst, src) +} +func (m *TsoRequest) XXX_Size() int { + return m.Size() +} +func (m *TsoRequest) XXX_DiscardUnknown() { + xxx_messageInfo_TsoRequest.DiscardUnknown(m) } -func (m *TsoRequest) Reset() { *m = TsoRequest{} } -func (m *TsoRequest) String() string { return proto.CompactTextString(m) } -func (*TsoRequest) ProtoMessage() {} -func (*TsoRequest) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{3} } +var xxx_messageInfo_TsoRequest proto.InternalMessageInfo func (m *TsoRequest) GetHeader() *RequestHeader { if m != nil { @@ -238,14 +305,45 @@ func (m *TsoRequest) GetCount() uint32 { } type Timestamp struct { - Physical int64 `protobuf:"varint,1,opt,name=physical,proto3" json:"physical,omitempty"` - Logical int64 `protobuf:"varint,2,opt,name=logical,proto3" json:"logical,omitempty"` + Physical int64 `protobuf:"varint,1,opt,name=physical,proto3" json:"physical,omitempty"` + Logical int64 `protobuf:"varint,2,opt,name=logical,proto3" json:"logical,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +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_151bd877a46a223e, []int{4} +} +func (m *Timestamp) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Timestamp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Timestamp.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 *Timestamp) XXX_Merge(src proto.Message) { + xxx_messageInfo_Timestamp.Merge(dst, src) +} +func (m *Timestamp) XXX_Size() int { + return m.Size() +} +func (m *Timestamp) XXX_DiscardUnknown() { + xxx_messageInfo_Timestamp.DiscardUnknown(m) } -func (m *Timestamp) Reset() { *m = Timestamp{} } -func (m *Timestamp) String() string { return proto.CompactTextString(m) } -func (*Timestamp) ProtoMessage() {} -func (*Timestamp) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{4} } +var xxx_messageInfo_Timestamp proto.InternalMessageInfo func (m *Timestamp) GetPhysical() int64 { if m != nil { @@ -262,15 +360,46 @@ func (m *Timestamp) GetLogical() int64 { } type TsoResponse struct { - Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` - Count uint32 `protobuf:"varint,2,opt,name=count,proto3" json:"count,omitempty"` - Timestamp *Timestamp `protobuf:"bytes,3,opt,name=timestamp" json:"timestamp,omitempty"` + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + Count uint32 `protobuf:"varint,2,opt,name=count,proto3" json:"count,omitempty"` + Timestamp *Timestamp `protobuf:"bytes,3,opt,name=timestamp" json:"timestamp,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +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_151bd877a46a223e, []int{5} +} +func (m *TsoResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *TsoResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_TsoResponse.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 *TsoResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_TsoResponse.Merge(dst, src) +} +func (m *TsoResponse) XXX_Size() int { + return m.Size() +} +func (m *TsoResponse) XXX_DiscardUnknown() { + xxx_messageInfo_TsoResponse.DiscardUnknown(m) } -func (m *TsoResponse) Reset() { *m = TsoResponse{} } -func (m *TsoResponse) String() string { return proto.CompactTextString(m) } -func (*TsoResponse) ProtoMessage() {} -func (*TsoResponse) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{5} } +var xxx_messageInfo_TsoResponse proto.InternalMessageInfo func (m *TsoResponse) GetHeader() *ResponseHeader { if m != nil { @@ -294,15 +423,46 @@ func (m *TsoResponse) GetTimestamp() *Timestamp { } type BootstrapRequest struct { - Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` - Store *metapb.Store `protobuf:"bytes,2,opt,name=store" json:"store,omitempty"` - Region *metapb.Region `protobuf:"bytes,3,opt,name=region" json:"region,omitempty"` + Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + Store *metapb.Store `protobuf:"bytes,2,opt,name=store" json:"store,omitempty"` + Region *metapb.Region `protobuf:"bytes,3,opt,name=region" json:"region,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +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_151bd877a46a223e, []int{6} +} +func (m *BootstrapRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *BootstrapRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_BootstrapRequest.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 *BootstrapRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_BootstrapRequest.Merge(dst, src) +} +func (m *BootstrapRequest) XXX_Size() int { + return m.Size() +} +func (m *BootstrapRequest) XXX_DiscardUnknown() { + xxx_messageInfo_BootstrapRequest.DiscardUnknown(m) } -func (m *BootstrapRequest) Reset() { *m = BootstrapRequest{} } -func (m *BootstrapRequest) String() string { return proto.CompactTextString(m) } -func (*BootstrapRequest) ProtoMessage() {} -func (*BootstrapRequest) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{6} } +var xxx_messageInfo_BootstrapRequest proto.InternalMessageInfo func (m *BootstrapRequest) GetHeader() *RequestHeader { if m != nil { @@ -326,13 +486,44 @@ func (m *BootstrapRequest) GetRegion() *metapb.Region { } type BootstrapResponse struct { - Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,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_151bd877a46a223e, []int{7} +} +func (m *BootstrapResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *BootstrapResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_BootstrapResponse.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 *BootstrapResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_BootstrapResponse.Merge(dst, src) +} +func (m *BootstrapResponse) XXX_Size() int { + return m.Size() +} +func (m *BootstrapResponse) XXX_DiscardUnknown() { + xxx_messageInfo_BootstrapResponse.DiscardUnknown(m) } -func (m *BootstrapResponse) Reset() { *m = BootstrapResponse{} } -func (m *BootstrapResponse) String() string { return proto.CompactTextString(m) } -func (*BootstrapResponse) ProtoMessage() {} -func (*BootstrapResponse) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{7} } +var xxx_messageInfo_BootstrapResponse proto.InternalMessageInfo func (m *BootstrapResponse) GetHeader() *ResponseHeader { if m != nil { @@ -342,13 +533,44 @@ func (m *BootstrapResponse) GetHeader() *ResponseHeader { } type IsBootstrappedRequest struct { - Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +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_151bd877a46a223e, []int{8} +} +func (m *IsBootstrappedRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *IsBootstrappedRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_IsBootstrappedRequest.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 *IsBootstrappedRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_IsBootstrappedRequest.Merge(dst, src) +} +func (m *IsBootstrappedRequest) XXX_Size() int { + return m.Size() +} +func (m *IsBootstrappedRequest) XXX_DiscardUnknown() { + xxx_messageInfo_IsBootstrappedRequest.DiscardUnknown(m) } -func (m *IsBootstrappedRequest) Reset() { *m = IsBootstrappedRequest{} } -func (m *IsBootstrappedRequest) String() string { return proto.CompactTextString(m) } -func (*IsBootstrappedRequest) ProtoMessage() {} -func (*IsBootstrappedRequest) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{8} } +var xxx_messageInfo_IsBootstrappedRequest proto.InternalMessageInfo func (m *IsBootstrappedRequest) GetHeader() *RequestHeader { if m != nil { @@ -358,14 +580,45 @@ func (m *IsBootstrappedRequest) GetHeader() *RequestHeader { } type IsBootstrappedResponse struct { - Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` - Bootstrapped bool `protobuf:"varint,2,opt,name=bootstrapped,proto3" json:"bootstrapped,omitempty"` + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + Bootstrapped bool `protobuf:"varint,2,opt,name=bootstrapped,proto3" json:"bootstrapped,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +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_151bd877a46a223e, []int{9} +} +func (m *IsBootstrappedResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *IsBootstrappedResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_IsBootstrappedResponse.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 *IsBootstrappedResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_IsBootstrappedResponse.Merge(dst, src) +} +func (m *IsBootstrappedResponse) XXX_Size() int { + return m.Size() +} +func (m *IsBootstrappedResponse) XXX_DiscardUnknown() { + xxx_messageInfo_IsBootstrappedResponse.DiscardUnknown(m) } -func (m *IsBootstrappedResponse) Reset() { *m = IsBootstrappedResponse{} } -func (m *IsBootstrappedResponse) String() string { return proto.CompactTextString(m) } -func (*IsBootstrappedResponse) ProtoMessage() {} -func (*IsBootstrappedResponse) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{9} } +var xxx_messageInfo_IsBootstrappedResponse proto.InternalMessageInfo func (m *IsBootstrappedResponse) GetHeader() *ResponseHeader { if m != nil { @@ -382,13 +635,44 @@ func (m *IsBootstrappedResponse) GetBootstrapped() bool { } type AllocIDRequest struct { - Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +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_151bd877a46a223e, []int{10} +} +func (m *AllocIDRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *AllocIDRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_AllocIDRequest.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 *AllocIDRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_AllocIDRequest.Merge(dst, src) +} +func (m *AllocIDRequest) XXX_Size() int { + return m.Size() +} +func (m *AllocIDRequest) XXX_DiscardUnknown() { + xxx_messageInfo_AllocIDRequest.DiscardUnknown(m) } -func (m *AllocIDRequest) Reset() { *m = AllocIDRequest{} } -func (m *AllocIDRequest) String() string { return proto.CompactTextString(m) } -func (*AllocIDRequest) ProtoMessage() {} -func (*AllocIDRequest) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{10} } +var xxx_messageInfo_AllocIDRequest proto.InternalMessageInfo func (m *AllocIDRequest) GetHeader() *RequestHeader { if m != nil { @@ -398,14 +682,45 @@ func (m *AllocIDRequest) GetHeader() *RequestHeader { } type AllocIDResponse struct { - Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` - Id uint64 `protobuf:"varint,2,opt,name=id,proto3" json:"id,omitempty"` + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + Id uint64 `protobuf:"varint,2,opt,name=id,proto3" json:"id,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +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_151bd877a46a223e, []int{11} +} +func (m *AllocIDResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *AllocIDResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_AllocIDResponse.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 *AllocIDResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_AllocIDResponse.Merge(dst, src) +} +func (m *AllocIDResponse) XXX_Size() int { + return m.Size() +} +func (m *AllocIDResponse) XXX_DiscardUnknown() { + xxx_messageInfo_AllocIDResponse.DiscardUnknown(m) } -func (m *AllocIDResponse) Reset() { *m = AllocIDResponse{} } -func (m *AllocIDResponse) String() string { return proto.CompactTextString(m) } -func (*AllocIDResponse) ProtoMessage() {} -func (*AllocIDResponse) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{11} } +var xxx_messageInfo_AllocIDResponse proto.InternalMessageInfo func (m *AllocIDResponse) GetHeader() *ResponseHeader { if m != nil { @@ -422,14 +737,45 @@ func (m *AllocIDResponse) GetId() uint64 { } type GetStoreRequest struct { - Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` - StoreId uint64 `protobuf:"varint,2,opt,name=store_id,json=storeId,proto3" json:"store_id,omitempty"` + Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + StoreId uint64 `protobuf:"varint,2,opt,name=store_id,json=storeId,proto3" json:"store_id,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +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_151bd877a46a223e, []int{12} +} +func (m *GetStoreRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GetStoreRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GetStoreRequest.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 *GetStoreRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetStoreRequest.Merge(dst, src) +} +func (m *GetStoreRequest) XXX_Size() int { + return m.Size() +} +func (m *GetStoreRequest) XXX_DiscardUnknown() { + xxx_messageInfo_GetStoreRequest.DiscardUnknown(m) } -func (m *GetStoreRequest) Reset() { *m = GetStoreRequest{} } -func (m *GetStoreRequest) String() string { return proto.CompactTextString(m) } -func (*GetStoreRequest) ProtoMessage() {} -func (*GetStoreRequest) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{12} } +var xxx_messageInfo_GetStoreRequest proto.InternalMessageInfo func (m *GetStoreRequest) GetHeader() *RequestHeader { if m != nil { @@ -446,14 +792,45 @@ func (m *GetStoreRequest) GetStoreId() uint64 { } type GetStoreResponse struct { - Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` - Store *metapb.Store `protobuf:"bytes,2,opt,name=store" json:"store,omitempty"` + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + Store *metapb.Store `protobuf:"bytes,2,opt,name=store" json:"store,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +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_151bd877a46a223e, []int{13} +} +func (m *GetStoreResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GetStoreResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GetStoreResponse.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 *GetStoreResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetStoreResponse.Merge(dst, src) +} +func (m *GetStoreResponse) XXX_Size() int { + return m.Size() +} +func (m *GetStoreResponse) XXX_DiscardUnknown() { + xxx_messageInfo_GetStoreResponse.DiscardUnknown(m) } -func (m *GetStoreResponse) Reset() { *m = GetStoreResponse{} } -func (m *GetStoreResponse) String() string { return proto.CompactTextString(m) } -func (*GetStoreResponse) ProtoMessage() {} -func (*GetStoreResponse) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{13} } +var xxx_messageInfo_GetStoreResponse proto.InternalMessageInfo func (m *GetStoreResponse) GetHeader() *ResponseHeader { if m != nil { @@ -470,14 +847,45 @@ func (m *GetStoreResponse) GetStore() *metapb.Store { } type PutStoreRequest struct { - Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` - Store *metapb.Store `protobuf:"bytes,2,opt,name=store" json:"store,omitempty"` + Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + Store *metapb.Store `protobuf:"bytes,2,opt,name=store" json:"store,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +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_151bd877a46a223e, []int{14} +} +func (m *PutStoreRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *PutStoreRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_PutStoreRequest.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 *PutStoreRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_PutStoreRequest.Merge(dst, src) +} +func (m *PutStoreRequest) XXX_Size() int { + return m.Size() +} +func (m *PutStoreRequest) XXX_DiscardUnknown() { + xxx_messageInfo_PutStoreRequest.DiscardUnknown(m) } -func (m *PutStoreRequest) Reset() { *m = PutStoreRequest{} } -func (m *PutStoreRequest) String() string { return proto.CompactTextString(m) } -func (*PutStoreRequest) ProtoMessage() {} -func (*PutStoreRequest) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{14} } +var xxx_messageInfo_PutStoreRequest proto.InternalMessageInfo func (m *PutStoreRequest) GetHeader() *RequestHeader { if m != nil { @@ -494,13 +902,44 @@ func (m *PutStoreRequest) GetStore() *metapb.Store { } type PutStoreResponse struct { - Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,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_151bd877a46a223e, []int{15} +} +func (m *PutStoreResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *PutStoreResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_PutStoreResponse.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 *PutStoreResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_PutStoreResponse.Merge(dst, src) +} +func (m *PutStoreResponse) XXX_Size() int { + return m.Size() +} +func (m *PutStoreResponse) XXX_DiscardUnknown() { + xxx_messageInfo_PutStoreResponse.DiscardUnknown(m) } -func (m *PutStoreResponse) Reset() { *m = PutStoreResponse{} } -func (m *PutStoreResponse) String() string { return proto.CompactTextString(m) } -func (*PutStoreResponse) ProtoMessage() {} -func (*PutStoreResponse) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{15} } +var xxx_messageInfo_PutStoreResponse proto.InternalMessageInfo func (m *PutStoreResponse) GetHeader() *ResponseHeader { if m != nil { @@ -510,13 +949,44 @@ func (m *PutStoreResponse) GetHeader() *ResponseHeader { } type GetAllStoresRequest struct { - Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +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_151bd877a46a223e, []int{16} +} +func (m *GetAllStoresRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GetAllStoresRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GetAllStoresRequest.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 *GetAllStoresRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetAllStoresRequest.Merge(dst, src) +} +func (m *GetAllStoresRequest) XXX_Size() int { + return m.Size() +} +func (m *GetAllStoresRequest) XXX_DiscardUnknown() { + xxx_messageInfo_GetAllStoresRequest.DiscardUnknown(m) } -func (m *GetAllStoresRequest) Reset() { *m = GetAllStoresRequest{} } -func (m *GetAllStoresRequest) String() string { return proto.CompactTextString(m) } -func (*GetAllStoresRequest) ProtoMessage() {} -func (*GetAllStoresRequest) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{16} } +var xxx_messageInfo_GetAllStoresRequest proto.InternalMessageInfo func (m *GetAllStoresRequest) GetHeader() *RequestHeader { if m != nil { @@ -526,14 +996,45 @@ func (m *GetAllStoresRequest) GetHeader() *RequestHeader { } type GetAllStoresResponse struct { - Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` - Stores []*metapb.Store `protobuf:"bytes,2,rep,name=stores" json:"stores,omitempty"` + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + Stores []*metapb.Store `protobuf:"bytes,2,rep,name=stores" json:"stores,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +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_151bd877a46a223e, []int{17} +} +func (m *GetAllStoresResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GetAllStoresResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GetAllStoresResponse.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 *GetAllStoresResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetAllStoresResponse.Merge(dst, src) +} +func (m *GetAllStoresResponse) XXX_Size() int { + return m.Size() +} +func (m *GetAllStoresResponse) XXX_DiscardUnknown() { + xxx_messageInfo_GetAllStoresResponse.DiscardUnknown(m) } -func (m *GetAllStoresResponse) Reset() { *m = GetAllStoresResponse{} } -func (m *GetAllStoresResponse) String() string { return proto.CompactTextString(m) } -func (*GetAllStoresResponse) ProtoMessage() {} -func (*GetAllStoresResponse) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{17} } +var xxx_messageInfo_GetAllStoresResponse proto.InternalMessageInfo func (m *GetAllStoresResponse) GetHeader() *ResponseHeader { if m != nil { @@ -550,14 +1051,45 @@ func (m *GetAllStoresResponse) GetStores() []*metapb.Store { } type GetRegionRequest struct { - Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` - RegionKey []byte `protobuf:"bytes,2,opt,name=region_key,json=regionKey,proto3" json:"region_key,omitempty"` + Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + RegionKey []byte `protobuf:"bytes,2,opt,name=region_key,json=regionKey,proto3" json:"region_key,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +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_151bd877a46a223e, []int{18} +} +func (m *GetRegionRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GetRegionRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GetRegionRequest.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 *GetRegionRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetRegionRequest.Merge(dst, src) +} +func (m *GetRegionRequest) XXX_Size() int { + return m.Size() +} +func (m *GetRegionRequest) XXX_DiscardUnknown() { + xxx_messageInfo_GetRegionRequest.DiscardUnknown(m) } -func (m *GetRegionRequest) Reset() { *m = GetRegionRequest{} } -func (m *GetRegionRequest) String() string { return proto.CompactTextString(m) } -func (*GetRegionRequest) ProtoMessage() {} -func (*GetRegionRequest) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{18} } +var xxx_messageInfo_GetRegionRequest proto.InternalMessageInfo func (m *GetRegionRequest) GetHeader() *RequestHeader { if m != nil { @@ -574,15 +1106,46 @@ func (m *GetRegionRequest) GetRegionKey() []byte { } type GetRegionResponse struct { - Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` - Region *metapb.Region `protobuf:"bytes,2,opt,name=region" json:"region,omitempty"` - Leader *metapb.Peer `protobuf:"bytes,3,opt,name=leader" json:"leader,omitempty"` + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + Region *metapb.Region `protobuf:"bytes,2,opt,name=region" json:"region,omitempty"` + Leader *metapb.Peer `protobuf:"bytes,3,opt,name=leader" json:"leader,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +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_151bd877a46a223e, []int{19} +} +func (m *GetRegionResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GetRegionResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GetRegionResponse.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 *GetRegionResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetRegionResponse.Merge(dst, src) +} +func (m *GetRegionResponse) XXX_Size() int { + return m.Size() +} +func (m *GetRegionResponse) XXX_DiscardUnknown() { + xxx_messageInfo_GetRegionResponse.DiscardUnknown(m) } -func (m *GetRegionResponse) Reset() { *m = GetRegionResponse{} } -func (m *GetRegionResponse) String() string { return proto.CompactTextString(m) } -func (*GetRegionResponse) ProtoMessage() {} -func (*GetRegionResponse) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{19} } +var xxx_messageInfo_GetRegionResponse proto.InternalMessageInfo func (m *GetRegionResponse) GetHeader() *ResponseHeader { if m != nil { @@ -606,14 +1169,45 @@ func (m *GetRegionResponse) GetLeader() *metapb.Peer { } type GetRegionByIDRequest struct { - Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` - RegionId uint64 `protobuf:"varint,2,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty"` + Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + RegionId uint64 `protobuf:"varint,2,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *GetRegionByIDRequest) Reset() { *m = GetRegionByIDRequest{} } +func (m *GetRegionByIDRequest) String() string { return proto.CompactTextString(m) } +func (*GetRegionByIDRequest) ProtoMessage() {} +func (*GetRegionByIDRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_pdpb_151bd877a46a223e, []int{20} +} +func (m *GetRegionByIDRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GetRegionByIDRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GetRegionByIDRequest.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 *GetRegionByIDRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetRegionByIDRequest.Merge(dst, src) +} +func (m *GetRegionByIDRequest) XXX_Size() int { + return m.Size() +} +func (m *GetRegionByIDRequest) XXX_DiscardUnknown() { + xxx_messageInfo_GetRegionByIDRequest.DiscardUnknown(m) } -func (m *GetRegionByIDRequest) Reset() { *m = GetRegionByIDRequest{} } -func (m *GetRegionByIDRequest) String() string { return proto.CompactTextString(m) } -func (*GetRegionByIDRequest) ProtoMessage() {} -func (*GetRegionByIDRequest) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{20} } +var xxx_messageInfo_GetRegionByIDRequest proto.InternalMessageInfo func (m *GetRegionByIDRequest) GetHeader() *RequestHeader { if m != nil { @@ -630,13 +1224,44 @@ func (m *GetRegionByIDRequest) GetRegionId() uint64 { } type GetClusterConfigRequest struct { - Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +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_151bd877a46a223e, []int{21} +} +func (m *GetClusterConfigRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GetClusterConfigRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GetClusterConfigRequest.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 *GetClusterConfigRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetClusterConfigRequest.Merge(dst, src) +} +func (m *GetClusterConfigRequest) XXX_Size() int { + return m.Size() +} +func (m *GetClusterConfigRequest) XXX_DiscardUnknown() { + xxx_messageInfo_GetClusterConfigRequest.DiscardUnknown(m) } -func (m *GetClusterConfigRequest) Reset() { *m = GetClusterConfigRequest{} } -func (m *GetClusterConfigRequest) String() string { return proto.CompactTextString(m) } -func (*GetClusterConfigRequest) ProtoMessage() {} -func (*GetClusterConfigRequest) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{21} } +var xxx_messageInfo_GetClusterConfigRequest proto.InternalMessageInfo func (m *GetClusterConfigRequest) GetHeader() *RequestHeader { if m != nil { @@ -646,14 +1271,45 @@ func (m *GetClusterConfigRequest) GetHeader() *RequestHeader { } type GetClusterConfigResponse struct { - Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` - Cluster *metapb.Cluster `protobuf:"bytes,2,opt,name=cluster" json:"cluster,omitempty"` + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + Cluster *metapb.Cluster `protobuf:"bytes,2,opt,name=cluster" json:"cluster,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *GetClusterConfigResponse) Reset() { *m = GetClusterConfigResponse{} } +func (m *GetClusterConfigResponse) String() string { return proto.CompactTextString(m) } +func (*GetClusterConfigResponse) ProtoMessage() {} +func (*GetClusterConfigResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_pdpb_151bd877a46a223e, []int{22} +} +func (m *GetClusterConfigResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GetClusterConfigResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GetClusterConfigResponse.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 *GetClusterConfigResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetClusterConfigResponse.Merge(dst, src) +} +func (m *GetClusterConfigResponse) XXX_Size() int { + return m.Size() +} +func (m *GetClusterConfigResponse) XXX_DiscardUnknown() { + xxx_messageInfo_GetClusterConfigResponse.DiscardUnknown(m) } -func (m *GetClusterConfigResponse) Reset() { *m = GetClusterConfigResponse{} } -func (m *GetClusterConfigResponse) String() string { return proto.CompactTextString(m) } -func (*GetClusterConfigResponse) ProtoMessage() {} -func (*GetClusterConfigResponse) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{22} } +var xxx_messageInfo_GetClusterConfigResponse proto.InternalMessageInfo func (m *GetClusterConfigResponse) GetHeader() *ResponseHeader { if m != nil { @@ -670,14 +1326,45 @@ func (m *GetClusterConfigResponse) GetCluster() *metapb.Cluster { } type PutClusterConfigRequest struct { - Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` - Cluster *metapb.Cluster `protobuf:"bytes,2,opt,name=cluster" json:"cluster,omitempty"` + Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + Cluster *metapb.Cluster `protobuf:"bytes,2,opt,name=cluster" json:"cluster,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +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_151bd877a46a223e, []int{23} +} +func (m *PutClusterConfigRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *PutClusterConfigRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_PutClusterConfigRequest.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 *PutClusterConfigRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_PutClusterConfigRequest.Merge(dst, src) +} +func (m *PutClusterConfigRequest) XXX_Size() int { + return m.Size() +} +func (m *PutClusterConfigRequest) XXX_DiscardUnknown() { + xxx_messageInfo_PutClusterConfigRequest.DiscardUnknown(m) } -func (m *PutClusterConfigRequest) Reset() { *m = PutClusterConfigRequest{} } -func (m *PutClusterConfigRequest) String() string { return proto.CompactTextString(m) } -func (*PutClusterConfigRequest) ProtoMessage() {} -func (*PutClusterConfigRequest) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{23} } +var xxx_messageInfo_PutClusterConfigRequest proto.InternalMessageInfo func (m *PutClusterConfigRequest) GetHeader() *RequestHeader { if m != nil { @@ -694,13 +1381,44 @@ func (m *PutClusterConfigRequest) GetCluster() *metapb.Cluster { } type PutClusterConfigResponse struct { - Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *PutClusterConfigResponse) Reset() { *m = PutClusterConfigResponse{} } +func (m *PutClusterConfigResponse) String() string { return proto.CompactTextString(m) } +func (*PutClusterConfigResponse) ProtoMessage() {} +func (*PutClusterConfigResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_pdpb_151bd877a46a223e, []int{24} +} +func (m *PutClusterConfigResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *PutClusterConfigResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_PutClusterConfigResponse.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 *PutClusterConfigResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_PutClusterConfigResponse.Merge(dst, src) +} +func (m *PutClusterConfigResponse) XXX_Size() int { + return m.Size() +} +func (m *PutClusterConfigResponse) XXX_DiscardUnknown() { + xxx_messageInfo_PutClusterConfigResponse.DiscardUnknown(m) } -func (m *PutClusterConfigResponse) Reset() { *m = PutClusterConfigResponse{} } -func (m *PutClusterConfigResponse) String() string { return proto.CompactTextString(m) } -func (*PutClusterConfigResponse) ProtoMessage() {} -func (*PutClusterConfigResponse) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{24} } +var xxx_messageInfo_PutClusterConfigResponse proto.InternalMessageInfo func (m *PutClusterConfigResponse) GetHeader() *ResponseHeader { if m != nil { @@ -713,16 +1431,47 @@ type Member struct { // name is the name of the PD member. Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` // member_id is the unique id of the PD member. - MemberId uint64 `protobuf:"varint,2,opt,name=member_id,json=memberId,proto3" json:"member_id,omitempty"` - PeerUrls []string `protobuf:"bytes,3,rep,name=peer_urls,json=peerUrls" json:"peer_urls,omitempty"` - ClientUrls []string `protobuf:"bytes,4,rep,name=client_urls,json=clientUrls" json:"client_urls,omitempty"` - LeaderPriority int32 `protobuf:"varint,5,opt,name=leader_priority,json=leaderPriority,proto3" json:"leader_priority,omitempty"` + MemberId uint64 `protobuf:"varint,2,opt,name=member_id,json=memberId,proto3" json:"member_id,omitempty"` + PeerUrls []string `protobuf:"bytes,3,rep,name=peer_urls,json=peerUrls" json:"peer_urls,omitempty"` + ClientUrls []string `protobuf:"bytes,4,rep,name=client_urls,json=clientUrls" json:"client_urls,omitempty"` + LeaderPriority int32 `protobuf:"varint,5,opt,name=leader_priority,json=leaderPriority,proto3" json:"leader_priority,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +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_151bd877a46a223e, []int{25} +} +func (m *Member) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Member) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Member.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 *Member) XXX_Merge(src proto.Message) { + xxx_messageInfo_Member.Merge(dst, src) +} +func (m *Member) XXX_Size() int { + return m.Size() +} +func (m *Member) XXX_DiscardUnknown() { + xxx_messageInfo_Member.DiscardUnknown(m) } -func (m *Member) Reset() { *m = Member{} } -func (m *Member) String() string { return proto.CompactTextString(m) } -func (*Member) ProtoMessage() {} -func (*Member) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{25} } +var xxx_messageInfo_Member proto.InternalMessageInfo func (m *Member) GetName() string { if m != nil { @@ -760,13 +1509,44 @@ func (m *Member) GetLeaderPriority() int32 { } type GetMembersRequest struct { - Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +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_151bd877a46a223e, []int{26} +} +func (m *GetMembersRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GetMembersRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GetMembersRequest.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 *GetMembersRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetMembersRequest.Merge(dst, src) +} +func (m *GetMembersRequest) XXX_Size() int { + return m.Size() +} +func (m *GetMembersRequest) XXX_DiscardUnknown() { + xxx_messageInfo_GetMembersRequest.DiscardUnknown(m) } -func (m *GetMembersRequest) Reset() { *m = GetMembersRequest{} } -func (m *GetMembersRequest) String() string { return proto.CompactTextString(m) } -func (*GetMembersRequest) ProtoMessage() {} -func (*GetMembersRequest) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{26} } +var xxx_messageInfo_GetMembersRequest proto.InternalMessageInfo func (m *GetMembersRequest) GetHeader() *RequestHeader { if m != nil { @@ -776,16 +1556,47 @@ func (m *GetMembersRequest) GetHeader() *RequestHeader { } type GetMembersResponse struct { - Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` - Members []*Member `protobuf:"bytes,2,rep,name=members" json:"members,omitempty"` - Leader *Member `protobuf:"bytes,3,opt,name=leader" json:"leader,omitempty"` - EtcdLeader *Member `protobuf:"bytes,4,opt,name=etcd_leader,json=etcdLeader" json:"etcd_leader,omitempty"` + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + Members []*Member `protobuf:"bytes,2,rep,name=members" json:"members,omitempty"` + Leader *Member `protobuf:"bytes,3,opt,name=leader" json:"leader,omitempty"` + EtcdLeader *Member `protobuf:"bytes,4,opt,name=etcd_leader,json=etcdLeader" json:"etcd_leader,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +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_151bd877a46a223e, []int{27} +} +func (m *GetMembersResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GetMembersResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GetMembersResponse.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 *GetMembersResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetMembersResponse.Merge(dst, src) +} +func (m *GetMembersResponse) XXX_Size() int { + return m.Size() +} +func (m *GetMembersResponse) XXX_DiscardUnknown() { + xxx_messageInfo_GetMembersResponse.DiscardUnknown(m) } -func (m *GetMembersResponse) Reset() { *m = GetMembersResponse{} } -func (m *GetMembersResponse) String() string { return proto.CompactTextString(m) } -func (*GetMembersResponse) ProtoMessage() {} -func (*GetMembersResponse) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{27} } +var xxx_messageInfo_GetMembersResponse proto.InternalMessageInfo func (m *GetMembersResponse) GetHeader() *ResponseHeader { if m != nil { @@ -816,14 +1627,45 @@ func (m *GetMembersResponse) GetEtcdLeader() *Member { } type PeerStats struct { - Peer *metapb.Peer `protobuf:"bytes,1,opt,name=peer" json:"peer,omitempty"` - DownSeconds uint64 `protobuf:"varint,2,opt,name=down_seconds,json=downSeconds,proto3" json:"down_seconds,omitempty"` + Peer *metapb.Peer `protobuf:"bytes,1,opt,name=peer" json:"peer,omitempty"` + DownSeconds uint64 `protobuf:"varint,2,opt,name=down_seconds,json=downSeconds,proto3" json:"down_seconds,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +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_151bd877a46a223e, []int{28} +} +func (m *PeerStats) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *PeerStats) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_PeerStats.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 *PeerStats) XXX_Merge(src proto.Message) { + xxx_messageInfo_PeerStats.Merge(dst, src) +} +func (m *PeerStats) XXX_Size() int { + return m.Size() +} +func (m *PeerStats) XXX_DiscardUnknown() { + xxx_messageInfo_PeerStats.DiscardUnknown(m) } -func (m *PeerStats) Reset() { *m = PeerStats{} } -func (m *PeerStats) String() string { return proto.CompactTextString(m) } -func (*PeerStats) ProtoMessage() {} -func (*PeerStats) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{28} } +var xxx_messageInfo_PeerStats proto.InternalMessageInfo func (m *PeerStats) GetPeer() *metapb.Peer { if m != nil { @@ -860,13 +1702,44 @@ type RegionHeartbeatRequest struct { // Actually reported time interval Interval *TimeInterval `protobuf:"bytes,12,opt,name=interval" json:"interval,omitempty"` // Approximate number of keys. - ApproximateKeys uint64 `protobuf:"varint,13,opt,name=approximate_keys,json=approximateKeys,proto3" json:"approximate_keys,omitempty"` + ApproximateKeys uint64 `protobuf:"varint,13,opt,name=approximate_keys,json=approximateKeys,proto3" json:"approximate_keys,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_151bd877a46a223e, []int{29} +} +func (m *RegionHeartbeatRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RegionHeartbeatRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RegionHeartbeatRequest.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 *RegionHeartbeatRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_RegionHeartbeatRequest.Merge(dst, src) +} +func (m *RegionHeartbeatRequest) XXX_Size() int { + return m.Size() +} +func (m *RegionHeartbeatRequest) XXX_DiscardUnknown() { + xxx_messageInfo_RegionHeartbeatRequest.DiscardUnknown(m) } -func (m *RegionHeartbeatRequest) Reset() { *m = RegionHeartbeatRequest{} } -func (m *RegionHeartbeatRequest) String() string { return proto.CompactTextString(m) } -func (*RegionHeartbeatRequest) ProtoMessage() {} -func (*RegionHeartbeatRequest) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{29} } +var xxx_messageInfo_RegionHeartbeatRequest proto.InternalMessageInfo func (m *RegionHeartbeatRequest) GetHeader() *RequestHeader { if m != nil { @@ -953,14 +1826,45 @@ func (m *RegionHeartbeatRequest) GetApproximateKeys() uint64 { } type ChangePeer struct { - Peer *metapb.Peer `protobuf:"bytes,1,opt,name=peer" json:"peer,omitempty"` - ChangeType eraftpb.ConfChangeType `protobuf:"varint,2,opt,name=change_type,json=changeType,proto3,enum=eraftpb.ConfChangeType" json:"change_type,omitempty"` + Peer *metapb.Peer `protobuf:"bytes,1,opt,name=peer" json:"peer,omitempty"` + ChangeType eraftpb.ConfChangeType `protobuf:"varint,2,opt,name=change_type,json=changeType,proto3,enum=eraftpb.ConfChangeType" json:"change_type,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +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_151bd877a46a223e, []int{30} +} +func (m *ChangePeer) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ChangePeer) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ChangePeer.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 *ChangePeer) XXX_Merge(src proto.Message) { + xxx_messageInfo_ChangePeer.Merge(dst, src) +} +func (m *ChangePeer) XXX_Size() int { + return m.Size() +} +func (m *ChangePeer) XXX_DiscardUnknown() { + xxx_messageInfo_ChangePeer.DiscardUnknown(m) } -func (m *ChangePeer) Reset() { *m = ChangePeer{} } -func (m *ChangePeer) String() string { return proto.CompactTextString(m) } -func (*ChangePeer) ProtoMessage() {} -func (*ChangePeer) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{30} } +var xxx_messageInfo_ChangePeer proto.InternalMessageInfo func (m *ChangePeer) GetPeer() *metapb.Peer { if m != nil { @@ -977,13 +1881,44 @@ func (m *ChangePeer) GetChangeType() eraftpb.ConfChangeType { } type TransferLeader struct { - Peer *metapb.Peer `protobuf:"bytes,1,opt,name=peer" json:"peer,omitempty"` + Peer *metapb.Peer `protobuf:"bytes,1,opt,name=peer" json:"peer,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +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_151bd877a46a223e, []int{31} +} +func (m *TransferLeader) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *TransferLeader) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_TransferLeader.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 *TransferLeader) XXX_Merge(src proto.Message) { + xxx_messageInfo_TransferLeader.Merge(dst, src) +} +func (m *TransferLeader) XXX_Size() int { + return m.Size() +} +func (m *TransferLeader) XXX_DiscardUnknown() { + xxx_messageInfo_TransferLeader.DiscardUnknown(m) } -func (m *TransferLeader) Reset() { *m = TransferLeader{} } -func (m *TransferLeader) String() string { return proto.CompactTextString(m) } -func (*TransferLeader) ProtoMessage() {} -func (*TransferLeader) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{31} } +var xxx_messageInfo_TransferLeader proto.InternalMessageInfo func (m *TransferLeader) GetPeer() *metapb.Peer { if m != nil { @@ -993,13 +1928,44 @@ func (m *TransferLeader) GetPeer() *metapb.Peer { } type Merge struct { - Target *metapb.Region `protobuf:"bytes,1,opt,name=target" json:"target,omitempty"` + Target *metapb.Region `protobuf:"bytes,1,opt,name=target" json:"target,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +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_151bd877a46a223e, []int{32} +} +func (m *Merge) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Merge) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Merge.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 *Merge) XXX_Merge(src proto.Message) { + xxx_messageInfo_Merge.Merge(dst, src) +} +func (m *Merge) XXX_Size() int { + return m.Size() +} +func (m *Merge) XXX_DiscardUnknown() { + xxx_messageInfo_Merge.DiscardUnknown(m) } -func (m *Merge) Reset() { *m = Merge{} } -func (m *Merge) String() string { return proto.CompactTextString(m) } -func (*Merge) ProtoMessage() {} -func (*Merge) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{32} } +var xxx_messageInfo_Merge proto.InternalMessageInfo func (m *Merge) GetTarget() *metapb.Region { if m != nil { @@ -1009,13 +1975,44 @@ func (m *Merge) GetTarget() *metapb.Region { } type SplitRegion struct { - Policy CheckPolicy `protobuf:"varint,1,opt,name=policy,proto3,enum=pdpb.CheckPolicy" json:"policy,omitempty"` + Policy CheckPolicy `protobuf:"varint,1,opt,name=policy,proto3,enum=pdpb.CheckPolicy" json:"policy,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +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_151bd877a46a223e, []int{33} +} +func (m *SplitRegion) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SplitRegion) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_SplitRegion.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 *SplitRegion) XXX_Merge(src proto.Message) { + xxx_messageInfo_SplitRegion.Merge(dst, src) +} +func (m *SplitRegion) XXX_Size() int { + return m.Size() +} +func (m *SplitRegion) XXX_DiscardUnknown() { + xxx_messageInfo_SplitRegion.DiscardUnknown(m) } -func (m *SplitRegion) Reset() { *m = SplitRegion{} } -func (m *SplitRegion) String() string { return proto.CompactTextString(m) } -func (*SplitRegion) ProtoMessage() {} -func (*SplitRegion) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{33} } +var xxx_messageInfo_SplitRegion proto.InternalMessageInfo func (m *SplitRegion) GetPolicy() CheckPolicy { if m != nil { @@ -1050,13 +2047,44 @@ type RegionHeartbeatResponse struct { TargetPeer *metapb.Peer `protobuf:"bytes,6,opt,name=target_peer,json=targetPeer" json:"target_peer,omitempty"` Merge *Merge `protobuf:"bytes,7,opt,name=merge" json:"merge,omitempty"` // PD sends split_region to let TiKV split a region into two regions. - SplitRegion *SplitRegion `protobuf:"bytes,8,opt,name=split_region,json=splitRegion" json:"split_region,omitempty"` + SplitRegion *SplitRegion `protobuf:"bytes,8,opt,name=split_region,json=splitRegion" json:"split_region,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +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_151bd877a46a223e, []int{34} +} +func (m *RegionHeartbeatResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RegionHeartbeatResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RegionHeartbeatResponse.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 *RegionHeartbeatResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_RegionHeartbeatResponse.Merge(dst, src) +} +func (m *RegionHeartbeatResponse) XXX_Size() int { + return m.Size() +} +func (m *RegionHeartbeatResponse) XXX_DiscardUnknown() { + xxx_messageInfo_RegionHeartbeatResponse.DiscardUnknown(m) } -func (m *RegionHeartbeatResponse) Reset() { *m = RegionHeartbeatResponse{} } -func (m *RegionHeartbeatResponse) String() string { return proto.CompactTextString(m) } -func (*RegionHeartbeatResponse) ProtoMessage() {} -func (*RegionHeartbeatResponse) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{34} } +var xxx_messageInfo_RegionHeartbeatResponse proto.InternalMessageInfo func (m *RegionHeartbeatResponse) GetHeader() *ResponseHeader { if m != nil { @@ -1115,14 +2143,45 @@ func (m *RegionHeartbeatResponse) GetSplitRegion() *SplitRegion { } type AskSplitRequest struct { - Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` - Region *metapb.Region `protobuf:"bytes,2,opt,name=region" json:"region,omitempty"` + Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + Region *metapb.Region `protobuf:"bytes,2,opt,name=region" json:"region,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +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_151bd877a46a223e, []int{35} +} +func (m *AskSplitRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *AskSplitRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_AskSplitRequest.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 *AskSplitRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_AskSplitRequest.Merge(dst, src) +} +func (m *AskSplitRequest) XXX_Size() int { + return m.Size() +} +func (m *AskSplitRequest) XXX_DiscardUnknown() { + xxx_messageInfo_AskSplitRequest.DiscardUnknown(m) } -func (m *AskSplitRequest) Reset() { *m = AskSplitRequest{} } -func (m *AskSplitRequest) String() string { return proto.CompactTextString(m) } -func (*AskSplitRequest) ProtoMessage() {} -func (*AskSplitRequest) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{35} } +var xxx_messageInfo_AskSplitRequest proto.InternalMessageInfo func (m *AskSplitRequest) GetHeader() *RequestHeader { if m != nil { @@ -1145,13 +2204,44 @@ type AskSplitResponse struct { // We must guarantee that the new_region_id is global unique. NewRegionId uint64 `protobuf:"varint,2,opt,name=new_region_id,json=newRegionId,proto3" json:"new_region_id,omitempty"` // The peer ids for the new split region. - NewPeerIds []uint64 `protobuf:"varint,3,rep,packed,name=new_peer_ids,json=newPeerIds" json:"new_peer_ids,omitempty"` + NewPeerIds []uint64 `protobuf:"varint,3,rep,packed,name=new_peer_ids,json=newPeerIds" json:"new_peer_ids,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +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_151bd877a46a223e, []int{36} +} +func (m *AskSplitResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *AskSplitResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_AskSplitResponse.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 *AskSplitResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_AskSplitResponse.Merge(dst, src) +} +func (m *AskSplitResponse) XXX_Size() int { + return m.Size() +} +func (m *AskSplitResponse) XXX_DiscardUnknown() { + xxx_messageInfo_AskSplitResponse.DiscardUnknown(m) } -func (m *AskSplitResponse) Reset() { *m = AskSplitResponse{} } -func (m *AskSplitResponse) String() string { return proto.CompactTextString(m) } -func (*AskSplitResponse) ProtoMessage() {} -func (*AskSplitResponse) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{36} } +var xxx_messageInfo_AskSplitResponse proto.InternalMessageInfo func (m *AskSplitResponse) GetHeader() *ResponseHeader { if m != nil { @@ -1175,15 +2265,46 @@ func (m *AskSplitResponse) GetNewPeerIds() []uint64 { } type ReportSplitRequest struct { - Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` - Left *metapb.Region `protobuf:"bytes,2,opt,name=left" json:"left,omitempty"` - Right *metapb.Region `protobuf:"bytes,3,opt,name=right" json:"right,omitempty"` + Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + Left *metapb.Region `protobuf:"bytes,2,opt,name=left" json:"left,omitempty"` + Right *metapb.Region `protobuf:"bytes,3,opt,name=right" json:"right,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +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_151bd877a46a223e, []int{37} +} +func (m *ReportSplitRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ReportSplitRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ReportSplitRequest.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 *ReportSplitRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ReportSplitRequest.Merge(dst, src) +} +func (m *ReportSplitRequest) XXX_Size() int { + return m.Size() +} +func (m *ReportSplitRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ReportSplitRequest.DiscardUnknown(m) } -func (m *ReportSplitRequest) Reset() { *m = ReportSplitRequest{} } -func (m *ReportSplitRequest) String() string { return proto.CompactTextString(m) } -func (*ReportSplitRequest) ProtoMessage() {} -func (*ReportSplitRequest) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{37} } +var xxx_messageInfo_ReportSplitRequest proto.InternalMessageInfo func (m *ReportSplitRequest) GetHeader() *RequestHeader { if m != nil { @@ -1207,13 +2328,44 @@ func (m *ReportSplitRequest) GetRight() *metapb.Region { } type ReportSplitResponse struct { - Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +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_151bd877a46a223e, []int{38} +} +func (m *ReportSplitResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ReportSplitResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ReportSplitResponse.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 *ReportSplitResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ReportSplitResponse.Merge(dst, src) +} +func (m *ReportSplitResponse) XXX_Size() int { + return m.Size() +} +func (m *ReportSplitResponse) XXX_DiscardUnknown() { + xxx_messageInfo_ReportSplitResponse.DiscardUnknown(m) } -func (m *ReportSplitResponse) Reset() { *m = ReportSplitResponse{} } -func (m *ReportSplitResponse) String() string { return proto.CompactTextString(m) } -func (*ReportSplitResponse) ProtoMessage() {} -func (*ReportSplitResponse) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{38} } +var xxx_messageInfo_ReportSplitResponse proto.InternalMessageInfo func (m *ReportSplitResponse) GetHeader() *ResponseHeader { if m != nil { @@ -1223,15 +2375,46 @@ func (m *ReportSplitResponse) GetHeader() *ResponseHeader { } type AskBatchSplitRequest struct { - Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` - Region *metapb.Region `protobuf:"bytes,2,opt,name=region" json:"region,omitempty"` - SplitCount uint32 `protobuf:"varint,3,opt,name=split_count,json=splitCount,proto3" json:"split_count,omitempty"` + Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + Region *metapb.Region `protobuf:"bytes,2,opt,name=region" json:"region,omitempty"` + SplitCount uint32 `protobuf:"varint,3,opt,name=split_count,json=splitCount,proto3" json:"split_count,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +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_151bd877a46a223e, []int{39} +} +func (m *AskBatchSplitRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *AskBatchSplitRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_AskBatchSplitRequest.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 *AskBatchSplitRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_AskBatchSplitRequest.Merge(dst, src) +} +func (m *AskBatchSplitRequest) XXX_Size() int { + return m.Size() +} +func (m *AskBatchSplitRequest) XXX_DiscardUnknown() { + xxx_messageInfo_AskBatchSplitRequest.DiscardUnknown(m) } -func (m *AskBatchSplitRequest) Reset() { *m = AskBatchSplitRequest{} } -func (m *AskBatchSplitRequest) String() string { return proto.CompactTextString(m) } -func (*AskBatchSplitRequest) ProtoMessage() {} -func (*AskBatchSplitRequest) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{39} } +var xxx_messageInfo_AskBatchSplitRequest proto.InternalMessageInfo func (m *AskBatchSplitRequest) GetHeader() *RequestHeader { if m != nil { @@ -1255,14 +2438,45 @@ func (m *AskBatchSplitRequest) GetSplitCount() uint32 { } type SplitID struct { - NewRegionId uint64 `protobuf:"varint,1,opt,name=new_region_id,json=newRegionId,proto3" json:"new_region_id,omitempty"` - NewPeerIds []uint64 `protobuf:"varint,2,rep,packed,name=new_peer_ids,json=newPeerIds" json:"new_peer_ids,omitempty"` + NewRegionId uint64 `protobuf:"varint,1,opt,name=new_region_id,json=newRegionId,proto3" json:"new_region_id,omitempty"` + NewPeerIds []uint64 `protobuf:"varint,2,rep,packed,name=new_peer_ids,json=newPeerIds" json:"new_peer_ids,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +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_151bd877a46a223e, []int{40} +} +func (m *SplitID) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SplitID) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_SplitID.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 *SplitID) XXX_Merge(src proto.Message) { + xxx_messageInfo_SplitID.Merge(dst, src) +} +func (m *SplitID) XXX_Size() int { + return m.Size() +} +func (m *SplitID) XXX_DiscardUnknown() { + xxx_messageInfo_SplitID.DiscardUnknown(m) } -func (m *SplitID) Reset() { *m = SplitID{} } -func (m *SplitID) String() string { return proto.CompactTextString(m) } -func (*SplitID) ProtoMessage() {} -func (*SplitID) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{40} } +var xxx_messageInfo_SplitID proto.InternalMessageInfo func (m *SplitID) GetNewRegionId() uint64 { if m != nil { @@ -1279,14 +2493,45 @@ func (m *SplitID) GetNewPeerIds() []uint64 { } type AskBatchSplitResponse struct { - Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` - Ids []*SplitID `protobuf:"bytes,2,rep,name=ids" json:"ids,omitempty"` + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + Ids []*SplitID `protobuf:"bytes,2,rep,name=ids" json:"ids,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +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_151bd877a46a223e, []int{41} +} +func (m *AskBatchSplitResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *AskBatchSplitResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_AskBatchSplitResponse.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 *AskBatchSplitResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_AskBatchSplitResponse.Merge(dst, src) +} +func (m *AskBatchSplitResponse) XXX_Size() int { + return m.Size() +} +func (m *AskBatchSplitResponse) XXX_DiscardUnknown() { + xxx_messageInfo_AskBatchSplitResponse.DiscardUnknown(m) } -func (m *AskBatchSplitResponse) Reset() { *m = AskBatchSplitResponse{} } -func (m *AskBatchSplitResponse) String() string { return proto.CompactTextString(m) } -func (*AskBatchSplitResponse) ProtoMessage() {} -func (*AskBatchSplitResponse) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{41} } +var xxx_messageInfo_AskBatchSplitResponse proto.InternalMessageInfo func (m *AskBatchSplitResponse) GetHeader() *ResponseHeader { if m != nil { @@ -1303,14 +2548,45 @@ func (m *AskBatchSplitResponse) GetIds() []*SplitID { } type ReportBatchSplitRequest struct { - Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` - Regions []*metapb.Region `protobuf:"bytes,2,rep,name=regions" json:"regions,omitempty"` + Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + Regions []*metapb.Region `protobuf:"bytes,2,rep,name=regions" json:"regions,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +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_151bd877a46a223e, []int{42} +} +func (m *ReportBatchSplitRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ReportBatchSplitRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ReportBatchSplitRequest.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 *ReportBatchSplitRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ReportBatchSplitRequest.Merge(dst, src) +} +func (m *ReportBatchSplitRequest) XXX_Size() int { + return m.Size() +} +func (m *ReportBatchSplitRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ReportBatchSplitRequest.DiscardUnknown(m) } -func (m *ReportBatchSplitRequest) Reset() { *m = ReportBatchSplitRequest{} } -func (m *ReportBatchSplitRequest) String() string { return proto.CompactTextString(m) } -func (*ReportBatchSplitRequest) ProtoMessage() {} -func (*ReportBatchSplitRequest) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{42} } +var xxx_messageInfo_ReportBatchSplitRequest proto.InternalMessageInfo func (m *ReportBatchSplitRequest) GetHeader() *RequestHeader { if m != nil { @@ -1327,13 +2603,44 @@ func (m *ReportBatchSplitRequest) GetRegions() []*metapb.Region { } type ReportBatchSplitResponse struct { - Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ReportBatchSplitResponse) Reset() { *m = ReportBatchSplitResponse{} } +func (m *ReportBatchSplitResponse) String() string { return proto.CompactTextString(m) } +func (*ReportBatchSplitResponse) ProtoMessage() {} +func (*ReportBatchSplitResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_pdpb_151bd877a46a223e, []int{43} +} +func (m *ReportBatchSplitResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ReportBatchSplitResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ReportBatchSplitResponse.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 *ReportBatchSplitResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ReportBatchSplitResponse.Merge(dst, src) +} +func (m *ReportBatchSplitResponse) XXX_Size() int { + return m.Size() +} +func (m *ReportBatchSplitResponse) XXX_DiscardUnknown() { + xxx_messageInfo_ReportBatchSplitResponse.DiscardUnknown(m) } -func (m *ReportBatchSplitResponse) Reset() { *m = ReportBatchSplitResponse{} } -func (m *ReportBatchSplitResponse) String() string { return proto.CompactTextString(m) } -func (*ReportBatchSplitResponse) ProtoMessage() {} -func (*ReportBatchSplitResponse) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{43} } +var xxx_messageInfo_ReportBatchSplitResponse proto.InternalMessageInfo func (m *ReportBatchSplitResponse) GetHeader() *ResponseHeader { if m != nil { @@ -1346,13 +2653,44 @@ type TimeInterval struct { // The unix timestamp in seconds of the start of this period. StartTimestamp uint64 `protobuf:"varint,1,opt,name=start_timestamp,json=startTimestamp,proto3" json:"start_timestamp,omitempty"` // The unix timestamp in seconds of the end of this period. - EndTimestamp uint64 `protobuf:"varint,2,opt,name=end_timestamp,json=endTimestamp,proto3" json:"end_timestamp,omitempty"` + EndTimestamp uint64 `protobuf:"varint,2,opt,name=end_timestamp,json=endTimestamp,proto3" json:"end_timestamp,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +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_151bd877a46a223e, []int{44} +} +func (m *TimeInterval) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *TimeInterval) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_TimeInterval.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 *TimeInterval) XXX_Merge(src proto.Message) { + xxx_messageInfo_TimeInterval.Merge(dst, src) +} +func (m *TimeInterval) XXX_Size() int { + return m.Size() +} +func (m *TimeInterval) XXX_DiscardUnknown() { + xxx_messageInfo_TimeInterval.DiscardUnknown(m) } -func (m *TimeInterval) Reset() { *m = TimeInterval{} } -func (m *TimeInterval) String() string { return proto.CompactTextString(m) } -func (*TimeInterval) ProtoMessage() {} -func (*TimeInterval) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{44} } +var xxx_messageInfo_TimeInterval proto.InternalMessageInfo func (m *TimeInterval) GetStartTimestamp() uint64 { if m != nil { @@ -1397,13 +2735,44 @@ type StoreStats struct { // Keys read for the store during this period. KeysRead uint64 `protobuf:"varint,14,opt,name=keys_read,json=keysRead,proto3" json:"keys_read,omitempty"` // Actually reported time interval - Interval *TimeInterval `protobuf:"bytes,15,opt,name=interval" json:"interval,omitempty"` + Interval *TimeInterval `protobuf:"bytes,15,opt,name=interval" json:"interval,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +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_151bd877a46a223e, []int{45} +} +func (m *StoreStats) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *StoreStats) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_StoreStats.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 *StoreStats) XXX_Merge(src proto.Message) { + xxx_messageInfo_StoreStats.Merge(dst, src) +} +func (m *StoreStats) XXX_Size() int { + return m.Size() +} +func (m *StoreStats) XXX_DiscardUnknown() { + xxx_messageInfo_StoreStats.DiscardUnknown(m) } -func (m *StoreStats) Reset() { *m = StoreStats{} } -func (m *StoreStats) String() string { return proto.CompactTextString(m) } -func (*StoreStats) ProtoMessage() {} -func (*StoreStats) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{45} } +var xxx_messageInfo_StoreStats proto.InternalMessageInfo func (m *StoreStats) GetStoreId() uint64 { if m != nil { @@ -1511,14 +2880,45 @@ func (m *StoreStats) GetInterval() *TimeInterval { } type StoreHeartbeatRequest struct { - Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` - Stats *StoreStats `protobuf:"bytes,2,opt,name=stats" json:"stats,omitempty"` + Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + Stats *StoreStats `protobuf:"bytes,2,opt,name=stats" json:"stats,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +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_151bd877a46a223e, []int{46} +} +func (m *StoreHeartbeatRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *StoreHeartbeatRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_StoreHeartbeatRequest.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 *StoreHeartbeatRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_StoreHeartbeatRequest.Merge(dst, src) +} +func (m *StoreHeartbeatRequest) XXX_Size() int { + return m.Size() +} +func (m *StoreHeartbeatRequest) XXX_DiscardUnknown() { + xxx_messageInfo_StoreHeartbeatRequest.DiscardUnknown(m) } -func (m *StoreHeartbeatRequest) Reset() { *m = StoreHeartbeatRequest{} } -func (m *StoreHeartbeatRequest) String() string { return proto.CompactTextString(m) } -func (*StoreHeartbeatRequest) ProtoMessage() {} -func (*StoreHeartbeatRequest) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{46} } +var xxx_messageInfo_StoreHeartbeatRequest proto.InternalMessageInfo func (m *StoreHeartbeatRequest) GetHeader() *RequestHeader { if m != nil { @@ -1535,13 +2935,44 @@ func (m *StoreHeartbeatRequest) GetStats() *StoreStats { } type StoreHeartbeatResponse struct { - Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,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_151bd877a46a223e, []int{47} +} +func (m *StoreHeartbeatResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *StoreHeartbeatResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_StoreHeartbeatResponse.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 *StoreHeartbeatResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_StoreHeartbeatResponse.Merge(dst, src) +} +func (m *StoreHeartbeatResponse) XXX_Size() int { + return m.Size() +} +func (m *StoreHeartbeatResponse) XXX_DiscardUnknown() { + xxx_messageInfo_StoreHeartbeatResponse.DiscardUnknown(m) } -func (m *StoreHeartbeatResponse) Reset() { *m = StoreHeartbeatResponse{} } -func (m *StoreHeartbeatResponse) String() string { return proto.CompactTextString(m) } -func (*StoreHeartbeatResponse) ProtoMessage() {} -func (*StoreHeartbeatResponse) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{47} } +var xxx_messageInfo_StoreHeartbeatResponse proto.InternalMessageInfo func (m *StoreHeartbeatResponse) GetHeader() *ResponseHeader { if m != nil { @@ -1555,14 +2986,45 @@ type ScatterRegionRequest struct { RegionId uint64 `protobuf:"varint,2,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty"` // PD will use these region information if it can't find the region. // For example, the region is just split and hasn't report to PD yet. - Region *metapb.Region `protobuf:"bytes,3,opt,name=region" json:"region,omitempty"` - Leader *metapb.Peer `protobuf:"bytes,4,opt,name=leader" json:"leader,omitempty"` + Region *metapb.Region `protobuf:"bytes,3,opt,name=region" json:"region,omitempty"` + Leader *metapb.Peer `protobuf:"bytes,4,opt,name=leader" json:"leader,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +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_151bd877a46a223e, []int{48} +} +func (m *ScatterRegionRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ScatterRegionRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ScatterRegionRequest.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 *ScatterRegionRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ScatterRegionRequest.Merge(dst, src) +} +func (m *ScatterRegionRequest) XXX_Size() int { + return m.Size() +} +func (m *ScatterRegionRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ScatterRegionRequest.DiscardUnknown(m) } -func (m *ScatterRegionRequest) Reset() { *m = ScatterRegionRequest{} } -func (m *ScatterRegionRequest) String() string { return proto.CompactTextString(m) } -func (*ScatterRegionRequest) ProtoMessage() {} -func (*ScatterRegionRequest) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{48} } +var xxx_messageInfo_ScatterRegionRequest proto.InternalMessageInfo func (m *ScatterRegionRequest) GetHeader() *RequestHeader { if m != nil { @@ -1593,13 +3055,44 @@ func (m *ScatterRegionRequest) GetLeader() *metapb.Peer { } type ScatterRegionResponse struct { - Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +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_151bd877a46a223e, []int{49} +} +func (m *ScatterRegionResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ScatterRegionResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ScatterRegionResponse.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 *ScatterRegionResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ScatterRegionResponse.Merge(dst, src) +} +func (m *ScatterRegionResponse) XXX_Size() int { + return m.Size() +} +func (m *ScatterRegionResponse) XXX_DiscardUnknown() { + xxx_messageInfo_ScatterRegionResponse.DiscardUnknown(m) } -func (m *ScatterRegionResponse) Reset() { *m = ScatterRegionResponse{} } -func (m *ScatterRegionResponse) String() string { return proto.CompactTextString(m) } -func (*ScatterRegionResponse) ProtoMessage() {} -func (*ScatterRegionResponse) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{49} } +var xxx_messageInfo_ScatterRegionResponse proto.InternalMessageInfo func (m *ScatterRegionResponse) GetHeader() *ResponseHeader { if m != nil { @@ -1609,13 +3102,44 @@ func (m *ScatterRegionResponse) GetHeader() *ResponseHeader { } type GetGCSafePointRequest struct { - Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +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_151bd877a46a223e, []int{50} +} +func (m *GetGCSafePointRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GetGCSafePointRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GetGCSafePointRequest.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 *GetGCSafePointRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetGCSafePointRequest.Merge(dst, src) +} +func (m *GetGCSafePointRequest) XXX_Size() int { + return m.Size() +} +func (m *GetGCSafePointRequest) XXX_DiscardUnknown() { + xxx_messageInfo_GetGCSafePointRequest.DiscardUnknown(m) } -func (m *GetGCSafePointRequest) Reset() { *m = GetGCSafePointRequest{} } -func (m *GetGCSafePointRequest) String() string { return proto.CompactTextString(m) } -func (*GetGCSafePointRequest) ProtoMessage() {} -func (*GetGCSafePointRequest) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{50} } +var xxx_messageInfo_GetGCSafePointRequest proto.InternalMessageInfo func (m *GetGCSafePointRequest) GetHeader() *RequestHeader { if m != nil { @@ -1625,14 +3149,45 @@ func (m *GetGCSafePointRequest) GetHeader() *RequestHeader { } type GetGCSafePointResponse struct { - Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` - SafePoint uint64 `protobuf:"varint,2,opt,name=safe_point,json=safePoint,proto3" json:"safe_point,omitempty"` + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + SafePoint uint64 `protobuf:"varint,2,opt,name=safe_point,json=safePoint,proto3" json:"safe_point,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *GetGCSafePointResponse) Reset() { *m = GetGCSafePointResponse{} } +func (m *GetGCSafePointResponse) String() string { return proto.CompactTextString(m) } +func (*GetGCSafePointResponse) ProtoMessage() {} +func (*GetGCSafePointResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_pdpb_151bd877a46a223e, []int{51} +} +func (m *GetGCSafePointResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GetGCSafePointResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GetGCSafePointResponse.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 *GetGCSafePointResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetGCSafePointResponse.Merge(dst, src) +} +func (m *GetGCSafePointResponse) XXX_Size() int { + return m.Size() +} +func (m *GetGCSafePointResponse) XXX_DiscardUnknown() { + xxx_messageInfo_GetGCSafePointResponse.DiscardUnknown(m) } -func (m *GetGCSafePointResponse) Reset() { *m = GetGCSafePointResponse{} } -func (m *GetGCSafePointResponse) String() string { return proto.CompactTextString(m) } -func (*GetGCSafePointResponse) ProtoMessage() {} -func (*GetGCSafePointResponse) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{51} } +var xxx_messageInfo_GetGCSafePointResponse proto.InternalMessageInfo func (m *GetGCSafePointResponse) GetHeader() *ResponseHeader { if m != nil { @@ -1649,14 +3204,45 @@ func (m *GetGCSafePointResponse) GetSafePoint() uint64 { } type UpdateGCSafePointRequest struct { - Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` - SafePoint uint64 `protobuf:"varint,2,opt,name=safe_point,json=safePoint,proto3" json:"safe_point,omitempty"` + Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + SafePoint uint64 `protobuf:"varint,2,opt,name=safe_point,json=safePoint,proto3" json:"safe_point,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *UpdateGCSafePointRequest) Reset() { *m = UpdateGCSafePointRequest{} } +func (m *UpdateGCSafePointRequest) String() string { return proto.CompactTextString(m) } +func (*UpdateGCSafePointRequest) ProtoMessage() {} +func (*UpdateGCSafePointRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_pdpb_151bd877a46a223e, []int{52} +} +func (m *UpdateGCSafePointRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *UpdateGCSafePointRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_UpdateGCSafePointRequest.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 *UpdateGCSafePointRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_UpdateGCSafePointRequest.Merge(dst, src) +} +func (m *UpdateGCSafePointRequest) XXX_Size() int { + return m.Size() +} +func (m *UpdateGCSafePointRequest) XXX_DiscardUnknown() { + xxx_messageInfo_UpdateGCSafePointRequest.DiscardUnknown(m) } -func (m *UpdateGCSafePointRequest) Reset() { *m = UpdateGCSafePointRequest{} } -func (m *UpdateGCSafePointRequest) String() string { return proto.CompactTextString(m) } -func (*UpdateGCSafePointRequest) ProtoMessage() {} -func (*UpdateGCSafePointRequest) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{52} } +var xxx_messageInfo_UpdateGCSafePointRequest proto.InternalMessageInfo func (m *UpdateGCSafePointRequest) GetHeader() *RequestHeader { if m != nil { @@ -1673,14 +3259,45 @@ func (m *UpdateGCSafePointRequest) GetSafePoint() uint64 { } type UpdateGCSafePointResponse struct { - Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` - NewSafePoint uint64 `protobuf:"varint,2,opt,name=new_safe_point,json=newSafePoint,proto3" json:"new_safe_point,omitempty"` + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + NewSafePoint uint64 `protobuf:"varint,2,opt,name=new_safe_point,json=newSafePoint,proto3" json:"new_safe_point,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *UpdateGCSafePointResponse) Reset() { *m = UpdateGCSafePointResponse{} } +func (m *UpdateGCSafePointResponse) String() string { return proto.CompactTextString(m) } +func (*UpdateGCSafePointResponse) ProtoMessage() {} +func (*UpdateGCSafePointResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_pdpb_151bd877a46a223e, []int{53} +} +func (m *UpdateGCSafePointResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *UpdateGCSafePointResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_UpdateGCSafePointResponse.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 *UpdateGCSafePointResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_UpdateGCSafePointResponse.Merge(dst, src) +} +func (m *UpdateGCSafePointResponse) XXX_Size() int { + return m.Size() +} +func (m *UpdateGCSafePointResponse) XXX_DiscardUnknown() { + xxx_messageInfo_UpdateGCSafePointResponse.DiscardUnknown(m) } -func (m *UpdateGCSafePointResponse) Reset() { *m = UpdateGCSafePointResponse{} } -func (m *UpdateGCSafePointResponse) String() string { return proto.CompactTextString(m) } -func (*UpdateGCSafePointResponse) ProtoMessage() {} -func (*UpdateGCSafePointResponse) Descriptor() ([]byte, []int) { return fileDescriptorPdpb, []int{53} } +var xxx_messageInfo_UpdateGCSafePointResponse proto.InternalMessageInfo func (m *UpdateGCSafePointResponse) GetHeader() *ResponseHeader { if m != nil { @@ -1696,6 +3313,116 @@ func (m *UpdateGCSafePointResponse) GetNewSafePoint() uint64 { return 0 } +type SyncRegionRequest struct { + Header *RequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + Member *Member `protobuf:"bytes,2,opt,name=member" json:"member,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *SyncRegionRequest) Reset() { *m = SyncRegionRequest{} } +func (m *SyncRegionRequest) String() string { return proto.CompactTextString(m) } +func (*SyncRegionRequest) ProtoMessage() {} +func (*SyncRegionRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_pdpb_151bd877a46a223e, []int{54} +} +func (m *SyncRegionRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SyncRegionRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_SyncRegionRequest.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 *SyncRegionRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_SyncRegionRequest.Merge(dst, src) +} +func (m *SyncRegionRequest) XXX_Size() int { + return m.Size() +} +func (m *SyncRegionRequest) XXX_DiscardUnknown() { + xxx_messageInfo_SyncRegionRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_SyncRegionRequest proto.InternalMessageInfo + +func (m *SyncRegionRequest) GetHeader() *RequestHeader { + if m != nil { + return m.Header + } + return nil +} + +func (m *SyncRegionRequest) GetMember() *Member { + if m != nil { + return m.Member + } + return nil +} + +type SyncRegionResponse struct { + Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"` + Regions []*metapb.Region `protobuf:"bytes,2,rep,name=regions" json:"regions,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *SyncRegionResponse) Reset() { *m = SyncRegionResponse{} } +func (m *SyncRegionResponse) String() string { return proto.CompactTextString(m) } +func (*SyncRegionResponse) ProtoMessage() {} +func (*SyncRegionResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_pdpb_151bd877a46a223e, []int{55} +} +func (m *SyncRegionResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SyncRegionResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_SyncRegionResponse.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 *SyncRegionResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_SyncRegionResponse.Merge(dst, src) +} +func (m *SyncRegionResponse) XXX_Size() int { + return m.Size() +} +func (m *SyncRegionResponse) XXX_DiscardUnknown() { + xxx_messageInfo_SyncRegionResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_SyncRegionResponse proto.InternalMessageInfo + +func (m *SyncRegionResponse) GetHeader() *ResponseHeader { + if m != nil { + return m.Header + } + return nil +} + +func (m *SyncRegionResponse) GetRegions() []*metapb.Region { + if m != nil { + return m.Regions + } + return nil +} + func init() { proto.RegisterType((*RequestHeader)(nil), "pdpb.RequestHeader") proto.RegisterType((*ResponseHeader)(nil), "pdpb.ResponseHeader") @@ -1751,6 +3478,8 @@ func init() { proto.RegisterType((*GetGCSafePointResponse)(nil), "pdpb.GetGCSafePointResponse") proto.RegisterType((*UpdateGCSafePointRequest)(nil), "pdpb.UpdateGCSafePointRequest") proto.RegisterType((*UpdateGCSafePointResponse)(nil), "pdpb.UpdateGCSafePointResponse") + proto.RegisterType((*SyncRegionRequest)(nil), "pdpb.SyncRegionRequest") + proto.RegisterType((*SyncRegionResponse)(nil), "pdpb.SyncRegionResponse") proto.RegisterEnum("pdpb.ErrorType", ErrorType_name, ErrorType_value) proto.RegisterEnum("pdpb.CheckPolicy", CheckPolicy_name, CheckPolicy_value) } @@ -1790,6 +3519,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) + SyncRegions(ctx context.Context, opts ...grpc.CallOption) (PD_SyncRegionsClient, error) } type pDClient struct { @@ -1802,7 +3532,7 @@ func NewPDClient(cc *grpc.ClientConn) PDClient { func (c *pDClient) GetMembers(ctx context.Context, in *GetMembersRequest, opts ...grpc.CallOption) (*GetMembersResponse, error) { out := new(GetMembersResponse) - err := grpc.Invoke(ctx, "/pdpb.PD/GetMembers", in, out, c.cc, opts...) + err := c.cc.Invoke(ctx, "/pdpb.PD/GetMembers", in, out, opts...) if err != nil { return nil, err } @@ -1810,7 +3540,7 @@ func (c *pDClient) GetMembers(ctx context.Context, in *GetMembersRequest, opts . } func (c *pDClient) Tso(ctx context.Context, opts ...grpc.CallOption) (PD_TsoClient, error) { - stream, err := grpc.NewClientStream(ctx, &_PD_serviceDesc.Streams[0], c.cc, "/pdpb.PD/Tso", opts...) + stream, err := c.cc.NewStream(ctx, &_PD_serviceDesc.Streams[0], "/pdpb.PD/Tso", opts...) if err != nil { return nil, err } @@ -1842,7 +3572,7 @@ func (x *pDTsoClient) Recv() (*TsoResponse, error) { func (c *pDClient) Bootstrap(ctx context.Context, in *BootstrapRequest, opts ...grpc.CallOption) (*BootstrapResponse, error) { out := new(BootstrapResponse) - err := grpc.Invoke(ctx, "/pdpb.PD/Bootstrap", in, out, c.cc, opts...) + err := c.cc.Invoke(ctx, "/pdpb.PD/Bootstrap", in, out, opts...) if err != nil { return nil, err } @@ -1851,7 +3581,7 @@ func (c *pDClient) Bootstrap(ctx context.Context, in *BootstrapRequest, opts ... func (c *pDClient) IsBootstrapped(ctx context.Context, in *IsBootstrappedRequest, opts ...grpc.CallOption) (*IsBootstrappedResponse, error) { out := new(IsBootstrappedResponse) - err := grpc.Invoke(ctx, "/pdpb.PD/IsBootstrapped", in, out, c.cc, opts...) + err := c.cc.Invoke(ctx, "/pdpb.PD/IsBootstrapped", in, out, opts...) if err != nil { return nil, err } @@ -1860,7 +3590,7 @@ func (c *pDClient) IsBootstrapped(ctx context.Context, in *IsBootstrappedRequest func (c *pDClient) AllocID(ctx context.Context, in *AllocIDRequest, opts ...grpc.CallOption) (*AllocIDResponse, error) { out := new(AllocIDResponse) - err := grpc.Invoke(ctx, "/pdpb.PD/AllocID", in, out, c.cc, opts...) + err := c.cc.Invoke(ctx, "/pdpb.PD/AllocID", in, out, opts...) if err != nil { return nil, err } @@ -1869,7 +3599,7 @@ func (c *pDClient) AllocID(ctx context.Context, in *AllocIDRequest, opts ...grpc func (c *pDClient) GetStore(ctx context.Context, in *GetStoreRequest, opts ...grpc.CallOption) (*GetStoreResponse, error) { out := new(GetStoreResponse) - err := grpc.Invoke(ctx, "/pdpb.PD/GetStore", in, out, c.cc, opts...) + err := c.cc.Invoke(ctx, "/pdpb.PD/GetStore", in, out, opts...) if err != nil { return nil, err } @@ -1878,7 +3608,7 @@ func (c *pDClient) GetStore(ctx context.Context, in *GetStoreRequest, opts ...gr func (c *pDClient) PutStore(ctx context.Context, in *PutStoreRequest, opts ...grpc.CallOption) (*PutStoreResponse, error) { out := new(PutStoreResponse) - err := grpc.Invoke(ctx, "/pdpb.PD/PutStore", in, out, c.cc, opts...) + err := c.cc.Invoke(ctx, "/pdpb.PD/PutStore", in, out, opts...) if err != nil { return nil, err } @@ -1887,7 +3617,7 @@ func (c *pDClient) PutStore(ctx context.Context, in *PutStoreRequest, opts ...gr func (c *pDClient) GetAllStores(ctx context.Context, in *GetAllStoresRequest, opts ...grpc.CallOption) (*GetAllStoresResponse, error) { out := new(GetAllStoresResponse) - err := grpc.Invoke(ctx, "/pdpb.PD/GetAllStores", in, out, c.cc, opts...) + err := c.cc.Invoke(ctx, "/pdpb.PD/GetAllStores", in, out, opts...) if err != nil { return nil, err } @@ -1896,7 +3626,7 @@ func (c *pDClient) GetAllStores(ctx context.Context, in *GetAllStoresRequest, op func (c *pDClient) StoreHeartbeat(ctx context.Context, in *StoreHeartbeatRequest, opts ...grpc.CallOption) (*StoreHeartbeatResponse, error) { out := new(StoreHeartbeatResponse) - err := grpc.Invoke(ctx, "/pdpb.PD/StoreHeartbeat", in, out, c.cc, opts...) + err := c.cc.Invoke(ctx, "/pdpb.PD/StoreHeartbeat", in, out, opts...) if err != nil { return nil, err } @@ -1904,7 +3634,7 @@ func (c *pDClient) StoreHeartbeat(ctx context.Context, in *StoreHeartbeatRequest } func (c *pDClient) RegionHeartbeat(ctx context.Context, opts ...grpc.CallOption) (PD_RegionHeartbeatClient, error) { - stream, err := grpc.NewClientStream(ctx, &_PD_serviceDesc.Streams[1], c.cc, "/pdpb.PD/RegionHeartbeat", opts...) + stream, err := c.cc.NewStream(ctx, &_PD_serviceDesc.Streams[1], "/pdpb.PD/RegionHeartbeat", opts...) if err != nil { return nil, err } @@ -1936,7 +3666,7 @@ func (x *pDRegionHeartbeatClient) Recv() (*RegionHeartbeatResponse, error) { func (c *pDClient) GetRegion(ctx context.Context, in *GetRegionRequest, opts ...grpc.CallOption) (*GetRegionResponse, error) { out := new(GetRegionResponse) - err := grpc.Invoke(ctx, "/pdpb.PD/GetRegion", in, out, c.cc, opts...) + err := c.cc.Invoke(ctx, "/pdpb.PD/GetRegion", in, out, opts...) if err != nil { return nil, err } @@ -1945,7 +3675,7 @@ func (c *pDClient) GetRegion(ctx context.Context, in *GetRegionRequest, opts ... func (c *pDClient) GetPrevRegion(ctx context.Context, in *GetRegionRequest, opts ...grpc.CallOption) (*GetRegionResponse, error) { out := new(GetRegionResponse) - err := grpc.Invoke(ctx, "/pdpb.PD/GetPrevRegion", in, out, c.cc, opts...) + err := c.cc.Invoke(ctx, "/pdpb.PD/GetPrevRegion", in, out, opts...) if err != nil { return nil, err } @@ -1954,25 +3684,27 @@ func (c *pDClient) GetPrevRegion(ctx context.Context, in *GetRegionRequest, opts func (c *pDClient) GetRegionByID(ctx context.Context, in *GetRegionByIDRequest, opts ...grpc.CallOption) (*GetRegionResponse, error) { out := new(GetRegionResponse) - err := grpc.Invoke(ctx, "/pdpb.PD/GetRegionByID", in, out, c.cc, opts...) + err := c.cc.Invoke(ctx, "/pdpb.PD/GetRegionByID", in, out, opts...) if err != nil { return nil, err } return out, nil } +// Deprecated: Do not use. func (c *pDClient) AskSplit(ctx context.Context, in *AskSplitRequest, opts ...grpc.CallOption) (*AskSplitResponse, error) { out := new(AskSplitResponse) - err := grpc.Invoke(ctx, "/pdpb.PD/AskSplit", in, out, c.cc, opts...) + err := c.cc.Invoke(ctx, "/pdpb.PD/AskSplit", in, out, opts...) if err != nil { return nil, err } return out, nil } +// Deprecated: Do not use. func (c *pDClient) ReportSplit(ctx context.Context, in *ReportSplitRequest, opts ...grpc.CallOption) (*ReportSplitResponse, error) { out := new(ReportSplitResponse) - err := grpc.Invoke(ctx, "/pdpb.PD/ReportSplit", in, out, c.cc, opts...) + err := c.cc.Invoke(ctx, "/pdpb.PD/ReportSplit", in, out, opts...) if err != nil { return nil, err } @@ -1981,7 +3713,7 @@ func (c *pDClient) ReportSplit(ctx context.Context, in *ReportSplitRequest, opts func (c *pDClient) AskBatchSplit(ctx context.Context, in *AskBatchSplitRequest, opts ...grpc.CallOption) (*AskBatchSplitResponse, error) { out := new(AskBatchSplitResponse) - err := grpc.Invoke(ctx, "/pdpb.PD/AskBatchSplit", in, out, c.cc, opts...) + err := c.cc.Invoke(ctx, "/pdpb.PD/AskBatchSplit", in, out, opts...) if err != nil { return nil, err } @@ -1990,7 +3722,7 @@ func (c *pDClient) AskBatchSplit(ctx context.Context, in *AskBatchSplitRequest, func (c *pDClient) ReportBatchSplit(ctx context.Context, in *ReportBatchSplitRequest, opts ...grpc.CallOption) (*ReportBatchSplitResponse, error) { out := new(ReportBatchSplitResponse) - err := grpc.Invoke(ctx, "/pdpb.PD/ReportBatchSplit", in, out, c.cc, opts...) + err := c.cc.Invoke(ctx, "/pdpb.PD/ReportBatchSplit", in, out, opts...) if err != nil { return nil, err } @@ -1999,7 +3731,7 @@ func (c *pDClient) ReportBatchSplit(ctx context.Context, in *ReportBatchSplitReq func (c *pDClient) GetClusterConfig(ctx context.Context, in *GetClusterConfigRequest, opts ...grpc.CallOption) (*GetClusterConfigResponse, error) { out := new(GetClusterConfigResponse) - err := grpc.Invoke(ctx, "/pdpb.PD/GetClusterConfig", in, out, c.cc, opts...) + err := c.cc.Invoke(ctx, "/pdpb.PD/GetClusterConfig", in, out, opts...) if err != nil { return nil, err } @@ -2008,7 +3740,7 @@ func (c *pDClient) GetClusterConfig(ctx context.Context, in *GetClusterConfigReq func (c *pDClient) PutClusterConfig(ctx context.Context, in *PutClusterConfigRequest, opts ...grpc.CallOption) (*PutClusterConfigResponse, error) { out := new(PutClusterConfigResponse) - err := grpc.Invoke(ctx, "/pdpb.PD/PutClusterConfig", in, out, c.cc, opts...) + err := c.cc.Invoke(ctx, "/pdpb.PD/PutClusterConfig", in, out, opts...) if err != nil { return nil, err } @@ -2017,7 +3749,7 @@ func (c *pDClient) PutClusterConfig(ctx context.Context, in *PutClusterConfigReq func (c *pDClient) ScatterRegion(ctx context.Context, in *ScatterRegionRequest, opts ...grpc.CallOption) (*ScatterRegionResponse, error) { out := new(ScatterRegionResponse) - err := grpc.Invoke(ctx, "/pdpb.PD/ScatterRegion", in, out, c.cc, opts...) + err := c.cc.Invoke(ctx, "/pdpb.PD/ScatterRegion", in, out, opts...) if err != nil { return nil, err } @@ -2026,7 +3758,7 @@ func (c *pDClient) ScatterRegion(ctx context.Context, in *ScatterRegionRequest, func (c *pDClient) GetGCSafePoint(ctx context.Context, in *GetGCSafePointRequest, opts ...grpc.CallOption) (*GetGCSafePointResponse, error) { out := new(GetGCSafePointResponse) - err := grpc.Invoke(ctx, "/pdpb.PD/GetGCSafePoint", in, out, c.cc, opts...) + err := c.cc.Invoke(ctx, "/pdpb.PD/GetGCSafePoint", in, out, opts...) if err != nil { return nil, err } @@ -2035,13 +3767,44 @@ func (c *pDClient) GetGCSafePoint(ctx context.Context, in *GetGCSafePointRequest func (c *pDClient) UpdateGCSafePoint(ctx context.Context, in *UpdateGCSafePointRequest, opts ...grpc.CallOption) (*UpdateGCSafePointResponse, error) { out := new(UpdateGCSafePointResponse) - err := grpc.Invoke(ctx, "/pdpb.PD/UpdateGCSafePoint", in, out, c.cc, opts...) + err := c.cc.Invoke(ctx, "/pdpb.PD/UpdateGCSafePoint", 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 { + return nil, err + } + x := &pDSyncRegionsClient{stream} + return x, nil +} + +type PD_SyncRegionsClient interface { + Send(*SyncRegionRequest) error + Recv() (*SyncRegionResponse, error) + grpc.ClientStream +} + +type pDSyncRegionsClient struct { + grpc.ClientStream +} + +func (x *pDSyncRegionsClient) Send(m *SyncRegionRequest) error { + return x.ClientStream.SendMsg(m) +} + +func (x *pDSyncRegionsClient) Recv() (*SyncRegionResponse, error) { + m := new(SyncRegionResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + // Server API for PD service type PDServer interface { @@ -2069,6 +3832,7 @@ type PDServer interface { ScatterRegion(context.Context, *ScatterRegionRequest) (*ScatterRegionResponse, error) GetGCSafePoint(context.Context, *GetGCSafePointRequest) (*GetGCSafePointResponse, error) UpdateGCSafePoint(context.Context, *UpdateGCSafePointRequest) (*UpdateGCSafePointResponse, error) + SyncRegions(PD_SyncRegionsServer) error } func RegisterPDServer(s *grpc.Server, srv PDServer) { @@ -2474,17 +4238,43 @@ func _PD_UpdateGCSafePoint_Handler(srv interface{}, ctx context.Context, dec fun if err := dec(in); err != nil { return nil, err } - if interceptor == nil { - return srv.(PDServer).UpdateGCSafePoint(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/pdpb.PD/UpdateGCSafePoint", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(PDServer).UpdateGCSafePoint(ctx, req.(*UpdateGCSafePointRequest)) - } - return interceptor(ctx, in, info, handler) + if interceptor == nil { + return srv.(PDServer).UpdateGCSafePoint(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/pdpb.PD/UpdateGCSafePoint", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(PDServer).UpdateGCSafePoint(ctx, req.(*UpdateGCSafePointRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _PD_SyncRegions_Handler(srv interface{}, stream grpc.ServerStream) error { + return srv.(PDServer).SyncRegions(&pDSyncRegionsServer{stream}) +} + +type PD_SyncRegionsServer interface { + Send(*SyncRegionResponse) error + Recv() (*SyncRegionRequest, error) + grpc.ServerStream +} + +type pDSyncRegionsServer struct { + grpc.ServerStream +} + +func (x *pDSyncRegionsServer) Send(m *SyncRegionResponse) error { + return x.ServerStream.SendMsg(m) +} + +func (x *pDSyncRegionsServer) Recv() (*SyncRegionRequest, error) { + m := new(SyncRegionRequest) + if err := x.ServerStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil } var _PD_serviceDesc = grpc.ServiceDesc{ @@ -2585,6 +4375,12 @@ var _PD_serviceDesc = grpc.ServiceDesc{ ServerStreams: true, ClientStreams: true, }, + { + StreamName: "SyncRegions", + Handler: _PD_SyncRegions_Handler, + ServerStreams: true, + ClientStreams: true, + }, }, Metadata: "pdpb.proto", } @@ -2609,6 +4405,9 @@ func (m *RequestHeader) MarshalTo(dAtA []byte) (int, error) { i++ i = encodeVarintPdpb(dAtA, i, uint64(m.ClusterId)) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -2642,6 +4441,9 @@ func (m *ResponseHeader) MarshalTo(dAtA []byte) (int, error) { } i += n1 } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -2671,6 +4473,9 @@ func (m *Error) MarshalTo(dAtA []byte) (int, error) { i = encodeVarintPdpb(dAtA, i, uint64(len(m.Message))) i += copy(dAtA[i:], m.Message) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -2704,6 +4509,9 @@ func (m *TsoRequest) MarshalTo(dAtA []byte) (int, error) { i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Count)) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -2732,6 +4540,9 @@ func (m *Timestamp) MarshalTo(dAtA []byte) (int, error) { i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Logical)) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -2775,6 +4586,9 @@ func (m *TsoResponse) MarshalTo(dAtA []byte) (int, error) { } i += n4 } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -2823,6 +4637,9 @@ func (m *BootstrapRequest) MarshalTo(dAtA []byte) (int, error) { } i += n7 } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -2851,6 +4668,9 @@ func (m *BootstrapResponse) MarshalTo(dAtA []byte) (int, error) { } i += n8 } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -2879,6 +4699,9 @@ func (m *IsBootstrappedRequest) MarshalTo(dAtA []byte) (int, error) { } i += n9 } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -2917,6 +4740,9 @@ func (m *IsBootstrappedResponse) MarshalTo(dAtA []byte) (int, error) { } i++ } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -2945,6 +4771,9 @@ func (m *AllocIDRequest) MarshalTo(dAtA []byte) (int, error) { } i += n11 } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -2978,6 +4807,9 @@ func (m *AllocIDResponse) MarshalTo(dAtA []byte) (int, error) { i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Id)) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -3011,6 +4843,9 @@ func (m *GetStoreRequest) MarshalTo(dAtA []byte) (int, error) { i++ i = encodeVarintPdpb(dAtA, i, uint64(m.StoreId)) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -3049,6 +4884,9 @@ func (m *GetStoreResponse) MarshalTo(dAtA []byte) (int, error) { } i += n15 } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -3087,6 +4925,9 @@ func (m *PutStoreRequest) MarshalTo(dAtA []byte) (int, error) { } i += n17 } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -3115,6 +4956,9 @@ func (m *PutStoreResponse) MarshalTo(dAtA []byte) (int, error) { } i += n18 } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -3143,6 +4987,9 @@ func (m *GetAllStoresRequest) MarshalTo(dAtA []byte) (int, error) { } i += n19 } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -3183,6 +5030,9 @@ func (m *GetAllStoresResponse) MarshalTo(dAtA []byte) (int, error) { i += n } } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -3217,6 +5067,9 @@ func (m *GetRegionRequest) MarshalTo(dAtA []byte) (int, error) { i = encodeVarintPdpb(dAtA, i, uint64(len(m.RegionKey))) i += copy(dAtA[i:], m.RegionKey) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -3265,6 +5118,9 @@ func (m *GetRegionResponse) MarshalTo(dAtA []byte) (int, error) { } i += n24 } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -3298,6 +5154,9 @@ func (m *GetRegionByIDRequest) MarshalTo(dAtA []byte) (int, error) { i++ i = encodeVarintPdpb(dAtA, i, uint64(m.RegionId)) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -3326,6 +5185,9 @@ func (m *GetClusterConfigRequest) MarshalTo(dAtA []byte) (int, error) { } i += n26 } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -3364,6 +5226,9 @@ func (m *GetClusterConfigResponse) MarshalTo(dAtA []byte) (int, error) { } i += n28 } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -3402,6 +5267,9 @@ func (m *PutClusterConfigRequest) MarshalTo(dAtA []byte) (int, error) { } i += n30 } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -3430,6 +5298,9 @@ func (m *PutClusterConfigResponse) MarshalTo(dAtA []byte) (int, error) { } i += n31 } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -3494,6 +5365,9 @@ func (m *Member) MarshalTo(dAtA []byte) (int, error) { i++ i = encodeVarintPdpb(dAtA, i, uint64(m.LeaderPriority)) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -3522,6 +5396,9 @@ func (m *GetMembersRequest) MarshalTo(dAtA []byte) (int, error) { } i += n32 } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -3582,6 +5459,9 @@ func (m *GetMembersResponse) MarshalTo(dAtA []byte) (int, error) { } i += n35 } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -3615,6 +5495,9 @@ func (m *PeerStats) MarshalTo(dAtA []byte) (int, error) { i++ i = encodeVarintPdpb(dAtA, i, uint64(m.DownSeconds)) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -3727,6 +5610,9 @@ func (m *RegionHeartbeatRequest) MarshalTo(dAtA []byte) (int, error) { i++ i = encodeVarintPdpb(dAtA, i, uint64(m.ApproximateKeys)) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -3760,6 +5646,9 @@ func (m *ChangePeer) MarshalTo(dAtA []byte) (int, error) { i++ i = encodeVarintPdpb(dAtA, i, uint64(m.ChangeType)) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -3788,6 +5677,9 @@ func (m *TransferLeader) MarshalTo(dAtA []byte) (int, error) { } i += n42 } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -3816,6 +5708,9 @@ func (m *Merge) MarshalTo(dAtA []byte) (int, error) { } i += n43 } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -3839,6 +5734,9 @@ func (m *SplitRegion) MarshalTo(dAtA []byte) (int, error) { i++ i = encodeVarintPdpb(dAtA, i, uint64(m.Policy)) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -3932,6 +5830,9 @@ func (m *RegionHeartbeatResponse) MarshalTo(dAtA []byte) (int, error) { } i += n50 } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -3970,6 +5871,9 @@ func (m *AskSplitRequest) MarshalTo(dAtA []byte) (int, error) { } i += n52 } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -4020,6 +5924,9 @@ func (m *AskSplitResponse) MarshalTo(dAtA []byte) (int, error) { i = encodeVarintPdpb(dAtA, i, uint64(j54)) i += copy(dAtA[i:], dAtA55[:j54]) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -4068,6 +5975,9 @@ func (m *ReportSplitRequest) MarshalTo(dAtA []byte) (int, error) { } i += n58 } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -4096,6 +6006,9 @@ func (m *ReportSplitResponse) MarshalTo(dAtA []byte) (int, error) { } i += n59 } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -4139,6 +6052,9 @@ func (m *AskBatchSplitRequest) MarshalTo(dAtA []byte) (int, error) { i++ i = encodeVarintPdpb(dAtA, i, uint64(m.SplitCount)) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -4179,6 +6095,9 @@ func (m *SplitID) MarshalTo(dAtA []byte) (int, error) { i = encodeVarintPdpb(dAtA, i, uint64(j62)) i += copy(dAtA[i:], dAtA63[:j62]) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -4219,6 +6138,9 @@ func (m *AskBatchSplitResponse) MarshalTo(dAtA []byte) (int, error) { i += n } } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -4259,6 +6181,9 @@ func (m *ReportBatchSplitRequest) MarshalTo(dAtA []byte) (int, error) { i += n } } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -4287,6 +6212,9 @@ func (m *ReportBatchSplitResponse) MarshalTo(dAtA []byte) (int, error) { } i += n66 } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -4315,6 +6243,9 @@ func (m *TimeInterval) MarshalTo(dAtA []byte) (int, error) { i++ i = encodeVarintPdpb(dAtA, i, uint64(m.EndTimestamp)) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -4418,6 +6349,9 @@ func (m *StoreStats) MarshalTo(dAtA []byte) (int, error) { } i += n67 } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -4456,6 +6390,9 @@ func (m *StoreHeartbeatRequest) MarshalTo(dAtA []byte) (int, error) { } i += n69 } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -4484,6 +6421,9 @@ func (m *StoreHeartbeatResponse) MarshalTo(dAtA []byte) (int, error) { } i += n70 } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -4537,6 +6477,9 @@ func (m *ScatterRegionRequest) MarshalTo(dAtA []byte) (int, error) { } i += n73 } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -4565,6 +6508,9 @@ func (m *ScatterRegionResponse) MarshalTo(dAtA []byte) (int, error) { } i += n74 } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -4593,6 +6539,9 @@ func (m *GetGCSafePointRequest) MarshalTo(dAtA []byte) (int, error) { } i += n75 } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -4626,6 +6575,9 @@ func (m *GetGCSafePointResponse) MarshalTo(dAtA []byte) (int, error) { i++ i = encodeVarintPdpb(dAtA, i, uint64(m.SafePoint)) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -4659,6 +6611,9 @@ func (m *UpdateGCSafePointRequest) MarshalTo(dAtA []byte) (int, error) { i++ i = encodeVarintPdpb(dAtA, i, uint64(m.SafePoint)) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -4692,27 +6647,96 @@ func (m *UpdateGCSafePointResponse) MarshalTo(dAtA []byte) (int, error) { i++ i = encodeVarintPdpb(dAtA, i, uint64(m.NewSafePoint)) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } -func encodeFixed64Pdpb(dAtA []byte, offset int, v uint64) int { - dAtA[offset] = uint8(v) - dAtA[offset+1] = uint8(v >> 8) - dAtA[offset+2] = uint8(v >> 16) - dAtA[offset+3] = uint8(v >> 24) - dAtA[offset+4] = uint8(v >> 32) - dAtA[offset+5] = uint8(v >> 40) - dAtA[offset+6] = uint8(v >> 48) - dAtA[offset+7] = uint8(v >> 56) - return offset + 8 -} -func encodeFixed32Pdpb(dAtA []byte, offset int, v uint32) int { - dAtA[offset] = uint8(v) - dAtA[offset+1] = uint8(v >> 8) - dAtA[offset+2] = uint8(v >> 16) - dAtA[offset+3] = uint8(v >> 24) - return offset + 4 +func (m *SyncRegionRequest) 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 *SyncRegionRequest) 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())) + n79, err := m.Header.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n79 + } + if m.Member != nil { + dAtA[i] = 0x12 + i++ + i = encodeVarintPdpb(dAtA, i, uint64(m.Member.Size())) + n80, err := m.Member.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n80 + } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *SyncRegionResponse) 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 *SyncRegionResponse) 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())) + n81, err := m.Header.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n81 + } + if len(m.Regions) > 0 { + for _, msg := range m.Regions { + dAtA[i] = 0x12 + i++ + i = encodeVarintPdpb(dAtA, i, uint64(msg.Size())) + n, err := msg.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } + return i, nil } + func encodeVarintPdpb(dAtA []byte, offset int, v uint64) int { for v >= 1<<7 { dAtA[offset] = uint8(v&0x7f | 0x80) @@ -4728,6 +6752,9 @@ func (m *RequestHeader) Size() (n int) { if m.ClusterId != 0 { n += 1 + sovPdpb(uint64(m.ClusterId)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -4741,6 +6768,9 @@ func (m *ResponseHeader) Size() (n int) { l = m.Error.Size() n += 1 + l + sovPdpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -4754,6 +6784,9 @@ func (m *Error) Size() (n int) { if l > 0 { n += 1 + l + sovPdpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -4767,6 +6800,9 @@ func (m *TsoRequest) Size() (n int) { if m.Count != 0 { n += 1 + sovPdpb(uint64(m.Count)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -4779,6 +6815,9 @@ func (m *Timestamp) Size() (n int) { if m.Logical != 0 { n += 1 + sovPdpb(uint64(m.Logical)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -4796,6 +6835,9 @@ func (m *TsoResponse) Size() (n int) { l = m.Timestamp.Size() n += 1 + l + sovPdpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -4814,6 +6856,9 @@ func (m *BootstrapRequest) Size() (n int) { l = m.Region.Size() n += 1 + l + sovPdpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -4824,6 +6869,9 @@ func (m *BootstrapResponse) Size() (n int) { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -4834,6 +6882,9 @@ func (m *IsBootstrappedRequest) Size() (n int) { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -4847,6 +6898,9 @@ func (m *IsBootstrappedResponse) Size() (n int) { if m.Bootstrapped { n += 2 } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -4857,6 +6911,9 @@ func (m *AllocIDRequest) Size() (n int) { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -4870,6 +6927,9 @@ func (m *AllocIDResponse) Size() (n int) { if m.Id != 0 { n += 1 + sovPdpb(uint64(m.Id)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -4883,6 +6943,9 @@ func (m *GetStoreRequest) Size() (n int) { if m.StoreId != 0 { n += 1 + sovPdpb(uint64(m.StoreId)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -4897,6 +6960,9 @@ func (m *GetStoreResponse) Size() (n int) { l = m.Store.Size() n += 1 + l + sovPdpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -4911,6 +6977,9 @@ func (m *PutStoreRequest) Size() (n int) { l = m.Store.Size() n += 1 + l + sovPdpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -4921,6 +6990,9 @@ func (m *PutStoreResponse) Size() (n int) { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -4931,6 +7003,9 @@ func (m *GetAllStoresRequest) Size() (n int) { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -4947,6 +7022,9 @@ func (m *GetAllStoresResponse) Size() (n int) { n += 1 + l + sovPdpb(uint64(l)) } } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -4961,6 +7039,9 @@ func (m *GetRegionRequest) Size() (n int) { if l > 0 { n += 1 + l + sovPdpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -4979,6 +7060,9 @@ func (m *GetRegionResponse) Size() (n int) { l = m.Leader.Size() n += 1 + l + sovPdpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -4992,6 +7076,9 @@ func (m *GetRegionByIDRequest) Size() (n int) { if m.RegionId != 0 { n += 1 + sovPdpb(uint64(m.RegionId)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5002,6 +7089,9 @@ func (m *GetClusterConfigRequest) Size() (n int) { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5016,6 +7106,9 @@ func (m *GetClusterConfigResponse) Size() (n int) { l = m.Cluster.Size() n += 1 + l + sovPdpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5030,6 +7123,9 @@ func (m *PutClusterConfigRequest) Size() (n int) { l = m.Cluster.Size() n += 1 + l + sovPdpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5040,6 +7136,9 @@ func (m *PutClusterConfigResponse) Size() (n int) { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5068,6 +7167,9 @@ func (m *Member) Size() (n int) { if m.LeaderPriority != 0 { n += 1 + sovPdpb(uint64(m.LeaderPriority)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5078,6 +7180,9 @@ func (m *GetMembersRequest) Size() (n int) { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5102,6 +7207,9 @@ func (m *GetMembersResponse) Size() (n int) { l = m.EtcdLeader.Size() n += 1 + l + sovPdpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5115,6 +7223,9 @@ func (m *PeerStats) Size() (n int) { if m.DownSeconds != 0 { n += 1 + sovPdpb(uint64(m.DownSeconds)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5167,6 +7278,9 @@ func (m *RegionHeartbeatRequest) Size() (n int) { if m.ApproximateKeys != 0 { n += 1 + sovPdpb(uint64(m.ApproximateKeys)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5180,6 +7294,9 @@ func (m *ChangePeer) Size() (n int) { if m.ChangeType != 0 { n += 1 + sovPdpb(uint64(m.ChangeType)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5190,6 +7307,9 @@ func (m *TransferLeader) Size() (n int) { l = m.Peer.Size() n += 1 + l + sovPdpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5200,6 +7320,9 @@ func (m *Merge) Size() (n int) { l = m.Target.Size() n += 1 + l + sovPdpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5209,6 +7332,9 @@ func (m *SplitRegion) Size() (n int) { if m.Policy != 0 { n += 1 + sovPdpb(uint64(m.Policy)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5246,6 +7372,9 @@ func (m *RegionHeartbeatResponse) Size() (n int) { l = m.SplitRegion.Size() n += 1 + l + sovPdpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5260,6 +7389,9 @@ func (m *AskSplitRequest) Size() (n int) { l = m.Region.Size() n += 1 + l + sovPdpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5280,6 +7412,9 @@ func (m *AskSplitResponse) Size() (n int) { } n += 1 + sovPdpb(uint64(l)) + l } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5298,6 +7433,9 @@ func (m *ReportSplitRequest) Size() (n int) { l = m.Right.Size() n += 1 + l + sovPdpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5308,6 +7446,9 @@ func (m *ReportSplitResponse) Size() (n int) { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5325,6 +7466,9 @@ func (m *AskBatchSplitRequest) Size() (n int) { if m.SplitCount != 0 { n += 1 + sovPdpb(uint64(m.SplitCount)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5341,6 +7485,9 @@ func (m *SplitID) Size() (n int) { } n += 1 + sovPdpb(uint64(l)) + l } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5357,6 +7504,9 @@ func (m *AskBatchSplitResponse) Size() (n int) { n += 1 + l + sovPdpb(uint64(l)) } } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5373,6 +7523,9 @@ func (m *ReportBatchSplitRequest) Size() (n int) { n += 1 + l + sovPdpb(uint64(l)) } } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5383,6 +7536,9 @@ func (m *ReportBatchSplitResponse) Size() (n int) { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5395,6 +7551,9 @@ func (m *TimeInterval) Size() (n int) { if m.EndTimestamp != 0 { n += 1 + sovPdpb(uint64(m.EndTimestamp)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5447,6 +7606,9 @@ func (m *StoreStats) Size() (n int) { l = m.Interval.Size() n += 1 + l + sovPdpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5461,6 +7623,9 @@ func (m *StoreHeartbeatRequest) Size() (n int) { l = m.Stats.Size() n += 1 + l + sovPdpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5471,6 +7636,9 @@ func (m *StoreHeartbeatResponse) Size() (n int) { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5492,6 +7660,9 @@ func (m *ScatterRegionRequest) Size() (n int) { l = m.Leader.Size() n += 1 + l + sovPdpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5502,6 +7673,9 @@ func (m *ScatterRegionResponse) Size() (n int) { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5512,6 +7686,9 @@ func (m *GetGCSafePointRequest) Size() (n int) { l = m.Header.Size() n += 1 + l + sovPdpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5525,6 +7702,9 @@ func (m *GetGCSafePointResponse) Size() (n int) { if m.SafePoint != 0 { n += 1 + sovPdpb(uint64(m.SafePoint)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5538,6 +7718,9 @@ func (m *UpdateGCSafePointRequest) Size() (n int) { if m.SafePoint != 0 { n += 1 + sovPdpb(uint64(m.SafePoint)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5551,6 +7734,45 @@ func (m *UpdateGCSafePointResponse) Size() (n int) { if m.NewSafePoint != 0 { n += 1 + sovPdpb(uint64(m.NewSafePoint)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *SyncRegionRequest) Size() (n int) { + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.Member != nil { + l = m.Member.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *SyncRegionResponse) Size() (n int) { + var l int + _ = l + if m.Header != nil { + l = m.Header.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + if len(m.Regions) > 0 { + for _, e := range m.Regions { + l = e.Size() + n += 1 + l + sovPdpb(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -5627,6 +7849,7 @@ func (m *RequestHeader) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -5729,6 +7952,7 @@ func (m *ResponseHeader) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -5827,6 +8051,7 @@ func (m *Error) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -5929,6 +8154,7 @@ func (m *TsoRequest) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -6017,6 +8243,7 @@ func (m *Timestamp) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -6152,6 +8379,7 @@ func (m *TsoResponse) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -6301,6 +8529,7 @@ func (m *BootstrapRequest) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -6384,6 +8613,7 @@ func (m *BootstrapResponse) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -6467,6 +8697,7 @@ func (m *IsBootstrappedRequest) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -6570,6 +8801,7 @@ func (m *IsBootstrappedResponse) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -6653,6 +8885,7 @@ func (m *AllocIDRequest) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -6755,6 +8988,7 @@ func (m *AllocIDResponse) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -6857,6 +9091,7 @@ func (m *GetStoreRequest) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -6973,6 +9208,7 @@ func (m *GetStoreResponse) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -7089,6 +9325,7 @@ func (m *PutStoreRequest) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -7172,6 +9409,7 @@ func (m *PutStoreResponse) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -7255,6 +9493,7 @@ func (m *GetAllStoresRequest) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -7369,6 +9608,7 @@ func (m *GetAllStoresResponse) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -7483,6 +9723,7 @@ func (m *GetRegionRequest) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -7632,6 +9873,7 @@ func (m *GetRegionResponse) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -7734,6 +9976,7 @@ func (m *GetRegionByIDRequest) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -7817,6 +10060,7 @@ func (m *GetClusterConfigRequest) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -7933,6 +10177,7 @@ func (m *GetClusterConfigResponse) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -8049,6 +10294,7 @@ func (m *PutClusterConfigRequest) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -8132,6 +10378,7 @@ func (m *PutClusterConfigResponse) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -8307,6 +10554,7 @@ func (m *Member) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -8390,6 +10638,7 @@ func (m *GetMembersRequest) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -8570,6 +10819,7 @@ func (m *GetMembersResponse) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -8672,6 +10922,7 @@ func (m *PeerStats) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -9030,6 +11281,7 @@ func (m *RegionHeartbeatRequest) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -9132,6 +11384,7 @@ func (m *ChangePeer) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -9215,6 +11468,7 @@ func (m *TransferLeader) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -9298,6 +11552,7 @@ func (m *Merge) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -9367,6 +11622,7 @@ func (m *SplitRegion) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -9667,6 +11923,7 @@ func (m *RegionHeartbeatResponse) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -9783,6 +12040,7 @@ func (m *AskSplitRequest) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -9874,7 +12132,24 @@ func (m *AskSplitResponse) Unmarshal(dAtA []byte) error { } } case 3: - if wireType == 2 { + if wireType == 0 { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.NewPeerIds = append(m.NewPeerIds, v) + } else if wireType == 2 { var packedLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { @@ -9910,28 +12185,11 @@ func (m *AskSplitResponse) Unmarshal(dAtA []byte) error { iNdEx++ v |= (uint64(b) & 0x7F) << shift if b < 0x80 { - break - } - } - m.NewPeerIds = append(m.NewPeerIds, v) - } - } else if wireType == 0 { - var v uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - v |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break + break + } } + m.NewPeerIds = append(m.NewPeerIds, v) } - m.NewPeerIds = append(m.NewPeerIds, v) } else { return fmt.Errorf("proto: wrong wireType = %d for field NewPeerIds", wireType) } @@ -9947,6 +12205,7 @@ func (m *AskSplitResponse) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -10096,6 +12355,7 @@ func (m *ReportSplitRequest) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -10179,6 +12439,7 @@ func (m *ReportSplitResponse) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -10314,6 +12575,7 @@ func (m *AskBatchSplitRequest) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -10372,7 +12634,24 @@ func (m *SplitID) Unmarshal(dAtA []byte) error { } } case 2: - if wireType == 2 { + if wireType == 0 { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPdpb + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.NewPeerIds = append(m.NewPeerIds, v) + } else if wireType == 2 { var packedLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { @@ -10413,23 +12692,6 @@ func (m *SplitID) Unmarshal(dAtA []byte) error { } m.NewPeerIds = append(m.NewPeerIds, v) } - } else if wireType == 0 { - var v uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowPdpb - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - v |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - m.NewPeerIds = append(m.NewPeerIds, v) } else { return fmt.Errorf("proto: wrong wireType = %d for field NewPeerIds", wireType) } @@ -10445,6 +12707,7 @@ func (m *SplitID) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -10559,6 +12822,7 @@ func (m *AskBatchSplitResponse) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -10673,6 +12937,7 @@ func (m *ReportBatchSplitRequest) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -10756,6 +13021,7 @@ func (m *ReportBatchSplitResponse) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -10844,6 +13110,7 @@ func (m *TimeInterval) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -11194,6 +13461,7 @@ func (m *StoreStats) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -11310,6 +13578,7 @@ func (m *StoreHeartbeatRequest) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -11393,6 +13662,7 @@ func (m *StoreHeartbeatResponse) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -11561,6 +13831,7 @@ func (m *ScatterRegionRequest) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -11644,6 +13915,7 @@ func (m *ScatterRegionResponse) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -11727,6 +13999,7 @@ func (m *GetGCSafePointRequest) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -11829,6 +14102,7 @@ func (m *GetGCSafePointResponse) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -11931,6 +14205,7 @@ func (m *UpdateGCSafePointRequest) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -12033,6 +14308,239 @@ func (m *UpdateGCSafePointResponse) Unmarshal(dAtA []byte) error { 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 *SyncRegionRequest) 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: SyncRegionRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SyncRegionRequest: 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 Member", 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.Member == nil { + m.Member = &Member{} + } + if err := m.Member.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipPdpb(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + 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 *SyncRegionResponse) 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: SyncRegionResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SyncRegionResponse: 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 Regions", 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 + } + m.Regions = append(m.Regions, &metapb.Region{}) + if err := m.Regions[len(m.Regions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + 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 } } @@ -12147,154 +14655,157 @@ var ( ErrIntOverflowPdpb = fmt.Errorf("proto: integer overflow") ) -func init() { proto.RegisterFile("pdpb.proto", fileDescriptorPdpb) } - -var fileDescriptorPdpb = []byte{ - // 2328 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x5a, 0x5b, 0x6f, 0x1b, 0xc7, - 0x15, 0xd6, 0x52, 0x24, 0x45, 0x1e, 0x5e, 0x35, 0xd6, 0x85, 0xa6, 0x6f, 0xca, 0xd8, 0x6d, 0x65, - 0x37, 0x61, 0x1c, 0xb7, 0x28, 0x0c, 0x14, 0x09, 0x42, 0x5d, 0x2c, 0x33, 0xb6, 0x44, 0x62, 0x48, - 0x27, 0x0d, 0x50, 0x94, 0x5d, 0x91, 0x23, 0x6a, 0x2b, 0x6a, 0x77, 0xb3, 0x3b, 0x92, 0xcb, 0xbc, - 0xb4, 0x4f, 0x41, 0x81, 0x06, 0xe8, 0x5b, 0xd1, 0x97, 0x02, 0xfd, 0x05, 0xfd, 0x07, 0x45, 0x5f, - 0xfb, 0xd8, 0x9f, 0x50, 0xb8, 0x7f, 0xa4, 0x98, 0xdb, 0xde, 0x48, 0xd9, 0xee, 0x3a, 0x79, 0x32, - 0xf7, 0x9c, 0x33, 0xdf, 0xcc, 0x7c, 0xe7, 0x9c, 0x99, 0x33, 0x47, 0x06, 0x70, 0xc7, 0xee, 0x71, - 0xcb, 0xf5, 0x1c, 0xe6, 0xa0, 0x2c, 0xff, 0xdd, 0x2c, 0x9f, 0x53, 0x66, 0x6a, 0x59, 0xb3, 0x42, - 0x3d, 0xf3, 0x84, 0x05, 0x9f, 0x6b, 0x13, 0x67, 0xe2, 0x88, 0x9f, 0x1f, 0xf2, 0x5f, 0x52, 0x8a, - 0x5b, 0x50, 0x21, 0xf4, 0xab, 0x0b, 0xea, 0xb3, 0xa7, 0xd4, 0x1c, 0x53, 0x0f, 0xdd, 0x02, 0x18, - 0x4d, 0x2f, 0x7c, 0x46, 0xbd, 0xa1, 0x35, 0x6e, 0x18, 0x5b, 0xc6, 0x76, 0x96, 0x14, 0x95, 0xa4, - 0x33, 0xc6, 0x04, 0xaa, 0x84, 0xfa, 0xae, 0x63, 0xfb, 0xf4, 0xad, 0x06, 0xa0, 0xf7, 0x20, 0x47, - 0x3d, 0xcf, 0xf1, 0x1a, 0x99, 0x2d, 0x63, 0xbb, 0xf4, 0xa8, 0xd4, 0x12, 0xab, 0xde, 0xe7, 0x22, - 0x22, 0x35, 0xf8, 0x09, 0xe4, 0xc4, 0x37, 0xba, 0x0b, 0x59, 0x36, 0x73, 0xa9, 0x00, 0xa9, 0x3e, - 0xaa, 0x45, 0x4c, 0x07, 0x33, 0x97, 0x12, 0xa1, 0x44, 0x0d, 0x58, 0x39, 0xa7, 0xbe, 0x6f, 0x4e, - 0xa8, 0x80, 0x2c, 0x12, 0xfd, 0x89, 0xbb, 0x00, 0x03, 0xdf, 0x51, 0xdb, 0x41, 0x3f, 0x86, 0xfc, - 0xa9, 0x58, 0xa1, 0x80, 0x2b, 0x3d, 0xba, 0x26, 0xe1, 0x62, 0xbb, 0x25, 0xca, 0x04, 0xad, 0x41, - 0x6e, 0xe4, 0x5c, 0xd8, 0x4c, 0x40, 0x56, 0x88, 0xfc, 0xc0, 0x6d, 0x28, 0x0e, 0xac, 0x73, 0xea, - 0x33, 0xf3, 0xdc, 0x45, 0x4d, 0x28, 0xb8, 0xa7, 0x33, 0xdf, 0x1a, 0x99, 0x53, 0x81, 0xb8, 0x4c, - 0x82, 0x6f, 0xbe, 0xa6, 0xa9, 0x33, 0x11, 0xaa, 0x8c, 0x50, 0xe9, 0x4f, 0xfc, 0x7b, 0x03, 0x4a, - 0x62, 0x51, 0x92, 0x33, 0xf4, 0x7e, 0x62, 0x55, 0x6b, 0x7a, 0x55, 0x51, 0x4e, 0x5f, 0xbf, 0x2c, - 0xf4, 0x01, 0x14, 0x99, 0x5e, 0x56, 0x63, 0x59, 0xc0, 0x28, 0xae, 0x82, 0xd5, 0x92, 0xd0, 0x02, - 0x7f, 0x6b, 0x40, 0x7d, 0xc7, 0x71, 0x98, 0xcf, 0x3c, 0xd3, 0x4d, 0xc5, 0xce, 0x5d, 0xc8, 0xf9, - 0xcc, 0xf1, 0xa8, 0xf2, 0x61, 0xa5, 0xa5, 0xe2, 0xac, 0xcf, 0x85, 0x44, 0xea, 0xd0, 0x0f, 0x21, - 0xef, 0xd1, 0x89, 0xe5, 0xd8, 0x6a, 0x49, 0x55, 0x6d, 0x45, 0x84, 0x94, 0x28, 0x2d, 0x6e, 0xc3, - 0x6a, 0x64, 0x35, 0x69, 0x68, 0xc1, 0x7b, 0xb0, 0xde, 0xf1, 0x03, 0x10, 0x97, 0x8e, 0xd3, 0xec, - 0x0a, 0xff, 0x06, 0x36, 0x92, 0x28, 0xa9, 0x9c, 0x84, 0xa1, 0x7c, 0x1c, 0x41, 0x11, 0x24, 0x15, - 0x48, 0x4c, 0x86, 0x3f, 0x86, 0x6a, 0x7b, 0x3a, 0x75, 0x46, 0x9d, 0xbd, 0x54, 0x4b, 0xed, 0x42, - 0x2d, 0x18, 0x9e, 0x6a, 0x8d, 0x55, 0xc8, 0x58, 0x72, 0x65, 0x59, 0x92, 0xb1, 0xc6, 0xf8, 0x4b, - 0xa8, 0x1d, 0x50, 0x26, 0xfd, 0x97, 0x26, 0x22, 0xae, 0x43, 0x41, 0x78, 0x7d, 0x18, 0xa0, 0xae, - 0x88, 0xef, 0xce, 0x18, 0x53, 0xa8, 0x87, 0xd0, 0xa9, 0x16, 0xfb, 0x36, 0xe1, 0x86, 0x47, 0x50, - 0xeb, 0x5d, 0xbc, 0xc3, 0x0e, 0xde, 0x6a, 0x92, 0x4f, 0xa1, 0x1e, 0x4e, 0x92, 0x2a, 0x54, 0x77, - 0xe0, 0xda, 0x01, 0x65, 0xed, 0xe9, 0x54, 0x80, 0xf8, 0xa9, 0xbc, 0x7f, 0x06, 0x6b, 0x71, 0x8c, - 0x54, 0xac, 0xfe, 0x00, 0xf2, 0x62, 0x53, 0x7e, 0x23, 0xb3, 0xb5, 0x3c, 0xbf, 0x63, 0xa5, 0xc4, - 0xbf, 0x12, 0xee, 0x53, 0x39, 0x9b, 0x86, 0xd8, 0x5b, 0x00, 0x32, 0xd3, 0x87, 0x67, 0x74, 0x26, - 0xd8, 0x2d, 0x93, 0xa2, 0x94, 0x3c, 0xa3, 0x33, 0xfc, 0x27, 0x03, 0x56, 0x23, 0x13, 0xa4, 0xda, - 0x4a, 0x78, 0xd4, 0x64, 0x5e, 0x77, 0xd4, 0xa0, 0x7b, 0x90, 0x9f, 0x4a, 0x54, 0x79, 0x24, 0x95, - 0xb5, 0x5d, 0x8f, 0x72, 0x34, 0xa9, 0xc3, 0xbf, 0x16, 0xf4, 0xca, 0xa1, 0x3b, 0xb3, 0x74, 0x19, - 0x8a, 0x6e, 0x80, 0xda, 0x63, 0x98, 0x11, 0x05, 0x29, 0xe8, 0x8c, 0xf1, 0x13, 0xd8, 0x3c, 0xa0, - 0x6c, 0x57, 0xde, 0x89, 0xbb, 0x8e, 0x7d, 0x62, 0x4d, 0x52, 0x05, 0x82, 0x0f, 0x8d, 0x79, 0x9c, - 0x54, 0x0c, 0xde, 0x87, 0x15, 0x75, 0x45, 0x2b, 0x0a, 0x6b, 0x9a, 0x1a, 0x85, 0x4e, 0xb4, 0x1e, - 0x7f, 0x05, 0x9b, 0xbd, 0x8b, 0x77, 0x5f, 0xfc, 0xff, 0x33, 0xe5, 0x53, 0x68, 0xcc, 0x4f, 0x99, - 0x2a, 0xfd, 0xfe, 0x66, 0x40, 0xfe, 0x90, 0x9e, 0x1f, 0x53, 0x0f, 0x21, 0xc8, 0xda, 0xe6, 0xb9, - 0x2c, 0x2e, 0x8a, 0x44, 0xfc, 0xe6, 0x5e, 0x3b, 0x17, 0xda, 0x88, 0xd7, 0xa4, 0xa0, 0x33, 0xe6, - 0x4a, 0x97, 0x52, 0x6f, 0x78, 0xe1, 0x4d, 0xfd, 0xc6, 0xf2, 0xd6, 0xf2, 0x76, 0x91, 0x14, 0xb8, - 0xe0, 0x85, 0x37, 0xf5, 0xd1, 0x1d, 0x28, 0x8d, 0xa6, 0x16, 0xb5, 0x99, 0x54, 0x67, 0x85, 0x1a, - 0xa4, 0x48, 0x18, 0xfc, 0x08, 0x6a, 0x32, 0xbe, 0x86, 0xae, 0x67, 0x39, 0x9e, 0xc5, 0x66, 0x8d, - 0xdc, 0x96, 0xb1, 0x9d, 0x23, 0x55, 0x29, 0xee, 0x29, 0x29, 0xfe, 0x54, 0xe4, 0x83, 0x5c, 0x64, - 0xba, 0xf3, 0xe1, 0x9f, 0x06, 0xa0, 0x28, 0x44, 0xca, 0x9c, 0x5a, 0x91, 0x3b, 0xd7, 0xe7, 0x43, - 0x59, 0x9a, 0x4b, 0x54, 0xa2, 0x95, 0x0b, 0x72, 0x2a, 0x6a, 0xa6, 0x74, 0xe8, 0x03, 0x28, 0x51, - 0x36, 0x1a, 0x0f, 0x95, 0x69, 0x76, 0x81, 0x29, 0x70, 0x83, 0xe7, 0x72, 0x07, 0x3d, 0x28, 0xf2, - 0x94, 0xec, 0x33, 0x93, 0xf9, 0x68, 0x0b, 0xb2, 0x9c, 0x66, 0xb5, 0xea, 0x78, 0xce, 0x0a, 0x0d, - 0x7a, 0x0f, 0xca, 0x63, 0xe7, 0xa5, 0x3d, 0xf4, 0xe9, 0xc8, 0xb1, 0xc7, 0xbe, 0xf2, 0x5c, 0x89, - 0xcb, 0xfa, 0x52, 0x84, 0xbf, 0xc9, 0xc2, 0x86, 0x4c, 0xe9, 0xa7, 0xd4, 0xf4, 0xd8, 0x31, 0x35, - 0x59, 0xaa, 0xa8, 0xfd, 0x4e, 0x8f, 0x1a, 0xd4, 0x02, 0x10, 0x0b, 0xe7, 0xbb, 0x90, 0x41, 0x13, - 0x94, 0x6e, 0xc1, 0xfe, 0x49, 0x91, 0x9b, 0xf0, 0x4f, 0x1f, 0x7d, 0x04, 0x15, 0x97, 0xda, 0x63, - 0xcb, 0x9e, 0xa8, 0x21, 0x39, 0xe5, 0x9a, 0x28, 0x78, 0x59, 0x99, 0xc8, 0x21, 0x77, 0xa1, 0x72, - 0x3c, 0x63, 0xd4, 0x1f, 0xbe, 0xf4, 0x2c, 0xc6, 0xa8, 0xdd, 0xc8, 0x0b, 0x72, 0xca, 0x42, 0xf8, - 0x85, 0x94, 0xf1, 0x33, 0x5a, 0x1a, 0x79, 0xd4, 0x1c, 0x37, 0x56, 0x64, 0xcd, 0x2e, 0x24, 0x84, - 0x9a, 0xbc, 0x66, 0x2f, 0x9f, 0xd1, 0x59, 0x08, 0x51, 0x90, 0xfc, 0x72, 0x99, 0x46, 0xb8, 0x01, - 0x45, 0x61, 0x22, 0x00, 0x8a, 0x32, 0x73, 0xb8, 0x40, 0x8c, 0xbf, 0x0f, 0x75, 0xd3, 0x75, 0x3d, - 0xe7, 0xb7, 0xd6, 0xb9, 0xc9, 0xe8, 0xd0, 0xb7, 0xbe, 0xa6, 0x0d, 0x10, 0x36, 0xb5, 0x88, 0xbc, - 0x6f, 0x7d, 0x4d, 0x51, 0x0b, 0x0a, 0x96, 0xcd, 0xa8, 0x77, 0x69, 0x4e, 0x1b, 0x65, 0xc1, 0x1c, - 0x0a, 0x4b, 0xd9, 0x8e, 0xd2, 0x90, 0xc0, 0x26, 0x09, 0xcd, 0xa7, 0x6c, 0x54, 0xe6, 0xa0, 0x9f, - 0xd1, 0x99, 0xff, 0x59, 0xb6, 0x50, 0xaa, 0x97, 0xf1, 0x29, 0xc0, 0xee, 0xa9, 0x69, 0x4f, 0x28, - 0xa7, 0xe7, 0x2d, 0x62, 0xeb, 0x31, 0x94, 0x46, 0xc2, 0x7e, 0x28, 0x9e, 0x22, 0x19, 0xf1, 0x14, - 0xd9, 0x6c, 0xe9, 0xb7, 0x14, 0x3f, 0x8d, 0x24, 0x9e, 0x78, 0x92, 0xc0, 0x28, 0xf8, 0x8d, 0x1f, - 0x41, 0x75, 0xe0, 0x99, 0xb6, 0x7f, 0x42, 0x3d, 0x19, 0xd6, 0x6f, 0x9e, 0x0d, 0x7f, 0x08, 0xb9, - 0x43, 0xea, 0x4d, 0x44, 0xf5, 0xcc, 0x4c, 0x6f, 0x42, 0x99, 0x32, 0x9e, 0x8b, 0x33, 0xa9, 0xc5, - 0x8f, 0xa1, 0xd4, 0x77, 0xa7, 0x96, 0xba, 0xae, 0xd0, 0x7d, 0xc8, 0xbb, 0xce, 0xd4, 0x1a, 0xcd, - 0xd4, 0x9b, 0x69, 0x55, 0x92, 0xb7, 0x7b, 0x4a, 0x47, 0x67, 0x3d, 0xa1, 0x20, 0xca, 0x00, 0xff, - 0x79, 0x19, 0x36, 0xe7, 0x32, 0x22, 0xd5, 0x51, 0xf1, 0x51, 0x40, 0x91, 0xd8, 0x9d, 0x4c, 0x8c, - 0xba, 0x9e, 0x59, 0x73, 0xad, 0xb9, 0x11, 0xbc, 0x7f, 0x0c, 0x35, 0xa6, 0xb8, 0x19, 0xc6, 0xf2, - 0x44, 0xcd, 0x14, 0x27, 0x8e, 0x54, 0x59, 0x9c, 0xc8, 0xd8, 0xed, 0x9a, 0x8d, 0xdf, 0xae, 0xe8, - 0x67, 0x50, 0x56, 0x4a, 0xea, 0x3a, 0xa3, 0x53, 0x71, 0xcc, 0xf2, 0xac, 0x8e, 0x11, 0xb8, 0xcf, - 0x55, 0xa4, 0xe4, 0x85, 0x1f, 0xfc, 0x8c, 0x92, 0xa4, 0xca, 0x6d, 0xe4, 0x17, 0x38, 0x09, 0xa4, - 0x41, 0x4f, 0x1e, 0x3a, 0xb9, 0x73, 0xee, 0x2a, 0x91, 0x2e, 0xc1, 0x43, 0x56, 0x78, 0x8f, 0x48, - 0x0d, 0xfa, 0x29, 0x94, 0x7d, 0xee, 0x9c, 0xa1, 0x3a, 0x32, 0x0a, 0xc2, 0x52, 0xf9, 0x24, 0xe2, - 0x36, 0x52, 0xf2, 0xc3, 0x0f, 0x7c, 0x02, 0xb5, 0xb6, 0x7f, 0xa6, 0xd4, 0xdf, 0xdf, 0x11, 0x85, - 0xbf, 0x31, 0xa0, 0x1e, 0x4e, 0x94, 0xf2, 0xa9, 0x53, 0xb1, 0xe9, 0xcb, 0x61, 0xb2, 0xd2, 0x29, - 0xd9, 0xf4, 0x25, 0xd1, 0xee, 0xd8, 0x82, 0x32, 0xb7, 0x11, 0x57, 0xa7, 0x35, 0x96, 0x37, 0x67, - 0x96, 0x80, 0x4d, 0x5f, 0x72, 0x1a, 0x3b, 0x63, 0x1f, 0xff, 0xd1, 0x00, 0x44, 0xa8, 0xeb, 0x78, - 0x2c, 0xfd, 0xa6, 0x31, 0x64, 0xa7, 0xf4, 0x84, 0x5d, 0xb1, 0x65, 0xa1, 0x43, 0xf7, 0x20, 0xe7, - 0x59, 0x93, 0x53, 0x76, 0xc5, 0x83, 0x54, 0x2a, 0xf1, 0x2e, 0x5c, 0x8b, 0x2d, 0x26, 0x55, 0x9d, - 0xf1, 0xad, 0x01, 0x6b, 0x6d, 0xff, 0x6c, 0xc7, 0x64, 0xa3, 0xd3, 0xef, 0xdd, 0x93, 0xbc, 0xf8, - 0x90, 0x71, 0x26, 0x9b, 0x03, 0xcb, 0xa2, 0x39, 0x00, 0x42, 0xb4, 0x2b, 0x1a, 0x17, 0x5d, 0x58, - 0x11, 0xab, 0xe8, 0xec, 0xcd, 0xbb, 0xcc, 0x78, 0xb3, 0xcb, 0x32, 0x73, 0x2e, 0x3b, 0x81, 0xf5, - 0xc4, 0xf6, 0x52, 0xc5, 0xcf, 0x1d, 0x58, 0xd6, 0xf8, 0xfc, 0x01, 0x12, 0xe6, 0x45, 0x67, 0x8f, - 0x70, 0x0d, 0x76, 0xf9, 0x19, 0xc5, 0x9d, 0xf1, 0x8e, 0x4c, 0x6e, 0xc3, 0x8a, 0xdc, 0xb1, 0x9e, - 0x2c, 0x49, 0xa5, 0x56, 0xf3, 0x5a, 0x73, 0x7e, 0xc6, 0x54, 0x31, 0xf0, 0x4b, 0x28, 0x47, 0x2f, - 0x2d, 0x5e, 0x01, 0xfa, 0xcc, 0xf4, 0xd8, 0x30, 0x6c, 0xd6, 0x48, 0xee, 0xab, 0x42, 0x1c, 0x76, - 0x96, 0xee, 0x42, 0x85, 0xda, 0xe3, 0x88, 0x99, 0xcc, 0xaa, 0x32, 0xb5, 0xc7, 0x81, 0x11, 0xfe, - 0x6b, 0x16, 0x40, 0xbc, 0xd4, 0x64, 0x91, 0x14, 0x7d, 0x80, 0x1b, 0xb1, 0x07, 0x38, 0x6a, 0x42, - 0x61, 0x64, 0xba, 0xe6, 0x88, 0x97, 0x9c, 0xaa, 0xa6, 0xd5, 0xdf, 0xe8, 0x26, 0x14, 0xcd, 0x4b, - 0xd3, 0x9a, 0x9a, 0xc7, 0x53, 0x2a, 0xe2, 0x26, 0x4b, 0x42, 0x01, 0xbf, 0xf7, 0x55, 0x9c, 0xc8, - 0xc0, 0xca, 0x8a, 0xc0, 0x52, 0x87, 0xa6, 0x88, 0x2c, 0xf4, 0x3e, 0x20, 0x5f, 0x55, 0x24, 0xbe, - 0x6d, 0xba, 0xca, 0x30, 0x27, 0x0c, 0xeb, 0x4a, 0xd3, 0xb7, 0x4d, 0x57, 0x5a, 0x3f, 0x84, 0x35, - 0x8f, 0x8e, 0xa8, 0x75, 0x99, 0xb0, 0xcf, 0x0b, 0x7b, 0x14, 0xe8, 0xc2, 0x11, 0xb7, 0x00, 0x42, - 0xd2, 0xc4, 0x51, 0x5b, 0x21, 0xc5, 0x80, 0x2f, 0xd4, 0x82, 0x6b, 0xa6, 0xeb, 0x4e, 0x67, 0x09, - 0xbc, 0x82, 0xb0, 0x5b, 0xd5, 0xaa, 0x10, 0x6e, 0x13, 0x56, 0x2c, 0x7f, 0x78, 0x7c, 0xe1, 0xcf, - 0x44, 0x91, 0x52, 0x20, 0x79, 0xcb, 0xdf, 0xb9, 0xf0, 0x67, 0xfc, 0x46, 0xb9, 0xf0, 0xe9, 0x38, - 0x5a, 0x9b, 0x14, 0xb8, 0x40, 0x14, 0x25, 0x73, 0x35, 0x54, 0x69, 0x41, 0x0d, 0x95, 0x2c, 0x92, - 0xca, 0xf3, 0x45, 0x52, 0xbc, 0xcc, 0xaa, 0x24, 0xcb, 0xac, 0x58, 0x0d, 0x55, 0x4d, 0xd4, 0x50, - 0xd1, 0xc2, 0xa8, 0xf6, 0xe6, 0xc2, 0x08, 0x4f, 0x61, 0x5d, 0x84, 0xc7, 0xbb, 0x96, 0xbb, 0x39, - 0x9f, 0xc7, 0x57, 0xfc, 0x52, 0x0f, 0xe3, 0x8e, 0x48, 0x35, 0x7e, 0x02, 0x1b, 0xc9, 0xd9, 0x52, - 0xe5, 0xcc, 0xdf, 0x0d, 0x58, 0xeb, 0x8f, 0x4c, 0xc6, 0x9f, 0x7f, 0xe9, 0x5b, 0x0e, 0xaf, 0x7b, - 0x7c, 0xbf, 0x6d, 0x5f, 0x32, 0x52, 0xc1, 0x67, 0x5f, 0xd3, 0x2c, 0xd8, 0x87, 0xf5, 0xc4, 0x7a, - 0xd3, 0x76, 0x30, 0x0f, 0x28, 0x3b, 0xd8, 0xed, 0x9b, 0x27, 0xb4, 0xe7, 0x58, 0x76, 0x2a, 0x6f, - 0x61, 0x0a, 0x1b, 0x49, 0x94, 0x54, 0xc7, 0x32, 0x4f, 0x3a, 0xf3, 0x84, 0x0e, 0x5d, 0x8e, 0xa1, - 0x08, 0x2c, 0xfa, 0x1a, 0x14, 0x9f, 0x40, 0xe3, 0x85, 0x3b, 0x36, 0x19, 0x7d, 0xc7, 0xf5, 0xbe, - 0x69, 0x1e, 0x07, 0xae, 0x2f, 0x98, 0x27, 0xd5, 0x8e, 0xee, 0x41, 0x95, 0xdf, 0x68, 0x73, 0xb3, - 0xf1, 0x7b, 0x2e, 0xc0, 0x7e, 0xf0, 0x3b, 0x28, 0x06, 0x7f, 0x5d, 0x40, 0x79, 0xc8, 0x74, 0x9f, - 0xd5, 0x97, 0x50, 0x09, 0x56, 0x5e, 0x1c, 0x3d, 0x3b, 0xea, 0x7e, 0x71, 0x54, 0x37, 0xd0, 0x1a, - 0xd4, 0x8f, 0xba, 0x83, 0xe1, 0x4e, 0xb7, 0x3b, 0xe8, 0x0f, 0x48, 0xbb, 0xd7, 0xdb, 0xdf, 0xab, - 0x67, 0xd0, 0x35, 0xa8, 0xf5, 0x07, 0x5d, 0xb2, 0x3f, 0x1c, 0x74, 0x0f, 0x77, 0xfa, 0x83, 0xee, - 0xd1, 0x7e, 0x7d, 0x19, 0x35, 0x60, 0xad, 0xfd, 0x9c, 0xec, 0xb7, 0xf7, 0xbe, 0x8c, 0x9b, 0x67, - 0xb9, 0xa6, 0x73, 0xb4, 0xdb, 0x3d, 0xec, 0xb5, 0x07, 0x9d, 0x9d, 0xe7, 0xfb, 0xc3, 0xcf, 0xf7, - 0x49, 0xbf, 0xd3, 0x3d, 0xaa, 0xe7, 0x1e, 0x6c, 0x43, 0x29, 0x52, 0xaa, 0xa3, 0x02, 0x64, 0xfb, - 0xbb, 0xed, 0xa3, 0xfa, 0x12, 0xaa, 0x41, 0xa9, 0xdd, 0xeb, 0x91, 0xee, 0x2f, 0x3a, 0x87, 0xed, - 0xc1, 0x7e, 0xdd, 0x78, 0xf4, 0x8f, 0x32, 0x64, 0x7a, 0x7b, 0xa8, 0x0d, 0x10, 0xbe, 0xf4, 0xd1, - 0xa6, 0xe4, 0x60, 0xae, 0x7d, 0xd0, 0x6c, 0xcc, 0x2b, 0x24, 0x4d, 0x78, 0x09, 0x3d, 0x84, 0xe5, - 0x81, 0xef, 0x20, 0x95, 0xda, 0xe1, 0x1f, 0x4c, 0x9a, 0xab, 0x11, 0x89, 0xb6, 0xde, 0x36, 0x1e, - 0x1a, 0xe8, 0x13, 0x28, 0x06, 0x6d, 0x72, 0xb4, 0x21, 0xad, 0x92, 0x7f, 0x50, 0x68, 0x6e, 0xce, - 0xc9, 0x83, 0x19, 0x0f, 0xa1, 0x1a, 0x6f, 0xb4, 0xa3, 0x1b, 0xd2, 0x78, 0x61, 0x13, 0xbf, 0x79, - 0x73, 0xb1, 0x32, 0x80, 0x7b, 0x0c, 0x2b, 0xaa, 0x19, 0x8e, 0x54, 0x10, 0xc4, 0x5b, 0xeb, 0xcd, - 0xf5, 0x84, 0x34, 0x18, 0xf9, 0x73, 0x28, 0xe8, 0xd6, 0x34, 0x5a, 0x0f, 0x28, 0x8a, 0xf6, 0x90, - 0x9b, 0x1b, 0x49, 0x71, 0x74, 0xb0, 0xee, 0x05, 0xeb, 0xc1, 0x89, 0x06, 0xb4, 0x1e, 0x9c, 0x6c, - 0x19, 0xe3, 0x25, 0x74, 0x00, 0xe5, 0x68, 0x0b, 0x17, 0x5d, 0x0f, 0xa6, 0x49, 0xb6, 0x86, 0x9b, - 0xcd, 0x45, 0xaa, 0x28, 0x97, 0xf1, 0x83, 0x57, 0x73, 0xb9, 0xf0, 0xf0, 0xd7, 0x5c, 0x2e, 0x3e, - 0xab, 0xf1, 0x12, 0x1a, 0x40, 0x2d, 0xf1, 0x26, 0x44, 0x37, 0x75, 0x62, 0x2d, 0x6a, 0x9e, 0x34, - 0x6f, 0x5d, 0xa1, 0x4d, 0x06, 0x4c, 0xd0, 0x51, 0x45, 0x21, 0xa3, 0xb1, 0x13, 0xbe, 0xb9, 0x39, - 0x27, 0x0f, 0x56, 0xb5, 0x03, 0x95, 0x03, 0xca, 0x7a, 0x1e, 0xbd, 0x4c, 0x8f, 0xf1, 0x44, 0x60, - 0x84, 0x5d, 0x5d, 0xd4, 0x4c, 0xd8, 0x46, 0x5a, 0xbd, 0xaf, 0xc3, 0xf9, 0x04, 0x0a, 0xfa, 0xd1, - 0xa4, 0xdd, 0x9e, 0x78, 0xad, 0x69, 0xb7, 0x27, 0xdf, 0x56, 0x78, 0xf9, 0x0f, 0x19, 0x03, 0x1d, - 0x40, 0x29, 0xf2, 0xbc, 0x40, 0x0d, 0xcd, 0x5f, 0xf2, 0xf9, 0xd3, 0xbc, 0xbe, 0x40, 0x13, 0x05, - 0xfa, 0x0c, 0x2a, 0xb1, 0x12, 0x5c, 0x6f, 0x68, 0xd1, 0xb3, 0xa3, 0x79, 0x63, 0xa1, 0x2e, 0xd8, - 0x54, 0x1f, 0xea, 0xc9, 0xa2, 0x17, 0xdd, 0x8a, 0xce, 0x3f, 0x8f, 0x78, 0xfb, 0x2a, 0x75, 0x14, - 0x34, 0xd9, 0x9d, 0xd6, 0xa0, 0x57, 0x74, 0xbf, 0x35, 0xe8, 0x55, 0x4d, 0x6d, 0x09, 0x9a, 0x6c, - 0x05, 0x6b, 0xd0, 0x2b, 0xba, 0xd2, 0x1a, 0xf4, 0xaa, 0x0e, 0x32, 0x5e, 0xe2, 0x54, 0xc6, 0x2e, - 0x71, 0x4d, 0xe5, 0xa2, 0x4a, 0x44, 0x53, 0xb9, 0xf0, 0xd6, 0x97, 0x09, 0x19, 0xbf, 0x83, 0x75, - 0x42, 0x2e, 0xbc, 0xdf, 0x75, 0x42, 0x2e, 0xbe, 0xb6, 0xf1, 0x12, 0xfa, 0x1c, 0x56, 0xe7, 0xee, - 0x40, 0xa4, 0x76, 0x74, 0xd5, 0x25, 0xdc, 0xbc, 0x73, 0xa5, 0x5e, 0xe3, 0xee, 0x3c, 0xf8, 0xd7, - 0xab, 0xdb, 0xc6, 0xbf, 0x5f, 0xdd, 0x36, 0xfe, 0xf3, 0xea, 0xb6, 0xf1, 0x97, 0xff, 0xde, 0x5e, - 0x82, 0xc6, 0xc8, 0x39, 0x6f, 0xb9, 0x96, 0x3d, 0x19, 0x99, 0x6e, 0x8b, 0x59, 0x67, 0x97, 0xad, - 0xb3, 0x4b, 0xf1, 0x7f, 0x02, 0x8e, 0xf3, 0xe2, 0x9f, 0x9f, 0xfc, 0x2f, 0x00, 0x00, 0xff, 0xff, - 0x64, 0x88, 0xec, 0x1f, 0x61, 0x20, 0x00, 0x00, +func init() { proto.RegisterFile("pdpb.proto", fileDescriptor_pdpb_151bd877a46a223e) } + +var fileDescriptor_pdpb_151bd877a46a223e = []byte{ + // 2371 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x1a, 0xd9, 0x6e, 0x1b, 0xd7, + 0x55, 0xc3, 0x4d, 0xe4, 0xe1, 0xaa, 0x6b, 0x2d, 0x34, 0xbd, 0x29, 0xd7, 0x6e, 0x2b, 0xbb, 0x09, + 0xe3, 0xb8, 0x45, 0x61, 0xa0, 0x48, 0x10, 0x6a, 0xb1, 0xcc, 0xd8, 0x12, 0x89, 0x4b, 0x3a, 0x69, + 0x80, 0xa2, 0xec, 0x68, 0x78, 0x45, 0x4d, 0x45, 0xcd, 0x4c, 0x66, 0x46, 0x72, 0x99, 0x97, 0xf6, + 0xa5, 0x41, 0x81, 0x06, 0xe8, 0x5b, 0xd1, 0x97, 0x02, 0xfd, 0x82, 0xfe, 0x42, 0x5f, 0xfb, 0xd8, + 0x4f, 0x28, 0xdc, 0x1f, 0x29, 0xee, 0x36, 0x1b, 0x29, 0x5b, 0x1d, 0x25, 0x4f, 0xe2, 0x9c, 0x73, + 0xe6, 0xdc, 0xb3, 0xde, 0xb3, 0x8c, 0x00, 0x9c, 0xb1, 0x73, 0xd4, 0x76, 0x5c, 0xdb, 0xb7, 0x51, + 0x8e, 0xfd, 0x6e, 0x55, 0xce, 0xa8, 0xaf, 0x2b, 0x58, 0xab, 0x4a, 0x5d, 0xfd, 0xd8, 0x0f, 0x1e, + 0x57, 0x27, 0xf6, 0xc4, 0xe6, 0x3f, 0x3f, 0x64, 0xbf, 0x04, 0x14, 0xb7, 0xa1, 0x4a, 0xe8, 0x57, + 0xe7, 0xd4, 0xf3, 0x9f, 0x53, 0x7d, 0x4c, 0x5d, 0x74, 0x07, 0xc0, 0x98, 0x9e, 0x7b, 0x3e, 0x75, + 0x47, 0xe6, 0xb8, 0xa9, 0x6d, 0x6a, 0x5b, 0x39, 0x52, 0x92, 0x90, 0xee, 0x18, 0x13, 0xa8, 0x11, + 0xea, 0x39, 0xb6, 0xe5, 0xd1, 0x2b, 0xbd, 0x80, 0xde, 0x83, 0x3c, 0x75, 0x5d, 0xdb, 0x6d, 0x66, + 0x36, 0xb5, 0xad, 0xf2, 0x93, 0x72, 0x9b, 0x4b, 0xbd, 0xc7, 0x40, 0x44, 0x60, 0xf0, 0x33, 0xc8, + 0xf3, 0x67, 0x74, 0x1f, 0x72, 0xfe, 0xcc, 0xa1, 0x9c, 0x49, 0xed, 0x49, 0x3d, 0x42, 0x3a, 0x9c, + 0x39, 0x94, 0x70, 0x24, 0x6a, 0xc2, 0xf2, 0x19, 0xf5, 0x3c, 0x7d, 0x42, 0x39, 0xcb, 0x12, 0x51, + 0x8f, 0xb8, 0x07, 0x30, 0xf4, 0x6c, 0xa9, 0x0e, 0xfa, 0x31, 0x14, 0x4e, 0xb8, 0x84, 0x9c, 0x5d, + 0xf9, 0xc9, 0x0d, 0xc1, 0x2e, 0xa6, 0x2d, 0x91, 0x24, 0x68, 0x15, 0xf2, 0x86, 0x7d, 0x6e, 0xf9, + 0x9c, 0x65, 0x95, 0x88, 0x07, 0xdc, 0x81, 0xd2, 0xd0, 0x3c, 0xa3, 0x9e, 0xaf, 0x9f, 0x39, 0xa8, + 0x05, 0x45, 0xe7, 0x64, 0xe6, 0x99, 0x86, 0x3e, 0xe5, 0x1c, 0xb3, 0x24, 0x78, 0x66, 0x32, 0x4d, + 0xed, 0x09, 0x47, 0x65, 0x38, 0x4a, 0x3d, 0xe2, 0xdf, 0x6b, 0x50, 0xe6, 0x42, 0x09, 0x9b, 0xa1, + 0xf7, 0x13, 0x52, 0xad, 0x2a, 0xa9, 0xa2, 0x36, 0x7d, 0xbb, 0x58, 0xe8, 0x03, 0x28, 0xf9, 0x4a, + 0xac, 0x66, 0x96, 0xb3, 0x91, 0xb6, 0x0a, 0xa4, 0x25, 0x21, 0x05, 0xfe, 0x56, 0x83, 0xc6, 0xb6, + 0x6d, 0xfb, 0x9e, 0xef, 0xea, 0x4e, 0x2a, 0xeb, 0xdc, 0x87, 0xbc, 0xe7, 0xdb, 0x2e, 0x95, 0x3e, + 0xac, 0xb6, 0x65, 0x9c, 0x0d, 0x18, 0x90, 0x08, 0x1c, 0xfa, 0x21, 0x14, 0x5c, 0x3a, 0x31, 0x6d, + 0x4b, 0x8a, 0x54, 0x53, 0x54, 0x84, 0x43, 0x89, 0xc4, 0xe2, 0x0e, 0xac, 0x44, 0xa4, 0x49, 0x63, + 0x16, 0xbc, 0x0b, 0x6b, 0x5d, 0x2f, 0x60, 0xe2, 0xd0, 0x71, 0x1a, 0xad, 0xf0, 0x6f, 0x60, 0x3d, + 0xc9, 0x25, 0x95, 0x93, 0x30, 0x54, 0x8e, 0x22, 0x5c, 0xb8, 0x91, 0x8a, 0x24, 0x06, 0xc3, 0x1f, + 0x43, 0xad, 0x33, 0x9d, 0xda, 0x46, 0x77, 0x37, 0x95, 0xa8, 0x3d, 0xa8, 0x07, 0xaf, 0xa7, 0x92, + 0xb1, 0x06, 0x19, 0x53, 0x48, 0x96, 0x23, 0x19, 0x73, 0x8c, 0xbf, 0x84, 0xfa, 0x3e, 0xf5, 0x85, + 0xff, 0xd2, 0x44, 0xc4, 0x4d, 0x28, 0x72, 0xaf, 0x8f, 0x02, 0xae, 0xcb, 0xfc, 0xb9, 0x3b, 0xc6, + 0x14, 0x1a, 0x21, 0xeb, 0x54, 0xc2, 0x5e, 0x25, 0xdc, 0xb0, 0x01, 0xf5, 0xfe, 0xf9, 0x35, 0x34, + 0xb8, 0xd2, 0x21, 0x9f, 0x42, 0x23, 0x3c, 0x24, 0x55, 0xa8, 0x6e, 0xc3, 0x8d, 0x7d, 0xea, 0x77, + 0xa6, 0x53, 0xce, 0xc4, 0x4b, 0xe5, 0xfd, 0x53, 0x58, 0x8d, 0xf3, 0x48, 0x65, 0xd5, 0x1f, 0x40, + 0x81, 0x2b, 0xe5, 0x35, 0x33, 0x9b, 0xd9, 0x79, 0x8d, 0x25, 0x12, 0xff, 0x8a, 0xbb, 0x4f, 0xe6, + 0x6c, 0x1a, 0xc3, 0xde, 0x01, 0x10, 0x99, 0x3e, 0x3a, 0xa5, 0x33, 0x6e, 0xdd, 0x0a, 0x29, 0x09, + 0xc8, 0x0b, 0x3a, 0xc3, 0x7f, 0xd6, 0x60, 0x25, 0x72, 0x40, 0x2a, 0x55, 0xc2, 0xab, 0x26, 0xf3, + 0xb6, 0xab, 0x06, 0x3d, 0x80, 0xc2, 0x54, 0x70, 0x15, 0x57, 0x52, 0x45, 0xd1, 0xf5, 0x29, 0xe3, + 0x26, 0x70, 0xf8, 0xd7, 0xdc, 0xbc, 0xe2, 0xd5, 0xed, 0x59, 0xba, 0x0c, 0x45, 0xb7, 0x40, 0xea, + 0x18, 0x66, 0x44, 0x51, 0x00, 0xba, 0x63, 0xfc, 0x0c, 0x36, 0xf6, 0xa9, 0xbf, 0x23, 0x6a, 0xe2, + 0x8e, 0x6d, 0x1d, 0x9b, 0x93, 0x54, 0x81, 0xe0, 0x41, 0x73, 0x9e, 0x4f, 0x2a, 0x0b, 0x3e, 0x84, + 0x65, 0x59, 0xa2, 0xa5, 0x09, 0xeb, 0xca, 0x34, 0x92, 0x3b, 0x51, 0x78, 0xfc, 0x15, 0x6c, 0xf4, + 0xcf, 0xaf, 0x2f, 0xfc, 0xff, 0x73, 0xe4, 0x73, 0x68, 0xce, 0x1f, 0x99, 0x2a, 0xfd, 0xfe, 0xae, + 0x41, 0xe1, 0x80, 0x9e, 0x1d, 0x51, 0x17, 0x21, 0xc8, 0x59, 0xfa, 0x99, 0x68, 0x2e, 0x4a, 0x84, + 0xff, 0x66, 0x5e, 0x3b, 0xe3, 0xd8, 0x88, 0xd7, 0x04, 0xa0, 0x3b, 0x66, 0x48, 0x87, 0x52, 0x77, + 0x74, 0xee, 0x4e, 0xbd, 0x66, 0x76, 0x33, 0xbb, 0x55, 0x22, 0x45, 0x06, 0x78, 0xe5, 0x4e, 0x3d, + 0x74, 0x0f, 0xca, 0xc6, 0xd4, 0xa4, 0x96, 0x2f, 0xd0, 0x39, 0x8e, 0x06, 0x01, 0xe2, 0x04, 0x3f, + 0x82, 0xba, 0x88, 0xaf, 0x91, 0xe3, 0x9a, 0xb6, 0x6b, 0xfa, 0xb3, 0x66, 0x7e, 0x53, 0xdb, 0xca, + 0x93, 0x9a, 0x00, 0xf7, 0x25, 0x14, 0x7f, 0xca, 0xf3, 0x41, 0x08, 0x99, 0xee, 0x7e, 0xf8, 0xa7, + 0x06, 0x28, 0xca, 0x22, 0x65, 0x4e, 0x2d, 0x0b, 0xcd, 0xd5, 0xfd, 0x50, 0x11, 0xe4, 0x82, 0x2b, + 0x51, 0xc8, 0x05, 0x39, 0x15, 0x25, 0x93, 0x38, 0xf4, 0x01, 0x94, 0xa9, 0x6f, 0x8c, 0x47, 0x92, + 0x34, 0xb7, 0x80, 0x14, 0x18, 0xc1, 0x4b, 0xa1, 0x41, 0x1f, 0x4a, 0x2c, 0x25, 0x07, 0xbe, 0xee, + 0x7b, 0x68, 0x13, 0x72, 0xcc, 0xcc, 0x52, 0xea, 0x78, 0xce, 0x72, 0x0c, 0x7a, 0x0f, 0x2a, 0x63, + 0xfb, 0xb5, 0x35, 0xf2, 0xa8, 0x61, 0x5b, 0x63, 0x4f, 0x7a, 0xae, 0xcc, 0x60, 0x03, 0x01, 0xc2, + 0xdf, 0xe4, 0x60, 0x5d, 0xa4, 0xf4, 0x73, 0xaa, 0xbb, 0xfe, 0x11, 0xd5, 0xfd, 0x54, 0x51, 0xfb, + 0x9d, 0x5e, 0x35, 0xa8, 0x0d, 0xc0, 0x05, 0x67, 0x5a, 0x88, 0xa0, 0x09, 0x5a, 0xb7, 0x40, 0x7f, + 0x52, 0x62, 0x24, 0xec, 0xd1, 0x43, 0x1f, 0x41, 0xd5, 0xa1, 0xd6, 0xd8, 0xb4, 0x26, 0xf2, 0x95, + 0xbc, 0x74, 0x4d, 0x94, 0x79, 0x45, 0x92, 0x88, 0x57, 0xee, 0x43, 0xf5, 0x68, 0xe6, 0x53, 0x6f, + 0xf4, 0xda, 0x35, 0x7d, 0x9f, 0x5a, 0xcd, 0x02, 0x37, 0x4e, 0x85, 0x03, 0xbf, 0x10, 0x30, 0x76, + 0x47, 0x0b, 0x22, 0x97, 0xea, 0xe3, 0xe6, 0xb2, 0xe8, 0xd9, 0x39, 0x84, 0x50, 0x9d, 0xf5, 0xec, + 0x95, 0x53, 0x3a, 0x0b, 0x59, 0x14, 0x85, 0x7d, 0x19, 0x4c, 0x71, 0xb8, 0x05, 0x25, 0x4e, 0xc2, + 0x19, 0x94, 0x44, 0xe6, 0x30, 0x00, 0x7f, 0xff, 0x21, 0x34, 0x74, 0xc7, 0x71, 0xed, 0xdf, 0x9a, + 0x67, 0xba, 0x4f, 0x47, 0x9e, 0xf9, 0x35, 0x6d, 0x02, 0xa7, 0xa9, 0x47, 0xe0, 0x03, 0xf3, 0x6b, + 0x8a, 0xda, 0x50, 0x34, 0x2d, 0x9f, 0xba, 0x17, 0xfa, 0xb4, 0x59, 0xe1, 0x96, 0x43, 0x61, 0x2b, + 0xdb, 0x95, 0x18, 0x12, 0xd0, 0x24, 0x59, 0xb3, 0x23, 0x9b, 0xd5, 0x39, 0xd6, 0x2f, 0xe8, 0xcc, + 0xfb, 0x2c, 0x57, 0x2c, 0x37, 0x2a, 0xf8, 0x04, 0x60, 0xe7, 0x44, 0xb7, 0x26, 0x94, 0x99, 0xe7, + 0x0a, 0xb1, 0xf5, 0x14, 0xca, 0x06, 0xa7, 0x1f, 0xf1, 0x51, 0x24, 0xc3, 0x47, 0x91, 0x8d, 0xb6, + 0x9a, 0xa5, 0xd8, 0x6d, 0x24, 0xf8, 0xf1, 0x91, 0x04, 0x8c, 0xe0, 0x37, 0x7e, 0x02, 0xb5, 0xa1, + 0xab, 0x5b, 0xde, 0x31, 0x75, 0x45, 0x58, 0xbf, 0xfb, 0x34, 0xfc, 0x21, 0xe4, 0x0f, 0xa8, 0x3b, + 0xe1, 0xdd, 0xb3, 0xaf, 0xbb, 0x13, 0xea, 0x4b, 0xe2, 0xb9, 0x38, 0x13, 0x58, 0xfc, 0x14, 0xca, + 0x03, 0x67, 0x6a, 0xca, 0x72, 0x85, 0x1e, 0x42, 0xc1, 0xb1, 0xa7, 0xa6, 0x31, 0x93, 0x33, 0xd3, + 0x8a, 0x30, 0xde, 0xce, 0x09, 0x35, 0x4e, 0xfb, 0x1c, 0x41, 0x24, 0x01, 0xfe, 0x4b, 0x16, 0x36, + 0xe6, 0x32, 0x22, 0xd5, 0x55, 0xf1, 0x51, 0x60, 0x22, 0xae, 0x9d, 0x48, 0x8c, 0x86, 0x3a, 0x59, + 0xd9, 0x5a, 0xd9, 0x86, 0xdb, 0xfd, 0x63, 0xa8, 0xfb, 0xd2, 0x36, 0xa3, 0x58, 0x9e, 0xc8, 0x93, + 0xe2, 0x86, 0x23, 0x35, 0x3f, 0x6e, 0xc8, 0x58, 0x75, 0xcd, 0xc5, 0xab, 0x2b, 0xfa, 0x19, 0x54, + 0x24, 0x92, 0x3a, 0xb6, 0x71, 0xc2, 0xaf, 0x59, 0x96, 0xd5, 0x31, 0x03, 0xee, 0x31, 0x14, 0x29, + 0xbb, 0xe1, 0x03, 0xbb, 0xa3, 0x84, 0x51, 0x85, 0x1a, 0x85, 0x05, 0x4e, 0x02, 0x41, 0xd0, 0x17, + 0x97, 0x4e, 0xfe, 0x8c, 0xb9, 0x8a, 0xa7, 0x4b, 0x30, 0xc8, 0x72, 0xef, 0x11, 0x81, 0x41, 0x3f, + 0x85, 0x8a, 0xc7, 0x9c, 0x33, 0x92, 0x57, 0x46, 0x91, 0x53, 0x4a, 0x9f, 0x44, 0xdc, 0x46, 0xca, + 0x5e, 0xf8, 0x80, 0x8f, 0xa1, 0xde, 0xf1, 0x4e, 0x25, 0xfa, 0xfb, 0xbb, 0xa2, 0xf0, 0x37, 0x1a, + 0x34, 0xc2, 0x83, 0x52, 0x8e, 0x3a, 0x55, 0x8b, 0xbe, 0x1e, 0x25, 0x3b, 0x9d, 0xb2, 0x45, 0x5f, + 0x13, 0xe5, 0x8e, 0x4d, 0xa8, 0x30, 0x1a, 0x5e, 0x3a, 0xcd, 0xb1, 0xa8, 0x9c, 0x39, 0x02, 0x16, + 0x7d, 0xcd, 0xcc, 0xd8, 0x1d, 0x7b, 0xf8, 0x4f, 0x1a, 0x20, 0x42, 0x1d, 0xdb, 0xf5, 0xd3, 0x2b, + 0x8d, 0x21, 0x37, 0xa5, 0xc7, 0xfe, 0x25, 0x2a, 0x73, 0x1c, 0x7a, 0x00, 0x79, 0xd7, 0x9c, 0x9c, + 0xf8, 0x97, 0x0c, 0xa4, 0x02, 0x89, 0x77, 0xe0, 0x46, 0x4c, 0x98, 0x54, 0x7d, 0xc6, 0xb7, 0x1a, + 0xac, 0x76, 0xbc, 0xd3, 0x6d, 0xdd, 0x37, 0x4e, 0xbe, 0x77, 0x4f, 0xb2, 0xe6, 0x43, 0xc4, 0x99, + 0x58, 0x0e, 0x64, 0xf9, 0x72, 0x00, 0x38, 0x68, 0x87, 0x2f, 0x2e, 0x7a, 0xb0, 0xcc, 0xa5, 0xe8, + 0xee, 0xce, 0xbb, 0x4c, 0x7b, 0xb7, 0xcb, 0x32, 0x73, 0x2e, 0x3b, 0x86, 0xb5, 0x84, 0x7a, 0xa9, + 0xe2, 0xe7, 0x1e, 0x64, 0x15, 0x7f, 0x36, 0x80, 0x84, 0x79, 0xd1, 0xdd, 0x25, 0x0c, 0x83, 0x1d, + 0x76, 0x47, 0x31, 0x67, 0x5c, 0xd3, 0x92, 0x5b, 0xb0, 0x2c, 0x34, 0x56, 0x87, 0x25, 0x4d, 0xa9, + 0xd0, 0xac, 0xd7, 0x9c, 0x3f, 0x31, 0x55, 0x0c, 0xfc, 0x12, 0x2a, 0xd1, 0xa2, 0xc5, 0x3a, 0x40, + 0xcf, 0xd7, 0x5d, 0x7f, 0x14, 0x2e, 0x6b, 0x84, 0xed, 0x6b, 0x1c, 0x1c, 0x6e, 0x96, 0xee, 0x43, + 0x95, 0x5a, 0xe3, 0x08, 0x99, 0xc8, 0xaa, 0x0a, 0xb5, 0xc6, 0x01, 0x11, 0xfe, 0x5b, 0x0e, 0x80, + 0x4f, 0x6a, 0xa2, 0x49, 0x8a, 0x0e, 0xe0, 0x5a, 0x6c, 0x00, 0x47, 0x2d, 0x28, 0x1a, 0xba, 0xa3, + 0x1b, 0xac, 0xe5, 0x94, 0x3d, 0xad, 0x7a, 0x46, 0xb7, 0xa1, 0xa4, 0x5f, 0xe8, 0xe6, 0x54, 0x3f, + 0x9a, 0x52, 0x1e, 0x37, 0x39, 0x12, 0x02, 0x58, 0xdd, 0x97, 0x71, 0x22, 0x02, 0x2b, 0xc7, 0x03, + 0x4b, 0x5e, 0x9a, 0x3c, 0xb2, 0xd0, 0xfb, 0x80, 0x3c, 0xd9, 0x91, 0x78, 0x96, 0xee, 0x48, 0xc2, + 0x3c, 0x27, 0x6c, 0x48, 0xcc, 0xc0, 0xd2, 0x1d, 0x41, 0xfd, 0x18, 0x56, 0x5d, 0x6a, 0x50, 0xf3, + 0x22, 0x41, 0x5f, 0xe0, 0xf4, 0x28, 0xc0, 0x85, 0x6f, 0xdc, 0x01, 0x08, 0x8d, 0xc6, 0xaf, 0xda, + 0x2a, 0x29, 0x05, 0xf6, 0x42, 0x6d, 0xb8, 0xa1, 0x3b, 0xce, 0x74, 0x96, 0xe0, 0x57, 0xe4, 0x74, + 0x2b, 0x0a, 0x15, 0xb2, 0xdb, 0x80, 0x65, 0xd3, 0x1b, 0x1d, 0x9d, 0x7b, 0x33, 0xde, 0xa4, 0x14, + 0x49, 0xc1, 0xf4, 0xb6, 0xcf, 0xbd, 0x19, 0xab, 0x28, 0xe7, 0x1e, 0x1d, 0x47, 0x7b, 0x93, 0x22, + 0x03, 0xf0, 0xa6, 0x64, 0xae, 0x87, 0x2a, 0x2f, 0xe8, 0xa1, 0x92, 0x4d, 0x52, 0x65, 0xbe, 0x49, + 0x8a, 0xb7, 0x59, 0xd5, 0x64, 0x9b, 0x15, 0xeb, 0xa1, 0x6a, 0x89, 0x1e, 0x2a, 0xda, 0x18, 0xd5, + 0xdf, 0xdd, 0x18, 0xe1, 0x29, 0xac, 0xf1, 0xf0, 0xb8, 0x6e, 0xbb, 0x9b, 0xf7, 0x58, 0x7c, 0xc5, + 0x8b, 0x7a, 0x18, 0x77, 0x44, 0xa0, 0xf1, 0x33, 0x58, 0x4f, 0x9e, 0x96, 0x2a, 0x67, 0xfe, 0xa1, + 0xc1, 0xea, 0xc0, 0xd0, 0x7d, 0x36, 0xfe, 0xa5, 0x5f, 0x39, 0xbc, 0x6d, 0xf8, 0xbe, 0xea, 0x5e, + 0x32, 0xd2, 0xc1, 0xe7, 0xde, 0xb2, 0x2c, 0xd8, 0x83, 0xb5, 0x84, 0xbc, 0x69, 0x37, 0x98, 0xfb, + 0xd4, 0xdf, 0xdf, 0x19, 0xe8, 0xc7, 0xb4, 0x6f, 0x9b, 0x56, 0x2a, 0x6f, 0x61, 0x0a, 0xeb, 0x49, + 0x2e, 0xa9, 0xae, 0x65, 0x96, 0x74, 0xfa, 0x31, 0x1d, 0x39, 0x8c, 0x87, 0x34, 0x60, 0xc9, 0x53, + 0x4c, 0xf1, 0x31, 0x34, 0x5f, 0x39, 0x63, 0xdd, 0xa7, 0xd7, 0x94, 0xf7, 0x5d, 0xe7, 0xd8, 0x70, + 0x73, 0xc1, 0x39, 0xa9, 0x34, 0x7a, 0x00, 0x35, 0x56, 0xd1, 0xe6, 0x4e, 0x63, 0x75, 0x6e, 0x10, + 0x51, 0x6c, 0x65, 0x30, 0xb3, 0x8c, 0x6b, 0x44, 0xde, 0x03, 0x28, 0x88, 0xc1, 0x58, 0x26, 0x4c, + 0x62, 0x1a, 0x16, 0x38, 0x3c, 0x05, 0x14, 0x3d, 0x27, 0x95, 0x46, 0x57, 0xae, 0x68, 0x8f, 0x7e, + 0x07, 0xa5, 0xe0, 0x9b, 0x09, 0x2a, 0x40, 0xa6, 0xf7, 0xa2, 0xb1, 0x84, 0xca, 0xb0, 0xfc, 0xea, + 0xf0, 0xc5, 0x61, 0xef, 0x8b, 0xc3, 0x86, 0x86, 0x56, 0xa1, 0x71, 0xd8, 0x1b, 0x8e, 0xb6, 0x7b, + 0xbd, 0xe1, 0x60, 0x48, 0x3a, 0xfd, 0xfe, 0xde, 0x6e, 0x23, 0x83, 0x6e, 0x40, 0x7d, 0x30, 0xec, + 0x91, 0xbd, 0xd1, 0xb0, 0x77, 0xb0, 0x3d, 0x18, 0xf6, 0x0e, 0xf7, 0x1a, 0x59, 0xd4, 0x84, 0xd5, + 0xce, 0x4b, 0xb2, 0xd7, 0xd9, 0xfd, 0x32, 0x4e, 0x9e, 0x63, 0x98, 0xee, 0xe1, 0x4e, 0xef, 0xa0, + 0xdf, 0x19, 0x76, 0xb7, 0x5f, 0xee, 0x8d, 0x3e, 0xdf, 0x23, 0x83, 0x6e, 0xef, 0xb0, 0x91, 0x7f, + 0xb4, 0x05, 0xe5, 0xc8, 0x00, 0x82, 0x8a, 0x90, 0x1b, 0xec, 0x74, 0x0e, 0x1b, 0x4b, 0xa8, 0x0e, + 0xe5, 0x4e, 0xbf, 0x4f, 0x7a, 0xbf, 0xe8, 0x1e, 0x74, 0x86, 0x7b, 0x0d, 0xed, 0xc9, 0x1f, 0xaa, + 0x90, 0xe9, 0xef, 0xa2, 0x0e, 0x40, 0xb8, 0xbf, 0x40, 0x1b, 0xc2, 0x0e, 0x73, 0x4b, 0x91, 0x56, + 0x73, 0x1e, 0x21, 0x4c, 0x85, 0x97, 0xd0, 0x63, 0xc8, 0x0e, 0x3d, 0x1b, 0xc9, 0x0b, 0x2b, 0xfc, + 0x0c, 0xd4, 0x5a, 0x89, 0x40, 0x14, 0xf5, 0x96, 0xf6, 0x58, 0x43, 0x9f, 0x40, 0x29, 0x58, 0xfe, + 0xa3, 0x75, 0x41, 0x95, 0xfc, 0x4c, 0xd2, 0xda, 0x98, 0x83, 0x07, 0x27, 0x1e, 0x40, 0x2d, 0xfe, + 0xf9, 0x00, 0xdd, 0x12, 0xc4, 0x0b, 0x3f, 0x4d, 0xb4, 0x6e, 0x2f, 0x46, 0x06, 0xec, 0x9e, 0xc2, + 0xb2, 0x5c, 0xf1, 0x23, 0x19, 0x08, 0xf1, 0x0f, 0x06, 0xad, 0xb5, 0x04, 0x34, 0x78, 0xf3, 0xe7, + 0x50, 0x54, 0x0b, 0x77, 0xb4, 0x16, 0x98, 0x28, 0xba, 0x19, 0x6f, 0xad, 0x27, 0xc1, 0xd1, 0x97, + 0xd5, 0x86, 0x5b, 0xbd, 0x9c, 0x58, 0xab, 0xab, 0x97, 0x93, 0x8b, 0x70, 0xbc, 0x84, 0xf6, 0xa1, + 0x12, 0x5d, 0x4c, 0xa3, 0x9b, 0xc1, 0x31, 0xc9, 0x85, 0x77, 0xab, 0xb5, 0x08, 0x15, 0xb5, 0x65, + 0xbc, 0x9c, 0x28, 0x5b, 0x2e, 0x2c, 0x69, 0xca, 0x96, 0x8b, 0x2b, 0x10, 0x5e, 0x42, 0x43, 0xa8, + 0x27, 0x26, 0x5d, 0x74, 0x5b, 0x25, 0xd7, 0xa2, 0x95, 0x50, 0xeb, 0xce, 0x25, 0xd8, 0x64, 0xc0, + 0x04, 0x7b, 0x62, 0x14, 0x5a, 0x34, 0x76, 0x7b, 0xb4, 0x36, 0xe6, 0xe0, 0x81, 0x54, 0xdb, 0x50, + 0xdd, 0xa7, 0x7e, 0xdf, 0xa5, 0x17, 0xe9, 0x79, 0x3c, 0xe3, 0x3c, 0xc2, 0x5d, 0x35, 0x6a, 0x25, + 0x68, 0x23, 0x0b, 0xec, 0xb7, 0xf1, 0xf9, 0x04, 0x8a, 0x6a, 0x14, 0x54, 0x6e, 0x4f, 0xcc, 0xa0, + 0xca, 0xed, 0xc9, 0x89, 0x11, 0x67, 0xff, 0x98, 0xd1, 0xd0, 0x3e, 0x94, 0x23, 0x43, 0x13, 0x6a, + 0x2a, 0xfb, 0x25, 0x87, 0xba, 0xd6, 0xcd, 0x05, 0x98, 0x28, 0xa3, 0xcf, 0xa0, 0x1a, 0x1b, 0x2c, + 0x94, 0x42, 0x8b, 0x86, 0xa9, 0xd6, 0xad, 0x85, 0xb8, 0x40, 0xa9, 0x01, 0x34, 0x92, 0xad, 0x3c, + 0xba, 0x13, 0x3d, 0x7f, 0x9e, 0xe3, 0xdd, 0xcb, 0xd0, 0x51, 0xa6, 0xc9, 0x9d, 0xbb, 0x62, 0x7a, + 0xc9, 0x4e, 0x5f, 0x31, 0xbd, 0x6c, 0x55, 0x2f, 0x98, 0x26, 0x17, 0xdc, 0x8a, 0xe9, 0x25, 0xbb, + 0x76, 0xc5, 0xf4, 0xb2, 0xbd, 0x38, 0x5e, 0x62, 0xa6, 0x8c, 0xb5, 0x26, 0xca, 0x94, 0x8b, 0xfa, + 0x2b, 0x65, 0xca, 0x85, 0xbd, 0x8c, 0x48, 0xc8, 0x78, 0x67, 0xa1, 0x12, 0x72, 0x61, 0xd7, 0xa2, + 0x12, 0x72, 0x71, 0x33, 0x82, 0x97, 0xd0, 0xe7, 0xb0, 0x32, 0x57, 0xd9, 0x91, 0xd4, 0xe8, 0xb2, + 0xd6, 0xa2, 0x75, 0xef, 0x52, 0x7c, 0x24, 0x1d, 0xca, 0x61, 0x61, 0x0d, 0x2a, 0xc7, 0x5c, 0x4d, + 0x57, 0x95, 0x63, 0xbe, 0x08, 0x8b, 0xd4, 0xde, 0x7e, 0xf4, 0xaf, 0x37, 0x77, 0xb5, 0x7f, 0xbf, + 0xb9, 0xab, 0xfd, 0xe7, 0xcd, 0x5d, 0xed, 0xaf, 0xff, 0xbd, 0xbb, 0x04, 0x4d, 0xc3, 0x3e, 0x6b, + 0x3b, 0xa6, 0x35, 0x31, 0x74, 0xa7, 0xed, 0x9b, 0xa7, 0x17, 0xed, 0xd3, 0x0b, 0xfe, 0x1f, 0x13, + 0x47, 0x05, 0xfe, 0xe7, 0x27, 0xff, 0x0b, 0x00, 0x00, 0xff, 0xff, 0xe2, 0x03, 0x4f, 0xc1, 0x7f, + 0x21, 0x00, 0x00, } diff --git a/vendor/github.com/pingcap/kvproto/pkg/raft_serverpb/raft_serverpb.pb.go b/vendor/github.com/pingcap/kvproto/pkg/raft_serverpb/raft_serverpb.pb.go index 3f99653ca02a6..25a9f7d884369 100644 --- a/vendor/github.com/pingcap/kvproto/pkg/raft_serverpb/raft_serverpb.pb.go +++ b/vendor/github.com/pingcap/kvproto/pkg/raft_serverpb/raft_serverpb.pb.go @@ -1,28 +1,6 @@ -// Code generated by protoc-gen-gogo. +// Code generated by protoc-gen-gogo. DO NOT EDIT. // source: raft_serverpb.proto -// DO NOT EDIT! - -/* - Package raft_serverpb is a generated protocol buffer package. - - It is generated from these files: - raft_serverpb.proto - - It has these top-level messages: - RaftMessage - RaftTruncatedState - SnapshotCFFile - SnapshotMeta - SnapshotChunk - Done - KeyValue - RaftSnapshotData - StoreIdent - RaftLocalState - RaftApplyState - MergeState - RegionLocalState -*/ + package raft_serverpb import ( @@ -73,7 +51,9 @@ var PeerState_value = map[string]int32{ func (x PeerState) String() string { return proto.EnumName(PeerState_name, int32(x)) } -func (PeerState) EnumDescriptor() ([]byte, []int) { return fileDescriptorRaftServerpb, []int{0} } +func (PeerState) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_raft_serverpb_b9474b49325b3596, []int{0} +} type RaftMessage struct { RegionId uint64 `protobuf:"varint,1,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty"` @@ -87,13 +67,44 @@ type RaftMessage struct { StartKey []byte `protobuf:"bytes,7,opt,name=start_key,json=startKey,proto3" json:"start_key,omitempty"` EndKey []byte `protobuf:"bytes,8,opt,name=end_key,json=endKey,proto3" json:"end_key,omitempty"` // If it has value, to_peer should be removed if merge is never going to complete. - MergeTarget *metapb.Region `protobuf:"bytes,9,opt,name=merge_target,json=mergeTarget" json:"merge_target,omitempty"` + MergeTarget *metapb.Region `protobuf:"bytes,9,opt,name=merge_target,json=mergeTarget" json:"merge_target,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RaftMessage) Reset() { *m = RaftMessage{} } +func (m *RaftMessage) String() string { return proto.CompactTextString(m) } +func (*RaftMessage) ProtoMessage() {} +func (*RaftMessage) Descriptor() ([]byte, []int) { + return fileDescriptor_raft_serverpb_b9474b49325b3596, []int{0} +} +func (m *RaftMessage) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RaftMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RaftMessage.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 *RaftMessage) XXX_Merge(src proto.Message) { + xxx_messageInfo_RaftMessage.Merge(dst, src) +} +func (m *RaftMessage) XXX_Size() int { + return m.Size() +} +func (m *RaftMessage) XXX_DiscardUnknown() { + xxx_messageInfo_RaftMessage.DiscardUnknown(m) } -func (m *RaftMessage) Reset() { *m = RaftMessage{} } -func (m *RaftMessage) String() string { return proto.CompactTextString(m) } -func (*RaftMessage) ProtoMessage() {} -func (*RaftMessage) Descriptor() ([]byte, []int) { return fileDescriptorRaftServerpb, []int{0} } +var xxx_messageInfo_RaftMessage proto.InternalMessageInfo func (m *RaftMessage) GetRegionId() uint64 { if m != nil { @@ -159,14 +170,45 @@ func (m *RaftMessage) GetMergeTarget() *metapb.Region { } type RaftTruncatedState struct { - Index uint64 `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"` - Term uint64 `protobuf:"varint,2,opt,name=term,proto3" json:"term,omitempty"` + Index uint64 `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"` + Term uint64 `protobuf:"varint,2,opt,name=term,proto3" json:"term,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RaftTruncatedState) Reset() { *m = RaftTruncatedState{} } +func (m *RaftTruncatedState) String() string { return proto.CompactTextString(m) } +func (*RaftTruncatedState) ProtoMessage() {} +func (*RaftTruncatedState) Descriptor() ([]byte, []int) { + return fileDescriptor_raft_serverpb_b9474b49325b3596, []int{1} +} +func (m *RaftTruncatedState) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RaftTruncatedState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RaftTruncatedState.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 *RaftTruncatedState) XXX_Merge(src proto.Message) { + xxx_messageInfo_RaftTruncatedState.Merge(dst, src) +} +func (m *RaftTruncatedState) XXX_Size() int { + return m.Size() +} +func (m *RaftTruncatedState) XXX_DiscardUnknown() { + xxx_messageInfo_RaftTruncatedState.DiscardUnknown(m) } -func (m *RaftTruncatedState) Reset() { *m = RaftTruncatedState{} } -func (m *RaftTruncatedState) String() string { return proto.CompactTextString(m) } -func (*RaftTruncatedState) ProtoMessage() {} -func (*RaftTruncatedState) Descriptor() ([]byte, []int) { return fileDescriptorRaftServerpb, []int{1} } +var xxx_messageInfo_RaftTruncatedState proto.InternalMessageInfo func (m *RaftTruncatedState) GetIndex() uint64 { if m != nil { @@ -183,15 +225,46 @@ func (m *RaftTruncatedState) GetTerm() uint64 { } type SnapshotCFFile struct { - Cf string `protobuf:"bytes,1,opt,name=cf,proto3" json:"cf,omitempty"` - Size_ uint64 `protobuf:"varint,2,opt,name=size,proto3" json:"size,omitempty"` - Checksum uint32 `protobuf:"varint,3,opt,name=checksum,proto3" json:"checksum,omitempty"` + Cf string `protobuf:"bytes,1,opt,name=cf,proto3" json:"cf,omitempty"` + Size_ uint64 `protobuf:"varint,2,opt,name=size,proto3" json:"size,omitempty"` + Checksum uint32 `protobuf:"varint,3,opt,name=checksum,proto3" json:"checksum,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *SnapshotCFFile) Reset() { *m = SnapshotCFFile{} } +func (m *SnapshotCFFile) String() string { return proto.CompactTextString(m) } +func (*SnapshotCFFile) ProtoMessage() {} +func (*SnapshotCFFile) Descriptor() ([]byte, []int) { + return fileDescriptor_raft_serverpb_b9474b49325b3596, []int{2} +} +func (m *SnapshotCFFile) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SnapshotCFFile) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_SnapshotCFFile.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 *SnapshotCFFile) XXX_Merge(src proto.Message) { + xxx_messageInfo_SnapshotCFFile.Merge(dst, src) +} +func (m *SnapshotCFFile) XXX_Size() int { + return m.Size() +} +func (m *SnapshotCFFile) XXX_DiscardUnknown() { + xxx_messageInfo_SnapshotCFFile.DiscardUnknown(m) } -func (m *SnapshotCFFile) Reset() { *m = SnapshotCFFile{} } -func (m *SnapshotCFFile) String() string { return proto.CompactTextString(m) } -func (*SnapshotCFFile) ProtoMessage() {} -func (*SnapshotCFFile) Descriptor() ([]byte, []int) { return fileDescriptorRaftServerpb, []int{2} } +var xxx_messageInfo_SnapshotCFFile proto.InternalMessageInfo func (m *SnapshotCFFile) GetCf() string { if m != nil { @@ -215,13 +288,44 @@ func (m *SnapshotCFFile) GetChecksum() uint32 { } type SnapshotMeta struct { - CfFiles []*SnapshotCFFile `protobuf:"bytes,1,rep,name=cf_files,json=cfFiles" json:"cf_files,omitempty"` + CfFiles []*SnapshotCFFile `protobuf:"bytes,1,rep,name=cf_files,json=cfFiles" json:"cf_files,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *SnapshotMeta) Reset() { *m = SnapshotMeta{} } +func (m *SnapshotMeta) String() string { return proto.CompactTextString(m) } +func (*SnapshotMeta) ProtoMessage() {} +func (*SnapshotMeta) Descriptor() ([]byte, []int) { + return fileDescriptor_raft_serverpb_b9474b49325b3596, []int{3} +} +func (m *SnapshotMeta) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SnapshotMeta) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_SnapshotMeta.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 *SnapshotMeta) XXX_Merge(src proto.Message) { + xxx_messageInfo_SnapshotMeta.Merge(dst, src) +} +func (m *SnapshotMeta) XXX_Size() int { + return m.Size() +} +func (m *SnapshotMeta) XXX_DiscardUnknown() { + xxx_messageInfo_SnapshotMeta.DiscardUnknown(m) } -func (m *SnapshotMeta) Reset() { *m = SnapshotMeta{} } -func (m *SnapshotMeta) String() string { return proto.CompactTextString(m) } -func (*SnapshotMeta) ProtoMessage() {} -func (*SnapshotMeta) Descriptor() ([]byte, []int) { return fileDescriptorRaftServerpb, []int{3} } +var xxx_messageInfo_SnapshotMeta proto.InternalMessageInfo func (m *SnapshotMeta) GetCfFiles() []*SnapshotCFFile { if m != nil { @@ -231,14 +335,45 @@ func (m *SnapshotMeta) GetCfFiles() []*SnapshotCFFile { } type SnapshotChunk struct { - Message *RaftMessage `protobuf:"bytes,1,opt,name=message" json:"message,omitempty"` - Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"` + Message *RaftMessage `protobuf:"bytes,1,opt,name=message" json:"message,omitempty"` + Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *SnapshotChunk) Reset() { *m = SnapshotChunk{} } +func (m *SnapshotChunk) String() string { return proto.CompactTextString(m) } +func (*SnapshotChunk) ProtoMessage() {} +func (*SnapshotChunk) Descriptor() ([]byte, []int) { + return fileDescriptor_raft_serverpb_b9474b49325b3596, []int{4} +} +func (m *SnapshotChunk) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SnapshotChunk) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_SnapshotChunk.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 *SnapshotChunk) XXX_Merge(src proto.Message) { + xxx_messageInfo_SnapshotChunk.Merge(dst, src) +} +func (m *SnapshotChunk) XXX_Size() int { + return m.Size() +} +func (m *SnapshotChunk) XXX_DiscardUnknown() { + xxx_messageInfo_SnapshotChunk.DiscardUnknown(m) } -func (m *SnapshotChunk) Reset() { *m = SnapshotChunk{} } -func (m *SnapshotChunk) String() string { return proto.CompactTextString(m) } -func (*SnapshotChunk) ProtoMessage() {} -func (*SnapshotChunk) Descriptor() ([]byte, []int) { return fileDescriptorRaftServerpb, []int{4} } +var xxx_messageInfo_SnapshotChunk proto.InternalMessageInfo func (m *SnapshotChunk) GetMessage() *RaftMessage { if m != nil { @@ -255,22 +390,84 @@ func (m *SnapshotChunk) GetData() []byte { } type Done struct { + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *Done) Reset() { *m = Done{} } +func (m *Done) String() string { return proto.CompactTextString(m) } +func (*Done) ProtoMessage() {} +func (*Done) Descriptor() ([]byte, []int) { + return fileDescriptor_raft_serverpb_b9474b49325b3596, []int{5} +} +func (m *Done) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Done) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Done.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 *Done) XXX_Merge(src proto.Message) { + xxx_messageInfo_Done.Merge(dst, src) +} +func (m *Done) XXX_Size() int { + return m.Size() +} +func (m *Done) XXX_DiscardUnknown() { + xxx_messageInfo_Done.DiscardUnknown(m) } -func (m *Done) Reset() { *m = Done{} } -func (m *Done) String() string { return proto.CompactTextString(m) } -func (*Done) ProtoMessage() {} -func (*Done) Descriptor() ([]byte, []int) { return fileDescriptorRaftServerpb, []int{5} } +var xxx_messageInfo_Done proto.InternalMessageInfo type KeyValue struct { - Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` - Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` + Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *KeyValue) Reset() { *m = KeyValue{} } +func (m *KeyValue) String() string { return proto.CompactTextString(m) } +func (*KeyValue) ProtoMessage() {} +func (*KeyValue) Descriptor() ([]byte, []int) { + return fileDescriptor_raft_serverpb_b9474b49325b3596, []int{6} +} +func (m *KeyValue) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *KeyValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_KeyValue.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 *KeyValue) XXX_Merge(src proto.Message) { + xxx_messageInfo_KeyValue.Merge(dst, src) +} +func (m *KeyValue) XXX_Size() int { + return m.Size() +} +func (m *KeyValue) XXX_DiscardUnknown() { + xxx_messageInfo_KeyValue.DiscardUnknown(m) } -func (m *KeyValue) Reset() { *m = KeyValue{} } -func (m *KeyValue) String() string { return proto.CompactTextString(m) } -func (*KeyValue) ProtoMessage() {} -func (*KeyValue) Descriptor() ([]byte, []int) { return fileDescriptorRaftServerpb, []int{6} } +var xxx_messageInfo_KeyValue proto.InternalMessageInfo func (m *KeyValue) GetKey() []byte { if m != nil { @@ -287,17 +484,48 @@ func (m *KeyValue) GetValue() []byte { } type RaftSnapshotData struct { - Region *metapb.Region `protobuf:"bytes,1,opt,name=region" json:"region,omitempty"` - FileSize uint64 `protobuf:"varint,2,opt,name=file_size,json=fileSize,proto3" json:"file_size,omitempty"` - Data []*KeyValue `protobuf:"bytes,3,rep,name=data" json:"data,omitempty"` - Version uint64 `protobuf:"varint,4,opt,name=version,proto3" json:"version,omitempty"` - Meta *SnapshotMeta `protobuf:"bytes,5,opt,name=meta" json:"meta,omitempty"` + Region *metapb.Region `protobuf:"bytes,1,opt,name=region" json:"region,omitempty"` + FileSize uint64 `protobuf:"varint,2,opt,name=file_size,json=fileSize,proto3" json:"file_size,omitempty"` + Data []*KeyValue `protobuf:"bytes,3,rep,name=data" json:"data,omitempty"` + Version uint64 `protobuf:"varint,4,opt,name=version,proto3" json:"version,omitempty"` + Meta *SnapshotMeta `protobuf:"bytes,5,opt,name=meta" json:"meta,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RaftSnapshotData) Reset() { *m = RaftSnapshotData{} } +func (m *RaftSnapshotData) String() string { return proto.CompactTextString(m) } +func (*RaftSnapshotData) ProtoMessage() {} +func (*RaftSnapshotData) Descriptor() ([]byte, []int) { + return fileDescriptor_raft_serverpb_b9474b49325b3596, []int{7} +} +func (m *RaftSnapshotData) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RaftSnapshotData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RaftSnapshotData.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 *RaftSnapshotData) XXX_Merge(src proto.Message) { + xxx_messageInfo_RaftSnapshotData.Merge(dst, src) +} +func (m *RaftSnapshotData) XXX_Size() int { + return m.Size() +} +func (m *RaftSnapshotData) XXX_DiscardUnknown() { + xxx_messageInfo_RaftSnapshotData.DiscardUnknown(m) } -func (m *RaftSnapshotData) Reset() { *m = RaftSnapshotData{} } -func (m *RaftSnapshotData) String() string { return proto.CompactTextString(m) } -func (*RaftSnapshotData) ProtoMessage() {} -func (*RaftSnapshotData) Descriptor() ([]byte, []int) { return fileDescriptorRaftServerpb, []int{7} } +var xxx_messageInfo_RaftSnapshotData proto.InternalMessageInfo func (m *RaftSnapshotData) GetRegion() *metapb.Region { if m != nil { @@ -335,14 +563,45 @@ func (m *RaftSnapshotData) GetMeta() *SnapshotMeta { } type StoreIdent struct { - ClusterId uint64 `protobuf:"varint,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"` - StoreId uint64 `protobuf:"varint,2,opt,name=store_id,json=storeId,proto3" json:"store_id,omitempty"` + ClusterId uint64 `protobuf:"varint,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"` + StoreId uint64 `protobuf:"varint,2,opt,name=store_id,json=storeId,proto3" json:"store_id,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *StoreIdent) Reset() { *m = StoreIdent{} } +func (m *StoreIdent) String() string { return proto.CompactTextString(m) } +func (*StoreIdent) ProtoMessage() {} +func (*StoreIdent) Descriptor() ([]byte, []int) { + return fileDescriptor_raft_serverpb_b9474b49325b3596, []int{8} +} +func (m *StoreIdent) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *StoreIdent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_StoreIdent.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 *StoreIdent) XXX_Merge(src proto.Message) { + xxx_messageInfo_StoreIdent.Merge(dst, src) +} +func (m *StoreIdent) XXX_Size() int { + return m.Size() +} +func (m *StoreIdent) XXX_DiscardUnknown() { + xxx_messageInfo_StoreIdent.DiscardUnknown(m) } -func (m *StoreIdent) Reset() { *m = StoreIdent{} } -func (m *StoreIdent) String() string { return proto.CompactTextString(m) } -func (*StoreIdent) ProtoMessage() {} -func (*StoreIdent) Descriptor() ([]byte, []int) { return fileDescriptorRaftServerpb, []int{8} } +var xxx_messageInfo_StoreIdent proto.InternalMessageInfo func (m *StoreIdent) GetClusterId() uint64 { if m != nil { @@ -359,14 +618,45 @@ func (m *StoreIdent) GetStoreId() uint64 { } type RaftLocalState struct { - HardState *eraftpb.HardState `protobuf:"bytes,1,opt,name=hard_state,json=hardState" json:"hard_state,omitempty"` - LastIndex uint64 `protobuf:"varint,2,opt,name=last_index,json=lastIndex,proto3" json:"last_index,omitempty"` + HardState *eraftpb.HardState `protobuf:"bytes,1,opt,name=hard_state,json=hardState" json:"hard_state,omitempty"` + LastIndex uint64 `protobuf:"varint,2,opt,name=last_index,json=lastIndex,proto3" json:"last_index,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RaftLocalState) Reset() { *m = RaftLocalState{} } +func (m *RaftLocalState) String() string { return proto.CompactTextString(m) } +func (*RaftLocalState) ProtoMessage() {} +func (*RaftLocalState) Descriptor() ([]byte, []int) { + return fileDescriptor_raft_serverpb_b9474b49325b3596, []int{9} +} +func (m *RaftLocalState) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RaftLocalState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RaftLocalState.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 *RaftLocalState) XXX_Merge(src proto.Message) { + xxx_messageInfo_RaftLocalState.Merge(dst, src) +} +func (m *RaftLocalState) XXX_Size() int { + return m.Size() +} +func (m *RaftLocalState) XXX_DiscardUnknown() { + xxx_messageInfo_RaftLocalState.DiscardUnknown(m) } -func (m *RaftLocalState) Reset() { *m = RaftLocalState{} } -func (m *RaftLocalState) String() string { return proto.CompactTextString(m) } -func (*RaftLocalState) ProtoMessage() {} -func (*RaftLocalState) Descriptor() ([]byte, []int) { return fileDescriptorRaftServerpb, []int{9} } +var xxx_messageInfo_RaftLocalState proto.InternalMessageInfo func (m *RaftLocalState) GetHardState() *eraftpb.HardState { if m != nil { @@ -383,14 +673,45 @@ func (m *RaftLocalState) GetLastIndex() uint64 { } type RaftApplyState struct { - AppliedIndex uint64 `protobuf:"varint,1,opt,name=applied_index,json=appliedIndex,proto3" json:"applied_index,omitempty"` - TruncatedState *RaftTruncatedState `protobuf:"bytes,2,opt,name=truncated_state,json=truncatedState" json:"truncated_state,omitempty"` + AppliedIndex uint64 `protobuf:"varint,1,opt,name=applied_index,json=appliedIndex,proto3" json:"applied_index,omitempty"` + TruncatedState *RaftTruncatedState `protobuf:"bytes,2,opt,name=truncated_state,json=truncatedState" json:"truncated_state,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RaftApplyState) Reset() { *m = RaftApplyState{} } +func (m *RaftApplyState) String() string { return proto.CompactTextString(m) } +func (*RaftApplyState) ProtoMessage() {} +func (*RaftApplyState) Descriptor() ([]byte, []int) { + return fileDescriptor_raft_serverpb_b9474b49325b3596, []int{10} +} +func (m *RaftApplyState) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RaftApplyState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RaftApplyState.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 *RaftApplyState) XXX_Merge(src proto.Message) { + xxx_messageInfo_RaftApplyState.Merge(dst, src) +} +func (m *RaftApplyState) XXX_Size() int { + return m.Size() +} +func (m *RaftApplyState) XXX_DiscardUnknown() { + xxx_messageInfo_RaftApplyState.DiscardUnknown(m) } -func (m *RaftApplyState) Reset() { *m = RaftApplyState{} } -func (m *RaftApplyState) String() string { return proto.CompactTextString(m) } -func (*RaftApplyState) ProtoMessage() {} -func (*RaftApplyState) Descriptor() ([]byte, []int) { return fileDescriptorRaftServerpb, []int{10} } +var xxx_messageInfo_RaftApplyState proto.InternalMessageInfo func (m *RaftApplyState) GetAppliedIndex() uint64 { if m != nil { @@ -407,15 +728,46 @@ func (m *RaftApplyState) GetTruncatedState() *RaftTruncatedState { } type MergeState struct { - MinIndex uint64 `protobuf:"varint,1,opt,name=min_index,json=minIndex,proto3" json:"min_index,omitempty"` - Target *metapb.Region `protobuf:"bytes,2,opt,name=target" json:"target,omitempty"` - Commit uint64 `protobuf:"varint,3,opt,name=commit,proto3" json:"commit,omitempty"` + MinIndex uint64 `protobuf:"varint,1,opt,name=min_index,json=minIndex,proto3" json:"min_index,omitempty"` + Target *metapb.Region `protobuf:"bytes,2,opt,name=target" json:"target,omitempty"` + Commit uint64 `protobuf:"varint,3,opt,name=commit,proto3" json:"commit,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *MergeState) Reset() { *m = MergeState{} } +func (m *MergeState) String() string { return proto.CompactTextString(m) } +func (*MergeState) ProtoMessage() {} +func (*MergeState) Descriptor() ([]byte, []int) { + return fileDescriptor_raft_serverpb_b9474b49325b3596, []int{11} +} +func (m *MergeState) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MergeState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MergeState.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 *MergeState) XXX_Merge(src proto.Message) { + xxx_messageInfo_MergeState.Merge(dst, src) +} +func (m *MergeState) XXX_Size() int { + return m.Size() +} +func (m *MergeState) XXX_DiscardUnknown() { + xxx_messageInfo_MergeState.DiscardUnknown(m) } -func (m *MergeState) Reset() { *m = MergeState{} } -func (m *MergeState) String() string { return proto.CompactTextString(m) } -func (*MergeState) ProtoMessage() {} -func (*MergeState) Descriptor() ([]byte, []int) { return fileDescriptorRaftServerpb, []int{11} } +var xxx_messageInfo_MergeState proto.InternalMessageInfo func (m *MergeState) GetMinIndex() uint64 { if m != nil { @@ -439,15 +791,46 @@ func (m *MergeState) GetCommit() uint64 { } type RegionLocalState struct { - State PeerState `protobuf:"varint,1,opt,name=state,proto3,enum=raft_serverpb.PeerState" json:"state,omitempty"` - Region *metapb.Region `protobuf:"bytes,2,opt,name=region" json:"region,omitempty"` - MergeState *MergeState `protobuf:"bytes,3,opt,name=merge_state,json=mergeState" json:"merge_state,omitempty"` + State PeerState `protobuf:"varint,1,opt,name=state,proto3,enum=raft_serverpb.PeerState" json:"state,omitempty"` + Region *metapb.Region `protobuf:"bytes,2,opt,name=region" json:"region,omitempty"` + MergeState *MergeState `protobuf:"bytes,3,opt,name=merge_state,json=mergeState" json:"merge_state,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RegionLocalState) Reset() { *m = RegionLocalState{} } +func (m *RegionLocalState) String() string { return proto.CompactTextString(m) } +func (*RegionLocalState) ProtoMessage() {} +func (*RegionLocalState) Descriptor() ([]byte, []int) { + return fileDescriptor_raft_serverpb_b9474b49325b3596, []int{12} +} +func (m *RegionLocalState) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RegionLocalState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RegionLocalState.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 *RegionLocalState) XXX_Merge(src proto.Message) { + xxx_messageInfo_RegionLocalState.Merge(dst, src) +} +func (m *RegionLocalState) XXX_Size() int { + return m.Size() +} +func (m *RegionLocalState) XXX_DiscardUnknown() { + xxx_messageInfo_RegionLocalState.DiscardUnknown(m) } -func (m *RegionLocalState) Reset() { *m = RegionLocalState{} } -func (m *RegionLocalState) String() string { return proto.CompactTextString(m) } -func (*RegionLocalState) ProtoMessage() {} -func (*RegionLocalState) Descriptor() ([]byte, []int) { return fileDescriptorRaftServerpb, []int{12} } +var xxx_messageInfo_RegionLocalState proto.InternalMessageInfo func (m *RegionLocalState) GetState() PeerState { if m != nil { @@ -578,6 +961,9 @@ func (m *RaftMessage) MarshalTo(dAtA []byte) (int, error) { } i += n5 } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -606,6 +992,9 @@ func (m *RaftTruncatedState) MarshalTo(dAtA []byte) (int, error) { i++ i = encodeVarintRaftServerpb(dAtA, i, uint64(m.Term)) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -640,6 +1029,9 @@ func (m *SnapshotCFFile) MarshalTo(dAtA []byte) (int, error) { i++ i = encodeVarintRaftServerpb(dAtA, i, uint64(m.Checksum)) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -670,6 +1062,9 @@ func (m *SnapshotMeta) MarshalTo(dAtA []byte) (int, error) { i += n } } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -704,6 +1099,9 @@ func (m *SnapshotChunk) MarshalTo(dAtA []byte) (int, error) { i = encodeVarintRaftServerpb(dAtA, i, uint64(len(m.Data))) i += copy(dAtA[i:], m.Data) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -722,6 +1120,9 @@ func (m *Done) MarshalTo(dAtA []byte) (int, error) { _ = i var l int _ = l + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -752,6 +1153,9 @@ func (m *KeyValue) MarshalTo(dAtA []byte) (int, error) { i = encodeVarintRaftServerpb(dAtA, i, uint64(len(m.Value))) i += copy(dAtA[i:], m.Value) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -812,6 +1216,9 @@ func (m *RaftSnapshotData) MarshalTo(dAtA []byte) (int, error) { } i += n8 } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -840,6 +1247,9 @@ func (m *StoreIdent) MarshalTo(dAtA []byte) (int, error) { i++ i = encodeVarintRaftServerpb(dAtA, i, uint64(m.StoreId)) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -873,6 +1283,9 @@ func (m *RaftLocalState) MarshalTo(dAtA []byte) (int, error) { i++ i = encodeVarintRaftServerpb(dAtA, i, uint64(m.LastIndex)) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -906,6 +1319,9 @@ func (m *RaftApplyState) MarshalTo(dAtA []byte) (int, error) { } i += n10 } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -944,6 +1360,9 @@ func (m *MergeState) MarshalTo(dAtA []byte) (int, error) { i++ i = encodeVarintRaftServerpb(dAtA, i, uint64(m.Commit)) } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } @@ -987,27 +1406,12 @@ func (m *RegionLocalState) MarshalTo(dAtA []byte) (int, error) { } i += n13 } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } return i, nil } -func encodeFixed64RaftServerpb(dAtA []byte, offset int, v uint64) int { - dAtA[offset] = uint8(v) - dAtA[offset+1] = uint8(v >> 8) - dAtA[offset+2] = uint8(v >> 16) - dAtA[offset+3] = uint8(v >> 24) - dAtA[offset+4] = uint8(v >> 32) - dAtA[offset+5] = uint8(v >> 40) - dAtA[offset+6] = uint8(v >> 48) - dAtA[offset+7] = uint8(v >> 56) - return offset + 8 -} -func encodeFixed32RaftServerpb(dAtA []byte, offset int, v uint32) int { - dAtA[offset] = uint8(v) - dAtA[offset+1] = uint8(v >> 8) - dAtA[offset+2] = uint8(v >> 16) - dAtA[offset+3] = uint8(v >> 24) - return offset + 4 -} func encodeVarintRaftServerpb(dAtA []byte, offset int, v uint64) int { for v >= 1<<7 { dAtA[offset] = uint8(v&0x7f | 0x80) @@ -1054,6 +1458,9 @@ func (m *RaftMessage) Size() (n int) { l = m.MergeTarget.Size() n += 1 + l + sovRaftServerpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -1066,6 +1473,9 @@ func (m *RaftTruncatedState) Size() (n int) { if m.Term != 0 { n += 1 + sovRaftServerpb(uint64(m.Term)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -1082,6 +1492,9 @@ func (m *SnapshotCFFile) Size() (n int) { if m.Checksum != 0 { n += 1 + sovRaftServerpb(uint64(m.Checksum)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -1094,6 +1507,9 @@ func (m *SnapshotMeta) Size() (n int) { n += 1 + l + sovRaftServerpb(uint64(l)) } } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -1108,12 +1524,18 @@ func (m *SnapshotChunk) Size() (n int) { if l > 0 { n += 1 + l + sovRaftServerpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } func (m *Done) Size() (n int) { var l int _ = l + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -1128,6 +1550,9 @@ func (m *KeyValue) Size() (n int) { if l > 0 { n += 1 + l + sovRaftServerpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -1154,6 +1579,9 @@ func (m *RaftSnapshotData) Size() (n int) { l = m.Meta.Size() n += 1 + l + sovRaftServerpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -1166,6 +1594,9 @@ func (m *StoreIdent) Size() (n int) { if m.StoreId != 0 { n += 1 + sovRaftServerpb(uint64(m.StoreId)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -1179,6 +1610,9 @@ func (m *RaftLocalState) Size() (n int) { if m.LastIndex != 0 { n += 1 + sovRaftServerpb(uint64(m.LastIndex)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -1192,6 +1626,9 @@ func (m *RaftApplyState) Size() (n int) { l = m.TruncatedState.Size() n += 1 + l + sovRaftServerpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -1208,6 +1645,9 @@ func (m *MergeState) Size() (n int) { if m.Commit != 0 { n += 1 + sovRaftServerpb(uint64(m.Commit)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -1225,6 +1665,9 @@ func (m *RegionLocalState) Size() (n int) { l = m.MergeState.Size() n += 1 + l + sovRaftServerpb(uint64(l)) } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } return n } @@ -1548,6 +1991,7 @@ func (m *RaftMessage) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -1636,6 +2080,7 @@ func (m *RaftTruncatedState) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -1753,6 +2198,7 @@ func (m *SnapshotCFFile) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -1834,6 +2280,7 @@ func (m *SnapshotMeta) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -1948,6 +2395,7 @@ func (m *SnapshotChunk) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -1998,6 +2446,7 @@ func (m *Done) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -2110,6 +2559,7 @@ func (m *KeyValue) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -2295,6 +2745,7 @@ func (m *RaftSnapshotData) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -2383,6 +2834,7 @@ func (m *StoreIdent) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -2485,6 +2937,7 @@ func (m *RaftLocalState) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -2587,6 +3040,7 @@ func (m *RaftApplyState) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -2708,6 +3162,7 @@ func (m *MergeState) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -2843,6 +3298,7 @@ func (m *RegionLocalState) Unmarshal(dAtA []byte) error { if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) iNdEx += skippy } } @@ -2957,9 +3413,9 @@ var ( ErrIntOverflowRaftServerpb = fmt.Errorf("proto: integer overflow") ) -func init() { proto.RegisterFile("raft_serverpb.proto", fileDescriptorRaftServerpb) } +func init() { proto.RegisterFile("raft_serverpb.proto", fileDescriptor_raft_serverpb_b9474b49325b3596) } -var fileDescriptorRaftServerpb = []byte{ +var fileDescriptor_raft_serverpb_b9474b49325b3596 = []byte{ // 866 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x55, 0xdd, 0x6e, 0xe3, 0x44, 0x14, 0x5e, 0x27, 0xae, 0x63, 0x9f, 0x38, 0x21, 0x9a, 0x45, 0xac, 0xb7, 0xd5, 0x56, 0x59, 0x23, diff --git a/vendor/github.com/pingcap/kvproto/pkg/tikvpb/tikvpb.pb.go b/vendor/github.com/pingcap/kvproto/pkg/tikvpb/tikvpb.pb.go index 10b706d08041f..3f2f8be7862cf 100644 --- a/vendor/github.com/pingcap/kvproto/pkg/tikvpb/tikvpb.pb.go +++ b/vendor/github.com/pingcap/kvproto/pkg/tikvpb/tikvpb.pb.go @@ -1,15 +1,6 @@ -// Code generated by protoc-gen-gogo. +// Code generated by protoc-gen-gogo. DO NOT EDIT. // source: tikvpb.proto -// DO NOT EDIT! -/* - Package tikvpb is a generated protocol buffer package. - - It is generated from these files: - tikvpb.proto - - It has these top-level messages: -*/ package tikvpb import ( @@ -18,6 +9,8 @@ import ( proto "github.com/golang/protobuf/proto" + _ "github.com/gogo/protobuf/gogoproto" + coprocessor "github.com/pingcap/kvproto/pkg/coprocessor" kvrpcpb "github.com/pingcap/kvproto/pkg/kvrpcpb" @@ -99,7 +92,7 @@ func NewTikvClient(cc *grpc.ClientConn) TikvClient { func (c *tikvClient) KvGet(ctx context.Context, in *kvrpcpb.GetRequest, opts ...grpc.CallOption) (*kvrpcpb.GetResponse, error) { out := new(kvrpcpb.GetResponse) - err := grpc.Invoke(ctx, "/tikvpb.Tikv/KvGet", in, out, c.cc, opts...) + err := c.cc.Invoke(ctx, "/tikvpb.Tikv/KvGet", in, out, opts...) if err != nil { return nil, err } @@ -108,7 +101,7 @@ func (c *tikvClient) KvGet(ctx context.Context, in *kvrpcpb.GetRequest, opts ... func (c *tikvClient) KvScan(ctx context.Context, in *kvrpcpb.ScanRequest, opts ...grpc.CallOption) (*kvrpcpb.ScanResponse, error) { out := new(kvrpcpb.ScanResponse) - err := grpc.Invoke(ctx, "/tikvpb.Tikv/KvScan", in, out, c.cc, opts...) + err := c.cc.Invoke(ctx, "/tikvpb.Tikv/KvScan", in, out, opts...) if err != nil { return nil, err } @@ -117,7 +110,7 @@ func (c *tikvClient) KvScan(ctx context.Context, in *kvrpcpb.ScanRequest, opts . func (c *tikvClient) KvPrewrite(ctx context.Context, in *kvrpcpb.PrewriteRequest, opts ...grpc.CallOption) (*kvrpcpb.PrewriteResponse, error) { out := new(kvrpcpb.PrewriteResponse) - err := grpc.Invoke(ctx, "/tikvpb.Tikv/KvPrewrite", in, out, c.cc, opts...) + err := c.cc.Invoke(ctx, "/tikvpb.Tikv/KvPrewrite", in, out, opts...) if err != nil { return nil, err } @@ -126,7 +119,7 @@ func (c *tikvClient) KvPrewrite(ctx context.Context, in *kvrpcpb.PrewriteRequest func (c *tikvClient) KvCommit(ctx context.Context, in *kvrpcpb.CommitRequest, opts ...grpc.CallOption) (*kvrpcpb.CommitResponse, error) { out := new(kvrpcpb.CommitResponse) - err := grpc.Invoke(ctx, "/tikvpb.Tikv/KvCommit", in, out, c.cc, opts...) + err := c.cc.Invoke(ctx, "/tikvpb.Tikv/KvCommit", in, out, opts...) if err != nil { return nil, err } @@ -135,7 +128,7 @@ func (c *tikvClient) KvCommit(ctx context.Context, in *kvrpcpb.CommitRequest, op func (c *tikvClient) KvImport(ctx context.Context, in *kvrpcpb.ImportRequest, opts ...grpc.CallOption) (*kvrpcpb.ImportResponse, error) { out := new(kvrpcpb.ImportResponse) - err := grpc.Invoke(ctx, "/tikvpb.Tikv/KvImport", in, out, c.cc, opts...) + err := c.cc.Invoke(ctx, "/tikvpb.Tikv/KvImport", in, out, opts...) if err != nil { return nil, err } @@ -144,7 +137,7 @@ func (c *tikvClient) KvImport(ctx context.Context, in *kvrpcpb.ImportRequest, op func (c *tikvClient) KvCleanup(ctx context.Context, in *kvrpcpb.CleanupRequest, opts ...grpc.CallOption) (*kvrpcpb.CleanupResponse, error) { out := new(kvrpcpb.CleanupResponse) - err := grpc.Invoke(ctx, "/tikvpb.Tikv/KvCleanup", in, out, c.cc, opts...) + err := c.cc.Invoke(ctx, "/tikvpb.Tikv/KvCleanup", in, out, opts...) if err != nil { return nil, err } @@ -153,7 +146,7 @@ func (c *tikvClient) KvCleanup(ctx context.Context, in *kvrpcpb.CleanupRequest, func (c *tikvClient) KvBatchGet(ctx context.Context, in *kvrpcpb.BatchGetRequest, opts ...grpc.CallOption) (*kvrpcpb.BatchGetResponse, error) { out := new(kvrpcpb.BatchGetResponse) - err := grpc.Invoke(ctx, "/tikvpb.Tikv/KvBatchGet", in, out, c.cc, opts...) + err := c.cc.Invoke(ctx, "/tikvpb.Tikv/KvBatchGet", in, out, opts...) if err != nil { return nil, err } @@ -162,7 +155,7 @@ func (c *tikvClient) KvBatchGet(ctx context.Context, in *kvrpcpb.BatchGetRequest func (c *tikvClient) KvBatchRollback(ctx context.Context, in *kvrpcpb.BatchRollbackRequest, opts ...grpc.CallOption) (*kvrpcpb.BatchRollbackResponse, error) { out := new(kvrpcpb.BatchRollbackResponse) - err := grpc.Invoke(ctx, "/tikvpb.Tikv/KvBatchRollback", in, out, c.cc, opts...) + err := c.cc.Invoke(ctx, "/tikvpb.Tikv/KvBatchRollback", in, out, opts...) if err != nil { return nil, err } @@ -171,7 +164,7 @@ func (c *tikvClient) KvBatchRollback(ctx context.Context, in *kvrpcpb.BatchRollb func (c *tikvClient) KvScanLock(ctx context.Context, in *kvrpcpb.ScanLockRequest, opts ...grpc.CallOption) (*kvrpcpb.ScanLockResponse, error) { out := new(kvrpcpb.ScanLockResponse) - err := grpc.Invoke(ctx, "/tikvpb.Tikv/KvScanLock", in, out, c.cc, opts...) + err := c.cc.Invoke(ctx, "/tikvpb.Tikv/KvScanLock", in, out, opts...) if err != nil { return nil, err } @@ -180,7 +173,7 @@ func (c *tikvClient) KvScanLock(ctx context.Context, in *kvrpcpb.ScanLockRequest func (c *tikvClient) KvResolveLock(ctx context.Context, in *kvrpcpb.ResolveLockRequest, opts ...grpc.CallOption) (*kvrpcpb.ResolveLockResponse, error) { out := new(kvrpcpb.ResolveLockResponse) - err := grpc.Invoke(ctx, "/tikvpb.Tikv/KvResolveLock", in, out, c.cc, opts...) + err := c.cc.Invoke(ctx, "/tikvpb.Tikv/KvResolveLock", in, out, opts...) if err != nil { return nil, err } @@ -189,7 +182,7 @@ func (c *tikvClient) KvResolveLock(ctx context.Context, in *kvrpcpb.ResolveLockR func (c *tikvClient) KvGC(ctx context.Context, in *kvrpcpb.GCRequest, opts ...grpc.CallOption) (*kvrpcpb.GCResponse, error) { out := new(kvrpcpb.GCResponse) - err := grpc.Invoke(ctx, "/tikvpb.Tikv/KvGC", in, out, c.cc, opts...) + err := c.cc.Invoke(ctx, "/tikvpb.Tikv/KvGC", in, out, opts...) if err != nil { return nil, err } @@ -198,7 +191,7 @@ func (c *tikvClient) KvGC(ctx context.Context, in *kvrpcpb.GCRequest, opts ...gr func (c *tikvClient) KvDeleteRange(ctx context.Context, in *kvrpcpb.DeleteRangeRequest, opts ...grpc.CallOption) (*kvrpcpb.DeleteRangeResponse, error) { out := new(kvrpcpb.DeleteRangeResponse) - err := grpc.Invoke(ctx, "/tikvpb.Tikv/KvDeleteRange", in, out, c.cc, opts...) + err := c.cc.Invoke(ctx, "/tikvpb.Tikv/KvDeleteRange", in, out, opts...) if err != nil { return nil, err } @@ -207,7 +200,7 @@ func (c *tikvClient) KvDeleteRange(ctx context.Context, in *kvrpcpb.DeleteRangeR func (c *tikvClient) RawGet(ctx context.Context, in *kvrpcpb.RawGetRequest, opts ...grpc.CallOption) (*kvrpcpb.RawGetResponse, error) { out := new(kvrpcpb.RawGetResponse) - err := grpc.Invoke(ctx, "/tikvpb.Tikv/RawGet", in, out, c.cc, opts...) + err := c.cc.Invoke(ctx, "/tikvpb.Tikv/RawGet", in, out, opts...) if err != nil { return nil, err } @@ -216,7 +209,7 @@ func (c *tikvClient) RawGet(ctx context.Context, in *kvrpcpb.RawGetRequest, opts func (c *tikvClient) RawBatchGet(ctx context.Context, in *kvrpcpb.RawBatchGetRequest, opts ...grpc.CallOption) (*kvrpcpb.RawBatchGetResponse, error) { out := new(kvrpcpb.RawBatchGetResponse) - err := grpc.Invoke(ctx, "/tikvpb.Tikv/RawBatchGet", in, out, c.cc, opts...) + err := c.cc.Invoke(ctx, "/tikvpb.Tikv/RawBatchGet", in, out, opts...) if err != nil { return nil, err } @@ -225,7 +218,7 @@ func (c *tikvClient) RawBatchGet(ctx context.Context, in *kvrpcpb.RawBatchGetReq func (c *tikvClient) RawPut(ctx context.Context, in *kvrpcpb.RawPutRequest, opts ...grpc.CallOption) (*kvrpcpb.RawPutResponse, error) { out := new(kvrpcpb.RawPutResponse) - err := grpc.Invoke(ctx, "/tikvpb.Tikv/RawPut", in, out, c.cc, opts...) + err := c.cc.Invoke(ctx, "/tikvpb.Tikv/RawPut", in, out, opts...) if err != nil { return nil, err } @@ -234,7 +227,7 @@ func (c *tikvClient) RawPut(ctx context.Context, in *kvrpcpb.RawPutRequest, opts func (c *tikvClient) RawBatchPut(ctx context.Context, in *kvrpcpb.RawBatchPutRequest, opts ...grpc.CallOption) (*kvrpcpb.RawBatchPutResponse, error) { out := new(kvrpcpb.RawBatchPutResponse) - err := grpc.Invoke(ctx, "/tikvpb.Tikv/RawBatchPut", in, out, c.cc, opts...) + err := c.cc.Invoke(ctx, "/tikvpb.Tikv/RawBatchPut", in, out, opts...) if err != nil { return nil, err } @@ -243,7 +236,7 @@ func (c *tikvClient) RawBatchPut(ctx context.Context, in *kvrpcpb.RawBatchPutReq func (c *tikvClient) RawDelete(ctx context.Context, in *kvrpcpb.RawDeleteRequest, opts ...grpc.CallOption) (*kvrpcpb.RawDeleteResponse, error) { out := new(kvrpcpb.RawDeleteResponse) - err := grpc.Invoke(ctx, "/tikvpb.Tikv/RawDelete", in, out, c.cc, opts...) + err := c.cc.Invoke(ctx, "/tikvpb.Tikv/RawDelete", in, out, opts...) if err != nil { return nil, err } @@ -252,7 +245,7 @@ func (c *tikvClient) RawDelete(ctx context.Context, in *kvrpcpb.RawDeleteRequest func (c *tikvClient) RawBatchDelete(ctx context.Context, in *kvrpcpb.RawBatchDeleteRequest, opts ...grpc.CallOption) (*kvrpcpb.RawBatchDeleteResponse, error) { out := new(kvrpcpb.RawBatchDeleteResponse) - err := grpc.Invoke(ctx, "/tikvpb.Tikv/RawBatchDelete", in, out, c.cc, opts...) + err := c.cc.Invoke(ctx, "/tikvpb.Tikv/RawBatchDelete", in, out, opts...) if err != nil { return nil, err } @@ -261,7 +254,7 @@ func (c *tikvClient) RawBatchDelete(ctx context.Context, in *kvrpcpb.RawBatchDel func (c *tikvClient) RawScan(ctx context.Context, in *kvrpcpb.RawScanRequest, opts ...grpc.CallOption) (*kvrpcpb.RawScanResponse, error) { out := new(kvrpcpb.RawScanResponse) - err := grpc.Invoke(ctx, "/tikvpb.Tikv/RawScan", in, out, c.cc, opts...) + err := c.cc.Invoke(ctx, "/tikvpb.Tikv/RawScan", in, out, opts...) if err != nil { return nil, err } @@ -270,7 +263,7 @@ func (c *tikvClient) RawScan(ctx context.Context, in *kvrpcpb.RawScanRequest, op func (c *tikvClient) RawDeleteRange(ctx context.Context, in *kvrpcpb.RawDeleteRangeRequest, opts ...grpc.CallOption) (*kvrpcpb.RawDeleteRangeResponse, error) { out := new(kvrpcpb.RawDeleteRangeResponse) - err := grpc.Invoke(ctx, "/tikvpb.Tikv/RawDeleteRange", in, out, c.cc, opts...) + err := c.cc.Invoke(ctx, "/tikvpb.Tikv/RawDeleteRange", in, out, opts...) if err != nil { return nil, err } @@ -279,7 +272,7 @@ func (c *tikvClient) RawDeleteRange(ctx context.Context, in *kvrpcpb.RawDeleteRa func (c *tikvClient) RawBatchScan(ctx context.Context, in *kvrpcpb.RawBatchScanRequest, opts ...grpc.CallOption) (*kvrpcpb.RawBatchScanResponse, error) { out := new(kvrpcpb.RawBatchScanResponse) - err := grpc.Invoke(ctx, "/tikvpb.Tikv/RawBatchScan", in, out, c.cc, opts...) + err := c.cc.Invoke(ctx, "/tikvpb.Tikv/RawBatchScan", in, out, opts...) if err != nil { return nil, err } @@ -288,7 +281,7 @@ func (c *tikvClient) RawBatchScan(ctx context.Context, in *kvrpcpb.RawBatchScanR func (c *tikvClient) UnsafeDestroyRange(ctx context.Context, in *kvrpcpb.UnsafeDestroyRangeRequest, opts ...grpc.CallOption) (*kvrpcpb.UnsafeDestroyRangeResponse, error) { out := new(kvrpcpb.UnsafeDestroyRangeResponse) - err := grpc.Invoke(ctx, "/tikvpb.Tikv/UnsafeDestroyRange", in, out, c.cc, opts...) + err := c.cc.Invoke(ctx, "/tikvpb.Tikv/UnsafeDestroyRange", in, out, opts...) if err != nil { return nil, err } @@ -297,7 +290,7 @@ func (c *tikvClient) UnsafeDestroyRange(ctx context.Context, in *kvrpcpb.UnsafeD func (c *tikvClient) Coprocessor(ctx context.Context, in *coprocessor.Request, opts ...grpc.CallOption) (*coprocessor.Response, error) { out := new(coprocessor.Response) - err := grpc.Invoke(ctx, "/tikvpb.Tikv/Coprocessor", in, out, c.cc, opts...) + err := c.cc.Invoke(ctx, "/tikvpb.Tikv/Coprocessor", in, out, opts...) if err != nil { return nil, err } @@ -305,7 +298,7 @@ func (c *tikvClient) Coprocessor(ctx context.Context, in *coprocessor.Request, o } func (c *tikvClient) CoprocessorStream(ctx context.Context, in *coprocessor.Request, opts ...grpc.CallOption) (Tikv_CoprocessorStreamClient, error) { - stream, err := grpc.NewClientStream(ctx, &_Tikv_serviceDesc.Streams[0], c.cc, "/tikvpb.Tikv/CoprocessorStream", opts...) + stream, err := c.cc.NewStream(ctx, &_Tikv_serviceDesc.Streams[0], "/tikvpb.Tikv/CoprocessorStream", opts...) if err != nil { return nil, err } @@ -337,7 +330,7 @@ func (x *tikvCoprocessorStreamClient) Recv() (*coprocessor.Response, error) { } func (c *tikvClient) Raft(ctx context.Context, opts ...grpc.CallOption) (Tikv_RaftClient, error) { - stream, err := grpc.NewClientStream(ctx, &_Tikv_serviceDesc.Streams[1], c.cc, "/tikvpb.Tikv/Raft", opts...) + stream, err := c.cc.NewStream(ctx, &_Tikv_serviceDesc.Streams[1], "/tikvpb.Tikv/Raft", opts...) if err != nil { return nil, err } @@ -371,7 +364,7 @@ func (x *tikvRaftClient) CloseAndRecv() (*raft_serverpb.Done, error) { } func (c *tikvClient) Snapshot(ctx context.Context, opts ...grpc.CallOption) (Tikv_SnapshotClient, error) { - stream, err := grpc.NewClientStream(ctx, &_Tikv_serviceDesc.Streams[2], c.cc, "/tikvpb.Tikv/Snapshot", opts...) + stream, err := c.cc.NewStream(ctx, &_Tikv_serviceDesc.Streams[2], "/tikvpb.Tikv/Snapshot", opts...) if err != nil { return nil, err } @@ -406,7 +399,7 @@ func (x *tikvSnapshotClient) CloseAndRecv() (*raft_serverpb.Done, error) { func (c *tikvClient) SplitRegion(ctx context.Context, in *kvrpcpb.SplitRegionRequest, opts ...grpc.CallOption) (*kvrpcpb.SplitRegionResponse, error) { out := new(kvrpcpb.SplitRegionResponse) - err := grpc.Invoke(ctx, "/tikvpb.Tikv/SplitRegion", in, out, c.cc, opts...) + err := c.cc.Invoke(ctx, "/tikvpb.Tikv/SplitRegion", in, out, opts...) if err != nil { return nil, err } @@ -415,7 +408,7 @@ func (c *tikvClient) SplitRegion(ctx context.Context, in *kvrpcpb.SplitRegionReq func (c *tikvClient) MvccGetByKey(ctx context.Context, in *kvrpcpb.MvccGetByKeyRequest, opts ...grpc.CallOption) (*kvrpcpb.MvccGetByKeyResponse, error) { out := new(kvrpcpb.MvccGetByKeyResponse) - err := grpc.Invoke(ctx, "/tikvpb.Tikv/MvccGetByKey", in, out, c.cc, opts...) + err := c.cc.Invoke(ctx, "/tikvpb.Tikv/MvccGetByKey", in, out, opts...) if err != nil { return nil, err } @@ -424,7 +417,7 @@ func (c *tikvClient) MvccGetByKey(ctx context.Context, in *kvrpcpb.MvccGetByKeyR func (c *tikvClient) MvccGetByStartTs(ctx context.Context, in *kvrpcpb.MvccGetByStartTsRequest, opts ...grpc.CallOption) (*kvrpcpb.MvccGetByStartTsResponse, error) { out := new(kvrpcpb.MvccGetByStartTsResponse) - err := grpc.Invoke(ctx, "/tikvpb.Tikv/MvccGetByStartTs", in, out, c.cc, opts...) + err := c.cc.Invoke(ctx, "/tikvpb.Tikv/MvccGetByStartTs", in, out, opts...) if err != nil { return nil, err } @@ -1146,9 +1139,9 @@ var _Tikv_serviceDesc = grpc.ServiceDesc{ Metadata: "tikvpb.proto", } -func init() { proto.RegisterFile("tikvpb.proto", fileDescriptorTikvpb) } +func init() { proto.RegisterFile("tikvpb.proto", fileDescriptor_tikvpb_cba75a7bda72a5e1) } -var fileDescriptorTikvpb = []byte{ +var fileDescriptor_tikvpb_cba75a7bda72a5e1 = []byte{ // 709 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x96, 0x4f, 0x6f, 0xd3, 0x30, 0x18, 0xc6, 0x57, 0x69, 0x94, 0xcd, 0xdb, 0x60, 0x73, 0x07, 0x74, 0x59, 0x97, 0xc1, 0xb8, 0x20, From aa23f25569e0e2b33efc4c952e60f4370337b794 Mon Sep 17 00:00:00 2001 From: MyonKeminta Date: Sun, 28 Oct 2018 19:43:22 +0800 Subject: [PATCH 02/17] seek bound initial commit Signed-off-by: MyonKeminta --- ddl/db_test.go | 10 +++++----- ddl/delete_range.go | 2 +- ddl/index.go | 3 ++- executor/show.go | 24 ++++++++++++------------ infoschema/tables.go | 30 +++++++++++++++--------------- kv/buffer_store.go | 6 +++--- kv/buffer_store_test.go | 2 +- kv/kv.go | 2 +- kv/mem_buffer_test.go | 20 ++++++++++---------- kv/memdb_buffer.go | 4 ++-- kv/mock.go | 6 +++--- kv/mock_test.go | 2 +- kv/union_store.go | 4 ++-- kv/union_store_test.go | 8 ++++---- session/txn.go | 6 +++--- store/store_test.go | 28 ++++++++++++++-------------- store/tikv/delete_range_test.go | 2 +- store/tikv/lock_test.go | 4 ++-- store/tikv/safepoint_test.go | 2 +- store/tikv/scan.go | 14 ++++++++++++-- store/tikv/scan_mock_test.go | 2 +- store/tikv/scan_test.go | 8 ++++---- store/tikv/snapshot.go | 4 ++-- store/tikv/snapshot_test.go | 4 ++-- store/tikv/store_test.go | 2 +- store/tikv/ticlient_test.go | 4 ++-- store/tikv/txn.go | 4 ++-- structure/hash.go | 2 +- table/tables/index.go | 8 +++++--- table/tables/tables.go | 4 ++-- util/admin/admin.go | 6 ++++-- util/prefix_helper.go | 4 ++-- 32 files changed, 123 insertions(+), 108 deletions(-) diff --git a/ddl/db_test.go b/ddl/db_test.go index 590e2d392ea4b..2c8194c9c75cf 100644 --- a/ddl/db_test.go +++ b/ddl/db_test.go @@ -1877,7 +1877,7 @@ func (s *testDBSuite) TestTruncateTable(c *C) { hasOldTableData := true for i := 0; i < waitForCleanDataRound; i++ { err = kv.RunInNewTxn(s.store, false, func(txn kv.Transaction) error { - it, err1 := txn.Seek(tablePrefix) + it, err1 := txn.Seek(tablePrefix, nil) if err1 != nil { return err1 } @@ -2803,7 +2803,7 @@ func (s *testDBSuite) TestAlterTableDropPartition(c *C) { s.tk.MustExec("drop table if exists tr;") s.tk.MustExec(` create table tr( - id int, name varchar(50), + id int, name varchar(50), purchased date ) partition by range( year(purchased) ) ( @@ -2893,7 +2893,7 @@ func checkPartitionDelRangeDone(c *C, s *testDBSuite, partitionPrefix kv.Key) bo hasOldPartitionData := true for i := 0; i < waitForCleanDataRound; i++ { err := kv.RunInNewTxn(s.store, false, func(txn kv.Transaction) error { - it, err := txn.Seek(partitionPrefix) + it, err := txn.Seek(partitionPrefix, nil) if err != nil { return err } @@ -2943,7 +2943,7 @@ func (s *testDBSuite) TestTruncatePartitionAndDropTable(c *C) { // Test truncate table partition. s.tk.MustExec("drop table if exists t3;") s.tk.MustExec(`create table t3( - id int, name varchar(50), + id int, name varchar(50), purchased date ) partition by range( year(purchased) ) ( @@ -2981,7 +2981,7 @@ func (s *testDBSuite) TestTruncatePartitionAndDropTable(c *C) { // Test drop table partition. s.tk.MustExec("drop table if exists t4;") s.tk.MustExec(`create table t4( - id int, name varchar(50), + id int, name varchar(50), purchased date ) partition by range( year(purchased) ) ( diff --git a/ddl/delete_range.go b/ddl/delete_range.go index 25a4512d6beeb..43bfd21742684 100644 --- a/ddl/delete_range.go +++ b/ddl/delete_range.go @@ -154,7 +154,7 @@ func (dr *delRange) doTask(ctx sessionctx.Context, r util.DelRangeTask) error { finish := true dr.keys = dr.keys[:0] err := kv.RunInNewTxn(dr.store, false, func(txn kv.Transaction) error { - iter, err := txn.Seek(oldStartKey) + iter, err := txn.Seek(oldStartKey, nil) if err != nil { return errors.Trace(err) } diff --git a/ddl/index.go b/ddl/index.go index 2e92bf619c05e..fc9f0e9230409 100644 --- a/ddl/index.go +++ b/ddl/index.go @@ -1216,7 +1216,8 @@ func iterateSnapshotRows(store kv.Storage, priority int, t table.Table, version return errors.Trace(err) } firstKey := t.RecordKey(seekHandle) - it, err := snap.Seek(firstKey) + upperBound := firstKey.PrefixNext() + it, err := snap.Seek(firstKey, &upperBound) if err != nil { return errors.Trace(err) } diff --git a/executor/show.go b/executor/show.go index a959a30aa9457..e568fd447ad4c 100644 --- a/executor/show.go +++ b/executor/show.go @@ -379,19 +379,19 @@ func (e *ShowExec) fetchShowIndex() error { subPart = col.Length } e.appendRow([]interface{}{ - tb.Meta().Name.O, // Table - nonUniq, // Non_unique - idx.Meta().Name.O, // Key_name - i + 1, // Seq_in_index - col.Name.O, // Column_name - "A", // Collation - 0, // Cardinality - subPart, // Sub_part - nil, // Packed - "YES", // Null + tb.Meta().Name.O, // Table + nonUniq, // Non_unique + idx.Meta().Name.O, // Key_name + i + 1, // Seq_in_index + col.Name.O, // Column_name + "A", // Collation + 0, // Cardinality + subPart, // Sub_part + nil, // Packed + "YES", // Null idx.Meta().Tp.String(), // Index_type - "", // Comment - idx.Meta().Comment, // Index_comment + "", // Comment + idx.Meta().Comment, // Index_comment }) } } diff --git a/infoschema/tables.go b/infoschema/tables.go index f7cabdcedcb2d..5ebc01ed3649f 100644 --- a/infoschema/tables.go +++ b/infoschema/tables.go @@ -1168,24 +1168,24 @@ func dataForTableConstraints(schemas []*model.DBInfo) [][]types.Datum { func dataForPseudoProfiling() [][]types.Datum { var rows [][]types.Datum row := types.MakeDatums( - 0, // QUERY_ID - 0, // SEQ - "", // STATE + 0, // QUERY_ID + 0, // SEQ + "", // STATE types.NewDecFromInt(0), // DURATION types.NewDecFromInt(0), // CPU_USER types.NewDecFromInt(0), // CPU_SYSTEM - 0, // CONTEXT_VOLUNTARY - 0, // CONTEXT_INVOLUNTARY - 0, // BLOCK_OPS_IN - 0, // BLOCK_OPS_OUT - 0, // MESSAGES_SENT - 0, // MESSAGES_RECEIVED - 0, // PAGE_FAULTS_MAJOR - 0, // PAGE_FAULTS_MINOR - 0, // SWAPS - 0, // SOURCE_FUNCTION - 0, // SOURCE_FILE - 0, // SOURCE_LINE + 0, // CONTEXT_VOLUNTARY + 0, // CONTEXT_INVOLUNTARY + 0, // BLOCK_OPS_IN + 0, // BLOCK_OPS_OUT + 0, // MESSAGES_SENT + 0, // MESSAGES_RECEIVED + 0, // PAGE_FAULTS_MAJOR + 0, // PAGE_FAULTS_MINOR + 0, // SWAPS + 0, // SOURCE_FUNCTION + 0, // SOURCE_FILE + 0, // SOURCE_LINE ) rows = append(rows, row) return rows diff --git a/kv/buffer_store.go b/kv/buffer_store.go index 5e798db5c8875..a890517f286d3 100644 --- a/kv/buffer_store.go +++ b/kv/buffer_store.go @@ -75,12 +75,12 @@ func (s *BufferStore) Get(k Key) ([]byte, error) { } // Seek implements the Retriever interface. -func (s *BufferStore) Seek(k Key) (Iterator, error) { - bufferIt, err := s.MemBuffer.Seek(k) +func (s *BufferStore) Seek(k Key, upperBound *Key) (Iterator, error) { + bufferIt, err := s.MemBuffer.Seek(k, upperBound) if err != nil { return nil, errors.Trace(err) } - retrieverIt, err := s.r.Seek(k) + retrieverIt, err := s.r.Seek(k, upperBound) if err != nil { return nil, errors.Trace(err) } diff --git a/kv/buffer_store_test.go b/kv/buffer_store_test.go index af84a9294cd24..4777cb84527ee 100644 --- a/kv/buffer_store_test.go +++ b/kv/buffer_store_test.go @@ -53,7 +53,7 @@ func (s testBufferStoreSuite) TestSaveTo(c *C) { err := bs.SaveTo(mutator) c.Check(err, IsNil) - iter, err := mutator.Seek(nil) + iter, err := mutator.Seek(nil, nil) c.Check(err, IsNil) for iter.Valid() { cmp := bytes.Compare(iter.Key(), iter.Value()) diff --git a/kv/kv.go b/kv/kv.go index 8c8a0830b208a..0660bf00b70df 100644 --- a/kv/kv.go +++ b/kv/kv.go @@ -82,7 +82,7 @@ type Retriever interface { // Seek creates an Iterator positioned on the first entry that k <= entry's key. // If such entry is not found, it returns an invalid Iterator with no error. // The Iterator must be Closed after use. - Seek(k Key) (Iterator, error) + Seek(k Key, upperBound *Key) (Iterator, error) // SeekReverse creates a reversed Iterator positioned on the first entry which key is less than k. // The returned iterator will iterate from greater key to smaller key. diff --git a/kv/mem_buffer_test.go b/kv/mem_buffer_test.go index 92807b528da2d..d5eec355abbd3 100644 --- a/kv/mem_buffer_test.go +++ b/kv/mem_buffer_test.go @@ -76,7 +76,7 @@ func valToStr(c *C, iter Iterator) string { func checkNewIterator(c *C, buffer MemBuffer) { for i := startIndex; i < testCount; i++ { val := encodeInt(i * indexStep) - iter, err := buffer.Seek(val) + iter, err := buffer.Seek(val, nil) c.Assert(err, IsNil) c.Assert([]byte(iter.Key()), BytesEquals, val) c.Assert(decodeInt([]byte(valToStr(c, iter))), Equals, i*indexStep) @@ -86,7 +86,7 @@ func checkNewIterator(c *C, buffer MemBuffer) { // Test iterator Next() for i := startIndex; i < testCount-1; i++ { val := encodeInt(i * indexStep) - iter, err := buffer.Seek(val) + iter, err := buffer.Seek(val, nil) c.Assert(err, IsNil) c.Assert([]byte(iter.Key()), BytesEquals, val) c.Assert(valToStr(c, iter), Equals, string(val)) @@ -102,7 +102,7 @@ func checkNewIterator(c *C, buffer MemBuffer) { } // Non exist and beyond maximum seek test - iter, err := buffer.Seek(encodeInt(testCount * indexStep)) + iter, err := buffer.Seek(encodeInt(testCount*indexStep), nil) c.Assert(err, IsNil) c.Assert(iter.Valid(), IsFalse) @@ -110,7 +110,7 @@ func checkNewIterator(c *C, buffer MemBuffer) { // it returns the smallest key that larger than the one we are seeking inBetween := encodeInt((testCount-1)*indexStep - 1) last := encodeInt((testCount - 1) * indexStep) - iter, err = buffer.Seek(inBetween) + iter, err = buffer.Seek(inBetween, nil) c.Assert(err, IsNil) c.Assert(iter.Valid(), IsTrue) c.Assert([]byte(iter.Key()), Not(BytesEquals), inBetween) @@ -140,7 +140,7 @@ func (s *testKVSuite) TestNewIterator(c *C) { defer testleak.AfterTest(c)() for _, buffer := range s.bs { // should be invalid - iter, err := buffer.Seek(nil) + iter, err := buffer.Seek(nil, nil) c.Assert(err, IsNil) c.Assert(iter.Valid(), IsFalse) @@ -155,7 +155,7 @@ func (s *testKVSuite) TestIterNextUntil(c *C) { buffer := NewMemDbBuffer(DefaultTxnMembufCap) insertData(c, buffer) - iter, err := buffer.Seek(nil) + iter, err := buffer.Seek(nil, nil) c.Assert(err, IsNil) err = NextUntil(iter, func(k Key) bool { @@ -168,7 +168,7 @@ func (s *testKVSuite) TestIterNextUntil(c *C) { func (s *testKVSuite) TestBasicNewIterator(c *C) { defer testleak.AfterTest(c)() for _, buffer := range s.bs { - it, err := buffer.Seek([]byte("2")) + it, err := buffer.Seek([]byte("2"), nil) c.Assert(err, IsNil) c.Assert(it.Valid(), IsFalse) } @@ -193,7 +193,7 @@ func (s *testKVSuite) TestNewIteratorMin(c *C) { } cnt := 0 - it, err := buffer.Seek(nil) + it, err := buffer.Seek(nil, nil) c.Assert(err, IsNil) for it.Valid() { cnt++ @@ -201,7 +201,7 @@ func (s *testKVSuite) TestNewIteratorMin(c *C) { } c.Assert(cnt, Equals, 6) - it, err = buffer.Seek([]byte("DATA_test_main_db_tbl_tbl_test_record__00000000000000000000")) + it, err = buffer.Seek([]byte("DATA_test_main_db_tbl_tbl_test_record__00000000000000000000"), nil) c.Assert(err, IsNil) c.Assert(string(it.Key()), Equals, "DATA_test_main_db_tbl_tbl_test_record__00000000000000000001") } @@ -294,7 +294,7 @@ func benchIterator(b *testing.B, buffer MemBuffer) { } b.ResetTimer() for i := 0; i < b.N; i++ { - iter, err := buffer.Seek(nil) + iter, err := buffer.Seek(nil, nil) if err != nil { b.Error(err) } diff --git a/kv/memdb_buffer.go b/kv/memdb_buffer.go index 76b93c355479c..51f15ea3aab14 100644 --- a/kv/memdb_buffer.go +++ b/kv/memdb_buffer.go @@ -51,7 +51,7 @@ func NewMemDbBuffer(cap int) MemBuffer { } // Seek creates an Iterator. -func (m *memDbBuffer) Seek(k Key) (Iterator, error) { +func (m *memDbBuffer) Seek(k Key, upperBound *Key) (Iterator, error) { var i Iterator if k == nil { i = &memDbIter{iter: m.db.NewIterator(&util.Range{}), reverse: false} @@ -161,7 +161,7 @@ func (i *memDbIter) Close() { // WalkMemBuffer iterates all buffered kv pairs in memBuf func WalkMemBuffer(memBuf MemBuffer, f func(k Key, v []byte) error) error { - iter, err := memBuf.Seek(nil) + iter, err := memBuf.Seek(nil, nil) if err != nil { return errors.Trace(err) } diff --git a/kv/mock.go b/kv/mock.go index 9fb8a0559c33d..3dd12abfacdc6 100644 --- a/kv/mock.go +++ b/kv/mock.go @@ -68,7 +68,7 @@ func (t *mockTxn) Get(k Key) ([]byte, error) { return nil, nil } -func (t *mockTxn) Seek(k Key) (Iterator, error) { +func (t *mockTxn) Seek(k Key, upperBound *Key) (Iterator, error) { return nil, nil } @@ -211,8 +211,8 @@ func (s *mockSnapshot) BatchGet(keys []Key) (map[string][]byte, error) { return m, nil } -func (s *mockSnapshot) Seek(k Key) (Iterator, error) { - return s.store.Seek(k) +func (s *mockSnapshot) Seek(k Key, upperBound *Key) (Iterator, error) { + return s.store.Seek(k, upperBound) } func (s *mockSnapshot) SeekReverse(k Key) (Iterator, error) { diff --git a/kv/mock_test.go b/kv/mock_test.go index 93dc59490b4a4..9c51d0864f970 100644 --- a/kv/mock_test.go +++ b/kv/mock_test.go @@ -46,7 +46,7 @@ func (s testMockSuite) TestInterface(c *C) { if transaction.IsReadOnly() { transaction.Get(Key("lock")) transaction.Set(Key("lock"), []byte{}) - transaction.Seek(Key("lock")) + transaction.Seek(Key("lock"), nil) transaction.SeekReverse(Key("lock")) } transaction.Commit(context.Background()) diff --git a/kv/union_store.go b/kv/union_store.go index 6e3111f3ca240..768d8f50217de 100644 --- a/kv/union_store.go +++ b/kv/union_store.go @@ -127,11 +127,11 @@ func (lmb *lazyMemBuffer) Delete(k Key) error { return lmb.mb.Delete(k) } -func (lmb *lazyMemBuffer) Seek(k Key) (Iterator, error) { +func (lmb *lazyMemBuffer) Seek(k Key, upperBound *Key) (Iterator, error) { if lmb.mb == nil { return invalidIterator{}, nil } - return lmb.mb.Seek(k) + return lmb.mb.Seek(k, upperBound) } func (lmb *lazyMemBuffer) SeekReverse(k Key) (Iterator, error) { diff --git a/kv/union_store_test.go b/kv/union_store_test.go index c4e6c400f915a..860c2a3f2fc3b 100644 --- a/kv/union_store_test.go +++ b/kv/union_store_test.go @@ -63,21 +63,21 @@ func (s *testUnionStoreSuite) TestSeek(c *C) { s.store.Set([]byte("2"), []byte("2")) s.store.Set([]byte("3"), []byte("3")) - iter, err := s.us.Seek(nil) + iter, err := s.us.Seek(nil, nil) c.Assert(err, IsNil) checkIterator(c, iter, [][]byte{[]byte("1"), []byte("2"), []byte("3")}, [][]byte{[]byte("1"), []byte("2"), []byte("3")}) - iter, err = s.us.Seek([]byte("2")) + iter, err = s.us.Seek([]byte("2"), nil) c.Assert(err, IsNil) checkIterator(c, iter, [][]byte{[]byte("2"), []byte("3")}, [][]byte{[]byte("2"), []byte("3")}) s.us.Set([]byte("4"), []byte("4")) - iter, err = s.us.Seek([]byte("2")) + iter, err = s.us.Seek([]byte("2"), nil) c.Assert(err, IsNil) checkIterator(c, iter, [][]byte{[]byte("2"), []byte("3"), []byte("4")}, [][]byte{[]byte("2"), []byte("3"), []byte("4")}) s.us.Delete([]byte("3")) - iter, err = s.us.Seek([]byte("2")) + iter, err = s.us.Seek([]byte("2"), nil) c.Assert(err, IsNil) checkIterator(c, iter, [][]byte{[]byte("2"), []byte("4")}, [][]byte{[]byte("2"), []byte("4")}) } diff --git a/session/txn.go b/session/txn.go index 5b37b63ad29f3..e663411122290 100644 --- a/session/txn.go +++ b/session/txn.go @@ -160,12 +160,12 @@ func (st *TxnState) Delete(k kv.Key) error { } // Seek overrides the Transaction interface. -func (st *TxnState) Seek(k kv.Key) (kv.Iterator, error) { - bufferIt, err := st.buf.Seek(k) +func (st *TxnState) Seek(k kv.Key, upperBound *kv.Key) (kv.Iterator, error) { + bufferIt, err := st.buf.Seek(k, upperBound) if err != nil { return nil, errors.Trace(err) } - retrieverIt, err := st.Transaction.Seek(k) + retrieverIt, err := st.Transaction.Seek(k, upperBound) if err != nil { return nil, errors.Trace(err) } diff --git a/store/store_test.go b/store/store_test.go index b69f92dbb7014..2e766e73b9a6e 100644 --- a/store/store_test.go +++ b/store/store_test.go @@ -97,7 +97,7 @@ func valToStr(c *C, iter kv.Iterator) string { func checkSeek(c *C, txn kv.Transaction) { for i := startIndex; i < testCount; i++ { val := encodeInt(i * indexStep) - iter, err := txn.Seek(val) + iter, err := txn.Seek(val, nil) c.Assert(err, IsNil) c.Assert([]byte(iter.Key()), BytesEquals, val) c.Assert(decodeInt([]byte(valToStr(c, iter))), Equals, i*indexStep) @@ -107,7 +107,7 @@ func checkSeek(c *C, txn kv.Transaction) { // Test iterator Next() for i := startIndex; i < testCount-1; i++ { val := encodeInt(i * indexStep) - iter, err := txn.Seek(val) + iter, err := txn.Seek(val, nil) c.Assert(err, IsNil) c.Assert([]byte(iter.Key()), BytesEquals, val) c.Assert(valToStr(c, iter), Equals, string(val)) @@ -123,7 +123,7 @@ func checkSeek(c *C, txn kv.Transaction) { } // Non exist and beyond maximum seek test - iter, err := txn.Seek(encodeInt(testCount * indexStep)) + iter, err := txn.Seek(encodeInt(testCount*indexStep), nil) c.Assert(err, IsNil) c.Assert(iter.Valid(), IsFalse) @@ -131,7 +131,7 @@ func checkSeek(c *C, txn kv.Transaction) { // it returns the smallest key that larger than the one we are seeking inBetween := encodeInt((testCount-1)*indexStep - 1) last := encodeInt((testCount - 1) * indexStep) - iter, err = txn.Seek(inBetween) + iter, err = txn.Seek(inBetween, nil) c.Assert(err, IsNil) c.Assert(iter.Valid(), IsTrue) c.Assert([]byte(iter.Key()), Not(BytesEquals), inBetween) @@ -278,7 +278,7 @@ func (s *testKVSuite) TestDelete2(c *C) { txn, err = s.s.Begin() c.Assert(err, IsNil) - it, err := txn.Seek([]byte("DATA_test_tbl_department_record__0000000001_0003")) + it, err := txn.Seek([]byte("DATA_test_tbl_department_record__0000000001_0003"), nil) c.Assert(err, IsNil) for it.Valid() { err = txn.Delete([]byte(it.Key())) @@ -290,7 +290,7 @@ func (s *testKVSuite) TestDelete2(c *C) { txn, err = s.s.Begin() c.Assert(err, IsNil) - it, _ = txn.Seek([]byte("DATA_test_tbl_department_record__000000000")) + it, _ = txn.Seek([]byte("DATA_test_tbl_department_record__000000000"), nil) c.Assert(it.Valid(), IsFalse) txn.Commit(context.Background()) } @@ -312,7 +312,7 @@ func (s *testKVSuite) TestBasicSeek(c *C) { c.Assert(err, IsNil) defer txn.Commit(context.Background()) - it, err := txn.Seek([]byte("2")) + it, err := txn.Seek([]byte("2"), nil) c.Assert(err, IsNil) c.Assert(it.Valid(), Equals, false) txn.Delete([]byte("1")) @@ -333,30 +333,30 @@ func (s *testKVSuite) TestBasicTable(c *C) { err = txn.Set([]byte("1"), []byte("1")) c.Assert(err, IsNil) - it, err := txn.Seek([]byte("0")) + it, err := txn.Seek([]byte("0"), nil) c.Assert(err, IsNil) c.Assert(string(it.Key()), Equals, "1") err = txn.Set([]byte("0"), []byte("0")) c.Assert(err, IsNil) - it, err = txn.Seek([]byte("0")) + it, err = txn.Seek([]byte("0"), nil) c.Assert(err, IsNil) c.Assert(string(it.Key()), Equals, "0") err = txn.Delete([]byte("0")) c.Assert(err, IsNil) txn.Delete([]byte("1")) - it, err = txn.Seek([]byte("0")) + it, err = txn.Seek([]byte("0"), nil) c.Assert(err, IsNil) c.Assert(string(it.Key()), Equals, "2") err = txn.Delete([]byte("3")) c.Assert(err, IsNil) - it, err = txn.Seek([]byte("2")) + it, err = txn.Seek([]byte("2"), nil) c.Assert(err, IsNil) c.Assert(string(it.Key()), Equals, "2") - it, err = txn.Seek([]byte("3")) + it, err = txn.Seek([]byte("3"), nil) c.Assert(err, IsNil) c.Assert(string(it.Key()), Equals, "4") err = txn.Delete([]byte("2")) @@ -411,13 +411,13 @@ func (s *testKVSuite) TestSeekMin(c *C) { txn.Set([]byte(row.key), []byte(row.value)) } - it, err := txn.Seek(nil) + it, err := txn.Seek(nil, nil) for it.Valid() { fmt.Printf("%s, %s\n", it.Key(), it.Value()) it.Next() } - it, err = txn.Seek([]byte("DATA_test_main_db_tbl_tbl_test_record__00000000000000000000")) + it, err = txn.Seek([]byte("DATA_test_main_db_tbl_tbl_test_record__00000000000000000000"), nil) c.Assert(err, IsNil) c.Assert(string(it.Key()), Equals, "DATA_test_main_db_tbl_tbl_test_record__00000000000000000001") diff --git a/store/tikv/delete_range_test.go b/store/tikv/delete_range_test.go index 7864eb0954878..9ae2c64d4ee19 100644 --- a/store/tikv/delete_range_test.go +++ b/store/tikv/delete_range_test.go @@ -50,7 +50,7 @@ func (s *testDeleteRangeSuite) TearDownTest(c *C) { func (s *testDeleteRangeSuite) checkData(c *C, expectedData map[string]string) { txn, err := s.store.Begin() c.Assert(err, IsNil) - it, err := txn.Seek([]byte("a")) + it, err := txn.Seek([]byte("a"), nil) c.Assert(err, IsNil) // Scan all data and save into a map diff --git a/store/tikv/lock_test.go b/store/tikv/lock_test.go index 20bedba474f10..4181cb43abedc 100644 --- a/store/tikv/lock_test.go +++ b/store/tikv/lock_test.go @@ -116,7 +116,7 @@ func (s *testLockSuite) TestScanLockResolveWithSeek(c *C) { txn, err := s.store.Begin() c.Assert(err, IsNil) - iter, err := txn.Seek([]byte("a")) + iter, err := txn.Seek([]byte("a"), nil) c.Assert(err, IsNil) for ch := byte('a'); ch <= byte('z'); ch++ { c.Assert(iter.Valid(), IsTrue) @@ -133,7 +133,7 @@ func (s *testLockSuite) TestScanLockResolveWithSeekKeyOnly(c *C) { txn, err := s.store.Begin() c.Assert(err, IsNil) txn.SetOption(kv.KeyOnly, true) - iter, err := txn.Seek([]byte("a")) + iter, err := txn.Seek([]byte("a"), nil) c.Assert(err, IsNil) for ch := byte('a'); ch <= byte('z'); ch++ { c.Assert(iter.Valid(), IsTrue) diff --git a/store/tikv/safepoint_test.go b/store/tikv/safepoint_test.go index e2142ccf9f1a2..7c7a26257efa1 100644 --- a/store/tikv/safepoint_test.go +++ b/store/tikv/safepoint_test.go @@ -100,7 +100,7 @@ func (s *testSafePointSuite) TestSafePoint(c *C) { s.waitUntilErrorPlugIn(txn3.startTS) - _, seekerr := txn3.Seek(encodeKey(s.prefix, "")) + _, seekerr := txn3.Seek(encodeKey(s.prefix, ""), nil) c.Assert(seekerr, NotNil) isFallBehind = terror.ErrorEqual(errors.Cause(geterr2), ErrGCTooEarly) isMayFallBehind = terror.ErrorEqual(errors.Cause(geterr2), ErrPDServerTimeout.GenWithStackByArgs("start timestamp may fall behind safe point")) diff --git a/store/tikv/scan.go b/store/tikv/scan.go index ab0ba76bc0e60..baa25489151ad 100644 --- a/store/tikv/scan.go +++ b/store/tikv/scan.go @@ -31,9 +31,10 @@ type Scanner struct { idx int nextStartKey []byte eof bool + upperBound *kv.Key } -func newScanner(snapshot *tikvSnapshot, startKey []byte, batchSize int) (*Scanner, error) { +func newScanner(snapshot *tikvSnapshot, startKey []byte, batchSize int, upperBound *kv.Key) (*Scanner, error) { // It must be > 1. Otherwise scanner won't skipFirst. if batchSize <= 1 { batchSize = scanBatchSize @@ -43,6 +44,7 @@ func newScanner(snapshot *tikvSnapshot, startKey []byte, batchSize int) (*Scanne batchSize: batchSize, valid: true, nextStartKey: startKey, + upperBound: upperBound, } err := scanner.Next() if kv.IsErrNotFound(err) { @@ -135,10 +137,18 @@ func (s *Scanner) resolveCurrentLock(bo *Backoffer, current *pb.KvPair) error { } func (s *Scanner) getData(bo *Backoffer) error { - log.Debugf("txn getData nextStartKey[%q], txn %d", s.nextStartKey, s.startTS()) + log.Debugf("txn getData nextStartKey[%q], txn %d, upperBound %q", s.nextStartKey, s.startTS(), s.upperBound) sender := NewRegionRequestSender(s.snapshot.store.regionCache, s.snapshot.store.client) for { + if s.upperBound != nil { + if kv.Key(s.nextStartKey).Cmp(*s.upperBound) >= 0 { + // nextStartKey >= upperBound + s.eof = true + return nil + } + } + loc, err := s.snapshot.store.regionCache.LocateKey(bo, s.nextStartKey) if err != nil { return errors.Trace(err) diff --git a/store/tikv/scan_mock_test.go b/store/tikv/scan_mock_test.go index af453a985ff32..9f2f282ba53fc 100644 --- a/store/tikv/scan_mock_test.go +++ b/store/tikv/scan_mock_test.go @@ -41,7 +41,7 @@ func (s *testScanMockSuite) TestScanMultipleRegions(c *C) { txn, err = store.Begin() c.Assert(err, IsNil) snapshot := newTiKVSnapshot(store, kv.Version{Ver: txn.StartTS()}) - scanner, err := newScanner(snapshot, []byte("a"), 10) + scanner, err := newScanner(snapshot, []byte("a"), 10, nil) c.Assert(err, IsNil) for ch := byte('a'); ch <= byte('z'); ch++ { c.Assert([]byte{ch}, BytesEquals, []byte(scanner.Key())) diff --git a/store/tikv/scan_test.go b/store/tikv/scan_test.go index e4897bc2de2b7..5796f07ba0e0b 100644 --- a/store/tikv/scan_test.go +++ b/store/tikv/scan_test.go @@ -40,7 +40,7 @@ func (s *testScanSuite) SetUpSuite(c *C) { func (s *testScanSuite) TearDownSuite(c *C) { txn := s.beginTxn(c) - scanner, err := txn.Seek(encodeKey(s.prefix, "")) + scanner, err := txn.Seek(encodeKey(s.prefix, ""), nil) c.Assert(err, IsNil) c.Assert(scanner, NotNil) for scanner.Valid() { @@ -76,7 +76,7 @@ func (s *testScanSuite) TestSeek(c *C) { val, err := txn2.Get(encodeKey(s.prefix, s08d("key", 0))) c.Assert(err, IsNil) c.Assert(val, BytesEquals, valueBytes(0)) - scan, err := txn2.Seek(encodeKey(s.prefix, "")) + scan, err := txn2.Seek(encodeKey(s.prefix, ""), nil) c.Assert(err, IsNil) for i := 0; i < rowNum; i++ { @@ -95,7 +95,7 @@ func (s *testScanSuite) TestSeek(c *C) { txn3 := s.beginTxn(c) txn3.SetOption(kv.KeyOnly, true) - scan, err = txn3.Seek(encodeKey(s.prefix, "")) + scan, err = txn3.Seek(encodeKey(s.prefix, ""), nil) c.Assert(err, IsNil) for i := 0; i < rowNum; i++ { @@ -112,7 +112,7 @@ func (s *testScanSuite) TestSeek(c *C) { // Restore KeyOnly to false txn3.SetOption(kv.KeyOnly, false) - scan, err = txn3.Seek(encodeKey(s.prefix, "")) + scan, err = txn3.Seek(encodeKey(s.prefix, ""), nil) c.Assert(err, IsNil) for i := 0; i < rowNum; i++ { diff --git a/store/tikv/snapshot.go b/store/tikv/snapshot.go index 730db0273c193..dc91aadfbd677 100644 --- a/store/tikv/snapshot.go +++ b/store/tikv/snapshot.go @@ -279,8 +279,8 @@ func (s *tikvSnapshot) get(bo *Backoffer, k kv.Key) ([]byte, error) { } // Seek return a list of key-value pair after `k`. -func (s *tikvSnapshot) Seek(k kv.Key) (kv.Iterator, error) { - scanner, err := newScanner(s, k, scanBatchSize) +func (s *tikvSnapshot) Seek(k kv.Key, upperBound *kv.Key) (kv.Iterator, error) { + scanner, err := newScanner(s, k, scanBatchSize, upperBound) return scanner, errors.Trace(err) } diff --git a/store/tikv/snapshot_test.go b/store/tikv/snapshot_test.go index 4ea695f224e4b..7bc03676e88fa 100644 --- a/store/tikv/snapshot_test.go +++ b/store/tikv/snapshot_test.go @@ -42,7 +42,7 @@ func (s *testSnapshotSuite) SetUpSuite(c *C) { func (s *testSnapshotSuite) TearDownSuite(c *C) { txn := s.beginTxn(c) - scanner, err := txn.Seek(encodeKey(s.prefix, "")) + scanner, err := txn.Seek(encodeKey(s.prefix, ""), nil) c.Assert(err, IsNil) c.Assert(scanner, NotNil) for scanner.Valid() { @@ -70,7 +70,7 @@ func (s *testSnapshotSuite) checkAll(keys []kv.Key, c *C) { m, err := snapshot.BatchGet(keys) c.Assert(err, IsNil) - scan, err := txn.Seek(encodeKey(s.prefix, "")) + scan, err := txn.Seek(encodeKey(s.prefix, ""), nil) c.Assert(err, IsNil) cnt := 0 for scan.Valid() { diff --git a/store/tikv/store_test.go b/store/tikv/store_test.go index 00735eee64a3f..000a085b5821c 100644 --- a/store/tikv/store_test.go +++ b/store/tikv/store_test.go @@ -229,7 +229,7 @@ func (s *testStoreSuite) TestRequestPriority(c *C) { // Cover Seek request. client.priority = pb.CommandPri_High txn.SetOption(kv.Priority, kv.PriorityHigh) - iter, err := txn.Seek([]byte("key")) + iter, err := txn.Seek([]byte("key"), nil) c.Assert(err, IsNil) for iter.Valid() { c.Assert(iter.Next(), IsNil) diff --git a/store/tikv/ticlient_test.go b/store/tikv/ticlient_test.go index 1b4ea24ad5c82..3634f788a22ff 100644 --- a/store/tikv/ticlient_test.go +++ b/store/tikv/ticlient_test.go @@ -61,7 +61,7 @@ func clearStorage(store kv.Storage) error { if err != nil { return errors.Trace(err) } - iter, err := txn.Seek(nil) + iter, err := txn.Seek(nil, nil) if err != nil { return errors.Trace(err) } @@ -93,7 +93,7 @@ func (s *testTiclientSuite) SetUpSuite(c *C) { func (s *testTiclientSuite) TearDownSuite(c *C) { // Clean all data, or it may pollute other data. txn := s.beginTxn(c) - scanner, err := txn.Seek(encodeKey(s.prefix, "")) + scanner, err := txn.Seek(encodeKey(s.prefix, ""), nil) c.Assert(err, IsNil) c.Assert(scanner, NotNil) for scanner.Valid() { diff --git a/store/tikv/txn.go b/store/tikv/txn.go index 110135718667a..10d447ecfb72f 100644 --- a/store/tikv/txn.go +++ b/store/tikv/txn.go @@ -115,12 +115,12 @@ func (txn *tikvTxn) String() string { return fmt.Sprintf("%d", txn.StartTS()) } -func (txn *tikvTxn) Seek(k kv.Key) (kv.Iterator, error) { +func (txn *tikvTxn) Seek(k kv.Key, upperBound *kv.Key) (kv.Iterator, error) { metrics.TiKVTxnCmdCounter.WithLabelValues("seek").Inc() start := time.Now() defer func() { metrics.TiKVTxnCmdHistogram.WithLabelValues("seek").Observe(time.Since(start).Seconds()) }() - return txn.us.Seek(k) + return txn.us.Seek(k, upperBound) } // SeekReverse creates a reversed Iterator positioned on the first entry which key is less than k. diff --git a/structure/hash.go b/structure/hash.go index 8b04016c37bc1..fa4dee0317abd 100644 --- a/structure/hash.go +++ b/structure/hash.go @@ -238,7 +238,7 @@ func (t *TxStructure) HClear(key []byte) error { func (t *TxStructure) iterateHash(key []byte, fn func(k []byte, v []byte) error) error { dataPrefix := t.hashDataKeyPrefix(key) - it, err := t.reader.Seek(dataPrefix) + it, err := t.reader.Seek(dataPrefix, nil) if err != nil { return errors.Trace(err) } diff --git a/table/tables/index.go b/table/tables/index.go index e4253d9275537..a32efe38d5ac4 100644 --- a/table/tables/index.go +++ b/table/tables/index.go @@ -240,7 +240,7 @@ func (c *index) Delete(sc *stmtctx.StatementContext, m kv.Mutator, indexedValues // Drop removes the KV index from store. func (c *index) Drop(rm kv.RetrieverMutator) error { - it, err := rm.Seek(c.prefix) + it, err := rm.Seek(c.prefix, nil) if err != nil { return errors.Trace(err) } @@ -270,7 +270,8 @@ func (c *index) Seek(sc *stmtctx.StatementContext, r kv.Retriever, indexedValues return nil, false, errors.Trace(err) } - it, err := r.Seek(key) + upperBound := c.prefix.PrefixNext() + it, err := r.Seek(key, &upperBound) if err != nil { return nil, false, errors.Trace(err) } @@ -284,7 +285,8 @@ func (c *index) Seek(sc *stmtctx.StatementContext, r kv.Retriever, indexedValues // SeekFirst returns an iterator which points to the first entry of the KV index. func (c *index) SeekFirst(r kv.Retriever) (iter table.IndexIterator, err error) { - it, err := r.Seek(c.prefix) + upperBound := c.prefix.PrefixNext() + it, err := r.Seek(c.prefix, &upperBound) if err != nil { return nil, errors.Trace(err) } diff --git a/table/tables/tables.go b/table/tables/tables.go index f244991c5d9cd..08b0174e854d1 100644 --- a/table/tables/tables.go +++ b/table/tables/tables.go @@ -782,7 +782,7 @@ func (t *tableCommon) buildIndexForRow(ctx sessionctx.Context, rm kv.RetrieverMu // IterRecords implements table.Table IterRecords interface. func (t *tableCommon) IterRecords(ctx sessionctx.Context, startKey kv.Key, cols []*table.Column, fn table.RecordIterFunc) error { - it, err := ctx.Txn().Seek(startKey) + it, err := ctx.Txn().Seek(startKey, nil) if err != nil { return errors.Trace(err) } @@ -912,7 +912,7 @@ func (t *tableCommon) RebaseAutoID(ctx sessionctx.Context, newBase int64, isSetS // Seek implements table.Table Seek interface. func (t *tableCommon) Seek(ctx sessionctx.Context, h int64) (int64, bool, error) { seekKey := tablecodec.EncodeRowKeyWithHandle(t.physicalTableID, h) - iter, err := ctx.Txn().Seek(seekKey) + iter, err := ctx.Txn().Seek(seekKey, nil) if !iter.Valid() || !iter.Key().HasPrefix(t.RecordPrefix()) { // No more records in the table, skip to the end. return 0, false, nil diff --git a/util/admin/admin.go b/util/admin/admin.go index a1985bd09a82c..66b301e8f6268 100644 --- a/util/admin/admin.go +++ b/util/admin/admin.go @@ -639,7 +639,10 @@ func rowWithCols(sessCtx sessionctx.Context, txn kv.Retriever, t table.Table, h // genExprs use to calculate generated column value. func iterRecords(sessCtx sessionctx.Context, retriever kv.Retriever, t table.Table, startKey kv.Key, cols []*table.Column, fn table.RecordIterFunc, genExprs map[model.TableColumnID]expression.Expression) error { - it, err := retriever.Seek(startKey) + prefix := t.RecordPrefix() + keyUpperBound := prefix.PrefixNext() + + it, err := retriever.Seek(startKey, &keyUpperBound) if err != nil { return errors.Trace(err) } @@ -651,7 +654,6 @@ func iterRecords(sessCtx sessionctx.Context, retriever kv.Retriever, t table.Tab log.Debugf("startKey:%q, key:%q, value:%q", startKey, it.Key(), it.Value()) rowDecoder := makeRowDecoder(t, cols, genExprs) - prefix := t.RecordPrefix() for it.Valid() && it.Key().HasPrefix(prefix) { // first kv pair is row lock information. // TODO: check valid lock diff --git a/util/prefix_helper.go b/util/prefix_helper.go index ccfd1ece9d633..74d575a35a1ba 100644 --- a/util/prefix_helper.go +++ b/util/prefix_helper.go @@ -26,7 +26,7 @@ import ( // ScanMetaWithPrefix scans metadata with the prefix. func ScanMetaWithPrefix(retriever kv.Retriever, prefix kv.Key, filter func(kv.Key, []byte) bool) error { - iter, err := retriever.Seek(prefix) + iter, err := retriever.Seek(prefix, nil) if err != nil { return errors.Trace(err) } @@ -56,7 +56,7 @@ func ScanMetaWithPrefix(retriever kv.Retriever, prefix kv.Key, filter func(kv.Ke // DelKeyWithPrefix deletes keys with prefix. func DelKeyWithPrefix(rm kv.RetrieverMutator, prefix kv.Key) error { var keys []kv.Key - iter, err := rm.Seek(prefix) + iter, err := rm.Seek(prefix, nil) if err != nil { return errors.Trace(err) } From 399502672f4830b98a7f5df805839f0ed63f6689 Mon Sep 17 00:00:00 2001 From: Breezewish Date: Sun, 2 Sep 2018 14:57:32 +0800 Subject: [PATCH 03/17] fix potential log error --- store/tikv/scan.go | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/store/tikv/scan.go b/store/tikv/scan.go index baa25489151ad..1fdcd5fd57efc 100644 --- a/store/tikv/scan.go +++ b/store/tikv/scan.go @@ -137,11 +137,12 @@ func (s *Scanner) resolveCurrentLock(bo *Backoffer, current *pb.KvPair) error { } func (s *Scanner) getData(bo *Backoffer) error { - log.Debugf("txn getData nextStartKey[%q], txn %d, upperBound %q", s.nextStartKey, s.startTS(), s.upperBound) + log.Debugf("txn getData nextStartKey[%q], txn %d", s.nextStartKey, s.startTS()) sender := NewRegionRequestSender(s.snapshot.store.regionCache, s.snapshot.store.client) for { if s.upperBound != nil { + log.Debugf("txn getData upperBound = %q, nextStartKey = %q", *s.upperBound, s.nextStartKey) if kv.Key(s.nextStartKey).Cmp(*s.upperBound) >= 0 { // nextStartKey >= upperBound s.eof = true From 5c12af20b451e918474bd9e0a36448a880def9f2 Mon Sep 17 00:00:00 2001 From: MyonKeminta Date: Sun, 28 Oct 2018 20:14:52 +0800 Subject: [PATCH 04/17] Use Key directly as the arg type Signed-off-by: MyonKeminta --- ddl/index.go | 2 +- executor/show.go | 24 ++++++++++++------------ infoschema/tables.go | 30 +++++++++++++++--------------- kv/buffer_store.go | 2 +- kv/kv.go | 3 ++- kv/memdb_buffer.go | 2 +- kv/mock.go | 4 ++-- kv/union_store.go | 2 +- session/txn.go | 2 +- store/tikv/scan.go | 18 +++++------------- store/tikv/scan_mock_test.go | 2 +- store/tikv/snapshot.go | 4 ++-- store/tikv/txn.go | 2 +- table/tables/index.go | 4 ++-- util/admin/admin.go | 2 +- 15 files changed, 48 insertions(+), 55 deletions(-) diff --git a/ddl/index.go b/ddl/index.go index fc9f0e9230409..bc0a39be03238 100644 --- a/ddl/index.go +++ b/ddl/index.go @@ -1217,7 +1217,7 @@ func iterateSnapshotRows(store kv.Storage, priority int, t table.Table, version } firstKey := t.RecordKey(seekHandle) upperBound := firstKey.PrefixNext() - it, err := snap.Seek(firstKey, &upperBound) + it, err := snap.Seek(firstKey, upperBound) if err != nil { return errors.Trace(err) } diff --git a/executor/show.go b/executor/show.go index e568fd447ad4c..a959a30aa9457 100644 --- a/executor/show.go +++ b/executor/show.go @@ -379,19 +379,19 @@ func (e *ShowExec) fetchShowIndex() error { subPart = col.Length } e.appendRow([]interface{}{ - tb.Meta().Name.O, // Table - nonUniq, // Non_unique - idx.Meta().Name.O, // Key_name - i + 1, // Seq_in_index - col.Name.O, // Column_name - "A", // Collation - 0, // Cardinality - subPart, // Sub_part - nil, // Packed - "YES", // Null + tb.Meta().Name.O, // Table + nonUniq, // Non_unique + idx.Meta().Name.O, // Key_name + i + 1, // Seq_in_index + col.Name.O, // Column_name + "A", // Collation + 0, // Cardinality + subPart, // Sub_part + nil, // Packed + "YES", // Null idx.Meta().Tp.String(), // Index_type - "", // Comment - idx.Meta().Comment, // Index_comment + "", // Comment + idx.Meta().Comment, // Index_comment }) } } diff --git a/infoschema/tables.go b/infoschema/tables.go index 5ebc01ed3649f..f7cabdcedcb2d 100644 --- a/infoschema/tables.go +++ b/infoschema/tables.go @@ -1168,24 +1168,24 @@ func dataForTableConstraints(schemas []*model.DBInfo) [][]types.Datum { func dataForPseudoProfiling() [][]types.Datum { var rows [][]types.Datum row := types.MakeDatums( - 0, // QUERY_ID - 0, // SEQ - "", // STATE + 0, // QUERY_ID + 0, // SEQ + "", // STATE types.NewDecFromInt(0), // DURATION types.NewDecFromInt(0), // CPU_USER types.NewDecFromInt(0), // CPU_SYSTEM - 0, // CONTEXT_VOLUNTARY - 0, // CONTEXT_INVOLUNTARY - 0, // BLOCK_OPS_IN - 0, // BLOCK_OPS_OUT - 0, // MESSAGES_SENT - 0, // MESSAGES_RECEIVED - 0, // PAGE_FAULTS_MAJOR - 0, // PAGE_FAULTS_MINOR - 0, // SWAPS - 0, // SOURCE_FUNCTION - 0, // SOURCE_FILE - 0, // SOURCE_LINE + 0, // CONTEXT_VOLUNTARY + 0, // CONTEXT_INVOLUNTARY + 0, // BLOCK_OPS_IN + 0, // BLOCK_OPS_OUT + 0, // MESSAGES_SENT + 0, // MESSAGES_RECEIVED + 0, // PAGE_FAULTS_MAJOR + 0, // PAGE_FAULTS_MINOR + 0, // SWAPS + 0, // SOURCE_FUNCTION + 0, // SOURCE_FILE + 0, // SOURCE_LINE ) rows = append(rows, row) return rows diff --git a/kv/buffer_store.go b/kv/buffer_store.go index a890517f286d3..af05ead1aecca 100644 --- a/kv/buffer_store.go +++ b/kv/buffer_store.go @@ -75,7 +75,7 @@ func (s *BufferStore) Get(k Key) ([]byte, error) { } // Seek implements the Retriever interface. -func (s *BufferStore) Seek(k Key, upperBound *Key) (Iterator, error) { +func (s *BufferStore) Seek(k Key, upperBound Key) (Iterator, error) { bufferIt, err := s.MemBuffer.Seek(k, upperBound) if err != nil { return nil, errors.Trace(err) diff --git a/kv/kv.go b/kv/kv.go index 0660bf00b70df..98d00dc1b0c15 100644 --- a/kv/kv.go +++ b/kv/kv.go @@ -81,8 +81,9 @@ type Retriever interface { Get(k Key) ([]byte, error) // Seek creates an Iterator positioned on the first entry that k <= entry's key. // If such entry is not found, it returns an invalid Iterator with no error. + // It yields only keys that < upperBound. If upperBound is nil, it means the upperBound is unbounded. // The Iterator must be Closed after use. - Seek(k Key, upperBound *Key) (Iterator, error) + Seek(k Key, upperBound Key) (Iterator, error) // SeekReverse creates a reversed Iterator positioned on the first entry which key is less than k. // The returned iterator will iterate from greater key to smaller key. diff --git a/kv/memdb_buffer.go b/kv/memdb_buffer.go index 51f15ea3aab14..119a118781f92 100644 --- a/kv/memdb_buffer.go +++ b/kv/memdb_buffer.go @@ -51,7 +51,7 @@ func NewMemDbBuffer(cap int) MemBuffer { } // Seek creates an Iterator. -func (m *memDbBuffer) Seek(k Key, upperBound *Key) (Iterator, error) { +func (m *memDbBuffer) Seek(k Key, upperBound Key) (Iterator, error) { var i Iterator if k == nil { i = &memDbIter{iter: m.db.NewIterator(&util.Range{}), reverse: false} diff --git a/kv/mock.go b/kv/mock.go index 3dd12abfacdc6..77d9855d77c8b 100644 --- a/kv/mock.go +++ b/kv/mock.go @@ -68,7 +68,7 @@ func (t *mockTxn) Get(k Key) ([]byte, error) { return nil, nil } -func (t *mockTxn) Seek(k Key, upperBound *Key) (Iterator, error) { +func (t *mockTxn) Seek(k Key, upperBound Key) (Iterator, error) { return nil, nil } @@ -211,7 +211,7 @@ func (s *mockSnapshot) BatchGet(keys []Key) (map[string][]byte, error) { return m, nil } -func (s *mockSnapshot) Seek(k Key, upperBound *Key) (Iterator, error) { +func (s *mockSnapshot) Seek(k Key, upperBound Key) (Iterator, error) { return s.store.Seek(k, upperBound) } diff --git a/kv/union_store.go b/kv/union_store.go index 768d8f50217de..f29e947f2672d 100644 --- a/kv/union_store.go +++ b/kv/union_store.go @@ -127,7 +127,7 @@ func (lmb *lazyMemBuffer) Delete(k Key) error { return lmb.mb.Delete(k) } -func (lmb *lazyMemBuffer) Seek(k Key, upperBound *Key) (Iterator, error) { +func (lmb *lazyMemBuffer) Seek(k Key, upperBound Key) (Iterator, error) { if lmb.mb == nil { return invalidIterator{}, nil } diff --git a/session/txn.go b/session/txn.go index e663411122290..df7b1de0d7a72 100644 --- a/session/txn.go +++ b/session/txn.go @@ -160,7 +160,7 @@ func (st *TxnState) Delete(k kv.Key) error { } // Seek overrides the Transaction interface. -func (st *TxnState) Seek(k kv.Key, upperBound *kv.Key) (kv.Iterator, error) { +func (st *TxnState) Seek(k kv.Key, upperBound kv.Key) (kv.Iterator, error) { bufferIt, err := st.buf.Seek(k, upperBound) if err != nil { return nil, errors.Trace(err) diff --git a/store/tikv/scan.go b/store/tikv/scan.go index 1fdcd5fd57efc..9dc10aad6f80f 100644 --- a/store/tikv/scan.go +++ b/store/tikv/scan.go @@ -30,11 +30,11 @@ type Scanner struct { cache []*pb.KvPair idx int nextStartKey []byte + endKey []byte eof bool - upperBound *kv.Key } -func newScanner(snapshot *tikvSnapshot, startKey []byte, batchSize int, upperBound *kv.Key) (*Scanner, error) { +func newScanner(snapshot *tikvSnapshot, startKey []byte, endKey []byte, batchSize int) (*Scanner, error) { // It must be > 1. Otherwise scanner won't skipFirst. if batchSize <= 1 { batchSize = scanBatchSize @@ -44,7 +44,7 @@ func newScanner(snapshot *tikvSnapshot, startKey []byte, batchSize int, upperBou batchSize: batchSize, valid: true, nextStartKey: startKey, - upperBound: upperBound, + endKey: endKey, } err := scanner.Next() if kv.IsErrNotFound(err) { @@ -141,15 +141,6 @@ func (s *Scanner) getData(bo *Backoffer) error { sender := NewRegionRequestSender(s.snapshot.store.regionCache, s.snapshot.store.client) for { - if s.upperBound != nil { - log.Debugf("txn getData upperBound = %q, nextStartKey = %q", *s.upperBound, s.nextStartKey) - if kv.Key(s.nextStartKey).Cmp(*s.upperBound) >= 0 { - // nextStartKey >= upperBound - s.eof = true - return nil - } - } - loc, err := s.snapshot.store.regionCache.LocateKey(bo, s.nextStartKey) if err != nil { return errors.Trace(err) @@ -158,6 +149,7 @@ func (s *Scanner) getData(bo *Backoffer) error { Type: tikvrpc.CmdScan, Scan: &pb.ScanRequest{ StartKey: s.nextStartKey, + EndKey: s.endKey, Limit: uint32(s.batchSize), Version: s.startTS(), KeyOnly: s.snapshot.keyOnly, @@ -210,7 +202,7 @@ func (s *Scanner) getData(bo *Backoffer) error { // No more data in current Region. Next getData() starts // from current Region's endKey. s.nextStartKey = loc.EndKey - if len(loc.EndKey) == 0 { + if len(loc.EndKey) == 0 || (s.endKey != nil && kv.Key(s.nextStartKey).Cmp(kv.Key(s.endKey)) >= 0) { // Current Region is the last one. s.eof = true } diff --git a/store/tikv/scan_mock_test.go b/store/tikv/scan_mock_test.go index 9f2f282ba53fc..ad5d377fd448f 100644 --- a/store/tikv/scan_mock_test.go +++ b/store/tikv/scan_mock_test.go @@ -41,7 +41,7 @@ func (s *testScanMockSuite) TestScanMultipleRegions(c *C) { txn, err = store.Begin() c.Assert(err, IsNil) snapshot := newTiKVSnapshot(store, kv.Version{Ver: txn.StartTS()}) - scanner, err := newScanner(snapshot, []byte("a"), 10, nil) + scanner, err := newScanner(snapshot, []byte("a"), nil, 10) c.Assert(err, IsNil) for ch := byte('a'); ch <= byte('z'); ch++ { c.Assert([]byte{ch}, BytesEquals, []byte(scanner.Key())) diff --git a/store/tikv/snapshot.go b/store/tikv/snapshot.go index dc91aadfbd677..71ac1de0151e8 100644 --- a/store/tikv/snapshot.go +++ b/store/tikv/snapshot.go @@ -279,8 +279,8 @@ func (s *tikvSnapshot) get(bo *Backoffer, k kv.Key) ([]byte, error) { } // Seek return a list of key-value pair after `k`. -func (s *tikvSnapshot) Seek(k kv.Key, upperBound *kv.Key) (kv.Iterator, error) { - scanner, err := newScanner(s, k, scanBatchSize, upperBound) +func (s *tikvSnapshot) Seek(k kv.Key, upperBound kv.Key) (kv.Iterator, error) { + scanner, err := newScanner(s, k, upperBound, scanBatchSize) return scanner, errors.Trace(err) } diff --git a/store/tikv/txn.go b/store/tikv/txn.go index 10d447ecfb72f..0821c676c964b 100644 --- a/store/tikv/txn.go +++ b/store/tikv/txn.go @@ -115,7 +115,7 @@ func (txn *tikvTxn) String() string { return fmt.Sprintf("%d", txn.StartTS()) } -func (txn *tikvTxn) Seek(k kv.Key, upperBound *kv.Key) (kv.Iterator, error) { +func (txn *tikvTxn) Seek(k kv.Key, upperBound kv.Key) (kv.Iterator, error) { metrics.TiKVTxnCmdCounter.WithLabelValues("seek").Inc() start := time.Now() defer func() { metrics.TiKVTxnCmdHistogram.WithLabelValues("seek").Observe(time.Since(start).Seconds()) }() diff --git a/table/tables/index.go b/table/tables/index.go index a32efe38d5ac4..3c0a73d12964b 100644 --- a/table/tables/index.go +++ b/table/tables/index.go @@ -271,7 +271,7 @@ func (c *index) Seek(sc *stmtctx.StatementContext, r kv.Retriever, indexedValues } upperBound := c.prefix.PrefixNext() - it, err := r.Seek(key, &upperBound) + it, err := r.Seek(key, upperBound) if err != nil { return nil, false, errors.Trace(err) } @@ -286,7 +286,7 @@ func (c *index) Seek(sc *stmtctx.StatementContext, r kv.Retriever, indexedValues // SeekFirst returns an iterator which points to the first entry of the KV index. func (c *index) SeekFirst(r kv.Retriever) (iter table.IndexIterator, err error) { upperBound := c.prefix.PrefixNext() - it, err := r.Seek(c.prefix, &upperBound) + it, err := r.Seek(c.prefix, upperBound) if err != nil { return nil, errors.Trace(err) } diff --git a/util/admin/admin.go b/util/admin/admin.go index 66b301e8f6268..fb915c8968c87 100644 --- a/util/admin/admin.go +++ b/util/admin/admin.go @@ -642,7 +642,7 @@ func iterRecords(sessCtx sessionctx.Context, retriever kv.Retriever, t table.Tab prefix := t.RecordPrefix() keyUpperBound := prefix.PrefixNext() - it, err := retriever.Seek(startKey, &keyUpperBound) + it, err := retriever.Seek(startKey, keyUpperBound) if err != nil { return errors.Trace(err) } From 3d118e380c15a8f126e317831d7d6e7aa7941aec Mon Sep 17 00:00:00 2001 From: MyonKeminta Date: Sun, 28 Oct 2018 21:04:51 +0800 Subject: [PATCH 05/17] Rename Seek to Iter Signed-off-by: MyonKeminta --- ddl/db_test.go | 4 ++-- ddl/delete_range.go | 2 +- ddl/index.go | 2 +- kv/buffer_store.go | 16 ++++++++-------- kv/buffer_store_test.go | 2 +- kv/kv.go | 9 +++++---- kv/mem_buffer_test.go | 20 ++++++++++---------- kv/memdb_buffer.go | 8 ++++---- kv/mock.go | 12 ++++++------ kv/mock_test.go | 4 ++-- kv/union_store.go | 8 ++++---- kv/union_store_test.go | 18 +++++++++--------- session/txn.go | 16 ++++++++-------- store/store_test.go | 28 ++++++++++++++-------------- store/tikv/delete_range_test.go | 2 +- store/tikv/lock_test.go | 4 ++-- store/tikv/safepoint_test.go | 2 +- store/tikv/scan_test.go | 8 ++++---- store/tikv/snapshot.go | 8 ++++---- store/tikv/snapshot_test.go | 4 ++-- store/tikv/store_test.go | 2 +- store/tikv/ticlient_test.go | 4 ++-- store/tikv/txn.go | 10 +++++----- structure/hash.go | 2 +- table/tables/index.go | 6 +++--- table/tables/tables.go | 4 ++-- util/admin/admin.go | 2 +- util/prefix_helper.go | 4 ++-- 28 files changed, 106 insertions(+), 105 deletions(-) diff --git a/ddl/db_test.go b/ddl/db_test.go index 2c8194c9c75cf..40e506c0694b2 100644 --- a/ddl/db_test.go +++ b/ddl/db_test.go @@ -1877,7 +1877,7 @@ func (s *testDBSuite) TestTruncateTable(c *C) { hasOldTableData := true for i := 0; i < waitForCleanDataRound; i++ { err = kv.RunInNewTxn(s.store, false, func(txn kv.Transaction) error { - it, err1 := txn.Seek(tablePrefix, nil) + it, err1 := txn.Iter(tablePrefix, nil) if err1 != nil { return err1 } @@ -2893,7 +2893,7 @@ func checkPartitionDelRangeDone(c *C, s *testDBSuite, partitionPrefix kv.Key) bo hasOldPartitionData := true for i := 0; i < waitForCleanDataRound; i++ { err := kv.RunInNewTxn(s.store, false, func(txn kv.Transaction) error { - it, err := txn.Seek(partitionPrefix, nil) + it, err := txn.Iter(partitionPrefix, nil) if err != nil { return err } diff --git a/ddl/delete_range.go b/ddl/delete_range.go index 43bfd21742684..10eac364b29e0 100644 --- a/ddl/delete_range.go +++ b/ddl/delete_range.go @@ -154,7 +154,7 @@ func (dr *delRange) doTask(ctx sessionctx.Context, r util.DelRangeTask) error { finish := true dr.keys = dr.keys[:0] err := kv.RunInNewTxn(dr.store, false, func(txn kv.Transaction) error { - iter, err := txn.Seek(oldStartKey, nil) + iter, err := txn.Iter(oldStartKey, nil) if err != nil { return errors.Trace(err) } diff --git a/ddl/index.go b/ddl/index.go index bc0a39be03238..8ce46f7977063 100644 --- a/ddl/index.go +++ b/ddl/index.go @@ -1217,7 +1217,7 @@ func iterateSnapshotRows(store kv.Storage, priority int, t table.Table, version } firstKey := t.RecordKey(seekHandle) upperBound := firstKey.PrefixNext() - it, err := snap.Seek(firstKey, upperBound) + it, err := snap.Iter(firstKey, upperBound) if err != nil { return errors.Trace(err) } diff --git a/kv/buffer_store.go b/kv/buffer_store.go index af05ead1aecca..2317a0f324437 100644 --- a/kv/buffer_store.go +++ b/kv/buffer_store.go @@ -74,26 +74,26 @@ func (s *BufferStore) Get(k Key) ([]byte, error) { return val, nil } -// Seek implements the Retriever interface. -func (s *BufferStore) Seek(k Key, upperBound Key) (Iterator, error) { - bufferIt, err := s.MemBuffer.Seek(k, upperBound) +// Iter implements the Retriever interface. +func (s *BufferStore) Iter(k Key, upperBound Key) (Iterator, error) { + bufferIt, err := s.MemBuffer.Iter(k, upperBound) if err != nil { return nil, errors.Trace(err) } - retrieverIt, err := s.r.Seek(k, upperBound) + retrieverIt, err := s.r.Iter(k, upperBound) if err != nil { return nil, errors.Trace(err) } return NewUnionIter(bufferIt, retrieverIt, false) } -// SeekReverse implements the Retriever interface. -func (s *BufferStore) SeekReverse(k Key) (Iterator, error) { - bufferIt, err := s.MemBuffer.SeekReverse(k) +// IterReverse implements the Retriever interface. +func (s *BufferStore) IterReverse(k Key) (Iterator, error) { + bufferIt, err := s.MemBuffer.IterReverse(k) if err != nil { return nil, errors.Trace(err) } - retrieverIt, err := s.r.SeekReverse(k) + retrieverIt, err := s.r.IterReverse(k) if err != nil { return nil, errors.Trace(err) } diff --git a/kv/buffer_store_test.go b/kv/buffer_store_test.go index 4777cb84527ee..1af716011c2a4 100644 --- a/kv/buffer_store_test.go +++ b/kv/buffer_store_test.go @@ -53,7 +53,7 @@ func (s testBufferStoreSuite) TestSaveTo(c *C) { err := bs.SaveTo(mutator) c.Check(err, IsNil) - iter, err := mutator.Seek(nil, nil) + iter, err := mutator.Iter(nil, nil) c.Check(err, IsNil) for iter.Valid() { cmp := bytes.Compare(iter.Key(), iter.Value()) diff --git a/kv/kv.go b/kv/kv.go index 98d00dc1b0c15..84e0ea8fd07f5 100644 --- a/kv/kv.go +++ b/kv/kv.go @@ -79,16 +79,17 @@ type Retriever interface { // Get gets the value for key k from kv store. // If corresponding kv pair does not exist, it returns nil and ErrNotExist. Get(k Key) ([]byte, error) - // Seek creates an Iterator positioned on the first entry that k <= entry's key. + // Iter creates an Iterator positioned on the first entry that k <= entry's key. // If such entry is not found, it returns an invalid Iterator with no error. // It yields only keys that < upperBound. If upperBound is nil, it means the upperBound is unbounded. // The Iterator must be Closed after use. - Seek(k Key, upperBound Key) (Iterator, error) + Iter(k Key, upperBound Key) (Iterator, error) - // SeekReverse creates a reversed Iterator positioned on the first entry which key is less than k. + // IterReverse creates a reversed Iterator positioned on the first entry which key is less than k. // The returned iterator will iterate from greater key to smaller key. // If k is nil, the returned iterator will be positioned at the last key. - SeekReverse(k Key) (Iterator, error) + // TODO: Add lower bound limit + IterReverse(k Key) (Iterator, error) } // Mutator is the interface wraps the basic Set and Delete methods. diff --git a/kv/mem_buffer_test.go b/kv/mem_buffer_test.go index d5eec355abbd3..e7ec5a1f4f9e6 100644 --- a/kv/mem_buffer_test.go +++ b/kv/mem_buffer_test.go @@ -76,7 +76,7 @@ func valToStr(c *C, iter Iterator) string { func checkNewIterator(c *C, buffer MemBuffer) { for i := startIndex; i < testCount; i++ { val := encodeInt(i * indexStep) - iter, err := buffer.Seek(val, nil) + iter, err := buffer.Iter(val, nil) c.Assert(err, IsNil) c.Assert([]byte(iter.Key()), BytesEquals, val) c.Assert(decodeInt([]byte(valToStr(c, iter))), Equals, i*indexStep) @@ -86,7 +86,7 @@ func checkNewIterator(c *C, buffer MemBuffer) { // Test iterator Next() for i := startIndex; i < testCount-1; i++ { val := encodeInt(i * indexStep) - iter, err := buffer.Seek(val, nil) + iter, err := buffer.Iter(val, nil) c.Assert(err, IsNil) c.Assert([]byte(iter.Key()), BytesEquals, val) c.Assert(valToStr(c, iter), Equals, string(val)) @@ -102,7 +102,7 @@ func checkNewIterator(c *C, buffer MemBuffer) { } // Non exist and beyond maximum seek test - iter, err := buffer.Seek(encodeInt(testCount*indexStep), nil) + iter, err := buffer.Iter(encodeInt(testCount*indexStep), nil) c.Assert(err, IsNil) c.Assert(iter.Valid(), IsFalse) @@ -110,7 +110,7 @@ func checkNewIterator(c *C, buffer MemBuffer) { // it returns the smallest key that larger than the one we are seeking inBetween := encodeInt((testCount-1)*indexStep - 1) last := encodeInt((testCount - 1) * indexStep) - iter, err = buffer.Seek(inBetween, nil) + iter, err = buffer.Iter(inBetween, nil) c.Assert(err, IsNil) c.Assert(iter.Valid(), IsTrue) c.Assert([]byte(iter.Key()), Not(BytesEquals), inBetween) @@ -140,7 +140,7 @@ func (s *testKVSuite) TestNewIterator(c *C) { defer testleak.AfterTest(c)() for _, buffer := range s.bs { // should be invalid - iter, err := buffer.Seek(nil, nil) + iter, err := buffer.Iter(nil, nil) c.Assert(err, IsNil) c.Assert(iter.Valid(), IsFalse) @@ -155,7 +155,7 @@ func (s *testKVSuite) TestIterNextUntil(c *C) { buffer := NewMemDbBuffer(DefaultTxnMembufCap) insertData(c, buffer) - iter, err := buffer.Seek(nil, nil) + iter, err := buffer.Iter(nil, nil) c.Assert(err, IsNil) err = NextUntil(iter, func(k Key) bool { @@ -168,7 +168,7 @@ func (s *testKVSuite) TestIterNextUntil(c *C) { func (s *testKVSuite) TestBasicNewIterator(c *C) { defer testleak.AfterTest(c)() for _, buffer := range s.bs { - it, err := buffer.Seek([]byte("2"), nil) + it, err := buffer.Iter([]byte("2"), nil) c.Assert(err, IsNil) c.Assert(it.Valid(), IsFalse) } @@ -193,7 +193,7 @@ func (s *testKVSuite) TestNewIteratorMin(c *C) { } cnt := 0 - it, err := buffer.Seek(nil, nil) + it, err := buffer.Iter(nil, nil) c.Assert(err, IsNil) for it.Valid() { cnt++ @@ -201,7 +201,7 @@ func (s *testKVSuite) TestNewIteratorMin(c *C) { } c.Assert(cnt, Equals, 6) - it, err = buffer.Seek([]byte("DATA_test_main_db_tbl_tbl_test_record__00000000000000000000"), nil) + it, err = buffer.Iter([]byte("DATA_test_main_db_tbl_tbl_test_record__00000000000000000000"), nil) c.Assert(err, IsNil) c.Assert(string(it.Key()), Equals, "DATA_test_main_db_tbl_tbl_test_record__00000000000000000001") } @@ -294,7 +294,7 @@ func benchIterator(b *testing.B, buffer MemBuffer) { } b.ResetTimer() for i := 0; i < b.N; i++ { - iter, err := buffer.Seek(nil, nil) + iter, err := buffer.Iter(nil, nil) if err != nil { b.Error(err) } diff --git a/kv/memdb_buffer.go b/kv/memdb_buffer.go index 119a118781f92..3e756eab62683 100644 --- a/kv/memdb_buffer.go +++ b/kv/memdb_buffer.go @@ -50,8 +50,8 @@ func NewMemDbBuffer(cap int) MemBuffer { } } -// Seek creates an Iterator. -func (m *memDbBuffer) Seek(k Key, upperBound Key) (Iterator, error) { +// Iter creates an Iterator. +func (m *memDbBuffer) Iter(k Key, upperBound Key) (Iterator, error) { var i Iterator if k == nil { i = &memDbIter{iter: m.db.NewIterator(&util.Range{}), reverse: false} @@ -69,7 +69,7 @@ func (m *memDbBuffer) SetCap(cap int) { } -func (m *memDbBuffer) SeekReverse(k Key) (Iterator, error) { +func (m *memDbBuffer) IterReverse(k Key) (Iterator, error) { var i *memDbIter if k == nil { i = &memDbIter{iter: m.db.NewIterator(&util.Range{}), reverse: true} @@ -161,7 +161,7 @@ func (i *memDbIter) Close() { // WalkMemBuffer iterates all buffered kv pairs in memBuf func WalkMemBuffer(memBuf MemBuffer, f func(k Key, v []byte) error) error { - iter, err := memBuf.Seek(nil, nil) + iter, err := memBuf.Iter(nil, nil) if err != nil { return errors.Trace(err) } diff --git a/kv/mock.go b/kv/mock.go index 77d9855d77c8b..6fc5a1ed52508 100644 --- a/kv/mock.go +++ b/kv/mock.go @@ -68,11 +68,11 @@ func (t *mockTxn) Get(k Key) ([]byte, error) { return nil, nil } -func (t *mockTxn) Seek(k Key, upperBound Key) (Iterator, error) { +func (t *mockTxn) Iter(k Key, upperBound Key) (Iterator, error) { return nil, nil } -func (t *mockTxn) SeekReverse(k Key) (Iterator, error) { +func (t *mockTxn) IterReverse(k Key) (Iterator, error) { return nil, nil } @@ -211,10 +211,10 @@ func (s *mockSnapshot) BatchGet(keys []Key) (map[string][]byte, error) { return m, nil } -func (s *mockSnapshot) Seek(k Key, upperBound Key) (Iterator, error) { - return s.store.Seek(k, upperBound) +func (s *mockSnapshot) Iter(k Key, upperBound Key) (Iterator, error) { + return s.store.Iter(k, upperBound) } -func (s *mockSnapshot) SeekReverse(k Key) (Iterator, error) { - return s.store.SeekReverse(k) +func (s *mockSnapshot) IterReverse(k Key) (Iterator, error) { + return s.store.IterReverse(k) } diff --git a/kv/mock_test.go b/kv/mock_test.go index 9c51d0864f970..2c1db84cf8a97 100644 --- a/kv/mock_test.go +++ b/kv/mock_test.go @@ -46,8 +46,8 @@ func (s testMockSuite) TestInterface(c *C) { if transaction.IsReadOnly() { transaction.Get(Key("lock")) transaction.Set(Key("lock"), []byte{}) - transaction.Seek(Key("lock"), nil) - transaction.SeekReverse(Key("lock")) + transaction.Iter(Key("lock"), nil) + transaction.IterReverse(Key("lock")) } transaction.Commit(context.Background()) diff --git a/kv/union_store.go b/kv/union_store.go index f29e947f2672d..82e3a96223334 100644 --- a/kv/union_store.go +++ b/kv/union_store.go @@ -127,18 +127,18 @@ func (lmb *lazyMemBuffer) Delete(k Key) error { return lmb.mb.Delete(k) } -func (lmb *lazyMemBuffer) Seek(k Key, upperBound Key) (Iterator, error) { +func (lmb *lazyMemBuffer) Iter(k Key, upperBound Key) (Iterator, error) { if lmb.mb == nil { return invalidIterator{}, nil } - return lmb.mb.Seek(k, upperBound) + return lmb.mb.Iter(k, upperBound) } -func (lmb *lazyMemBuffer) SeekReverse(k Key) (Iterator, error) { +func (lmb *lazyMemBuffer) IterReverse(k Key) (Iterator, error) { if lmb.mb == nil { return invalidIterator{}, nil } - return lmb.mb.SeekReverse(k) + return lmb.mb.IterReverse(k) } func (lmb *lazyMemBuffer) Size() int { diff --git a/kv/union_store_test.go b/kv/union_store_test.go index 860c2a3f2fc3b..3297b14f969bc 100644 --- a/kv/union_store_test.go +++ b/kv/union_store_test.go @@ -63,46 +63,46 @@ func (s *testUnionStoreSuite) TestSeek(c *C) { s.store.Set([]byte("2"), []byte("2")) s.store.Set([]byte("3"), []byte("3")) - iter, err := s.us.Seek(nil, nil) + iter, err := s.us.Iter(nil, nil) c.Assert(err, IsNil) checkIterator(c, iter, [][]byte{[]byte("1"), []byte("2"), []byte("3")}, [][]byte{[]byte("1"), []byte("2"), []byte("3")}) - iter, err = s.us.Seek([]byte("2"), nil) + iter, err = s.us.Iter([]byte("2"), nil) c.Assert(err, IsNil) checkIterator(c, iter, [][]byte{[]byte("2"), []byte("3")}, [][]byte{[]byte("2"), []byte("3")}) s.us.Set([]byte("4"), []byte("4")) - iter, err = s.us.Seek([]byte("2"), nil) + iter, err = s.us.Iter([]byte("2"), nil) c.Assert(err, IsNil) checkIterator(c, iter, [][]byte{[]byte("2"), []byte("3"), []byte("4")}, [][]byte{[]byte("2"), []byte("3"), []byte("4")}) s.us.Delete([]byte("3")) - iter, err = s.us.Seek([]byte("2"), nil) + iter, err = s.us.Iter([]byte("2"), nil) c.Assert(err, IsNil) checkIterator(c, iter, [][]byte{[]byte("2"), []byte("4")}, [][]byte{[]byte("2"), []byte("4")}) } -func (s *testUnionStoreSuite) TestSeekReverse(c *C) { +func (s *testUnionStoreSuite) TestIterReverse(c *C) { defer testleak.AfterTest(c)() s.store.Set([]byte("1"), []byte("1")) s.store.Set([]byte("2"), []byte("2")) s.store.Set([]byte("3"), []byte("3")) - iter, err := s.us.SeekReverse(nil) + iter, err := s.us.IterReverse(nil) c.Assert(err, IsNil) checkIterator(c, iter, [][]byte{[]byte("3"), []byte("2"), []byte("1")}, [][]byte{[]byte("3"), []byte("2"), []byte("1")}) - iter, err = s.us.SeekReverse([]byte("3")) + iter, err = s.us.IterReverse([]byte("3")) c.Assert(err, IsNil) checkIterator(c, iter, [][]byte{[]byte("2"), []byte("1")}, [][]byte{[]byte("2"), []byte("1")}) s.us.Set([]byte("0"), []byte("0")) - iter, err = s.us.SeekReverse([]byte("3")) + iter, err = s.us.IterReverse([]byte("3")) c.Assert(err, IsNil) checkIterator(c, iter, [][]byte{[]byte("2"), []byte("1"), []byte("0")}, [][]byte{[]byte("2"), []byte("1"), []byte("0")}) s.us.Delete([]byte("1")) - iter, err = s.us.SeekReverse([]byte("3")) + iter, err = s.us.IterReverse([]byte("3")) c.Assert(err, IsNil) checkIterator(c, iter, [][]byte{[]byte("2"), []byte("0")}, [][]byte{[]byte("2"), []byte("0")}) } diff --git a/session/txn.go b/session/txn.go index df7b1de0d7a72..6e391335fc966 100644 --- a/session/txn.go +++ b/session/txn.go @@ -159,26 +159,26 @@ func (st *TxnState) Delete(k kv.Key) error { return st.buf.Delete(k) } -// Seek overrides the Transaction interface. -func (st *TxnState) Seek(k kv.Key, upperBound kv.Key) (kv.Iterator, error) { - bufferIt, err := st.buf.Seek(k, upperBound) +// Iter overrides the Transaction interface. +func (st *TxnState) Iter(k kv.Key, upperBound kv.Key) (kv.Iterator, error) { + bufferIt, err := st.buf.Iter(k, upperBound) if err != nil { return nil, errors.Trace(err) } - retrieverIt, err := st.Transaction.Seek(k, upperBound) + retrieverIt, err := st.Transaction.Iter(k, upperBound) if err != nil { return nil, errors.Trace(err) } return kv.NewUnionIter(bufferIt, retrieverIt, false) } -// SeekReverse overrides the Transaction interface. -func (st *TxnState) SeekReverse(k kv.Key) (kv.Iterator, error) { - bufferIt, err := st.buf.SeekReverse(k) +// IterReverse overrides the Transaction interface. +func (st *TxnState) IterReverse(k kv.Key) (kv.Iterator, error) { + bufferIt, err := st.buf.IterReverse(k) if err != nil { return nil, errors.Trace(err) } - retrieverIt, err := st.Transaction.SeekReverse(k) + retrieverIt, err := st.Transaction.IterReverse(k) if err != nil { return nil, errors.Trace(err) } diff --git a/store/store_test.go b/store/store_test.go index 2e766e73b9a6e..6fdb11ab58338 100644 --- a/store/store_test.go +++ b/store/store_test.go @@ -97,7 +97,7 @@ func valToStr(c *C, iter kv.Iterator) string { func checkSeek(c *C, txn kv.Transaction) { for i := startIndex; i < testCount; i++ { val := encodeInt(i * indexStep) - iter, err := txn.Seek(val, nil) + iter, err := txn.Iter(val, nil) c.Assert(err, IsNil) c.Assert([]byte(iter.Key()), BytesEquals, val) c.Assert(decodeInt([]byte(valToStr(c, iter))), Equals, i*indexStep) @@ -107,7 +107,7 @@ func checkSeek(c *C, txn kv.Transaction) { // Test iterator Next() for i := startIndex; i < testCount-1; i++ { val := encodeInt(i * indexStep) - iter, err := txn.Seek(val, nil) + iter, err := txn.Iter(val, nil) c.Assert(err, IsNil) c.Assert([]byte(iter.Key()), BytesEquals, val) c.Assert(valToStr(c, iter), Equals, string(val)) @@ -123,7 +123,7 @@ func checkSeek(c *C, txn kv.Transaction) { } // Non exist and beyond maximum seek test - iter, err := txn.Seek(encodeInt(testCount*indexStep), nil) + iter, err := txn.Iter(encodeInt(testCount*indexStep), nil) c.Assert(err, IsNil) c.Assert(iter.Valid(), IsFalse) @@ -131,7 +131,7 @@ func checkSeek(c *C, txn kv.Transaction) { // it returns the smallest key that larger than the one we are seeking inBetween := encodeInt((testCount-1)*indexStep - 1) last := encodeInt((testCount - 1) * indexStep) - iter, err = txn.Seek(inBetween, nil) + iter, err = txn.Iter(inBetween, nil) c.Assert(err, IsNil) c.Assert(iter.Valid(), IsTrue) c.Assert([]byte(iter.Key()), Not(BytesEquals), inBetween) @@ -278,7 +278,7 @@ func (s *testKVSuite) TestDelete2(c *C) { txn, err = s.s.Begin() c.Assert(err, IsNil) - it, err := txn.Seek([]byte("DATA_test_tbl_department_record__0000000001_0003"), nil) + it, err := txn.Iter([]byte("DATA_test_tbl_department_record__0000000001_0003"), nil) c.Assert(err, IsNil) for it.Valid() { err = txn.Delete([]byte(it.Key())) @@ -290,7 +290,7 @@ func (s *testKVSuite) TestDelete2(c *C) { txn, err = s.s.Begin() c.Assert(err, IsNil) - it, _ = txn.Seek([]byte("DATA_test_tbl_department_record__000000000"), nil) + it, _ = txn.Iter([]byte("DATA_test_tbl_department_record__000000000"), nil) c.Assert(it.Valid(), IsFalse) txn.Commit(context.Background()) } @@ -312,7 +312,7 @@ func (s *testKVSuite) TestBasicSeek(c *C) { c.Assert(err, IsNil) defer txn.Commit(context.Background()) - it, err := txn.Seek([]byte("2"), nil) + it, err := txn.Iter([]byte("2"), nil) c.Assert(err, IsNil) c.Assert(it.Valid(), Equals, false) txn.Delete([]byte("1")) @@ -333,30 +333,30 @@ func (s *testKVSuite) TestBasicTable(c *C) { err = txn.Set([]byte("1"), []byte("1")) c.Assert(err, IsNil) - it, err := txn.Seek([]byte("0"), nil) + it, err := txn.Iter([]byte("0"), nil) c.Assert(err, IsNil) c.Assert(string(it.Key()), Equals, "1") err = txn.Set([]byte("0"), []byte("0")) c.Assert(err, IsNil) - it, err = txn.Seek([]byte("0"), nil) + it, err = txn.Iter([]byte("0"), nil) c.Assert(err, IsNil) c.Assert(string(it.Key()), Equals, "0") err = txn.Delete([]byte("0")) c.Assert(err, IsNil) txn.Delete([]byte("1")) - it, err = txn.Seek([]byte("0"), nil) + it, err = txn.Iter([]byte("0"), nil) c.Assert(err, IsNil) c.Assert(string(it.Key()), Equals, "2") err = txn.Delete([]byte("3")) c.Assert(err, IsNil) - it, err = txn.Seek([]byte("2"), nil) + it, err = txn.Iter([]byte("2"), nil) c.Assert(err, IsNil) c.Assert(string(it.Key()), Equals, "2") - it, err = txn.Seek([]byte("3"), nil) + it, err = txn.Iter([]byte("3"), nil) c.Assert(err, IsNil) c.Assert(string(it.Key()), Equals, "4") err = txn.Delete([]byte("2")) @@ -411,13 +411,13 @@ func (s *testKVSuite) TestSeekMin(c *C) { txn.Set([]byte(row.key), []byte(row.value)) } - it, err := txn.Seek(nil, nil) + it, err := txn.Iter(nil, nil) for it.Valid() { fmt.Printf("%s, %s\n", it.Key(), it.Value()) it.Next() } - it, err = txn.Seek([]byte("DATA_test_main_db_tbl_tbl_test_record__00000000000000000000"), nil) + it, err = txn.Iter([]byte("DATA_test_main_db_tbl_tbl_test_record__00000000000000000000"), nil) c.Assert(err, IsNil) c.Assert(string(it.Key()), Equals, "DATA_test_main_db_tbl_tbl_test_record__00000000000000000001") diff --git a/store/tikv/delete_range_test.go b/store/tikv/delete_range_test.go index 9ae2c64d4ee19..ee0b3c6c73126 100644 --- a/store/tikv/delete_range_test.go +++ b/store/tikv/delete_range_test.go @@ -50,7 +50,7 @@ func (s *testDeleteRangeSuite) TearDownTest(c *C) { func (s *testDeleteRangeSuite) checkData(c *C, expectedData map[string]string) { txn, err := s.store.Begin() c.Assert(err, IsNil) - it, err := txn.Seek([]byte("a"), nil) + it, err := txn.Iter([]byte("a"), nil) c.Assert(err, IsNil) // Scan all data and save into a map diff --git a/store/tikv/lock_test.go b/store/tikv/lock_test.go index 4181cb43abedc..31e0c4597b121 100644 --- a/store/tikv/lock_test.go +++ b/store/tikv/lock_test.go @@ -116,7 +116,7 @@ func (s *testLockSuite) TestScanLockResolveWithSeek(c *C) { txn, err := s.store.Begin() c.Assert(err, IsNil) - iter, err := txn.Seek([]byte("a"), nil) + iter, err := txn.Iter([]byte("a"), nil) c.Assert(err, IsNil) for ch := byte('a'); ch <= byte('z'); ch++ { c.Assert(iter.Valid(), IsTrue) @@ -133,7 +133,7 @@ func (s *testLockSuite) TestScanLockResolveWithSeekKeyOnly(c *C) { txn, err := s.store.Begin() c.Assert(err, IsNil) txn.SetOption(kv.KeyOnly, true) - iter, err := txn.Seek([]byte("a"), nil) + iter, err := txn.Iter([]byte("a"), nil) c.Assert(err, IsNil) for ch := byte('a'); ch <= byte('z'); ch++ { c.Assert(iter.Valid(), IsTrue) diff --git a/store/tikv/safepoint_test.go b/store/tikv/safepoint_test.go index 7c7a26257efa1..975f099bfaece 100644 --- a/store/tikv/safepoint_test.go +++ b/store/tikv/safepoint_test.go @@ -100,7 +100,7 @@ func (s *testSafePointSuite) TestSafePoint(c *C) { s.waitUntilErrorPlugIn(txn3.startTS) - _, seekerr := txn3.Seek(encodeKey(s.prefix, ""), nil) + _, seekerr := txn3.Iter(encodeKey(s.prefix, ""), nil) c.Assert(seekerr, NotNil) isFallBehind = terror.ErrorEqual(errors.Cause(geterr2), ErrGCTooEarly) isMayFallBehind = terror.ErrorEqual(errors.Cause(geterr2), ErrPDServerTimeout.GenWithStackByArgs("start timestamp may fall behind safe point")) diff --git a/store/tikv/scan_test.go b/store/tikv/scan_test.go index 5796f07ba0e0b..e64496ef31e19 100644 --- a/store/tikv/scan_test.go +++ b/store/tikv/scan_test.go @@ -40,7 +40,7 @@ func (s *testScanSuite) SetUpSuite(c *C) { func (s *testScanSuite) TearDownSuite(c *C) { txn := s.beginTxn(c) - scanner, err := txn.Seek(encodeKey(s.prefix, ""), nil) + scanner, err := txn.Iter(encodeKey(s.prefix, ""), nil) c.Assert(err, IsNil) c.Assert(scanner, NotNil) for scanner.Valid() { @@ -76,7 +76,7 @@ func (s *testScanSuite) TestSeek(c *C) { val, err := txn2.Get(encodeKey(s.prefix, s08d("key", 0))) c.Assert(err, IsNil) c.Assert(val, BytesEquals, valueBytes(0)) - scan, err := txn2.Seek(encodeKey(s.prefix, ""), nil) + scan, err := txn2.Iter(encodeKey(s.prefix, ""), nil) c.Assert(err, IsNil) for i := 0; i < rowNum; i++ { @@ -95,7 +95,7 @@ func (s *testScanSuite) TestSeek(c *C) { txn3 := s.beginTxn(c) txn3.SetOption(kv.KeyOnly, true) - scan, err = txn3.Seek(encodeKey(s.prefix, ""), nil) + scan, err = txn3.Iter(encodeKey(s.prefix, ""), nil) c.Assert(err, IsNil) for i := 0; i < rowNum; i++ { @@ -112,7 +112,7 @@ func (s *testScanSuite) TestSeek(c *C) { // Restore KeyOnly to false txn3.SetOption(kv.KeyOnly, false) - scan, err = txn3.Seek(encodeKey(s.prefix, ""), nil) + scan, err = txn3.Iter(encodeKey(s.prefix, ""), nil) c.Assert(err, IsNil) for i := 0; i < rowNum; i++ { diff --git a/store/tikv/snapshot.go b/store/tikv/snapshot.go index 71ac1de0151e8..4480a984a37d8 100644 --- a/store/tikv/snapshot.go +++ b/store/tikv/snapshot.go @@ -278,14 +278,14 @@ func (s *tikvSnapshot) get(bo *Backoffer, k kv.Key) ([]byte, error) { } } -// Seek return a list of key-value pair after `k`. -func (s *tikvSnapshot) Seek(k kv.Key, upperBound kv.Key) (kv.Iterator, error) { +// Iter return a list of key-value pair after `k`. +func (s *tikvSnapshot) Iter(k kv.Key, upperBound kv.Key) (kv.Iterator, error) { scanner, err := newScanner(s, k, upperBound, scanBatchSize) return scanner, errors.Trace(err) } -// SeekReverse creates a reversed Iterator positioned on the first entry which key is less than k. -func (s *tikvSnapshot) SeekReverse(k kv.Key) (kv.Iterator, error) { +// IterReverse creates a reversed Iterator positioned on the first entry which key is less than k. +func (s *tikvSnapshot) IterReverse(k kv.Key) (kv.Iterator, error) { return nil, kv.ErrNotImplemented } diff --git a/store/tikv/snapshot_test.go b/store/tikv/snapshot_test.go index 7bc03676e88fa..61d5da2112863 100644 --- a/store/tikv/snapshot_test.go +++ b/store/tikv/snapshot_test.go @@ -42,7 +42,7 @@ func (s *testSnapshotSuite) SetUpSuite(c *C) { func (s *testSnapshotSuite) TearDownSuite(c *C) { txn := s.beginTxn(c) - scanner, err := txn.Seek(encodeKey(s.prefix, ""), nil) + scanner, err := txn.Iter(encodeKey(s.prefix, ""), nil) c.Assert(err, IsNil) c.Assert(scanner, NotNil) for scanner.Valid() { @@ -70,7 +70,7 @@ func (s *testSnapshotSuite) checkAll(keys []kv.Key, c *C) { m, err := snapshot.BatchGet(keys) c.Assert(err, IsNil) - scan, err := txn.Seek(encodeKey(s.prefix, ""), nil) + scan, err := txn.Iter(encodeKey(s.prefix, ""), nil) c.Assert(err, IsNil) cnt := 0 for scan.Valid() { diff --git a/store/tikv/store_test.go b/store/tikv/store_test.go index 000a085b5821c..116f4b875748e 100644 --- a/store/tikv/store_test.go +++ b/store/tikv/store_test.go @@ -229,7 +229,7 @@ func (s *testStoreSuite) TestRequestPriority(c *C) { // Cover Seek request. client.priority = pb.CommandPri_High txn.SetOption(kv.Priority, kv.PriorityHigh) - iter, err := txn.Seek([]byte("key"), nil) + iter, err := txn.Iter([]byte("key"), nil) c.Assert(err, IsNil) for iter.Valid() { c.Assert(iter.Next(), IsNil) diff --git a/store/tikv/ticlient_test.go b/store/tikv/ticlient_test.go index 3634f788a22ff..e67b9c7562c57 100644 --- a/store/tikv/ticlient_test.go +++ b/store/tikv/ticlient_test.go @@ -61,7 +61,7 @@ func clearStorage(store kv.Storage) error { if err != nil { return errors.Trace(err) } - iter, err := txn.Seek(nil, nil) + iter, err := txn.Iter(nil, nil) if err != nil { return errors.Trace(err) } @@ -93,7 +93,7 @@ func (s *testTiclientSuite) SetUpSuite(c *C) { func (s *testTiclientSuite) TearDownSuite(c *C) { // Clean all data, or it may pollute other data. txn := s.beginTxn(c) - scanner, err := txn.Seek(encodeKey(s.prefix, ""), nil) + scanner, err := txn.Iter(encodeKey(s.prefix, ""), nil) c.Assert(err, IsNil) c.Assert(scanner, NotNil) for scanner.Valid() { diff --git a/store/tikv/txn.go b/store/tikv/txn.go index 0821c676c964b..0297fcb14d967 100644 --- a/store/tikv/txn.go +++ b/store/tikv/txn.go @@ -115,23 +115,23 @@ func (txn *tikvTxn) String() string { return fmt.Sprintf("%d", txn.StartTS()) } -func (txn *tikvTxn) Seek(k kv.Key, upperBound kv.Key) (kv.Iterator, error) { +func (txn *tikvTxn) Iter(k kv.Key, upperBound kv.Key) (kv.Iterator, error) { metrics.TiKVTxnCmdCounter.WithLabelValues("seek").Inc() start := time.Now() defer func() { metrics.TiKVTxnCmdHistogram.WithLabelValues("seek").Observe(time.Since(start).Seconds()) }() - return txn.us.Seek(k, upperBound) + return txn.us.Iter(k, upperBound) } -// SeekReverse creates a reversed Iterator positioned on the first entry which key is less than k. -func (txn *tikvTxn) SeekReverse(k kv.Key) (kv.Iterator, error) { +// IterReverse creates a reversed Iterator positioned on the first entry which key is less than k. +func (txn *tikvTxn) IterReverse(k kv.Key) (kv.Iterator, error) { metrics.TiKVTxnCmdCounter.WithLabelValues("seek_reverse").Inc() start := time.Now() defer func() { metrics.TiKVTxnCmdHistogram.WithLabelValues("seek_reverse").Observe(time.Since(start).Seconds()) }() - return txn.us.SeekReverse(k) + return txn.us.IterReverse(k) } func (txn *tikvTxn) Delete(k kv.Key) error { diff --git a/structure/hash.go b/structure/hash.go index fa4dee0317abd..bfa13118cce8c 100644 --- a/structure/hash.go +++ b/structure/hash.go @@ -238,7 +238,7 @@ func (t *TxStructure) HClear(key []byte) error { func (t *TxStructure) iterateHash(key []byte, fn func(k []byte, v []byte) error) error { dataPrefix := t.hashDataKeyPrefix(key) - it, err := t.reader.Seek(dataPrefix, nil) + it, err := t.reader.Iter(dataPrefix, nil) if err != nil { return errors.Trace(err) } diff --git a/table/tables/index.go b/table/tables/index.go index 3c0a73d12964b..f4c1f84317657 100644 --- a/table/tables/index.go +++ b/table/tables/index.go @@ -240,7 +240,7 @@ func (c *index) Delete(sc *stmtctx.StatementContext, m kv.Mutator, indexedValues // Drop removes the KV index from store. func (c *index) Drop(rm kv.RetrieverMutator) error { - it, err := rm.Seek(c.prefix, nil) + it, err := rm.Iter(c.prefix, nil) if err != nil { return errors.Trace(err) } @@ -271,7 +271,7 @@ func (c *index) Seek(sc *stmtctx.StatementContext, r kv.Retriever, indexedValues } upperBound := c.prefix.PrefixNext() - it, err := r.Seek(key, upperBound) + it, err := r.Iter(key, upperBound) if err != nil { return nil, false, errors.Trace(err) } @@ -286,7 +286,7 @@ func (c *index) Seek(sc *stmtctx.StatementContext, r kv.Retriever, indexedValues // SeekFirst returns an iterator which points to the first entry of the KV index. func (c *index) SeekFirst(r kv.Retriever) (iter table.IndexIterator, err error) { upperBound := c.prefix.PrefixNext() - it, err := r.Seek(c.prefix, upperBound) + it, err := r.Iter(c.prefix, upperBound) if err != nil { return nil, errors.Trace(err) } diff --git a/table/tables/tables.go b/table/tables/tables.go index 08b0174e854d1..34a0e35fc5c4f 100644 --- a/table/tables/tables.go +++ b/table/tables/tables.go @@ -782,7 +782,7 @@ func (t *tableCommon) buildIndexForRow(ctx sessionctx.Context, rm kv.RetrieverMu // IterRecords implements table.Table IterRecords interface. func (t *tableCommon) IterRecords(ctx sessionctx.Context, startKey kv.Key, cols []*table.Column, fn table.RecordIterFunc) error { - it, err := ctx.Txn().Seek(startKey, nil) + it, err := ctx.Txn().Iter(startKey, nil) if err != nil { return errors.Trace(err) } @@ -912,7 +912,7 @@ func (t *tableCommon) RebaseAutoID(ctx sessionctx.Context, newBase int64, isSetS // Seek implements table.Table Seek interface. func (t *tableCommon) Seek(ctx sessionctx.Context, h int64) (int64, bool, error) { seekKey := tablecodec.EncodeRowKeyWithHandle(t.physicalTableID, h) - iter, err := ctx.Txn().Seek(seekKey, nil) + iter, err := ctx.Txn().Iter(seekKey, nil) if !iter.Valid() || !iter.Key().HasPrefix(t.RecordPrefix()) { // No more records in the table, skip to the end. return 0, false, nil diff --git a/util/admin/admin.go b/util/admin/admin.go index fb915c8968c87..37fad8869402f 100644 --- a/util/admin/admin.go +++ b/util/admin/admin.go @@ -642,7 +642,7 @@ func iterRecords(sessCtx sessionctx.Context, retriever kv.Retriever, t table.Tab prefix := t.RecordPrefix() keyUpperBound := prefix.PrefixNext() - it, err := retriever.Seek(startKey, keyUpperBound) + it, err := retriever.Iter(startKey, keyUpperBound) if err != nil { return errors.Trace(err) } diff --git a/util/prefix_helper.go b/util/prefix_helper.go index 74d575a35a1ba..a2c5d76dfd168 100644 --- a/util/prefix_helper.go +++ b/util/prefix_helper.go @@ -26,7 +26,7 @@ import ( // ScanMetaWithPrefix scans metadata with the prefix. func ScanMetaWithPrefix(retriever kv.Retriever, prefix kv.Key, filter func(kv.Key, []byte) bool) error { - iter, err := retriever.Seek(prefix, nil) + iter, err := retriever.Iter(prefix, nil) if err != nil { return errors.Trace(err) } @@ -56,7 +56,7 @@ func ScanMetaWithPrefix(retriever kv.Retriever, prefix kv.Key, filter func(kv.Ke // DelKeyWithPrefix deletes keys with prefix. func DelKeyWithPrefix(rm kv.RetrieverMutator, prefix kv.Key) error { var keys []kv.Key - iter, err := rm.Seek(prefix, nil) + iter, err := rm.Iter(prefix, nil) if err != nil { return errors.Trace(err) } From 4a20ceba1a2f723e91fcdad2f9eb78d6b12f21bb Mon Sep 17 00:00:00 2001 From: MyonKeminta Date: Mon, 29 Oct 2018 16:56:44 +0800 Subject: [PATCH 06/17] Fix tests Signed-off-by: MyonKeminta --- ddl/index.go | 13 +++++++++---- ddl/reorg.go | 2 +- store/mockstore/mocktikv/rpc.go | 6 +++++- store/tikv/scan.go | 2 +- store/tikv/scan_mock_test.go | 8 ++++++++ 5 files changed, 24 insertions(+), 7 deletions(-) diff --git a/ddl/index.go b/ddl/index.go index 8ce46f7977063..42ffa15a04c3a 100644 --- a/ddl/index.go +++ b/ddl/index.go @@ -622,7 +622,11 @@ func (w *addIndexWorker) fetchRowColVals(txn kv.Transaction, taskRange reorgInde // taskDone means that the added handle is out of taskRange.endHandle. taskDone := false oprStartTime := startTime - err := iterateSnapshotRows(w.sessCtx.GetStore(), w.priority, w.table, txn.StartTS(), taskRange.startHandle, + endHandle := taskRange.endHandle + if !taskRange.endIncluded { + endHandle -= 1 + } + err := iterateSnapshotRows(w.sessCtx.GetStore(), w.priority, w.table, txn.StartTS(), taskRange.startHandle, endHandle, func(handle int64, recordKey kv.Key, rawRow []byte) (bool, error) { oprEndTime := time.Now() w.logSlowOperations(oprEndTime.Sub(oprStartTime), "iterateSnapshotRows in fetchRowColVals", 0) @@ -1207,7 +1211,8 @@ func allocateIndexID(tblInfo *model.TableInfo) int64 { // recordIterFunc is used for low-level record iteration. type recordIterFunc func(h int64, rowKey kv.Key, rawRecord []byte) (more bool, err error) -func iterateSnapshotRows(store kv.Storage, priority int, t table.Table, version uint64, seekHandle int64, fn recordIterFunc) error { +// limitHandle is the inclusive upper bound. +func iterateSnapshotRows(store kv.Storage, priority int, t table.Table, version uint64, startHandle int64, endHandle int64, fn recordIterFunc) error { ver := kv.Version{Ver: version} snap, err := store.GetSnapshot(ver) @@ -1215,8 +1220,8 @@ func iterateSnapshotRows(store kv.Storage, priority int, t table.Table, version if err != nil { return errors.Trace(err) } - firstKey := t.RecordKey(seekHandle) - upperBound := firstKey.PrefixNext() + firstKey := t.RecordKey(startHandle) + upperBound := t.RecordKey(endHandle).PrefixNext() it, err := snap.Iter(firstKey, upperBound) if err != nil { return errors.Trace(err) diff --git a/ddl/reorg.go b/ddl/reorg.go index 52b6009d927f2..bce08bce798b3 100644 --- a/ddl/reorg.go +++ b/ddl/reorg.go @@ -304,7 +304,7 @@ func getTableRange(d *ddlCtx, tbl table.PhysicalTable, snapshotVer uint64, prior startHandle = math.MinInt64 endHandle = math.MaxInt64 // Get the start handle of this partition. - err = iterateSnapshotRows(d.store, priority, tbl, snapshotVer, math.MinInt64, + err = iterateSnapshotRows(d.store, priority, tbl, snapshotVer, math.MinInt64, math.MaxInt64, func(h int64, rowKey kv.Key, rawRecord []byte) (bool, error) { startHandle = h return false, nil diff --git a/store/mockstore/mocktikv/rpc.go b/store/mockstore/mocktikv/rpc.go index 34ff33c87c5ec..380974cbed0fe 100644 --- a/store/mockstore/mocktikv/rpc.go +++ b/store/mockstore/mocktikv/rpc.go @@ -229,7 +229,11 @@ func (h *rpcHandler) handleKvScan(req *kvrpcpb.ScanRequest) *kvrpcpb.ScanRespons if !h.checkKeyInRegion(req.GetStartKey()) { panic("KvScan: startKey not in region") } - pairs := h.mvccStore.Scan(req.GetStartKey(), h.endKey, int(req.GetLimit()), req.GetVersion(), h.isolationLevel) + endKey := h.endKey + if len(req.EndKey) > 0 && (len(endKey) == 0 || bytes.Compare(req.EndKey, endKey) < 0) { + endKey = req.EndKey + } + pairs := h.mvccStore.Scan(req.GetStartKey(), endKey, int(req.GetLimit()), req.GetVersion(), h.isolationLevel) return &kvrpcpb.ScanResponse{ Pairs: convertToPbPairs(pairs), } diff --git a/store/tikv/scan.go b/store/tikv/scan.go index 9dc10aad6f80f..933ce8a002c8e 100644 --- a/store/tikv/scan.go +++ b/store/tikv/scan.go @@ -202,7 +202,7 @@ func (s *Scanner) getData(bo *Backoffer) error { // No more data in current Region. Next getData() starts // from current Region's endKey. s.nextStartKey = loc.EndKey - if len(loc.EndKey) == 0 || (s.endKey != nil && kv.Key(s.nextStartKey).Cmp(kv.Key(s.endKey)) >= 0) { + if len(loc.EndKey) == 0 || (len(s.endKey) > 0 && kv.Key(s.nextStartKey).Cmp(kv.Key(s.endKey)) >= 0) { // Current Region is the last one. s.eof = true } diff --git a/store/tikv/scan_mock_test.go b/store/tikv/scan_mock_test.go index ad5d377fd448f..94b720314f2bd 100644 --- a/store/tikv/scan_mock_test.go +++ b/store/tikv/scan_mock_test.go @@ -48,4 +48,12 @@ func (s *testScanMockSuite) TestScanMultipleRegions(c *C) { c.Assert(scanner.Next(), IsNil) } c.Assert(scanner.Valid(), IsFalse) + + scanner, err = newScanner(snapshot, []byte("a"), []byte("i"), 10) + c.Assert(err, IsNil) + for ch := byte('a'); ch <= byte('h'); ch++ { + c.Assert([]byte{ch}, BytesEquals, []byte(scanner.Key())) + c.Assert(scanner.Next(), IsNil) + } + c.Assert(scanner.Valid(), IsFalse) } From 6f92d477cea41dc5c0a62cb8c5de211e83ca144c Mon Sep 17 00:00:00 2001 From: MyonKeminta Date: Mon, 29 Oct 2018 18:25:09 +0800 Subject: [PATCH 07/17] use upperbound in membuffer Signed-off-by: MyonKeminta --- kv/memdb_buffer.go | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/kv/memdb_buffer.go b/kv/memdb_buffer.go index 3e756eab62683..1de19e527af5b 100644 --- a/kv/memdb_buffer.go +++ b/kv/memdb_buffer.go @@ -52,12 +52,8 @@ func NewMemDbBuffer(cap int) MemBuffer { // Iter creates an Iterator. func (m *memDbBuffer) Iter(k Key, upperBound Key) (Iterator, error) { - var i Iterator - if k == nil { - i = &memDbIter{iter: m.db.NewIterator(&util.Range{}), reverse: false} - } else { - i = &memDbIter{iter: m.db.NewIterator(&util.Range{Start: []byte(k)}), reverse: false} - } + i := &memDbIter{iter: m.db.NewIterator(&util.Range{Start: []byte(k), Limit: []byte(upperBound)}), reverse: false} + err := i.Next() if err != nil { return nil, errors.Trace(err) From e64e7c9d485b7615ae422bae93ca5285ca6b0e11 Mon Sep 17 00:00:00 2001 From: MyonKeminta Date: Mon, 5 Nov 2018 16:44:14 +0800 Subject: [PATCH 08/17] Update kvproto Signed-off-by: MyonKeminta --- go.mod | 2 +- go.sum | 2 ++ 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/go.mod b/go.mod index b9bc33169b9c9..8ce29d723c96e 100644 --- a/go.mod +++ b/go.mod @@ -68,7 +68,7 @@ require ( github.com/pingcap/errcode v0.0.0-20180921232412-a1a7271709d9 // indirect github.com/pingcap/errors v0.11.0 github.com/pingcap/goleveldb v0.0.0-20171020122428-b9ff6c35079e - github.com/pingcap/kvproto v0.0.0-20181028030329-855d2192cdc7 + github.com/pingcap/kvproto v0.0.0-20181105061835-1b5d69cd1d26 github.com/pingcap/parser v0.0.0-20181102070703-4acd198f5092 github.com/pingcap/pd v2.1.0-rc.4+incompatible github.com/pingcap/tidb-tools v0.0.0-20181101090416-cfac1096162e diff --git a/go.sum b/go.sum index 7e6637029312b..f97032e4215d2 100644 --- a/go.sum +++ b/go.sum @@ -189,6 +189,8 @@ github.com/pingcap/kvproto v0.0.0-20180930052200-fae11119f066 h1:ulo0ph8sxCzY3GY github.com/pingcap/kvproto v0.0.0-20180930052200-fae11119f066/go.mod h1:0gwbe1F2iBIjuQ9AH0DbQhL+Dpr5GofU8fgYyXk+ykk= github.com/pingcap/kvproto v0.0.0-20181028030329-855d2192cdc7 h1:CYssSnPvf90ZSbFdZpsZGSI7y+drG1EfKxqTOnKnHb0= github.com/pingcap/kvproto v0.0.0-20181028030329-855d2192cdc7/go.mod h1:0gwbe1F2iBIjuQ9AH0DbQhL+Dpr5GofU8fgYyXk+ykk= +github.com/pingcap/kvproto v0.0.0-20181105061835-1b5d69cd1d26 h1:JK4VLNYbSn36QSbCnqALi2ySXdH0DfcMssT/zmLf4Ls= +github.com/pingcap/kvproto v0.0.0-20181105061835-1b5d69cd1d26/go.mod h1:0gwbe1F2iBIjuQ9AH0DbQhL+Dpr5GofU8fgYyXk+ykk= github.com/pingcap/parser v0.0.0-20181024082006-53ac409ed043 h1:P9Osi8lei5j2fiRgsBi2Wch7qe4a3yWUOsS5vSan/JU= github.com/pingcap/parser v0.0.0-20181024082006-53ac409ed043/go.mod h1:1FNvfp9+J0wvc4kl8eGNh7Rqrxveg15jJoWo/a0uHwA= github.com/pingcap/parser v0.0.0-20181102070703-4acd198f5092 h1:vGjjf7fhuaO9udn6QEFzvsNJDwVxFmdJvIJhCdCNe/E= From d6ee0908b02ce261bcbd468900dcee904d1eba4a Mon Sep 17 00:00:00 2001 From: MyonKeminta Date: Mon, 5 Nov 2018 17:24:46 +0800 Subject: [PATCH 09/17] Add end_key param to ticlient scanner Signed-off-by: MyonKeminta --- store/tikv/scan.go | 7 +++++-- store/tikv/scan_mock_test.go | 10 +++++++++- store/tikv/snapshot.go | 2 +- 3 files changed, 15 insertions(+), 4 deletions(-) diff --git a/store/tikv/scan.go b/store/tikv/scan.go index 93637a0c90589..575a55f2b9d92 100644 --- a/store/tikv/scan.go +++ b/store/tikv/scan.go @@ -30,10 +30,11 @@ type Scanner struct { cache []*pb.KvPair idx int nextStartKey []byte + endKey []byte eof bool } -func newScanner(snapshot *tikvSnapshot, startKey []byte, batchSize int) (*Scanner, error) { +func newScanner(snapshot *tikvSnapshot, startKey []byte, endKey []byte, batchSize int) (*Scanner, error) { // It must be > 1. Otherwise scanner won't skipFirst. if batchSize <= 1 { batchSize = scanBatchSize @@ -43,6 +44,7 @@ func newScanner(snapshot *tikvSnapshot, startKey []byte, batchSize int) (*Scanne batchSize: batchSize, valid: true, nextStartKey: startKey, + endKey: endKey, } err := scanner.Next() if kv.IsErrNotFound(err) { @@ -147,6 +149,7 @@ func (s *Scanner) getData(bo *Backoffer) error { Type: tikvrpc.CmdScan, Scan: &pb.ScanRequest{ StartKey: s.nextStartKey, + EndKey: s.endKey, Limit: uint32(s.batchSize), Version: s.startTS(), KeyOnly: s.snapshot.keyOnly, @@ -199,7 +202,7 @@ func (s *Scanner) getData(bo *Backoffer) error { // No more data in current Region. Next getData() starts // from current Region's endKey. s.nextStartKey = loc.EndKey - if len(loc.EndKey) == 0 { + if len(loc.EndKey) == 0 || (len(s.endKey) > 0 && kv.Key(s.nextStartKey).Cmp(kv.Key(s.endKey)) >= 0) { // Current Region is the last one. s.eof = true } diff --git a/store/tikv/scan_mock_test.go b/store/tikv/scan_mock_test.go index af453a985ff32..94b720314f2bd 100644 --- a/store/tikv/scan_mock_test.go +++ b/store/tikv/scan_mock_test.go @@ -41,11 +41,19 @@ func (s *testScanMockSuite) TestScanMultipleRegions(c *C) { txn, err = store.Begin() c.Assert(err, IsNil) snapshot := newTiKVSnapshot(store, kv.Version{Ver: txn.StartTS()}) - scanner, err := newScanner(snapshot, []byte("a"), 10) + scanner, err := newScanner(snapshot, []byte("a"), nil, 10) c.Assert(err, IsNil) for ch := byte('a'); ch <= byte('z'); ch++ { c.Assert([]byte{ch}, BytesEquals, []byte(scanner.Key())) c.Assert(scanner.Next(), IsNil) } c.Assert(scanner.Valid(), IsFalse) + + scanner, err = newScanner(snapshot, []byte("a"), []byte("i"), 10) + c.Assert(err, IsNil) + for ch := byte('a'); ch <= byte('h'); ch++ { + c.Assert([]byte{ch}, BytesEquals, []byte(scanner.Key())) + c.Assert(scanner.Next(), IsNil) + } + c.Assert(scanner.Valid(), IsFalse) } diff --git a/store/tikv/snapshot.go b/store/tikv/snapshot.go index 4a3c8c0862e23..5e5d7d3fabbd1 100644 --- a/store/tikv/snapshot.go +++ b/store/tikv/snapshot.go @@ -280,7 +280,7 @@ func (s *tikvSnapshot) get(bo *Backoffer, k kv.Key) ([]byte, error) { // Seek return a list of key-value pair after `k`. func (s *tikvSnapshot) Seek(k kv.Key) (kv.Iterator, error) { - scanner, err := newScanner(s, k, scanBatchSize) + scanner, err := newScanner(s, k, nil, scanBatchSize) return scanner, errors.Trace(err) } From a059b8f21f5556075af1b00836ffee10020a3ef1 Mon Sep 17 00:00:00 2001 From: MyonKeminta Date: Mon, 5 Nov 2018 17:46:15 +0800 Subject: [PATCH 10/17] Use endKey in mock tikv Signed-off-by: MyonKeminta --- store/mockstore/mocktikv/rpc.go | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/store/mockstore/mocktikv/rpc.go b/store/mockstore/mocktikv/rpc.go index 96458eb569aa3..7cc6009569537 100644 --- a/store/mockstore/mocktikv/rpc.go +++ b/store/mockstore/mocktikv/rpc.go @@ -229,7 +229,11 @@ func (h *rpcHandler) handleKvScan(req *kvrpcpb.ScanRequest) *kvrpcpb.ScanRespons if !h.checkKeyInRegion(req.GetStartKey()) { panic("KvScan: startKey not in region") } - pairs := h.mvccStore.Scan(req.GetStartKey(), h.endKey, int(req.GetLimit()), req.GetVersion(), h.isolationLevel) + endKey := h.endKey + if len(req.EndKey) > 0 && (len(endKey) == 0 || bytes.Compare(req.EndKey, endKey) < 0) { + endKey = req.EndKey + } + pairs := h.mvccStore.Scan(req.GetStartKey(), endKey, int(req.GetLimit()), req.GetVersion(), h.isolationLevel) return &kvrpcpb.ScanResponse{ Pairs: convertToPbPairs(pairs), } From 63fdd1ca9f6596c5467527d4d589eff916aab191 Mon Sep 17 00:00:00 2001 From: MyonKeminta Date: Tue, 6 Nov 2018 15:45:54 +0800 Subject: [PATCH 11/17] Remove the -1 Signed-off-by: MyonKeminta --- ddl/index.go | 24 ++++++++++++++++-------- ddl/reorg.go | 2 +- 2 files changed, 17 insertions(+), 9 deletions(-) diff --git a/ddl/index.go b/ddl/index.go index 75029491a8a12..a8fa89e39e36e 100644 --- a/ddl/index.go +++ b/ddl/index.go @@ -622,11 +622,7 @@ func (w *addIndexWorker) fetchRowColVals(txn kv.Transaction, taskRange reorgInde // taskDone means that the added handle is out of taskRange.endHandle. taskDone := false oprStartTime := startTime - endHandle := taskRange.endHandle - if !taskRange.endIncluded { - endHandle -= 1 - } - err := iterateSnapshotRows(w.sessCtx.GetStore(), w.priority, w.table, txn.StartTS(), taskRange.startHandle, endHandle, + err := iterateSnapshotRows(w.sessCtx.GetStore(), w.priority, w.table, txn.StartTS(), taskRange.startHandle, taskRange.endHandle, taskRange.endIncluded, func(handle int64, recordKey kv.Key, rawRow []byte) (bool, error) { oprEndTime := time.Now() w.logSlowOperations(oprEndTime.Sub(oprStartTime), "iterateSnapshotRows in fetchRowColVals", 0) @@ -1211,8 +1207,7 @@ func allocateIndexID(tblInfo *model.TableInfo) int64 { // recordIterFunc is used for low-level record iteration. type recordIterFunc func(h int64, rowKey kv.Key, rawRecord []byte) (more bool, err error) -// limitHandle is the inclusive upper bound. -func iterateSnapshotRows(store kv.Storage, priority int, t table.Table, version uint64, startHandle int64, endHandle int64, fn recordIterFunc) error { +func iterateSnapshotRows(store kv.Storage, priority int, t table.Table, version uint64, startHandle int64, endHandle int64, endIncluded bool, fn recordIterFunc) error { ver := kv.Version{Ver: version} snap, err := store.GetSnapshot(ver) @@ -1221,7 +1216,20 @@ func iterateSnapshotRows(store kv.Storage, priority int, t table.Table, version return errors.Trace(err) } firstKey := t.RecordKey(startHandle) - upperBound := t.RecordKey(endHandle).PrefixNext() + + // Calculate the exclusive upper bound + var upperBound kv.Key + if endIncluded { + if endHandle == math.MaxInt64 { + upperBound = t.RecordKey(endHandle).PrefixNext() + } else { + // PrefixNext is time costing. Try to avoid it if possible. + upperBound = t.RecordKey(endHandle + 1) + } + } else { + upperBound = t.RecordKey(endHandle) + } + it, err := snap.Iter(firstKey, upperBound) if err != nil { return errors.Trace(err) diff --git a/ddl/reorg.go b/ddl/reorg.go index cd8bcf9a75f5b..d69bb257277b4 100644 --- a/ddl/reorg.go +++ b/ddl/reorg.go @@ -304,7 +304,7 @@ func getTableRange(d *ddlCtx, tbl table.PhysicalTable, snapshotVer uint64, prior startHandle = math.MinInt64 endHandle = math.MaxInt64 // Get the start handle of this partition. - err = iterateSnapshotRows(d.store, priority, tbl, snapshotVer, math.MinInt64, math.MaxInt64, + err = iterateSnapshotRows(d.store, priority, tbl, snapshotVer, math.MinInt64, math.MaxInt64, true, func(h int64, rowKey kv.Key, rawRecord []byte) (bool, error) { startHandle = h return false, nil From f8426e5c7aeb2d027e5a2006e891311f6bc6d5e7 Mon Sep 17 00:00:00 2001 From: MyonKeminta Date: Tue, 6 Nov 2018 16:00:53 +0800 Subject: [PATCH 12/17] Do not change logic Signed-off-by: MyonKeminta --- ddl/index.go | 22 ++++------------------ ddl/reorg.go | 2 +- util/admin/admin.go | 6 ++---- 3 files changed, 7 insertions(+), 23 deletions(-) diff --git a/ddl/index.go b/ddl/index.go index a8fa89e39e36e..bcd690383490c 100644 --- a/ddl/index.go +++ b/ddl/index.go @@ -622,7 +622,7 @@ func (w *addIndexWorker) fetchRowColVals(txn kv.Transaction, taskRange reorgInde // taskDone means that the added handle is out of taskRange.endHandle. taskDone := false oprStartTime := startTime - err := iterateSnapshotRows(w.sessCtx.GetStore(), w.priority, w.table, txn.StartTS(), taskRange.startHandle, taskRange.endHandle, taskRange.endIncluded, + err := iterateSnapshotRows(w.sessCtx.GetStore(), w.priority, w.table, txn.StartTS(), taskRange.startHandle, func(handle int64, recordKey kv.Key, rawRow []byte) (bool, error) { oprEndTime := time.Now() w.logSlowOperations(oprEndTime.Sub(oprStartTime), "iterateSnapshotRows in fetchRowColVals", 0) @@ -1207,7 +1207,7 @@ func allocateIndexID(tblInfo *model.TableInfo) int64 { // recordIterFunc is used for low-level record iteration. type recordIterFunc func(h int64, rowKey kv.Key, rawRecord []byte) (more bool, err error) -func iterateSnapshotRows(store kv.Storage, priority int, t table.Table, version uint64, startHandle int64, endHandle int64, endIncluded bool, fn recordIterFunc) error { +func iterateSnapshotRows(store kv.Storage, priority int, t table.Table, version uint64, seekHandle int64, fn recordIterFunc) error { ver := kv.Version{Ver: version} snap, err := store.GetSnapshot(ver) @@ -1215,22 +1215,8 @@ func iterateSnapshotRows(store kv.Storage, priority int, t table.Table, version if err != nil { return errors.Trace(err) } - firstKey := t.RecordKey(startHandle) - - // Calculate the exclusive upper bound - var upperBound kv.Key - if endIncluded { - if endHandle == math.MaxInt64 { - upperBound = t.RecordKey(endHandle).PrefixNext() - } else { - // PrefixNext is time costing. Try to avoid it if possible. - upperBound = t.RecordKey(endHandle + 1) - } - } else { - upperBound = t.RecordKey(endHandle) - } - - it, err := snap.Iter(firstKey, upperBound) + firstKey := t.RecordKey(seekHandle) + it, err := snap.Iter(firstKey, nil) if err != nil { return errors.Trace(err) } diff --git a/ddl/reorg.go b/ddl/reorg.go index d69bb257277b4..a793e0c402c71 100644 --- a/ddl/reorg.go +++ b/ddl/reorg.go @@ -304,7 +304,7 @@ func getTableRange(d *ddlCtx, tbl table.PhysicalTable, snapshotVer uint64, prior startHandle = math.MinInt64 endHandle = math.MaxInt64 // Get the start handle of this partition. - err = iterateSnapshotRows(d.store, priority, tbl, snapshotVer, math.MinInt64, math.MaxInt64, true, + err = iterateSnapshotRows(d.store, priority, tbl, snapshotVer, math.MinInt64, func(h int64, rowKey kv.Key, rawRecord []byte) (bool, error) { startHandle = h return false, nil diff --git a/util/admin/admin.go b/util/admin/admin.go index ab324eb51f3d6..9aa38113ba13c 100644 --- a/util/admin/admin.go +++ b/util/admin/admin.go @@ -639,10 +639,7 @@ func rowWithCols(sessCtx sessionctx.Context, txn kv.Retriever, t table.Table, h // genExprs use to calculate generated column value. func iterRecords(sessCtx sessionctx.Context, retriever kv.Retriever, t table.Table, startKey kv.Key, cols []*table.Column, fn table.RecordIterFunc, genExprs map[model.TableColumnID]expression.Expression) error { - prefix := t.RecordPrefix() - keyUpperBound := prefix.PrefixNext() - - it, err := retriever.Iter(startKey, keyUpperBound) + it, err := retriever.Iter(startKey, nil) if err != nil { return errors.Trace(err) } @@ -654,6 +651,7 @@ func iterRecords(sessCtx sessionctx.Context, retriever kv.Retriever, t table.Tab log.Debugf("startKey:%q, key:%q, value:%q", startKey, it.Key(), it.Value()) rowDecoder := makeRowDecoder(t, cols, genExprs) + prefix := t.RecordPrefix() for it.Valid() && it.Key().HasPrefix(prefix) { // first kv pair is row lock information. // TODO: check valid lock From 6e893fc88aff4c8efb379a2254cb57c4d752dacc Mon Sep 17 00:00:00 2001 From: MyonKeminta Date: Tue, 6 Nov 2018 17:02:52 +0800 Subject: [PATCH 13/17] Test how scan end_key of mvcc_leveldb works Signed-off-by: MyonKeminta --- store/mockstore/mocktikv/mock_tikv_test.go | 24 ++++++++++++++++++++-- 1 file changed, 22 insertions(+), 2 deletions(-) diff --git a/store/mockstore/mocktikv/mock_tikv_test.go b/store/mockstore/mocktikv/mock_tikv_test.go index 807a4267134ba..a4af86f037a28 100644 --- a/store/mockstore/mocktikv/mock_tikv_test.go +++ b/store/mockstore/mocktikv/mock_tikv_test.go @@ -119,7 +119,11 @@ func (s *testMockTiKVSuite) mustDeleteOK(c *C, key string, startTS, commitTS uin } func (s *testMockTiKVSuite) mustScanOK(c *C, start string, limit int, ts uint64, expect ...string) { - pairs := s.store.Scan([]byte(start), nil, limit, ts, kvrpcpb.IsolationLevel_SI) + s.mustRangeScanOK(c, start, "", limit, ts, expect...) +} + +func (s *testMockTiKVSuite) mustRangeScanOK(c *C, start, end string, limit int, ts uint64, expect ...string) { + pairs := s.store.Scan([]byte(start), []byte(end), limit, ts, kvrpcpb.IsolationLevel_SI) c.Assert(len(pairs)*2, Equals, len(expect)) for i := 0; i < len(pairs); i++ { c.Assert(pairs[i].Err, IsNil) @@ -129,7 +133,11 @@ func (s *testMockTiKVSuite) mustScanOK(c *C, start string, limit int, ts uint64, } func (s *testMockTiKVSuite) mustReverseScanOK(c *C, end string, limit int, ts uint64, expect ...string) { - pairs := s.store.ReverseScan(nil, []byte(end), limit, ts, kvrpcpb.IsolationLevel_SI) + s.mustRangeReverseScanOK(c, "", end, limit, ts, expect...) +} + +func (s *testMockTiKVSuite) mustRangeReverseScanOK(c *C, start, end string, limit int, ts uint64, expect ...string) { + pairs := s.store.ReverseScan([]byte(start), []byte(end), limit, ts, kvrpcpb.IsolationLevel_SI) c.Assert(len(pairs)*2, Equals, len(expect)) for i := 0; i < len(pairs); i++ { c.Assert(pairs[i].Err, IsNil) @@ -249,6 +257,9 @@ func (s *testMockTiKVSuite) TestReverseScan(c *C) { s.mustReverseScanOK(c, "C\x00", 3, 10, "C", "C10", "A", "A10") s.mustReverseScanOK(c, "C\x00", 4, 10, "C", "C10", "A", "A10") s.mustReverseScanOK(c, "B", 1, 10, "A", "A10") + s.mustRangeReverseScanOK(c, "", "E", 5, 10, "C", "C10", "A", "A10") + s.mustRangeReverseScanOK(c, "", "C\x00", 5, 10, "C", "C10", "A", "A10") + s.mustRangeReverseScanOK(c, "A\x00", "C", 5, 10) } checkV10() @@ -260,6 +271,9 @@ func (s *testMockTiKVSuite) TestReverseScan(c *C) { s.mustReverseScanOK(c, "Z", 5, 20, "E", "E10", "D", "D20", "C", "C10", "B", "B20", "A", "A10") s.mustReverseScanOK(c, "C\x00", 5, 20, "C", "C10", "B", "B20", "A", "A10") s.mustReverseScanOK(c, "A\x00", 1, 20, "A", "A10") + s.mustRangeReverseScanOK(c, "B", "D", 5, 20, "C", "C10", "B", "B20") + s.mustRangeReverseScanOK(c, "B", "D\x00", 5, 20, "D", "D20", "C", "C10", "B", "B20") + s.mustRangeReverseScanOK(c, "B\x00", "D\x00", 5, 20, "D", "D20", "C", "C10") } checkV10() checkV20() @@ -308,6 +322,9 @@ func (s *testMockTiKVSuite) TestScan(c *C) { s.mustScanOK(c, "A\x00", 3, 10, "C", "C10", "E", "E10") s.mustScanOK(c, "C", 4, 10, "C", "C10", "E", "E10") s.mustScanOK(c, "F", 1, 10) + s.mustRangeScanOK(c, "", "E", 5, 10, "A", "A10", "C", "C10") + s.mustRangeScanOK(c, "", "C\x00", 5, 10, "A", "A10", "C", "C10") + s.mustRangeScanOK(c, "A\x00", "C", 5, 10) } checkV10() @@ -319,6 +336,9 @@ func (s *testMockTiKVSuite) TestScan(c *C) { s.mustScanOK(c, "", 5, 20, "A", "A10", "B", "B20", "C", "C10", "D", "D20", "E", "E10") s.mustScanOK(c, "C", 5, 20, "C", "C10", "D", "D20", "E", "E10") s.mustScanOK(c, "D\x00", 1, 20, "E", "E10") + s.mustRangeScanOK(c, "B", "D", 5, 20, "B", "B20", "C", "C10") + s.mustRangeScanOK(c, "B", "D\x00", 5, 20, "B", "B20", "C", "C10", "D", "D20") + s.mustRangeScanOK(c, "B\x00", "D\x00", 5, 20, "C", "C10", "D", "D20") } checkV10() checkV20() From aae45bc1850f9a472f2faefa4fde04f2e04f7deb Mon Sep 17 00:00:00 2001 From: MyonKeminta Date: Tue, 6 Nov 2018 17:44:03 +0800 Subject: [PATCH 14/17] Add upperbound-limited scan test to the ScanTest Signed-off-by: MyonKeminta --- store/tikv/scan_test.go | 78 +++++++++++++++++++---------------------- 1 file changed, 37 insertions(+), 41 deletions(-) diff --git a/store/tikv/scan_test.go b/store/tikv/scan_test.go index e64496ef31e19..ff9184d0c0323 100644 --- a/store/tikv/scan_test.go +++ b/store/tikv/scan_test.go @@ -62,7 +62,25 @@ func (s *testScanSuite) beginTxn(c *C) *tikvTxn { return txn.(*tikvTxn) } -func (s *testScanSuite) TestSeek(c *C) { +func (s *testScanSuite) TestScan(c *C) { + check := func(c *C, scan kv.Iterator, rowNum int, keyOnly bool) { + for i := 0; i < rowNum; i++ { + k := scan.Key() + c.Assert([]byte(k), BytesEquals, encodeKey(s.prefix, s08d("key", i))) + if !keyOnly { + v := scan.Value() + c.Assert(v, BytesEquals, valueBytes(i)) + } + // Because newScan return first item without calling scan.Next() just like go-hbase, + // for-loop count will decrease 1. + if i < rowNum-1 { + scan.Next() + } + } + scan.Next() + c.Assert(scan.Valid(), IsFalse) + } + for _, rowNum := range s.rowNums { txn := s.beginTxn(c) for i := 0; i < rowNum; i++ { @@ -76,57 +94,35 @@ func (s *testScanSuite) TestSeek(c *C) { val, err := txn2.Get(encodeKey(s.prefix, s08d("key", 0))) c.Assert(err, IsNil) c.Assert(val, BytesEquals, valueBytes(0)) + // Test scan without upperBound scan, err := txn2.Iter(encodeKey(s.prefix, ""), nil) c.Assert(err, IsNil) - - for i := 0; i < rowNum; i++ { - k := scan.Key() - c.Assert([]byte(k), BytesEquals, encodeKey(s.prefix, s08d("key", i))) - v := scan.Value() - c.Assert(v, BytesEquals, valueBytes(i)) - // Because newScan return first item without calling scan.Next() just like go-hbase, - // for-loop count will decrease 1. - if i < rowNum-1 { - scan.Next() - } - } - scan.Next() - c.Assert(scan.Valid(), IsFalse) + check(c, scan, rowNum, false) + // Test scan with upperBound + upperBound := rowNum / 2 + scan, err = txn2.Iter(encodeKey(s.prefix, ""), encodeKey(s.prefix, s08d("key", upperBound))) + c.Assert(err, IsNil) + check(c, scan, upperBound, false) txn3 := s.beginTxn(c) txn3.SetOption(kv.KeyOnly, true) + // Test scan without upper bound scan, err = txn3.Iter(encodeKey(s.prefix, ""), nil) c.Assert(err, IsNil) - - for i := 0; i < rowNum; i++ { - k := scan.Key() - c.Assert([]byte(k), BytesEquals, encodeKey(s.prefix, s08d("key", i))) - // Because newScan return first item without calling scan.Next() just like go-hbase, - // for-loop count will decrease 1. - if i < rowNum-1 { - scan.Next() - } - } - scan.Next() - c.Assert(scan.Valid(), IsFalse) + check(c, scan, rowNum, true) + // test scan with upper bound + scan, err = txn3.Iter(encodeKey(s.prefix, ""), encodeKey(s.prefix, s08d("key", upperBound))) + c.Assert(err, IsNil) + check(c, scan, upperBound, true) // Restore KeyOnly to false txn3.SetOption(kv.KeyOnly, false) scan, err = txn3.Iter(encodeKey(s.prefix, ""), nil) c.Assert(err, IsNil) - - for i := 0; i < rowNum; i++ { - k := scan.Key() - c.Assert([]byte(k), BytesEquals, encodeKey(s.prefix, s08d("key", i))) - v := scan.Value() - c.Assert(v, BytesEquals, valueBytes(i)) - // Because newScan return first item without calling scan.Next() just like go-hbase, - // for-loop count will decrease 1. - if i < rowNum-1 { - scan.Next() - } - } - scan.Next() - c.Assert(scan.Valid(), IsFalse) + check(c, scan, rowNum, true) + // test scan with upper bound + scan, err = txn3.Iter(encodeKey(s.prefix, ""), encodeKey(s.prefix, s08d("key", upperBound))) + c.Assert(err, IsNil) + check(c, scan, upperBound, true) } } From cf6c3773626838e0e14000fd2eec4d4fdfb390cf Mon Sep 17 00:00:00 2001 From: MyonKeminta Date: Tue, 6 Nov 2018 18:02:52 +0800 Subject: [PATCH 15/17] Recover changes Signed-off-by: MyonKeminta --- ddl/index.go | 22 ++++++++++++++++++---- ddl/reorg.go | 2 +- util/admin/admin.go | 6 ++++-- 3 files changed, 23 insertions(+), 7 deletions(-) diff --git a/ddl/index.go b/ddl/index.go index bcd690383490c..a8fa89e39e36e 100644 --- a/ddl/index.go +++ b/ddl/index.go @@ -622,7 +622,7 @@ func (w *addIndexWorker) fetchRowColVals(txn kv.Transaction, taskRange reorgInde // taskDone means that the added handle is out of taskRange.endHandle. taskDone := false oprStartTime := startTime - err := iterateSnapshotRows(w.sessCtx.GetStore(), w.priority, w.table, txn.StartTS(), taskRange.startHandle, + err := iterateSnapshotRows(w.sessCtx.GetStore(), w.priority, w.table, txn.StartTS(), taskRange.startHandle, taskRange.endHandle, taskRange.endIncluded, func(handle int64, recordKey kv.Key, rawRow []byte) (bool, error) { oprEndTime := time.Now() w.logSlowOperations(oprEndTime.Sub(oprStartTime), "iterateSnapshotRows in fetchRowColVals", 0) @@ -1207,7 +1207,7 @@ func allocateIndexID(tblInfo *model.TableInfo) int64 { // recordIterFunc is used for low-level record iteration. type recordIterFunc func(h int64, rowKey kv.Key, rawRecord []byte) (more bool, err error) -func iterateSnapshotRows(store kv.Storage, priority int, t table.Table, version uint64, seekHandle int64, fn recordIterFunc) error { +func iterateSnapshotRows(store kv.Storage, priority int, t table.Table, version uint64, startHandle int64, endHandle int64, endIncluded bool, fn recordIterFunc) error { ver := kv.Version{Ver: version} snap, err := store.GetSnapshot(ver) @@ -1215,8 +1215,22 @@ func iterateSnapshotRows(store kv.Storage, priority int, t table.Table, version if err != nil { return errors.Trace(err) } - firstKey := t.RecordKey(seekHandle) - it, err := snap.Iter(firstKey, nil) + firstKey := t.RecordKey(startHandle) + + // Calculate the exclusive upper bound + var upperBound kv.Key + if endIncluded { + if endHandle == math.MaxInt64 { + upperBound = t.RecordKey(endHandle).PrefixNext() + } else { + // PrefixNext is time costing. Try to avoid it if possible. + upperBound = t.RecordKey(endHandle + 1) + } + } else { + upperBound = t.RecordKey(endHandle) + } + + it, err := snap.Iter(firstKey, upperBound) if err != nil { return errors.Trace(err) } diff --git a/ddl/reorg.go b/ddl/reorg.go index a793e0c402c71..d69bb257277b4 100644 --- a/ddl/reorg.go +++ b/ddl/reorg.go @@ -304,7 +304,7 @@ func getTableRange(d *ddlCtx, tbl table.PhysicalTable, snapshotVer uint64, prior startHandle = math.MinInt64 endHandle = math.MaxInt64 // Get the start handle of this partition. - err = iterateSnapshotRows(d.store, priority, tbl, snapshotVer, math.MinInt64, + err = iterateSnapshotRows(d.store, priority, tbl, snapshotVer, math.MinInt64, math.MaxInt64, true, func(h int64, rowKey kv.Key, rawRecord []byte) (bool, error) { startHandle = h return false, nil diff --git a/util/admin/admin.go b/util/admin/admin.go index 9aa38113ba13c..ab324eb51f3d6 100644 --- a/util/admin/admin.go +++ b/util/admin/admin.go @@ -639,7 +639,10 @@ func rowWithCols(sessCtx sessionctx.Context, txn kv.Retriever, t table.Table, h // genExprs use to calculate generated column value. func iterRecords(sessCtx sessionctx.Context, retriever kv.Retriever, t table.Table, startKey kv.Key, cols []*table.Column, fn table.RecordIterFunc, genExprs map[model.TableColumnID]expression.Expression) error { - it, err := retriever.Iter(startKey, nil) + prefix := t.RecordPrefix() + keyUpperBound := prefix.PrefixNext() + + it, err := retriever.Iter(startKey, keyUpperBound) if err != nil { return errors.Trace(err) } @@ -651,7 +654,6 @@ func iterRecords(sessCtx sessionctx.Context, retriever kv.Retriever, t table.Tab log.Debugf("startKey:%q, key:%q, value:%q", startKey, it.Key(), it.Value()) rowDecoder := makeRowDecoder(t, cols, genExprs) - prefix := t.RecordPrefix() for it.Valid() && it.Key().HasPrefix(prefix) { // first kv pair is row lock information. // TODO: check valid lock From b8326f34c521b528ae156972eb4b7c2476865383 Mon Sep 17 00:00:00 2001 From: MyonKeminta Date: Tue, 6 Nov 2018 20:03:38 +0800 Subject: [PATCH 16/17] Make use of the upperBound limit every where Signed-off-by: MyonKeminta --- ddl/delete_range.go | 8 ++------ structure/hash.go | 2 +- table/tables/index.go | 2 +- table/tables/tables.go | 6 +++--- util/prefix_helper.go | 4 ++-- 5 files changed, 9 insertions(+), 13 deletions(-) diff --git a/ddl/delete_range.go b/ddl/delete_range.go index d0e242662fd48..2eeb9b7321ae3 100644 --- a/ddl/delete_range.go +++ b/ddl/delete_range.go @@ -14,7 +14,6 @@ package ddl import ( - "bytes" "encoding/hex" "fmt" "math" @@ -154,7 +153,7 @@ func (dr *delRange) doTask(ctx sessionctx.Context, r util.DelRangeTask) error { finish := true dr.keys = dr.keys[:0] err := kv.RunInNewTxn(dr.store, false, func(txn kv.Transaction) error { - iter, err := txn.Iter(oldStartKey, nil) + iter, err := txn.Iter(oldStartKey, r.EndKey) if err != nil { return errors.Trace(err) } @@ -164,10 +163,7 @@ func (dr *delRange) doTask(ctx sessionctx.Context, r util.DelRangeTask) error { if !iter.Valid() { break } - finish = bytes.Compare(iter.Key(), r.EndKey) >= 0 - if finish { - break - } + finish = false dr.keys = append(dr.keys, iter.Key().Clone()) newStartKey = iter.Key().Next() diff --git a/structure/hash.go b/structure/hash.go index 8921bbe0db0af..609c4df398b68 100644 --- a/structure/hash.go +++ b/structure/hash.go @@ -238,7 +238,7 @@ func (t *TxStructure) HClear(key []byte) error { func (t *TxStructure) iterateHash(key []byte, fn func(k []byte, v []byte) error) error { dataPrefix := t.hashDataKeyPrefix(key) - it, err := t.reader.Iter(dataPrefix, nil) + it, err := t.reader.Iter(dataPrefix, dataPrefix.PrefixNext()) if err != nil { return errors.Trace(err) } diff --git a/table/tables/index.go b/table/tables/index.go index 4ff8c3e9881f0..d86c45c6c1d72 100644 --- a/table/tables/index.go +++ b/table/tables/index.go @@ -240,7 +240,7 @@ func (c *index) Delete(sc *stmtctx.StatementContext, m kv.Mutator, indexedValues // Drop removes the KV index from store. func (c *index) Drop(rm kv.RetrieverMutator) error { - it, err := rm.Iter(c.prefix, nil) + it, err := rm.Iter(c.prefix, c.prefix.PrefixNext()) if err != nil { return errors.Trace(err) } diff --git a/table/tables/tables.go b/table/tables/tables.go index 9d8c01022fd9b..d1126be735582 100644 --- a/table/tables/tables.go +++ b/table/tables/tables.go @@ -782,7 +782,8 @@ func (t *tableCommon) buildIndexForRow(ctx sessionctx.Context, rm kv.RetrieverMu // IterRecords implements table.Table IterRecords interface. func (t *tableCommon) IterRecords(ctx sessionctx.Context, startKey kv.Key, cols []*table.Column, fn table.RecordIterFunc) error { - it, err := ctx.Txn().Iter(startKey, nil) + prefix := t.RecordPrefix() + it, err := ctx.Txn().Iter(startKey, prefix.PrefixNext()) if err != nil { return errors.Trace(err) } @@ -798,7 +799,6 @@ func (t *tableCommon) IterRecords(ctx sessionctx.Context, startKey kv.Key, cols for _, col := range cols { colMap[col.ID] = &col.FieldType } - prefix := t.RecordPrefix() defaultVals := make([]types.Datum, len(cols)) for it.Valid() && it.Key().HasPrefix(prefix) { // first kv pair is row lock information. @@ -912,7 +912,7 @@ func (t *tableCommon) RebaseAutoID(ctx sessionctx.Context, newBase int64, isSetS // Seek implements table.Table Seek interface. func (t *tableCommon) Seek(ctx sessionctx.Context, h int64) (int64, bool, error) { seekKey := tablecodec.EncodeRowKeyWithHandle(t.physicalTableID, h) - iter, err := ctx.Txn().Iter(seekKey, nil) + iter, err := ctx.Txn().Iter(seekKey, t.RecordPrefix().PrefixNext()) if !iter.Valid() || !iter.Key().HasPrefix(t.RecordPrefix()) { // No more records in the table, skip to the end. return 0, false, nil diff --git a/util/prefix_helper.go b/util/prefix_helper.go index 214414a9cef64..cb01e3b57b102 100644 --- a/util/prefix_helper.go +++ b/util/prefix_helper.go @@ -26,7 +26,7 @@ import ( // ScanMetaWithPrefix scans metadata with the prefix. func ScanMetaWithPrefix(retriever kv.Retriever, prefix kv.Key, filter func(kv.Key, []byte) bool) error { - iter, err := retriever.Iter(prefix, nil) + iter, err := retriever.Iter(prefix, prefix.PrefixNext()) if err != nil { return errors.Trace(err) } @@ -56,7 +56,7 @@ func ScanMetaWithPrefix(retriever kv.Retriever, prefix kv.Key, filter func(kv.Ke // DelKeyWithPrefix deletes keys with prefix. func DelKeyWithPrefix(rm kv.RetrieverMutator, prefix kv.Key) error { var keys []kv.Key - iter, err := rm.Iter(prefix, nil) + iter, err := rm.Iter(prefix, prefix.PrefixNext()) if err != nil { return errors.Trace(err) } From 11f4b36be767633e00ef5cbd979c750597febf96 Mon Sep 17 00:00:00 2001 From: MyonKeminta Date: Thu, 8 Nov 2018 20:46:52 +0800 Subject: [PATCH 17/17] Check key in Next Signed-off-by: MyonKeminta --- store/tikv/scan.go | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/store/tikv/scan.go b/store/tikv/scan.go index 52ce4ca23df2a..6bf1813bbcf41 100644 --- a/store/tikv/scan.go +++ b/store/tikv/scan.go @@ -98,6 +98,11 @@ func (s *Scanner) Next() error { } current := s.cache[s.idx] + if len(s.endKey) > 0 && kv.Key(current.Key).Cmp(kv.Key(s.endKey)) >= 0 { + s.eof = true + s.Close() + return nil + } // Try to resolve the lock if current.GetError() != nil { // 'current' would be modified if the lock being resolved