potyarkin/frostfs-api-go
1
0
Fork 0
forked from TrueCloudLab/frostfs-api-go
Code Pull requests Activity

Update neofs-api to latest jindo version

Browse source 
Signed-off-by: Alex Vanin <alexey@nspcc.ru>
This commit is contained in:
Alex Vanin 2020-08-18 15:48:39 +03:00 committed by Stanislav Bogatyrev
parent c3604d00f0
commit c94cb44b58
17 changed files with 2115 additions and 2236 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

270
v2/accounting/grpc/service.pb.go
View file

@ -154,64 +154,6 @@ func (m *BalanceRequest_Body) GetOwnerId() *grpc1.OwnerID {
return nil
}
// Decimal represents the decimal numbers.
type Decimal struct {
// value carries number value.
Value int64 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
// precision carries value precision.
Precision uint32 `protobuf:"varint,2,opt,name=precision,proto3" json:"precision,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Decimal) Reset() { *m = Decimal{} }
func (m *Decimal) String() string { return proto.CompactTextString(m) }
func (*Decimal) ProtoMessage() {}
func (*Decimal) Descriptor() ([]byte, []int) {
return fileDescriptor_d9dd5af2ff2bbb25, []int{1}
}
func (m *Decimal) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *Decimal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_Decimal.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 *Decimal) XXX_Merge(src proto.Message) {
xxx_messageInfo_Decimal.Merge(m, src)
}
func (m *Decimal) XXX_Size() int {
return m.Size()
}
func (m *Decimal) XXX_DiscardUnknown() {
xxx_messageInfo_Decimal.DiscardUnknown(m)
}
var xxx_messageInfo_Decimal proto.InternalMessageInfo
func (m *Decimal) GetValue() int64 {
if m != nil {
return m.Value
}
return 0
}
func (m *Decimal) GetPrecision() uint32 {
if m != nil {
return m.Precision
}
return 0
}
// Message defines the response body of Balance method.
//
// The amount of funds is calculated in decimal numbers.
@ -234,7 +176,7 @@ func (m *BalanceResponse) Reset() { *m = BalanceResponse{} }
func (m *BalanceResponse) String() string { return proto.CompactTextString(m) }
func (*BalanceResponse) ProtoMessage() {}
func (*BalanceResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_d9dd5af2ff2bbb25, []int{2}
return fileDescriptor_d9dd5af2ff2bbb25, []int{1}
}
func (m *BalanceResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -297,7 +239,7 @@ func (m *BalanceResponse_Body) Reset() { *m = BalanceResponse_Body{} }
func (m *BalanceResponse_Body) String() string { return proto.CompactTextString(m) }
func (*BalanceResponse_Body) ProtoMessage() {}
func (*BalanceResponse_Body) Descriptor() ([]byte, []int) {
return fileDescriptor_d9dd5af2ff2bbb25, []int{2, 0}
return fileDescriptor_d9dd5af2ff2bbb25, []int{1, 0}
}
func (m *BalanceResponse_Body) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -336,7 +278,6 @@ func (m *BalanceResponse_Body) GetBalance() *Decimal {
func init() {
proto.RegisterType((*BalanceRequest)(nil), "neo.fs.v2.accounting.BalanceRequest")
proto.RegisterType((*BalanceRequest_Body)(nil), "neo.fs.v2.accounting.BalanceRequest.Body")
proto.RegisterType((*Decimal)(nil), "neo.fs.v2.accounting.Decimal")
proto.RegisterType((*BalanceResponse)(nil), "neo.fs.v2.accounting.BalanceResponse")
proto.RegisterType((*BalanceResponse_Body)(nil), "neo.fs.v2.accounting.BalanceResponse.Body")
}
@ -344,37 +285,35 @@ func init() {
func init() { proto.RegisterFile("v2/accounting/grpc/service.proto", fileDescriptor_d9dd5af2ff2bbb25) }
var fileDescriptor_d9dd5af2ff2bbb25 = []byte{
// 478 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x93, 0x4f, 0x6e, 0x13, 0x31,
0x18, 0xc5, 0x99, 0xb4, 0x10, 0x70, 0x29, 0x08, 0xab, 0x52, 0xa3, 0x51, 0x89, 0xaa, 0xa8, 0x95,
0x00, 0x11, 0x8f, 0x34, 0x2c, 0x90, 0x40, 0xa5, 0x6a, 0x54, 0x2a, 0xb2, 0xe0, 0xdf, 0x54, 0xea,
0x82, 0x4d, 0xe5, 0x78, 0xbe, 0xa4, 0x56, 0x13, 0x7b, 0x18, 0x3b, 0x46, 0xb9, 0x09, 0x17, 0x60,
0xc3, 0x82, 0x73, 0xb0, 0xe4, 0x08, 0x28, 0x5c, 0x04, 0x8d, 0xed, 0x64, 0x52, 0x98, 0xb6, 0xd9,
0xc5, 0xf9, 0xde, 0x7b, 0xfe, 0xde, 0x4f, 0x63, 0xb4, 0x6d, 0xe2, 0x88, 0x32, 0x26, 0xc7, 0x42,
0x73, 0x31, 0x88, 0x06, 0x79, 0xc6, 0x22, 0x05, 0xb9, 0xe1, 0x0c, 0x48, 0x96, 0x4b, 0x2d, 0xf1,
0x86, 0x00, 0x49, 0xfa, 0x8a, 0x98, 0x98, 0x94, 0xc2, 0xb0, 0x61, 0xe2, 0x28, 0x87, 0xbe, 0x72,
0x0e, 0x3d, 0xc9, 0x40, 0x39, 0x7d, 0x18, 0x9a, 0x78, 0x96, 0xe0, 0x86, 0x23, 0xd0, 0xd4, 0xcf,
0xb6, 0xfe, 0x9d, 0x19, 0xc8, 0x79, 0x7f, 0xe2, 0xa6, 0xad, 0x6f, 0x35, 0x74, 0xaf, 0x43, 0x87,
0x54, 0x30, 0x48, 0xe0, 0xf3, 0x18, 0x94, 0xc6, 0x7b, 0x68, 0xb5, 0x27, 0xd3, 0x49, 0x23, 0xd8,
0x0e, 0x1e, 0xad, 0xc5, 0x8f, 0x49, 0xd5, 0x2e, 0xe4, 0xa2, 0x87, 0x74, 0x64, 0x3a, 0x49, 0xac,
0x0d, 0xbf, 0x46, 0x6b, 0xc5, 0xed, 0xa7, 0x67, 0x40, 0x53, 0xc8, 0x1b, 0x35, 0x9b, 0xb2, 0xb3,
0x90, 0x32, 0xab, 0xea, 0xbd, 0x6f, 0x41, 0xd3, 0x37, 0x56, 0x9b, 0xa0, 0xd1, 0xfc, 0x37, 0xfe,
0x88, 0xd6, 0xdd, 0xa2, 0xb3, 0xa0, 0x15, 0x1b, 0xf4, 0xf4, 0xf2, 0xa0, 0x93, 0x42, 0xce, 0x19,
0xd5, 0x5c, 0x0a, 0x1f, 0x78, 0xd7, 0x45, 0xb8, 0x53, 0xf8, 0x02, 0xad, 0x16, 0x7b, 0xe2, 0x18,
0xdd, 0x96, 0x5f, 0x04, 0xe4, 0xa7, 0x3c, 0xf5, 0x25, 0x37, 0x17, 0x52, 0x0b, 0xc2, 0xe4, 0x7d,
0x31, 0xef, 0x1e, 0x26, 0x75, 0x2b, 0xec, 0xa6, 0xad, 0x3d, 0x54, 0x3f, 0x04, 0xc6, 0x47, 0x74,
0x88, 0x37, 0xd0, 0x4d, 0x43, 0x87, 0x63, 0xb0, 0xde, 0x95, 0xc4, 0x1d, 0xf0, 0x16, 0xba, 0x93,
0xe5, 0xc0, 0xb8, 0xe2, 0x52, 0xd8, 0xd2, 0xeb, 0x49, 0xf9, 0x47, 0xeb, 0x47, 0x0d, 0xdd, 0x9f,
0x23, 0x53, 0x99, 0x14, 0x0a, 0xf0, 0xab, 0x0b, 0x9c, 0x9f, 0x5c, 0xc3, 0xd9, 0x99, 0x16, 0x41,
0x1f, 0x55, 0x81, 0xde, 0xad, 0xe4, 0xe3, 0xcc, 0x97, 0x90, 0x4e, 0xaa, 0x49, 0xb7, 0xaf, 0x48,
0xba, 0x16, 0xf5, 0xbe, 0x47, 0xfd, 0x1c, 0xd5, 0x7b, 0xae, 0x81, 0xaf, 0xf9, 0xb0, 0xba, 0xa6,
0x67, 0x9b, 0xcc, 0xd4, 0xf1, 0x39, 0x7a, 0x70, 0x30, 0x1f, 0x1f, 0xbb, 0xeb, 0xf1, 0x09, 0xaa,
0x7b, 0x1e, 0x78, 0x67, 0x99, 0xcf, 0x32, 0xdc, 0x5d, 0x0a, 0x6a, 0xe7, 0xfc, 0xe7, 0xb4, 0x19,
0xfc, 0x9a, 0x36, 0x83, 0xdf, 0xd3, 0x66, 0xf0, 0xf5, 0x4f, 0xf3, 0xc6, 0xa7, 0xfd, 0x01, 0xd7,
0x67, 0xe3, 0x1e, 0x61, 0x72, 0x14, 0x09, 0x95, 0x31, 0xd6, 0x4e, 0xc1, 0x44, 0x02, 0x64, 0x5f,
0xb5, 0x69, 0xc6, 0xdb, 0x03, 0x19, 0xfd, 0xff, 0x88, 0x5f, 0x96, 0xe7, 0xef, 0xb5, 0xcd, 0x77,
0x20, 0x8f, 0x8e, 0xc9, 0xc1, 0x87, 0x6e, 0x71, 0x79, 0xd9, 0xa5, 0x77, 0xcb, 0x3e, 0xbc, 0x67,
0x7f, 0x03, 0x00, 0x00, 0xff, 0xff, 0x34, 0x56, 0xa2, 0x45, 0x06, 0x04, 0x00, 0x00,
// 438 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x93, 0xcb, 0x8a, 0xd4, 0x40,
0x18, 0x85, 0x4d, 0x1c, 0x6c, 0xa9, 0xf1, 0x82, 0x85, 0x30, 0x4d, 0xc4, 0x30, 0x0c, 0x33, 0xa0,
0x62, 0x2a, 0x10, 0x17, 0x82, 0xa2, 0xc3, 0x34, 0xe3, 0x60, 0x2f, 0xbc, 0x65, 0x60, 0x16, 0x6e,
0x86, 0x4a, 0xe5, 0x4f, 0xa6, 0xe8, 0x4e, 0x55, 0x4c, 0x55, 0x47, 0xf2, 0x26, 0xbe, 0x80, 0x1b,
0x17, 0x3e, 0x87, 0x4b, 0x1f, 0x41, 0xda, 0x17, 0x91, 0xdc, 0xfa, 0x42, 0xa7, 0xed, 0xde, 0xa5,
0xf8, 0xcf, 0x39, 0x7f, 0x9d, 0x8f, 0x14, 0xda, 0xcf, 0x3d, 0x97, 0x32, 0x26, 0x27, 0x42, 0x73,
0x11, 0xbb, 0x71, 0x96, 0x32, 0x57, 0x41, 0x96, 0x73, 0x06, 0x24, 0xcd, 0xa4, 0x96, 0xf8, 0xbe,
0x00, 0x49, 0x22, 0x45, 0x72, 0x8f, 0xcc, 0x85, 0x96, 0xdd, 0xe1, 0xd3, 0x45, 0x0a, 0xaa, 0x76,
0x59, 0xfd, 0xdc, 0x73, 0x33, 0x88, 0xd4, 0xea, 0xe4, 0x41, 0xee, 0xb5, 0x1b, 0x56, 0x86, 0x07,
0xdf, 0x4d, 0x74, 0x67, 0x40, 0xc7, 0x54, 0x30, 0xf0, 0xe1, 0xcb, 0x04, 0x94, 0xc6, 0xaf, 0xd0,
0x4e, 0x20, 0xc3, 0xa2, 0x6f, 0xec, 0x1b, 0x8f, 0x76, 0xbd, 0xc7, 0xa4, 0xeb, 0x3a, 0x64, 0xd9,
0x43, 0x06, 0x32, 0x2c, 0xfc, 0xca, 0x86, 0xdf, 0xa0, 0xdd, 0x04, 0x34, 0xbd, 0xbc, 0x02, 0x1a,
0x42, 0xd6, 0x37, 0xab, 0x94, 0xc3, 0x85, 0x94, 0xb6, 0x6d, 0xe3, 0x7d, 0x07, 0x9a, 0xbe, 0xad,
0xb4, 0x3e, 0x4a, 0x66, 0xdf, 0xf8, 0x13, 0xba, 0x9d, 0x43, 0xc6, 0xa3, 0xa2, 0x0d, 0xba, 0x5e,
0x05, 0x3d, 0x5d, 0x1f, 0x74, 0x51, 0xca, 0x39, 0xa3, 0x9a, 0x4b, 0xd1, 0x04, 0xde, 0xaa, 0x23,
0xea, 0x93, 0xf5, 0x02, 0xed, 0x94, 0xf7, 0xc4, 0x1e, 0xba, 0x29, 0xbf, 0x0a, 0xc8, 0x2e, 0x79,
0xd8, 0x94, 0xdc, 0x5b, 0x48, 0x2d, 0x21, 0x92, 0x0f, 0xe5, 0x7c, 0x78, 0xea, 0xf7, 0x2a, 0xe1,
0x30, 0x3c, 0xf8, 0x69, 0xa2, 0xbb, 0xb3, 0xce, 0x2a, 0x95, 0x42, 0x01, 0x7e, 0xbd, 0x04, 0xea,
0xc9, 0x06, 0x50, 0xb5, 0x69, 0x91, 0xd4, 0x59, 0x17, 0xa9, 0xa3, 0xce, 0x82, 0xb5, 0x79, 0x0d,
0x2a, 0xbf, 0x1b, 0x95, 0xf3, 0x9f, 0xa4, 0x8d, 0xac, 0x8e, 0x1b, 0x56, 0xcf, 0x51, 0x2f, 0xa8,
0x1b, 0x34, 0x35, 0x1f, 0x76, 0xd7, 0x3c, 0x05, 0xc6, 0x13, 0x3a, 0xf6, 0x5b, 0xb5, 0x37, 0x42,
0xf7, 0x4e, 0x66, 0xe3, 0xf3, 0x7a, 0x3d, 0xbe, 0x40, 0xbd, 0x86, 0x07, 0x3e, 0xdc, 0xe6, 0xbf,
0xb2, 0x8e, 0xb6, 0x82, 0x3a, 0x18, 0xfd, 0x9a, 0xda, 0xc6, 0xef, 0xa9, 0x6d, 0xfc, 0x99, 0xda,
0xc6, 0xb7, 0xbf, 0xf6, 0xb5, 0xcf, 0xc7, 0x31, 0xd7, 0x57, 0x93, 0x80, 0x30, 0x99, 0xb8, 0x42,
0xa5, 0x8c, 0x39, 0x21, 0xe4, 0xae, 0x00, 0x19, 0x29, 0x87, 0xa6, 0xdc, 0x89, 0xa5, 0xbb, 0xfa,
0xa0, 0x5e, 0xce, 0xcf, 0x3f, 0xcc, 0xbd, 0xf7, 0x20, 0xcf, 0xce, 0xc9, 0xc9, 0xc7, 0x61, 0xb9,
0x7c, 0xde, 0x25, 0xb8, 0x51, 0xbd, 0x9c, 0x67, 0xff, 0x02, 0x00, 0x00, 0xff, 0xff, 0x15, 0x3d,
0x57, 0xcb, 0xca, 0x03, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
@ -561,43 +500,6 @@ func (m *BalanceRequest_Body) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil
}
func (m *Decimal) 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 *Decimal) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *Decimal) 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.Precision != 0 {
i = encodeVarintService(dAtA, i, uint64(m.Precision))
i--
dAtA[i] = 0x10
}
if m.Value != 0 {
i = encodeVarintService(dAtA, i, uint64(m.Value))
i--
dAtA[i] = 0x8
}
return len(dAtA) - i, nil
}
func (m *BalanceResponse) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
@ -751,24 +653,6 @@ func (m *BalanceRequest_Body) Size() (n int) {
return n
}
func (m *Decimal) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
if m.Value != 0 {
n += 1 + sovService(uint64(m.Value))
}
if m.Precision != 0 {
n += 1 + sovService(uint64(m.Precision))
}
if m.XXX_unrecognized != nil {
n += len(m.XXX_unrecognized)
}
return n
}
func (m *BalanceResponse) Size() (n int) {
if m == nil {
return 0
@ -1067,98 +951,6 @@ func (m *BalanceRequest_Body) Unmarshal(dAtA []byte) error {
}
return nil
}
func (m *Decimal) 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: Decimal: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: Decimal: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
}
m.Value = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowService
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.Value |= int64(b&0x7F) << shift
if b < 0x80 {
break
}
}
case 2:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Precision", wireType)
}
m.Precision = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowService
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.Precision |= uint32(b&0x7F) << shift
if b < 0x80 {
break
}
}
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 *BalanceResponse) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0

353
v2/accounting/grpc/types.pb.go Normal file
View file

@ -0,0 +1,353 @@
// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: v2/accounting/grpc/types.proto
package accounting
import (
fmt "fmt"
proto "github.com/golang/protobuf/proto"
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
// Decimal represents the decimal numbers.
type Decimal struct {
// value carries number value.
Value int64 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
// precision carries value precision.
Precision uint32 `protobuf:"varint,2,opt,name=precision,proto3" json:"precision,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Decimal) Reset() { *m = Decimal{} }
func (m *Decimal) String() string { return proto.CompactTextString(m) }
func (*Decimal) ProtoMessage() {}
func (*Decimal) Descriptor() ([]byte, []int) {
return fileDescriptor_86d8857937dfd0e8, []int{0}
}
func (m *Decimal) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *Decimal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_Decimal.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 *Decimal) XXX_Merge(src proto.Message) {
xxx_messageInfo_Decimal.Merge(m, src)
}
func (m *Decimal) XXX_Size() int {
return m.Size()
}
func (m *Decimal) XXX_DiscardUnknown() {
xxx_messageInfo_Decimal.DiscardUnknown(m)
}
var xxx_messageInfo_Decimal proto.InternalMessageInfo
func (m *Decimal) GetValue() int64 {
if m != nil {
return m.Value
}
return 0
}
func (m *Decimal) GetPrecision() uint32 {
if m != nil {
return m.Precision
}
return 0
}
func init() {
proto.RegisterType((*Decimal)(nil), "neo.fs.v2.accounting.Decimal")
}
func init() { proto.RegisterFile("v2/accounting/grpc/types.proto", fileDescriptor_86d8857937dfd0e8) }
var fileDescriptor_86d8857937dfd0e8 = []byte{
// 203 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x2b, 0x33, 0xd2, 0x4f,
0x4c, 0x4e, 0xce, 0x2f, 0xcd, 0x2b, 0xc9, 0xcc, 0x4b, 0xd7, 0x4f, 0x2f, 0x2a, 0x48, 0xd6, 0x2f,
0xa9, 0x2c, 0x48, 0x2d, 0xd6, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x12, 0xc9, 0x4b, 0xcd, 0xd7,
0x4b, 0x2b, 0xd6, 0x2b, 0x33, 0xd2, 0x43, 0x28, 0x53, 0xb2, 0xe5, 0x62, 0x77, 0x49, 0x4d, 0xce,
0xcc, 0x4d, 0xcc, 0x11, 0x12, 0xe1, 0x62, 0x2d, 0x4b, 0xcc, 0x29, 0x4d, 0x95, 0x60, 0x54, 0x60,
0xd4, 0x60, 0x0e, 0x82, 0x70, 0x84, 0x64, 0xb8, 0x38, 0x0b, 0x8a, 0x52, 0x93, 0x33, 0x8b, 0x33,
0xf3, 0xf3, 0x24, 0x98, 0x14, 0x18, 0x35, 0x78, 0x83, 0x10, 0x02, 0x4e, 0xd9, 0x27, 0x1e, 0xc9,
0x31, 0x5e, 0x78, 0x24, 0xc7, 0xf8, 0xe0, 0x91, 0x1c, 0xe3, 0x8c, 0xc7, 0x72, 0x0c, 0x51, 0xf6,
0xe9, 0x99, 0x25, 0x19, 0xa5, 0x49, 0x7a, 0xc9, 0xf9, 0xb9, 0xfa, 0x79, 0xc5, 0x05, 0xc9, 0xc9,
0xba, 0x29, 0xa9, 0x65, 0xfa, 0x79, 0xa9, 0xf9, 0x69, 0xc5, 0xba, 0x89, 0x05, 0x99, 0xba, 0xe9,
0xf9, 0xfa, 0x98, 0x0e, 0xb5, 0x46, 0xf0, 0x57, 0x31, 0x89, 0xfb, 0xa5, 0xe6, 0xbb, 0x05, 0xeb,
0x39, 0x06, 0x78, 0x82, 0xdc, 0xea, 0x08, 0x97, 0x49, 0x62, 0x03, 0x7b, 0xc4, 0x18, 0x10, 0x00,
0x00, 0xff, 0xff, 0xcd, 0x8e, 0x26, 0xec, 0xea, 0x00, 0x00, 0x00,
}
func (m *Decimal) 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 *Decimal) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *Decimal) 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.Precision != 0 {
i = encodeVarintTypes(dAtA, i, uint64(m.Precision))
i--
dAtA[i] = 0x10
}
if m.Value != 0 {
i = encodeVarintTypes(dAtA, i, uint64(m.Value))
i--
dAtA[i] = 0x8
}
return len(dAtA) - i, nil
}
func encodeVarintTypes(dAtA []byte, offset int, v uint64) int {
offset -= sovTypes(v)
base := offset
for v >= 1<<7 {
dAtA[offset] = uint8(v&0x7f | 0x80)
v >>= 7
offset++
}
dAtA[offset] = uint8(v)
return base
}
func (m *Decimal) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
if m.Value != 0 {
n += 1 + sovTypes(uint64(m.Value))
}
if m.Precision != 0 {
n += 1 + sovTypes(uint64(m.Precision))
}
if m.XXX_unrecognized != nil {
n += len(m.XXX_unrecognized)
}
return n
}
func sovTypes(x uint64) (n int) {
return (math_bits.Len64(x|1) + 6) / 7
}
func sozTypes(x uint64) (n int) {
return sovTypes(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *Decimal) 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 ErrIntOverflowTypes
}
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: Decimal: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: Decimal: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
}
m.Value = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.Value |= int64(b&0x7F) << shift
if b < 0x80 {
break
}
}
case 2:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Precision", wireType)
}
m.Precision = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.Precision |= uint32(b&0x7F) << shift
if b < 0x80 {
break
}
}
default:
iNdEx = preIndex
skippy, err := skipTypes(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthTypes
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthTypes
}
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 skipTypes(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, ErrIntOverflowTypes
}
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, ErrIntOverflowTypes
}
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, ErrIntOverflowTypes
}
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, ErrInvalidLengthTypes
}
iNdEx += length
case 3:
depth++
case 4:
if depth == 0 {
return 0, ErrUnexpectedEndOfGroupTypes
}
depth--
case 5:
iNdEx += 4
default:
return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
}
if iNdEx < 0 {
return 0, ErrInvalidLengthTypes
}
if depth == 0 {
return iNdEx, nil
}
}
return 0, io.ErrUnexpectedEOF
}
var (
ErrInvalidLengthTypes = fmt.Errorf("proto: negative length found during unmarshaling")
ErrIntOverflowTypes = fmt.Errorf("proto: integer overflow")
ErrUnexpectedEndOfGroupTypes = fmt.Errorf("proto: unexpected end of group")
)

33
v2/container/convert.go
View file

@ -116,8 +116,9 @@ func PutRequestBodyToGRPCMessage(r *PutRequestBody) *container.PutRequest_Body {
ContainerToGRPCMessage(r.GetContainer()),
)
m.SetPublicKey(r.GetPublicKey())
m.SetSignature(r.GetSignature())
m.SetSignature(
service.SignatureToGRPCMessage(r.GetSignature()),
)
return m
}
@ -133,8 +134,9 @@ func PutRequestBodyFromGRPCMessage(m *container.PutRequest_Body) *PutRequestBody
ContainerFromGRPCMessage(m.GetContainer()),
)
r.SetPublicKey(m.GetPublicKey())
r.SetSignature(m.GetSignature())
r.SetSignature(
service.SignatureFromGRPCMessage(m.GetSignature()),
)
return r
}
@ -362,7 +364,9 @@ func DeleteRequestBodyToGRPCMessage(r *DeleteRequestBody) *container.DeleteReque
refs.ContainerIDToGRPCMessage(r.GetContainerID()),
)
m.SetSignature(r.GetSignature())
m.SetSignature(
service.SignatureToGRPCMessage(r.GetSignature()),
)
return m
}
@ -378,7 +382,9 @@ func DeleteRequestBodyFromGRPCMessage(m *container.DeleteRequest_Body) *DeleteRe
refs.ContainerIDFromGRPCMessage(m.GetContainerId()),
)
r.SetSignature(m.GetSignature())
r.SetSignature(
service.SignatureFromGRPCMessage(m.GetSignature()),
)
return r
}
@ -608,7 +614,8 @@ func SetExtendedACLRequestBodyToGRPCMessage(r *SetExtendedACLRequestBody) *conta
acl.TableToGRPCMessage(r.GetEACL()),
)
m.SetSignature(r.GetSignature())
m.SetSignature(
service.SignatureToGRPCMessage(r.GetSignature()))
return m
}
@ -624,6 +631,10 @@ func SetExtendedACLRequestBodyFromGRPCMessage(m *container.SetExtendedACLRequest
acl.TableFromGRPCMessage(m.GetEacl()),
)
r.SetSignature(
service.SignatureFromGRPCMessage(m.GetSignature()),
)
return r
}
@ -782,7 +793,9 @@ func GetExtendedACLResponseBodyToGRPCMessage(r *GetExtendedACLResponseBody) *con
acl.TableToGRPCMessage(r.GetEACL()),
)
m.SetSignature(r.GetSignature())
m.SetSignature(
service.SignatureToGRPCMessage(r.GetSignature()),
)
return m
}
@ -798,7 +811,9 @@ func GetExtendedACLResponseBodyFromGRPCMessage(m *container.GetExtendedACLRespon
acl.TableFromGRPCMessage(m.GetEacl()),
)
r.SetSignature(m.GetSignature())
r.SetSignature(
service.SignatureFromGRPCMessage(m.GetSignature()),
)
return r
}

15
v2/container/grpc/service.go
View file

@ -13,15 +13,8 @@ func (m *PutRequest_Body) SetContainer(v *Container) {
}
}
// SetPublicKey sets public key of the container owner.
func (m *PutRequest_Body) SetPublicKey(v []byte) {
if m != nil {
m.PublicKey = v
}
}
// SetSignature sets signature of the container structure.
func (m *PutRequest_Body) SetSignature(v []byte) {
func (m *PutRequest_Body) SetSignature(v *service.Signature) {
if m != nil {
m.Signature = v
}
@ -84,7 +77,7 @@ func (m *DeleteRequest_Body) SetContainerId(v *refs.ContainerID) {
}
// SetSignature sets signature of the container identifier.
func (m *DeleteRequest_Body) SetSignature(v []byte) {
func (m *DeleteRequest_Body) SetSignature(v *service.Signature) {
if m != nil {
m.Signature = v
}
@ -250,7 +243,7 @@ func (m *SetExtendedACLRequest_Body) SetEacl(v *acl.EACLTable) {
}
// SetSignature sets signature of the eACL table.
func (m *SetExtendedACLRequest_Body) SetSignature(v []byte) {
func (m *SetExtendedACLRequest_Body) SetSignature(v *service.Signature) {
if m != nil {
m.Signature = v
}
@ -334,7 +327,7 @@ func (m *GetExtendedACLResponse_Body) SetEacl(v *acl.EACLTable) {
}
// SetSignature sets signature of the eACL table.
func (m *GetExtendedACLResponse_Body) SetSignature(v []byte) {
func (m *GetExtendedACLResponse_Body) SetSignature(v *service.Signature) {
if m != nil {
m.Signature = v
}

327
v2/container/grpc/service.pb.go
View file

@ -103,14 +103,11 @@ func (m *PutRequest) GetVerifyHeader() *grpc.RequestVerificationHeader {
type PutRequest_Body struct {
// Container to create in NeoFS.
Container *Container `protobuf:"bytes,1,opt,name=container,proto3" json:"container,omitempty"`
// Public Key of container owner. It can be public key of the owner
// or it can be public key that bound in neofs.id smart-contract.
PublicKey []byte `protobuf:"bytes,2,opt,name=public_key,json=publicKey,proto3" json:"public_key,omitempty"`
// Signature of stable-marshalled container according to RFC-6979.
Signature []byte `protobuf:"bytes,3,opt,name=signature,proto3" json:"signature,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
//Signature of stable-marshalled container according to RFC-6979.
Signature *grpc.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{} }
@ -153,14 +150,7 @@ func (m *PutRequest_Body) GetContainer() *Container {
return nil
}
func (m *PutRequest_Body) GetPublicKey() []byte {
if m != nil {
return m.PublicKey
}
return nil
}
func (m *PutRequest_Body) GetSignature() []byte {
func (m *PutRequest_Body) GetSignature() *grpc.Signature {
if m != nil {
return m.Signature
}
@ -362,10 +352,10 @@ type DeleteRequest_Body struct {
// from NeoFS.
ContainerId *grpc1.ContainerID `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"`
// Signature of container id according to RFC-6979.
Signature []byte `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
Signature *grpc.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{} }
@ -408,7 +398,7 @@ func (m *DeleteRequest_Body) GetContainerId() *grpc1.ContainerID {
return nil
}
func (m *DeleteRequest_Body) GetSignature() []byte {
func (m *DeleteRequest_Body) GetSignature() *grpc.Signature {
if m != nil {
return m.Signature
}
@ -1077,10 +1067,10 @@ type SetExtendedACLRequest_Body struct {
// Extended ACL to set for the container.
Eacl *grpc2.EACLTable `protobuf:"bytes,1,opt,name=eacl,proto3" json:"eacl,omitempty"`
// Signature of stable-marshalled Extended ACL according to RFC-6979.
Signature []byte `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
Signature *grpc.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{} }
@ -1123,7 +1113,7 @@ func (m *SetExtendedACLRequest_Body) GetEacl() *grpc2.EACLTable {
return nil
}
func (m *SetExtendedACLRequest_Body) GetSignature() []byte {
func (m *SetExtendedACLRequest_Body) GetSignature() *grpc.Signature {
if m != nil {
return m.Signature
}
@ -1434,10 +1424,10 @@ type GetExtendedACLResponse_Body struct {
// Extended ACL that has been requested if it was set up.
Eacl *grpc2.EACLTable `protobuf:"bytes,1,opt,name=eacl,proto3" json:"eacl,omitempty"`
// Signature of stable-marshalled Extended ACL according to RFC-6979.
Signature []byte `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
Signature *grpc.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{} }
@ -1480,7 +1470,7 @@ func (m *GetExtendedACLResponse_Body) GetEacl() *grpc2.EACLTable {
return nil
}
func (m *GetExtendedACLResponse_Body) GetSignature() []byte {
func (m *GetExtendedACLResponse_Body) GetSignature() *grpc.Signature {
if m != nil {
return m.Signature
}
@ -1517,60 +1507,58 @@ func init() {
func init() { proto.RegisterFile("v2/container/grpc/service.proto", fileDescriptor_364186d99410ec35) }
var fileDescriptor_364186d99410ec35 = []byte{
// 840 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x98, 0x41, 0x6f, 0xd3, 0x4a,
0x10, 0xc7, 0x9f, 0xdd, 0xa8, 0xef, 0x75, 0x92, 0x56, 0x4f, 0x7e, 0x6a, 0x1b, 0xf9, 0xb5, 0x69,
0x30, 0x14, 0x2a, 0x68, 0x6c, 0x64, 0x2e, 0xd0, 0x16, 0x44, 0x9b, 0xb4, 0x6e, 0xd4, 0x02, 0xad,
0x8b, 0x38, 0x70, 0xa9, 0x1c, 0x7b, 0x93, 0x5a, 0xa4, 0x76, 0xb0, 0x1d, 0x97, 0x1c, 0xe1, 0x53,
0x70, 0x40, 0x9c, 0x51, 0xc5, 0x81, 0x4f, 0xc0, 0x19, 0x21, 0x84, 0xf8, 0x08, 0xa8, 0xf0, 0x09,
0xf8, 0x04, 0xc8, 0x5e, 0xc7, 0xb1, 0x13, 0xa7, 0x4e, 0xaa, 0x70, 0xf0, 0xcd, 0xf6, 0xce, 0xcc,
0xce, 0xfc, 0xf4, 0xdf, 0x9d, 0x5d, 0xc3, 0x82, 0xcd, 0x73, 0xb2, 0xae, 0x59, 0x92, 0xaa, 0x21,
0x83, 0xab, 0x19, 0x0d, 0x99, 0x33, 0x91, 0x61, 0xab, 0x32, 0x62, 0x1b, 0x86, 0x6e, 0xe9, 0xd4,
0x7f, 0x1a, 0xd2, 0xd9, 0xaa, 0xc9, 0xda, 0x3c, 0xeb, 0xdb, 0xd1, 0xb3, 0x36, 0xcf, 0x49, 0x72,
0x1d, 0xdb, 0x5b, 0xad, 0x06, 0x32, 0xb1, 0x35, 0x3d, 0xdf, 0x1b, 0x2e, 0x38, 0x9c, 0xb5, 0x79,
0xce, 0x40, 0x55, 0xb3, 0x77, 0x84, 0xb6, 0xf9, 0xf6, 0xc4, 0x78, 0xf0, 0x18, 0x59, 0x92, 0x37,
0x36, 0xd7, 0x3d, 0x66, 0x23, 0x43, 0xad, 0xb6, 0xf0, 0x28, 0xf3, 0x93, 0x04, 0xd8, 0x6b, 0x5a,
0x22, 0x7a, 0xde, 0x44, 0xa6, 0x45, 0xdd, 0x86, 0x54, 0x45, 0x57, 0x5a, 0x59, 0x22, 0x4f, 0x2c,
0xa5, 0xf9, 0x2b, 0x6c, 0x44, 0xfa, 0x6c, 0xc7, 0x9c, 0xdd, 0xd0, 0x95, 0x96, 0xe8, 0x7a, 0x50,
0x9b, 0x90, 0x76, 0x26, 0x3d, 0x3c, 0x42, 0x92, 0x82, 0x8c, 0x2c, 0xd9, 0x13, 0xa0, 0x0d, 0xc6,
0xf3, 0x7d, 0x80, 0x2c, 0x69, 0xdb, 0xb5, 0x15, 0xe1, 0xd8, 0x7f, 0xa6, 0xf6, 0x61, 0x12, 0xe7,
0xd7, 0x0e, 0x34, 0xe6, 0x06, 0x5a, 0xee, 0x1f, 0xe8, 0x89, 0x63, 0xae, 0xca, 0x92, 0xa5, 0xea,
0x9a, 0x17, 0x30, 0x83, 0x43, 0xe0, 0x37, 0xfa, 0x25, 0x01, 0x29, 0x27, 0x51, 0x6a, 0x0d, 0x26,
0xfc, 0x2a, 0xbc, 0x0a, 0x73, 0x91, 0x15, 0x16, 0xdb, 0x4f, 0x62, 0xc7, 0x81, 0x9a, 0x07, 0x68,
0x34, 0x2b, 0x75, 0x55, 0x3e, 0x7c, 0x86, 0x5a, 0x6e, 0x7d, 0x19, 0x71, 0x02, 0x7f, 0xd9, 0x41,
0x2d, 0x6a, 0x0e, 0x26, 0x4c, 0xb5, 0xa6, 0x49, 0x56, 0xd3, 0x40, 0x6e, 0xd2, 0x19, 0xb1, 0xf3,
0x81, 0x79, 0x4f, 0x42, 0xda, 0xe5, 0x66, 0x36, 0x74, 0xcd, 0x44, 0xd4, 0x9d, 0x10, 0xe7, 0xc5,
0xfe, 0x9c, 0xb1, 0x7d, 0x10, 0xf4, 0x56, 0x14, 0xe8, 0xc5, 0x48, 0x3e, 0xd8, 0xb9, 0x0f, 0x69,
0x31, 0x9a, 0x74, 0xe1, 0x9c, 0x48, 0xb1, 0xa8, 0xb7, 0x3c, 0xd2, 0xf7, 0x20, 0xe3, 0xd7, 0x71,
0xa8, 0x2a, 0x5e, 0x99, 0xff, 0x07, 0x42, 0x3b, 0x3a, 0xee, 0x70, 0x2e, 0x97, 0xc4, 0xb4, 0xef,
0x50, 0x56, 0x98, 0x2f, 0x24, 0x4c, 0x96, 0x50, 0x1d, 0x59, 0xa8, 0x2d, 0xcc, 0xd5, 0x10, 0xb0,
0x6b, 0x91, 0xc0, 0x42, 0x1e, 0xc9, 0xd0, 0xa6, 0x32, 0x1a, 0x60, 0x61, 0xf5, 0x91, 0xdd, 0xea,
0xfb, 0x45, 0xc0, 0x54, 0x1b, 0x8e, 0x27, 0xc0, 0xb5, 0x10, 0xcf, 0xa5, 0x73, 0x79, 0x26, 0x4b,
0x83, 0xe3, 0x18, 0x29, 0xf3, 0x8e, 0x04, 0x10, 0xd0, 0x50, 0x3b, 0x5b, 0xc7, 0x3c, 0x19, 0xea,
0x19, 0xd5, 0x72, 0x3b, 0x25, 0x21, 0xed, 0xd6, 0x3e, 0xc4, 0xee, 0x14, 0xb0, 0x4f, 0x8a, 0x32,
0x4a, 0xa3, 0xe8, 0x03, 0xcc, 0x5b, 0x12, 0xd2, 0xbb, 0xaa, 0xe9, 0x0b, 0x6b, 0x10, 0x58, 0x01,
0xfb, 0x64, 0x28, 0x6b, 0xc5, 0x43, 0xc5, 0xc3, 0x3f, 0xfa, 0x49, 0x48, 0x55, 0xb3, 0xdd, 0xaa,
0x7a, 0x74, 0x82, 0x15, 0xf5, 0xb7, 0x6b, 0x58, 0x56, 0x98, 0x0f, 0x24, 0x64, 0x70, 0xc1, 0x9e,
0x9c, 0x56, 0x42, 0x84, 0xae, 0x9e, 0x43, 0x28, 0x59, 0x7a, 0xda, 0xf6, 0x20, 0xdd, 0x87, 0xc9,
0xe0, 0xf2, 0x33, 0xb3, 0x44, 0x7e, 0x2c, 0x6e, 0xfd, 0x65, 0x02, 0xeb, 0xcf, 0x64, 0x3e, 0x93,
0x30, 0x7d, 0x80, 0xac, 0xcd, 0x17, 0x16, 0xd2, 0x14, 0xa4, 0xac, 0x17, 0x77, 0xdb, 0xea, 0x2a,
0x86, 0xd8, 0x71, 0x91, 0xec, 0x22, 0x3d, 0x93, 0xa1, 0x33, 0xd1, 0x43, 0xb8, 0x0c, 0x29, 0x24,
0xc9, 0x75, 0xaf, 0xcc, 0x6c, 0x20, 0xa2, 0x24, 0xd7, 0xd9, 0xcd, 0xf5, 0xe2, 0xee, 0x63, 0xa9,
0x52, 0x47, 0xa2, 0x6b, 0x15, 0xd3, 0xed, 0x5e, 0x91, 0x30, 0xd3, 0x8d, 0xc4, 0x53, 0x62, 0x29,
0x44, 0xf3, 0xe6, 0x40, 0x34, 0x93, 0xd9, 0xfd, 0x3e, 0x92, 0x30, 0x2d, 0x5c, 0x58, 0x51, 0x42,
0x72, 0x15, 0x35, 0xaa, 0x9e, 0xf8, 0x95, 0x84, 0x19, 0xe1, 0xe2, 0x2a, 0x12, 0x12, 0xad, 0xa2,
0x3f, 0xb0, 0x2c, 0xf9, 0x37, 0x29, 0xf8, 0xd7, 0xa7, 0x7d, 0x80, 0x33, 0xa2, 0xb6, 0x61, 0x6c,
0xaf, 0x69, 0x51, 0x0b, 0x31, 0x17, 0x4d, 0x3a, 0x1f, 0x77, 0x43, 0xa2, 0xf6, 0x61, 0x1c, 0x9f,
0x57, 0x29, 0x26, 0xfe, 0x72, 0x40, 0x5f, 0x1e, 0xe0, 0xc0, 0xeb, 0x24, 0x27, 0xa0, 0x7e, 0xc9,
0x75, 0xce, 0x8a, 0x7d, 0x92, 0x0b, 0x1e, 0xa8, 0x76, 0x20, 0xe5, 0x34, 0x38, 0x2a, 0x1f, 0x77,
0x3a, 0xa0, 0x2f, 0xc5, 0x76, 0x47, 0x4a, 0x85, 0xa9, 0xf0, 0x1e, 0x45, 0x5d, 0x1f, 0xbc, 0x2d,
0xd0, 0x37, 0x86, 0xd8, 0xf4, 0x9c, 0xa9, 0x84, 0x41, 0xa6, 0x12, 0x86, 0x98, 0x2a, 0x7a, 0x65,
0x6c, 0x1c, 0x7d, 0x3a, 0xcb, 0x11, 0xdf, 0xce, 0x72, 0xc4, 0xf7, 0xb3, 0x1c, 0xf1, 0xfa, 0x47,
0xee, 0xaf, 0xa7, 0x77, 0x6b, 0xaa, 0x75, 0xd4, 0xac, 0xb0, 0xb2, 0x7e, 0xcc, 0x69, 0x66, 0x43,
0x96, 0x0b, 0x0a, 0xb2, 0x39, 0x0d, 0xe9, 0x55, 0xb3, 0x20, 0x35, 0xd4, 0x42, 0x4d, 0xe7, 0x7a,
0xfe, 0x97, 0xac, 0xfa, 0xaf, 0xa7, 0xe4, 0xcc, 0x43, 0xa4, 0x6f, 0x1d, 0xb0, 0xeb, 0x7b, 0x65,
0x27, 0x01, 0x5f, 0x7a, 0x95, 0x71, 0xf7, 0xcf, 0xc7, 0xad, 0xdf, 0x01, 0x00, 0x00, 0xff, 0xff,
0x27, 0x5d, 0xa8, 0x45, 0xbd, 0x11, 0x00, 0x00,
// 813 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x98, 0xcf, 0x6e, 0xd3, 0x5a,
0x10, 0xc6, 0xaf, 0xdd, 0xa8, 0xf7, 0x76, 0x92, 0x56, 0x57, 0xbe, 0x6a, 0x1b, 0xa5, 0x97, 0x34,
0x18, 0x0a, 0x15, 0x34, 0x36, 0x32, 0x1b, 0x68, 0x0b, 0xa2, 0x4d, 0x5a, 0x37, 0xa2, 0x40, 0xeb,
0x20, 0x16, 0x6c, 0x2a, 0xc7, 0x9e, 0xa4, 0x96, 0x52, 0x3b, 0xd8, 0x8e, 0x4b, 0x76, 0xa8, 0x4f,
0xc1, 0x02, 0xb1, 0x46, 0x15, 0x0b, 0x9e, 0x80, 0x35, 0x4b, 0x1e, 0x01, 0xb5, 0x1b, 0x24, 0x58,
0xf1, 0x04, 0x28, 0xfe, 0x17, 0xbb, 0x71, 0x9a, 0xa4, 0x8d, 0x90, 0xbc, 0x4b, 0xe4, 0x6f, 0xe6,
0xcc, 0xfc, 0xf2, 0x9d, 0x33, 0xc7, 0x81, 0x79, 0x8b, 0x63, 0x25, 0x4d, 0x35, 0x45, 0x45, 0x45,
0x9d, 0xad, 0xe9, 0x0d, 0x89, 0x35, 0x50, 0xb7, 0x14, 0x09, 0x99, 0x86, 0xae, 0x99, 0x1a, 0xf5,
0x9f, 0x8a, 0x1a, 0x53, 0x35, 0x18, 0x8b, 0x63, 0x7c, 0x5d, 0x66, 0xd6, 0xe2, 0x58, 0x51, 0xaa,
0x3b, 0x7a, 0xb3, 0xd5, 0x40, 0xc3, 0x51, 0x67, 0xae, 0x74, 0xa7, 0x0b, 0x3e, 0x4e, 0x5b, 0x1c,
0xab, 0x63, 0xd5, 0xe8, 0x7e, 0x32, 0x67, 0x71, 0xde, 0xc2, 0x5d, 0x0f, 0xe9, 0x53, 0x12, 0x60,
0xa7, 0x69, 0x0a, 0xf8, 0xaa, 0x89, 0x86, 0x49, 0xdd, 0x83, 0x44, 0x45, 0x93, 0x5b, 0x69, 0x22,
0x47, 0x2c, 0x26, 0xb9, 0xeb, 0x4c, 0x44, 0x85, 0x4c, 0x47, 0xce, 0xac, 0x6b, 0x72, 0x4b, 0xb0,
0x23, 0xa8, 0x0d, 0x48, 0x1e, 0xa0, 0x29, 0xee, 0xed, 0xa3, 0x28, 0xa3, 0x9e, 0x26, 0xbb, 0x12,
0x78, 0xbd, 0xbb, 0xb1, 0x4f, 0xd0, 0x14, 0xb7, 0x6c, 0xad, 0x00, 0x07, 0xfe, 0x67, 0x6a, 0x17,
0x26, 0x2d, 0xd4, 0x95, 0x6a, 0xcb, 0x4b, 0x34, 0x66, 0x27, 0x5a, 0xea, 0x9d, 0xe8, 0x45, 0x5b,
0xae, 0x48, 0xa2, 0xa9, 0x68, 0xaa, 0x9b, 0x30, 0xe5, 0xa4, 0x70, 0xbe, 0x65, 0xde, 0x10, 0x90,
0x68, 0x17, 0x4a, 0xad, 0xc2, 0x84, 0xdf, 0x85, 0xdb, 0x61, 0x36, 0xb2, 0xc3, 0x82, 0xf7, 0x49,
0xe8, 0x04, 0x50, 0xcb, 0x30, 0x61, 0x28, 0x35, 0x55, 0x34, 0x9b, 0x3a, 0xba, 0xed, 0xfd, 0x1f,
0x51, 0x55, 0xd9, 0xd3, 0x08, 0x1d, 0x39, 0xfd, 0x91, 0x84, 0xa4, 0x8d, 0xcd, 0x68, 0x68, 0xaa,
0x81, 0xd4, 0xfd, 0x10, 0xe6, 0x85, 0xde, 0x98, 0x1d, 0x7d, 0x90, 0xf3, 0x66, 0x14, 0xe7, 0x85,
0x48, 0x3c, 0x4e, 0x70, 0x0f, 0xd0, 0x42, 0x34, 0xe8, 0xfc, 0x39, 0x99, 0xfa, 0x92, 0xde, 0x74,
0x41, 0x3f, 0x84, 0x94, 0xdf, 0xc7, 0x9e, 0x22, 0xbb, 0x6d, 0xce, 0x05, 0x52, 0xb7, 0x9d, 0xda,
0xc1, 0x5c, 0x2a, 0x0a, 0x49, 0x3f, 0xa0, 0x24, 0xd3, 0x3f, 0x48, 0x98, 0x2c, 0x62, 0x1d, 0x4d,
0xf4, 0x7c, 0xb9, 0x12, 0x02, 0x76, 0x33, 0x12, 0x58, 0x28, 0x22, 0x1e, 0xd6, 0x3c, 0x22, 0x46,
0x43, 0xec, 0x52, 0xe6, 0xfc, 0x45, 0xc0, 0x94, 0xc7, 0xce, 0xf5, 0xe7, 0x6a, 0x08, 0xf7, 0xe2,
0xb9, 0xb8, 0xe3, 0x65, 0xd1, 0x71, 0x07, 0x38, 0xfd, 0x81, 0x04, 0xe0, 0x71, 0xa8, 0x73, 0xaf,
0x23, 0x8f, 0x87, 0xb9, 0x46, 0xb5, 0x1b, 0x8f, 0x49, 0x48, 0xda, 0xbd, 0x0f, 0x71, 0x78, 0x05,
0xf4, 0x71, 0x71, 0x46, 0x71, 0x14, 0x53, 0x82, 0x7e, 0x4f, 0x42, 0x72, 0x5b, 0x31, 0x7c, 0x63,
0x0d, 0x02, 0x2b, 0xa0, 0x8f, 0x87, 0xb3, 0x96, 0x5d, 0x54, 0x1c, 0xfc, 0xa3, 0x1d, 0x86, 0x5c,
0x35, 0x7b, 0xd6, 0x55, 0xcf, 0x0e, 0x1d, 0x47, 0xfd, 0x6d, 0x0b, 0x4b, 0x32, 0xfd, 0x89, 0x84,
0x94, 0xd3, 0xb0, 0x6b, 0xa7, 0xe5, 0x10, 0xa1, 0x1b, 0xe7, 0x10, 0x8a, 0x97, 0x9f, 0xb6, 0x5c,
0x48, 0x8f, 0x60, 0x32, 0xb8, 0xfd, 0x8c, 0x34, 0x91, 0x1b, 0xeb, 0xb7, 0xff, 0x52, 0x81, 0xfd,
0x67, 0xd0, 0xdf, 0x49, 0x98, 0x2e, 0xa3, 0xb9, 0xf1, 0xda, 0x44, 0x55, 0x46, 0x79, 0xad, 0xb0,
0xed, 0xb9, 0xab, 0x10, 0x62, 0xc7, 0x46, 0xb2, 0x8b, 0x8c, 0x8c, 0x87, 0xcf, 0x1a, 0x2e, 0xc2,
0x25, 0x48, 0xa0, 0x28, 0xd5, 0xdd, 0x36, 0xd3, 0x81, 0x8c, 0xa2, 0x54, 0x67, 0x36, 0xd6, 0x0a,
0xdb, 0xcf, 0xc5, 0x4a, 0x1d, 0x05, 0x5b, 0x75, 0xa9, 0x59, 0x78, 0x44, 0xc2, 0xcc, 0x59, 0x60,
0xae, 0x4f, 0x8b, 0x21, 0xd6, 0x77, 0x06, 0x62, 0x1d, 0xcf, 0xd9, 0xf8, 0x99, 0x84, 0x69, 0xfe,
0xc2, 0x7e, 0xe3, 0xe3, 0xeb, 0xb7, 0x51, 0x4d, 0xcc, 0x9f, 0x24, 0xcc, 0xf0, 0x17, 0x77, 0x11,
0x1f, 0x6b, 0x17, 0xfd, 0xf1, 0x4d, 0xcb, 0xbd, 0x4b, 0xc0, 0xbf, 0xfe, 0x6f, 0x51, 0x76, 0x94,
0xd4, 0x16, 0x8c, 0xed, 0x34, 0x4d, 0x6a, 0xbe, 0xcf, 0x2b, 0x6c, 0x26, 0xd7, 0xef, 0xe5, 0x8b,
0xda, 0x85, 0x71, 0xe7, 0xae, 0x4b, 0xd1, 0xfd, 0xdf, 0x3b, 0x32, 0xd7, 0x06, 0xb8, 0x2c, 0xb7,
0x8b, 0xe3, 0xb1, 0x57, 0x71, 0x9d, 0x7b, 0x66, 0x8f, 0xe2, 0x82, 0x97, 0xb1, 0xc7, 0x90, 0x68,
0x0f, 0x47, 0x2a, 0xd7, 0xef, 0x66, 0x91, 0xb9, 0xda, 0x77, 0xb2, 0x52, 0x0a, 0x4c, 0x85, 0x4f,
0x30, 0xea, 0xd6, 0xe0, 0x23, 0x25, 0x73, 0x7b, 0x88, 0x23, 0xb1, 0xbd, 0x14, 0x3f, 0xc8, 0x52,
0xfc, 0x10, 0x4b, 0x45, 0xef, 0x9b, 0xf5, 0xfd, 0x2f, 0x27, 0x59, 0xe2, 0xeb, 0x49, 0x96, 0xf8,
0x76, 0x92, 0x25, 0xde, 0x9e, 0x66, 0xff, 0x7a, 0xf9, 0xa0, 0xa6, 0x98, 0xfb, 0xcd, 0x0a, 0x23,
0x69, 0x07, 0xac, 0x6a, 0x34, 0x24, 0x29, 0x2f, 0xa3, 0xc5, 0xaa, 0xa8, 0x55, 0x8d, 0xbc, 0xd8,
0x50, 0xf2, 0x35, 0x8d, 0xed, 0xfa, 0xb3, 0x65, 0xc5, 0xff, 0x7a, 0x4c, 0xce, 0x3c, 0x45, 0x6d,
0xb3, 0xcc, 0xac, 0xed, 0x94, 0xda, 0x05, 0xf8, 0xd6, 0xab, 0x8c, 0xdb, 0xff, 0xa9, 0xdc, 0xfd,
0x1d, 0x00, 0x00, 0xff, 0xff, 0x27, 0xf9, 0x1d, 0xbb, 0xfa, 0x11, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
@ -1952,17 +1940,15 @@ func (m *PutRequest_Body) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i -= len(m.XXX_unrecognized)
copy(dAtA[i:], m.XXX_unrecognized)
}
if len(m.Signature) > 0 {
i -= len(m.Signature)
copy(dAtA[i:], m.Signature)
i = encodeVarintService(dAtA, i, uint64(len(m.Signature)))
i--
dAtA[i] = 0x1a
}
if len(m.PublicKey) > 0 {
i -= len(m.PublicKey)
copy(dAtA[i:], m.PublicKey)
i = encodeVarintService(dAtA, i, uint64(len(m.PublicKey)))
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
}
@ -2170,10 +2156,15 @@ func (m *DeleteRequest_Body) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i -= len(m.XXX_unrecognized)
copy(dAtA[i:], m.XXX_unrecognized)
}
if len(m.Signature) > 0 {
i -= len(m.Signature)
copy(dAtA[i:], m.Signature)
i = encodeVarintService(dAtA, i, uint64(len(m.Signature)))
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
}
@ -2779,10 +2770,15 @@ func (m *SetExtendedACLRequest_Body) MarshalToSizedBuffer(dAtA []byte) (int, err
i -= len(m.XXX_unrecognized)
copy(dAtA[i:], m.XXX_unrecognized)
}
if len(m.Signature) > 0 {
i -= len(m.Signature)
copy(dAtA[i:], m.Signature)
i = encodeVarintService(dAtA, i, uint64(len(m.Signature)))
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
}
@ -3080,10 +3076,15 @@ func (m *GetExtendedACLResponse_Body) MarshalToSizedBuffer(dAtA []byte) (int, er
i -= len(m.XXX_unrecognized)
copy(dAtA[i:], m.XXX_unrecognized)
}
if len(m.Signature) > 0 {
i -= len(m.Signature)
copy(dAtA[i:], m.Signature)
i = encodeVarintService(dAtA, i, uint64(len(m.Signature)))
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
}
@ -3147,12 +3148,8 @@ func (m *PutRequest_Body) Size() (n int) {
l = m.Container.Size()
n += 1 + l + sovService(uint64(l))
}
l = len(m.PublicKey)
if l > 0 {
n += 1 + l + sovService(uint64(l))
}
l = len(m.Signature)
if l > 0 {
if m.Signature != nil {
l = m.Signature.Size()
n += 1 + l + sovService(uint64(l))
}
if m.XXX_unrecognized != nil {
@ -3235,8 +3232,8 @@ func (m *DeleteRequest_Body) Size() (n int) {
l = m.ContainerId.Size()
n += 1 + l + sovService(uint64(l))
}
l = len(m.Signature)
if l > 0 {
if m.Signature != nil {
l = m.Signature.Size()
n += 1 + l + sovService(uint64(l))
}
if m.XXX_unrecognized != nil {
@ -3477,8 +3474,8 @@ func (m *SetExtendedACLRequest_Body) Size() (n int) {
l = m.Eacl.Size()
n += 1 + l + sovService(uint64(l))
}
l = len(m.Signature)
if l > 0 {
if m.Signature != nil {
l = m.Signature.Size()
n += 1 + l + sovService(uint64(l))
}
if m.XXX_unrecognized != nil {
@ -3597,8 +3594,8 @@ func (m *GetExtendedACLResponse_Body) Size() (n int) {
l = m.Eacl.Size()
n += 1 + l + sovService(uint64(l))
}
l = len(m.Signature)
if l > 0 {
if m.Signature != nil {
l = m.Signature.Size()
n += 1 + l + sovService(uint64(l))
}
if m.XXX_unrecognized != nil {
@ -3841,44 +3838,10 @@ func (m *PutRequest_Body) Unmarshal(dAtA []byte) error {
}
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field PublicKey", wireType)
}
var byteLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowService
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
byteLen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if byteLen < 0 {
return ErrInvalidLengthService
}
postIndex := iNdEx + byteLen
if postIndex < 0 {
return ErrInvalidLengthService
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.PublicKey = append(m.PublicKey[:0], dAtA[iNdEx:postIndex]...)
if m.PublicKey == nil {
m.PublicKey = []byte{}
}
iNdEx = postIndex
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType)
}
var byteLen int
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowService
@ -3888,24 +3851,26 @@ func (m *PutRequest_Body) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
byteLen |= int(b&0x7F) << shift
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if byteLen < 0 {
if msglen < 0 {
return ErrInvalidLengthService
}
postIndex := iNdEx + byteLen
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthService
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Signature = append(m.Signature[:0], dAtA[iNdEx:postIndex]...)
if m.Signature == nil {
m.Signature = []byte{}
m.Signature = &grpc.Signature{}
}
if err := m.Signature.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
@ -4416,7 +4381,7 @@ func (m *DeleteRequest_Body) Unmarshal(dAtA []byte) error {
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType)
}
var byteLen int
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowService
@ -4426,24 +4391,26 @@ func (m *DeleteRequest_Body) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
byteLen |= int(b&0x7F) << shift
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if byteLen < 0 {
if msglen < 0 {
return ErrInvalidLengthService
}
postIndex := iNdEx + byteLen
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthService
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Signature = append(m.Signature[:0], dAtA[iNdEx:postIndex]...)
if m.Signature == nil {
m.Signature = []byte{}
m.Signature = &grpc.Signature{}
}
if err := m.Signature.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
@ -5924,7 +5891,7 @@ func (m *SetExtendedACLRequest_Body) Unmarshal(dAtA []byte) error {
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType)
}
var byteLen int
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowService
@ -5934,24 +5901,26 @@ func (m *SetExtendedACLRequest_Body) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
byteLen |= int(b&0x7F) << shift
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if byteLen < 0 {
if msglen < 0 {
return ErrInvalidLengthService
}
postIndex := iNdEx + byteLen
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthService
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Signature = append(m.Signature[:0], dAtA[iNdEx:postIndex]...)
if m.Signature == nil {
m.Signature = []byte{}
m.Signature = &grpc.Signature{}
}
if err := m.Signature.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
@ -6678,7 +6647,7 @@ func (m *GetExtendedACLResponse_Body) Unmarshal(dAtA []byte) error {
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType)
}
var byteLen int
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowService
@ -6688,24 +6657,26 @@ func (m *GetExtendedACLResponse_Body) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
byteLen |= int(b&0x7F) << shift
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if byteLen < 0 {
if msglen < 0 {
return ErrInvalidLengthService
}
postIndex := iNdEx + byteLen
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthService
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Signature = append(m.Signature[:0], dAtA[iNdEx:postIndex]...)
if m.Signature == nil {
m.Signature = []byte{}
m.Signature = &grpc.Signature{}
}
if err := m.Signature.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:

50
v2/container/grpc/types.pb.go
View file

@ -190,32 +190,32 @@ func init() {
func init() { proto.RegisterFile("v2/container/grpc/types.proto", fileDescriptor_3bfd95a81c72c35c) }
var fileDescriptor_3bfd95a81c72c35c = []byte{
// 400 bytes of a gzipped FileDescriptorProto
// 398 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x52, 0xcd, 0xaa, 0x13, 0x31,
0x14, 0x76, 0x5a, 0xef, 0xcf, 0xe4, 0x2a, 0x5e, 0xa2, 0xe8, 0x30, 0x62, 0xa9, 0xae, 0x66, 0xd3,
0x04, 0xe6, 0xba, 0x13, 0x17, 0x55, 0x11, 0x0b, 0xa2, 0x25, 0x82, 0x0b, 0x37, 0x25, 0x4d, 0x4f,
0xdb, 0xe0, 0x34, 0x09, 0x49, 0x1a, 0xe9, 0x9b, 0xf8, 0x0c, 0x3e, 0x89, 0x4b, 0x1f, 0x41, 0xea,
0x33, 0xb8, 0x97, 0xc9, 0x38, 0x63, 0xa5, 0x77, 0x97, 0x73, 0xbe, 0xef, 0x3b, 0xf9, 0xce, 0x97,
0xa0, 0x47, 0xa1, 0xa4, 0x42, 0x2b, 0xcf, 0xa5, 0x02, 0x4b, 0x57, 0xd6, 0x08, 0xea, 0x77, 0x06,
0x1c, 0x31, 0x56, 0x7b, 0x8d, 0xef, 0x2a, 0xd0, 0x64, 0xe9, 0x48, 0x28, 0x49, 0xc7, 0xca, 0xf3,
0x50, 0x52, 0x05, 0x7e, 0xc3, 0xcd, 0x91, 0x20, 0xcf, 0x42, 0x49, 0x2d, 0x2c, 0xdd, 0x31, 0x52,
0xab, 0x1c, 0xd8, 0x20, 0x05, 0x34, 0xe0, 0x06, 0x3c, 0x6f, 0xb0, 0x27, 0xbf, 0x7b, 0x28, 0x7d,
0xd9, 0xce, 0xc7, 0x4f, 0xd1, 0x59, 0x00, 0xeb, 0xa4, 0x56, 0x59, 0x32, 0x4c, 0x8a, 0x8b, 0x32,
0x27, 0xff, 0x6c, 0xfc, 0x1d, 0x41, 0x3e, 0x36, 0x0c, 0xd6, 0x52, 0x71, 0x89, 0xce, 0xf5, 0x17,
0x05, 0x76, 0x26, 0x17, 0x59, 0x2f, 0xca, 0x1e, 0x1c, 0xc8, 0x6a, 0x4f, 0xe4, 0x7d, 0x8d, 0x4f,
0x5e, 0xb1, 0xb3, 0x48, 0x9c, 0x2c, 0xf0, 0x3d, 0x74, 0xa2, 0xb4, 0x12, 0x90, 0xf5, 0x87, 0x49,
0x71, 0x8b, 0x35, 0x05, 0x7e, 0x88, 0xd2, 0x39, 0x77, 0x52, 0xcc, 0xb8, 0xa8, 0xb2, 0x9b, 0xc3,
0xa4, 0xb8, 0xcd, 0xce, 0x63, 0x63, 0x2c, 0x2a, 0xfc, 0x06, 0x21, 0xee, 0xbd, 0x95, 0xf3, 0xad,
0x07, 0x97, 0x9d, 0x0c, 0xfb, 0xc5, 0x45, 0x59, 0x90, 0x6b, 0x62, 0x22, 0xdd, 0x42, 0x64, 0xdc,
0x0a, 0xd8, 0x81, 0x16, 0xbf, 0x45, 0x97, 0xa6, 0xe2, 0x02, 0x36, 0xa0, 0xfc, 0xcc, 0xe8, 0x4a,
0x8a, 0x5d, 0x76, 0x1a, 0x8d, 0x3f, 0x3e, 0x98, 0xd7, 0x04, 0x4d, 0xa6, 0x2d, 0x73, 0x1a, 0x89,
0xec, 0x8e, 0xf9, 0xbf, 0x91, 0x5f, 0xa1, 0xb4, 0xbb, 0x06, 0x5f, 0xa2, 0xfe, 0x67, 0xd8, 0xc5,
0xf4, 0x52, 0x56, 0x1f, 0xeb, 0x4d, 0x03, 0xaf, 0xb6, 0x10, 0xa3, 0x49, 0x59, 0x53, 0xbc, 0x58,
0x7f, 0xdf, 0x0f, 0x92, 0x1f, 0xfb, 0x41, 0xf2, 0x73, 0x3f, 0x48, 0xbe, 0xfe, 0x1a, 0xdc, 0xf8,
0xf4, 0x7c, 0x25, 0xfd, 0x7a, 0x3b, 0x27, 0x42, 0x6f, 0xa8, 0x72, 0x46, 0x88, 0xd1, 0x02, 0x02,
0x55, 0xa0, 0x97, 0x6e, 0xc4, 0x8d, 0x1c, 0xad, 0x34, 0x3d, 0xfa, 0x31, 0xcf, 0xba, 0xf2, 0x5b,
0xef, 0xfe, 0x3b, 0xd0, 0xaf, 0x3f, 0x90, 0xf1, 0x74, 0x52, 0x9b, 0xef, 0x22, 0x98, 0x9f, 0xc6,
0x87, 0xbe, 0xfa, 0x13, 0x00, 0x00, 0xff, 0xff, 0xbd, 0xc4, 0xfa, 0xf8, 0x70, 0x02, 0x00, 0x00,
0x14, 0x76, 0x5a, 0xef, 0xcf, 0xe4, 0x2a, 0x5e, 0xa2, 0xe8, 0x30, 0x17, 0x4b, 0x75, 0x35, 0x9b,
0x26, 0x90, 0xeb, 0x4e, 0x5c, 0x54, 0x45, 0x2c, 0x88, 0x96, 0x08, 0x2e, 0xdc, 0x94, 0x34, 0x3d,
0x6d, 0x83, 0xd3, 0x24, 0x24, 0x69, 0xa4, 0x6f, 0xe2, 0x33, 0xf8, 0x24, 0x2e, 0x7d, 0x04, 0xa9,
0xcf, 0xe0, 0x5e, 0x26, 0xb5, 0x63, 0xa5, 0xee, 0xe6, 0x9c, 0xef, 0xfb, 0xce, 0xf9, 0xce, 0x37,
0x41, 0x0f, 0x23, 0xa3, 0xd2, 0xe8, 0x20, 0x94, 0x06, 0x47, 0x17, 0xce, 0x4a, 0x1a, 0x36, 0x16,
0x3c, 0xb1, 0xce, 0x04, 0x83, 0xef, 0x6a, 0x30, 0x64, 0xee, 0x49, 0x64, 0xa4, 0x65, 0x95, 0x65,
0x64, 0x54, 0x43, 0x58, 0x09, 0x7b, 0x24, 0x28, 0x8b, 0xc8, 0xa8, 0x83, 0xb9, 0x3f, 0x46, 0xae,
0x22, 0xa3, 0x1e, 0x5c, 0x54, 0x12, 0x8e, 0xc0, 0xc7, 0xbf, 0x3a, 0x28, 0x7f, 0xb1, 0x5f, 0x80,
0x9f, 0xa0, 0xb3, 0x08, 0xce, 0x2b, 0xa3, 0x8b, 0xac, 0x9f, 0x55, 0x17, 0xac, 0x24, 0x7f, 0x7d,
0xfc, 0x99, 0x41, 0x3e, 0xec, 0x18, 0x7c, 0x4f, 0xc5, 0x0c, 0x9d, 0x9b, 0xcf, 0x1a, 0xdc, 0x44,
0xcd, 0x8a, 0x4e, 0x92, 0x3d, 0x38, 0x90, 0x35, 0xa6, 0xc8, 0xbb, 0x06, 0x1f, 0xbd, 0xe4, 0x67,
0x89, 0x38, 0x9a, 0xe1, 0x7b, 0xe8, 0x44, 0x1b, 0x2d, 0xa1, 0xe8, 0xf6, 0xb3, 0xea, 0x16, 0xdf,
0x15, 0xf8, 0x0a, 0xe5, 0x53, 0xe1, 0x95, 0x9c, 0x08, 0x59, 0x17, 0x37, 0xfb, 0x59, 0x75, 0x9b,
0x9f, 0xa7, 0xc6, 0x50, 0xd6, 0xf8, 0x35, 0x42, 0x22, 0x04, 0xa7, 0xa6, 0xeb, 0x00, 0xbe, 0x38,
0xe9, 0x77, 0xab, 0x0b, 0x56, 0x91, 0xff, 0xe4, 0x44, 0xda, 0x83, 0xc8, 0x70, 0x2f, 0xe0, 0x07,
0x5a, 0xfc, 0x06, 0x5d, 0xda, 0x5a, 0x48, 0x58, 0x81, 0x0e, 0x13, 0x6b, 0x6a, 0x25, 0x37, 0xc5,
0x69, 0x32, 0xfe, 0xe8, 0x60, 0xde, 0x2e, 0x69, 0x32, 0xde, 0x33, 0xc7, 0x89, 0xc8, 0xef, 0xd8,
0x7f, 0x1b, 0xe5, 0x35, 0xca, 0xdb, 0x35, 0xf8, 0x12, 0x75, 0x3f, 0xc1, 0x26, 0xa5, 0x97, 0xf3,
0xe6, 0xb3, 0xb9, 0x34, 0x8a, 0x7a, 0x0d, 0x29, 0x9a, 0x9c, 0xef, 0x8a, 0xe7, 0xcb, 0x6f, 0xdb,
0x5e, 0xf6, 0x7d, 0xdb, 0xcb, 0x7e, 0x6c, 0x7b, 0xd9, 0x97, 0x9f, 0xbd, 0x1b, 0x1f, 0x9f, 0x2d,
0x54, 0x58, 0xae, 0xa7, 0x44, 0x9a, 0x15, 0xd5, 0xde, 0x4a, 0x39, 0x98, 0x41, 0xa4, 0x1a, 0xcc,
0xdc, 0x0f, 0x84, 0x55, 0x83, 0x85, 0xa1, 0x47, 0x4f, 0xe6, 0x69, 0x5b, 0x7e, 0xed, 0xdc, 0x7f,
0x0b, 0xe6, 0xd5, 0x7b, 0x32, 0x1c, 0x8f, 0x1a, 0xf3, 0x6d, 0x04, 0xd3, 0xd3, 0xf4, 0xa3, 0xaf,
0x7f, 0x07, 0x00, 0x00, 0xff, 0xff, 0x17, 0x73, 0x67, 0xd0, 0x71, 0x02, 0x00, 0x00,
}
func (m *Container) Marshal() (dAtA []byte, err error) {

40
v2/container/types.go
View file

@ -28,9 +28,7 @@ type Container struct {
type PutRequestBody struct {
cnr *Container
pubKey []byte
sig []byte
sig *service.Signature
}
type PutRequest struct {
@ -80,7 +78,7 @@ type GetResponse struct {
type DeleteRequestBody struct {
cid *refs.ContainerID
sig []byte
sig *service.Signature
}
type DeleteRequest struct {
@ -128,7 +126,7 @@ type ListResponse struct {
type SetExtendedACLRequestBody struct {
eacl *acl.Table
sig []byte
sig *service.Signature
}
type SetExtendedACLRequest struct {
@ -164,7 +162,7 @@ type GetExtendedACLRequest struct {
type GetExtendedACLResponseBody struct {
eacl *acl.Table
sig []byte
sig *service.Signature
}
type GetExtendedACLResponse struct {
@ -301,21 +299,7 @@ func (r *PutRequestBody) SetContainer(v *Container) {
}
}
func (r *PutRequestBody) GetPublicKey() []byte {
if r != nil {
return r.pubKey
}
return nil
}
func (r *PutRequestBody) SetPublicKey(v []byte) {
if r != nil {
r.pubKey = v
}
}
func (r *PutRequestBody) GetSignature() []byte {
func (r *PutRequestBody) GetSignature() *service.Signature {
if r != nil {
return r.sig
}
@ -323,7 +307,7 @@ func (r *PutRequestBody) GetSignature() []byte {
return nil
}
func (r *PutRequestBody) SetSignature(v []byte) {
func (r *PutRequestBody) SetSignature(v *service.Signature) {
if r != nil {
r.sig = v
}
@ -553,7 +537,7 @@ func (r *DeleteRequestBody) SetContainerID(v *refs.ContainerID) {
}
}
func (r *DeleteRequestBody) GetSignature() []byte {
func (r *DeleteRequestBody) GetSignature() *service.Signature {
if r != nil {
return r.sig
}
@ -561,7 +545,7 @@ func (r *DeleteRequestBody) GetSignature() []byte {
return nil
}
func (r *DeleteRequestBody) SetSignature(v []byte) {
func (r *DeleteRequestBody) SetSignature(v *service.Signature) {
if r != nil {
r.sig = v
}
@ -777,7 +761,7 @@ func (r *SetExtendedACLRequestBody) SetEACL(v *acl.Table) {
}
}
func (r *SetExtendedACLRequestBody) GetSignature() []byte {
func (r *SetExtendedACLRequestBody) GetSignature() *service.Signature {
if r != nil {
return r.sig
}
@ -785,7 +769,7 @@ func (r *SetExtendedACLRequestBody) GetSignature() []byte {
return nil
}
func (r *SetExtendedACLRequestBody) SetSignature(v []byte) {
func (r *SetExtendedACLRequestBody) SetSignature(v *service.Signature) {
if r != nil {
r.sig = v
}
@ -945,7 +929,7 @@ func (r *GetExtendedACLResponseBody) SetEACL(v *acl.Table) {
}
}
func (r *GetExtendedACLResponseBody) GetSignature() []byte {
func (r *GetExtendedACLResponseBody) GetSignature() *service.Signature {
if r != nil {
return r.sig
}
@ -953,7 +937,7 @@ func (r *GetExtendedACLResponseBody) GetSignature() []byte {
return nil
}
func (r *GetExtendedACLResponseBody) SetSignature(v []byte) {
func (r *GetExtendedACLResponseBody) SetSignature(v *service.Signature) {
if r != nil {
r.sig = v
}

8
v2/object/convert.go
View file

@ -758,10 +758,6 @@ func DeleteRequestBodyToGRPCMessage(r *DeleteRequestBody) *object.DeleteRequest_
refs.AddressToGRPCMessage(r.GetAddress()),
)
m.SetOwnerId(
refs.OwnerIDToGRPCMessage(r.GetOwnerID()),
)
return m
}
@ -776,10 +772,6 @@ func DeleteRequestBodyFromGRPCMessage(m *object.DeleteRequest_Body) *DeleteReque
refs.AddressFromGRPCMessage(m.GetAddress()),
)
r.SetOwnerID(
refs.OwnerIDFromGRPCMessage(m.GetOwnerId()),
)
return r
}

7
v2/object/grpc/service.go
View file

@ -230,13 +230,6 @@ func (m *DeleteRequest_Body) SetAddress(v *refs.Address) {
}
}
// SetOwnerId sets identifier of the removing object owner.
func (m *DeleteRequest_Body) SetOwnerId(v *refs.OwnerID) {
if m != nil {
m.OwnerId = v
}
}
// SetBody sets body of the request.
func (m *DeleteRequest) SetBody(v *DeleteRequest_Body) {
if m != nil {

221
v2/object/grpc/service.pb.go
View file

@ -815,9 +815,7 @@ func (m *DeleteRequest) GetVerifyHeader() *grpc.RequestVerificationHeader {
// Request body
type DeleteRequest_Body struct {
// Carries the address of the object to be deleted.
Address *grpc1.Address `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
// Carries identifier the object owner.
OwnerId *grpc1.OwnerID `protobuf:"bytes,2,opt,name=owner_id,json=ownerId,proto3" json:"owner_id,omitempty"`
Address *grpc1.Address `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
@ -863,13 +861,6 @@ func (m *DeleteRequest_Body) GetAddress() *grpc1.Address {
return nil
}
func (m *DeleteRequest_Body) GetOwnerId() *grpc1.OwnerID {
if m != nil {
return m.OwnerId
}
return nil
}
// DeleteResponse is empty because we cannot guarantee permanent object removal
// in distributed system.
type DeleteResponse struct {
@ -2199,86 +2190,84 @@ func init() {
func init() { proto.RegisterFile("v2/object/grpc/service.proto", fileDescriptor_1d7d92b1e85e5b48) }
var fileDescriptor_1d7d92b1e85e5b48 = []byte{
// 1258 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x58, 0x4d, 0x6f, 0x1b, 0x45,
0x18, 0xce, 0xae, 0x37, 0x8e, 0xfd, 0xda, 0x0e, 0xd1, 0x34, 0x2a, 0x96, 0xf3, 0x41, 0xba, 0x69,
0xd2, 0x88, 0x92, 0x75, 0x30, 0x2a, 0xa1, 0x29, 0x2d, 0x6a, 0x48, 0xd2, 0x58, 0x25, 0x4d, 0x58,
0x23, 0x0e, 0x48, 0xc8, 0xda, 0xec, 0x8e, 0xed, 0x05, 0x7b, 0xd7, 0xec, 0xac, 0x5d, 0xf9, 0xc2,
0x11, 0x89, 0x5f, 0x40, 0xc5, 0x01, 0x21, 0x8e, 0xe5, 0xc6, 0x0f, 0xe0, 0x0c, 0xb7, 0xc2, 0x2f,
0x40, 0xe1, 0x8a, 0xd4, 0x5f, 0x00, 0x42, 0xf3, 0xb1, 0xb6, 0xd7, 0xf1, 0x97, 0x72, 0xdb, 0xde,
0xe6, 0xe3, 0x79, 0xdf, 0x9d, 0xf7, 0x99, 0x67, 0xde, 0x79, 0x67, 0x61, 0xb9, 0x5d, 0xc8, 0xbb,
0xe7, 0x5f, 0x60, 0xd3, 0xcf, 0x57, 0xbd, 0xa6, 0x99, 0x27, 0xd8, 0x6b, 0xdb, 0x26, 0xd6, 0x9a,
0x9e, 0xeb, 0xbb, 0x68, 0xc1, 0xc1, 0xae, 0x56, 0x21, 0x5a, 0xbb, 0xa0, 0x71, 0x50, 0x2e, 0x37,
0x80, 0xf7, 0x3b, 0x4d, 0x4c, 0x38, 0x3a, 0x97, 0x6d, 0x17, 0xf2, 0x1e, 0xae, 0x90, 0xcb, 0x33,
0xd4, 0x4a, 0x78, 0xe6, 0x93, 0x0d, 0xec, 0x1b, 0x62, 0x6e, 0x79, 0x70, 0xae, 0x8d, 0x3d, 0xbb,
0xd2, 0xe1, 0xb3, 0xea, 0x73, 0x19, 0xe0, 0x11, 0xf6, 0x75, 0xfc, 0x55, 0x0b, 0x13, 0x1f, 0xdd,
0x01, 0xe5, 0xdc, 0xb5, 0x3a, 0x59, 0x69, 0x4d, 0xda, 0x4a, 0x15, 0x6e, 0x68, 0x83, 0xeb, 0xd3,
0x7a, 0x58, 0x6d, 0xdf, 0xb5, 0x3a, 0x3a, 0x83, 0xa3, 0x43, 0x48, 0xd1, 0x2f, 0x96, 0x6b, 0xd8,
0xb0, 0xb0, 0x97, 0x95, 0x99, 0xf5, 0xcd, 0x3e, 0xeb, 0x20, 0x6c, 0x61, 0x7b, 0x82, 0x7d, 0xe3,
0x98, 0x61, 0x75, 0x68, 0x74, 0xdb, 0xe8, 0x63, 0xc8, 0xf0, 0xc5, 0x05, 0x8e, 0x62, 0xcc, 0xd1,
0x5b, 0xa3, 0x1d, 0x7d, 0x4a, 0xe1, 0xb6, 0x69, 0xf8, 0xb6, 0xeb, 0x08, 0x87, 0x69, 0xee, 0x82,
0xf7, 0x72, 0x8f, 0x41, 0xa1, 0xeb, 0x44, 0x6f, 0xc3, 0x9c, 0x61, 0x59, 0x1e, 0x26, 0x44, 0xc4,
0xf6, 0x7a, 0x9f, 0x53, 0x4a, 0xaa, 0xf6, 0x90, 0x4f, 0xeb, 0x01, 0x0e, 0x2d, 0x40, 0xcc, 0x33,
0x9e, 0xb2, 0x60, 0x12, 0x3a, 0x6d, 0xaa, 0xff, 0xc5, 0x20, 0xc5, 0x08, 0x20, 0x4d, 0xd7, 0x21,
0x18, 0xbd, 0x1b, 0x62, 0x4b, 0x1d, 0xc1, 0x16, 0x07, 0xf7, 0xd3, 0x75, 0x34, 0x8c, 0xae, 0x8d,
0xa1, 0x51, 0x72, 0xe3, 0x11, 0x7c, 0xe9, 0xc3, 0xf9, 0xda, 0x1e, 0xe3, 0x69, 0x22, 0x61, 0xdf,
0xcb, 0x82, 0xb1, 0xfb, 0xa0, 0xd8, 0x8e, 0xed, 0x8b, 0xe0, 0x6e, 0x4d, 0x0e, 0x4e, 0x2b, 0x3a,
0xb6, 0x7f, 0x3c, 0xa3, 0x33, 0x33, 0x74, 0x1d, 0x66, 0xcd, 0x5a, 0xcb, 0xf9, 0x92, 0x45, 0x97,
0x3e, 0x9e, 0xd1, 0x79, 0x37, 0xf7, 0xb3, 0x04, 0x0a, 0x05, 0xa2, 0x3b, 0x90, 0xe4, 0x8e, 0xca,
0xb6, 0x25, 0x3e, 0x92, 0x1d, 0xdc, 0x93, 0x53, 0x06, 0x28, 0x1e, 0xe8, 0x09, 0x0e, 0x2d, 0x5a,
0x68, 0x0f, 0x92, 0xc4, 0xae, 0x3a, 0x86, 0xdf, 0xf2, 0xb0, 0x60, 0x6e, 0x79, 0x48, 0xbc, 0xa5,
0x00, 0xa3, 0xf7, 0xe0, 0x68, 0x07, 0xe2, 0x21, 0xa2, 0xb2, 0x97, 0x83, 0x12, 0x9c, 0x08, 0xdc,
0x7e, 0x06, 0x52, 0x62, 0x91, 0x4d, 0xc3, 0xf3, 0xd5, 0x1f, 0x14, 0x80, 0xb3, 0xd6, 0xf4, 0xa7,
0xa5, 0x87, 0x8d, 0xc6, 0x69, 0xf9, 0x35, 0xd8, 0xfc, 0xf7, 0x43, 0x9b, 0xbf, 0x39, 0x31, 0xb2,
0xe9, 0xf6, 0xfe, 0x45, 0x94, 0xf6, 0x1e, 0xad, 0x43, 0xc6, 0x74, 0x9b, 0x36, 0x26, 0x65, 0xa7,
0xd5, 0x38, 0xc7, 0x5e, 0x56, 0x59, 0x93, 0xb6, 0x32, 0x7a, 0x9a, 0x0f, 0x3e, 0x61, 0x63, 0x83,
0x02, 0xf9, 0x51, 0x86, 0x14, 0xa3, 0x66, 0xda, 0x0c, 0xd1, 0x07, 0x8e, 0x4a, 0x86, 0xb8, 0x2f,
0x34, 0x72, 0xb5, 0x4d, 0x54, 0xff, 0x94, 0x21, 0x73, 0x80, 0xeb, 0xd8, 0xc7, 0xc1, 0x31, 0x7a,
0x2f, 0x44, 0xd2, 0xcd, 0xcb, 0x24, 0x85, 0xe0, 0xd1, 0x38, 0x49, 0x8d, 0xab, 0xdf, 0x3b, 0x05,
0x48, 0xb8, 0x4f, 0x1d, 0xec, 0x51, 0x5a, 0xe5, 0xe1, 0x36, 0xa7, 0x74, 0xbe, 0x78, 0xa0, 0xcf,
0x31, 0x60, 0xd1, 0x52, 0x5f, 0x4a, 0x30, 0x1f, 0xb0, 0x24, 0xa4, 0x77, 0x37, 0xc4, 0xea, 0xc6,
0x68, 0x56, 0xa3, 0xa5, 0xbe, 0x38, 0x27, 0x56, 0xfd, 0x5d, 0x86, 0x14, 0x1d, 0x0a, 0x44, 0x34,
0xf1, 0xa4, 0xf5, 0x81, 0xa3, 0x21, 0xa1, 0xda, 0xd5, 0x25, 0xb4, 0x04, 0xc9, 0x86, 0x61, 0x3b,
0x65, 0xd7, 0xa9, 0x77, 0x44, 0x01, 0x93, 0xa0, 0x03, 0xa7, 0x4e, 0xbd, 0x13, 0xd4, 0x35, 0xb1,
0x5e, 0x5d, 0xf3, 0x8f, 0x0c, 0x69, 0x4e, 0x8f, 0xd0, 0xce, 0x6e, 0x88, 0xcc, 0xf5, 0x51, 0x64,
0x46, 0x4b, 0x39, 0xdf, 0x48, 0x82, 0xd0, 0x42, 0xf7, 0x2a, 0x90, 0xc6, 0x5f, 0x05, 0xc7, 0x33,
0xdd, 0xcb, 0x60, 0x1f, 0xd2, 0xa4, 0xe6, 0x7a, 0x7e, 0x38, 0xb2, 0x95, 0xcb, 0x96, 0x25, 0x8a,
0xea, 0x9a, 0xa7, 0x48, 0xaf, 0xbb, 0x1f, 0x07, 0x85, 0x5a, 0xab, 0xff, 0xc6, 0x20, 0x53, 0xc2,
0x86, 0x67, 0xd6, 0xa6, 0xce, 0x80, 0x21, 0x78, 0x34, 0xe4, 0xfb, 0x5d, 0x50, 0x4b, 0x3c, 0x80,
0xb4, 0xe9, 0x3a, 0xbe, 0x61, 0x8b, 0x9c, 0xc6, 0x83, 0x5c, 0x1a, 0x14, 0xf1, 0x87, 0x01, 0xa6,
0x78, 0xa0, 0xa7, 0xba, 0x06, 0x45, 0x0b, 0x65, 0x61, 0xae, 0x8d, 0x3d, 0x62, 0xbb, 0x0e, 0x0b,
0x2f, 0xa3, 0x07, 0x5d, 0x74, 0x08, 0x73, 0x15, 0xbb, 0xee, 0x63, 0x8f, 0x64, 0x63, 0x6b, 0xb1,
0xad, 0x54, 0xe1, 0xf6, 0x34, 0xcc, 0x69, 0x47, 0xcc, 0x46, 0x0f, 0x6c, 0x73, 0x0e, 0xc4, 0xf9,
0x10, 0xda, 0x03, 0x68, 0x18, 0xbe, 0x59, 0x2b, 0xd3, 0xc7, 0x15, 0x5b, 0xe8, 0x7c, 0x68, 0xa1,
0xc2, 0xe7, 0x09, 0xc5, 0x7c, 0xd2, 0x69, 0x62, 0x3d, 0xd9, 0x08, 0x9a, 0x08, 0x81, 0xe2, 0x18,
0x0d, 0x5e, 0x97, 0x24, 0x75, 0xd6, 0x46, 0x8b, 0x30, 0xdb, 0x36, 0xea, 0x2d, 0xcc, 0xe8, 0x4c,
0xea, 0xbc, 0xa3, 0xfe, 0x24, 0xc3, 0x7c, 0xb0, 0xac, 0x69, 0x93, 0x75, 0x18, 0x1f, 0x95, 0x23,
0x77, 0xb7, 0x97, 0xc2, 0x6c, 0xab, 0x5c, 0xb7, 0x09, 0xad, 0x28, 0x63, 0x63, 0x0b, 0x85, 0xb8,
0x6d, 0x7d, 0x64, 0x13, 0x5f, 0xdd, 0x85, 0x59, 0xdd, 0x70, 0xaa, 0x18, 0x5d, 0x87, 0xb8, 0x5b,
0xa9, 0x10, 0xcc, 0x8b, 0x51, 0x45, 0x17, 0x3d, 0x3a, 0x5e, 0xc7, 0x4e, 0xd5, 0xaf, 0xb1, 0x90,
0x15, 0x5d, 0xf4, 0xd4, 0x3f, 0x64, 0x78, 0x8d, 0x3e, 0x4d, 0xa8, 0x71, 0x70, 0xbe, 0xf6, 0x42,
0xf4, 0x6e, 0x0e, 0x7f, 0xcb, 0xf4, 0x19, 0xbc, 0xf2, 0x17, 0xc4, 0x36, 0xcc, 0x7a, 0x34, 0xde,
0x21, 0x05, 0x86, 0x60, 0x84, 0xd3, 0xc1, 0x51, 0xea, 0xb7, 0x32, 0x2c, 0xf4, 0x28, 0x12, 0x9a,
0xbd, 0x17, 0x22, 0xf5, 0xd6, 0x38, 0x52, 0xa3, 0xa5, 0xda, 0x65, 0xc1, 0xeb, 0x62, 0xf0, 0x8c,
0xa1, 0x11, 0xa6, 0xc5, 0x23, 0x46, 0x7d, 0x29, 0xc3, 0xb5, 0x20, 0xb2, 0x63, 0x83, 0x74, 0x73,
0xf8, 0x83, 0x10, 0x1d, 0x6f, 0x8e, 0xa6, 0xa3, 0xcf, 0x28, 0x1a, 0x3a, 0xfb, 0xfa, 0xea, 0x3a,
0xcb, 0x43, 0x9c, 0x29, 0x88, 0x64, 0x65, 0x76, 0xee, 0x47, 0x0a, 0x4d, 0xc0, 0x68, 0x16, 0x25,
0x46, 0xdd, 0x67, 0xab, 0x4e, 0xeb, 0xac, 0xad, 0x3e, 0x93, 0x61, 0x31, 0x4c, 0x9e, 0x50, 0xe0,
0x07, 0x21, 0xca, 0x6f, 0x4f, 0xa2, 0x3c, 0x5a, 0x2a, 0x5c, 0x17, 0xac, 0x2f, 0x41, 0xb2, 0x66,
0x90, 0x5a, 0x2f, 0x7b, 0xa6, 0xf5, 0x04, 0x1d, 0xa0, 0x59, 0xb2, 0xf0, 0x8b, 0x02, 0x19, 0x9e,
0x3a, 0x4b, 0xdc, 0x3f, 0x3a, 0x80, 0xd8, 0x23, 0xec, 0xa3, 0xe5, 0x71, 0xbf, 0xee, 0x72, 0x2b,
0x63, 0xff, 0xe6, 0xec, 0x48, 0xd4, 0xcb, 0x59, 0x6b, 0xa8, 0x97, 0xde, 0xc3, 0x7f, 0x98, 0x97,
0xbe, 0xe7, 0xec, 0x96, 0x84, 0x1e, 0x43, 0x9c, 0x3f, 0x32, 0xd0, 0x1b, 0x13, 0x1e, 0x75, 0xb9,
0xb5, 0x49, 0xef, 0x13, 0x74, 0x08, 0x0a, 0x65, 0x06, 0xad, 0x8c, 0x2d, 0xed, 0x73, 0xab, 0xe3,
0x8b, 0x55, 0x74, 0x02, 0x71, 0x7e, 0x97, 0x0e, 0x5b, 0x53, 0xa8, 0x58, 0x18, 0xb6, 0xa6, 0xf0,
0x35, 0xbc, 0x23, 0xa1, 0x12, 0x24, 0x02, 0x91, 0xa1, 0x1b, 0x13, 0xef, 0x95, 0x9c, 0x3a, 0x39,
0x4b, 0xee, 0x48, 0xe8, 0x73, 0x48, 0xf7, 0x2b, 0x17, 0x6d, 0x4c, 0x95, 0x4c, 0x72, 0x9b, 0xd3,
0x1d, 0x80, 0xfd, 0xf2, 0x6f, 0x17, 0xab, 0xd2, 0x8b, 0x8b, 0x55, 0xe9, 0xaf, 0x8b, 0x55, 0xe9,
0xd9, 0xdf, 0xab, 0x33, 0x9f, 0xed, 0x56, 0x6d, 0xbf, 0xd6, 0x3a, 0xd7, 0x4c, 0xb7, 0x91, 0x77,
0x48, 0xd3, 0x34, 0xb7, 0x2d, 0xdc, 0xce, 0x3b, 0xd8, 0xad, 0x90, 0x6d, 0xa3, 0x69, 0x6f, 0x57,
0xdd, 0x7c, 0xf8, 0xbf, 0xf4, 0x3d, 0xde, 0x7e, 0x2e, 0x5f, 0x7b, 0x82, 0xdd, 0xa3, 0x92, 0xf6,
0xf0, 0xac, 0x48, 0xbf, 0xca, 0xa5, 0x78, 0x1e, 0x67, 0xff, 0x96, 0xdf, 0xf9, 0x3f, 0x00, 0x00,
0xff, 0xff, 0x89, 0x37, 0x38, 0x06, 0xfd, 0x16, 0x00, 0x00,
// 1231 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x58, 0x5d, 0x6f, 0x1b, 0x45,
0x17, 0xce, 0xae, 0x37, 0x4e, 0x7c, 0x6c, 0xe7, 0x8d, 0xa6, 0x51, 0x6b, 0x39, 0x1f, 0x6f, 0xba,
0x69, 0xd2, 0x88, 0x92, 0x75, 0x30, 0x2a, 0xa1, 0x29, 0x2d, 0x6a, 0x48, 0xd2, 0x58, 0x25, 0x6d,
0x58, 0x23, 0x2e, 0x90, 0x90, 0xb5, 0x59, 0x8f, 0xed, 0x05, 0x7b, 0xd7, 0xec, 0x8c, 0x8d, 0x7c,
0xc3, 0x25, 0x12, 0xbf, 0x80, 0x8a, 0x8b, 0x0a, 0x71, 0x59, 0xee, 0xf8, 0x01, 0x5c, 0xc3, 0x5d,
0xf9, 0x07, 0x28, 0xdc, 0x22, 0xf5, 0x17, 0x80, 0xd0, 0x7c, 0xac, 0xed, 0x8d, 0x3f, 0x95, 0xbb,
0xe5, 0x6e, 0x66, 0xfc, 0x9c, 0xe3, 0x39, 0xcf, 0x3c, 0x73, 0xe6, 0x9c, 0x85, 0x95, 0x76, 0x3e,
0xe7, 0x9d, 0x7f, 0x8e, 0x6d, 0x9a, 0xab, 0xfa, 0x4d, 0x3b, 0x47, 0xb0, 0xdf, 0x76, 0x6c, 0x6c,
0x34, 0x7d, 0x8f, 0x7a, 0x68, 0xd1, 0xc5, 0x9e, 0x51, 0x21, 0x46, 0x3b, 0x6f, 0x08, 0x50, 0x36,
0x7b, 0x09, 0x4f, 0x3b, 0x4d, 0x4c, 0x04, 0x3a, 0x9b, 0x69, 0xe7, 0x73, 0x3e, 0xae, 0x90, 0xc1,
0x5f, 0x96, 0xdb, 0xf9, 0xc0, 0xf3, 0xc0, 0x8f, 0xfa, 0x4b, 0x15, 0xe0, 0x31, 0xa6, 0x26, 0xfe,
0xb2, 0x85, 0x09, 0x45, 0x77, 0x41, 0x3b, 0xf7, 0xca, 0x9d, 0x8c, 0xb2, 0xae, 0x6c, 0x27, 0xf3,
0x37, 0x8d, 0xcb, 0x5b, 0x30, 0x7a, 0x58, 0xe3, 0xc0, 0x2b, 0x77, 0x4c, 0x0e, 0x47, 0x47, 0x90,
0x6c, 0x60, 0x6a, 0x95, 0x6a, 0xd8, 0x2a, 0x63, 0x3f, 0xa3, 0x72, 0xeb, 0x5b, 0x7d, 0xd6, 0x41,
0x64, 0xd2, 0xf6, 0x14, 0x53, 0xeb, 0x84, 0x63, 0x4d, 0x68, 0x74, 0xc7, 0xe8, 0x23, 0x48, 0xb7,
0xb1, 0xef, 0x54, 0x3a, 0x81, 0xa3, 0x18, 0x77, 0xf4, 0xe6, 0x68, 0x47, 0x9f, 0x30, 0xb8, 0x63,
0x5b, 0xd4, 0xf1, 0x5c, 0xe9, 0x30, 0x25, 0x5c, 0x88, 0x59, 0xf6, 0x09, 0x68, 0x6c, 0x9f, 0xe8,
0x2d, 0x98, 0xb3, 0xca, 0x65, 0x1f, 0x13, 0x22, 0x63, 0xbb, 0xd1, 0xe7, 0x94, 0xf1, 0x66, 0x3c,
0x12, 0x3f, 0x9b, 0x01, 0x0e, 0x2d, 0x42, 0xcc, 0xb7, 0xbe, 0xe2, 0xc1, 0xcc, 0x9b, 0x6c, 0xa8,
0xff, 0x13, 0x83, 0x24, 0x27, 0x80, 0x34, 0x3d, 0x97, 0x60, 0xf4, 0x4e, 0x88, 0x2d, 0x7d, 0x04,
0x5b, 0x02, 0xdc, 0x4f, 0xd7, 0xf1, 0x30, 0xba, 0x36, 0x87, 0x46, 0x29, 0x8c, 0x47, 0xf0, 0x65,
0x0e, 0xe7, 0x6b, 0x67, 0x8c, 0xa7, 0x89, 0x84, 0x7d, 0xaf, 0x4a, 0xc6, 0x1e, 0x80, 0xe6, 0xb8,
0x0e, 0x95, 0xc1, 0xdd, 0x9e, 0x1c, 0x9c, 0x51, 0x70, 0x1d, 0x7a, 0x32, 0x63, 0x72, 0x33, 0x74,
0x1d, 0x66, 0xed, 0x5a, 0xcb, 0xfd, 0x82, 0x47, 0x97, 0x3a, 0x99, 0x31, 0xc5, 0x34, 0xfb, 0x93,
0x02, 0x1a, 0x03, 0xa2, 0xbb, 0x90, 0x10, 0x8e, 0x4a, 0x4e, 0x59, 0xfe, 0x49, 0xe6, 0xf2, 0x99,
0x3c, 0xe3, 0x80, 0xc2, 0xa1, 0x39, 0x2f, 0xa0, 0x85, 0x32, 0xda, 0x87, 0x04, 0x71, 0xaa, 0xae,
0x45, 0x5b, 0x3e, 0x96, 0xcc, 0xad, 0x0c, 0x89, 0xb7, 0x18, 0x60, 0xcc, 0x1e, 0x1c, 0xed, 0x42,
0x3c, 0x44, 0x54, 0x66, 0x30, 0x28, 0xc9, 0x89, 0xc4, 0x1d, 0xa4, 0x21, 0x29, 0x37, 0xd9, 0xb4,
0x7c, 0xaa, 0xbf, 0xd0, 0x00, 0xce, 0x5a, 0xd3, 0xdf, 0x96, 0x1e, 0x36, 0x1a, 0xb7, 0xe5, 0x97,
0xe0, 0xf0, 0xdf, 0x0b, 0x1d, 0xfe, 0xd6, 0xc4, 0xc8, 0xa6, 0x3b, 0xfb, 0x57, 0x51, 0x3a, 0x7b,
0xb4, 0x01, 0x69, 0xdb, 0x6b, 0x3a, 0x98, 0x94, 0xdc, 0x56, 0xe3, 0x1c, 0xfb, 0x19, 0x6d, 0x5d,
0xd9, 0x4e, 0x9b, 0x29, 0xb1, 0xf8, 0x94, 0xaf, 0x5d, 0x16, 0xc8, 0x0f, 0x2a, 0x24, 0x39, 0x35,
0xd3, 0x66, 0x88, 0x3e, 0x70, 0x54, 0x32, 0xc4, 0x03, 0xa9, 0x91, 0xab, 0x1d, 0xa2, 0xfe, 0x42,
0x85, 0xf4, 0x21, 0xae, 0x63, 0x8a, 0x83, 0x6b, 0xf4, 0x6e, 0x88, 0xa4, 0x5b, 0x83, 0x24, 0x85,
0xe0, 0xd1, 0xb8, 0x49, 0xf7, 0xae, 0xfc, 0xee, 0xe8, 0xaf, 0x15, 0x58, 0x08, 0x22, 0x96, 0x32,
0xba, 0x17, 0x62, 0x68, 0x73, 0x34, 0x43, 0xd1, 0x52, 0x52, 0x5c, 0x90, 0xa4, 0xff, 0xa6, 0x42,
0x92, 0x2d, 0x05, 0x82, 0x98, 0x78, 0x6b, 0xfa, 0xc0, 0xd1, 0x90, 0x43, 0xed, 0xea, 0x65, 0xc8,
0x32, 0x24, 0x1a, 0x96, 0xe3, 0x96, 0x3c, 0xb7, 0xde, 0x91, 0xc5, 0xc8, 0x3c, 0x5b, 0x78, 0xe6,
0xd6, 0x3b, 0x41, 0x8d, 0x12, 0xeb, 0xd5, 0x28, 0x7f, 0xa9, 0x90, 0x12, 0xf4, 0x48, 0xed, 0xec,
0x85, 0xc8, 0xdc, 0x18, 0x45, 0x66, 0xb4, 0x94, 0xf3, 0x8d, 0x22, 0x09, 0xcd, 0x77, 0xd3, 0xba,
0x32, 0x3e, 0xad, 0x9f, 0xcc, 0x74, 0x13, 0xfb, 0x01, 0xa4, 0x48, 0xcd, 0xf3, 0x69, 0x38, 0xb2,
0xd5, 0x41, 0xcb, 0x22, 0x43, 0x75, 0xcd, 0x93, 0xa4, 0x37, 0x3d, 0x88, 0x83, 0xc6, 0xac, 0xf5,
0xbf, 0x63, 0x90, 0x2e, 0x62, 0xcb, 0xb7, 0x6b, 0x53, 0x67, 0xb3, 0x10, 0x3c, 0x1a, 0xf2, 0xfd,
0x2e, 0xa8, 0x0b, 0x1e, 0x42, 0xca, 0xf6, 0x5c, 0x6a, 0x39, 0x2e, 0xf6, 0x7b, 0x69, 0x7f, 0xf9,
0xb2, 0x88, 0x3f, 0x08, 0x30, 0x85, 0x43, 0x33, 0xd9, 0x35, 0x28, 0x94, 0x51, 0x06, 0xe6, 0xda,
0xd8, 0x27, 0x8e, 0xe7, 0xf2, 0xf0, 0xd2, 0x66, 0x30, 0x45, 0x47, 0x30, 0x57, 0x71, 0xea, 0x14,
0xfb, 0x24, 0x13, 0x5b, 0x8f, 0x6d, 0x27, 0xf3, 0x77, 0xa6, 0x61, 0xce, 0x38, 0xe6, 0x36, 0x66,
0x60, 0x9b, 0x75, 0x21, 0x2e, 0x96, 0xd0, 0x3e, 0x40, 0xc3, 0xa2, 0x76, 0xad, 0xc4, 0xda, 0x1d,
0xbe, 0xd1, 0x85, 0xd0, 0x46, 0xa5, 0xcf, 0x53, 0x86, 0xf9, 0xb8, 0xd3, 0xc4, 0x66, 0xa2, 0x11,
0x0c, 0x11, 0x02, 0xcd, 0xb5, 0x1a, 0xa2, 0xc6, 0x48, 0x98, 0x7c, 0x8c, 0x96, 0x60, 0xb6, 0x6d,
0xd5, 0x5b, 0x98, 0xd3, 0x99, 0x30, 0xc5, 0x44, 0xff, 0x51, 0x85, 0x85, 0x60, 0x5b, 0xd3, 0x26,
0xeb, 0x30, 0x3e, 0x2a, 0x57, 0xae, 0xef, 0x45, 0x73, 0xca, 0xa5, 0xba, 0x43, 0x58, 0x75, 0x18,
0x1b, 0xfb, 0xe8, 0xc7, 0x9d, 0xf2, 0x87, 0x0e, 0xa1, 0xfa, 0x1e, 0xcc, 0x9a, 0x96, 0x5b, 0xc5,
0xe8, 0x3a, 0xc4, 0xbd, 0x4a, 0x85, 0x60, 0x51, 0x58, 0x6a, 0xa6, 0x9c, 0xb1, 0xf5, 0x3a, 0x76,
0xab, 0xb4, 0xc6, 0x43, 0xd6, 0x4c, 0x39, 0xd3, 0x7f, 0x57, 0xe1, 0x7f, 0xac, 0xcd, 0x60, 0xc6,
0xc1, 0xfd, 0xda, 0x0f, 0xd1, 0xbb, 0x35, 0xbc, 0x2f, 0xe9, 0x33, 0xf8, 0xcf, 0x3f, 0x10, 0x3b,
0x30, 0xeb, 0xb3, 0x78, 0x65, 0x38, 0x37, 0x06, 0x19, 0x11, 0x74, 0x08, 0x94, 0xfe, 0xad, 0x0a,
0x8b, 0x3d, 0x8a, 0xa4, 0x66, 0xef, 0x87, 0x48, 0xbd, 0x3d, 0x8e, 0xd4, 0x68, 0xa9, 0x76, 0x45,
0xf2, 0xba, 0x14, 0xb4, 0x24, 0x2c, 0xc2, 0x94, 0x6c, 0x48, 0xf4, 0xd7, 0x2a, 0x5c, 0x0b, 0x22,
0x3b, 0xb1, 0x48, 0x37, 0x87, 0x3f, 0x0c, 0xd1, 0xf1, 0xc6, 0x68, 0x3a, 0xfa, 0x8c, 0xa2, 0xa1,
0xb3, 0xaf, 0xaf, 0xae, 0xb3, 0x1c, 0xc4, 0xb9, 0x82, 0x48, 0x46, 0xe5, 0xf7, 0x7e, 0xa4, 0xd0,
0x24, 0x8c, 0x65, 0x51, 0x62, 0xd5, 0x29, 0xdf, 0x75, 0xca, 0xe4, 0x63, 0xfd, 0xb9, 0x0a, 0x4b,
0x61, 0xf2, 0xa4, 0x02, 0xdf, 0x0f, 0x51, 0x7e, 0x67, 0x12, 0xe5, 0xd1, 0x52, 0xe1, 0x86, 0x64,
0x7d, 0x19, 0x12, 0x35, 0x8b, 0xd4, 0x7a, 0xd9, 0x33, 0x65, 0xce, 0xb3, 0x05, 0x96, 0x25, 0xf3,
0x3f, 0x6b, 0x90, 0x16, 0xa9, 0xb3, 0x28, 0xfc, 0xa3, 0x43, 0x88, 0x3d, 0xc6, 0x14, 0xad, 0x8c,
0xfb, 0x0c, 0x97, 0x5d, 0x1d, 0xfb, 0x65, 0x66, 0x57, 0x61, 0x5e, 0xce, 0x5a, 0x43, 0xbd, 0xf4,
0x9a, 0xf8, 0x61, 0x5e, 0xfa, 0x5a, 0xd3, 0x6d, 0x05, 0x3d, 0x81, 0xb8, 0x68, 0x32, 0xd0, 0xff,
0x27, 0x34, 0x68, 0xd9, 0xf5, 0x49, 0xfd, 0x09, 0x3a, 0x02, 0x8d, 0x31, 0x83, 0x56, 0xc7, 0x96,
0xf6, 0xd9, 0xb5, 0xf1, 0xc5, 0x2a, 0x3a, 0x85, 0xb8, 0x78, 0x4b, 0x87, 0xed, 0x29, 0x54, 0x2c,
0x0c, 0xdb, 0x53, 0xf8, 0x19, 0xde, 0x55, 0x50, 0x11, 0xe6, 0x03, 0x91, 0xa1, 0x9b, 0x13, 0xdf,
0x95, 0xac, 0x3e, 0x39, 0x4b, 0xee, 0x2a, 0xe8, 0x33, 0x48, 0xf5, 0x2b, 0x17, 0x6d, 0x4e, 0x95,
0x4c, 0xb2, 0x5b, 0xd3, 0x5d, 0x80, 0x83, 0xd2, 0xaf, 0x17, 0x6b, 0xca, 0xab, 0x8b, 0x35, 0xe5,
0x8f, 0x8b, 0x35, 0xe5, 0xf9, 0x9f, 0x6b, 0x33, 0x9f, 0xee, 0x55, 0x1d, 0x5a, 0x6b, 0x9d, 0x1b,
0xb6, 0xd7, 0xc8, 0xb9, 0xa4, 0x69, 0xdb, 0x3b, 0x65, 0xdc, 0xce, 0xb9, 0xd8, 0xab, 0x90, 0x1d,
0xab, 0xe9, 0xec, 0x54, 0xbd, 0x5c, 0xf8, 0x33, 0xf2, 0x7d, 0x31, 0x7e, 0xa9, 0x5e, 0x7b, 0x8a,
0xbd, 0xe3, 0xa2, 0xf1, 0xe8, 0xac, 0xc0, 0xfe, 0x55, 0x48, 0xf1, 0x3c, 0xce, 0xbf, 0x13, 0xbf,
0xfd, 0x6f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x11, 0xd3, 0xc8, 0xed, 0xac, 0x16, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
@ -3447,18 +3436,6 @@ func (m *DeleteRequest_Body) MarshalToSizedBuffer(dAtA []byte) (int, error) {
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] = 0x12
}
if m.Address != nil {
{
size, err := m.Address.MarshalToSizedBuffer(dAtA[:i])
@ -4873,10 +4850,6 @@ func (m *DeleteRequest_Body) Size() (n int) {
l = m.Address.Size()
n += 1 + l + sovService(uint64(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)
}
@ -7004,42 +6977,6 @@ func (m *DeleteRequest_Body) Unmarshal(dAtA []byte) error {
return err
}
iNdEx = postIndex
case 2:
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:])

101
v2/object/grpc/types.pb.go
View file

@ -549,58 +549,57 @@ func init() {
func init() { proto.RegisterFile("v2/object/grpc/types.proto", fileDescriptor_545319325da7b9b1) }
var fileDescriptor_545319325da7b9b1 = []byte{
// 808 bytes of a gzipped FileDescriptorProto
// 795 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x95, 0xdd, 0x6e, 0xe3, 0x44,
0x14, 0xc7, 0xeb, 0xb4, 0xf9, 0x3a, 0x49, 0x76, 0xcd, 0x80, 0xc0, 0x0a, 0x55, 0x08, 0x95, 0x90,
0xc2, 0x4a, 0x75, 0x50, 0xb6, 0x08, 0xc1, 0x6a, 0x91, 0xd2, 0xc6, 0x9b, 0x5a, 0x6a, 0x9b, 0x32,
0x76, 0x91, 0xe0, 0xc6, 0x72, 0xed, 0x69, 0x6c, 0x36, 0xf5, 0x58, 0x33, 0x13, 0xa3, 0xdc, 0xf3,
0x10, 0x3c, 0x03, 0x12, 0x37, 0xbc, 0x04, 0x5c, 0xf2, 0x08, 0xa8, 0xbc, 0x08, 0xf2, 0x8c, 0x9d,
0x7e, 0x2e, 0xbb, 0xb0, 0x57, 0x9e, 0x39, 0xf3, 0x3b, 0x67, 0xce, 0xf9, 0x9f, 0x33, 0x32, 0x74,
0xb3, 0xd1, 0x90, 0x9e, 0xff, 0x40, 0x02, 0x31, 0x9c, 0xb3, 0x34, 0x18, 0x8a, 0x55, 0x4a, 0xb8,
0x99, 0x32, 0x2a, 0x28, 0xd2, 0x13, 0x42, 0xcd, 0x0b, 0x6e, 0x66, 0x23, 0x53, 0x21, 0x5d, 0x23,
0x1b, 0x0d, 0x19, 0xb9, 0xe0, 0xf7, 0xd8, 0x6e, 0x1e, 0x87, 0x13, 0x96, 0xc5, 0x01, 0x51, 0x87,
0x97, 0x44, 0xf8, 0xc5, 0xd9, 0xf6, 0xdd, 0xb3, 0x8c, 0xb0, 0xf8, 0x62, 0xa5, 0x4e, 0x77, 0x7e,
0xaa, 0x40, 0xcb, 0x89, 0x28, 0x13, 0x87, 0xc4, 0x0f, 0x09, 0x43, 0x7b, 0x50, 0xcf, 0x08, 0xe3,
0x31, 0x4d, 0x0c, 0xad, 0xaf, 0x0d, 0x5a, 0xa3, 0xae, 0x79, 0x9d, 0x47, 0x11, 0xc6, 0xfc, 0x56,
0x11, 0xb8, 0x44, 0xd1, 0x27, 0xf0, 0x28, 0x60, 0xc4, 0x17, 0x31, 0x4d, 0x3c, 0x92, 0xd2, 0x20,
0x32, 0x2a, 0x7d, 0x6d, 0xb0, 0x85, 0x3b, 0xa5, 0xd5, 0xca, 0x8d, 0x68, 0x04, 0x0d, 0xfa, 0x63,
0x42, 0x98, 0x17, 0x87, 0xc6, 0xa6, 0x8c, 0xfe, 0xc1, 0x8d, 0xe8, 0x79, 0x69, 0xe6, 0x2c, 0x3f,
0xb7, 0x27, 0xb8, 0x2e, 0x41, 0x3b, 0x44, 0xcf, 0xa1, 0xa5, 0xca, 0xf7, 0xf2, 0x82, 0x8d, 0xad,
0xbe, 0x36, 0x78, 0x34, 0xda, 0x36, 0xef, 0x8a, 0x63, 0xce, 0xe4, 0xc7, 0x5d, 0xa5, 0x04, 0x03,
0x5d, 0xaf, 0xf3, 0xcc, 0x52, 0x7f, 0xb5, 0xa0, 0x7e, 0xe8, 0x2d, 0x48, 0x32, 0x17, 0x91, 0x51,
0x55, 0x99, 0x15, 0xd6, 0x23, 0x69, 0xdc, 0xf9, 0xad, 0x0e, 0xb5, 0xb7, 0x52, 0xe0, 0x6b, 0x68,
0x07, 0x34, 0x11, 0x7e, 0x5c, 0x94, 0x57, 0x91, 0xae, 0x1f, 0xde, 0x2d, 0xef, 0xa0, 0x64, 0xec,
0x09, 0x6e, 0xad, 0x1d, 0xec, 0xf0, 0x7f, 0x49, 0x73, 0x5f, 0xf5, 0xad, 0x87, 0x54, 0x7f, 0x33,
0x09, 0xd0, 0xc7, 0xd0, 0x2e, 0xb1, 0xc8, 0xe7, 0x91, 0x51, 0xeb, 0x6b, 0x83, 0x36, 0x6e, 0x15,
0xb6, 0x43, 0x9f, 0x47, 0x77, 0x7b, 0x51, 0xff, 0x8f, 0xbd, 0xf8, 0x14, 0xf4, 0x88, 0x5e, 0xd2,
0x4b, 0xca, 0xd2, 0x28, 0x0e, 0xd4, 0x2d, 0x0d, 0x79, 0xcb, 0xe3, 0x1b, 0x76, 0x79, 0xd3, 0x04,
0x3a, 0x9c, 0xf0, 0x5c, 0x59, 0x4f, 0xd0, 0x97, 0x24, 0x31, 0x9a, 0x52, 0x93, 0x8f, 0x1e, 0x68,
0x85, 0xa3, 0x38, 0x37, 0xc7, 0x70, 0x9b, 0xdf, 0xd8, 0xa1, 0x7d, 0x00, 0x5f, 0x08, 0x16, 0x9f,
0x2f, 0x05, 0xe1, 0x06, 0xf4, 0x37, 0x07, 0xad, 0xd1, 0xce, 0xfd, 0x74, 0x55, 0xe3, 0xcd, 0x71,
0x89, 0xe2, 0x1b, 0x5e, 0x68, 0x0f, 0xaa, 0x3c, 0x5d, 0xc4, 0xc2, 0x68, 0xc9, 0x0c, 0x7a, 0xaf,
0x74, 0x77, 0x72, 0x0a, 0x2b, 0xb8, 0xfb, 0x14, 0x9a, 0xeb, 0x70, 0x48, 0x87, 0xcd, 0x97, 0x64,
0x25, 0xa7, 0xa9, 0x89, 0xf3, 0x25, 0x7a, 0x0f, 0xaa, 0x99, 0xbf, 0x58, 0x12, 0x39, 0x26, 0x4d,
0xac, 0x36, 0xdd, 0x5f, 0x2b, 0x50, 0x95, 0x51, 0xd0, 0x67, 0x50, 0x4b, 0x7d, 0x46, 0x12, 0x51,
0x8c, 0xa0, 0x71, 0x6f, 0x16, 0xe4, 0xd5, 0xf6, 0x04, 0x17, 0x1c, 0xda, 0x83, 0x46, 0xca, 0x48,
0x16, 0xd3, 0x25, 0x2f, 0x66, 0xef, 0xd5, 0x3e, 0x6b, 0x12, 0x4d, 0x41, 0x57, 0xfe, 0x1e, 0x8f,
0xe7, 0x89, 0x2f, 0x96, 0x8c, 0x14, 0xd3, 0xb7, 0xfd, 0x90, 0xd2, 0x25, 0x83, 0x1f, 0x2b, 0xaf,
0xb5, 0x01, 0x3d, 0x87, 0x4e, 0x11, 0x28, 0x92, 0x6a, 0xc8, 0x49, 0xbc, 0x9d, 0xc3, 0x2d, 0xb5,
0x70, 0x5b, 0xe1, 0xeb, 0x37, 0xd7, 0x08, 0xa2, 0x78, 0x11, 0x32, 0x92, 0x18, 0x55, 0xd9, 0xa6,
0x7f, 0xc9, 0xbe, 0x24, 0x77, 0x7e, 0xd7, 0xa0, 0xa6, 0xcc, 0xe8, 0x73, 0x68, 0x16, 0x93, 0x19,
0x87, 0xaf, 0xd5, 0xac, 0xa1, 0x50, 0x3b, 0x44, 0x5f, 0x41, 0xf3, 0xba, 0xf0, 0xca, 0x1b, 0x14,
0x7e, 0x8d, 0xe7, 0x3d, 0x2a, 0x6a, 0xdd, 0x7c, 0x4d, 0xad, 0x05, 0x87, 0x0c, 0xa8, 0x17, 0xaf,
0x49, 0xca, 0xd3, 0xc6, 0xe5, 0xf6, 0xc9, 0x33, 0x80, 0xeb, 0x37, 0x83, 0x5a, 0x50, 0xc7, 0xd6,
0xf4, 0xec, 0x68, 0x8c, 0xf5, 0x0d, 0xd4, 0x81, 0xa6, 0x3b, 0x3b, 0xde, 0x77, 0xdc, 0xd9, 0x89,
0xa5, 0x6b, 0xe8, 0x1d, 0xe8, 0x38, 0xee, 0x0c, 0x8f, 0xa7, 0x96, 0x37, 0xc5, 0xb3, 0xb3, 0x53,
0xbd, 0xf2, 0xe4, 0x4b, 0x68, 0x1e, 0xfb, 0x22, 0x88, 0xa4, 0x6f, 0x17, 0xde, 0x3f, 0x1e, 0xbb,
0x07, 0x87, 0x9e, 0xfb, 0xdd, 0xa9, 0xe5, 0x9d, 0x9d, 0x38, 0xa7, 0xd6, 0x81, 0xfd, 0xc2, 0xb6,
0x26, 0xfa, 0x06, 0xd2, 0xa1, 0xed, 0xb8, 0xd8, 0x3e, 0x99, 0x7a, 0xd6, 0x37, 0x67, 0xe3, 0x23,
0x5d, 0xdb, 0xf7, 0xfe, 0xb8, 0xea, 0x69, 0x7f, 0x5e, 0xf5, 0xb4, 0xbf, 0xae, 0x7a, 0xda, 0xcf,
0x7f, 0xf7, 0x36, 0xbe, 0xff, 0x62, 0x1e, 0x8b, 0x68, 0x79, 0x6e, 0x06, 0xf4, 0x72, 0x98, 0xf0,
0x34, 0x08, 0x76, 0x43, 0x92, 0x0d, 0x13, 0x42, 0x2f, 0xf8, 0xae, 0x9f, 0xc6, 0xbb, 0x73, 0x3a,
0xbc, 0xfd, 0xcf, 0x7a, 0xa6, 0xd6, 0xbf, 0x54, 0xde, 0x3d, 0x21, 0xf4, 0x85, 0x63, 0x8e, 0x4f,
0xed, 0x5c, 0x01, 0x55, 0xce, 0x79, 0x4d, 0xfe, 0x65, 0x9e, 0xfe, 0x13, 0x00, 0x00, 0xff, 0xff,
0x47, 0xd1, 0x60, 0xa2, 0xe9, 0x06, 0x00, 0x00,
0x14, 0xc7, 0xeb, 0xb4, 0xf9, 0x3a, 0x49, 0x76, 0xcd, 0x80, 0xc0, 0xca, 0xae, 0x42, 0xa8, 0x84,
0x14, 0x56, 0xaa, 0x8d, 0xbc, 0x45, 0x08, 0x56, 0x8b, 0x94, 0x36, 0xde, 0xd4, 0x52, 0xdb, 0x94,
0xb1, 0x8b, 0x04, 0x37, 0x96, 0x6b, 0x4f, 0x63, 0xb3, 0xa9, 0xc7, 0xf2, 0x4c, 0x8c, 0x7a, 0xcf,
0x43, 0xf0, 0x0c, 0x48, 0xdc, 0xf0, 0x12, 0x70, 0xc9, 0x23, 0xa0, 0xf2, 0x22, 0xc8, 0x33, 0x76,
0xfa, 0x91, 0x2e, 0x5b, 0xe0, 0x2a, 0x33, 0x27, 0xbf, 0xf3, 0xf5, 0x3f, 0x67, 0x64, 0xe8, 0xe7,
0xa6, 0x41, 0xcf, 0xbe, 0x27, 0x01, 0x37, 0xe6, 0x59, 0x1a, 0x18, 0xfc, 0x32, 0x25, 0x4c, 0x4f,
0x33, 0xca, 0x29, 0x52, 0x13, 0x42, 0xf5, 0x73, 0xa6, 0xe7, 0xa6, 0x2e, 0x91, 0xbe, 0x96, 0x9b,
0x46, 0x46, 0xce, 0xd9, 0x1a, 0xdb, 0x7f, 0x92, 0x9b, 0x06, 0x23, 0x59, 0x1e, 0x07, 0x64, 0xed,
0xcf, 0xed, 0x1f, 0x6b, 0xd0, 0x71, 0x22, 0x9a, 0xf1, 0x03, 0xe2, 0x87, 0x24, 0x43, 0xbb, 0xd0,
0xcc, 0x49, 0xc6, 0x62, 0x9a, 0x68, 0xca, 0x50, 0x19, 0x75, 0xcc, 0xbe, 0x7e, 0x9d, 0xaa, 0x8c,
0xa2, 0x7f, 0x23, 0x09, 0x5c, 0xa1, 0xe8, 0x63, 0x78, 0x14, 0x64, 0xc4, 0xe7, 0x31, 0x4d, 0x3c,
0x92, 0xd2, 0x20, 0xd2, 0x6a, 0x43, 0x65, 0xb4, 0x85, 0x7b, 0x95, 0xd5, 0x2a, 0x8c, 0xc8, 0x84,
0x16, 0xfd, 0x21, 0x21, 0x99, 0x17, 0x87, 0xda, 0xa6, 0x88, 0xfe, 0xc1, 0x8d, 0xe8, 0x45, 0xf5,
0xfa, 0xac, 0xf8, 0xdf, 0x9e, 0xe0, 0xa6, 0x00, 0xed, 0x10, 0xbd, 0x84, 0x8e, 0xec, 0xd0, 0x2b,
0xca, 0xd6, 0xb6, 0x86, 0xca, 0xe8, 0x91, 0xf9, 0x54, 0xbf, 0xdb, 0xbf, 0x3e, 0x13, 0x3f, 0xee,
0x65, 0x4a, 0x30, 0xd0, 0xd5, 0xb9, 0xa8, 0x2c, 0xf5, 0x2f, 0x17, 0xd4, 0x0f, 0xbd, 0x05, 0x49,
0xe6, 0x3c, 0xd2, 0xea, 0xb2, 0xb2, 0xd2, 0x7a, 0x28, 0x8c, 0xdb, 0xbf, 0x36, 0xa1, 0xf1, 0xbf,
0x14, 0xf8, 0x0a, 0xba, 0x01, 0x4d, 0xb8, 0x1f, 0x97, 0xed, 0xd5, 0x84, 0xeb, 0x93, 0xbb, 0xed,
0xed, 0x57, 0x8c, 0x3d, 0xc1, 0x9d, 0x95, 0x83, 0x1d, 0xfe, 0x27, 0x69, 0xd6, 0x55, 0xdf, 0xba,
0x4f, 0xf5, 0x87, 0x49, 0x80, 0x3e, 0x82, 0x6e, 0x85, 0x45, 0x3e, 0x8b, 0xb4, 0xc6, 0x50, 0x19,
0x75, 0x71, 0xa7, 0xb4, 0x1d, 0xf8, 0x2c, 0xba, 0x3b, 0x8b, 0xe6, 0xbf, 0x9c, 0xc5, 0x27, 0xa0,
0x46, 0xf4, 0x82, 0x5e, 0xd0, 0x2c, 0x8d, 0xe2, 0x40, 0x66, 0x69, 0x89, 0x2c, 0x8f, 0x6f, 0xd8,
0x45, 0xa6, 0x09, 0xf4, 0x18, 0x61, 0x85, 0xb2, 0x1e, 0xa7, 0xaf, 0x49, 0xa2, 0xb5, 0x85, 0x26,
0x1f, 0xde, 0x33, 0x0a, 0x47, 0x72, 0x6e, 0x81, 0xe1, 0x2e, 0xbb, 0x71, 0x43, 0x7b, 0x00, 0x3e,
0xe7, 0x59, 0x7c, 0xb6, 0xe4, 0x84, 0x69, 0x30, 0xdc, 0x1c, 0x75, 0xcc, 0xed, 0xf5, 0x72, 0xe5,
0xe0, 0xf5, 0x71, 0x85, 0xe2, 0x1b, 0x5e, 0x68, 0x17, 0xea, 0x2c, 0x5d, 0xc4, 0x5c, 0xeb, 0x88,
0x0a, 0x06, 0x6f, 0x74, 0x77, 0x0a, 0x0a, 0x4b, 0xb8, 0xff, 0x1c, 0xda, 0xab, 0x70, 0x48, 0x85,
0xcd, 0xd7, 0xe4, 0x52, 0x6c, 0x53, 0x1b, 0x17, 0x47, 0xf4, 0x1e, 0xd4, 0x73, 0x7f, 0xb1, 0x24,
0x62, 0x4d, 0xda, 0x58, 0x5e, 0xfa, 0xbf, 0xd4, 0xa0, 0x2e, 0xa2, 0xa0, 0x4f, 0xa1, 0x91, 0xfa,
0x19, 0x49, 0x78, 0xb9, 0x82, 0xda, 0xda, 0x2e, 0x88, 0xd4, 0xf6, 0x04, 0x97, 0x1c, 0xda, 0x85,
0x56, 0x9a, 0x91, 0x3c, 0xa6, 0x4b, 0x56, 0xee, 0xde, 0x9b, 0x7d, 0x56, 0x24, 0x9a, 0x82, 0x2a,
0xfd, 0x3d, 0x16, 0xcf, 0x13, 0x9f, 0x2f, 0x33, 0x52, 0x6e, 0xdf, 0xd3, 0xfb, 0x94, 0xae, 0x18,
0xfc, 0x58, 0x7a, 0xad, 0x0c, 0xe8, 0x25, 0xf4, 0xca, 0x40, 0x91, 0x50, 0x43, 0x6c, 0xe2, 0xed,
0x1a, 0x6e, 0xa9, 0x85, 0xbb, 0x12, 0x5f, 0xbd, 0xb9, 0x56, 0x10, 0xc5, 0x8b, 0x30, 0x23, 0x89,
0x56, 0x17, 0x63, 0xfa, 0x87, 0xea, 0x2b, 0x72, 0xfb, 0x37, 0x05, 0x1a, 0xd2, 0x8c, 0x3e, 0x83,
0x76, 0xb9, 0x99, 0x71, 0xf8, 0x56, 0xcd, 0x5a, 0x12, 0xb5, 0x43, 0xf4, 0x25, 0xb4, 0xaf, 0x1b,
0xaf, 0x3d, 0xa0, 0xf1, 0x6b, 0xbc, 0x98, 0x51, 0xd9, 0xeb, 0xe6, 0x5b, 0x7a, 0x2d, 0x39, 0xa4,
0x41, 0xb3, 0x7c, 0x4d, 0x42, 0x9e, 0x2e, 0xae, 0xae, 0xcf, 0x5e, 0x00, 0x5c, 0xbf, 0x19, 0xd4,
0x81, 0x26, 0xb6, 0xa6, 0xa7, 0x87, 0x63, 0xac, 0x6e, 0xa0, 0x1e, 0xb4, 0xdd, 0xd9, 0xd1, 0x9e,
0xe3, 0xce, 0x8e, 0x2d, 0x55, 0x41, 0xef, 0x40, 0xcf, 0x71, 0x67, 0x78, 0x3c, 0xb5, 0xbc, 0x29,
0x9e, 0x9d, 0x9e, 0xa8, 0xb5, 0x67, 0x5f, 0x40, 0xfb, 0xc8, 0xe7, 0x41, 0x24, 0x7c, 0xfb, 0xf0,
0xfe, 0xd1, 0xd8, 0xdd, 0x3f, 0xf0, 0xdc, 0x6f, 0x4f, 0x2c, 0xef, 0xf4, 0xd8, 0x39, 0xb1, 0xf6,
0xed, 0x57, 0xb6, 0x35, 0x51, 0x37, 0x90, 0x0a, 0x5d, 0xc7, 0xc5, 0xf6, 0xf1, 0xd4, 0xb3, 0xbe,
0x3e, 0x1d, 0x1f, 0xaa, 0xca, 0x9e, 0xf7, 0xfb, 0xd5, 0x40, 0xf9, 0xe3, 0x6a, 0xa0, 0xfc, 0x79,
0x35, 0x50, 0x7e, 0xfa, 0x6b, 0xb0, 0xf1, 0xdd, 0xe7, 0xf3, 0x98, 0x47, 0xcb, 0x33, 0x3d, 0xa0,
0x17, 0x46, 0xc2, 0xd2, 0x20, 0xd8, 0x09, 0x49, 0x6e, 0x24, 0x84, 0x9e, 0xb3, 0x1d, 0x3f, 0x8d,
0x77, 0xe6, 0xd4, 0xb8, 0xfd, 0x59, 0x7a, 0x21, 0xcf, 0x3f, 0xd7, 0xde, 0x3d, 0x26, 0xf4, 0x95,
0xa3, 0x8f, 0x4f, 0xec, 0x42, 0x01, 0xd9, 0xce, 0x59, 0x43, 0x7c, 0x65, 0x9e, 0xff, 0x1d, 0x00,
0x00, 0xff, 0xff, 0x30, 0x4b, 0x22, 0xa9, 0xcc, 0x06, 0x00, 0x00,
}
func (m *ShortHeader) Marshal() (dAtA []byte, err error) {

44
v2/service/convert.go
View file

@ -546,54 +546,54 @@ func ResponseHeadersFromGRPC(
)
}
func ObjectSessionVerbToGRPCField(v ObjectSessionVerb) service.ObjectServiceContext_Verb {
func ObjectSessionVerbToGRPCField(v ObjectSessionVerb) service.ObjectSessionContext_Verb {
switch v {
case ObjectVerbPut:
return service.ObjectServiceContext_PUT
return service.ObjectSessionContext_PUT
case ObjectVerbGet:
return service.ObjectServiceContext_GET
return service.ObjectSessionContext_GET
case ObjectVerbHead:
return service.ObjectServiceContext_HEAD
return service.ObjectSessionContext_HEAD
case ObjectVerbSearch:
return service.ObjectServiceContext_SEARCH
return service.ObjectSessionContext_SEARCH
case ObjectVerbDelete:
return service.ObjectServiceContext_DELETE
return service.ObjectSessionContext_DELETE
case ObjectVerbRange:
return service.ObjectServiceContext_RANGE
return service.ObjectSessionContext_RANGE
case ObjectVerbRangeHash:
return service.ObjectServiceContext_RANGEHASH
return service.ObjectSessionContext_RANGEHASH
default:
return service.ObjectServiceContext_VERB_UNSPECIFIED
return service.ObjectSessionContext_VERB_UNSPECIFIED
}
}
func ObjectSessionVerbFromGRPCField(v service.ObjectServiceContext_Verb) ObjectSessionVerb {
func ObjectSessionVerbFromGRPCField(v service.ObjectSessionContext_Verb) ObjectSessionVerb {
switch v {
case service.ObjectServiceContext_PUT:
case service.ObjectSessionContext_PUT:
return ObjectVerbPut
case service.ObjectServiceContext_GET:
case service.ObjectSessionContext_GET:
return ObjectVerbGet
case service.ObjectServiceContext_HEAD:
case service.ObjectSessionContext_HEAD:
return ObjectVerbHead
case service.ObjectServiceContext_SEARCH:
case service.ObjectSessionContext_SEARCH:
return ObjectVerbSearch
case service.ObjectServiceContext_DELETE:
case service.ObjectSessionContext_DELETE:
return ObjectVerbDelete
case service.ObjectServiceContext_RANGE:
case service.ObjectSessionContext_RANGE:
return ObjectVerbRange
case service.ObjectServiceContext_RANGEHASH:
case service.ObjectSessionContext_RANGEHASH:
return ObjectVerbRangeHash
default:
return ObjectVerbUnknown
}
}
func ObjectSessionContextToGRPCMessage(c *ObjectSessionContext) *service.ObjectServiceContext {
func ObjectSessionContextToGRPCMessage(c *ObjectSessionContext) *service.ObjectSessionContext {
if c == nil {
return nil
}
m := new(service.ObjectServiceContext)
m := new(service.ObjectSessionContext)
m.SetVerb(
ObjectSessionVerbToGRPCField(c.GetVerb()),
@ -606,7 +606,7 @@ func ObjectSessionContextToGRPCMessage(c *ObjectSessionContext) *service.ObjectS
return m
}
func ObjectSessionContextFromGRPCMessage(m *service.ObjectServiceContext) *ObjectSessionContext {
func ObjectSessionContextFromGRPCMessage(m *service.ObjectSessionContext) *ObjectSessionContext {
if m == nil {
return nil
}
@ -665,9 +665,9 @@ func SessionTokenBodyFromGRPCMessage(m *service.SessionToken_Body) *SessionToken
switch v := m.GetContext().(type) {
case nil:
case *service.SessionToken_Body_ObjectService:
case *service.SessionToken_Body_Object:
t.SetContext(
ObjectSessionContextFromGRPCMessage(v.ObjectService),
ObjectSessionContextFromGRPCMessage(v.Object),
)
default:
panic(fmt.Sprintf("unknown session context %T", v))

10
v2/service/grpc/meta.go
View file

@ -83,23 +83,23 @@ func (m *SessionToken_Body) SetSessionKey(v []byte) {
}
// SetObjectAddressContext sets object context of the session token.
func (m *SessionToken_Body) SetObjectServiceContext(v *ObjectServiceContext) {
func (m *SessionToken_Body) SetObjectServiceContext(v *ObjectSessionContext) {
if m != nil {
m.Context = &SessionToken_Body_ObjectService{
ObjectService: v,
m.Context = &SessionToken_Body_Object{
Object: v,
}
}
}
// SetObjectAddressContext sets object context of the session token.
func (m *ObjectServiceContext) SetAddress(v *refs.Address) {
func (m *ObjectSessionContext) SetAddress(v *refs.Address) {
if m != nil {
m.Address = v
}
}
// SetObjectAddressContext sets object context of the session token.
func (m *ObjectServiceContext) SetVerb(v ObjectServiceContext_Verb) {
func (m *ObjectSessionContext) SetVerb(v ObjectSessionContext_Verb) {
if m != nil {
m.Verb = v
}

1660
v2/service/grpc/meta.pb.go → v2/service/grpc/types.pb.go
View file

File diff suppressed because it is too large Load diff

1153
v2/service/grpc/verify.pb.go
View file

File diff suppressed because it is too large Load diff

2
v2/service/marshal_test.go
View file

@ -77,7 +77,7 @@ func TestTokenLifetime_StableMarshal(t *testing.T) {
func TestObjectSessionContext_StableMarshal(t *testing.T) {
objectCtxFrom := generateObjectCtx("Object ID")
transport := new(grpc.ObjectServiceContext)
transport := new(grpc.ObjectSessionContext)
t.Run("non empty", func(t *testing.T) {
wire, err := objectCtxFrom.StableMarshal(nil)

57
v2/session/grpc/service.pb.go
View file

@ -293,37 +293,36 @@ func init() {
func init() { proto.RegisterFile("v2/session/grpc/service.proto", fileDescriptor_4ed1365cc8e16cd4) }
var fileDescriptor_4ed1365cc8e16cd4 = []byte{
// 466 bytes of a gzipped FileDescriptorProto
// 458 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x93, 0x4f, 0x6f, 0xd3, 0x30,
0x18, 0xc6, 0x49, 0x98, 0xc6, 0xe4, 0x76, 0x95, 0xb0, 0x90, 0xa8, 0x22, 0x28, 0x65, 0x62, 0x88,
0x18, 0xc6, 0x49, 0x98, 0xc6, 0xe4, 0x76, 0x95, 0xb0, 0x90, 0xa8, 0x8a, 0x28, 0x65, 0x62, 0x88,
0x03, 0x75, 0xa4, 0x70, 0x40, 0x03, 0x2e, 0x0c, 0x98, 0xa8, 0x60, 0xfc, 0x71, 0x11, 0x07, 0x2e,
0x55, 0xfe, 0xbc, 0xe9, 0xac, 0x11, 0x3b, 0xd8, 0x5e, 0x20, 0xdf, 0x84, 0x2b, 0x57, 0x3e, 0x09,
0x47, 0x3e, 0x01, 0x42, 0xe5, 0x8b, 0xa0, 0xd8, 0xde, 0xb4, 0x6e, 0x59, 0x7b, 0xab, 0xfb, 0x3e,
0xcf, 0xe3, 0xe7, 0xfd, 0x29, 0x46, 0x37, 0xab, 0x28, 0x54, 0xa0, 0x14, 0x13, 0x3c, 0x9c, 0xc9,
0x32, 0x0d, 0x15, 0xc8, 0x8a, 0xa5, 0x40, 0x4a, 0x29, 0xb4, 0xc0, 0x57, 0x39, 0x08, 0x92, 0x2b,
0x52, 0x45, 0xc4, 0xa9, 0x82, 0x7e, 0x15, 0x85, 0x12, 0x72, 0x65, 0xe5, 0xba, 0x2e, 0x41, 0x59,
0x71, 0x10, 0x98, 0x2c, 0x63, 0xb7, 0xc3, 0x02, 0x74, 0xec, 0x66, 0x37, 0xce, 0xce, 0x2a, 0x90,
0x2c, 0xaf, 0xed, 0x74, 0xeb, 0x8f, 0x8f, 0x36, 0x9f, 0x49, 0x88, 0x35, 0x50, 0xf8, 0x72, 0x04,
0x4a, 0xe3, 0x1d, 0xb4, 0x96, 0x88, 0xac, 0xee, 0x7b, 0x43, 0xef, 0x5e, 0x27, 0xda, 0x26, 0xe7,
0x7a, 0x90, 0x05, 0x3d, 0xd9, 0x15, 0x59, 0x4d, 0x8d, 0x05, 0xbf, 0x40, 0x9d, 0xe6, 0xe2, 0xe9,
0x01, 0xc4, 0x19, 0xc8, 0xbe, 0x6f, 0x12, 0xee, 0x2c, 0x24, 0xd8, 0x15, 0x9d, 0x77, 0x1f, 0x74,
0xfc, 0xd2, 0x68, 0x29, 0x2a, 0x4e, 0x7e, 0xe3, 0xf7, 0x68, 0xd3, 0x76, 0x3c, 0x0e, 0xba, 0x6c,
0x82, 0xee, 0x5f, 0x1c, 0xf4, 0xb1, 0x91, 0xb3, 0x34, 0xd6, 0x4c, 0x70, 0x17, 0xd8, 0xb5, 0x11,
0xf6, 0x14, 0x7c, 0x43, 0x6b, 0x4d, 0x4f, 0x1c, 0xa1, 0x0d, 0xf1, 0x95, 0x83, 0x9c, 0xb2, 0xcc,
0x2d, 0x78, 0xfd, 0x54, 0x6a, 0x03, 0x97, 0xbc, 0x6d, 0xe6, 0xe3, 0xe7, 0xf4, 0x8a, 0x11, 0x8e,
0x33, 0xfc, 0x04, 0x6d, 0x7c, 0x66, 0x39, 0x68, 0x56, 0x80, 0x5b, 0x69, 0xd8, 0xd2, 0xe4, 0x83,
0x38, 0x04, 0xfe, 0xda, 0xe9, 0xe8, 0x89, 0x63, 0xeb, 0x87, 0x8f, 0x7a, 0xc7, 0xc0, 0x54, 0x29,
0xb8, 0x02, 0xfc, 0x68, 0x81, 0xf0, 0xdd, 0x25, 0x84, 0xad, 0xe1, 0x34, 0xe2, 0xbd, 0x36, 0xc4,
0xdb, 0xad, 0x64, 0xac, 0xf9, 0x02, 0xc6, 0xb4, 0x9d, 0xf1, 0x68, 0x49, 0xd2, 0x4a, 0xc8, 0x0f,
0x1d, 0xe4, 0x1e, 0xf2, 0x1d, 0xde, 0x2e, 0xf5, 0x59, 0x86, 0x6f, 0xa1, 0x8e, 0x5b, 0x6c, 0x7a,
0x08, 0xb5, 0xe9, 0xdc, 0xa5, 0xc8, 0xfd, 0xf5, 0x0a, 0xea, 0x68, 0x8a, 0x7a, 0x13, 0x7b, 0x9a,
0xd8, 0x3b, 0xf1, 0x3e, 0x5a, 0xb7, 0x0c, 0xf0, 0x70, 0xd5, 0x07, 0x18, 0xdc, 0x5e, 0x09, 0x70,
0x37, 0xf9, 0x35, 0x1f, 0x78, 0xbf, 0xe7, 0x03, 0xef, 0xef, 0x7c, 0xe0, 0x7d, 0xff, 0x37, 0xb8,
0xf4, 0x69, 0x67, 0xc6, 0xf4, 0xc1, 0x51, 0x42, 0x52, 0x51, 0x84, 0x5c, 0x95, 0x69, 0x3a, 0xca,
0xa0, 0x0a, 0x39, 0x88, 0x5c, 0x8d, 0xe2, 0x92, 0x8d, 0x66, 0x22, 0x3c, 0xf3, 0x3e, 0x1f, 0xbb,
0xc3, 0x4f, 0xff, 0xda, 0x1b, 0x10, 0x7b, 0x13, 0xf2, 0xf4, 0xdd, 0xb8, 0xb9, 0xd2, 0x35, 0x4f,
0xd6, 0xcd, 0x83, 0x7a, 0xf0, 0x3f, 0x00, 0x00, 0xff, 0xff, 0xc2, 0x58, 0x7b, 0xc5, 0xd8, 0x03,
0x00, 0x00,
0x51, 0xfe, 0xbc, 0xe9, 0xac, 0x11, 0x3b, 0xd8, 0x5e, 0x20, 0xdf, 0x84, 0x2b, 0x57, 0x3e, 0x09,
0x47, 0x3e, 0x01, 0x42, 0xe5, 0x8b, 0xa0, 0xd8, 0xde, 0xb4, 0x6e, 0x59, 0x7b, 0xcb, 0x1b, 0x3f,
0xcf, 0xf3, 0xbe, 0xef, 0x4f, 0x36, 0xba, 0x59, 0x85, 0x81, 0x02, 0xa5, 0x98, 0xe0, 0xc1, 0x4c,
0x96, 0x69, 0xa0, 0x40, 0x56, 0x2c, 0x05, 0x52, 0x4a, 0xa1, 0x05, 0xbe, 0xca, 0x41, 0x90, 0x5c,
0x91, 0x2a, 0x24, 0x4e, 0x35, 0xe8, 0x57, 0x61, 0x20, 0x21, 0x57, 0x56, 0xae, 0xeb, 0x12, 0x94,
0x15, 0x0f, 0x6e, 0x98, 0x2c, 0x63, 0x3f, 0x77, 0xb8, 0xf5, 0xc7, 0x47, 0x9b, 0xcf, 0x24, 0xc4,
0x1a, 0x28, 0x7c, 0x39, 0x02, 0xa5, 0xf1, 0x0e, 0x5a, 0x4b, 0x44, 0x56, 0xf7, 0xbd, 0x91, 0x77,
0xaf, 0x13, 0x6e, 0x93, 0x73, 0xad, 0xc8, 0x82, 0x9e, 0xec, 0x8a, 0xac, 0xa6, 0xc6, 0x82, 0x5f,
0xa0, 0x4e, 0x01, 0x3a, 0x8e, 0x0e, 0x20, 0xce, 0x40, 0xf6, 0x7d, 0x93, 0x70, 0x67, 0x21, 0xc1,
0x6e, 0xe1, 0xbc, 0xfb, 0xa0, 0xe3, 0x97, 0x46, 0x4b, 0x51, 0x71, 0xf2, 0x8d, 0xdf, 0xa3, 0xcd,
0x0a, 0x24, 0xcb, 0xeb, 0xe3, 0xa0, 0xcb, 0x26, 0xe8, 0xfe, 0xc5, 0x41, 0x1f, 0x1b, 0x39, 0x4b,
0x63, 0xcd, 0x04, 0x77, 0x81, 0x5d, 0x1b, 0x61, 0xab, 0xc1, 0x37, 0xb4, 0xd6, 0xcc, 0x89, 0x43,
0xb4, 0x21, 0xbe, 0x72, 0x90, 0x11, 0xcb, 0xdc, 0x82, 0xd7, 0x4f, 0xa5, 0x36, 0xfc, 0xc8, 0xdb,
0xe6, 0x7c, 0xf2, 0x9c, 0x5e, 0x31, 0xc2, 0x49, 0x86, 0x9f, 0xa0, 0x8d, 0xcf, 0x2c, 0x07, 0xcd,
0x0a, 0x70, 0x2b, 0x8d, 0x5a, 0x26, 0xf9, 0x20, 0x0e, 0x81, 0xbf, 0x76, 0x3a, 0x7a, 0xe2, 0xd8,
0xfa, 0xe1, 0xa3, 0xde, 0x31, 0x30, 0x55, 0x0a, 0xae, 0x00, 0x3f, 0x5a, 0x20, 0x7c, 0x77, 0x09,
0x61, 0x6b, 0x38, 0x8d, 0x78, 0xaf, 0x0d, 0xf1, 0x76, 0x2b, 0x19, 0x6b, 0xbe, 0x80, 0x31, 0x6d,
0x67, 0x3c, 0x5e, 0x92, 0xb4, 0x12, 0xf2, 0x43, 0x07, 0xb9, 0x87, 0x7c, 0x87, 0xb7, 0x4b, 0x7d,
0x96, 0xe1, 0x5b, 0xa8, 0xe3, 0x16, 0x8b, 0x0e, 0xa1, 0x36, 0x33, 0x77, 0x29, 0x72, 0xbf, 0x5e,
0x41, 0x1d, 0x46, 0xa8, 0x37, 0xb5, 0xd5, 0xd4, 0xf6, 0xc4, 0xfb, 0x68, 0xdd, 0x32, 0xc0, 0xa3,
0x55, 0x17, 0x70, 0x70, 0x7b, 0x25, 0xc0, 0xdd, 0xe4, 0xd7, 0x7c, 0xe8, 0xfd, 0x9e, 0x0f, 0xbd,
0xbf, 0xf3, 0xa1, 0xf7, 0xfd, 0xdf, 0xf0, 0xd2, 0xa7, 0x9d, 0x19, 0xd3, 0x07, 0x47, 0x09, 0x49,
0x45, 0x11, 0x70, 0x55, 0xa6, 0xe9, 0x38, 0x83, 0x2a, 0xe0, 0x20, 0x72, 0x35, 0x8e, 0x4b, 0x36,
0x9e, 0x89, 0xe0, 0xcc, 0x13, 0x7c, 0xec, 0x8a, 0x9f, 0xfe, 0xb5, 0x37, 0x20, 0xf6, 0xa6, 0xe4,
0xe9, 0xbb, 0x49, 0xd3, 0xd2, 0x4d, 0x9e, 0xac, 0x9b, 0x07, 0xf5, 0xe0, 0x7f, 0x00, 0x00, 0x00,
0xff, 0xff, 0x9a, 0x12, 0x33, 0x00, 0xbb, 0x03, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.