3025 lines
66 KiB
Go
3025 lines
66 KiB
Go
// Code generated by protoc-gen-gogo.
|
|
// source: rpc.proto
|
|
// DO NOT EDIT!
|
|
|
|
package etcdserverpb
|
|
|
|
import proto "github.com/coreos/etcd/Godeps/_workspace/src/github.com/gogo/protobuf/proto"
|
|
|
|
// discarding unused import gogoproto "github.com/coreos/etcd/Godeps/_workspace/src/gogoproto"
|
|
import storagepb "github.com/coreos/etcd/storage/storagepb"
|
|
|
|
import (
|
|
context "github.com/coreos/etcd/Godeps/_workspace/src/golang.org/x/net/context"
|
|
grpc "github.com/coreos/etcd/Godeps/_workspace/src/google.golang.org/grpc"
|
|
)
|
|
|
|
import io "io"
|
|
import fmt "fmt"
|
|
|
|
// Reference imports to suppress errors if they are not otherwise used.
|
|
var _ = proto.Marshal
|
|
|
|
type Compare_CompareResult int32
|
|
|
|
const (
|
|
Compare_EQUAL Compare_CompareResult = 0
|
|
Compare_GREATER Compare_CompareResult = 1
|
|
Compare_LESS Compare_CompareResult = 2
|
|
)
|
|
|
|
var Compare_CompareResult_name = map[int32]string{
|
|
0: "EQUAL",
|
|
1: "GREATER",
|
|
2: "LESS",
|
|
}
|
|
var Compare_CompareResult_value = map[string]int32{
|
|
"EQUAL": 0,
|
|
"GREATER": 1,
|
|
"LESS": 2,
|
|
}
|
|
|
|
func (x Compare_CompareResult) String() string {
|
|
return proto.EnumName(Compare_CompareResult_name, int32(x))
|
|
}
|
|
|
|
type Compare_CompareTarget int32
|
|
|
|
const (
|
|
Compare_VERSION Compare_CompareTarget = 0
|
|
Compare_CREATE Compare_CompareTarget = 1
|
|
Compare_MOD Compare_CompareTarget = 2
|
|
Compare_VALUE Compare_CompareTarget = 3
|
|
)
|
|
|
|
var Compare_CompareTarget_name = map[int32]string{
|
|
0: "VERSION",
|
|
1: "CREATE",
|
|
2: "MOD",
|
|
3: "VALUE",
|
|
}
|
|
var Compare_CompareTarget_value = map[string]int32{
|
|
"VERSION": 0,
|
|
"CREATE": 1,
|
|
"MOD": 2,
|
|
"VALUE": 3,
|
|
}
|
|
|
|
func (x Compare_CompareTarget) String() string {
|
|
return proto.EnumName(Compare_CompareTarget_name, int32(x))
|
|
}
|
|
|
|
type ResponseHeader struct {
|
|
ClusterId uint64 `protobuf:"varint,1,opt,name=cluster_id,proto3" json:"cluster_id,omitempty"`
|
|
MemberId uint64 `protobuf:"varint,2,opt,name=member_id,proto3" json:"member_id,omitempty"`
|
|
// revision of the store when the request was applied.
|
|
Revision int64 `protobuf:"varint,3,opt,name=revision,proto3" json:"revision,omitempty"`
|
|
// term of raft when the request was applied.
|
|
RaftTerm uint64 `protobuf:"varint,4,opt,name=raft_term,proto3" json:"raft_term,omitempty"`
|
|
}
|
|
|
|
func (m *ResponseHeader) Reset() { *m = ResponseHeader{} }
|
|
func (m *ResponseHeader) String() string { return proto.CompactTextString(m) }
|
|
func (*ResponseHeader) ProtoMessage() {}
|
|
|
|
type RangeRequest struct {
|
|
// if the range_end is not given, the request returns the key.
|
|
Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
|
|
// if the range_end is given, it gets the keys in range [key, range_end).
|
|
RangeEnd []byte `protobuf:"bytes,2,opt,name=range_end,proto3" json:"range_end,omitempty"`
|
|
// limit the number of keys returned.
|
|
Limit int64 `protobuf:"varint,3,opt,name=limit,proto3" json:"limit,omitempty"`
|
|
// range over the store at the given revision.
|
|
// if revision is less or equal to zero, range over the newest store.
|
|
// if the revision has been compacted, ErrCompaction will be returned in
|
|
// response.
|
|
Revision int64 `protobuf:"varint,4,opt,name=revision,proto3" json:"revision,omitempty"`
|
|
}
|
|
|
|
func (m *RangeRequest) Reset() { *m = RangeRequest{} }
|
|
func (m *RangeRequest) String() string { return proto.CompactTextString(m) }
|
|
func (*RangeRequest) ProtoMessage() {}
|
|
|
|
type RangeResponse struct {
|
|
Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
|
|
Kvs []*storagepb.KeyValue `protobuf:"bytes,2,rep,name=kvs" json:"kvs,omitempty"`
|
|
// more indicates if there are more keys to return in the requested range.
|
|
More bool `protobuf:"varint,3,opt,name=more,proto3" json:"more,omitempty"`
|
|
}
|
|
|
|
func (m *RangeResponse) Reset() { *m = RangeResponse{} }
|
|
func (m *RangeResponse) String() string { return proto.CompactTextString(m) }
|
|
func (*RangeResponse) ProtoMessage() {}
|
|
|
|
func (m *RangeResponse) GetHeader() *ResponseHeader {
|
|
if m != nil {
|
|
return m.Header
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *RangeResponse) GetKvs() []*storagepb.KeyValue {
|
|
if m != nil {
|
|
return m.Kvs
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type PutRequest 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"`
|
|
}
|
|
|
|
func (m *PutRequest) Reset() { *m = PutRequest{} }
|
|
func (m *PutRequest) String() string { return proto.CompactTextString(m) }
|
|
func (*PutRequest) ProtoMessage() {}
|
|
|
|
type PutResponse struct {
|
|
Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
|
|
}
|
|
|
|
func (m *PutResponse) Reset() { *m = PutResponse{} }
|
|
func (m *PutResponse) String() string { return proto.CompactTextString(m) }
|
|
func (*PutResponse) ProtoMessage() {}
|
|
|
|
func (m *PutResponse) GetHeader() *ResponseHeader {
|
|
if m != nil {
|
|
return m.Header
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type DeleteRangeRequest struct {
|
|
// if the range_end is not given, the request deletes the key.
|
|
Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
|
|
// if the range_end is given, it deletes the keys in range [key, range_end).
|
|
RangeEnd []byte `protobuf:"bytes,2,opt,name=range_end,proto3" json:"range_end,omitempty"`
|
|
}
|
|
|
|
func (m *DeleteRangeRequest) Reset() { *m = DeleteRangeRequest{} }
|
|
func (m *DeleteRangeRequest) String() string { return proto.CompactTextString(m) }
|
|
func (*DeleteRangeRequest) ProtoMessage() {}
|
|
|
|
type DeleteRangeResponse struct {
|
|
Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
|
|
}
|
|
|
|
func (m *DeleteRangeResponse) Reset() { *m = DeleteRangeResponse{} }
|
|
func (m *DeleteRangeResponse) String() string { return proto.CompactTextString(m) }
|
|
func (*DeleteRangeResponse) ProtoMessage() {}
|
|
|
|
func (m *DeleteRangeResponse) GetHeader() *ResponseHeader {
|
|
if m != nil {
|
|
return m.Header
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type RequestUnion struct {
|
|
RequestRange *RangeRequest `protobuf:"bytes,1,opt,name=request_range" json:"request_range,omitempty"`
|
|
RequestPut *PutRequest `protobuf:"bytes,2,opt,name=request_put" json:"request_put,omitempty"`
|
|
RequestDeleteRange *DeleteRangeRequest `protobuf:"bytes,3,opt,name=request_delete_range" json:"request_delete_range,omitempty"`
|
|
}
|
|
|
|
func (m *RequestUnion) Reset() { *m = RequestUnion{} }
|
|
func (m *RequestUnion) String() string { return proto.CompactTextString(m) }
|
|
func (*RequestUnion) ProtoMessage() {}
|
|
|
|
func (m *RequestUnion) GetRequestRange() *RangeRequest {
|
|
if m != nil {
|
|
return m.RequestRange
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *RequestUnion) GetRequestPut() *PutRequest {
|
|
if m != nil {
|
|
return m.RequestPut
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *RequestUnion) GetRequestDeleteRange() *DeleteRangeRequest {
|
|
if m != nil {
|
|
return m.RequestDeleteRange
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type ResponseUnion struct {
|
|
ResponseRange *RangeResponse `protobuf:"bytes,1,opt,name=response_range" json:"response_range,omitempty"`
|
|
ResponsePut *PutResponse `protobuf:"bytes,2,opt,name=response_put" json:"response_put,omitempty"`
|
|
ResponseDeleteRange *DeleteRangeResponse `protobuf:"bytes,3,opt,name=response_delete_range" json:"response_delete_range,omitempty"`
|
|
}
|
|
|
|
func (m *ResponseUnion) Reset() { *m = ResponseUnion{} }
|
|
func (m *ResponseUnion) String() string { return proto.CompactTextString(m) }
|
|
func (*ResponseUnion) ProtoMessage() {}
|
|
|
|
func (m *ResponseUnion) GetResponseRange() *RangeResponse {
|
|
if m != nil {
|
|
return m.ResponseRange
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *ResponseUnion) GetResponsePut() *PutResponse {
|
|
if m != nil {
|
|
return m.ResponsePut
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *ResponseUnion) GetResponseDeleteRange() *DeleteRangeResponse {
|
|
if m != nil {
|
|
return m.ResponseDeleteRange
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type Compare struct {
|
|
Result Compare_CompareResult `protobuf:"varint,1,opt,name=result,proto3,enum=etcdserverpb.Compare_CompareResult" json:"result,omitempty"`
|
|
Target Compare_CompareTarget `protobuf:"varint,2,opt,name=target,proto3,enum=etcdserverpb.Compare_CompareTarget" json:"target,omitempty"`
|
|
// key path
|
|
Key []byte `protobuf:"bytes,3,opt,name=key,proto3" json:"key,omitempty"`
|
|
// version of the given key
|
|
Version int64 `protobuf:"varint,4,opt,name=version,proto3" json:"version,omitempty"`
|
|
// create revision of the given key
|
|
CreateRevision int64 `protobuf:"varint,5,opt,name=create_revision,proto3" json:"create_revision,omitempty"`
|
|
// last modified revision of the given key
|
|
ModRevision int64 `protobuf:"varint,6,opt,name=mod_revision,proto3" json:"mod_revision,omitempty"`
|
|
// value of the given key
|
|
Value []byte `protobuf:"bytes,7,opt,name=value,proto3" json:"value,omitempty"`
|
|
}
|
|
|
|
func (m *Compare) Reset() { *m = Compare{} }
|
|
func (m *Compare) String() string { return proto.CompactTextString(m) }
|
|
func (*Compare) ProtoMessage() {}
|
|
|
|
// From google paxosdb paper:
|
|
// Our implementation hinges around a powerful primitive which we call MultiOp. All other database
|
|
// operations except for iteration are implemented as a single call to MultiOp. A MultiOp is applied atomically
|
|
// and consists of three components:
|
|
// 1. A list of tests called guard. Each test in guard checks a single entry in the database. It may check
|
|
// for the absence or presence of a value, or compare with a given value. Two different tests in the guard
|
|
// may apply to the same or different entries in the database. All tests in the guard are applied and
|
|
// MultiOp returns the results. If all tests are true, MultiOp executes t op (see item 2 below), otherwise
|
|
// it executes f op (see item 3 below).
|
|
// 2. A list of database operations called t op. Each operation in the list is either an insert, delete, or
|
|
// lookup operation, and applies to a single database entry. Two different operations in the list may apply
|
|
// to the same or different entries in the database. These operations are executed
|
|
// if guard evaluates to
|
|
// true.
|
|
// 3. A list of database operations called f op. Like t op, but executed if guard evaluates to false.
|
|
type TxnRequest struct {
|
|
Compare []*Compare `protobuf:"bytes,1,rep,name=compare" json:"compare,omitempty"`
|
|
Success []*RequestUnion `protobuf:"bytes,2,rep,name=success" json:"success,omitempty"`
|
|
Failure []*RequestUnion `protobuf:"bytes,3,rep,name=failure" json:"failure,omitempty"`
|
|
}
|
|
|
|
func (m *TxnRequest) Reset() { *m = TxnRequest{} }
|
|
func (m *TxnRequest) String() string { return proto.CompactTextString(m) }
|
|
func (*TxnRequest) ProtoMessage() {}
|
|
|
|
func (m *TxnRequest) GetCompare() []*Compare {
|
|
if m != nil {
|
|
return m.Compare
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *TxnRequest) GetSuccess() []*RequestUnion {
|
|
if m != nil {
|
|
return m.Success
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *TxnRequest) GetFailure() []*RequestUnion {
|
|
if m != nil {
|
|
return m.Failure
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type TxnResponse struct {
|
|
Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
|
|
Succeeded bool `protobuf:"varint,2,opt,name=succeeded,proto3" json:"succeeded,omitempty"`
|
|
Responses []*ResponseUnion `protobuf:"bytes,3,rep,name=responses" json:"responses,omitempty"`
|
|
}
|
|
|
|
func (m *TxnResponse) Reset() { *m = TxnResponse{} }
|
|
func (m *TxnResponse) String() string { return proto.CompactTextString(m) }
|
|
func (*TxnResponse) ProtoMessage() {}
|
|
|
|
func (m *TxnResponse) GetHeader() *ResponseHeader {
|
|
if m != nil {
|
|
return m.Header
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *TxnResponse) GetResponses() []*ResponseUnion {
|
|
if m != nil {
|
|
return m.Responses
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Compaction compacts the kv store upto the given revision (including).
|
|
// It removes the old versions of a key. It keeps the newest version of
|
|
// the key even if its latest modification revision is smaller than the given
|
|
// revision.
|
|
type CompactionRequest struct {
|
|
Revision int64 `protobuf:"varint,1,opt,name=revision,proto3" json:"revision,omitempty"`
|
|
}
|
|
|
|
func (m *CompactionRequest) Reset() { *m = CompactionRequest{} }
|
|
func (m *CompactionRequest) String() string { return proto.CompactTextString(m) }
|
|
func (*CompactionRequest) ProtoMessage() {}
|
|
|
|
type CompactionResponse struct {
|
|
Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
|
|
}
|
|
|
|
func (m *CompactionResponse) Reset() { *m = CompactionResponse{} }
|
|
func (m *CompactionResponse) String() string { return proto.CompactTextString(m) }
|
|
func (*CompactionResponse) ProtoMessage() {}
|
|
|
|
func (m *CompactionResponse) GetHeader() *ResponseHeader {
|
|
if m != nil {
|
|
return m.Header
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func init() {
|
|
proto.RegisterEnum("etcdserverpb.Compare_CompareResult", Compare_CompareResult_name, Compare_CompareResult_value)
|
|
proto.RegisterEnum("etcdserverpb.Compare_CompareTarget", Compare_CompareTarget_name, Compare_CompareTarget_value)
|
|
}
|
|
|
|
// Reference imports to suppress errors if they are not otherwise used.
|
|
var _ context.Context
|
|
var _ grpc.ClientConn
|
|
|
|
// Client API for Etcd service
|
|
|
|
type EtcdClient interface {
|
|
// Range gets the keys in the range from the store.
|
|
Range(ctx context.Context, in *RangeRequest, opts ...grpc.CallOption) (*RangeResponse, error)
|
|
// Put puts the given key into the store.
|
|
// A put request increases the revision of the store,
|
|
// and generates one event in the event history.
|
|
Put(ctx context.Context, in *PutRequest, opts ...grpc.CallOption) (*PutResponse, error)
|
|
// Delete deletes the given range from the store.
|
|
// A delete request increase the revision of the store,
|
|
// and generates one event in the event history.
|
|
DeleteRange(ctx context.Context, in *DeleteRangeRequest, opts ...grpc.CallOption) (*DeleteRangeResponse, error)
|
|
// Txn processes all the requests in one transaction.
|
|
// A txn request increases the revision of the store,
|
|
// and generates events with the same revision in the event history.
|
|
Txn(ctx context.Context, in *TxnRequest, opts ...grpc.CallOption) (*TxnResponse, error)
|
|
// Compact compacts the event history in etcd. User should compact the
|
|
// event history periodically, or it will grow infinitely.
|
|
Compact(ctx context.Context, in *CompactionRequest, opts ...grpc.CallOption) (*CompactionResponse, error)
|
|
}
|
|
|
|
type etcdClient struct {
|
|
cc *grpc.ClientConn
|
|
}
|
|
|
|
func NewEtcdClient(cc *grpc.ClientConn) EtcdClient {
|
|
return &etcdClient{cc}
|
|
}
|
|
|
|
func (c *etcdClient) Range(ctx context.Context, in *RangeRequest, opts ...grpc.CallOption) (*RangeResponse, error) {
|
|
out := new(RangeResponse)
|
|
err := grpc.Invoke(ctx, "/etcdserverpb.etcd/Range", in, out, c.cc, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *etcdClient) Put(ctx context.Context, in *PutRequest, opts ...grpc.CallOption) (*PutResponse, error) {
|
|
out := new(PutResponse)
|
|
err := grpc.Invoke(ctx, "/etcdserverpb.etcd/Put", in, out, c.cc, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *etcdClient) DeleteRange(ctx context.Context, in *DeleteRangeRequest, opts ...grpc.CallOption) (*DeleteRangeResponse, error) {
|
|
out := new(DeleteRangeResponse)
|
|
err := grpc.Invoke(ctx, "/etcdserverpb.etcd/DeleteRange", in, out, c.cc, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *etcdClient) Txn(ctx context.Context, in *TxnRequest, opts ...grpc.CallOption) (*TxnResponse, error) {
|
|
out := new(TxnResponse)
|
|
err := grpc.Invoke(ctx, "/etcdserverpb.etcd/Txn", in, out, c.cc, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *etcdClient) Compact(ctx context.Context, in *CompactionRequest, opts ...grpc.CallOption) (*CompactionResponse, error) {
|
|
out := new(CompactionResponse)
|
|
err := grpc.Invoke(ctx, "/etcdserverpb.etcd/Compact", in, out, c.cc, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
// Server API for Etcd service
|
|
|
|
type EtcdServer interface {
|
|
// Range gets the keys in the range from the store.
|
|
Range(context.Context, *RangeRequest) (*RangeResponse, error)
|
|
// Put puts the given key into the store.
|
|
// A put request increases the revision of the store,
|
|
// and generates one event in the event history.
|
|
Put(context.Context, *PutRequest) (*PutResponse, error)
|
|
// Delete deletes the given range from the store.
|
|
// A delete request increase the revision of the store,
|
|
// and generates one event in the event history.
|
|
DeleteRange(context.Context, *DeleteRangeRequest) (*DeleteRangeResponse, error)
|
|
// Txn processes all the requests in one transaction.
|
|
// A txn request increases the revision of the store,
|
|
// and generates events with the same revision in the event history.
|
|
Txn(context.Context, *TxnRequest) (*TxnResponse, error)
|
|
// Compact compacts the event history in etcd. User should compact the
|
|
// event history periodically, or it will grow infinitely.
|
|
Compact(context.Context, *CompactionRequest) (*CompactionResponse, error)
|
|
}
|
|
|
|
func RegisterEtcdServer(s *grpc.Server, srv EtcdServer) {
|
|
s.RegisterService(&_Etcd_serviceDesc, srv)
|
|
}
|
|
|
|
func _Etcd_Range_Handler(srv interface{}, ctx context.Context, codec grpc.Codec, buf []byte) (interface{}, error) {
|
|
in := new(RangeRequest)
|
|
if err := codec.Unmarshal(buf, in); err != nil {
|
|
return nil, err
|
|
}
|
|
out, err := srv.(EtcdServer).Range(ctx, in)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func _Etcd_Put_Handler(srv interface{}, ctx context.Context, codec grpc.Codec, buf []byte) (interface{}, error) {
|
|
in := new(PutRequest)
|
|
if err := codec.Unmarshal(buf, in); err != nil {
|
|
return nil, err
|
|
}
|
|
out, err := srv.(EtcdServer).Put(ctx, in)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func _Etcd_DeleteRange_Handler(srv interface{}, ctx context.Context, codec grpc.Codec, buf []byte) (interface{}, error) {
|
|
in := new(DeleteRangeRequest)
|
|
if err := codec.Unmarshal(buf, in); err != nil {
|
|
return nil, err
|
|
}
|
|
out, err := srv.(EtcdServer).DeleteRange(ctx, in)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func _Etcd_Txn_Handler(srv interface{}, ctx context.Context, codec grpc.Codec, buf []byte) (interface{}, error) {
|
|
in := new(TxnRequest)
|
|
if err := codec.Unmarshal(buf, in); err != nil {
|
|
return nil, err
|
|
}
|
|
out, err := srv.(EtcdServer).Txn(ctx, in)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func _Etcd_Compact_Handler(srv interface{}, ctx context.Context, codec grpc.Codec, buf []byte) (interface{}, error) {
|
|
in := new(CompactionRequest)
|
|
if err := codec.Unmarshal(buf, in); err != nil {
|
|
return nil, err
|
|
}
|
|
out, err := srv.(EtcdServer).Compact(ctx, in)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
var _Etcd_serviceDesc = grpc.ServiceDesc{
|
|
ServiceName: "etcdserverpb.etcd",
|
|
HandlerType: (*EtcdServer)(nil),
|
|
Methods: []grpc.MethodDesc{
|
|
{
|
|
MethodName: "Range",
|
|
Handler: _Etcd_Range_Handler,
|
|
},
|
|
{
|
|
MethodName: "Put",
|
|
Handler: _Etcd_Put_Handler,
|
|
},
|
|
{
|
|
MethodName: "DeleteRange",
|
|
Handler: _Etcd_DeleteRange_Handler,
|
|
},
|
|
{
|
|
MethodName: "Txn",
|
|
Handler: _Etcd_Txn_Handler,
|
|
},
|
|
{
|
|
MethodName: "Compact",
|
|
Handler: _Etcd_Compact_Handler,
|
|
},
|
|
},
|
|
Streams: []grpc.StreamDesc{},
|
|
}
|
|
|
|
func (m *ResponseHeader) 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 *ResponseHeader) MarshalTo(data []byte) (int, error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.ClusterId != 0 {
|
|
data[i] = 0x8
|
|
i++
|
|
i = encodeVarintRpc(data, i, uint64(m.ClusterId))
|
|
}
|
|
if m.MemberId != 0 {
|
|
data[i] = 0x10
|
|
i++
|
|
i = encodeVarintRpc(data, i, uint64(m.MemberId))
|
|
}
|
|
if m.Revision != 0 {
|
|
data[i] = 0x18
|
|
i++
|
|
i = encodeVarintRpc(data, i, uint64(m.Revision))
|
|
}
|
|
if m.RaftTerm != 0 {
|
|
data[i] = 0x20
|
|
i++
|
|
i = encodeVarintRpc(data, i, uint64(m.RaftTerm))
|
|
}
|
|
return i, nil
|
|
}
|
|
|
|
func (m *RangeRequest) 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 *RangeRequest) MarshalTo(data []byte) (int, error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.Key != nil {
|
|
if len(m.Key) > 0 {
|
|
data[i] = 0xa
|
|
i++
|
|
i = encodeVarintRpc(data, i, uint64(len(m.Key)))
|
|
i += copy(data[i:], m.Key)
|
|
}
|
|
}
|
|
if m.RangeEnd != nil {
|
|
if len(m.RangeEnd) > 0 {
|
|
data[i] = 0x12
|
|
i++
|
|
i = encodeVarintRpc(data, i, uint64(len(m.RangeEnd)))
|
|
i += copy(data[i:], m.RangeEnd)
|
|
}
|
|
}
|
|
if m.Limit != 0 {
|
|
data[i] = 0x18
|
|
i++
|
|
i = encodeVarintRpc(data, i, uint64(m.Limit))
|
|
}
|
|
if m.Revision != 0 {
|
|
data[i] = 0x20
|
|
i++
|
|
i = encodeVarintRpc(data, i, uint64(m.Revision))
|
|
}
|
|
return i, nil
|
|
}
|
|
|
|
func (m *RangeResponse) 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 *RangeResponse) MarshalTo(data []byte) (int, error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.Header != nil {
|
|
data[i] = 0xa
|
|
i++
|
|
i = encodeVarintRpc(data, i, uint64(m.Header.Size()))
|
|
n1, err := m.Header.MarshalTo(data[i:])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i += n1
|
|
}
|
|
if len(m.Kvs) > 0 {
|
|
for _, msg := range m.Kvs {
|
|
data[i] = 0x12
|
|
i++
|
|
i = encodeVarintRpc(data, i, uint64(msg.Size()))
|
|
n, err := msg.MarshalTo(data[i:])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i += n
|
|
}
|
|
}
|
|
if m.More {
|
|
data[i] = 0x18
|
|
i++
|
|
if m.More {
|
|
data[i] = 1
|
|
} else {
|
|
data[i] = 0
|
|
}
|
|
i++
|
|
}
|
|
return i, nil
|
|
}
|
|
|
|
func (m *PutRequest) 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 *PutRequest) MarshalTo(data []byte) (int, error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.Key != nil {
|
|
if len(m.Key) > 0 {
|
|
data[i] = 0xa
|
|
i++
|
|
i = encodeVarintRpc(data, i, uint64(len(m.Key)))
|
|
i += copy(data[i:], m.Key)
|
|
}
|
|
}
|
|
if m.Value != nil {
|
|
if len(m.Value) > 0 {
|
|
data[i] = 0x12
|
|
i++
|
|
i = encodeVarintRpc(data, i, uint64(len(m.Value)))
|
|
i += copy(data[i:], m.Value)
|
|
}
|
|
}
|
|
return i, nil
|
|
}
|
|
|
|
func (m *PutResponse) 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 *PutResponse) MarshalTo(data []byte) (int, error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.Header != nil {
|
|
data[i] = 0xa
|
|
i++
|
|
i = encodeVarintRpc(data, i, uint64(m.Header.Size()))
|
|
n2, err := m.Header.MarshalTo(data[i:])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i += n2
|
|
}
|
|
return i, nil
|
|
}
|
|
|
|
func (m *DeleteRangeRequest) 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 *DeleteRangeRequest) MarshalTo(data []byte) (int, error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.Key != nil {
|
|
if len(m.Key) > 0 {
|
|
data[i] = 0xa
|
|
i++
|
|
i = encodeVarintRpc(data, i, uint64(len(m.Key)))
|
|
i += copy(data[i:], m.Key)
|
|
}
|
|
}
|
|
if m.RangeEnd != nil {
|
|
if len(m.RangeEnd) > 0 {
|
|
data[i] = 0x12
|
|
i++
|
|
i = encodeVarintRpc(data, i, uint64(len(m.RangeEnd)))
|
|
i += copy(data[i:], m.RangeEnd)
|
|
}
|
|
}
|
|
return i, nil
|
|
}
|
|
|
|
func (m *DeleteRangeResponse) 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 *DeleteRangeResponse) MarshalTo(data []byte) (int, error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.Header != nil {
|
|
data[i] = 0xa
|
|
i++
|
|
i = encodeVarintRpc(data, i, uint64(m.Header.Size()))
|
|
n3, err := m.Header.MarshalTo(data[i:])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i += n3
|
|
}
|
|
return i, nil
|
|
}
|
|
|
|
func (m *RequestUnion) 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 *RequestUnion) MarshalTo(data []byte) (int, error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.RequestRange != nil {
|
|
data[i] = 0xa
|
|
i++
|
|
i = encodeVarintRpc(data, i, uint64(m.RequestRange.Size()))
|
|
n4, err := m.RequestRange.MarshalTo(data[i:])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i += n4
|
|
}
|
|
if m.RequestPut != nil {
|
|
data[i] = 0x12
|
|
i++
|
|
i = encodeVarintRpc(data, i, uint64(m.RequestPut.Size()))
|
|
n5, err := m.RequestPut.MarshalTo(data[i:])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i += n5
|
|
}
|
|
if m.RequestDeleteRange != nil {
|
|
data[i] = 0x1a
|
|
i++
|
|
i = encodeVarintRpc(data, i, uint64(m.RequestDeleteRange.Size()))
|
|
n6, err := m.RequestDeleteRange.MarshalTo(data[i:])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i += n6
|
|
}
|
|
return i, nil
|
|
}
|
|
|
|
func (m *ResponseUnion) 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 *ResponseUnion) MarshalTo(data []byte) (int, error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.ResponseRange != nil {
|
|
data[i] = 0xa
|
|
i++
|
|
i = encodeVarintRpc(data, i, uint64(m.ResponseRange.Size()))
|
|
n7, err := m.ResponseRange.MarshalTo(data[i:])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i += n7
|
|
}
|
|
if m.ResponsePut != nil {
|
|
data[i] = 0x12
|
|
i++
|
|
i = encodeVarintRpc(data, i, uint64(m.ResponsePut.Size()))
|
|
n8, err := m.ResponsePut.MarshalTo(data[i:])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i += n8
|
|
}
|
|
if m.ResponseDeleteRange != nil {
|
|
data[i] = 0x1a
|
|
i++
|
|
i = encodeVarintRpc(data, i, uint64(m.ResponseDeleteRange.Size()))
|
|
n9, err := m.ResponseDeleteRange.MarshalTo(data[i:])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i += n9
|
|
}
|
|
return i, nil
|
|
}
|
|
|
|
func (m *Compare) 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 *Compare) MarshalTo(data []byte) (int, error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.Result != 0 {
|
|
data[i] = 0x8
|
|
i++
|
|
i = encodeVarintRpc(data, i, uint64(m.Result))
|
|
}
|
|
if m.Target != 0 {
|
|
data[i] = 0x10
|
|
i++
|
|
i = encodeVarintRpc(data, i, uint64(m.Target))
|
|
}
|
|
if m.Key != nil {
|
|
if len(m.Key) > 0 {
|
|
data[i] = 0x1a
|
|
i++
|
|
i = encodeVarintRpc(data, i, uint64(len(m.Key)))
|
|
i += copy(data[i:], m.Key)
|
|
}
|
|
}
|
|
if m.Version != 0 {
|
|
data[i] = 0x20
|
|
i++
|
|
i = encodeVarintRpc(data, i, uint64(m.Version))
|
|
}
|
|
if m.CreateRevision != 0 {
|
|
data[i] = 0x28
|
|
i++
|
|
i = encodeVarintRpc(data, i, uint64(m.CreateRevision))
|
|
}
|
|
if m.ModRevision != 0 {
|
|
data[i] = 0x30
|
|
i++
|
|
i = encodeVarintRpc(data, i, uint64(m.ModRevision))
|
|
}
|
|
if m.Value != nil {
|
|
if len(m.Value) > 0 {
|
|
data[i] = 0x3a
|
|
i++
|
|
i = encodeVarintRpc(data, i, uint64(len(m.Value)))
|
|
i += copy(data[i:], m.Value)
|
|
}
|
|
}
|
|
return i, nil
|
|
}
|
|
|
|
func (m *TxnRequest) 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 *TxnRequest) MarshalTo(data []byte) (int, error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.Compare) > 0 {
|
|
for _, msg := range m.Compare {
|
|
data[i] = 0xa
|
|
i++
|
|
i = encodeVarintRpc(data, i, uint64(msg.Size()))
|
|
n, err := msg.MarshalTo(data[i:])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i += n
|
|
}
|
|
}
|
|
if len(m.Success) > 0 {
|
|
for _, msg := range m.Success {
|
|
data[i] = 0x12
|
|
i++
|
|
i = encodeVarintRpc(data, i, uint64(msg.Size()))
|
|
n, err := msg.MarshalTo(data[i:])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i += n
|
|
}
|
|
}
|
|
if len(m.Failure) > 0 {
|
|
for _, msg := range m.Failure {
|
|
data[i] = 0x1a
|
|
i++
|
|
i = encodeVarintRpc(data, i, uint64(msg.Size()))
|
|
n, err := msg.MarshalTo(data[i:])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i += n
|
|
}
|
|
}
|
|
return i, nil
|
|
}
|
|
|
|
func (m *TxnResponse) 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 *TxnResponse) MarshalTo(data []byte) (int, error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.Header != nil {
|
|
data[i] = 0xa
|
|
i++
|
|
i = encodeVarintRpc(data, i, uint64(m.Header.Size()))
|
|
n10, err := m.Header.MarshalTo(data[i:])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i += n10
|
|
}
|
|
if m.Succeeded {
|
|
data[i] = 0x10
|
|
i++
|
|
if m.Succeeded {
|
|
data[i] = 1
|
|
} else {
|
|
data[i] = 0
|
|
}
|
|
i++
|
|
}
|
|
if len(m.Responses) > 0 {
|
|
for _, msg := range m.Responses {
|
|
data[i] = 0x1a
|
|
i++
|
|
i = encodeVarintRpc(data, i, uint64(msg.Size()))
|
|
n, err := msg.MarshalTo(data[i:])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i += n
|
|
}
|
|
}
|
|
return i, nil
|
|
}
|
|
|
|
func (m *CompactionRequest) 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 *CompactionRequest) MarshalTo(data []byte) (int, error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.Revision != 0 {
|
|
data[i] = 0x8
|
|
i++
|
|
i = encodeVarintRpc(data, i, uint64(m.Revision))
|
|
}
|
|
return i, nil
|
|
}
|
|
|
|
func (m *CompactionResponse) 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 *CompactionResponse) MarshalTo(data []byte) (int, error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.Header != nil {
|
|
data[i] = 0xa
|
|
i++
|
|
i = encodeVarintRpc(data, i, uint64(m.Header.Size()))
|
|
n11, err := m.Header.MarshalTo(data[i:])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i += n11
|
|
}
|
|
return i, nil
|
|
}
|
|
|
|
func encodeFixed64Rpc(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 encodeFixed32Rpc(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 encodeVarintRpc(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 *ResponseHeader) Size() (n int) {
|
|
var l int
|
|
_ = l
|
|
if m.ClusterId != 0 {
|
|
n += 1 + sovRpc(uint64(m.ClusterId))
|
|
}
|
|
if m.MemberId != 0 {
|
|
n += 1 + sovRpc(uint64(m.MemberId))
|
|
}
|
|
if m.Revision != 0 {
|
|
n += 1 + sovRpc(uint64(m.Revision))
|
|
}
|
|
if m.RaftTerm != 0 {
|
|
n += 1 + sovRpc(uint64(m.RaftTerm))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *RangeRequest) Size() (n int) {
|
|
var l int
|
|
_ = l
|
|
if m.Key != nil {
|
|
l = len(m.Key)
|
|
if l > 0 {
|
|
n += 1 + l + sovRpc(uint64(l))
|
|
}
|
|
}
|
|
if m.RangeEnd != nil {
|
|
l = len(m.RangeEnd)
|
|
if l > 0 {
|
|
n += 1 + l + sovRpc(uint64(l))
|
|
}
|
|
}
|
|
if m.Limit != 0 {
|
|
n += 1 + sovRpc(uint64(m.Limit))
|
|
}
|
|
if m.Revision != 0 {
|
|
n += 1 + sovRpc(uint64(m.Revision))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *RangeResponse) Size() (n int) {
|
|
var l int
|
|
_ = l
|
|
if m.Header != nil {
|
|
l = m.Header.Size()
|
|
n += 1 + l + sovRpc(uint64(l))
|
|
}
|
|
if len(m.Kvs) > 0 {
|
|
for _, e := range m.Kvs {
|
|
l = e.Size()
|
|
n += 1 + l + sovRpc(uint64(l))
|
|
}
|
|
}
|
|
if m.More {
|
|
n += 2
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *PutRequest) Size() (n int) {
|
|
var l int
|
|
_ = l
|
|
if m.Key != nil {
|
|
l = len(m.Key)
|
|
if l > 0 {
|
|
n += 1 + l + sovRpc(uint64(l))
|
|
}
|
|
}
|
|
if m.Value != nil {
|
|
l = len(m.Value)
|
|
if l > 0 {
|
|
n += 1 + l + sovRpc(uint64(l))
|
|
}
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *PutResponse) Size() (n int) {
|
|
var l int
|
|
_ = l
|
|
if m.Header != nil {
|
|
l = m.Header.Size()
|
|
n += 1 + l + sovRpc(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *DeleteRangeRequest) Size() (n int) {
|
|
var l int
|
|
_ = l
|
|
if m.Key != nil {
|
|
l = len(m.Key)
|
|
if l > 0 {
|
|
n += 1 + l + sovRpc(uint64(l))
|
|
}
|
|
}
|
|
if m.RangeEnd != nil {
|
|
l = len(m.RangeEnd)
|
|
if l > 0 {
|
|
n += 1 + l + sovRpc(uint64(l))
|
|
}
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *DeleteRangeResponse) Size() (n int) {
|
|
var l int
|
|
_ = l
|
|
if m.Header != nil {
|
|
l = m.Header.Size()
|
|
n += 1 + l + sovRpc(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *RequestUnion) Size() (n int) {
|
|
var l int
|
|
_ = l
|
|
if m.RequestRange != nil {
|
|
l = m.RequestRange.Size()
|
|
n += 1 + l + sovRpc(uint64(l))
|
|
}
|
|
if m.RequestPut != nil {
|
|
l = m.RequestPut.Size()
|
|
n += 1 + l + sovRpc(uint64(l))
|
|
}
|
|
if m.RequestDeleteRange != nil {
|
|
l = m.RequestDeleteRange.Size()
|
|
n += 1 + l + sovRpc(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *ResponseUnion) Size() (n int) {
|
|
var l int
|
|
_ = l
|
|
if m.ResponseRange != nil {
|
|
l = m.ResponseRange.Size()
|
|
n += 1 + l + sovRpc(uint64(l))
|
|
}
|
|
if m.ResponsePut != nil {
|
|
l = m.ResponsePut.Size()
|
|
n += 1 + l + sovRpc(uint64(l))
|
|
}
|
|
if m.ResponseDeleteRange != nil {
|
|
l = m.ResponseDeleteRange.Size()
|
|
n += 1 + l + sovRpc(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *Compare) Size() (n int) {
|
|
var l int
|
|
_ = l
|
|
if m.Result != 0 {
|
|
n += 1 + sovRpc(uint64(m.Result))
|
|
}
|
|
if m.Target != 0 {
|
|
n += 1 + sovRpc(uint64(m.Target))
|
|
}
|
|
if m.Key != nil {
|
|
l = len(m.Key)
|
|
if l > 0 {
|
|
n += 1 + l + sovRpc(uint64(l))
|
|
}
|
|
}
|
|
if m.Version != 0 {
|
|
n += 1 + sovRpc(uint64(m.Version))
|
|
}
|
|
if m.CreateRevision != 0 {
|
|
n += 1 + sovRpc(uint64(m.CreateRevision))
|
|
}
|
|
if m.ModRevision != 0 {
|
|
n += 1 + sovRpc(uint64(m.ModRevision))
|
|
}
|
|
if m.Value != nil {
|
|
l = len(m.Value)
|
|
if l > 0 {
|
|
n += 1 + l + sovRpc(uint64(l))
|
|
}
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *TxnRequest) Size() (n int) {
|
|
var l int
|
|
_ = l
|
|
if len(m.Compare) > 0 {
|
|
for _, e := range m.Compare {
|
|
l = e.Size()
|
|
n += 1 + l + sovRpc(uint64(l))
|
|
}
|
|
}
|
|
if len(m.Success) > 0 {
|
|
for _, e := range m.Success {
|
|
l = e.Size()
|
|
n += 1 + l + sovRpc(uint64(l))
|
|
}
|
|
}
|
|
if len(m.Failure) > 0 {
|
|
for _, e := range m.Failure {
|
|
l = e.Size()
|
|
n += 1 + l + sovRpc(uint64(l))
|
|
}
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *TxnResponse) Size() (n int) {
|
|
var l int
|
|
_ = l
|
|
if m.Header != nil {
|
|
l = m.Header.Size()
|
|
n += 1 + l + sovRpc(uint64(l))
|
|
}
|
|
if m.Succeeded {
|
|
n += 2
|
|
}
|
|
if len(m.Responses) > 0 {
|
|
for _, e := range m.Responses {
|
|
l = e.Size()
|
|
n += 1 + l + sovRpc(uint64(l))
|
|
}
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *CompactionRequest) Size() (n int) {
|
|
var l int
|
|
_ = l
|
|
if m.Revision != 0 {
|
|
n += 1 + sovRpc(uint64(m.Revision))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *CompactionResponse) Size() (n int) {
|
|
var l int
|
|
_ = l
|
|
if m.Header != nil {
|
|
l = m.Header.Size()
|
|
n += 1 + l + sovRpc(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func sovRpc(x uint64) (n int) {
|
|
for {
|
|
n++
|
|
x >>= 7
|
|
if x == 0 {
|
|
break
|
|
}
|
|
}
|
|
return n
|
|
}
|
|
func sozRpc(x uint64) (n int) {
|
|
return sovRpc(uint64((x << 1) ^ uint64((int64(x) >> 63))))
|
|
}
|
|
func (m *ResponseHeader) Unmarshal(data []byte) error {
|
|
l := len(data)
|
|
iNdEx := 0
|
|
for iNdEx < l {
|
|
var wire uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
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)
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field ClusterId", wireType)
|
|
}
|
|
m.ClusterId = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
m.ClusterId |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 2:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field MemberId", wireType)
|
|
}
|
|
m.MemberId = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
m.MemberId |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 3:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Revision", wireType)
|
|
}
|
|
m.Revision = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
m.Revision |= (int64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 4:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field RaftTerm", wireType)
|
|
}
|
|
m.RaftTerm = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
m.RaftTerm |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
default:
|
|
var sizeOfWire int
|
|
for {
|
|
sizeOfWire++
|
|
wire >>= 7
|
|
if wire == 0 {
|
|
break
|
|
}
|
|
}
|
|
iNdEx -= sizeOfWire
|
|
skippy, err := skipRpc(data[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthRpc
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
func (m *RangeRequest) Unmarshal(data []byte) error {
|
|
l := len(data)
|
|
iNdEx := 0
|
|
for iNdEx < l {
|
|
var wire uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
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)
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
|
|
}
|
|
var byteLen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
byteLen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if byteLen < 0 {
|
|
return ErrInvalidLengthRpc
|
|
}
|
|
postIndex := iNdEx + byteLen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Key = append([]byte{}, data[iNdEx:postIndex]...)
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field RangeEnd", wireType)
|
|
}
|
|
var byteLen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
byteLen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if byteLen < 0 {
|
|
return ErrInvalidLengthRpc
|
|
}
|
|
postIndex := iNdEx + byteLen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.RangeEnd = append([]byte{}, data[iNdEx:postIndex]...)
|
|
iNdEx = postIndex
|
|
case 3:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType)
|
|
}
|
|
m.Limit = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
m.Limit |= (int64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 4:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Revision", wireType)
|
|
}
|
|
m.Revision = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
m.Revision |= (int64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
default:
|
|
var sizeOfWire int
|
|
for {
|
|
sizeOfWire++
|
|
wire >>= 7
|
|
if wire == 0 {
|
|
break
|
|
}
|
|
}
|
|
iNdEx -= sizeOfWire
|
|
skippy, err := skipRpc(data[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthRpc
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
func (m *RangeResponse) Unmarshal(data []byte) error {
|
|
l := len(data)
|
|
iNdEx := 0
|
|
for iNdEx < l {
|
|
var wire uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
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)
|
|
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 iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
msglen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthRpc
|
|
}
|
|
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 Kvs", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
msglen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthRpc
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Kvs = append(m.Kvs, &storagepb.KeyValue{})
|
|
if err := m.Kvs[len(m.Kvs)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 3:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field More", wireType)
|
|
}
|
|
var v int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
v |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
m.More = bool(v != 0)
|
|
default:
|
|
var sizeOfWire int
|
|
for {
|
|
sizeOfWire++
|
|
wire >>= 7
|
|
if wire == 0 {
|
|
break
|
|
}
|
|
}
|
|
iNdEx -= sizeOfWire
|
|
skippy, err := skipRpc(data[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthRpc
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
func (m *PutRequest) Unmarshal(data []byte) error {
|
|
l := len(data)
|
|
iNdEx := 0
|
|
for iNdEx < l {
|
|
var wire uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
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)
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
|
|
}
|
|
var byteLen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
byteLen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if byteLen < 0 {
|
|
return ErrInvalidLengthRpc
|
|
}
|
|
postIndex := iNdEx + byteLen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Key = append([]byte{}, data[iNdEx:postIndex]...)
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
|
|
}
|
|
var byteLen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
byteLen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if byteLen < 0 {
|
|
return ErrInvalidLengthRpc
|
|
}
|
|
postIndex := iNdEx + byteLen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Value = append([]byte{}, data[iNdEx:postIndex]...)
|
|
iNdEx = postIndex
|
|
default:
|
|
var sizeOfWire int
|
|
for {
|
|
sizeOfWire++
|
|
wire >>= 7
|
|
if wire == 0 {
|
|
break
|
|
}
|
|
}
|
|
iNdEx -= sizeOfWire
|
|
skippy, err := skipRpc(data[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthRpc
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
func (m *PutResponse) Unmarshal(data []byte) error {
|
|
l := len(data)
|
|
iNdEx := 0
|
|
for iNdEx < l {
|
|
var wire uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
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)
|
|
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 iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
msglen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthRpc
|
|
}
|
|
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
|
|
default:
|
|
var sizeOfWire int
|
|
for {
|
|
sizeOfWire++
|
|
wire >>= 7
|
|
if wire == 0 {
|
|
break
|
|
}
|
|
}
|
|
iNdEx -= sizeOfWire
|
|
skippy, err := skipRpc(data[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthRpc
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
func (m *DeleteRangeRequest) Unmarshal(data []byte) error {
|
|
l := len(data)
|
|
iNdEx := 0
|
|
for iNdEx < l {
|
|
var wire uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
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)
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
|
|
}
|
|
var byteLen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
byteLen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if byteLen < 0 {
|
|
return ErrInvalidLengthRpc
|
|
}
|
|
postIndex := iNdEx + byteLen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Key = append([]byte{}, data[iNdEx:postIndex]...)
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field RangeEnd", wireType)
|
|
}
|
|
var byteLen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
byteLen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if byteLen < 0 {
|
|
return ErrInvalidLengthRpc
|
|
}
|
|
postIndex := iNdEx + byteLen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.RangeEnd = append([]byte{}, data[iNdEx:postIndex]...)
|
|
iNdEx = postIndex
|
|
default:
|
|
var sizeOfWire int
|
|
for {
|
|
sizeOfWire++
|
|
wire >>= 7
|
|
if wire == 0 {
|
|
break
|
|
}
|
|
}
|
|
iNdEx -= sizeOfWire
|
|
skippy, err := skipRpc(data[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthRpc
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
func (m *DeleteRangeResponse) Unmarshal(data []byte) error {
|
|
l := len(data)
|
|
iNdEx := 0
|
|
for iNdEx < l {
|
|
var wire uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
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)
|
|
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 iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
msglen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthRpc
|
|
}
|
|
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
|
|
default:
|
|
var sizeOfWire int
|
|
for {
|
|
sizeOfWire++
|
|
wire >>= 7
|
|
if wire == 0 {
|
|
break
|
|
}
|
|
}
|
|
iNdEx -= sizeOfWire
|
|
skippy, err := skipRpc(data[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthRpc
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
func (m *RequestUnion) Unmarshal(data []byte) error {
|
|
l := len(data)
|
|
iNdEx := 0
|
|
for iNdEx < l {
|
|
var wire uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
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)
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field RequestRange", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
msglen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthRpc
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.RequestRange == nil {
|
|
m.RequestRange = &RangeRequest{}
|
|
}
|
|
if err := m.RequestRange.Unmarshal(data[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field RequestPut", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
msglen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthRpc
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.RequestPut == nil {
|
|
m.RequestPut = &PutRequest{}
|
|
}
|
|
if err := m.RequestPut.Unmarshal(data[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 3:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field RequestDeleteRange", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
msglen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthRpc
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.RequestDeleteRange == nil {
|
|
m.RequestDeleteRange = &DeleteRangeRequest{}
|
|
}
|
|
if err := m.RequestDeleteRange.Unmarshal(data[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
var sizeOfWire int
|
|
for {
|
|
sizeOfWire++
|
|
wire >>= 7
|
|
if wire == 0 {
|
|
break
|
|
}
|
|
}
|
|
iNdEx -= sizeOfWire
|
|
skippy, err := skipRpc(data[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthRpc
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
func (m *ResponseUnion) Unmarshal(data []byte) error {
|
|
l := len(data)
|
|
iNdEx := 0
|
|
for iNdEx < l {
|
|
var wire uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
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)
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field ResponseRange", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
msglen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthRpc
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.ResponseRange == nil {
|
|
m.ResponseRange = &RangeResponse{}
|
|
}
|
|
if err := m.ResponseRange.Unmarshal(data[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field ResponsePut", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
msglen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthRpc
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.ResponsePut == nil {
|
|
m.ResponsePut = &PutResponse{}
|
|
}
|
|
if err := m.ResponsePut.Unmarshal(data[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 3:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field ResponseDeleteRange", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
msglen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthRpc
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.ResponseDeleteRange == nil {
|
|
m.ResponseDeleteRange = &DeleteRangeResponse{}
|
|
}
|
|
if err := m.ResponseDeleteRange.Unmarshal(data[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
var sizeOfWire int
|
|
for {
|
|
sizeOfWire++
|
|
wire >>= 7
|
|
if wire == 0 {
|
|
break
|
|
}
|
|
}
|
|
iNdEx -= sizeOfWire
|
|
skippy, err := skipRpc(data[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthRpc
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
func (m *Compare) Unmarshal(data []byte) error {
|
|
l := len(data)
|
|
iNdEx := 0
|
|
for iNdEx < l {
|
|
var wire uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
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)
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType)
|
|
}
|
|
m.Result = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
m.Result |= (Compare_CompareResult(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 2:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType)
|
|
}
|
|
m.Target = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
m.Target |= (Compare_CompareTarget(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 3:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
|
|
}
|
|
var byteLen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
byteLen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if byteLen < 0 {
|
|
return ErrInvalidLengthRpc
|
|
}
|
|
postIndex := iNdEx + byteLen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Key = append([]byte{}, data[iNdEx:postIndex]...)
|
|
iNdEx = postIndex
|
|
case 4:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
|
|
}
|
|
m.Version = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
m.Version |= (int64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 5:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field CreateRevision", wireType)
|
|
}
|
|
m.CreateRevision = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
m.CreateRevision |= (int64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 6:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field ModRevision", wireType)
|
|
}
|
|
m.ModRevision = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
m.ModRevision |= (int64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 7:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
|
|
}
|
|
var byteLen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
byteLen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if byteLen < 0 {
|
|
return ErrInvalidLengthRpc
|
|
}
|
|
postIndex := iNdEx + byteLen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Value = append([]byte{}, data[iNdEx:postIndex]...)
|
|
iNdEx = postIndex
|
|
default:
|
|
var sizeOfWire int
|
|
for {
|
|
sizeOfWire++
|
|
wire >>= 7
|
|
if wire == 0 {
|
|
break
|
|
}
|
|
}
|
|
iNdEx -= sizeOfWire
|
|
skippy, err := skipRpc(data[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthRpc
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
func (m *TxnRequest) Unmarshal(data []byte) error {
|
|
l := len(data)
|
|
iNdEx := 0
|
|
for iNdEx < l {
|
|
var wire uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
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)
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Compare", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
msglen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthRpc
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Compare = append(m.Compare, &Compare{})
|
|
if err := m.Compare[len(m.Compare)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Success", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
msglen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthRpc
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Success = append(m.Success, &RequestUnion{})
|
|
if err := m.Success[len(m.Success)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 3:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Failure", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
msglen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthRpc
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Failure = append(m.Failure, &RequestUnion{})
|
|
if err := m.Failure[len(m.Failure)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
var sizeOfWire int
|
|
for {
|
|
sizeOfWire++
|
|
wire >>= 7
|
|
if wire == 0 {
|
|
break
|
|
}
|
|
}
|
|
iNdEx -= sizeOfWire
|
|
skippy, err := skipRpc(data[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthRpc
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
func (m *TxnResponse) Unmarshal(data []byte) error {
|
|
l := len(data)
|
|
iNdEx := 0
|
|
for iNdEx < l {
|
|
var wire uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
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)
|
|
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 iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
msglen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthRpc
|
|
}
|
|
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 != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Succeeded", wireType)
|
|
}
|
|
var v int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
v |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
m.Succeeded = bool(v != 0)
|
|
case 3:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Responses", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
msglen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthRpc
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Responses = append(m.Responses, &ResponseUnion{})
|
|
if err := m.Responses[len(m.Responses)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
var sizeOfWire int
|
|
for {
|
|
sizeOfWire++
|
|
wire >>= 7
|
|
if wire == 0 {
|
|
break
|
|
}
|
|
}
|
|
iNdEx -= sizeOfWire
|
|
skippy, err := skipRpc(data[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthRpc
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
func (m *CompactionRequest) Unmarshal(data []byte) error {
|
|
l := len(data)
|
|
iNdEx := 0
|
|
for iNdEx < l {
|
|
var wire uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
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)
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Revision", wireType)
|
|
}
|
|
m.Revision = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
m.Revision |= (int64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
default:
|
|
var sizeOfWire int
|
|
for {
|
|
sizeOfWire++
|
|
wire >>= 7
|
|
if wire == 0 {
|
|
break
|
|
}
|
|
}
|
|
iNdEx -= sizeOfWire
|
|
skippy, err := skipRpc(data[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthRpc
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
func (m *CompactionResponse) Unmarshal(data []byte) error {
|
|
l := len(data)
|
|
iNdEx := 0
|
|
for iNdEx < l {
|
|
var wire uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
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)
|
|
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 iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
msglen |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthRpc
|
|
}
|
|
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
|
|
default:
|
|
var sizeOfWire int
|
|
for {
|
|
sizeOfWire++
|
|
wire >>= 7
|
|
if wire == 0 {
|
|
break
|
|
}
|
|
}
|
|
iNdEx -= sizeOfWire
|
|
skippy, err := skipRpc(data[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthRpc
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
func skipRpc(data []byte) (n int, err error) {
|
|
l := len(data)
|
|
iNdEx := 0
|
|
for iNdEx < l {
|
|
var wire uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
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 {
|
|
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 iNdEx >= l {
|
|
return 0, io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
length |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
iNdEx += length
|
|
if length < 0 {
|
|
return 0, ErrInvalidLengthRpc
|
|
}
|
|
return iNdEx, nil
|
|
case 3:
|
|
for {
|
|
var innerWire uint64
|
|
var start int = iNdEx
|
|
for shift := uint(0); ; shift += 7 {
|
|
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 := skipRpc(data[start:])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
iNdEx = start + next
|
|
}
|
|
return iNdEx, nil
|
|
case 4:
|
|
return iNdEx, nil
|
|
case 5:
|
|
iNdEx += 4
|
|
return iNdEx, nil
|
|
default:
|
|
return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
|
|
}
|
|
}
|
|
panic("unreachable")
|
|
}
|
|
|
|
var (
|
|
ErrInvalidLengthRpc = fmt.Errorf("proto: negative length found during unmarshaling")
|
|
)
|