cfa879d63c
* Add JSON and Binary Marshaler Generators for Protobuf Types * Generate files with the correct version of gogo/protobuf I have pinned the version in the makefile so when you run make tools you get the right version. This pulls the version out of go.mod so it should remain up to date. The version at the time of this commit we are using is v1.2.1 * Fixup some shell output * Update how we determine the version of gogo This just greps the go.mod file instead of expecting the go mod cache to already be present * Fixup vendoring and remove no longer needed json encoder functions
1673 lines
41 KiB
Go
1673 lines
41 KiB
Go
// Code generated by protoc-gen-gogo. DO NOT EDIT.
|
|
// source: common.proto
|
|
|
|
package agentpb
|
|
|
|
import (
|
|
fmt "fmt"
|
|
_ "github.com/gogo/protobuf/gogoproto"
|
|
_ "github.com/gogo/protobuf/types"
|
|
github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
|
|
proto "github.com/golang/protobuf/proto"
|
|
io "io"
|
|
math "math"
|
|
time "time"
|
|
)
|
|
|
|
// Reference imports to suppress errors if they are not otherwise used.
|
|
var _ = proto.Marshal
|
|
var _ = fmt.Errorf
|
|
var _ = math.Inf
|
|
var _ = time.Kitchen
|
|
|
|
// This is a compile-time assertion to ensure that this generated file
|
|
// is compatible with the proto package it is being compiled against.
|
|
// A compilation error at this line likely means your copy of the
|
|
// proto package needs to be updated.
|
|
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
|
|
|
|
// RaftIndex is used to track the index used while creating
|
|
// or modifying a given struct type.
|
|
type RaftIndex struct {
|
|
CreateIndex uint64 `protobuf:"varint,1,opt,name=CreateIndex,proto3" json:"CreateIndex,omitempty" bexpr:"-"`
|
|
ModifyIndex uint64 `protobuf:"varint,2,opt,name=ModifyIndex,proto3" json:"ModifyIndex,omitempty" bexpr:"-"`
|
|
}
|
|
|
|
func (m *RaftIndex) Reset() { *m = RaftIndex{} }
|
|
func (m *RaftIndex) String() string { return proto.CompactTextString(m) }
|
|
func (*RaftIndex) ProtoMessage() {}
|
|
func (*RaftIndex) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_555bd8c177793206, []int{0}
|
|
}
|
|
func (m *RaftIndex) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *RaftIndex) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_RaftIndex.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 (m *RaftIndex) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_RaftIndex.Merge(m, src)
|
|
}
|
|
func (m *RaftIndex) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *RaftIndex) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_RaftIndex.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_RaftIndex proto.InternalMessageInfo
|
|
|
|
// TargetDatacenter is intended to be used within other messages used for RPC routing
|
|
// amongst the various Consul datacenters
|
|
type TargetDatacenter struct {
|
|
Datacenter string `protobuf:"bytes,1,opt,name=Datacenter,proto3" json:"Datacenter,omitempty"`
|
|
}
|
|
|
|
func (m *TargetDatacenter) Reset() { *m = TargetDatacenter{} }
|
|
func (m *TargetDatacenter) String() string { return proto.CompactTextString(m) }
|
|
func (*TargetDatacenter) ProtoMessage() {}
|
|
func (*TargetDatacenter) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_555bd8c177793206, []int{1}
|
|
}
|
|
func (m *TargetDatacenter) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *TargetDatacenter) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_TargetDatacenter.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 (m *TargetDatacenter) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_TargetDatacenter.Merge(m, src)
|
|
}
|
|
func (m *TargetDatacenter) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *TargetDatacenter) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_TargetDatacenter.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_TargetDatacenter proto.InternalMessageInfo
|
|
|
|
type WriteRequest struct {
|
|
// Token is the ACL token ID. If not provided, the 'anonymous'
|
|
// token is assumed for backwards compatibility.
|
|
Token string `protobuf:"bytes,1,opt,name=Token,proto3" json:"Token,omitempty"`
|
|
}
|
|
|
|
func (m *WriteRequest) Reset() { *m = WriteRequest{} }
|
|
func (m *WriteRequest) String() string { return proto.CompactTextString(m) }
|
|
func (*WriteRequest) ProtoMessage() {}
|
|
func (*WriteRequest) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_555bd8c177793206, []int{2}
|
|
}
|
|
func (m *WriteRequest) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *WriteRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_WriteRequest.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 (m *WriteRequest) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_WriteRequest.Merge(m, src)
|
|
}
|
|
func (m *WriteRequest) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *WriteRequest) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_WriteRequest.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_WriteRequest proto.InternalMessageInfo
|
|
|
|
func (m *WriteRequest) GetToken() string {
|
|
if m != nil {
|
|
return m.Token
|
|
}
|
|
return ""
|
|
}
|
|
|
|
// QueryOptions is used to specify various flags for read queries
|
|
type QueryOptions struct {
|
|
// Token is the ACL token ID. If not provided, the 'anonymous'
|
|
// token is assumed for backwards compatibility.
|
|
Token string `protobuf:"bytes,1,opt,name=Token,proto3" json:"Token,omitempty"`
|
|
// If set, wait until query exceeds given index. Must be provided
|
|
// with MaxQueryTime.
|
|
MinQueryIndex uint64 `protobuf:"varint,2,opt,name=MinQueryIndex,proto3" json:"MinQueryIndex,omitempty"`
|
|
// Provided with MinQueryIndex to wait for change.
|
|
MaxQueryTime time.Duration `protobuf:"bytes,3,opt,name=MaxQueryTime,proto3,stdduration" json:"MaxQueryTime"`
|
|
// If set, any follower can service the request. Results
|
|
// may be arbitrarily stale.
|
|
AllowStale bool `protobuf:"varint,4,opt,name=AllowStale,proto3" json:"AllowStale,omitempty"`
|
|
// If set, the leader must verify leadership prior to
|
|
// servicing the request. Prevents a stale read.
|
|
RequireConsistent bool `protobuf:"varint,5,opt,name=RequireConsistent,proto3" json:"RequireConsistent,omitempty"`
|
|
// If set, the local agent may respond with an arbitrarily stale locally
|
|
// cached response. The semantics differ from AllowStale since the agent may
|
|
// be entirely partitioned from the servers and still considered "healthy" by
|
|
// operators. Stale responses from Servers are also arbitrarily stale, but can
|
|
// provide additional bounds on the last contact time from the leader. It's
|
|
// expected that servers that are partitioned are noticed and replaced in a
|
|
// timely way by operators while the same may not be true for client agents.
|
|
UseCache bool `protobuf:"varint,6,opt,name=UseCache,proto3" json:"UseCache,omitempty"`
|
|
// If set and AllowStale is true, will try first a stale
|
|
// read, and then will perform a consistent read if stale
|
|
// read is older than value.
|
|
MaxStaleDuration time.Duration `protobuf:"bytes,7,opt,name=MaxStaleDuration,proto3,stdduration" json:"MaxStaleDuration"`
|
|
// MaxAge limits how old a cached value will be returned if UseCache is true.
|
|
// If there is a cached response that is older than the MaxAge, it is treated
|
|
// as a cache miss and a new fetch invoked. If the fetch fails, the error is
|
|
// returned. Clients that wish to allow for stale results on error can set
|
|
// StaleIfError to a longer duration to change this behavior. It is ignored
|
|
// if the endpoint supports background refresh caching. See
|
|
// https://www.consul.io/api/index.html#agent-caching for more details.
|
|
MaxAge time.Duration `protobuf:"bytes,8,opt,name=MaxAge,proto3,stdduration" json:"MaxAge"`
|
|
// MustRevalidate forces the agent to fetch a fresh version of a cached
|
|
// resource or at least validate that the cached version is still fresh. It is
|
|
// implied by either max-age=0 or must-revalidate Cache-Control headers. It
|
|
// only makes sense when UseCache is true. We store it since MaxAge = 0 is the
|
|
// default unset value.
|
|
MustRevalidate bool `protobuf:"varint,9,opt,name=MustRevalidate,proto3" json:"MustRevalidate,omitempty"`
|
|
// StaleIfError specifies how stale the client will accept a cached response
|
|
// if the servers are unavailable to fetch a fresh one. Only makes sense when
|
|
// UseCache is true and MaxAge is set to a lower, non-zero value. It is
|
|
// ignored if the endpoint supports background refresh caching. See
|
|
// https://www.consul.io/api/index.html#agent-caching for more details.
|
|
StaleIfError time.Duration `protobuf:"bytes,10,opt,name=StaleIfError,proto3,stdduration" json:"StaleIfError"`
|
|
// Filter specifies the go-bexpr filter expression to be used for
|
|
// filtering the data prior to returning a response
|
|
Filter string `protobuf:"bytes,11,opt,name=Filter,proto3" json:"Filter,omitempty"`
|
|
}
|
|
|
|
func (m *QueryOptions) Reset() { *m = QueryOptions{} }
|
|
func (m *QueryOptions) String() string { return proto.CompactTextString(m) }
|
|
func (*QueryOptions) ProtoMessage() {}
|
|
func (*QueryOptions) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_555bd8c177793206, []int{3}
|
|
}
|
|
func (m *QueryOptions) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *QueryOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_QueryOptions.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 (m *QueryOptions) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_QueryOptions.Merge(m, src)
|
|
}
|
|
func (m *QueryOptions) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *QueryOptions) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_QueryOptions.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_QueryOptions proto.InternalMessageInfo
|
|
|
|
func (m *QueryOptions) GetToken() string {
|
|
if m != nil {
|
|
return m.Token
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *QueryOptions) GetMinQueryIndex() uint64 {
|
|
if m != nil {
|
|
return m.MinQueryIndex
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *QueryOptions) GetMaxQueryTime() time.Duration {
|
|
if m != nil {
|
|
return m.MaxQueryTime
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *QueryOptions) GetAllowStale() bool {
|
|
if m != nil {
|
|
return m.AllowStale
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (m *QueryOptions) GetRequireConsistent() bool {
|
|
if m != nil {
|
|
return m.RequireConsistent
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (m *QueryOptions) GetUseCache() bool {
|
|
if m != nil {
|
|
return m.UseCache
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (m *QueryOptions) GetMaxStaleDuration() time.Duration {
|
|
if m != nil {
|
|
return m.MaxStaleDuration
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *QueryOptions) GetMaxAge() time.Duration {
|
|
if m != nil {
|
|
return m.MaxAge
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *QueryOptions) GetMustRevalidate() bool {
|
|
if m != nil {
|
|
return m.MustRevalidate
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (m *QueryOptions) GetStaleIfError() time.Duration {
|
|
if m != nil {
|
|
return m.StaleIfError
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *QueryOptions) GetFilter() string {
|
|
if m != nil {
|
|
return m.Filter
|
|
}
|
|
return ""
|
|
}
|
|
|
|
// QueryMeta allows a query response to include potentially
|
|
// useful metadata about a query
|
|
type QueryMeta struct {
|
|
// This is the index associated with the read
|
|
Index uint64 `protobuf:"varint,1,opt,name=Index,proto3" json:"Index,omitempty"`
|
|
// If AllowStale is used, this is time elapsed since
|
|
// last contact between the follower and leader. This
|
|
// can be used to gauge staleness.
|
|
LastContact time.Duration `protobuf:"bytes,2,opt,name=LastContact,proto3,stdduration" json:"LastContact"`
|
|
// Used to indicate if there is a known leader node
|
|
KnownLeader bool `protobuf:"varint,3,opt,name=KnownLeader,proto3" json:"KnownLeader,omitempty"`
|
|
// Consistencylevel returns the consistency used to serve the query
|
|
// Having `discovery_max_stale` on the agent can affect whether
|
|
// the request was served by a leader.
|
|
ConsistencyLevel string `protobuf:"bytes,4,opt,name=ConsistencyLevel,proto3" json:"ConsistencyLevel,omitempty"`
|
|
}
|
|
|
|
func (m *QueryMeta) Reset() { *m = QueryMeta{} }
|
|
func (m *QueryMeta) String() string { return proto.CompactTextString(m) }
|
|
func (*QueryMeta) ProtoMessage() {}
|
|
func (*QueryMeta) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_555bd8c177793206, []int{4}
|
|
}
|
|
func (m *QueryMeta) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *QueryMeta) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_QueryMeta.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 (m *QueryMeta) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_QueryMeta.Merge(m, src)
|
|
}
|
|
func (m *QueryMeta) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *QueryMeta) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_QueryMeta.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_QueryMeta proto.InternalMessageInfo
|
|
|
|
func (m *QueryMeta) GetIndex() uint64 {
|
|
if m != nil {
|
|
return m.Index
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *QueryMeta) GetLastContact() time.Duration {
|
|
if m != nil {
|
|
return m.LastContact
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *QueryMeta) GetKnownLeader() bool {
|
|
if m != nil {
|
|
return m.KnownLeader
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (m *QueryMeta) GetConsistencyLevel() string {
|
|
if m != nil {
|
|
return m.ConsistencyLevel
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func init() {
|
|
proto.RegisterType((*RaftIndex)(nil), "agentpb.RaftIndex")
|
|
proto.RegisterType((*TargetDatacenter)(nil), "agentpb.TargetDatacenter")
|
|
proto.RegisterType((*WriteRequest)(nil), "agentpb.WriteRequest")
|
|
proto.RegisterType((*QueryOptions)(nil), "agentpb.QueryOptions")
|
|
proto.RegisterType((*QueryMeta)(nil), "agentpb.QueryMeta")
|
|
}
|
|
|
|
func init() { proto.RegisterFile("common.proto", fileDescriptor_555bd8c177793206) }
|
|
|
|
var fileDescriptor_555bd8c177793206 = []byte{
|
|
// 538 bytes of a gzipped FileDescriptorProto
|
|
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x52, 0xc1, 0x6e, 0xd3, 0x40,
|
|
0x14, 0xb4, 0x21, 0x4d, 0xe3, 0x97, 0x14, 0x85, 0x55, 0x85, 0x4c, 0x0e, 0x4e, 0x64, 0x21, 0x14,
|
|
0x55, 0x90, 0x48, 0xe5, 0x56, 0x4e, 0x4d, 0x5a, 0x50, 0x45, 0xac, 0x8a, 0x25, 0x88, 0xf3, 0x26,
|
|
0x79, 0x31, 0x16, 0xce, 0x6e, 0x58, 0x6f, 0xda, 0xe4, 0x0f, 0x38, 0x72, 0xac, 0x38, 0xf1, 0x21,
|
|
0x7c, 0x40, 0x8e, 0x3d, 0x72, 0x2a, 0x90, 0xfc, 0x01, 0x5f, 0x80, 0xbc, 0x76, 0x8a, 0x4b, 0x7a,
|
|
0x08, 0x37, 0xcf, 0x78, 0x66, 0x77, 0xf6, 0xbd, 0x81, 0x52, 0x5f, 0x8c, 0x46, 0x82, 0x37, 0xc6,
|
|
0x52, 0x28, 0x41, 0xb6, 0x99, 0x8f, 0x5c, 0x8d, 0x7b, 0x15, 0xc7, 0x17, 0xc2, 0x0f, 0xb1, 0xa9,
|
|
0xe9, 0xde, 0x64, 0xd8, 0x1c, 0x4c, 0x24, 0x53, 0xc1, 0x4a, 0x58, 0xd9, 0xf5, 0x85, 0x2f, 0xf4,
|
|
0x67, 0x33, 0xfe, 0x4a, 0x58, 0x77, 0x04, 0x16, 0x65, 0x43, 0x75, 0xc2, 0x07, 0x38, 0x25, 0x4d,
|
|
0x28, 0xb6, 0x25, 0x32, 0x85, 0x1a, 0xda, 0x66, 0xcd, 0xac, 0xe7, 0x5a, 0x3b, 0xbf, 0xaf, 0xaa,
|
|
0x56, 0x0f, 0xa7, 0x63, 0x79, 0xe0, 0x3e, 0x75, 0x69, 0x56, 0x11, 0x1b, 0x3c, 0x31, 0x08, 0x86,
|
|
0xb3, 0xc4, 0x70, 0xe7, 0x56, 0x43, 0x46, 0xe1, 0xee, 0x43, 0xb9, 0xcb, 0xa4, 0x8f, 0xea, 0x88,
|
|
0x29, 0xd6, 0x47, 0xae, 0x50, 0x12, 0x07, 0xe0, 0x2f, 0xd2, 0x97, 0x5a, 0x34, 0xc3, 0xb8, 0x7b,
|
|
0x50, 0x7a, 0x27, 0x03, 0x85, 0x14, 0x3f, 0x4e, 0x30, 0x52, 0x64, 0x17, 0xb6, 0xba, 0xe2, 0x03,
|
|
0xf2, 0x54, 0x9a, 0x80, 0x83, 0xdc, 0xa7, 0xaf, 0x55, 0xd3, 0xfd, 0x92, 0x83, 0xd2, 0xeb, 0x09,
|
|
0xca, 0xd9, 0xe9, 0x38, 0x7e, 0x7a, 0x74, 0xbb, 0x98, 0x3c, 0x82, 0x1d, 0x2f, 0xe0, 0x5a, 0x98,
|
|
0x49, 0x4e, 0x6f, 0x92, 0xe4, 0x25, 0x94, 0x3c, 0x36, 0xd5, 0x44, 0x37, 0x18, 0xa1, 0x7d, 0xb7,
|
|
0x66, 0xd6, 0x8b, 0xfb, 0x0f, 0x1b, 0xc9, 0xa0, 0x1b, 0xab, 0x41, 0x37, 0x8e, 0xd2, 0x41, 0xb7,
|
|
0x0a, 0xf3, 0xab, 0xaa, 0x71, 0xf1, 0xa3, 0x6a, 0xd2, 0x1b, 0xc6, 0xf8, 0x85, 0x87, 0x61, 0x28,
|
|
0xce, 0xdf, 0x28, 0x16, 0xa2, 0x9d, 0xab, 0x99, 0xf5, 0x02, 0xcd, 0x30, 0xe4, 0x09, 0xdc, 0x8f,
|
|
0x1f, 0x17, 0x48, 0x6c, 0x0b, 0x1e, 0x05, 0x91, 0x42, 0xae, 0xec, 0x2d, 0x2d, 0x5b, 0xff, 0x41,
|
|
0x2a, 0x50, 0x78, 0x1b, 0x61, 0x9b, 0xf5, 0xdf, 0xa3, 0x9d, 0xd7, 0xa2, 0x6b, 0x4c, 0x4e, 0xa1,
|
|
0xec, 0xb1, 0xa9, 0x3e, 0x75, 0x95, 0xca, 0xde, 0xde, 0x3c, 0xf6, 0x9a, 0x99, 0x3c, 0x87, 0xbc,
|
|
0xc7, 0xa6, 0x87, 0x3e, 0xda, 0x85, 0xcd, 0x8f, 0x49, 0x2d, 0xe4, 0x31, 0xdc, 0xf3, 0x26, 0x91,
|
|
0xa2, 0x78, 0xc6, 0xc2, 0x60, 0xc0, 0x14, 0xda, 0x96, 0xce, 0xfb, 0x0f, 0x1b, 0x0f, 0x5a, 0xdf,
|
|
0x7a, 0x32, 0x3c, 0x96, 0x52, 0x48, 0x1b, 0xfe, 0x63, 0xd0, 0x59, 0x23, 0x79, 0x00, 0xf9, 0x17,
|
|
0x41, 0x18, 0xd7, 0xa8, 0xa8, 0xd7, 0x9d, 0xa2, 0xb4, 0x1c, 0xdf, 0x4c, 0xb0, 0xf4, 0x52, 0x3c,
|
|
0x54, 0x2c, 0x6e, 0x46, 0xa6, 0xe6, 0x34, 0x01, 0xe4, 0x18, 0x8a, 0x1d, 0x16, 0xa9, 0xb6, 0xe0,
|
|
0x8a, 0xf5, 0x95, 0xee, 0xc5, 0x86, 0x49, 0xb2, 0x3e, 0x52, 0x83, 0xe2, 0x2b, 0x2e, 0xce, 0x79,
|
|
0x07, 0xd9, 0x00, 0xa5, 0x6e, 0x4e, 0x81, 0x66, 0x29, 0xb2, 0x07, 0xe5, 0xeb, 0x9d, 0xf6, 0x67,
|
|
0x1d, 0x3c, 0xc3, 0x50, 0x37, 0xc3, 0xa2, 0x6b, 0x7c, 0x12, 0xbf, 0x55, 0x9b, 0xff, 0x72, 0x8c,
|
|
0xf9, 0xc2, 0x31, 0x2f, 0x17, 0x8e, 0xf9, 0x73, 0xe1, 0x98, 0x9f, 0x97, 0x8e, 0x71, 0xb1, 0x74,
|
|
0x8c, 0xcb, 0xa5, 0x63, 0x7c, 0x5f, 0x3a, 0x46, 0x2f, 0xaf, 0xf3, 0x3d, 0xfb, 0x13, 0x00, 0x00,
|
|
0xff, 0xff, 0x1c, 0x85, 0xfc, 0x3b, 0x22, 0x04, 0x00, 0x00,
|
|
}
|
|
|
|
func (m *RaftIndex) 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 *RaftIndex) MarshalTo(dAtA []byte) (int, error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.CreateIndex != 0 {
|
|
dAtA[i] = 0x8
|
|
i++
|
|
i = encodeVarintCommon(dAtA, i, uint64(m.CreateIndex))
|
|
}
|
|
if m.ModifyIndex != 0 {
|
|
dAtA[i] = 0x10
|
|
i++
|
|
i = encodeVarintCommon(dAtA, i, uint64(m.ModifyIndex))
|
|
}
|
|
return i, nil
|
|
}
|
|
|
|
func (m *TargetDatacenter) 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 *TargetDatacenter) MarshalTo(dAtA []byte) (int, error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.Datacenter) > 0 {
|
|
dAtA[i] = 0xa
|
|
i++
|
|
i = encodeVarintCommon(dAtA, i, uint64(len(m.Datacenter)))
|
|
i += copy(dAtA[i:], m.Datacenter)
|
|
}
|
|
return i, nil
|
|
}
|
|
|
|
func (m *WriteRequest) 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 *WriteRequest) MarshalTo(dAtA []byte) (int, error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.Token) > 0 {
|
|
dAtA[i] = 0xa
|
|
i++
|
|
i = encodeVarintCommon(dAtA, i, uint64(len(m.Token)))
|
|
i += copy(dAtA[i:], m.Token)
|
|
}
|
|
return i, nil
|
|
}
|
|
|
|
func (m *QueryOptions) 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 *QueryOptions) MarshalTo(dAtA []byte) (int, error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.Token) > 0 {
|
|
dAtA[i] = 0xa
|
|
i++
|
|
i = encodeVarintCommon(dAtA, i, uint64(len(m.Token)))
|
|
i += copy(dAtA[i:], m.Token)
|
|
}
|
|
if m.MinQueryIndex != 0 {
|
|
dAtA[i] = 0x10
|
|
i++
|
|
i = encodeVarintCommon(dAtA, i, uint64(m.MinQueryIndex))
|
|
}
|
|
dAtA[i] = 0x1a
|
|
i++
|
|
i = encodeVarintCommon(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdDuration(m.MaxQueryTime)))
|
|
n1, err := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.MaxQueryTime, dAtA[i:])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i += n1
|
|
if m.AllowStale {
|
|
dAtA[i] = 0x20
|
|
i++
|
|
if m.AllowStale {
|
|
dAtA[i] = 1
|
|
} else {
|
|
dAtA[i] = 0
|
|
}
|
|
i++
|
|
}
|
|
if m.RequireConsistent {
|
|
dAtA[i] = 0x28
|
|
i++
|
|
if m.RequireConsistent {
|
|
dAtA[i] = 1
|
|
} else {
|
|
dAtA[i] = 0
|
|
}
|
|
i++
|
|
}
|
|
if m.UseCache {
|
|
dAtA[i] = 0x30
|
|
i++
|
|
if m.UseCache {
|
|
dAtA[i] = 1
|
|
} else {
|
|
dAtA[i] = 0
|
|
}
|
|
i++
|
|
}
|
|
dAtA[i] = 0x3a
|
|
i++
|
|
i = encodeVarintCommon(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdDuration(m.MaxStaleDuration)))
|
|
n2, err := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.MaxStaleDuration, dAtA[i:])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i += n2
|
|
dAtA[i] = 0x42
|
|
i++
|
|
i = encodeVarintCommon(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdDuration(m.MaxAge)))
|
|
n3, err := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.MaxAge, dAtA[i:])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i += n3
|
|
if m.MustRevalidate {
|
|
dAtA[i] = 0x48
|
|
i++
|
|
if m.MustRevalidate {
|
|
dAtA[i] = 1
|
|
} else {
|
|
dAtA[i] = 0
|
|
}
|
|
i++
|
|
}
|
|
dAtA[i] = 0x52
|
|
i++
|
|
i = encodeVarintCommon(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdDuration(m.StaleIfError)))
|
|
n4, err := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.StaleIfError, dAtA[i:])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i += n4
|
|
if len(m.Filter) > 0 {
|
|
dAtA[i] = 0x5a
|
|
i++
|
|
i = encodeVarintCommon(dAtA, i, uint64(len(m.Filter)))
|
|
i += copy(dAtA[i:], m.Filter)
|
|
}
|
|
return i, nil
|
|
}
|
|
|
|
func (m *QueryMeta) 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 *QueryMeta) MarshalTo(dAtA []byte) (int, error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.Index != 0 {
|
|
dAtA[i] = 0x8
|
|
i++
|
|
i = encodeVarintCommon(dAtA, i, uint64(m.Index))
|
|
}
|
|
dAtA[i] = 0x12
|
|
i++
|
|
i = encodeVarintCommon(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdDuration(m.LastContact)))
|
|
n5, err := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.LastContact, dAtA[i:])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i += n5
|
|
if m.KnownLeader {
|
|
dAtA[i] = 0x18
|
|
i++
|
|
if m.KnownLeader {
|
|
dAtA[i] = 1
|
|
} else {
|
|
dAtA[i] = 0
|
|
}
|
|
i++
|
|
}
|
|
if len(m.ConsistencyLevel) > 0 {
|
|
dAtA[i] = 0x22
|
|
i++
|
|
i = encodeVarintCommon(dAtA, i, uint64(len(m.ConsistencyLevel)))
|
|
i += copy(dAtA[i:], m.ConsistencyLevel)
|
|
}
|
|
return i, nil
|
|
}
|
|
|
|
func encodeVarintCommon(dAtA []byte, offset int, v uint64) int {
|
|
for v >= 1<<7 {
|
|
dAtA[offset] = uint8(v&0x7f | 0x80)
|
|
v >>= 7
|
|
offset++
|
|
}
|
|
dAtA[offset] = uint8(v)
|
|
return offset + 1
|
|
}
|
|
func (m *RaftIndex) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.CreateIndex != 0 {
|
|
n += 1 + sovCommon(uint64(m.CreateIndex))
|
|
}
|
|
if m.ModifyIndex != 0 {
|
|
n += 1 + sovCommon(uint64(m.ModifyIndex))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *TargetDatacenter) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
l = len(m.Datacenter)
|
|
if l > 0 {
|
|
n += 1 + l + sovCommon(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *WriteRequest) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
l = len(m.Token)
|
|
if l > 0 {
|
|
n += 1 + l + sovCommon(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *QueryOptions) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
l = len(m.Token)
|
|
if l > 0 {
|
|
n += 1 + l + sovCommon(uint64(l))
|
|
}
|
|
if m.MinQueryIndex != 0 {
|
|
n += 1 + sovCommon(uint64(m.MinQueryIndex))
|
|
}
|
|
l = github_com_gogo_protobuf_types.SizeOfStdDuration(m.MaxQueryTime)
|
|
n += 1 + l + sovCommon(uint64(l))
|
|
if m.AllowStale {
|
|
n += 2
|
|
}
|
|
if m.RequireConsistent {
|
|
n += 2
|
|
}
|
|
if m.UseCache {
|
|
n += 2
|
|
}
|
|
l = github_com_gogo_protobuf_types.SizeOfStdDuration(m.MaxStaleDuration)
|
|
n += 1 + l + sovCommon(uint64(l))
|
|
l = github_com_gogo_protobuf_types.SizeOfStdDuration(m.MaxAge)
|
|
n += 1 + l + sovCommon(uint64(l))
|
|
if m.MustRevalidate {
|
|
n += 2
|
|
}
|
|
l = github_com_gogo_protobuf_types.SizeOfStdDuration(m.StaleIfError)
|
|
n += 1 + l + sovCommon(uint64(l))
|
|
l = len(m.Filter)
|
|
if l > 0 {
|
|
n += 1 + l + sovCommon(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *QueryMeta) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.Index != 0 {
|
|
n += 1 + sovCommon(uint64(m.Index))
|
|
}
|
|
l = github_com_gogo_protobuf_types.SizeOfStdDuration(m.LastContact)
|
|
n += 1 + l + sovCommon(uint64(l))
|
|
if m.KnownLeader {
|
|
n += 2
|
|
}
|
|
l = len(m.ConsistencyLevel)
|
|
if l > 0 {
|
|
n += 1 + l + sovCommon(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func sovCommon(x uint64) (n int) {
|
|
for {
|
|
n++
|
|
x >>= 7
|
|
if x == 0 {
|
|
break
|
|
}
|
|
}
|
|
return n
|
|
}
|
|
func sozCommon(x uint64) (n int) {
|
|
return sovCommon(uint64((x << 1) ^ uint64((int64(x) >> 63))))
|
|
}
|
|
func (m *RaftIndex) 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 ErrIntOverflowCommon
|
|
}
|
|
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: RaftIndex: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: RaftIndex: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field CreateIndex", wireType)
|
|
}
|
|
m.CreateIndex = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowCommon
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.CreateIndex |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 2:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field ModifyIndex", wireType)
|
|
}
|
|
m.ModifyIndex = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowCommon
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.ModifyIndex |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipCommon(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthCommon
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthCommon
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *TargetDatacenter) 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 ErrIntOverflowCommon
|
|
}
|
|
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: TargetDatacenter: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: TargetDatacenter: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Datacenter", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowCommon
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
stringLen |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthCommon
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthCommon
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Datacenter = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipCommon(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthCommon
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthCommon
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *WriteRequest) 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 ErrIntOverflowCommon
|
|
}
|
|
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: WriteRequest: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: WriteRequest: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Token", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowCommon
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
stringLen |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthCommon
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthCommon
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Token = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipCommon(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthCommon
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthCommon
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *QueryOptions) 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 ErrIntOverflowCommon
|
|
}
|
|
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: QueryOptions: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: QueryOptions: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Token", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowCommon
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
stringLen |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthCommon
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthCommon
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Token = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field MinQueryIndex", wireType)
|
|
}
|
|
m.MinQueryIndex = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowCommon
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.MinQueryIndex |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 3:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field MaxQueryTime", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowCommon
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthCommon
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthCommon
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(&m.MaxQueryTime, dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 4:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field AllowStale", wireType)
|
|
}
|
|
var v int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowCommon
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
v |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
m.AllowStale = bool(v != 0)
|
|
case 5:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field RequireConsistent", wireType)
|
|
}
|
|
var v int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowCommon
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
v |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
m.RequireConsistent = bool(v != 0)
|
|
case 6:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field UseCache", wireType)
|
|
}
|
|
var v int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowCommon
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
v |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
m.UseCache = bool(v != 0)
|
|
case 7:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field MaxStaleDuration", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowCommon
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthCommon
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthCommon
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(&m.MaxStaleDuration, dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 8:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field MaxAge", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowCommon
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthCommon
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthCommon
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(&m.MaxAge, dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 9:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field MustRevalidate", wireType)
|
|
}
|
|
var v int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowCommon
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
v |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
m.MustRevalidate = bool(v != 0)
|
|
case 10:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field StaleIfError", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowCommon
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthCommon
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthCommon
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(&m.StaleIfError, dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 11:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Filter", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowCommon
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
stringLen |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthCommon
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthCommon
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Filter = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipCommon(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthCommon
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthCommon
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *QueryMeta) 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 ErrIntOverflowCommon
|
|
}
|
|
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: QueryMeta: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: QueryMeta: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
|
|
}
|
|
m.Index = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowCommon
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.Index |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field LastContact", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowCommon
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthCommon
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthCommon
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(&m.LastContact, dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 3:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field KnownLeader", wireType)
|
|
}
|
|
var v int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowCommon
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
v |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
m.KnownLeader = bool(v != 0)
|
|
case 4:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field ConsistencyLevel", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowCommon
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
stringLen |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthCommon
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthCommon
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.ConsistencyLevel = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipCommon(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthCommon
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthCommon
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func skipCommon(dAtA []byte) (n int, err error) {
|
|
l := len(dAtA)
|
|
iNdEx := 0
|
|
for iNdEx < l {
|
|
var wire uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return 0, ErrIntOverflowCommon
|
|
}
|
|
if iNdEx >= l {
|
|
return 0, io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
wire |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
wireType := int(wire & 0x7)
|
|
switch wireType {
|
|
case 0:
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return 0, ErrIntOverflowCommon
|
|
}
|
|
if iNdEx >= l {
|
|
return 0, io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx++
|
|
if dAtA[iNdEx-1] < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
return iNdEx, nil
|
|
case 1:
|
|
iNdEx += 8
|
|
return iNdEx, nil
|
|
case 2:
|
|
var length int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return 0, ErrIntOverflowCommon
|
|
}
|
|
if iNdEx >= l {
|
|
return 0, io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
length |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if length < 0 {
|
|
return 0, ErrInvalidLengthCommon
|
|
}
|
|
iNdEx += length
|
|
if iNdEx < 0 {
|
|
return 0, ErrInvalidLengthCommon
|
|
}
|
|
return iNdEx, nil
|
|
case 3:
|
|
for {
|
|
var innerWire uint64
|
|
var start int = iNdEx
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return 0, ErrIntOverflowCommon
|
|
}
|
|
if iNdEx >= l {
|
|
return 0, io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
innerWire |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
innerWireType := int(innerWire & 0x7)
|
|
if innerWireType == 4 {
|
|
break
|
|
}
|
|
next, err := skipCommon(dAtA[start:])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
iNdEx = start + next
|
|
if iNdEx < 0 {
|
|
return 0, ErrInvalidLengthCommon
|
|
}
|
|
}
|
|
return iNdEx, nil
|
|
case 4:
|
|
return iNdEx, nil
|
|
case 5:
|
|
iNdEx += 4
|
|
return iNdEx, nil
|
|
default:
|
|
return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
|
|
}
|
|
}
|
|
panic("unreachable")
|
|
}
|
|
|
|
var (
|
|
ErrInvalidLengthCommon = fmt.Errorf("proto: negative length found during unmarshaling")
|
|
ErrIntOverflowCommon = fmt.Errorf("proto: integer overflow")
|
|
)
|