forked from TrueCloudLab/frostfs-api-go
6804 lines
170 KiB
Go
Generated
6804 lines
170 KiB
Go
Generated
// Code generated by protoc-gen-gogo. DO NOT EDIT.
|
|
// source: v2/container/grpc/service.proto
|
|
|
|
package container
|
|
|
|
import (
|
|
context "context"
|
|
fmt "fmt"
|
|
proto "github.com/golang/protobuf/proto"
|
|
grpc2 "github.com/nspcc-dev/neofs-api-go/v2/acl/grpc"
|
|
grpc1 "github.com/nspcc-dev/neofs-api-go/v2/refs/grpc"
|
|
grpc "github.com/nspcc-dev/neofs-api-go/v2/session/grpc"
|
|
grpc3 "google.golang.org/grpc"
|
|
codes "google.golang.org/grpc/codes"
|
|
status "google.golang.org/grpc/status"
|
|
io "io"
|
|
math "math"
|
|
math_bits "math/bits"
|
|
)
|
|
|
|
// 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.ProtoPackageIsVersion3 // please upgrade the proto package
|
|
|
|
// New NeoFS Container creation request
|
|
type PutRequest struct {
|
|
// Body of container put request message.
|
|
Body *PutRequest_Body `protobuf:"bytes,1,opt,name=body,proto3" json:"body,omitempty"`
|
|
// Carries request meta information. Header data is used only to regulate
|
|
// message transport and does not affect request execution.
|
|
MetaHeader *grpc.RequestMetaHeader `protobuf:"bytes,2,opt,name=meta_header,json=metaHeader,proto3" json:"meta_header,omitempty"`
|
|
// Carries request verification information. This header is used to
|
|
// authenticate the nodes of the message route and check the correctness of
|
|
// transmission.
|
|
VerifyHeader *grpc.RequestVerificationHeader `protobuf:"bytes,3,opt,name=verify_header,json=verifyHeader,proto3" json:"verify_header,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *PutRequest) Reset() { *m = PutRequest{} }
|
|
func (m *PutRequest) String() string { return proto.CompactTextString(m) }
|
|
func (*PutRequest) ProtoMessage() {}
|
|
func (*PutRequest) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_364186d99410ec35, []int{0}
|
|
}
|
|
func (m *PutRequest) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *PutRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_PutRequest.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 *PutRequest) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_PutRequest.Merge(m, src)
|
|
}
|
|
func (m *PutRequest) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *PutRequest) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_PutRequest.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_PutRequest proto.InternalMessageInfo
|
|
|
|
func (m *PutRequest) GetBody() *PutRequest_Body {
|
|
if m != nil {
|
|
return m.Body
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *PutRequest) GetMetaHeader() *grpc.RequestMetaHeader {
|
|
if m != nil {
|
|
return m.MetaHeader
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *PutRequest) GetVerifyHeader() *grpc.RequestVerificationHeader {
|
|
if m != nil {
|
|
return m.VerifyHeader
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Container creation request has container structure's signature as a
|
|
// separate field. It's not stored in sidechain, just verified on container
|
|
// creation by `Container` smart contract. `ContainerID` is a SHA256 hash of
|
|
// the stable-marshalled container strucutre, hence there is no need for
|
|
// additional signature checks.
|
|
type PutRequest_Body struct {
|
|
// Container structure to register in NeoFS
|
|
Container *Container `protobuf:"bytes,1,opt,name=container,proto3" json:"container,omitempty"`
|
|
// Signature of a stable-marshalled container according to RFC-6979
|
|
Signature *grpc1.Signature `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *PutRequest_Body) Reset() { *m = PutRequest_Body{} }
|
|
func (m *PutRequest_Body) String() string { return proto.CompactTextString(m) }
|
|
func (*PutRequest_Body) ProtoMessage() {}
|
|
func (*PutRequest_Body) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_364186d99410ec35, []int{0, 0}
|
|
}
|
|
func (m *PutRequest_Body) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *PutRequest_Body) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_PutRequest_Body.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 *PutRequest_Body) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_PutRequest_Body.Merge(m, src)
|
|
}
|
|
func (m *PutRequest_Body) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *PutRequest_Body) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_PutRequest_Body.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_PutRequest_Body proto.InternalMessageInfo
|
|
|
|
func (m *PutRequest_Body) GetContainer() *Container {
|
|
if m != nil {
|
|
return m.Container
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *PutRequest_Body) GetSignature() *grpc1.Signature {
|
|
if m != nil {
|
|
return m.Signature
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// New NeoFS Container creation response
|
|
type PutResponse struct {
|
|
// Body of container put response message.
|
|
Body *PutResponse_Body `protobuf:"bytes,1,opt,name=body,proto3" json:"body,omitempty"`
|
|
// Carries response meta information. Header data is used only to regulate
|
|
// message transport and does not affect request execution.
|
|
MetaHeader *grpc.ResponseMetaHeader `protobuf:"bytes,2,opt,name=meta_header,json=metaHeader,proto3" json:"meta_header,omitempty"`
|
|
// Carries response verification information. This header is used to
|
|
// authenticate the nodes of the message route and check the correctness of
|
|
// transmission.
|
|
VerifyHeader *grpc.ResponseVerificationHeader `protobuf:"bytes,3,opt,name=verify_header,json=verifyHeader,proto3" json:"verify_header,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *PutResponse) Reset() { *m = PutResponse{} }
|
|
func (m *PutResponse) String() string { return proto.CompactTextString(m) }
|
|
func (*PutResponse) ProtoMessage() {}
|
|
func (*PutResponse) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_364186d99410ec35, []int{1}
|
|
}
|
|
func (m *PutResponse) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *PutResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_PutResponse.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 *PutResponse) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_PutResponse.Merge(m, src)
|
|
}
|
|
func (m *PutResponse) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *PutResponse) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_PutResponse.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_PutResponse proto.InternalMessageInfo
|
|
|
|
func (m *PutResponse) GetBody() *PutResponse_Body {
|
|
if m != nil {
|
|
return m.Body
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *PutResponse) GetMetaHeader() *grpc.ResponseMetaHeader {
|
|
if m != nil {
|
|
return m.MetaHeader
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *PutResponse) GetVerifyHeader() *grpc.ResponseVerificationHeader {
|
|
if m != nil {
|
|
return m.VerifyHeader
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Container put response body contains information about the newly registered
|
|
// container as seen by `Container` smart contract. `ContainerID` can be
|
|
// calculated beforehand from the container structure and compared to the one
|
|
// returned here to make sure everything was done as expected.
|
|
type PutResponse_Body struct {
|
|
// Unique identifier of the newly created container
|
|
ContainerId *grpc1.ContainerID `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *PutResponse_Body) Reset() { *m = PutResponse_Body{} }
|
|
func (m *PutResponse_Body) String() string { return proto.CompactTextString(m) }
|
|
func (*PutResponse_Body) ProtoMessage() {}
|
|
func (*PutResponse_Body) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_364186d99410ec35, []int{1, 0}
|
|
}
|
|
func (m *PutResponse_Body) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *PutResponse_Body) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_PutResponse_Body.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 *PutResponse_Body) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_PutResponse_Body.Merge(m, src)
|
|
}
|
|
func (m *PutResponse_Body) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *PutResponse_Body) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_PutResponse_Body.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_PutResponse_Body proto.InternalMessageInfo
|
|
|
|
func (m *PutResponse_Body) GetContainerId() *grpc1.ContainerID {
|
|
if m != nil {
|
|
return m.ContainerId
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Container removal request
|
|
type DeleteRequest struct {
|
|
// Body of container delete request message.
|
|
Body *DeleteRequest_Body `protobuf:"bytes,1,opt,name=body,proto3" json:"body,omitempty"`
|
|
// Carries request meta information. Header data is used only to regulate
|
|
// message transport and does not affect request execution.
|
|
MetaHeader *grpc.RequestMetaHeader `protobuf:"bytes,2,opt,name=meta_header,json=metaHeader,proto3" json:"meta_header,omitempty"`
|
|
// Carries request verification information. This header is used to
|
|
// authenticate the nodes of the message route and check the correctness of
|
|
// transmission.
|
|
VerifyHeader *grpc.RequestVerificationHeader `protobuf:"bytes,3,opt,name=verify_header,json=verifyHeader,proto3" json:"verify_header,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *DeleteRequest) Reset() { *m = DeleteRequest{} }
|
|
func (m *DeleteRequest) String() string { return proto.CompactTextString(m) }
|
|
func (*DeleteRequest) ProtoMessage() {}
|
|
func (*DeleteRequest) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_364186d99410ec35, []int{2}
|
|
}
|
|
func (m *DeleteRequest) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *DeleteRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_DeleteRequest.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 *DeleteRequest) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_DeleteRequest.Merge(m, src)
|
|
}
|
|
func (m *DeleteRequest) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *DeleteRequest) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_DeleteRequest.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_DeleteRequest proto.InternalMessageInfo
|
|
|
|
func (m *DeleteRequest) GetBody() *DeleteRequest_Body {
|
|
if m != nil {
|
|
return m.Body
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *DeleteRequest) GetMetaHeader() *grpc.RequestMetaHeader {
|
|
if m != nil {
|
|
return m.MetaHeader
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *DeleteRequest) GetVerifyHeader() *grpc.RequestVerificationHeader {
|
|
if m != nil {
|
|
return m.VerifyHeader
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Container removal request body has a signed `ContainerID` as a proof of
|
|
// container owner's intent. The signature will be verified by `Container`
|
|
// smart contract, so signing algorithm must be supported by NeoVM.
|
|
type DeleteRequest_Body struct {
|
|
// Identifier of the container to delete from NeoFS
|
|
ContainerId *grpc1.ContainerID `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"`
|
|
// `ContainerID` signed with the container owner's key according to RFC-6979
|
|
Signature *grpc1.Signature `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *DeleteRequest_Body) Reset() { *m = DeleteRequest_Body{} }
|
|
func (m *DeleteRequest_Body) String() string { return proto.CompactTextString(m) }
|
|
func (*DeleteRequest_Body) ProtoMessage() {}
|
|
func (*DeleteRequest_Body) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_364186d99410ec35, []int{2, 0}
|
|
}
|
|
func (m *DeleteRequest_Body) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *DeleteRequest_Body) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_DeleteRequest_Body.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 *DeleteRequest_Body) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_DeleteRequest_Body.Merge(m, src)
|
|
}
|
|
func (m *DeleteRequest_Body) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *DeleteRequest_Body) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_DeleteRequest_Body.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_DeleteRequest_Body proto.InternalMessageInfo
|
|
|
|
func (m *DeleteRequest_Body) GetContainerId() *grpc1.ContainerID {
|
|
if m != nil {
|
|
return m.ContainerId
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *DeleteRequest_Body) GetSignature() *grpc1.Signature {
|
|
if m != nil {
|
|
return m.Signature
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// `DeleteResponse` has an empty body because delete operation is asynchronous
|
|
// and done via consensus in Inner Ring nodes.
|
|
type DeleteResponse struct {
|
|
// Body of container delete response message.
|
|
Body *DeleteResponse_Body `protobuf:"bytes,1,opt,name=body,proto3" json:"body,omitempty"`
|
|
// Carries response meta information. Header data is used only to regulate
|
|
// message transport and does not affect request execution.
|
|
MetaHeader *grpc.ResponseMetaHeader `protobuf:"bytes,2,opt,name=meta_header,json=metaHeader,proto3" json:"meta_header,omitempty"`
|
|
// Carries response verification information. This header is used to
|
|
// authenticate the nodes of the message route and check the correctness of
|
|
// transmission.
|
|
VerifyHeader *grpc.ResponseVerificationHeader `protobuf:"bytes,3,opt,name=verify_header,json=verifyHeader,proto3" json:"verify_header,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *DeleteResponse) Reset() { *m = DeleteResponse{} }
|
|
func (m *DeleteResponse) String() string { return proto.CompactTextString(m) }
|
|
func (*DeleteResponse) ProtoMessage() {}
|
|
func (*DeleteResponse) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_364186d99410ec35, []int{3}
|
|
}
|
|
func (m *DeleteResponse) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *DeleteResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_DeleteResponse.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 *DeleteResponse) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_DeleteResponse.Merge(m, src)
|
|
}
|
|
func (m *DeleteResponse) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *DeleteResponse) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_DeleteResponse.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_DeleteResponse proto.InternalMessageInfo
|
|
|
|
func (m *DeleteResponse) GetBody() *DeleteResponse_Body {
|
|
if m != nil {
|
|
return m.Body
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *DeleteResponse) GetMetaHeader() *grpc.ResponseMetaHeader {
|
|
if m != nil {
|
|
return m.MetaHeader
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *DeleteResponse) GetVerifyHeader() *grpc.ResponseVerificationHeader {
|
|
if m != nil {
|
|
return m.VerifyHeader
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// `DeleteResponse` has an empty body because delete operation is asynchronous
|
|
// and done via consensus in Inner Ring nodes.
|
|
type DeleteResponse_Body struct {
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *DeleteResponse_Body) Reset() { *m = DeleteResponse_Body{} }
|
|
func (m *DeleteResponse_Body) String() string { return proto.CompactTextString(m) }
|
|
func (*DeleteResponse_Body) ProtoMessage() {}
|
|
func (*DeleteResponse_Body) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_364186d99410ec35, []int{3, 0}
|
|
}
|
|
func (m *DeleteResponse_Body) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *DeleteResponse_Body) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_DeleteResponse_Body.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 *DeleteResponse_Body) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_DeleteResponse_Body.Merge(m, src)
|
|
}
|
|
func (m *DeleteResponse_Body) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *DeleteResponse_Body) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_DeleteResponse_Body.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_DeleteResponse_Body proto.InternalMessageInfo
|
|
|
|
// Get container structure
|
|
type GetRequest struct {
|
|
// Body of container get request message.
|
|
Body *GetRequest_Body `protobuf:"bytes,1,opt,name=body,proto3" json:"body,omitempty"`
|
|
// Carries request meta information. Header data is used only to regulate
|
|
// message transport and does not affect request execution.
|
|
MetaHeader *grpc.RequestMetaHeader `protobuf:"bytes,2,opt,name=meta_header,json=metaHeader,proto3" json:"meta_header,omitempty"`
|
|
// Carries request verification information. This header is used to
|
|
// authenticate the nodes of the message route and check the correctness of
|
|
// transmission.
|
|
VerifyHeader *grpc.RequestVerificationHeader `protobuf:"bytes,3,opt,name=verify_header,json=verifyHeader,proto3" json:"verify_header,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *GetRequest) Reset() { *m = GetRequest{} }
|
|
func (m *GetRequest) String() string { return proto.CompactTextString(m) }
|
|
func (*GetRequest) ProtoMessage() {}
|
|
func (*GetRequest) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_364186d99410ec35, []int{4}
|
|
}
|
|
func (m *GetRequest) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *GetRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_GetRequest.Marshal(b, m, deterministic)
|
|
} else {
|
|
b = b[:cap(b)]
|
|
n, err := m.MarshalToSizedBuffer(b)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return b[:n], nil
|
|
}
|
|
}
|
|
func (m *GetRequest) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_GetRequest.Merge(m, src)
|
|
}
|
|
func (m *GetRequest) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *GetRequest) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_GetRequest.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_GetRequest proto.InternalMessageInfo
|
|
|
|
func (m *GetRequest) GetBody() *GetRequest_Body {
|
|
if m != nil {
|
|
return m.Body
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *GetRequest) GetMetaHeader() *grpc.RequestMetaHeader {
|
|
if m != nil {
|
|
return m.MetaHeader
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *GetRequest) GetVerifyHeader() *grpc.RequestVerificationHeader {
|
|
if m != nil {
|
|
return m.VerifyHeader
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Get container structure request body.
|
|
type GetRequest_Body struct {
|
|
// Identifier of the container to get
|
|
ContainerId *grpc1.ContainerID `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *GetRequest_Body) Reset() { *m = GetRequest_Body{} }
|
|
func (m *GetRequest_Body) String() string { return proto.CompactTextString(m) }
|
|
func (*GetRequest_Body) ProtoMessage() {}
|
|
func (*GetRequest_Body) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_364186d99410ec35, []int{4, 0}
|
|
}
|
|
func (m *GetRequest_Body) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *GetRequest_Body) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_GetRequest_Body.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 *GetRequest_Body) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_GetRequest_Body.Merge(m, src)
|
|
}
|
|
func (m *GetRequest_Body) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *GetRequest_Body) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_GetRequest_Body.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_GetRequest_Body proto.InternalMessageInfo
|
|
|
|
func (m *GetRequest_Body) GetContainerId() *grpc1.ContainerID {
|
|
if m != nil {
|
|
return m.ContainerId
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Get container structure
|
|
type GetResponse struct {
|
|
// Body of container get response message.
|
|
Body *GetResponse_Body `protobuf:"bytes,1,opt,name=body,proto3" json:"body,omitempty"`
|
|
// Carries response meta information. Header data is used only to regulate
|
|
// message transport and does not affect request execution.
|
|
MetaHeader *grpc.ResponseMetaHeader `protobuf:"bytes,2,opt,name=meta_header,json=metaHeader,proto3" json:"meta_header,omitempty"`
|
|
// Carries response verification information. This header is used to
|
|
// authenticate the nodes of the message route and check the correctness of
|
|
// transmission.
|
|
VerifyHeader *grpc.ResponseVerificationHeader `protobuf:"bytes,3,opt,name=verify_header,json=verifyHeader,proto3" json:"verify_header,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *GetResponse) Reset() { *m = GetResponse{} }
|
|
func (m *GetResponse) String() string { return proto.CompactTextString(m) }
|
|
func (*GetResponse) ProtoMessage() {}
|
|
func (*GetResponse) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_364186d99410ec35, []int{5}
|
|
}
|
|
func (m *GetResponse) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *GetResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_GetResponse.Marshal(b, m, deterministic)
|
|
} else {
|
|
b = b[:cap(b)]
|
|
n, err := m.MarshalToSizedBuffer(b)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return b[:n], nil
|
|
}
|
|
}
|
|
func (m *GetResponse) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_GetResponse.Merge(m, src)
|
|
}
|
|
func (m *GetResponse) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *GetResponse) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_GetResponse.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_GetResponse proto.InternalMessageInfo
|
|
|
|
func (m *GetResponse) GetBody() *GetResponse_Body {
|
|
if m != nil {
|
|
return m.Body
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *GetResponse) GetMetaHeader() *grpc.ResponseMetaHeader {
|
|
if m != nil {
|
|
return m.MetaHeader
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *GetResponse) GetVerifyHeader() *grpc.ResponseVerificationHeader {
|
|
if m != nil {
|
|
return m.VerifyHeader
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Get container response body does not have container structure signature. It
|
|
// was already verified on container creation.
|
|
type GetResponse_Body struct {
|
|
// Requested container structure
|
|
Container *Container `protobuf:"bytes,1,opt,name=container,proto3" json:"container,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *GetResponse_Body) Reset() { *m = GetResponse_Body{} }
|
|
func (m *GetResponse_Body) String() string { return proto.CompactTextString(m) }
|
|
func (*GetResponse_Body) ProtoMessage() {}
|
|
func (*GetResponse_Body) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_364186d99410ec35, []int{5, 0}
|
|
}
|
|
func (m *GetResponse_Body) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *GetResponse_Body) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_GetResponse_Body.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 *GetResponse_Body) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_GetResponse_Body.Merge(m, src)
|
|
}
|
|
func (m *GetResponse_Body) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *GetResponse_Body) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_GetResponse_Body.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_GetResponse_Body proto.InternalMessageInfo
|
|
|
|
func (m *GetResponse_Body) GetContainer() *Container {
|
|
if m != nil {
|
|
return m.Container
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// List containers
|
|
type ListRequest struct {
|
|
// Body of list containers request message
|
|
Body *ListRequest_Body `protobuf:"bytes,1,opt,name=body,proto3" json:"body,omitempty"`
|
|
// Carries request meta information. Header data is used only to regulate
|
|
// message transport and does not affect request execution.
|
|
MetaHeader *grpc.RequestMetaHeader `protobuf:"bytes,2,opt,name=meta_header,json=metaHeader,proto3" json:"meta_header,omitempty"`
|
|
// Carries request verification information. This header is used to
|
|
// authenticate the nodes of the message route and check the correctness of
|
|
// transmission.
|
|
VerifyHeader *grpc.RequestVerificationHeader `protobuf:"bytes,3,opt,name=verify_header,json=verifyHeader,proto3" json:"verify_header,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *ListRequest) Reset() { *m = ListRequest{} }
|
|
func (m *ListRequest) String() string { return proto.CompactTextString(m) }
|
|
func (*ListRequest) ProtoMessage() {}
|
|
func (*ListRequest) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_364186d99410ec35, []int{6}
|
|
}
|
|
func (m *ListRequest) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *ListRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_ListRequest.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 *ListRequest) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_ListRequest.Merge(m, src)
|
|
}
|
|
func (m *ListRequest) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *ListRequest) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_ListRequest.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_ListRequest proto.InternalMessageInfo
|
|
|
|
func (m *ListRequest) GetBody() *ListRequest_Body {
|
|
if m != nil {
|
|
return m.Body
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *ListRequest) GetMetaHeader() *grpc.RequestMetaHeader {
|
|
if m != nil {
|
|
return m.MetaHeader
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *ListRequest) GetVerifyHeader() *grpc.RequestVerificationHeader {
|
|
if m != nil {
|
|
return m.VerifyHeader
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// List containers request body.
|
|
type ListRequest_Body struct {
|
|
// Identifier of the container owner
|
|
OwnerId *grpc1.OwnerID `protobuf:"bytes,1,opt,name=owner_id,json=ownerId,proto3" json:"owner_id,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *ListRequest_Body) Reset() { *m = ListRequest_Body{} }
|
|
func (m *ListRequest_Body) String() string { return proto.CompactTextString(m) }
|
|
func (*ListRequest_Body) ProtoMessage() {}
|
|
func (*ListRequest_Body) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_364186d99410ec35, []int{6, 0}
|
|
}
|
|
func (m *ListRequest_Body) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *ListRequest_Body) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_ListRequest_Body.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 *ListRequest_Body) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_ListRequest_Body.Merge(m, src)
|
|
}
|
|
func (m *ListRequest_Body) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *ListRequest_Body) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_ListRequest_Body.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_ListRequest_Body proto.InternalMessageInfo
|
|
|
|
func (m *ListRequest_Body) GetOwnerId() *grpc1.OwnerID {
|
|
if m != nil {
|
|
return m.OwnerId
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// List containers
|
|
type ListResponse struct {
|
|
// Body of list containers response message.
|
|
Body *ListResponse_Body `protobuf:"bytes,1,opt,name=body,proto3" json:"body,omitempty"`
|
|
// Carries response meta information. Header data is used only to regulate
|
|
// message transport and does not affect request execution.
|
|
MetaHeader *grpc.ResponseMetaHeader `protobuf:"bytes,2,opt,name=meta_header,json=metaHeader,proto3" json:"meta_header,omitempty"`
|
|
// Carries response verification information. This header is used to
|
|
// authenticate the nodes of the message route and check the correctness of
|
|
// transmission.
|
|
VerifyHeader *grpc.ResponseVerificationHeader `protobuf:"bytes,3,opt,name=verify_header,json=verifyHeader,proto3" json:"verify_header,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *ListResponse) Reset() { *m = ListResponse{} }
|
|
func (m *ListResponse) String() string { return proto.CompactTextString(m) }
|
|
func (*ListResponse) ProtoMessage() {}
|
|
func (*ListResponse) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_364186d99410ec35, []int{7}
|
|
}
|
|
func (m *ListResponse) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *ListResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_ListResponse.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 *ListResponse) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_ListResponse.Merge(m, src)
|
|
}
|
|
func (m *ListResponse) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *ListResponse) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_ListResponse.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_ListResponse proto.InternalMessageInfo
|
|
|
|
func (m *ListResponse) GetBody() *ListResponse_Body {
|
|
if m != nil {
|
|
return m.Body
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *ListResponse) GetMetaHeader() *grpc.ResponseMetaHeader {
|
|
if m != nil {
|
|
return m.MetaHeader
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *ListResponse) GetVerifyHeader() *grpc.ResponseVerificationHeader {
|
|
if m != nil {
|
|
return m.VerifyHeader
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// List containers response body.
|
|
type ListResponse_Body struct {
|
|
// List of `ContainerID`s belonging to the requested `OwnerID`
|
|
ContainerIds []*grpc1.ContainerID `protobuf:"bytes,1,rep,name=container_ids,json=containerIds,proto3" json:"container_ids,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *ListResponse_Body) Reset() { *m = ListResponse_Body{} }
|
|
func (m *ListResponse_Body) String() string { return proto.CompactTextString(m) }
|
|
func (*ListResponse_Body) ProtoMessage() {}
|
|
func (*ListResponse_Body) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_364186d99410ec35, []int{7, 0}
|
|
}
|
|
func (m *ListResponse_Body) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *ListResponse_Body) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_ListResponse_Body.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 *ListResponse_Body) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_ListResponse_Body.Merge(m, src)
|
|
}
|
|
func (m *ListResponse_Body) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *ListResponse_Body) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_ListResponse_Body.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_ListResponse_Body proto.InternalMessageInfo
|
|
|
|
func (m *ListResponse_Body) GetContainerIds() []*grpc1.ContainerID {
|
|
if m != nil {
|
|
return m.ContainerIds
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Set Extended ACL
|
|
type SetExtendedACLRequest struct {
|
|
// Body of set extended acl request message.
|
|
Body *SetExtendedACLRequest_Body `protobuf:"bytes,1,opt,name=body,proto3" json:"body,omitempty"`
|
|
// Carries request meta information. Header data is used only to regulate
|
|
// message transport and does not affect request execution.
|
|
MetaHeader *grpc.RequestMetaHeader `protobuf:"bytes,2,opt,name=meta_header,json=metaHeader,proto3" json:"meta_header,omitempty"`
|
|
// Carries request verification information. This header is used to
|
|
// authenticate the nodes of the message route and check the correctness of
|
|
// transmission.
|
|
VerifyHeader *grpc.RequestVerificationHeader `protobuf:"bytes,3,opt,name=verify_header,json=verifyHeader,proto3" json:"verify_header,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *SetExtendedACLRequest) Reset() { *m = SetExtendedACLRequest{} }
|
|
func (m *SetExtendedACLRequest) String() string { return proto.CompactTextString(m) }
|
|
func (*SetExtendedACLRequest) ProtoMessage() {}
|
|
func (*SetExtendedACLRequest) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_364186d99410ec35, []int{8}
|
|
}
|
|
func (m *SetExtendedACLRequest) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *SetExtendedACLRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_SetExtendedACLRequest.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 *SetExtendedACLRequest) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_SetExtendedACLRequest.Merge(m, src)
|
|
}
|
|
func (m *SetExtendedACLRequest) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *SetExtendedACLRequest) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_SetExtendedACLRequest.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_SetExtendedACLRequest proto.InternalMessageInfo
|
|
|
|
func (m *SetExtendedACLRequest) GetBody() *SetExtendedACLRequest_Body {
|
|
if m != nil {
|
|
return m.Body
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *SetExtendedACLRequest) GetMetaHeader() *grpc.RequestMetaHeader {
|
|
if m != nil {
|
|
return m.MetaHeader
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *SetExtendedACLRequest) GetVerifyHeader() *grpc.RequestVerificationHeader {
|
|
if m != nil {
|
|
return m.VerifyHeader
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Set Extended ACL request body does not have separate `ContainerID`
|
|
// reference. It will be taken from `EACLTable.container_id` field.
|
|
type SetExtendedACLRequest_Body struct {
|
|
// Extended ACL table to set for container
|
|
Eacl *grpc2.EACLTable `protobuf:"bytes,1,opt,name=eacl,proto3" json:"eacl,omitempty"`
|
|
// Signature of stable-marshalled Extended ACL table according to RFC-6979
|
|
Signature *grpc1.Signature `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *SetExtendedACLRequest_Body) Reset() { *m = SetExtendedACLRequest_Body{} }
|
|
func (m *SetExtendedACLRequest_Body) String() string { return proto.CompactTextString(m) }
|
|
func (*SetExtendedACLRequest_Body) ProtoMessage() {}
|
|
func (*SetExtendedACLRequest_Body) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_364186d99410ec35, []int{8, 0}
|
|
}
|
|
func (m *SetExtendedACLRequest_Body) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *SetExtendedACLRequest_Body) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_SetExtendedACLRequest_Body.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 *SetExtendedACLRequest_Body) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_SetExtendedACLRequest_Body.Merge(m, src)
|
|
}
|
|
func (m *SetExtendedACLRequest_Body) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *SetExtendedACLRequest_Body) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_SetExtendedACLRequest_Body.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_SetExtendedACLRequest_Body proto.InternalMessageInfo
|
|
|
|
func (m *SetExtendedACLRequest_Body) GetEacl() *grpc2.EACLTable {
|
|
if m != nil {
|
|
return m.Eacl
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *SetExtendedACLRequest_Body) GetSignature() *grpc1.Signature {
|
|
if m != nil {
|
|
return m.Signature
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Set Extended ACL
|
|
type SetExtendedACLResponse struct {
|
|
// Body of set extended acl response message.
|
|
Body *SetExtendedACLResponse_Body `protobuf:"bytes,1,opt,name=body,proto3" json:"body,omitempty"`
|
|
// Carries response meta information. Header data is used only to regulate
|
|
// message transport and does not affect request execution.
|
|
MetaHeader *grpc.ResponseMetaHeader `protobuf:"bytes,2,opt,name=meta_header,json=metaHeader,proto3" json:"meta_header,omitempty"`
|
|
// Carries response verification information. This header is used to
|
|
// authenticate the nodes of the message route and check the correctness of
|
|
// transmission.
|
|
VerifyHeader *grpc.ResponseVerificationHeader `protobuf:"bytes,3,opt,name=verify_header,json=verifyHeader,proto3" json:"verify_header,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *SetExtendedACLResponse) Reset() { *m = SetExtendedACLResponse{} }
|
|
func (m *SetExtendedACLResponse) String() string { return proto.CompactTextString(m) }
|
|
func (*SetExtendedACLResponse) ProtoMessage() {}
|
|
func (*SetExtendedACLResponse) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_364186d99410ec35, []int{9}
|
|
}
|
|
func (m *SetExtendedACLResponse) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *SetExtendedACLResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_SetExtendedACLResponse.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 *SetExtendedACLResponse) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_SetExtendedACLResponse.Merge(m, src)
|
|
}
|
|
func (m *SetExtendedACLResponse) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *SetExtendedACLResponse) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_SetExtendedACLResponse.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_SetExtendedACLResponse proto.InternalMessageInfo
|
|
|
|
func (m *SetExtendedACLResponse) GetBody() *SetExtendedACLResponse_Body {
|
|
if m != nil {
|
|
return m.Body
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *SetExtendedACLResponse) GetMetaHeader() *grpc.ResponseMetaHeader {
|
|
if m != nil {
|
|
return m.MetaHeader
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *SetExtendedACLResponse) GetVerifyHeader() *grpc.ResponseVerificationHeader {
|
|
if m != nil {
|
|
return m.VerifyHeader
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// `SetExtendedACLResponse` has an empty body because the operation is
|
|
// asynchronous and update should be reflected in `Container` smart contract's
|
|
// storage after next block is issued in sidechain.
|
|
type SetExtendedACLResponse_Body struct {
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *SetExtendedACLResponse_Body) Reset() { *m = SetExtendedACLResponse_Body{} }
|
|
func (m *SetExtendedACLResponse_Body) String() string { return proto.CompactTextString(m) }
|
|
func (*SetExtendedACLResponse_Body) ProtoMessage() {}
|
|
func (*SetExtendedACLResponse_Body) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_364186d99410ec35, []int{9, 0}
|
|
}
|
|
func (m *SetExtendedACLResponse_Body) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *SetExtendedACLResponse_Body) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_SetExtendedACLResponse_Body.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 *SetExtendedACLResponse_Body) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_SetExtendedACLResponse_Body.Merge(m, src)
|
|
}
|
|
func (m *SetExtendedACLResponse_Body) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *SetExtendedACLResponse_Body) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_SetExtendedACLResponse_Body.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_SetExtendedACLResponse_Body proto.InternalMessageInfo
|
|
|
|
// Get Extended ACL
|
|
type GetExtendedACLRequest struct {
|
|
// Body of get extended acl request message.
|
|
Body *GetExtendedACLRequest_Body `protobuf:"bytes,1,opt,name=body,proto3" json:"body,omitempty"`
|
|
// Carries request meta information. Header data is used only to regulate
|
|
// message transport and does not affect request execution.
|
|
MetaHeader *grpc.RequestMetaHeader `protobuf:"bytes,2,opt,name=meta_header,json=metaHeader,proto3" json:"meta_header,omitempty"`
|
|
// Carries request verification information. This header is used to
|
|
// authenticate the nodes of the message route and check the correctness of
|
|
// transmission.
|
|
VerifyHeader *grpc.RequestVerificationHeader `protobuf:"bytes,3,opt,name=verify_header,json=verifyHeader,proto3" json:"verify_header,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *GetExtendedACLRequest) Reset() { *m = GetExtendedACLRequest{} }
|
|
func (m *GetExtendedACLRequest) String() string { return proto.CompactTextString(m) }
|
|
func (*GetExtendedACLRequest) ProtoMessage() {}
|
|
func (*GetExtendedACLRequest) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_364186d99410ec35, []int{10}
|
|
}
|
|
func (m *GetExtendedACLRequest) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *GetExtendedACLRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_GetExtendedACLRequest.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 *GetExtendedACLRequest) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_GetExtendedACLRequest.Merge(m, src)
|
|
}
|
|
func (m *GetExtendedACLRequest) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *GetExtendedACLRequest) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_GetExtendedACLRequest.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_GetExtendedACLRequest proto.InternalMessageInfo
|
|
|
|
func (m *GetExtendedACLRequest) GetBody() *GetExtendedACLRequest_Body {
|
|
if m != nil {
|
|
return m.Body
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *GetExtendedACLRequest) GetMetaHeader() *grpc.RequestMetaHeader {
|
|
if m != nil {
|
|
return m.MetaHeader
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *GetExtendedACLRequest) GetVerifyHeader() *grpc.RequestVerificationHeader {
|
|
if m != nil {
|
|
return m.VerifyHeader
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Get Extended ACL request body
|
|
type GetExtendedACLRequest_Body struct {
|
|
// Identifier of the container having Extended ACL
|
|
ContainerId *grpc1.ContainerID `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *GetExtendedACLRequest_Body) Reset() { *m = GetExtendedACLRequest_Body{} }
|
|
func (m *GetExtendedACLRequest_Body) String() string { return proto.CompactTextString(m) }
|
|
func (*GetExtendedACLRequest_Body) ProtoMessage() {}
|
|
func (*GetExtendedACLRequest_Body) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_364186d99410ec35, []int{10, 0}
|
|
}
|
|
func (m *GetExtendedACLRequest_Body) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *GetExtendedACLRequest_Body) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_GetExtendedACLRequest_Body.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 *GetExtendedACLRequest_Body) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_GetExtendedACLRequest_Body.Merge(m, src)
|
|
}
|
|
func (m *GetExtendedACLRequest_Body) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *GetExtendedACLRequest_Body) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_GetExtendedACLRequest_Body.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_GetExtendedACLRequest_Body proto.InternalMessageInfo
|
|
|
|
func (m *GetExtendedACLRequest_Body) GetContainerId() *grpc1.ContainerID {
|
|
if m != nil {
|
|
return m.ContainerId
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Get Extended ACL
|
|
type GetExtendedACLResponse struct {
|
|
// Body of get extended acl response message.
|
|
Body *GetExtendedACLResponse_Body `protobuf:"bytes,1,opt,name=body,proto3" json:"body,omitempty"`
|
|
// Carries response meta information. Header data is used only to regulate
|
|
// message transport and does not affect request execution.
|
|
MetaHeader *grpc.ResponseMetaHeader `protobuf:"bytes,2,opt,name=meta_header,json=metaHeader,proto3" json:"meta_header,omitempty"`
|
|
// Carries response verification information. This header is used to
|
|
// authenticate the nodes of the message route and check the correctness of
|
|
// transmission.
|
|
VerifyHeader *grpc.ResponseVerificationHeader `protobuf:"bytes,3,opt,name=verify_header,json=verifyHeader,proto3" json:"verify_header,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *GetExtendedACLResponse) Reset() { *m = GetExtendedACLResponse{} }
|
|
func (m *GetExtendedACLResponse) String() string { return proto.CompactTextString(m) }
|
|
func (*GetExtendedACLResponse) ProtoMessage() {}
|
|
func (*GetExtendedACLResponse) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_364186d99410ec35, []int{11}
|
|
}
|
|
func (m *GetExtendedACLResponse) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *GetExtendedACLResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_GetExtendedACLResponse.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 *GetExtendedACLResponse) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_GetExtendedACLResponse.Merge(m, src)
|
|
}
|
|
func (m *GetExtendedACLResponse) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *GetExtendedACLResponse) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_GetExtendedACLResponse.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_GetExtendedACLResponse proto.InternalMessageInfo
|
|
|
|
func (m *GetExtendedACLResponse) GetBody() *GetExtendedACLResponse_Body {
|
|
if m != nil {
|
|
return m.Body
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *GetExtendedACLResponse) GetMetaHeader() *grpc.ResponseMetaHeader {
|
|
if m != nil {
|
|
return m.MetaHeader
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *GetExtendedACLResponse) GetVerifyHeader() *grpc.ResponseVerificationHeader {
|
|
if m != nil {
|
|
return m.VerifyHeader
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Get Extended ACL Response body can be empty if the requested container did
|
|
// not have Extended ACL Table attached or Extended ACL was not allowed at
|
|
// container creation.
|
|
type GetExtendedACLResponse_Body struct {
|
|
// Extended ACL requested, if available
|
|
Eacl *grpc2.EACLTable `protobuf:"bytes,1,opt,name=eacl,proto3" json:"eacl,omitempty"`
|
|
// Signature of stable-marshalled Extended ACL according to RFC-6979
|
|
Signature *grpc1.Signature `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
|
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
|
XXX_unrecognized []byte `json:"-"`
|
|
XXX_sizecache int32 `json:"-"`
|
|
}
|
|
|
|
func (m *GetExtendedACLResponse_Body) Reset() { *m = GetExtendedACLResponse_Body{} }
|
|
func (m *GetExtendedACLResponse_Body) String() string { return proto.CompactTextString(m) }
|
|
func (*GetExtendedACLResponse_Body) ProtoMessage() {}
|
|
func (*GetExtendedACLResponse_Body) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_364186d99410ec35, []int{11, 0}
|
|
}
|
|
func (m *GetExtendedACLResponse_Body) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *GetExtendedACLResponse_Body) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_GetExtendedACLResponse_Body.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 *GetExtendedACLResponse_Body) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_GetExtendedACLResponse_Body.Merge(m, src)
|
|
}
|
|
func (m *GetExtendedACLResponse_Body) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *GetExtendedACLResponse_Body) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_GetExtendedACLResponse_Body.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_GetExtendedACLResponse_Body proto.InternalMessageInfo
|
|
|
|
func (m *GetExtendedACLResponse_Body) GetEacl() *grpc2.EACLTable {
|
|
if m != nil {
|
|
return m.Eacl
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *GetExtendedACLResponse_Body) GetSignature() *grpc1.Signature {
|
|
if m != nil {
|
|
return m.Signature
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func init() {
|
|
proto.RegisterType((*PutRequest)(nil), "neo.fs.v2.container.PutRequest")
|
|
proto.RegisterType((*PutRequest_Body)(nil), "neo.fs.v2.container.PutRequest.Body")
|
|
proto.RegisterType((*PutResponse)(nil), "neo.fs.v2.container.PutResponse")
|
|
proto.RegisterType((*PutResponse_Body)(nil), "neo.fs.v2.container.PutResponse.Body")
|
|
proto.RegisterType((*DeleteRequest)(nil), "neo.fs.v2.container.DeleteRequest")
|
|
proto.RegisterType((*DeleteRequest_Body)(nil), "neo.fs.v2.container.DeleteRequest.Body")
|
|
proto.RegisterType((*DeleteResponse)(nil), "neo.fs.v2.container.DeleteResponse")
|
|
proto.RegisterType((*DeleteResponse_Body)(nil), "neo.fs.v2.container.DeleteResponse.Body")
|
|
proto.RegisterType((*GetRequest)(nil), "neo.fs.v2.container.GetRequest")
|
|
proto.RegisterType((*GetRequest_Body)(nil), "neo.fs.v2.container.GetRequest.Body")
|
|
proto.RegisterType((*GetResponse)(nil), "neo.fs.v2.container.GetResponse")
|
|
proto.RegisterType((*GetResponse_Body)(nil), "neo.fs.v2.container.GetResponse.Body")
|
|
proto.RegisterType((*ListRequest)(nil), "neo.fs.v2.container.ListRequest")
|
|
proto.RegisterType((*ListRequest_Body)(nil), "neo.fs.v2.container.ListRequest.Body")
|
|
proto.RegisterType((*ListResponse)(nil), "neo.fs.v2.container.ListResponse")
|
|
proto.RegisterType((*ListResponse_Body)(nil), "neo.fs.v2.container.ListResponse.Body")
|
|
proto.RegisterType((*SetExtendedACLRequest)(nil), "neo.fs.v2.container.SetExtendedACLRequest")
|
|
proto.RegisterType((*SetExtendedACLRequest_Body)(nil), "neo.fs.v2.container.SetExtendedACLRequest.Body")
|
|
proto.RegisterType((*SetExtendedACLResponse)(nil), "neo.fs.v2.container.SetExtendedACLResponse")
|
|
proto.RegisterType((*SetExtendedACLResponse_Body)(nil), "neo.fs.v2.container.SetExtendedACLResponse.Body")
|
|
proto.RegisterType((*GetExtendedACLRequest)(nil), "neo.fs.v2.container.GetExtendedACLRequest")
|
|
proto.RegisterType((*GetExtendedACLRequest_Body)(nil), "neo.fs.v2.container.GetExtendedACLRequest.Body")
|
|
proto.RegisterType((*GetExtendedACLResponse)(nil), "neo.fs.v2.container.GetExtendedACLResponse")
|
|
proto.RegisterType((*GetExtendedACLResponse_Body)(nil), "neo.fs.v2.container.GetExtendedACLResponse.Body")
|
|
}
|
|
|
|
func init() { proto.RegisterFile("v2/container/grpc/service.proto", fileDescriptor_364186d99410ec35) }
|
|
|
|
var fileDescriptor_364186d99410ec35 = []byte{
|
|
// 821 bytes of a gzipped FileDescriptorProto
|
|
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x98, 0xcf, 0x6e, 0xd3, 0x58,
|
|
0x14, 0xc6, 0x27, 0x6e, 0xd4, 0x99, 0x9e, 0xa4, 0xd5, 0xc8, 0xa3, 0xb6, 0x99, 0x54, 0x93, 0x66,
|
|
0x3c, 0xd3, 0x99, 0x0a, 0x1a, 0x1b, 0x99, 0x05, 0xd0, 0x16, 0x44, 0x9b, 0xb4, 0x6e, 0x44, 0x81,
|
|
0xd6, 0x41, 0x2c, 0xd8, 0x54, 0x8e, 0x7d, 0x92, 0x5a, 0x4a, 0xec, 0xe0, 0xeb, 0xb8, 0x64, 0x81,
|
|
0x90, 0x78, 0x0a, 0x16, 0x88, 0x35, 0xaa, 0x58, 0xf0, 0x04, 0xac, 0x59, 0xf2, 0x06, 0xa0, 0x22,
|
|
0x84, 0xd8, 0xf2, 0x04, 0x28, 0xb6, 0xe3, 0xd8, 0x8d, 0xd3, 0xfc, 0x51, 0x84, 0xe4, 0x5d, 0x22,
|
|
0x7f, 0xe7, 0xf8, 0x9c, 0x5f, 0xbe, 0x7b, 0xcf, 0xbd, 0x81, 0x65, 0x8b, 0xe7, 0x64, 0x5d, 0x33,
|
|
0x25, 0x55, 0x43, 0x83, 0xab, 0x1a, 0x0d, 0x99, 0x23, 0x68, 0x58, 0xaa, 0x8c, 0x6c, 0xc3, 0xd0,
|
|
0x4d, 0x9d, 0xfe, 0x43, 0x43, 0x9d, 0xad, 0x10, 0xd6, 0xe2, 0x59, 0x4f, 0x97, 0x5e, 0xb4, 0x78,
|
|
0x4e, 0x92, 0x6b, 0x8e, 0xde, 0x6c, 0x35, 0x90, 0x38, 0xea, 0xf4, 0x5f, 0xbd, 0xe9, 0xfc, 0x8f,
|
|
0x53, 0x16, 0xcf, 0x19, 0x58, 0x21, 0xbd, 0x4f, 0x96, 0x2c, 0x9e, 0x23, 0x48, 0x88, 0xaa, 0x6b,
|
|
0x3d, 0x0f, 0x99, 0x8f, 0x14, 0xc0, 0x41, 0xd3, 0x14, 0xf1, 0x71, 0x13, 0x89, 0x49, 0x5f, 0x87,
|
|
0x78, 0x59, 0x57, 0x5a, 0xa9, 0x58, 0x36, 0xb6, 0x9a, 0xe0, 0xff, 0x65, 0x43, 0x2a, 0x64, 0xbb,
|
|
0x72, 0x76, 0x5b, 0x57, 0x5a, 0xa2, 0x1d, 0x41, 0xef, 0x40, 0xa2, 0x8e, 0xa6, 0x74, 0x74, 0x8c,
|
|
0x92, 0x82, 0x46, 0x8a, 0xea, 0x49, 0xe0, 0x96, 0xc0, 0xba, 0xb1, 0x77, 0xd1, 0x94, 0xf6, 0x6c,
|
|
0xad, 0x08, 0x75, 0xef, 0x33, 0x7d, 0x08, 0xb3, 0x16, 0x1a, 0x6a, 0xa5, 0xd5, 0x49, 0x34, 0x65,
|
|
0x27, 0x5a, 0xeb, 0x9f, 0xe8, 0x61, 0x5b, 0xae, 0xca, 0x92, 0xa9, 0xea, 0x9a, 0x9b, 0x30, 0xe9,
|
|
0xa4, 0x70, 0xbe, 0xa5, 0x9f, 0x42, 0xbc, 0x5d, 0x27, 0xbd, 0x09, 0x33, 0x5e, 0x13, 0x6e, 0x83,
|
|
0x99, 0xd0, 0x06, 0xf3, 0x9d, 0x4f, 0x62, 0x37, 0x80, 0xbe, 0x06, 0x33, 0x44, 0xad, 0x6a, 0x92,
|
|
0xd9, 0x34, 0xd0, 0xed, 0xee, 0x4f, 0x5f, 0x74, 0x1b, 0x3d, 0x5b, 0xea, 0x08, 0xc4, 0xae, 0x96,
|
|
0x79, 0x43, 0x41, 0xc2, 0x46, 0x46, 0x1a, 0xba, 0x46, 0x90, 0xbe, 0x11, 0x40, 0xbc, 0xd2, 0x1f,
|
|
0xb1, 0xa3, 0xf7, 0x33, 0xde, 0x0d, 0x63, 0xbc, 0x12, 0x8a, 0xc6, 0x09, 0xee, 0x03, 0x59, 0x0c,
|
|
0x87, 0x9c, 0xbb, 0x20, 0xd3, 0x40, 0xca, 0xbb, 0x2e, 0xe5, 0x5b, 0x90, 0xf4, 0xfa, 0x38, 0x52,
|
|
0x15, 0xb7, 0xcd, 0xa5, 0xf3, 0xa8, 0x3c, 0xc6, 0xc5, 0x82, 0x98, 0xf0, 0x02, 0x8a, 0x0a, 0xf3,
|
|
0x95, 0x82, 0xd9, 0x02, 0xd6, 0xd0, 0xc4, 0x8e, 0x27, 0x37, 0x02, 0xc0, 0xfe, 0x0f, 0x05, 0x16,
|
|
0x88, 0x88, 0x86, 0x2d, 0x9f, 0x4d, 0x06, 0xd8, 0xf8, 0xc6, 0xfc, 0x1e, 0x83, 0xb9, 0x0e, 0x37,
|
|
0xd7, 0x9b, 0x9b, 0x01, 0xd4, 0xab, 0x17, 0xa2, 0x8e, 0x96, 0x3d, 0xa7, 0x1d, 0xda, 0xcc, 0x6b,
|
|
0x0a, 0x40, 0xc0, 0x91, 0xf6, 0xbb, 0xae, 0x3c, 0x1a, 0xc6, 0x9a, 0xd4, 0x4a, 0x3c, 0xa5, 0x20,
|
|
0x61, 0xf7, 0x3e, 0xc2, 0xc6, 0xe5, 0xd3, 0x47, 0xc5, 0x19, 0x85, 0x49, 0x8c, 0x07, 0xe6, 0x15,
|
|
0x05, 0x89, 0x7d, 0x95, 0x78, 0xc6, 0x1a, 0x06, 0x96, 0x4f, 0x1f, 0x0d, 0x67, 0xad, 0xbb, 0xa8,
|
|
0x78, 0xf8, 0x4d, 0x3f, 0x09, 0xb8, 0x6a, 0xf1, 0xbc, 0xab, 0xee, 0x9f, 0x38, 0x8e, 0xfa, 0xd5,
|
|
0x16, 0x16, 0x15, 0xe6, 0x2d, 0x05, 0x49, 0xa7, 0x61, 0xd7, 0x4e, 0xeb, 0x01, 0x42, 0xff, 0x5d,
|
|
0x40, 0x28, 0x5a, 0x7e, 0xda, 0x73, 0x21, 0xdd, 0x86, 0x59, 0xff, 0xf2, 0x23, 0xa9, 0x58, 0x76,
|
|
0x6a, 0xd0, 0xfa, 0x4b, 0xfa, 0xd6, 0x1f, 0x61, 0xbe, 0x50, 0x30, 0x5f, 0x42, 0x73, 0xe7, 0x89,
|
|
0x89, 0x9a, 0x82, 0xca, 0x56, 0x7e, 0xbf, 0xe3, 0xae, 0x7c, 0x80, 0x1d, 0x17, 0xca, 0x2e, 0x34,
|
|
0x32, 0x1a, 0x3e, 0xab, 0xbb, 0x08, 0xd7, 0x20, 0x8e, 0x92, 0x5c, 0x73, 0xdb, 0x4c, 0xf9, 0x32,
|
|
0x4a, 0x72, 0x8d, 0xdd, 0xd9, 0xca, 0xef, 0x3f, 0x90, 0xca, 0x35, 0x14, 0x6d, 0xd5, 0xf8, 0x83,
|
|
0xf0, 0x39, 0x05, 0x0b, 0xe7, 0x69, 0xb9, 0x26, 0x2d, 0x04, 0x40, 0x5f, 0x19, 0x0a, 0x74, 0x34,
|
|
0x07, 0xe3, 0x3b, 0x0a, 0xe6, 0x85, 0xb1, 0xcd, 0x26, 0x44, 0xd7, 0x6c, 0x93, 0x1a, 0x97, 0xdf,
|
|
0x28, 0x58, 0x10, 0xc6, 0x77, 0x91, 0x10, 0x69, 0x17, 0xfd, 0xdc, 0x15, 0xcb, 0xbf, 0x8c, 0xc3,
|
|
0xef, 0xde, 0x0f, 0x51, 0x72, 0x2e, 0xd5, 0xf4, 0x1e, 0x4c, 0x1d, 0x34, 0x4d, 0x7a, 0x79, 0xc0,
|
|
0xa5, 0x35, 0x9d, 0x1d, 0x74, 0xe5, 0xa2, 0x0f, 0x61, 0xda, 0x39, 0xe5, 0xd2, 0xcc, 0xe0, 0xdb,
|
|
0x46, 0xfa, 0x9f, 0x21, 0x8e, 0xc9, 0xed, 0xe2, 0x04, 0xec, 0x57, 0x5c, 0xf7, 0x84, 0xd9, 0xa7,
|
|
0x38, 0xff, 0x31, 0xec, 0x0e, 0xc4, 0xdb, 0x63, 0x91, 0xce, 0x0e, 0x3a, 0x53, 0xa4, 0xff, 0x1e,
|
|
0x38, 0x53, 0x69, 0x15, 0xe6, 0x82, 0xdb, 0x17, 0x7d, 0x69, 0xf8, 0x61, 0x92, 0xbe, 0x3c, 0xc2,
|
|
0x7e, 0xd8, 0x7e, 0x95, 0x30, 0xcc, 0xab, 0x84, 0x11, 0x5e, 0x15, 0xbe, 0x68, 0xb6, 0x8f, 0xdf,
|
|
0x9f, 0x65, 0x62, 0x1f, 0xce, 0x32, 0xb1, 0x4f, 0x67, 0x99, 0xd8, 0x8b, 0xcf, 0x99, 0x5f, 0x1e,
|
|
0xdd, 0xac, 0xaa, 0xe6, 0x71, 0xb3, 0xcc, 0xca, 0x7a, 0x9d, 0xd3, 0x48, 0x43, 0x96, 0x73, 0x0a,
|
|
0x5a, 0x9c, 0x86, 0x7a, 0x85, 0xe4, 0xa4, 0x86, 0x9a, 0xab, 0xea, 0x5c, 0xcf, 0xdf, 0x2b, 0x1b,
|
|
0xde, 0xd7, 0x53, 0x6a, 0xe1, 0x1e, 0xea, 0xbb, 0x25, 0x76, 0xeb, 0xa0, 0xd8, 0x2e, 0xc0, 0xb3,
|
|
0x5e, 0x79, 0xda, 0xfe, 0x17, 0xe5, 0xea, 0x8f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xa1, 0x09, 0xe6,
|
|
0xa5, 0xec, 0x11, 0x00, 0x00,
|
|
}
|
|
|
|
// Reference imports to suppress errors if they are not otherwise used.
|
|
var _ context.Context
|
|
var _ grpc3.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 _ = grpc3.SupportPackageIsVersion4
|
|
|
|
// ContainerServiceClient is the client API for ContainerService service.
|
|
//
|
|
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
|
|
type ContainerServiceClient interface {
|
|
// `Put` invokes `Container` smart contract's `Put` method and returns
|
|
// response immediately. After a new block is issued in sidechain, request is
|
|
// verified by Inner Ring nodes. After one more block in sidechain, container
|
|
// is added into smart contract storage.
|
|
Put(ctx context.Context, in *PutRequest, opts ...grpc3.CallOption) (*PutResponse, error)
|
|
// `Delete` invokes `Container` smart contract's `Delete` method and returns
|
|
// response immediately. After a new block is issued in sidechain, request is
|
|
// verified by Inner Ring nodes. After one more block in sidechain, container
|
|
// is added into smart contract storage.
|
|
Delete(ctx context.Context, in *DeleteRequest, opts ...grpc3.CallOption) (*DeleteResponse, error)
|
|
// Returns container structure from `Container` smart contract storage.
|
|
Get(ctx context.Context, in *GetRequest, opts ...grpc3.CallOption) (*GetResponse, error)
|
|
// Returns all owner's containers from 'Container` smart contract' storage.
|
|
List(ctx context.Context, in *ListRequest, opts ...grpc3.CallOption) (*ListResponse, error)
|
|
// Invokes 'SetEACL' method of 'Container` smart contract and returns response
|
|
// immediately. After one more block in sidechain, Extended ACL changes are
|
|
// added into smart contract storage.
|
|
SetExtendedACL(ctx context.Context, in *SetExtendedACLRequest, opts ...grpc3.CallOption) (*SetExtendedACLResponse, error)
|
|
// Returns Extended ACL table and signature from `Container` smart contract
|
|
// storage.
|
|
GetExtendedACL(ctx context.Context, in *GetExtendedACLRequest, opts ...grpc3.CallOption) (*GetExtendedACLResponse, error)
|
|
}
|
|
|
|
type containerServiceClient struct {
|
|
cc *grpc3.ClientConn
|
|
}
|
|
|
|
func NewContainerServiceClient(cc *grpc3.ClientConn) ContainerServiceClient {
|
|
return &containerServiceClient{cc}
|
|
}
|
|
|
|
func (c *containerServiceClient) Put(ctx context.Context, in *PutRequest, opts ...grpc3.CallOption) (*PutResponse, error) {
|
|
out := new(PutResponse)
|
|
err := c.cc.Invoke(ctx, "/neo.fs.v2.container.ContainerService/Put", in, out, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *containerServiceClient) Delete(ctx context.Context, in *DeleteRequest, opts ...grpc3.CallOption) (*DeleteResponse, error) {
|
|
out := new(DeleteResponse)
|
|
err := c.cc.Invoke(ctx, "/neo.fs.v2.container.ContainerService/Delete", in, out, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *containerServiceClient) Get(ctx context.Context, in *GetRequest, opts ...grpc3.CallOption) (*GetResponse, error) {
|
|
out := new(GetResponse)
|
|
err := c.cc.Invoke(ctx, "/neo.fs.v2.container.ContainerService/Get", in, out, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *containerServiceClient) List(ctx context.Context, in *ListRequest, opts ...grpc3.CallOption) (*ListResponse, error) {
|
|
out := new(ListResponse)
|
|
err := c.cc.Invoke(ctx, "/neo.fs.v2.container.ContainerService/List", in, out, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *containerServiceClient) SetExtendedACL(ctx context.Context, in *SetExtendedACLRequest, opts ...grpc3.CallOption) (*SetExtendedACLResponse, error) {
|
|
out := new(SetExtendedACLResponse)
|
|
err := c.cc.Invoke(ctx, "/neo.fs.v2.container.ContainerService/SetExtendedACL", in, out, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *containerServiceClient) GetExtendedACL(ctx context.Context, in *GetExtendedACLRequest, opts ...grpc3.CallOption) (*GetExtendedACLResponse, error) {
|
|
out := new(GetExtendedACLResponse)
|
|
err := c.cc.Invoke(ctx, "/neo.fs.v2.container.ContainerService/GetExtendedACL", in, out, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
// ContainerServiceServer is the server API for ContainerService service.
|
|
type ContainerServiceServer interface {
|
|
// `Put` invokes `Container` smart contract's `Put` method and returns
|
|
// response immediately. After a new block is issued in sidechain, request is
|
|
// verified by Inner Ring nodes. After one more block in sidechain, container
|
|
// is added into smart contract storage.
|
|
Put(context.Context, *PutRequest) (*PutResponse, error)
|
|
// `Delete` invokes `Container` smart contract's `Delete` method and returns
|
|
// response immediately. After a new block is issued in sidechain, request is
|
|
// verified by Inner Ring nodes. After one more block in sidechain, container
|
|
// is added into smart contract storage.
|
|
Delete(context.Context, *DeleteRequest) (*DeleteResponse, error)
|
|
// Returns container structure from `Container` smart contract storage.
|
|
Get(context.Context, *GetRequest) (*GetResponse, error)
|
|
// Returns all owner's containers from 'Container` smart contract' storage.
|
|
List(context.Context, *ListRequest) (*ListResponse, error)
|
|
// Invokes 'SetEACL' method of 'Container` smart contract and returns response
|
|
// immediately. After one more block in sidechain, Extended ACL changes are
|
|
// added into smart contract storage.
|
|
SetExtendedACL(context.Context, *SetExtendedACLRequest) (*SetExtendedACLResponse, error)
|
|
// Returns Extended ACL table and signature from `Container` smart contract
|
|
// storage.
|
|
GetExtendedACL(context.Context, *GetExtendedACLRequest) (*GetExtendedACLResponse, error)
|
|
}
|
|
|
|
// UnimplementedContainerServiceServer can be embedded to have forward compatible implementations.
|
|
type UnimplementedContainerServiceServer struct {
|
|
}
|
|
|
|
func (*UnimplementedContainerServiceServer) Put(ctx context.Context, req *PutRequest) (*PutResponse, error) {
|
|
return nil, status.Errorf(codes.Unimplemented, "method Put not implemented")
|
|
}
|
|
func (*UnimplementedContainerServiceServer) Delete(ctx context.Context, req *DeleteRequest) (*DeleteResponse, error) {
|
|
return nil, status.Errorf(codes.Unimplemented, "method Delete not implemented")
|
|
}
|
|
func (*UnimplementedContainerServiceServer) Get(ctx context.Context, req *GetRequest) (*GetResponse, error) {
|
|
return nil, status.Errorf(codes.Unimplemented, "method Get not implemented")
|
|
}
|
|
func (*UnimplementedContainerServiceServer) List(ctx context.Context, req *ListRequest) (*ListResponse, error) {
|
|
return nil, status.Errorf(codes.Unimplemented, "method List not implemented")
|
|
}
|
|
func (*UnimplementedContainerServiceServer) SetExtendedACL(ctx context.Context, req *SetExtendedACLRequest) (*SetExtendedACLResponse, error) {
|
|
return nil, status.Errorf(codes.Unimplemented, "method SetExtendedACL not implemented")
|
|
}
|
|
func (*UnimplementedContainerServiceServer) GetExtendedACL(ctx context.Context, req *GetExtendedACLRequest) (*GetExtendedACLResponse, error) {
|
|
return nil, status.Errorf(codes.Unimplemented, "method GetExtendedACL not implemented")
|
|
}
|
|
|
|
func RegisterContainerServiceServer(s *grpc3.Server, srv ContainerServiceServer) {
|
|
s.RegisterService(&_ContainerService_serviceDesc, srv)
|
|
}
|
|
|
|
func _ContainerService_Put_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc3.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(PutRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ContainerServiceServer).Put(ctx, in)
|
|
}
|
|
info := &grpc3.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: "/neo.fs.v2.container.ContainerService/Put",
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ContainerServiceServer).Put(ctx, req.(*PutRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _ContainerService_Delete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc3.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(DeleteRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ContainerServiceServer).Delete(ctx, in)
|
|
}
|
|
info := &grpc3.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: "/neo.fs.v2.container.ContainerService/Delete",
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ContainerServiceServer).Delete(ctx, req.(*DeleteRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _ContainerService_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc3.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(GetRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ContainerServiceServer).Get(ctx, in)
|
|
}
|
|
info := &grpc3.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: "/neo.fs.v2.container.ContainerService/Get",
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ContainerServiceServer).Get(ctx, req.(*GetRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _ContainerService_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc3.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(ListRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ContainerServiceServer).List(ctx, in)
|
|
}
|
|
info := &grpc3.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: "/neo.fs.v2.container.ContainerService/List",
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ContainerServiceServer).List(ctx, req.(*ListRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _ContainerService_SetExtendedACL_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc3.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(SetExtendedACLRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ContainerServiceServer).SetExtendedACL(ctx, in)
|
|
}
|
|
info := &grpc3.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: "/neo.fs.v2.container.ContainerService/SetExtendedACL",
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ContainerServiceServer).SetExtendedACL(ctx, req.(*SetExtendedACLRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _ContainerService_GetExtendedACL_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc3.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(GetExtendedACLRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ContainerServiceServer).GetExtendedACL(ctx, in)
|
|
}
|
|
info := &grpc3.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: "/neo.fs.v2.container.ContainerService/GetExtendedACL",
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ContainerServiceServer).GetExtendedACL(ctx, req.(*GetExtendedACLRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
var _ContainerService_serviceDesc = grpc3.ServiceDesc{
|
|
ServiceName: "neo.fs.v2.container.ContainerService",
|
|
HandlerType: (*ContainerServiceServer)(nil),
|
|
Methods: []grpc3.MethodDesc{
|
|
{
|
|
MethodName: "Put",
|
|
Handler: _ContainerService_Put_Handler,
|
|
},
|
|
{
|
|
MethodName: "Delete",
|
|
Handler: _ContainerService_Delete_Handler,
|
|
},
|
|
{
|
|
MethodName: "Get",
|
|
Handler: _ContainerService_Get_Handler,
|
|
},
|
|
{
|
|
MethodName: "List",
|
|
Handler: _ContainerService_List_Handler,
|
|
},
|
|
{
|
|
MethodName: "SetExtendedACL",
|
|
Handler: _ContainerService_SetExtendedACL_Handler,
|
|
},
|
|
{
|
|
MethodName: "GetExtendedACL",
|
|
Handler: _ContainerService_GetExtendedACL_Handler,
|
|
},
|
|
},
|
|
Streams: []grpc3.StreamDesc{},
|
|
Metadata: "v2/container/grpc/service.proto",
|
|
}
|
|
|
|
func (m *PutRequest) 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 *PutRequest) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *PutRequest) 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.VerifyHeader != nil {
|
|
{
|
|
size, err := m.VerifyHeader.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintService(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x1a
|
|
}
|
|
if m.MetaHeader != nil {
|
|
{
|
|
size, err := m.MetaHeader.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintService(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x12
|
|
}
|
|
if m.Body != nil {
|
|
{
|
|
size, err := m.Body.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintService(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *PutRequest_Body) 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 *PutRequest_Body) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *PutRequest_Body) 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.Signature != nil {
|
|
{
|
|
size, err := m.Signature.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintService(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x12
|
|
}
|
|
if m.Container != nil {
|
|
{
|
|
size, err := m.Container.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintService(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *PutResponse) 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 *PutResponse) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *PutResponse) 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.VerifyHeader != nil {
|
|
{
|
|
size, err := m.VerifyHeader.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintService(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x1a
|
|
}
|
|
if m.MetaHeader != nil {
|
|
{
|
|
size, err := m.MetaHeader.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintService(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x12
|
|
}
|
|
if m.Body != nil {
|
|
{
|
|
size, err := m.Body.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintService(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *PutResponse_Body) 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 *PutResponse_Body) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *PutResponse_Body) 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.ContainerId != nil {
|
|
{
|
|
size, err := m.ContainerId.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintService(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *DeleteRequest) 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 *DeleteRequest) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *DeleteRequest) 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.VerifyHeader != nil {
|
|
{
|
|
size, err := m.VerifyHeader.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintService(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x1a
|
|
}
|
|
if m.MetaHeader != nil {
|
|
{
|
|
size, err := m.MetaHeader.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintService(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x12
|
|
}
|
|
if m.Body != nil {
|
|
{
|
|
size, err := m.Body.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintService(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *DeleteRequest_Body) 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 *DeleteRequest_Body) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *DeleteRequest_Body) 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.Signature != nil {
|
|
{
|
|
size, err := m.Signature.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintService(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x12
|
|
}
|
|
if m.ContainerId != nil {
|
|
{
|
|
size, err := m.ContainerId.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintService(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *DeleteResponse) 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 *DeleteResponse) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *DeleteResponse) 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.VerifyHeader != nil {
|
|
{
|
|
size, err := m.VerifyHeader.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintService(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x1a
|
|
}
|
|
if m.MetaHeader != nil {
|
|
{
|
|
size, err := m.MetaHeader.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintService(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x12
|
|
}
|
|
if m.Body != nil {
|
|
{
|
|
size, err := m.Body.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintService(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *DeleteResponse_Body) 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 *DeleteResponse_Body) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *DeleteResponse_Body) 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)
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *GetRequest) 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 *GetRequest) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *GetRequest) 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.VerifyHeader != nil {
|
|
{
|
|
size, err := m.VerifyHeader.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintService(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x1a
|
|
}
|
|
if m.MetaHeader != nil {
|
|
{
|
|
size, err := m.MetaHeader.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintService(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x12
|
|
}
|
|
if m.Body != nil {
|
|
{
|
|
size, err := m.Body.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintService(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *GetRequest_Body) 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 *GetRequest_Body) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *GetRequest_Body) 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.ContainerId != nil {
|
|
{
|
|
size, err := m.ContainerId.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintService(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *GetResponse) 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 *GetResponse) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *GetResponse) 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.VerifyHeader != nil {
|
|
{
|
|
size, err := m.VerifyHeader.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintService(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x1a
|
|
}
|
|
if m.MetaHeader != nil {
|
|
{
|
|
size, err := m.MetaHeader.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintService(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x12
|
|
}
|
|
if m.Body != nil {
|
|
{
|
|
size, err := m.Body.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintService(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *GetResponse_Body) 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 *GetResponse_Body) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *GetResponse_Body) 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.Container != nil {
|
|
{
|
|
size, err := m.Container.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintService(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *ListRequest) 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 *ListRequest) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *ListRequest) 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.VerifyHeader != nil {
|
|
{
|
|
size, err := m.VerifyHeader.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintService(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x1a
|
|
}
|
|
if m.MetaHeader != nil {
|
|
{
|
|
size, err := m.MetaHeader.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintService(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x12
|
|
}
|
|
if m.Body != nil {
|
|
{
|
|
size, err := m.Body.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintService(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *ListRequest_Body) 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 *ListRequest_Body) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *ListRequest_Body) 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.OwnerId != nil {
|
|
{
|
|
size, err := m.OwnerId.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintService(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *ListResponse) 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 *ListResponse) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *ListResponse) 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.VerifyHeader != nil {
|
|
{
|
|
size, err := m.VerifyHeader.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintService(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x1a
|
|
}
|
|
if m.MetaHeader != nil {
|
|
{
|
|
size, err := m.MetaHeader.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintService(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x12
|
|
}
|
|
if m.Body != nil {
|
|
{
|
|
size, err := m.Body.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintService(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *ListResponse_Body) 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 *ListResponse_Body) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *ListResponse_Body) 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.ContainerIds) > 0 {
|
|
for iNdEx := len(m.ContainerIds) - 1; iNdEx >= 0; iNdEx-- {
|
|
{
|
|
size, err := m.ContainerIds[iNdEx].MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintService(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *SetExtendedACLRequest) 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 *SetExtendedACLRequest) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *SetExtendedACLRequest) 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.VerifyHeader != nil {
|
|
{
|
|
size, err := m.VerifyHeader.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintService(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x1a
|
|
}
|
|
if m.MetaHeader != nil {
|
|
{
|
|
size, err := m.MetaHeader.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintService(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x12
|
|
}
|
|
if m.Body != nil {
|
|
{
|
|
size, err := m.Body.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintService(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *SetExtendedACLRequest_Body) 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 *SetExtendedACLRequest_Body) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *SetExtendedACLRequest_Body) 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.Signature != nil {
|
|
{
|
|
size, err := m.Signature.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintService(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x12
|
|
}
|
|
if m.Eacl != nil {
|
|
{
|
|
size, err := m.Eacl.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintService(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *SetExtendedACLResponse) 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 *SetExtendedACLResponse) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *SetExtendedACLResponse) 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.VerifyHeader != nil {
|
|
{
|
|
size, err := m.VerifyHeader.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintService(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x1a
|
|
}
|
|
if m.MetaHeader != nil {
|
|
{
|
|
size, err := m.MetaHeader.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintService(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x12
|
|
}
|
|
if m.Body != nil {
|
|
{
|
|
size, err := m.Body.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintService(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *SetExtendedACLResponse_Body) 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 *SetExtendedACLResponse_Body) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *SetExtendedACLResponse_Body) 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)
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *GetExtendedACLRequest) 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 *GetExtendedACLRequest) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *GetExtendedACLRequest) 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.VerifyHeader != nil {
|
|
{
|
|
size, err := m.VerifyHeader.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintService(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x1a
|
|
}
|
|
if m.MetaHeader != nil {
|
|
{
|
|
size, err := m.MetaHeader.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintService(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x12
|
|
}
|
|
if m.Body != nil {
|
|
{
|
|
size, err := m.Body.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintService(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *GetExtendedACLRequest_Body) 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 *GetExtendedACLRequest_Body) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *GetExtendedACLRequest_Body) 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.ContainerId != nil {
|
|
{
|
|
size, err := m.ContainerId.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintService(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *GetExtendedACLResponse) 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 *GetExtendedACLResponse) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *GetExtendedACLResponse) 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.VerifyHeader != nil {
|
|
{
|
|
size, err := m.VerifyHeader.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintService(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x1a
|
|
}
|
|
if m.MetaHeader != nil {
|
|
{
|
|
size, err := m.MetaHeader.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintService(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x12
|
|
}
|
|
if m.Body != nil {
|
|
{
|
|
size, err := m.Body.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintService(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *GetExtendedACLResponse_Body) 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 *GetExtendedACLResponse_Body) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *GetExtendedACLResponse_Body) 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.Signature != nil {
|
|
{
|
|
size, err := m.Signature.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintService(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x12
|
|
}
|
|
if m.Eacl != nil {
|
|
{
|
|
size, err := m.Eacl.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintService(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func encodeVarintService(dAtA []byte, offset int, v uint64) int {
|
|
offset -= sovService(v)
|
|
base := offset
|
|
for v >= 1<<7 {
|
|
dAtA[offset] = uint8(v&0x7f | 0x80)
|
|
v >>= 7
|
|
offset++
|
|
}
|
|
dAtA[offset] = uint8(v)
|
|
return base
|
|
}
|
|
func (m *PutRequest) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.Body != nil {
|
|
l = m.Body.Size()
|
|
n += 1 + l + sovService(uint64(l))
|
|
}
|
|
if m.MetaHeader != nil {
|
|
l = m.MetaHeader.Size()
|
|
n += 1 + l + sovService(uint64(l))
|
|
}
|
|
if m.VerifyHeader != nil {
|
|
l = m.VerifyHeader.Size()
|
|
n += 1 + l + sovService(uint64(l))
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
n += len(m.XXX_unrecognized)
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *PutRequest_Body) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.Container != nil {
|
|
l = m.Container.Size()
|
|
n += 1 + l + sovService(uint64(l))
|
|
}
|
|
if m.Signature != nil {
|
|
l = m.Signature.Size()
|
|
n += 1 + l + sovService(uint64(l))
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
n += len(m.XXX_unrecognized)
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *PutResponse) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.Body != nil {
|
|
l = m.Body.Size()
|
|
n += 1 + l + sovService(uint64(l))
|
|
}
|
|
if m.MetaHeader != nil {
|
|
l = m.MetaHeader.Size()
|
|
n += 1 + l + sovService(uint64(l))
|
|
}
|
|
if m.VerifyHeader != nil {
|
|
l = m.VerifyHeader.Size()
|
|
n += 1 + l + sovService(uint64(l))
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
n += len(m.XXX_unrecognized)
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *PutResponse_Body) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.ContainerId != nil {
|
|
l = m.ContainerId.Size()
|
|
n += 1 + l + sovService(uint64(l))
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
n += len(m.XXX_unrecognized)
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *DeleteRequest) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.Body != nil {
|
|
l = m.Body.Size()
|
|
n += 1 + l + sovService(uint64(l))
|
|
}
|
|
if m.MetaHeader != nil {
|
|
l = m.MetaHeader.Size()
|
|
n += 1 + l + sovService(uint64(l))
|
|
}
|
|
if m.VerifyHeader != nil {
|
|
l = m.VerifyHeader.Size()
|
|
n += 1 + l + sovService(uint64(l))
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
n += len(m.XXX_unrecognized)
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *DeleteRequest_Body) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.ContainerId != nil {
|
|
l = m.ContainerId.Size()
|
|
n += 1 + l + sovService(uint64(l))
|
|
}
|
|
if m.Signature != nil {
|
|
l = m.Signature.Size()
|
|
n += 1 + l + sovService(uint64(l))
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
n += len(m.XXX_unrecognized)
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *DeleteResponse) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.Body != nil {
|
|
l = m.Body.Size()
|
|
n += 1 + l + sovService(uint64(l))
|
|
}
|
|
if m.MetaHeader != nil {
|
|
l = m.MetaHeader.Size()
|
|
n += 1 + l + sovService(uint64(l))
|
|
}
|
|
if m.VerifyHeader != nil {
|
|
l = m.VerifyHeader.Size()
|
|
n += 1 + l + sovService(uint64(l))
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
n += len(m.XXX_unrecognized)
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *DeleteResponse_Body) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.XXX_unrecognized != nil {
|
|
n += len(m.XXX_unrecognized)
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *GetRequest) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.Body != nil {
|
|
l = m.Body.Size()
|
|
n += 1 + l + sovService(uint64(l))
|
|
}
|
|
if m.MetaHeader != nil {
|
|
l = m.MetaHeader.Size()
|
|
n += 1 + l + sovService(uint64(l))
|
|
}
|
|
if m.VerifyHeader != nil {
|
|
l = m.VerifyHeader.Size()
|
|
n += 1 + l + sovService(uint64(l))
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
n += len(m.XXX_unrecognized)
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *GetRequest_Body) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.ContainerId != nil {
|
|
l = m.ContainerId.Size()
|
|
n += 1 + l + sovService(uint64(l))
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
n += len(m.XXX_unrecognized)
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *GetResponse) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.Body != nil {
|
|
l = m.Body.Size()
|
|
n += 1 + l + sovService(uint64(l))
|
|
}
|
|
if m.MetaHeader != nil {
|
|
l = m.MetaHeader.Size()
|
|
n += 1 + l + sovService(uint64(l))
|
|
}
|
|
if m.VerifyHeader != nil {
|
|
l = m.VerifyHeader.Size()
|
|
n += 1 + l + sovService(uint64(l))
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
n += len(m.XXX_unrecognized)
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *GetResponse_Body) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.Container != nil {
|
|
l = m.Container.Size()
|
|
n += 1 + l + sovService(uint64(l))
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
n += len(m.XXX_unrecognized)
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *ListRequest) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.Body != nil {
|
|
l = m.Body.Size()
|
|
n += 1 + l + sovService(uint64(l))
|
|
}
|
|
if m.MetaHeader != nil {
|
|
l = m.MetaHeader.Size()
|
|
n += 1 + l + sovService(uint64(l))
|
|
}
|
|
if m.VerifyHeader != nil {
|
|
l = m.VerifyHeader.Size()
|
|
n += 1 + l + sovService(uint64(l))
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
n += len(m.XXX_unrecognized)
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *ListRequest_Body) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.OwnerId != nil {
|
|
l = m.OwnerId.Size()
|
|
n += 1 + l + sovService(uint64(l))
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
n += len(m.XXX_unrecognized)
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *ListResponse) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.Body != nil {
|
|
l = m.Body.Size()
|
|
n += 1 + l + sovService(uint64(l))
|
|
}
|
|
if m.MetaHeader != nil {
|
|
l = m.MetaHeader.Size()
|
|
n += 1 + l + sovService(uint64(l))
|
|
}
|
|
if m.VerifyHeader != nil {
|
|
l = m.VerifyHeader.Size()
|
|
n += 1 + l + sovService(uint64(l))
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
n += len(m.XXX_unrecognized)
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *ListResponse_Body) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if len(m.ContainerIds) > 0 {
|
|
for _, e := range m.ContainerIds {
|
|
l = e.Size()
|
|
n += 1 + l + sovService(uint64(l))
|
|
}
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
n += len(m.XXX_unrecognized)
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *SetExtendedACLRequest) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.Body != nil {
|
|
l = m.Body.Size()
|
|
n += 1 + l + sovService(uint64(l))
|
|
}
|
|
if m.MetaHeader != nil {
|
|
l = m.MetaHeader.Size()
|
|
n += 1 + l + sovService(uint64(l))
|
|
}
|
|
if m.VerifyHeader != nil {
|
|
l = m.VerifyHeader.Size()
|
|
n += 1 + l + sovService(uint64(l))
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
n += len(m.XXX_unrecognized)
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *SetExtendedACLRequest_Body) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.Eacl != nil {
|
|
l = m.Eacl.Size()
|
|
n += 1 + l + sovService(uint64(l))
|
|
}
|
|
if m.Signature != nil {
|
|
l = m.Signature.Size()
|
|
n += 1 + l + sovService(uint64(l))
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
n += len(m.XXX_unrecognized)
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *SetExtendedACLResponse) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.Body != nil {
|
|
l = m.Body.Size()
|
|
n += 1 + l + sovService(uint64(l))
|
|
}
|
|
if m.MetaHeader != nil {
|
|
l = m.MetaHeader.Size()
|
|
n += 1 + l + sovService(uint64(l))
|
|
}
|
|
if m.VerifyHeader != nil {
|
|
l = m.VerifyHeader.Size()
|
|
n += 1 + l + sovService(uint64(l))
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
n += len(m.XXX_unrecognized)
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *SetExtendedACLResponse_Body) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.XXX_unrecognized != nil {
|
|
n += len(m.XXX_unrecognized)
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *GetExtendedACLRequest) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.Body != nil {
|
|
l = m.Body.Size()
|
|
n += 1 + l + sovService(uint64(l))
|
|
}
|
|
if m.MetaHeader != nil {
|
|
l = m.MetaHeader.Size()
|
|
n += 1 + l + sovService(uint64(l))
|
|
}
|
|
if m.VerifyHeader != nil {
|
|
l = m.VerifyHeader.Size()
|
|
n += 1 + l + sovService(uint64(l))
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
n += len(m.XXX_unrecognized)
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *GetExtendedACLRequest_Body) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.ContainerId != nil {
|
|
l = m.ContainerId.Size()
|
|
n += 1 + l + sovService(uint64(l))
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
n += len(m.XXX_unrecognized)
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *GetExtendedACLResponse) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.Body != nil {
|
|
l = m.Body.Size()
|
|
n += 1 + l + sovService(uint64(l))
|
|
}
|
|
if m.MetaHeader != nil {
|
|
l = m.MetaHeader.Size()
|
|
n += 1 + l + sovService(uint64(l))
|
|
}
|
|
if m.VerifyHeader != nil {
|
|
l = m.VerifyHeader.Size()
|
|
n += 1 + l + sovService(uint64(l))
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
n += len(m.XXX_unrecognized)
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *GetExtendedACLResponse_Body) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.Eacl != nil {
|
|
l = m.Eacl.Size()
|
|
n += 1 + l + sovService(uint64(l))
|
|
}
|
|
if m.Signature != nil {
|
|
l = m.Signature.Size()
|
|
n += 1 + l + sovService(uint64(l))
|
|
}
|
|
if m.XXX_unrecognized != nil {
|
|
n += len(m.XXX_unrecognized)
|
|
}
|
|
return n
|
|
}
|
|
|
|
func sovService(x uint64) (n int) {
|
|
return (math_bits.Len64(x|1) + 6) / 7
|
|
}
|
|
func sozService(x uint64) (n int) {
|
|
return sovService(uint64((x << 1) ^ uint64((int64(x) >> 63))))
|
|
}
|
|
func (m *PutRequest) 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 ErrIntOverflowService
|
|
}
|
|
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: PutRequest: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: PutRequest: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowService
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.Body == nil {
|
|
m.Body = &PutRequest_Body{}
|
|
}
|
|
if err := m.Body.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field MetaHeader", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowService
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.MetaHeader == nil {
|
|
m.MetaHeader = &grpc.RequestMetaHeader{}
|
|
}
|
|
if err := m.MetaHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 3:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field VerifyHeader", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowService
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.VerifyHeader == nil {
|
|
m.VerifyHeader = &grpc.RequestVerificationHeader{}
|
|
}
|
|
if err := m.VerifyHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipService(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
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 *PutRequest_Body) 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 ErrIntOverflowService
|
|
}
|
|
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: Body: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: Body: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Container", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowService
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.Container == nil {
|
|
m.Container = &Container{}
|
|
}
|
|
if err := m.Container.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowService
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.Signature == nil {
|
|
m.Signature = &grpc1.Signature{}
|
|
}
|
|
if err := m.Signature.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipService(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
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 *PutResponse) 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 ErrIntOverflowService
|
|
}
|
|
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: PutResponse: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: PutResponse: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowService
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.Body == nil {
|
|
m.Body = &PutResponse_Body{}
|
|
}
|
|
if err := m.Body.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field MetaHeader", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowService
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.MetaHeader == nil {
|
|
m.MetaHeader = &grpc.ResponseMetaHeader{}
|
|
}
|
|
if err := m.MetaHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 3:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field VerifyHeader", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowService
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.VerifyHeader == nil {
|
|
m.VerifyHeader = &grpc.ResponseVerificationHeader{}
|
|
}
|
|
if err := m.VerifyHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipService(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
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 *PutResponse_Body) 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 ErrIntOverflowService
|
|
}
|
|
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: Body: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: Body: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field ContainerId", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowService
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.ContainerId == nil {
|
|
m.ContainerId = &grpc1.ContainerID{}
|
|
}
|
|
if err := m.ContainerId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipService(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
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 *DeleteRequest) 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 ErrIntOverflowService
|
|
}
|
|
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: DeleteRequest: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: DeleteRequest: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowService
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.Body == nil {
|
|
m.Body = &DeleteRequest_Body{}
|
|
}
|
|
if err := m.Body.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field MetaHeader", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowService
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.MetaHeader == nil {
|
|
m.MetaHeader = &grpc.RequestMetaHeader{}
|
|
}
|
|
if err := m.MetaHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 3:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field VerifyHeader", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowService
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.VerifyHeader == nil {
|
|
m.VerifyHeader = &grpc.RequestVerificationHeader{}
|
|
}
|
|
if err := m.VerifyHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipService(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
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 *DeleteRequest_Body) 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 ErrIntOverflowService
|
|
}
|
|
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: Body: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: Body: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field ContainerId", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowService
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.ContainerId == nil {
|
|
m.ContainerId = &grpc1.ContainerID{}
|
|
}
|
|
if err := m.ContainerId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowService
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.Signature == nil {
|
|
m.Signature = &grpc1.Signature{}
|
|
}
|
|
if err := m.Signature.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipService(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
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 *DeleteResponse) 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 ErrIntOverflowService
|
|
}
|
|
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: DeleteResponse: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: DeleteResponse: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowService
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.Body == nil {
|
|
m.Body = &DeleteResponse_Body{}
|
|
}
|
|
if err := m.Body.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field MetaHeader", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowService
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.MetaHeader == nil {
|
|
m.MetaHeader = &grpc.ResponseMetaHeader{}
|
|
}
|
|
if err := m.MetaHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 3:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field VerifyHeader", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowService
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.VerifyHeader == nil {
|
|
m.VerifyHeader = &grpc.ResponseVerificationHeader{}
|
|
}
|
|
if err := m.VerifyHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipService(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
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 *DeleteResponse_Body) 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 ErrIntOverflowService
|
|
}
|
|
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: Body: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: Body: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipService(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
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 *GetRequest) 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 ErrIntOverflowService
|
|
}
|
|
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: GetRequest: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: GetRequest: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowService
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.Body == nil {
|
|
m.Body = &GetRequest_Body{}
|
|
}
|
|
if err := m.Body.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field MetaHeader", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowService
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.MetaHeader == nil {
|
|
m.MetaHeader = &grpc.RequestMetaHeader{}
|
|
}
|
|
if err := m.MetaHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 3:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field VerifyHeader", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowService
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.VerifyHeader == nil {
|
|
m.VerifyHeader = &grpc.RequestVerificationHeader{}
|
|
}
|
|
if err := m.VerifyHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipService(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
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 *GetRequest_Body) 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 ErrIntOverflowService
|
|
}
|
|
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: Body: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: Body: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field ContainerId", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowService
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.ContainerId == nil {
|
|
m.ContainerId = &grpc1.ContainerID{}
|
|
}
|
|
if err := m.ContainerId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipService(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
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 *GetResponse) 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 ErrIntOverflowService
|
|
}
|
|
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: GetResponse: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: GetResponse: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowService
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.Body == nil {
|
|
m.Body = &GetResponse_Body{}
|
|
}
|
|
if err := m.Body.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field MetaHeader", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowService
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.MetaHeader == nil {
|
|
m.MetaHeader = &grpc.ResponseMetaHeader{}
|
|
}
|
|
if err := m.MetaHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 3:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field VerifyHeader", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowService
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.VerifyHeader == nil {
|
|
m.VerifyHeader = &grpc.ResponseVerificationHeader{}
|
|
}
|
|
if err := m.VerifyHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipService(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
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 *GetResponse_Body) 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 ErrIntOverflowService
|
|
}
|
|
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: Body: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: Body: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Container", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowService
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.Container == nil {
|
|
m.Container = &Container{}
|
|
}
|
|
if err := m.Container.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipService(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
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 *ListRequest) 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 ErrIntOverflowService
|
|
}
|
|
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: ListRequest: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: ListRequest: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowService
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.Body == nil {
|
|
m.Body = &ListRequest_Body{}
|
|
}
|
|
if err := m.Body.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field MetaHeader", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowService
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.MetaHeader == nil {
|
|
m.MetaHeader = &grpc.RequestMetaHeader{}
|
|
}
|
|
if err := m.MetaHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 3:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field VerifyHeader", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowService
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.VerifyHeader == nil {
|
|
m.VerifyHeader = &grpc.RequestVerificationHeader{}
|
|
}
|
|
if err := m.VerifyHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipService(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
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 *ListRequest_Body) 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 ErrIntOverflowService
|
|
}
|
|
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: Body: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: Body: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field OwnerId", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowService
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.OwnerId == nil {
|
|
m.OwnerId = &grpc1.OwnerID{}
|
|
}
|
|
if err := m.OwnerId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipService(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
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 *ListResponse) 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 ErrIntOverflowService
|
|
}
|
|
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: ListResponse: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: ListResponse: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowService
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.Body == nil {
|
|
m.Body = &ListResponse_Body{}
|
|
}
|
|
if err := m.Body.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field MetaHeader", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowService
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.MetaHeader == nil {
|
|
m.MetaHeader = &grpc.ResponseMetaHeader{}
|
|
}
|
|
if err := m.MetaHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 3:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field VerifyHeader", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowService
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.VerifyHeader == nil {
|
|
m.VerifyHeader = &grpc.ResponseVerificationHeader{}
|
|
}
|
|
if err := m.VerifyHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipService(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
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 *ListResponse_Body) 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 ErrIntOverflowService
|
|
}
|
|
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: Body: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: Body: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field ContainerIds", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowService
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.ContainerIds = append(m.ContainerIds, &grpc1.ContainerID{})
|
|
if err := m.ContainerIds[len(m.ContainerIds)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipService(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
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 *SetExtendedACLRequest) 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 ErrIntOverflowService
|
|
}
|
|
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: SetExtendedACLRequest: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: SetExtendedACLRequest: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowService
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.Body == nil {
|
|
m.Body = &SetExtendedACLRequest_Body{}
|
|
}
|
|
if err := m.Body.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field MetaHeader", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowService
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.MetaHeader == nil {
|
|
m.MetaHeader = &grpc.RequestMetaHeader{}
|
|
}
|
|
if err := m.MetaHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 3:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field VerifyHeader", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowService
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.VerifyHeader == nil {
|
|
m.VerifyHeader = &grpc.RequestVerificationHeader{}
|
|
}
|
|
if err := m.VerifyHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipService(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
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 *SetExtendedACLRequest_Body) 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 ErrIntOverflowService
|
|
}
|
|
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: Body: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: Body: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Eacl", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowService
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.Eacl == nil {
|
|
m.Eacl = &grpc2.EACLTable{}
|
|
}
|
|
if err := m.Eacl.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowService
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.Signature == nil {
|
|
m.Signature = &grpc1.Signature{}
|
|
}
|
|
if err := m.Signature.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipService(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
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 *SetExtendedACLResponse) 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 ErrIntOverflowService
|
|
}
|
|
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: SetExtendedACLResponse: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: SetExtendedACLResponse: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowService
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.Body == nil {
|
|
m.Body = &SetExtendedACLResponse_Body{}
|
|
}
|
|
if err := m.Body.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field MetaHeader", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowService
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.MetaHeader == nil {
|
|
m.MetaHeader = &grpc.ResponseMetaHeader{}
|
|
}
|
|
if err := m.MetaHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 3:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field VerifyHeader", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowService
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.VerifyHeader == nil {
|
|
m.VerifyHeader = &grpc.ResponseVerificationHeader{}
|
|
}
|
|
if err := m.VerifyHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipService(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
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 *SetExtendedACLResponse_Body) 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 ErrIntOverflowService
|
|
}
|
|
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: Body: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: Body: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipService(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
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 *GetExtendedACLRequest) 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 ErrIntOverflowService
|
|
}
|
|
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: GetExtendedACLRequest: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: GetExtendedACLRequest: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowService
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.Body == nil {
|
|
m.Body = &GetExtendedACLRequest_Body{}
|
|
}
|
|
if err := m.Body.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field MetaHeader", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowService
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.MetaHeader == nil {
|
|
m.MetaHeader = &grpc.RequestMetaHeader{}
|
|
}
|
|
if err := m.MetaHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 3:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field VerifyHeader", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowService
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.VerifyHeader == nil {
|
|
m.VerifyHeader = &grpc.RequestVerificationHeader{}
|
|
}
|
|
if err := m.VerifyHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipService(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
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 *GetExtendedACLRequest_Body) 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 ErrIntOverflowService
|
|
}
|
|
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: Body: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: Body: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field ContainerId", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowService
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.ContainerId == nil {
|
|
m.ContainerId = &grpc1.ContainerID{}
|
|
}
|
|
if err := m.ContainerId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipService(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
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 *GetExtendedACLResponse) 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 ErrIntOverflowService
|
|
}
|
|
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: GetExtendedACLResponse: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: GetExtendedACLResponse: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowService
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.Body == nil {
|
|
m.Body = &GetExtendedACLResponse_Body{}
|
|
}
|
|
if err := m.Body.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field MetaHeader", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowService
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.MetaHeader == nil {
|
|
m.MetaHeader = &grpc.ResponseMetaHeader{}
|
|
}
|
|
if err := m.MetaHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 3:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field VerifyHeader", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowService
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.VerifyHeader == nil {
|
|
m.VerifyHeader = &grpc.ResponseVerificationHeader{}
|
|
}
|
|
if err := m.VerifyHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipService(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
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 *GetExtendedACLResponse_Body) 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 ErrIntOverflowService
|
|
}
|
|
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: Body: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: Body: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Eacl", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowService
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.Eacl == nil {
|
|
m.Eacl = &grpc2.EACLTable{}
|
|
}
|
|
if err := m.Eacl.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowService
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.Signature == nil {
|
|
m.Signature = &grpc1.Signature{}
|
|
}
|
|
if err := m.Signature.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipService(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthService
|
|
}
|
|
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 skipService(dAtA []byte) (n int, err error) {
|
|
l := len(dAtA)
|
|
iNdEx := 0
|
|
depth := 0
|
|
for iNdEx < l {
|
|
var wire uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return 0, ErrIntOverflowService
|
|
}
|
|
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, ErrIntOverflowService
|
|
}
|
|
if iNdEx >= l {
|
|
return 0, io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx++
|
|
if dAtA[iNdEx-1] < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 1:
|
|
iNdEx += 8
|
|
case 2:
|
|
var length int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return 0, ErrIntOverflowService
|
|
}
|
|
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, ErrInvalidLengthService
|
|
}
|
|
iNdEx += length
|
|
case 3:
|
|
depth++
|
|
case 4:
|
|
if depth == 0 {
|
|
return 0, ErrUnexpectedEndOfGroupService
|
|
}
|
|
depth--
|
|
case 5:
|
|
iNdEx += 4
|
|
default:
|
|
return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
|
|
}
|
|
if iNdEx < 0 {
|
|
return 0, ErrInvalidLengthService
|
|
}
|
|
if depth == 0 {
|
|
return iNdEx, nil
|
|
}
|
|
}
|
|
return 0, io.ErrUnexpectedEOF
|
|
}
|
|
|
|
var (
|
|
ErrInvalidLengthService = fmt.Errorf("proto: negative length found during unmarshaling")
|
|
ErrIntOverflowService = fmt.Errorf("proto: integer overflow")
|
|
ErrUnexpectedEndOfGroupService = fmt.Errorf("proto: unexpected end of group")
|
|
)
|