| // Code generated by protoc-gen-gogo. DO NOT EDIT. |
| // source: v3lock.proto |
| |
| package v3lockpb |
| |
| import ( |
| context "context" |
| fmt "fmt" |
| io "io" |
| math "math" |
| math_bits "math/bits" |
| |
| etcdserverpb "github.com/coreos/etcd/etcdserver/etcdserverpb" |
| _ "github.com/gogo/protobuf/gogoproto" |
| proto "github.com/golang/protobuf/proto" |
| _ "google.golang.org/genproto/googleapis/api/annotations" |
| grpc "google.golang.org/grpc" |
| codes "google.golang.org/grpc/codes" |
| status "google.golang.org/grpc/status" |
| ) |
| |
| // Reference imports to suppress errors if they are not otherwise used. |
| var _ = proto.Marshal |
| var _ = fmt.Errorf |
| var _ = math.Inf |
| |
| // This is a compile-time assertion to ensure that this generated file |
| // is compatible with the proto package it is being compiled against. |
| // A compilation error at this line likely means your copy of the |
| // proto package needs to be updated. |
| const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package |
| |
| type LockRequest struct { |
| // name is the identifier for the distributed shared lock to be acquired. |
| Name []byte `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` |
| // lease is the ID of the lease that will be attached to ownership of the |
| // lock. If the lease expires or is revoked and currently holds the lock, |
| // the lock is automatically released. Calls to Lock with the same lease will |
| // be treated as a single acquistion; locking twice with the same lease is a |
| // no-op. |
| Lease int64 `protobuf:"varint,2,opt,name=lease,proto3" json:"lease,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *LockRequest) Reset() { *m = LockRequest{} } |
| func (m *LockRequest) String() string { return proto.CompactTextString(m) } |
| func (*LockRequest) ProtoMessage() {} |
| func (*LockRequest) Descriptor() ([]byte, []int) { |
| return fileDescriptor_52389b3e2f253201, []int{0} |
| } |
| func (m *LockRequest) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *LockRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| if deterministic { |
| return xxx_messageInfo_LockRequest.Marshal(b, m, deterministic) |
| } else { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| } |
| func (m *LockRequest) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_LockRequest.Merge(m, src) |
| } |
| func (m *LockRequest) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *LockRequest) XXX_DiscardUnknown() { |
| xxx_messageInfo_LockRequest.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_LockRequest proto.InternalMessageInfo |
| |
| func (m *LockRequest) GetName() []byte { |
| if m != nil { |
| return m.Name |
| } |
| return nil |
| } |
| |
| func (m *LockRequest) GetLease() int64 { |
| if m != nil { |
| return m.Lease |
| } |
| return 0 |
| } |
| |
| type LockResponse struct { |
| Header *etcdserverpb.ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"` |
| // key is a key that will exist on etcd for the duration that the Lock caller |
| // owns the lock. Users should not modify this key or the lock may exhibit |
| // undefined behavior. |
| Key []byte `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *LockResponse) Reset() { *m = LockResponse{} } |
| func (m *LockResponse) String() string { return proto.CompactTextString(m) } |
| func (*LockResponse) ProtoMessage() {} |
| func (*LockResponse) Descriptor() ([]byte, []int) { |
| return fileDescriptor_52389b3e2f253201, []int{1} |
| } |
| func (m *LockResponse) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *LockResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| if deterministic { |
| return xxx_messageInfo_LockResponse.Marshal(b, m, deterministic) |
| } else { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| } |
| func (m *LockResponse) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_LockResponse.Merge(m, src) |
| } |
| func (m *LockResponse) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *LockResponse) XXX_DiscardUnknown() { |
| xxx_messageInfo_LockResponse.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_LockResponse proto.InternalMessageInfo |
| |
| func (m *LockResponse) GetHeader() *etcdserverpb.ResponseHeader { |
| if m != nil { |
| return m.Header |
| } |
| return nil |
| } |
| |
| func (m *LockResponse) GetKey() []byte { |
| if m != nil { |
| return m.Key |
| } |
| return nil |
| } |
| |
| type UnlockRequest struct { |
| // key is the lock ownership key granted by Lock. |
| Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *UnlockRequest) Reset() { *m = UnlockRequest{} } |
| func (m *UnlockRequest) String() string { return proto.CompactTextString(m) } |
| func (*UnlockRequest) ProtoMessage() {} |
| func (*UnlockRequest) Descriptor() ([]byte, []int) { |
| return fileDescriptor_52389b3e2f253201, []int{2} |
| } |
| func (m *UnlockRequest) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *UnlockRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| if deterministic { |
| return xxx_messageInfo_UnlockRequest.Marshal(b, m, deterministic) |
| } else { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| } |
| func (m *UnlockRequest) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_UnlockRequest.Merge(m, src) |
| } |
| func (m *UnlockRequest) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *UnlockRequest) XXX_DiscardUnknown() { |
| xxx_messageInfo_UnlockRequest.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_UnlockRequest proto.InternalMessageInfo |
| |
| func (m *UnlockRequest) GetKey() []byte { |
| if m != nil { |
| return m.Key |
| } |
| return nil |
| } |
| |
| type UnlockResponse struct { |
| Header *etcdserverpb.ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *UnlockResponse) Reset() { *m = UnlockResponse{} } |
| func (m *UnlockResponse) String() string { return proto.CompactTextString(m) } |
| func (*UnlockResponse) ProtoMessage() {} |
| func (*UnlockResponse) Descriptor() ([]byte, []int) { |
| return fileDescriptor_52389b3e2f253201, []int{3} |
| } |
| func (m *UnlockResponse) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *UnlockResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| if deterministic { |
| return xxx_messageInfo_UnlockResponse.Marshal(b, m, deterministic) |
| } else { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| } |
| func (m *UnlockResponse) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_UnlockResponse.Merge(m, src) |
| } |
| func (m *UnlockResponse) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *UnlockResponse) XXX_DiscardUnknown() { |
| xxx_messageInfo_UnlockResponse.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_UnlockResponse proto.InternalMessageInfo |
| |
| func (m *UnlockResponse) GetHeader() *etcdserverpb.ResponseHeader { |
| if m != nil { |
| return m.Header |
| } |
| return nil |
| } |
| |
| func init() { |
| proto.RegisterType((*LockRequest)(nil), "v3lockpb.LockRequest") |
| proto.RegisterType((*LockResponse)(nil), "v3lockpb.LockResponse") |
| proto.RegisterType((*UnlockRequest)(nil), "v3lockpb.UnlockRequest") |
| proto.RegisterType((*UnlockResponse)(nil), "v3lockpb.UnlockResponse") |
| } |
| |
| func init() { proto.RegisterFile("v3lock.proto", fileDescriptor_52389b3e2f253201) } |
| |
| var fileDescriptor_52389b3e2f253201 = []byte{ |
| // 335 bytes of a gzipped FileDescriptorProto |
| 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xe2, 0x29, 0x33, 0xce, 0xc9, |
| 0x4f, 0xce, 0xd6, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x80, 0xf0, 0x0a, 0x92, 0xa4, 0x44, |
| 0xd2, 0xf3, 0xd3, 0xf3, 0xc1, 0x82, 0xfa, 0x20, 0x16, 0x44, 0x5e, 0x4a, 0x2d, 0xb5, 0x24, 0x39, |
| 0x45, 0x1f, 0x44, 0x14, 0xa7, 0x16, 0x95, 0xa5, 0x16, 0x21, 0x31, 0x0b, 0x92, 0xf4, 0x8b, 0x0a, |
| 0x92, 0xa1, 0xea, 0x64, 0xd2, 0xf3, 0xf3, 0xd3, 0x73, 0x52, 0xf5, 0x13, 0x0b, 0x32, 0xf5, 0x13, |
| 0xf3, 0xf2, 0xf2, 0x4b, 0x12, 0x4b, 0x32, 0xf3, 0xf3, 0x8a, 0x21, 0xb2, 0x4a, 0xe6, 0x5c, 0xdc, |
| 0x3e, 0xf9, 0xc9, 0xd9, 0x41, 0xa9, 0x85, 0xa5, 0xa9, 0xc5, 0x25, 0x42, 0x42, 0x5c, 0x2c, 0x79, |
| 0x89, 0xb9, 0xa9, 0x12, 0x8c, 0x0a, 0x8c, 0x1a, 0x3c, 0x41, 0x60, 0xb6, 0x90, 0x08, 0x17, 0x6b, |
| 0x4e, 0x6a, 0x62, 0x71, 0xaa, 0x04, 0x93, 0x02, 0xa3, 0x06, 0x73, 0x10, 0x84, 0xa3, 0x14, 0xc6, |
| 0xc5, 0x03, 0xd1, 0x58, 0x5c, 0x90, 0x9f, 0x57, 0x9c, 0x2a, 0x64, 0xc2, 0xc5, 0x96, 0x91, 0x9a, |
| 0x98, 0x92, 0x5a, 0x04, 0xd6, 0xcb, 0x6d, 0x24, 0xa3, 0x87, 0xec, 0x1e, 0x3d, 0x98, 0x3a, 0x0f, |
| 0xb0, 0x9a, 0x20, 0xa8, 0x5a, 0x21, 0x01, 0x2e, 0xe6, 0xec, 0xd4, 0x4a, 0xb0, 0xc9, 0x3c, 0x41, |
| 0x20, 0xa6, 0x92, 0x22, 0x17, 0x6f, 0x68, 0x5e, 0x0e, 0x92, 0x93, 0xa0, 0x4a, 0x18, 0x11, 0x4a, |
| 0xdc, 0xb8, 0xf8, 0x60, 0x4a, 0x28, 0xb1, 0xdc, 0x68, 0x07, 0x23, 0x17, 0x0b, 0xc8, 0x0f, 0x42, |
| 0xc1, 0x50, 0x5a, 0x54, 0x0f, 0x16, 0xe6, 0x7a, 0x48, 0x81, 0x22, 0x25, 0x86, 0x2e, 0x0c, 0x31, |
| 0x4d, 0x49, 0xa6, 0xe9, 0xf2, 0x93, 0xc9, 0x4c, 0x62, 0x4a, 0x82, 0xfa, 0x65, 0xc6, 0x49, 0xa9, |
| 0x25, 0x89, 0xfa, 0x20, 0x45, 0x60, 0xc2, 0x8a, 0x51, 0x4b, 0x28, 0x9a, 0x8b, 0x0d, 0xe2, 0x4a, |
| 0x21, 0x71, 0x84, 0x7e, 0x14, 0xaf, 0x49, 0x49, 0x60, 0x4a, 0x40, 0x8d, 0x96, 0x03, 0x1b, 0x2d, |
| 0xa1, 0x24, 0x8c, 0x62, 0x74, 0x69, 0x1e, 0xd4, 0x70, 0x27, 0x81, 0x13, 0x8f, 0xe4, 0x18, 0x2f, |
| 0x3c, 0x92, 0x63, 0x7c, 0xf0, 0x48, 0x8e, 0x71, 0xc6, 0x63, 0x39, 0x86, 0x24, 0x36, 0x70, 0x7c, |
| 0x1a, 0x03, 0x02, 0x00, 0x00, 0xff, 0xff, 0x10, 0x82, 0x89, 0xf0, 0x45, 0x02, 0x00, 0x00, |
| } |
| |
| // Reference imports to suppress errors if they are not otherwise used. |
| var _ context.Context |
| var _ grpc.ClientConn |
| |
| // This is a compile-time assertion to ensure that this generated file |
| // is compatible with the grpc package it is being compiled against. |
| const _ = grpc.SupportPackageIsVersion4 |
| |
| // LockClient is the client API for Lock service. |
| // |
| // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. |
| type LockClient interface { |
| // Lock acquires a distributed shared lock on a given named lock. |
| // On success, it will return a unique key that exists so long as the |
| // lock is held by the caller. This key can be used in conjunction with |
| // transactions to safely ensure updates to etcd only occur while holding |
| // lock ownership. The lock is held until Unlock is called on the key or the |
| // lease associate with the owner expires. |
| Lock(ctx context.Context, in *LockRequest, opts ...grpc.CallOption) (*LockResponse, error) |
| // Unlock takes a key returned by Lock and releases the hold on lock. The |
| // next Lock caller waiting for the lock will then be woken up and given |
| // ownership of the lock. |
| Unlock(ctx context.Context, in *UnlockRequest, opts ...grpc.CallOption) (*UnlockResponse, error) |
| } |
| |
| type lockClient struct { |
| cc *grpc.ClientConn |
| } |
| |
| func NewLockClient(cc *grpc.ClientConn) LockClient { |
| return &lockClient{cc} |
| } |
| |
| func (c *lockClient) Lock(ctx context.Context, in *LockRequest, opts ...grpc.CallOption) (*LockResponse, error) { |
| out := new(LockResponse) |
| err := c.cc.Invoke(ctx, "/v3lockpb.Lock/Lock", in, out, opts...) |
| if err != nil { |
| return nil, err |
| } |
| return out, nil |
| } |
| |
| func (c *lockClient) Unlock(ctx context.Context, in *UnlockRequest, opts ...grpc.CallOption) (*UnlockResponse, error) { |
| out := new(UnlockResponse) |
| err := c.cc.Invoke(ctx, "/v3lockpb.Lock/Unlock", in, out, opts...) |
| if err != nil { |
| return nil, err |
| } |
| return out, nil |
| } |
| |
| // LockServer is the server API for Lock service. |
| type LockServer interface { |
| // Lock acquires a distributed shared lock on a given named lock. |
| // On success, it will return a unique key that exists so long as the |
| // lock is held by the caller. This key can be used in conjunction with |
| // transactions to safely ensure updates to etcd only occur while holding |
| // lock ownership. The lock is held until Unlock is called on the key or the |
| // lease associate with the owner expires. |
| Lock(context.Context, *LockRequest) (*LockResponse, error) |
| // Unlock takes a key returned by Lock and releases the hold on lock. The |
| // next Lock caller waiting for the lock will then be woken up and given |
| // ownership of the lock. |
| Unlock(context.Context, *UnlockRequest) (*UnlockResponse, error) |
| } |
| |
| // UnimplementedLockServer can be embedded to have forward compatible implementations. |
| type UnimplementedLockServer struct { |
| } |
| |
| func (*UnimplementedLockServer) Lock(ctx context.Context, req *LockRequest) (*LockResponse, error) { |
| return nil, status.Errorf(codes.Unimplemented, "method Lock not implemented") |
| } |
| func (*UnimplementedLockServer) Unlock(ctx context.Context, req *UnlockRequest) (*UnlockResponse, error) { |
| return nil, status.Errorf(codes.Unimplemented, "method Unlock not implemented") |
| } |
| |
| func RegisterLockServer(s *grpc.Server, srv LockServer) { |
| s.RegisterService(&_Lock_serviceDesc, srv) |
| } |
| |
| func _Lock_Lock_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { |
| in := new(LockRequest) |
| if err := dec(in); err != nil { |
| return nil, err |
| } |
| if interceptor == nil { |
| return srv.(LockServer).Lock(ctx, in) |
| } |
| info := &grpc.UnaryServerInfo{ |
| Server: srv, |
| FullMethod: "/v3lockpb.Lock/Lock", |
| } |
| handler := func(ctx context.Context, req interface{}) (interface{}, error) { |
| return srv.(LockServer).Lock(ctx, req.(*LockRequest)) |
| } |
| return interceptor(ctx, in, info, handler) |
| } |
| |
| func _Lock_Unlock_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { |
| in := new(UnlockRequest) |
| if err := dec(in); err != nil { |
| return nil, err |
| } |
| if interceptor == nil { |
| return srv.(LockServer).Unlock(ctx, in) |
| } |
| info := &grpc.UnaryServerInfo{ |
| Server: srv, |
| FullMethod: "/v3lockpb.Lock/Unlock", |
| } |
| handler := func(ctx context.Context, req interface{}) (interface{}, error) { |
| return srv.(LockServer).Unlock(ctx, req.(*UnlockRequest)) |
| } |
| return interceptor(ctx, in, info, handler) |
| } |
| |
| var _Lock_serviceDesc = grpc.ServiceDesc{ |
| ServiceName: "v3lockpb.Lock", |
| HandlerType: (*LockServer)(nil), |
| Methods: []grpc.MethodDesc{ |
| { |
| MethodName: "Lock", |
| Handler: _Lock_Lock_Handler, |
| }, |
| { |
| MethodName: "Unlock", |
| Handler: _Lock_Unlock_Handler, |
| }, |
| }, |
| Streams: []grpc.StreamDesc{}, |
| Metadata: "v3lock.proto", |
| } |
| |
| func (m *LockRequest) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *LockRequest) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *LockRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| if m.XXX_unrecognized != nil { |
| i -= len(m.XXX_unrecognized) |
| copy(dAtA[i:], m.XXX_unrecognized) |
| } |
| if m.Lease != 0 { |
| i = encodeVarintV3Lock(dAtA, i, uint64(m.Lease)) |
| i-- |
| dAtA[i] = 0x10 |
| } |
| if len(m.Name) > 0 { |
| i -= len(m.Name) |
| copy(dAtA[i:], m.Name) |
| i = encodeVarintV3Lock(dAtA, i, uint64(len(m.Name))) |
| i-- |
| dAtA[i] = 0xa |
| } |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *LockResponse) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *LockResponse) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *LockResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| if m.XXX_unrecognized != nil { |
| i -= len(m.XXX_unrecognized) |
| copy(dAtA[i:], m.XXX_unrecognized) |
| } |
| if len(m.Key) > 0 { |
| i -= len(m.Key) |
| copy(dAtA[i:], m.Key) |
| i = encodeVarintV3Lock(dAtA, i, uint64(len(m.Key))) |
| i-- |
| dAtA[i] = 0x12 |
| } |
| if m.Header != nil { |
| { |
| size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintV3Lock(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0xa |
| } |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *UnlockRequest) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *UnlockRequest) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *UnlockRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| if m.XXX_unrecognized != nil { |
| i -= len(m.XXX_unrecognized) |
| copy(dAtA[i:], m.XXX_unrecognized) |
| } |
| if len(m.Key) > 0 { |
| i -= len(m.Key) |
| copy(dAtA[i:], m.Key) |
| i = encodeVarintV3Lock(dAtA, i, uint64(len(m.Key))) |
| i-- |
| dAtA[i] = 0xa |
| } |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *UnlockResponse) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *UnlockResponse) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *UnlockResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| if m.XXX_unrecognized != nil { |
| i -= len(m.XXX_unrecognized) |
| copy(dAtA[i:], m.XXX_unrecognized) |
| } |
| if m.Header != nil { |
| { |
| size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintV3Lock(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0xa |
| } |
| return len(dAtA) - i, nil |
| } |
| |
| func encodeVarintV3Lock(dAtA []byte, offset int, v uint64) int { |
| offset -= sovV3Lock(v) |
| base := offset |
| for v >= 1<<7 { |
| dAtA[offset] = uint8(v&0x7f | 0x80) |
| v >>= 7 |
| offset++ |
| } |
| dAtA[offset] = uint8(v) |
| return base |
| } |
| func (m *LockRequest) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| l = len(m.Name) |
| if l > 0 { |
| n += 1 + l + sovV3Lock(uint64(l)) |
| } |
| if m.Lease != 0 { |
| n += 1 + sovV3Lock(uint64(m.Lease)) |
| } |
| if m.XXX_unrecognized != nil { |
| n += len(m.XXX_unrecognized) |
| } |
| return n |
| } |
| |
| func (m *LockResponse) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| if m.Header != nil { |
| l = m.Header.Size() |
| n += 1 + l + sovV3Lock(uint64(l)) |
| } |
| l = len(m.Key) |
| if l > 0 { |
| n += 1 + l + sovV3Lock(uint64(l)) |
| } |
| if m.XXX_unrecognized != nil { |
| n += len(m.XXX_unrecognized) |
| } |
| return n |
| } |
| |
| func (m *UnlockRequest) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| l = len(m.Key) |
| if l > 0 { |
| n += 1 + l + sovV3Lock(uint64(l)) |
| } |
| if m.XXX_unrecognized != nil { |
| n += len(m.XXX_unrecognized) |
| } |
| return n |
| } |
| |
| func (m *UnlockResponse) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| if m.Header != nil { |
| l = m.Header.Size() |
| n += 1 + l + sovV3Lock(uint64(l)) |
| } |
| if m.XXX_unrecognized != nil { |
| n += len(m.XXX_unrecognized) |
| } |
| return n |
| } |
| |
| func sovV3Lock(x uint64) (n int) { |
| return (math_bits.Len64(x|1) + 6) / 7 |
| } |
| func sozV3Lock(x uint64) (n int) { |
| return sovV3Lock(uint64((x << 1) ^ uint64((int64(x) >> 63)))) |
| } |
| func (m *LockRequest) Unmarshal(dAtA []byte) error { |
| l := len(dAtA) |
| iNdEx := 0 |
| for iNdEx < l { |
| preIndex := iNdEx |
| var wire uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowV3Lock |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| wire |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| fieldNum := int32(wire >> 3) |
| wireType := int(wire & 0x7) |
| if wireType == 4 { |
| return fmt.Errorf("proto: LockRequest: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: LockRequest: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) |
| } |
| var byteLen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowV3Lock |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| byteLen |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if byteLen < 0 { |
| return ErrInvalidLengthV3Lock |
| } |
| postIndex := iNdEx + byteLen |
| if postIndex < 0 { |
| return ErrInvalidLengthV3Lock |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Name = append(m.Name[:0], dAtA[iNdEx:postIndex]...) |
| if m.Name == nil { |
| m.Name = []byte{} |
| } |
| iNdEx = postIndex |
| case 2: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Lease", wireType) |
| } |
| m.Lease = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowV3Lock |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.Lease |= int64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| default: |
| iNdEx = preIndex |
| skippy, err := skipV3Lock(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthV3Lock |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthV3Lock |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *LockResponse) Unmarshal(dAtA []byte) error { |
| l := len(dAtA) |
| iNdEx := 0 |
| for iNdEx < l { |
| preIndex := iNdEx |
| var wire uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowV3Lock |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| wire |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| fieldNum := int32(wire >> 3) |
| wireType := int(wire & 0x7) |
| if wireType == 4 { |
| return fmt.Errorf("proto: LockResponse: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: LockResponse: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowV3Lock |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthV3Lock |
| } |
| postIndex := iNdEx + msglen |
| if postIndex < 0 { |
| return ErrInvalidLengthV3Lock |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if m.Header == nil { |
| m.Header = &etcdserverpb.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 Key", wireType) |
| } |
| var byteLen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowV3Lock |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| byteLen |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if byteLen < 0 { |
| return ErrInvalidLengthV3Lock |
| } |
| postIndex := iNdEx + byteLen |
| if postIndex < 0 { |
| return ErrInvalidLengthV3Lock |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...) |
| if m.Key == nil { |
| m.Key = []byte{} |
| } |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipV3Lock(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthV3Lock |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthV3Lock |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *UnlockRequest) Unmarshal(dAtA []byte) error { |
| l := len(dAtA) |
| iNdEx := 0 |
| for iNdEx < l { |
| preIndex := iNdEx |
| var wire uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowV3Lock |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| wire |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| fieldNum := int32(wire >> 3) |
| wireType := int(wire & 0x7) |
| if wireType == 4 { |
| return fmt.Errorf("proto: UnlockRequest: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: UnlockRequest: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| 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 shift >= 64 { |
| return ErrIntOverflowV3Lock |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| byteLen |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if byteLen < 0 { |
| return ErrInvalidLengthV3Lock |
| } |
| postIndex := iNdEx + byteLen |
| if postIndex < 0 { |
| return ErrInvalidLengthV3Lock |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...) |
| if m.Key == nil { |
| m.Key = []byte{} |
| } |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipV3Lock(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthV3Lock |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthV3Lock |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *UnlockResponse) Unmarshal(dAtA []byte) error { |
| l := len(dAtA) |
| iNdEx := 0 |
| for iNdEx < l { |
| preIndex := iNdEx |
| var wire uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowV3Lock |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| wire |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| fieldNum := int32(wire >> 3) |
| wireType := int(wire & 0x7) |
| if wireType == 4 { |
| return fmt.Errorf("proto: UnlockResponse: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: UnlockResponse: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowV3Lock |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthV3Lock |
| } |
| postIndex := iNdEx + msglen |
| if postIndex < 0 { |
| return ErrInvalidLengthV3Lock |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if m.Header == nil { |
| m.Header = &etcdserverpb.ResponseHeader{} |
| } |
| if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipV3Lock(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthV3Lock |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthV3Lock |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func skipV3Lock(dAtA []byte) (n int, err error) { |
| l := len(dAtA) |
| iNdEx := 0 |
| for iNdEx < l { |
| var wire uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return 0, ErrIntOverflowV3Lock |
| } |
| if iNdEx >= l { |
| return 0, io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| wire |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| wireType := int(wire & 0x7) |
| switch wireType { |
| case 0: |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return 0, ErrIntOverflowV3Lock |
| } |
| if iNdEx >= l { |
| return 0, io.ErrUnexpectedEOF |
| } |
| iNdEx++ |
| if dAtA[iNdEx-1] < 0x80 { |
| break |
| } |
| } |
| return iNdEx, nil |
| case 1: |
| iNdEx += 8 |
| return iNdEx, nil |
| case 2: |
| var length int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return 0, ErrIntOverflowV3Lock |
| } |
| if iNdEx >= l { |
| return 0, io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| length |= (int(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if length < 0 { |
| return 0, ErrInvalidLengthV3Lock |
| } |
| iNdEx += length |
| if iNdEx < 0 { |
| return 0, ErrInvalidLengthV3Lock |
| } |
| return iNdEx, nil |
| case 3: |
| for { |
| var innerWire uint64 |
| var start int = iNdEx |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return 0, ErrIntOverflowV3Lock |
| } |
| 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 := skipV3Lock(dAtA[start:]) |
| if err != nil { |
| return 0, err |
| } |
| iNdEx = start + next |
| if iNdEx < 0 { |
| return 0, ErrInvalidLengthV3Lock |
| } |
| } |
| 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 ( |
| ErrInvalidLengthV3Lock = fmt.Errorf("proto: negative length found during unmarshaling") |
| ErrIntOverflowV3Lock = fmt.Errorf("proto: integer overflow") |
| ) |