mirror of
https://github.com/etcd-io/etcd.git
synced 2024-09-27 06:25:44 +00:00
45390b9fb8
Using Go-style import paths in protos is not idiomatic. Normally, this detail would be internal to etcd, but the path from which gogoproto is imported affects downstream consumers (e.g. cockroachdb). In cockroach, we want to avoid including `$GOPATH/src` in our protoc include path for various reasons. This patch puts etcd on the same convention, which allows this for cockroach. More information: https://github.com/cockroachdb/cockroach/pull/2339#discussion_r38663417 This commit also regenerates all the protos, which seem to have drifted a tiny bit.
2973 lines
65 KiB
Go
2973 lines
65 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/gogo.pb"
|
|
import storagepb "github.com/coreos/etcd/storage/storagepb"
|
|
|
|
import io "io"
|
|
import fmt "fmt"
|
|
|
|
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"
|
|
)
|
|
|
|
// Reference imports to suppress errors if they are not otherwise used.
|
|
var _ context.Context
|
|
var _ grpc.ClientConn
|
|
|
|
// 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 {
|
|
// an error type message?
|
|
Error string `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
|
|
ClusterId uint64 `protobuf:"varint,2,opt,name=cluster_id,proto3" json:"cluster_id,omitempty"`
|
|
MemberId uint64 `protobuf:"varint,3,opt,name=member_id,proto3" json:"member_id,omitempty"`
|
|
// index of the store when the request was applied.
|
|
Index int64 `protobuf:"varint,4,opt,name=index,proto3" json:"index,omitempty"`
|
|
// term of raft when the request was applied.
|
|
RaftTerm uint64 `protobuf:"varint,5,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"`
|
|
// the response will be consistent with previous request with same token if the token is
|
|
// given and is valid.
|
|
ConsistentToken []byte `protobuf:"bytes,4,opt,name=consistent_token,proto3" json:"consistent_token,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"`
|
|
ConsistentToken []byte `protobuf:"bytes,3,opt,name=consistent_token,proto3" json:"consistent_token,omitempty"`
|
|
// more indicates if there are more keys to return in the requested range.
|
|
More bool `protobuf:"varint,4,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 index of the given key
|
|
CreateIndex int64 `protobuf:"varint,5,opt,name=create_index,proto3" json:"create_index,omitempty"`
|
|
// last modified index of the given key
|
|
ModIndex int64 `protobuf:"varint,6,opt,name=mod_index,proto3" json:"mod_index,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 index (including).
|
|
// It removes the old versions of a key. It keeps the newest version of
|
|
// the key even if its latest modification index is smaller than the given
|
|
// index.
|
|
type CompactionRequest struct {
|
|
Index int64 `protobuf:"varint,1,opt,name=index,proto3" json:"index,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)
|
|
}
|
|
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 != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
stringLen |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
postIndex := iNdEx + int(stringLen)
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Error = string(data[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field ClusterId", wireType)
|
|
}
|
|
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 3:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field MemberId", wireType)
|
|
}
|
|
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 4:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
|
|
}
|
|
for shift := uint(0); ; shift += 7 {
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
m.Index |= (int64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 5:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field RaftTerm", wireType)
|
|
}
|
|
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 (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
|
|
}
|
|
}
|
|
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
|
|
}
|
|
}
|
|
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)
|
|
}
|
|
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 != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field ConsistentToken", 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
|
|
}
|
|
}
|
|
postIndex := iNdEx + byteLen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.ConsistentToken = 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 (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
|
|
}
|
|
}
|
|
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
|
|
}
|
|
}
|
|
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 != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field ConsistentToken", 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
|
|
}
|
|
}
|
|
postIndex := iNdEx + byteLen
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.ConsistentToken = append([]byte{}, data[iNdEx:postIndex]...)
|
|
iNdEx = postIndex
|
|
case 4:
|
|
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 (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
|
|
}
|
|
}
|
|
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
|
|
}
|
|
}
|
|
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 (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
|
|
}
|
|
}
|
|
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 (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
|
|
}
|
|
}
|
|
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
|
|
}
|
|
}
|
|
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 (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
|
|
}
|
|
}
|
|
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 (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
|
|
}
|
|
}
|
|
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
|
|
}
|
|
}
|
|
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
|
|
}
|
|
}
|
|
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 (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
|
|
}
|
|
}
|
|
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
|
|
}
|
|
}
|
|
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
|
|
}
|
|
}
|
|
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 (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)
|
|
}
|
|
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)
|
|
}
|
|
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
|
|
}
|
|
}
|
|
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)
|
|
}
|
|
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 CreateIndex", wireType)
|
|
}
|
|
for shift := uint(0); ; shift += 7 {
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
m.CreateIndex |= (int64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 6:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field ModIndex", wireType)
|
|
}
|
|
for shift := uint(0); ; shift += 7 {
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
m.ModIndex |= (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
|
|
}
|
|
}
|
|
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 (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
|
|
}
|
|
}
|
|
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
|
|
}
|
|
}
|
|
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
|
|
}
|
|
}
|
|
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 (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
|
|
}
|
|
}
|
|
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
|
|
}
|
|
}
|
|
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 (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 Index", wireType)
|
|
}
|
|
for shift := uint(0); ; shift += 7 {
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := data[iNdEx]
|
|
iNdEx++
|
|
m.Index |= (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 (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
|
|
}
|
|
}
|
|
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 (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
|
|
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")
|
|
}
|
|
func (m *ResponseHeader) Size() (n int) {
|
|
var l int
|
|
_ = l
|
|
l = len(m.Error)
|
|
if l > 0 {
|
|
n += 1 + l + sovRpc(uint64(l))
|
|
}
|
|
if m.ClusterId != 0 {
|
|
n += 1 + sovRpc(uint64(m.ClusterId))
|
|
}
|
|
if m.MemberId != 0 {
|
|
n += 1 + sovRpc(uint64(m.MemberId))
|
|
}
|
|
if m.Index != 0 {
|
|
n += 1 + sovRpc(uint64(m.Index))
|
|
}
|
|
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.ConsistentToken != nil {
|
|
l = len(m.ConsistentToken)
|
|
if l > 0 {
|
|
n += 1 + l + sovRpc(uint64(l))
|
|
}
|
|
}
|
|
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.ConsistentToken != nil {
|
|
l = len(m.ConsistentToken)
|
|
if l > 0 {
|
|
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.CreateIndex != 0 {
|
|
n += 1 + sovRpc(uint64(m.CreateIndex))
|
|
}
|
|
if m.ModIndex != 0 {
|
|
n += 1 + sovRpc(uint64(m.ModIndex))
|
|
}
|
|
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.Index != 0 {
|
|
n += 1 + sovRpc(uint64(m.Index))
|
|
}
|
|
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) 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) (n int, err error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.Error) > 0 {
|
|
data[i] = 0xa
|
|
i++
|
|
i = encodeVarintRpc(data, i, uint64(len(m.Error)))
|
|
i += copy(data[i:], m.Error)
|
|
}
|
|
if m.ClusterId != 0 {
|
|
data[i] = 0x10
|
|
i++
|
|
i = encodeVarintRpc(data, i, uint64(m.ClusterId))
|
|
}
|
|
if m.MemberId != 0 {
|
|
data[i] = 0x18
|
|
i++
|
|
i = encodeVarintRpc(data, i, uint64(m.MemberId))
|
|
}
|
|
if m.Index != 0 {
|
|
data[i] = 0x20
|
|
i++
|
|
i = encodeVarintRpc(data, i, uint64(m.Index))
|
|
}
|
|
if m.RaftTerm != 0 {
|
|
data[i] = 0x28
|
|
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) (n int, err 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.ConsistentToken != nil {
|
|
if len(m.ConsistentToken) > 0 {
|
|
data[i] = 0x22
|
|
i++
|
|
i = encodeVarintRpc(data, i, uint64(len(m.ConsistentToken)))
|
|
i += copy(data[i:], m.ConsistentToken)
|
|
}
|
|
}
|
|
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) (n int, err 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.ConsistentToken != nil {
|
|
if len(m.ConsistentToken) > 0 {
|
|
data[i] = 0x1a
|
|
i++
|
|
i = encodeVarintRpc(data, i, uint64(len(m.ConsistentToken)))
|
|
i += copy(data[i:], m.ConsistentToken)
|
|
}
|
|
}
|
|
if m.More {
|
|
data[i] = 0x20
|
|
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) (n int, err 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) (n int, err 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) (n int, err 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) (n int, err 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) (n int, err 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) (n int, err 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) (n int, err 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.CreateIndex != 0 {
|
|
data[i] = 0x28
|
|
i++
|
|
i = encodeVarintRpc(data, i, uint64(m.CreateIndex))
|
|
}
|
|
if m.ModIndex != 0 {
|
|
data[i] = 0x30
|
|
i++
|
|
i = encodeVarintRpc(data, i, uint64(m.ModIndex))
|
|
}
|
|
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) (n int, err 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) (n int, err 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) (n int, err error) {
|
|
var i int
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.Index != 0 {
|
|
data[i] = 0x8
|
|
i++
|
|
i = encodeVarintRpc(data, i, uint64(m.Index))
|
|
}
|
|
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) (n int, err 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
|
|
}
|
|
|
|
// 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 index 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 index 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 index of the store,
|
|
// and generates events with the same index 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 index 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 index 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 index of the store,
|
|
// and generates events with the same index 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{},
|
|
}
|