Recompile proto files with neofs-api jindo-rc-1

Signed-off-by: Alex Vanin <alexey@nspcc.ru>
This commit is contained in:
Alex Vanin 2020-08-20 10:49:12 +03:00 committed by Stanislav Bogatyrev
parent bcacfb9cf6
commit 556be90818
10 changed files with 2419 additions and 1837 deletions

View file

@ -8,7 +8,7 @@ import (
fmt "fmt"
proto "github.com/golang/protobuf/proto"
grpc1 "github.com/nspcc-dev/neofs-api-go/v2/refs/grpc"
grpc "github.com/nspcc-dev/neofs-api-go/v2/service/grpc"
grpc "github.com/nspcc-dev/neofs-api-go/v2/session/grpc"
grpc2 "google.golang.org/grpc"
codes "google.golang.org/grpc/codes"
status "google.golang.org/grpc/status"
@ -285,35 +285,35 @@ func init() {
func init() { proto.RegisterFile("v2/accounting/grpc/service.proto", fileDescriptor_d9dd5af2ff2bbb25) }
var fileDescriptor_d9dd5af2ff2bbb25 = []byte{
// 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,
// 442 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x93, 0xdb, 0x6a, 0xd4, 0x40,
0x1c, 0xc6, 0x4d, 0x2c, 0xae, 0x4c, 0x3d, 0xe0, 0x20, 0x74, 0x89, 0x18, 0x4a, 0x69, 0x41, 0xc5,
0xcc, 0x40, 0xbc, 0x10, 0x14, 0x2d, 0x5d, 0x6a, 0x71, 0x2f, 0x3c, 0xa5, 0xd0, 0x0b, 0x6f, 0xca,
0x64, 0xf2, 0x4f, 0x3a, 0xb4, 0x99, 0x89, 0x99, 0xd9, 0x48, 0xde, 0xc4, 0x17, 0xf0, 0xc6, 0x0b,
0x9f, 0xc3, 0x4b, 0x1f, 0x41, 0xd6, 0x17, 0x91, 0x1c, 0xf6, 0xc4, 0x66, 0xdd, 0xbd, 0xcb, 0xf0,
0xff, 0xbe, 0x2f, 0xff, 0xef, 0xc7, 0x0c, 0xda, 0x2d, 0x7c, 0xca, 0x38, 0x57, 0x23, 0x69, 0x84,
0x4c, 0x68, 0x92, 0x67, 0x9c, 0x6a, 0xc8, 0x0b, 0xc1, 0x81, 0x64, 0xb9, 0x32, 0x0a, 0xdf, 0x97,
0xa0, 0x48, 0xac, 0x49, 0xe1, 0x93, 0x99, 0xd0, 0x71, 0x3b, 0x7c, 0xa6, 0xcc, 0x40, 0x37, 0x2e,
0xa7, 0x5f, 0xf8, 0x34, 0x87, 0x58, 0x2f, 0x4f, 0x1e, 0x14, 0x3e, 0xd5, 0xa0, 0xb5, 0x50, 0x72,
0x69, 0xb8, 0xf7, 0xdd, 0x46, 0x77, 0x06, 0xec, 0x8a, 0x49, 0x0e, 0x01, 0x7c, 0x19, 0x81, 0x36,
0xf8, 0x15, 0xda, 0x0a, 0x55, 0x54, 0xf6, 0xad, 0x5d, 0xeb, 0xd1, 0xb6, 0xff, 0x98, 0x74, 0xad,
0x43, 0x16, 0x3d, 0x64, 0xa0, 0xa2, 0x32, 0xa8, 0x6d, 0xf8, 0x0d, 0xda, 0x4e, 0xc1, 0xb0, 0xf3,
0x0b, 0x60, 0x11, 0xe4, 0x7d, 0xbb, 0x4e, 0xd9, 0x9f, 0x4b, 0x69, 0x77, 0x21, 0xad, 0xf7, 0x1d,
0x18, 0xf6, 0xb6, 0xd6, 0x06, 0x28, 0x9d, 0x7e, 0xe3, 0x4f, 0xe8, 0x76, 0x01, 0xb9, 0x88, 0xcb,
0x49, 0xd0, 0xf5, 0x3a, 0xe8, 0xe9, 0xea, 0xa0, 0xb3, 0x4a, 0x2e, 0x38, 0x33, 0x42, 0xc9, 0x36,
0xf0, 0x56, 0x13, 0xd1, 0x9c, 0x9c, 0x17, 0x68, 0xab, 0xda, 0x13, 0xfb, 0xe8, 0xa6, 0xfa, 0x2a,
0x21, 0x3f, 0x17, 0x51, 0x5b, 0x72, 0x67, 0x2e, 0xb5, 0x82, 0x48, 0x3e, 0x54, 0xf3, 0xe1, 0x71,
0xd0, 0xab, 0x85, 0xc3, 0x68, 0xef, 0xa7, 0x8d, 0xee, 0x4e, 0x3b, 0xeb, 0x4c, 0x49, 0x0d, 0xf8,
0xf5, 0x02, 0xa8, 0x27, 0x6b, 0x40, 0x35, 0xa6, 0x79, 0x52, 0x27, 0x5d, 0xa4, 0x0e, 0x3a, 0x0b,
0x36, 0xe6, 0x15, 0xa8, 0x82, 0x6e, 0x54, 0xde, 0x7f, 0x92, 0xd6, 0xb2, 0x3a, 0x6c, 0x59, 0x3d,
0x47, 0xbd, 0xb0, 0x69, 0xd0, 0xd6, 0x7c, 0xd8, 0x5d, 0xf3, 0x18, 0xb8, 0x48, 0xd9, 0x55, 0x30,
0x51, 0xfb, 0x97, 0xe8, 0xde, 0xd1, 0x74, 0x7c, 0xda, 0x5c, 0x70, 0x7c, 0x86, 0x7a, 0x2d, 0x0f,
0xbc, 0xbf, 0xc9, 0xbd, 0x72, 0x0e, 0x36, 0x82, 0x3a, 0xb8, 0xfc, 0x35, 0x76, 0xad, 0xdf, 0x63,
0xd7, 0xfa, 0x33, 0x76, 0xad, 0x6f, 0x7f, 0xdd, 0x6b, 0x9f, 0x0f, 0x13, 0x61, 0x2e, 0x46, 0x21,
0xe1, 0x2a, 0xa5, 0x52, 0x67, 0x9c, 0x7b, 0x11, 0x14, 0x54, 0x82, 0x8a, 0xb5, 0xc7, 0x32, 0xe1,
0x25, 0x8a, 0x2e, 0x3f, 0xa8, 0x97, 0xb3, 0xf3, 0x0f, 0x7b, 0xe7, 0x3d, 0xa8, 0x93, 0x53, 0x72,
0xf4, 0x71, 0x58, 0xfd, 0x7c, 0xd6, 0x25, 0xbc, 0x51, 0xbf, 0x9c, 0x67, 0xff, 0x02, 0x00, 0x00,
0xff, 0xff, 0x54, 0x53, 0x6d, 0x41, 0xca, 0x03, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.

View file

@ -477,6 +477,198 @@ func (m *EACLTable) GetRecords() []*EACLRecord {
return nil
}
// BearerToken has information about request ACL rules with limited lifetime
type BearerToken struct {
// Bearer Token body
Body *BearerToken_Body `protobuf:"bytes,1,opt,name=body,proto3" json:"body,omitempty"`
// Signature of BearerToken body
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 *BearerToken) Reset() { *m = BearerToken{} }
func (m *BearerToken) String() string { return proto.CompactTextString(m) }
func (*BearerToken) ProtoMessage() {}
func (*BearerToken) Descriptor() ([]byte, []int) {
return fileDescriptor_8233b6696fb3e24f, []int{2}
}
func (m *BearerToken) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *BearerToken) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_BearerToken.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 *BearerToken) XXX_Merge(src proto.Message) {
xxx_messageInfo_BearerToken.Merge(m, src)
}
func (m *BearerToken) XXX_Size() int {
return m.Size()
}
func (m *BearerToken) XXX_DiscardUnknown() {
xxx_messageInfo_BearerToken.DiscardUnknown(m)
}
var xxx_messageInfo_BearerToken proto.InternalMessageInfo
func (m *BearerToken) GetBody() *BearerToken_Body {
if m != nil {
return m.Body
}
return nil
}
func (m *BearerToken) GetSignature() *grpc.Signature {
if m != nil {
return m.Signature
}
return nil
}
// Bearer Token body
type BearerToken_Body struct {
// EACLTable carries table of extended ACL rules
EaclTable *EACLTable `protobuf:"bytes,1,opt,name=eacl_table,json=eaclTable,proto3" json:"eacl_table,omitempty"`
// OwnerID carries identifier of the token owner
OwnerId *grpc.OwnerID `protobuf:"bytes,2,opt,name=owner_id,json=ownerId,proto3" json:"owner_id,omitempty"`
// Token expiration and valid time period parameters
Lifetime *BearerToken_Body_TokenLifetime `protobuf:"bytes,3,opt,name=lifetime,proto3" json:"lifetime,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *BearerToken_Body) Reset() { *m = BearerToken_Body{} }
func (m *BearerToken_Body) String() string { return proto.CompactTextString(m) }
func (*BearerToken_Body) ProtoMessage() {}
func (*BearerToken_Body) Descriptor() ([]byte, []int) {
return fileDescriptor_8233b6696fb3e24f, []int{2, 0}
}
func (m *BearerToken_Body) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *BearerToken_Body) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_BearerToken_Body.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *BearerToken_Body) XXX_Merge(src proto.Message) {
xxx_messageInfo_BearerToken_Body.Merge(m, src)
}
func (m *BearerToken_Body) XXX_Size() int {
return m.Size()
}
func (m *BearerToken_Body) XXX_DiscardUnknown() {
xxx_messageInfo_BearerToken_Body.DiscardUnknown(m)
}
var xxx_messageInfo_BearerToken_Body proto.InternalMessageInfo
func (m *BearerToken_Body) GetEaclTable() *EACLTable {
if m != nil {
return m.EaclTable
}
return nil
}
func (m *BearerToken_Body) GetOwnerId() *grpc.OwnerID {
if m != nil {
return m.OwnerId
}
return nil
}
func (m *BearerToken_Body) GetLifetime() *BearerToken_Body_TokenLifetime {
if m != nil {
return m.Lifetime
}
return nil
}
// Lifetime parameters of the token. Filed names taken from rfc7519.
type BearerToken_Body_TokenLifetime struct {
// Expiration Epoch
Exp uint64 `protobuf:"varint,1,opt,name=exp,proto3" json:"exp,omitempty"`
// Not valid before Epoch
Nbf uint64 `protobuf:"varint,2,opt,name=nbf,proto3" json:"nbf,omitempty"`
// Issued at Epoch
Iat uint64 `protobuf:"varint,3,opt,name=iat,proto3" json:"iat,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *BearerToken_Body_TokenLifetime) Reset() { *m = BearerToken_Body_TokenLifetime{} }
func (m *BearerToken_Body_TokenLifetime) String() string { return proto.CompactTextString(m) }
func (*BearerToken_Body_TokenLifetime) ProtoMessage() {}
func (*BearerToken_Body_TokenLifetime) Descriptor() ([]byte, []int) {
return fileDescriptor_8233b6696fb3e24f, []int{2, 0, 0}
}
func (m *BearerToken_Body_TokenLifetime) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *BearerToken_Body_TokenLifetime) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_BearerToken_Body_TokenLifetime.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 *BearerToken_Body_TokenLifetime) XXX_Merge(src proto.Message) {
xxx_messageInfo_BearerToken_Body_TokenLifetime.Merge(m, src)
}
func (m *BearerToken_Body_TokenLifetime) XXX_Size() int {
return m.Size()
}
func (m *BearerToken_Body_TokenLifetime) XXX_DiscardUnknown() {
xxx_messageInfo_BearerToken_Body_TokenLifetime.DiscardUnknown(m)
}
var xxx_messageInfo_BearerToken_Body_TokenLifetime proto.InternalMessageInfo
func (m *BearerToken_Body_TokenLifetime) GetExp() uint64 {
if m != nil {
return m.Exp
}
return 0
}
func (m *BearerToken_Body_TokenLifetime) GetNbf() uint64 {
if m != nil {
return m.Nbf
}
return 0
}
func (m *BearerToken_Body_TokenLifetime) GetIat() uint64 {
if m != nil {
return m.Iat
}
return 0
}
func init() {
proto.RegisterEnum("neo.fs.v2.acl.Target", Target_name, Target_value)
proto.RegisterEnum("neo.fs.v2.acl.MatchType", MatchType_name, MatchType_value)
@ -487,56 +679,69 @@ func init() {
proto.RegisterType((*EACLRecord_FilterInfo)(nil), "neo.fs.v2.acl.EACLRecord.FilterInfo")
proto.RegisterType((*EACLRecord_TargetInfo)(nil), "neo.fs.v2.acl.EACLRecord.TargetInfo")
proto.RegisterType((*EACLTable)(nil), "neo.fs.v2.acl.EACLTable")
proto.RegisterType((*BearerToken)(nil), "neo.fs.v2.acl.BearerToken")
proto.RegisterType((*BearerToken_Body)(nil), "neo.fs.v2.acl.BearerToken.Body")
proto.RegisterType((*BearerToken_Body_TokenLifetime)(nil), "neo.fs.v2.acl.BearerToken.Body.TokenLifetime")
}
func init() { proto.RegisterFile("v2/acl/grpc/types.proto", fileDescriptor_8233b6696fb3e24f) }
var fileDescriptor_8233b6696fb3e24f = []byte{
// 703 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x54, 0xd1, 0x6e, 0xda, 0x48,
0x14, 0x8d, 0x6d, 0x62, 0xc2, 0x85, 0x5d, 0x8d, 0x46, 0x1b, 0xd6, 0x61, 0x25, 0x84, 0xa2, 0x7d,
0x40, 0xac, 0x30, 0x5a, 0xa2, 0xec, 0x3e, 0x54, 0x8d, 0xe4, 0xc0, 0x04, 0x68, 0x89, 0x4d, 0xc6,
0x43, 0xaa, 0xf4, 0x05, 0x39, 0x66, 0x20, 0xa8, 0xc6, 0x46, 0xb6, 0x83, 0x44, 0x9f, 0xfa, 0x19,
0xfd, 0x86, 0x3e, 0xf6, 0x2b, 0xfa, 0xd8, 0x4f, 0xa8, 0xd2, 0xcf, 0xe8, 0x4b, 0x65, 0x1b, 0x02,
0x75, 0x2a, 0xf5, 0xc9, 0xd7, 0x73, 0xcf, 0x39, 0xf7, 0xcc, 0xf1, 0x78, 0xe0, 0xcf, 0x65, 0xb3,
0x61, 0xd9, 0x4e, 0x63, 0xea, 0x2f, 0xec, 0x46, 0xb8, 0x5a, 0xf0, 0x40, 0x5d, 0xf8, 0x5e, 0xe8,
0xe1, 0xdf, 0x5c, 0xee, 0xa9, 0x93, 0x40, 0x5d, 0x36, 0x55, 0xcb, 0x76, 0x4a, 0xca, 0xb2, 0xd9,
0xf0, 0xf9, 0x24, 0x78, 0x02, 0x3c, 0xfe, 0x26, 0x01, 0x10, 0xad, 0xd5, 0xa7, 0xdc, 0xf6, 0xfc,
0x31, 0xfe, 0x0f, 0x72, 0xde, 0x82, 0xfb, 0x56, 0x38, 0xf3, 0x5c, 0x45, 0xa8, 0x08, 0xd5, 0xdf,
0x9b, 0x8a, 0xfa, 0x83, 0x96, 0x6a, 0x6c, 0xfa, 0x34, 0xf7, 0x58, 0xe2, 0x3a, 0xc8, 0x96, 0x1d,
0x93, 0xc4, 0x98, 0x74, 0x98, 0x22, 0x69, 0x71, 0x93, 0xca, 0xc9, 0x13, 0x9f, 0x41, 0x76, 0x32,
0x73, 0x42, 0xee, 0x07, 0x8a, 0x54, 0x91, 0xaa, 0xf9, 0xe6, 0xdf, 0x29, 0xfc, 0xd6, 0x92, 0x7a,
0x11, 0x03, 0x7b, 0xee, 0xc4, 0xa3, 0xd9, 0xa4, 0x0e, 0x22, 0x7e, 0x68, 0xf9, 0x53, 0x1e, 0x06,
0x4a, 0xe6, 0x57, 0x7c, 0x16, 0x03, 0x13, 0x7e, 0x52, 0x07, 0xa5, 0x8f, 0x02, 0xc0, 0x56, 0x17,
0x9f, 0x82, 0x7c, 0xc7, 0xad, 0x31, 0xf7, 0xd7, 0x5b, 0x3e, 0x4a, 0xa9, 0x75, 0xe3, 0x26, 0x5b,
0x2d, 0x38, 0x85, 0x6d, 0x8d, 0xff, 0x07, 0x98, 0x5b, 0xa1, 0x7d, 0x37, 0x8a, 0x02, 0x5d, 0x6f,
0x3c, 0x9d, 0xd6, 0x65, 0x04, 0x88, 0x99, 0xb9, 0xc7, 0x12, 0x1f, 0x41, 0x3e, 0x99, 0x37, 0x72,
0xad, 0x39, 0x57, 0xa4, 0x8a, 0x50, 0xcd, 0xd1, 0x8c, 0x6e, 0xcd, 0xa3, 0x16, 0xac, 0x5b, 0x4b,
0xcb, 0x51, 0x32, 0x71, 0x67, 0xff, 0xda, 0x72, 0xee, 0x79, 0xe9, 0x0a, 0x60, 0xbb, 0x17, 0xfc,
0x0f, 0xc8, 0x49, 0x04, 0x6b, 0xcf, 0xe9, 0xc4, 0x13, 0x28, 0xcd, 0x50, 0xcf, 0xe1, 0xb8, 0x08,
0x07, 0x6f, 0xf8, 0x6a, 0xe4, 0xcc, 0x82, 0x50, 0x11, 0x2b, 0x52, 0xb5, 0x40, 0x33, 0x2f, 0xf9,
0x2a, 0x38, 0x7e, 0x27, 0x40, 0x2e, 0x8a, 0x8a, 0x59, 0xb7, 0x0e, 0xc7, 0x67, 0x50, 0xb0, 0x3d,
0x37, 0xb4, 0x66, 0x2e, 0xf7, 0x47, 0xb3, 0x71, 0x2c, 0x9c, 0x6f, 0xfe, 0xb5, 0x23, 0x1c, 0x9d,
0x21, 0xb5, 0xb5, 0xc1, 0xf4, 0xda, 0x34, 0xbf, 0xf3, 0x82, 0x4f, 0x20, 0xeb, 0xc7, 0x99, 0x07,
0xf1, 0x90, 0xfc, 0x93, 0x1c, 0xb7, 0x5f, 0x85, 0x66, 0x93, 0x67, 0x50, 0x3b, 0x07, 0x39, 0xb1,
0x8a, 0x8b, 0x80, 0x99, 0x46, 0x3b, 0x84, 0x8d, 0x86, 0xba, 0x39, 0x20, 0xad, 0xde, 0x45, 0x8f,
0xb4, 0xd1, 0x1e, 0x3e, 0x80, 0xcc, 0xd0, 0x24, 0x14, 0x09, 0x18, 0x40, 0x36, 0x6f, 0x4c, 0x46,
0x2e, 0x91, 0x18, 0xd5, 0x06, 0xeb, 0x12, 0x6a, 0x22, 0xa9, 0x66, 0xc0, 0x4e, 0xb8, 0x25, 0x28,
0x5e, 0x6a, 0xac, 0xd5, 0x1d, 0xb1, 0x9b, 0x01, 0x49, 0x49, 0x21, 0x28, 0x98, 0x8c, 0xf6, 0xf4,
0xce, 0x88, 0x5c, 0x0d, 0xb5, 0x3e, 0x12, 0xf0, 0x1f, 0x80, 0xd6, 0x2b, 0xba, 0xc1, 0xd6, 0xab,
0x62, 0xed, 0x2d, 0xec, 0x9c, 0xed, 0x23, 0x38, 0x34, 0x06, 0x84, 0x6a, 0xac, 0x67, 0xe8, 0x29,
0xbd, 0x2c, 0x48, 0x1d, 0xc2, 0x90, 0x10, 0x79, 0xec, 0x12, 0xad, 0x8d, 0xc4, 0x68, 0x69, 0x30,
0x64, 0x48, 0x8a, 0x0c, 0xb6, 0x49, 0x9f, 0x30, 0x82, 0x32, 0xb1, 0x71, 0xa2, 0xd1, 0x56, 0x17,
0xed, 0xe3, 0x02, 0x1c, 0x74, 0x08, 0xa3, 0x9a, 0xde, 0x21, 0x48, 0x8e, 0x1c, 0x6d, 0xde, 0xba,
0x9a, 0xd9, 0x45, 0xd9, 0xda, 0x29, 0x6c, 0xfe, 0x92, 0x22, 0x60, 0xad, 0xf5, 0x93, 0xa9, 0x39,
0xd8, 0xd7, 0xfa, 0x7d, 0xe3, 0x55, 0x32, 0xb7, 0x4d, 0xf4, 0x1b, 0x24, 0xd6, 0x9e, 0xc3, 0xee,
0xd1, 0x2c, 0x02, 0x8e, 0xfc, 0x10, 0x9a, 0xa2, 0xe6, 0x21, 0x4b, 0xc9, 0xd5, 0x90, 0x98, 0x2c,
0x89, 0xd3, 0x38, 0x7f, 0x41, 0x5a, 0x0c, 0x89, 0xe7, 0xd7, 0x9f, 0x1e, 0xca, 0xc2, 0xe7, 0x87,
0xb2, 0xf0, 0xe5, 0xa1, 0x2c, 0xbc, 0xff, 0x5a, 0xde, 0x7b, 0xfd, 0xef, 0x74, 0x16, 0xde, 0xdd,
0xdf, 0xaa, 0xb6, 0x37, 0x6f, 0xb8, 0xc1, 0xc2, 0xb6, 0xeb, 0x63, 0xbe, 0x6c, 0xb8, 0xdc, 0x9b,
0x04, 0x75, 0x6b, 0x31, 0xab, 0x4f, 0xbd, 0xc6, 0xce, 0xed, 0xf3, 0xcc, 0xb2, 0x9d, 0x0f, 0x22,
0xd2, 0xb9, 0x77, 0x61, 0xaa, 0xda, 0xa0, 0x17, 0x7d, 0x72, 0xcd, 0x76, 0x6e, 0xe5, 0xf8, 0x9a,
0x39, 0xf9, 0x1e, 0x00, 0x00, 0xff, 0xff, 0xef, 0xd5, 0x9b, 0x33, 0xaa, 0x04, 0x00, 0x00,
// 862 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x55, 0xdd, 0x6e, 0xe2, 0x46,
0x18, 0x5d, 0x63, 0x87, 0x9f, 0x8f, 0x6c, 0x65, 0x8d, 0xba, 0x2c, 0xa1, 0x52, 0x1a, 0x45, 0xbd,
0x88, 0xa8, 0x30, 0x2a, 0xd1, 0x76, 0x2f, 0xaa, 0xae, 0x64, 0x60, 0x02, 0xb4, 0x04, 0x93, 0xf1,
0xb0, 0x55, 0x7a, 0x83, 0x06, 0x33, 0x10, 0x6b, 0x1d, 0x1b, 0xd9, 0x0e, 0x5b, 0x7a, 0x55, 0xa9,
0xea, 0x3b, 0xf4, 0x19, 0x7a, 0xd9, 0xa7, 0xe8, 0x65, 0x1f, 0xa1, 0x4a, 0x1f, 0xa3, 0x37, 0xd5,
0x8c, 0x4d, 0x20, 0xde, 0x95, 0x72, 0xc5, 0xe7, 0xf9, 0xce, 0xf9, 0xce, 0x99, 0x33, 0xa3, 0x01,
0x5e, 0xae, 0x5b, 0x4d, 0xe6, 0x78, 0xcd, 0x65, 0xb8, 0x72, 0x9a, 0xf1, 0x66, 0xc5, 0x23, 0x63,
0x15, 0x06, 0x71, 0x80, 0x9e, 0xfb, 0x3c, 0x30, 0x16, 0x91, 0xb1, 0x6e, 0x19, 0xcc, 0xf1, 0x6a,
0xd5, 0x75, 0xab, 0x19, 0xf2, 0x45, 0xf4, 0x01, 0xf0, 0xf4, 0x3f, 0x15, 0x00, 0x9b, 0x9d, 0x21,
0xe1, 0x4e, 0x10, 0xce, 0xd1, 0xd7, 0x50, 0x0a, 0x56, 0x3c, 0x64, 0xb1, 0x1b, 0xf8, 0x55, 0xe5,
0x44, 0x39, 0xfb, 0xa4, 0x55, 0x35, 0x1e, 0xcd, 0x32, 0xac, 0x6d, 0x9f, 0x94, 0x1e, 0x4a, 0xd4,
0x80, 0x3c, 0x73, 0x24, 0x29, 0x27, 0x49, 0x2f, 0x32, 0x24, 0x53, 0x36, 0x49, 0x3e, 0xf9, 0x45,
0x6f, 0xa0, 0xb0, 0x70, 0xbd, 0x98, 0x87, 0x51, 0x55, 0x3d, 0x51, 0xcf, 0xca, 0xad, 0x2f, 0x32,
0xf8, 0x9d, 0x25, 0xe3, 0x42, 0x02, 0x07, 0xfe, 0x22, 0x20, 0x85, 0xa4, 0x8e, 0x04, 0x3f, 0x66,
0xe1, 0x92, 0xc7, 0x51, 0x55, 0x7b, 0x8a, 0x4f, 0x25, 0x30, 0xe1, 0x27, 0x75, 0x54, 0xfb, 0x53,
0x01, 0xd8, 0xcd, 0x45, 0xaf, 0x20, 0x7f, 0xc3, 0xd9, 0x9c, 0x87, 0xe9, 0x96, 0x8f, 0x32, 0xd3,
0xfa, 0xb2, 0x49, 0x37, 0x2b, 0x4e, 0x60, 0x57, 0xa3, 0xd7, 0x00, 0xb7, 0x2c, 0x76, 0x6e, 0xa6,
0x22, 0xd0, 0x74, 0xe3, 0xd9, 0xb4, 0x2e, 0x05, 0x40, 0x32, 0x4b, 0x0f, 0x25, 0x3a, 0x82, 0x72,
0xa2, 0x37, 0xf5, 0xd9, 0x2d, 0xaf, 0xaa, 0x27, 0xca, 0x59, 0x89, 0x68, 0x23, 0x76, 0x2b, 0x5a,
0x90, 0xb6, 0xd6, 0xcc, 0xab, 0x6a, 0xb2, 0x73, 0xf0, 0x96, 0x79, 0x77, 0xbc, 0x76, 0x05, 0xb0,
0xdb, 0x0b, 0xfa, 0x12, 0xf2, 0x49, 0x04, 0xa9, 0xe7, 0x6c, 0xe2, 0x09, 0x94, 0x68, 0x24, 0xf0,
0x38, 0xaa, 0x40, 0xf1, 0x1d, 0xdf, 0x4c, 0x3d, 0x37, 0x8a, 0xab, 0xb9, 0x13, 0xf5, 0xec, 0x90,
0x68, 0xdf, 0xf3, 0x4d, 0x74, 0xfa, 0x8b, 0x02, 0x25, 0x11, 0x15, 0x65, 0x33, 0x8f, 0xa3, 0x37,
0x70, 0xe8, 0x04, 0x7e, 0xcc, 0x5c, 0x9f, 0x87, 0x53, 0x77, 0x2e, 0x07, 0x97, 0x5b, 0x9f, 0xed,
0x0d, 0x16, 0x77, 0xc8, 0xe8, 0x6c, 0x31, 0x83, 0x2e, 0x29, 0xef, 0x7d, 0xa0, 0x73, 0x28, 0x84,
0x32, 0xf3, 0x48, 0x8a, 0x94, 0x3f, 0xc8, 0x71, 0x77, 0x2a, 0xa4, 0x90, 0xfc, 0x46, 0xa7, 0xbf,
0xaa, 0x50, 0x6e, 0x73, 0x16, 0xf2, 0x90, 0x06, 0xef, 0xb8, 0x8f, 0xce, 0x41, 0x9b, 0x05, 0xf3,
0x4d, 0x2a, 0xfe, 0x79, 0x66, 0xc2, 0x1e, 0xd2, 0x68, 0x07, 0xf3, 0x0d, 0x91, 0x60, 0xf4, 0x1a,
0x4a, 0x91, 0xbb, 0xf4, 0x59, 0x7c, 0x17, 0x26, 0x07, 0xf1, 0x58, 0x5b, 0xda, 0xb6, 0xb7, 0x00,
0xb2, 0xc3, 0xd6, 0x7e, 0xcb, 0x81, 0xd6, 0x4e, 0x26, 0x00, 0x67, 0x8e, 0x37, 0x8d, 0x45, 0x12,
0xa9, 0x78, 0xf5, 0x23, 0xf6, 0x65, 0x52, 0xa4, 0x24, 0xb0, 0x49, 0x68, 0x2d, 0x28, 0x06, 0xef,
0xd3, 0xc0, 0x12, 0xe5, 0x97, 0x59, 0x65, 0xeb, 0x7d, 0x12, 0x56, 0x41, 0x02, 0x07, 0x73, 0x34,
0x80, 0xa2, 0xe7, 0x2e, 0x78, 0xec, 0xa6, 0x87, 0x5f, 0x6e, 0x35, 0x9e, 0xd8, 0xa7, 0x21, 0xcb,
0x61, 0x4a, 0x22, 0x0f, 0xf4, 0x1a, 0x86, 0xe7, 0x8f, 0x5a, 0x48, 0x07, 0x95, 0xff, 0xb4, 0x92,
0x3b, 0xd0, 0x88, 0x28, 0xc5, 0x8a, 0x3f, 0x5b, 0x48, 0x73, 0x1a, 0x11, 0xa5, 0x58, 0x71, 0x59,
0x2c, 0xa5, 0x35, 0x22, 0xca, 0x7a, 0x1b, 0xf2, 0xc9, 0x85, 0x41, 0x15, 0x40, 0xd4, 0x24, 0x3d,
0x4c, 0xa7, 0x93, 0x91, 0x3d, 0xc6, 0x9d, 0xc1, 0xc5, 0x00, 0x77, 0xf5, 0x67, 0xa8, 0x08, 0xda,
0xc4, 0xc6, 0x44, 0x57, 0x10, 0x40, 0xde, 0xbe, 0xb6, 0x29, 0xbe, 0xd4, 0x73, 0xa2, 0xb6, 0x68,
0x1f, 0x13, 0x5b, 0x57, 0xeb, 0x16, 0xec, 0x5d, 0xf1, 0x1a, 0x54, 0x2e, 0x4d, 0xda, 0xe9, 0x4f,
0xe9, 0xf5, 0x18, 0x67, 0x46, 0xe9, 0x70, 0x68, 0x53, 0x32, 0x18, 0xf5, 0xa6, 0xf8, 0x6a, 0x62,
0x0e, 0x75, 0x05, 0x7d, 0x0a, 0x7a, 0xba, 0x32, 0xb2, 0x68, 0xba, 0x9a, 0xab, 0xff, 0x0c, 0x7b,
0x2f, 0xcc, 0x11, 0xbc, 0xb0, 0xc6, 0x98, 0x98, 0x74, 0x60, 0x8d, 0x32, 0xf3, 0x0a, 0xa0, 0xf6,
0x30, 0xd5, 0x15, 0xe1, 0xb1, 0x8f, 0xcd, 0xae, 0x9e, 0x13, 0x4b, 0xe3, 0x09, 0xd5, 0x55, 0x61,
0xb0, 0x8b, 0x87, 0x98, 0x62, 0x5d, 0x93, 0xc6, 0xb1, 0x49, 0x3a, 0x7d, 0xfd, 0x00, 0x1d, 0x42,
0xb1, 0x87, 0x29, 0x31, 0x47, 0x3d, 0xac, 0xe7, 0x85, 0xa3, 0xed, 0x57, 0xdf, 0xb4, 0xfb, 0x7a,
0xa1, 0xfe, 0x0a, 0xb6, 0x6f, 0x55, 0x05, 0x90, 0xd9, 0xf9, 0x88, 0x6a, 0x09, 0x0e, 0xcc, 0xe1,
0xd0, 0xfa, 0x21, 0xd1, 0xed, 0xe2, 0xd1, 0xb5, 0x9e, 0xab, 0x7f, 0x0b, 0xfb, 0x0f, 0x44, 0x05,
0x90, 0xf0, 0x83, 0x49, 0x86, 0x5a, 0x86, 0x02, 0xc1, 0x57, 0x13, 0x6c, 0xd3, 0x24, 0x4e, 0xab,
0xfd, 0x1d, 0xee, 0x50, 0x3d, 0xd7, 0x7e, 0xfb, 0xd7, 0xfd, 0xb1, 0xf2, 0xf7, 0xfd, 0xb1, 0xf2,
0xcf, 0xfd, 0xb1, 0xf2, 0xfb, 0xbf, 0xc7, 0xcf, 0x7e, 0xfc, 0x6a, 0xe9, 0xc6, 0x37, 0x77, 0x33,
0xc3, 0x09, 0x6e, 0x9b, 0x7e, 0xb4, 0x72, 0x9c, 0xc6, 0x9c, 0xaf, 0x9b, 0x3e, 0x0f, 0x16, 0x51,
0x83, 0xad, 0xdc, 0xc6, 0x32, 0x68, 0xee, 0xfd, 0x07, 0x7c, 0xc3, 0x1c, 0xef, 0x8f, 0x9c, 0x3e,
0xe2, 0xc1, 0x85, 0x6d, 0x98, 0xe3, 0x81, 0xb8, 0x4e, 0xa6, 0xe3, 0xcd, 0xf2, 0xf2, 0xb1, 0x3f,
0xff, 0x3f, 0x00, 0x00, 0xff, 0xff, 0x0d, 0x9c, 0x67, 0x62, 0x30, 0x06, 0x00, 0x00,
}
func (m *EACLRecord) Marshal() (dAtA []byte, err error) {
@ -749,6 +954,162 @@ func (m *EACLTable) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil
}
func (m *BearerToken) 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 *BearerToken) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *BearerToken) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if m.XXX_unrecognized != nil {
i -= len(m.XXX_unrecognized)
copy(dAtA[i:], m.XXX_unrecognized)
}
if m.Signature != nil {
{
size, err := m.Signature.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintTypes(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x12
}
if m.Body != nil {
{
size, err := m.Body.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintTypes(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0xa
}
return len(dAtA) - i, nil
}
func (m *BearerToken_Body) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *BearerToken_Body) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *BearerToken_Body) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if m.XXX_unrecognized != nil {
i -= len(m.XXX_unrecognized)
copy(dAtA[i:], m.XXX_unrecognized)
}
if m.Lifetime != nil {
{
size, err := m.Lifetime.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintTypes(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x1a
}
if m.OwnerId != nil {
{
size, err := m.OwnerId.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintTypes(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x12
}
if m.EaclTable != nil {
{
size, err := m.EaclTable.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintTypes(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0xa
}
return len(dAtA) - i, nil
}
func (m *BearerToken_Body_TokenLifetime) 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 *BearerToken_Body_TokenLifetime) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *BearerToken_Body_TokenLifetime) 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.Iat != 0 {
i = encodeVarintTypes(dAtA, i, uint64(m.Iat))
i--
dAtA[i] = 0x18
}
if m.Nbf != 0 {
i = encodeVarintTypes(dAtA, i, uint64(m.Nbf))
i--
dAtA[i] = 0x10
}
if m.Exp != 0 {
i = encodeVarintTypes(dAtA, i, uint64(m.Exp))
i--
dAtA[i] = 0x8
}
return len(dAtA) - i, nil
}
func encodeVarintTypes(dAtA []byte, offset int, v uint64) int {
offset -= sovTypes(v)
base := offset
@ -859,6 +1220,71 @@ func (m *EACLTable) Size() (n int) {
return n
}
func (m *BearerToken) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
if m.Body != nil {
l = m.Body.Size()
n += 1 + l + sovTypes(uint64(l))
}
if m.Signature != nil {
l = m.Signature.Size()
n += 1 + l + sovTypes(uint64(l))
}
if m.XXX_unrecognized != nil {
n += len(m.XXX_unrecognized)
}
return n
}
func (m *BearerToken_Body) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
if m.EaclTable != nil {
l = m.EaclTable.Size()
n += 1 + l + sovTypes(uint64(l))
}
if m.OwnerId != nil {
l = m.OwnerId.Size()
n += 1 + l + sovTypes(uint64(l))
}
if m.Lifetime != nil {
l = m.Lifetime.Size()
n += 1 + l + sovTypes(uint64(l))
}
if m.XXX_unrecognized != nil {
n += len(m.XXX_unrecognized)
}
return n
}
func (m *BearerToken_Body_TokenLifetime) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
if m.Exp != 0 {
n += 1 + sovTypes(uint64(m.Exp))
}
if m.Nbf != 0 {
n += 1 + sovTypes(uint64(m.Nbf))
}
if m.Iat != 0 {
n += 1 + sovTypes(uint64(m.Iat))
}
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
}
@ -1410,6 +1836,405 @@ func (m *EACLTable) Unmarshal(dAtA []byte) error {
}
return nil
}
func (m *BearerToken) 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: BearerToken: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: BearerToken: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthTypes
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthTypes
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Body == nil {
m.Body = &BearerToken_Body{}
}
if err := m.Body.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthTypes
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthTypes
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Signature == nil {
m.Signature = &grpc.Signature{}
}
if err := m.Signature.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
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 (m *BearerToken_Body) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return 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: Body: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: Body: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field EaclTable", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthTypes
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthTypes
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.EaclTable == nil {
m.EaclTable = &EACLTable{}
}
if err := m.EaclTable.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
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 ErrIntOverflowTypes
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthTypes
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthTypes
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.OwnerId == nil {
m.OwnerId = &grpc.OwnerID{}
}
if err := m.OwnerId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Lifetime", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthTypes
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthTypes
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Lifetime == nil {
m.Lifetime = &BearerToken_Body_TokenLifetime{}
}
if err := m.Lifetime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
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 (m *BearerToken_Body_TokenLifetime) 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: TokenLifetime: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: TokenLifetime: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Exp", wireType)
}
m.Exp = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.Exp |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
case 2:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Nbf", wireType)
}
m.Nbf = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.Nbf |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
case 3:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Iat", wireType)
}
m.Iat = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.Iat |= uint64(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

View file

@ -9,7 +9,7 @@ import (
proto "github.com/golang/protobuf/proto"
grpc2 "github.com/nspcc-dev/neofs-api-go/v2/acl/grpc"
grpc1 "github.com/nspcc-dev/neofs-api-go/v2/refs/grpc"
grpc "github.com/nspcc-dev/neofs-api-go/v2/service/grpc"
grpc "github.com/nspcc-dev/neofs-api-go/v2/session/grpc"
grpc3 "google.golang.org/grpc"
codes "google.golang.org/grpc/codes"
status "google.golang.org/grpc/status"
@ -104,10 +104,10 @@ type PutRequest_Body struct {
// Container to create in NeoFS.
Container *Container `protobuf:"bytes,1,opt,name=container,proto3" json:"container,omitempty"`
//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:"-"`
Signature *grpc1.Signature `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *PutRequest_Body) Reset() { *m = PutRequest_Body{} }
@ -150,7 +150,7 @@ func (m *PutRequest_Body) GetContainer() *Container {
return nil
}
func (m *PutRequest_Body) GetSignature() *grpc.Signature {
func (m *PutRequest_Body) GetSignature() *grpc1.Signature {
if m != nil {
return m.Signature
}
@ -352,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 *grpc.Signature `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
Signature *grpc1.Signature `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *DeleteRequest_Body) Reset() { *m = DeleteRequest_Body{} }
@ -398,7 +398,7 @@ func (m *DeleteRequest_Body) GetContainerId() *grpc1.ContainerID {
return nil
}
func (m *DeleteRequest_Body) GetSignature() *grpc.Signature {
func (m *DeleteRequest_Body) GetSignature() *grpc1.Signature {
if m != nil {
return m.Signature
}
@ -1067,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 *grpc.Signature `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
Signature *grpc1.Signature `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *SetExtendedACLRequest_Body) Reset() { *m = SetExtendedACLRequest_Body{} }
@ -1113,7 +1113,7 @@ func (m *SetExtendedACLRequest_Body) GetEacl() *grpc2.EACLTable {
return nil
}
func (m *SetExtendedACLRequest_Body) GetSignature() *grpc.Signature {
func (m *SetExtendedACLRequest_Body) GetSignature() *grpc1.Signature {
if m != nil {
return m.Signature
}
@ -1424,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 *grpc.Signature `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
Signature *grpc1.Signature `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *GetExtendedACLResponse_Body) Reset() { *m = GetExtendedACLResponse_Body{} }
@ -1470,7 +1470,7 @@ func (m *GetExtendedACLResponse_Body) GetEacl() *grpc2.EACLTable {
return nil
}
func (m *GetExtendedACLResponse_Body) GetSignature() *grpc.Signature {
func (m *GetExtendedACLResponse_Body) GetSignature() *grpc1.Signature {
if m != nil {
return m.Signature
}
@ -1507,58 +1507,59 @@ func init() {
func init() { proto.RegisterFile("v2/container/grpc/service.proto", fileDescriptor_364186d99410ec35) }
var fileDescriptor_364186d99410ec35 = []byte{
// 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,
// 821 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x98, 0xcf, 0x6e, 0xd3, 0x58,
0x14, 0xc6, 0x27, 0x6e, 0xd4, 0x99, 0x9e, 0xa4, 0xd5, 0xc8, 0xa3, 0xb6, 0x99, 0x54, 0x93, 0x66,
0x3c, 0xd3, 0x99, 0x0a, 0x1a, 0x1b, 0x99, 0x05, 0xd0, 0x16, 0x44, 0x9b, 0xb4, 0x6e, 0x44, 0x81,
0xd6, 0x41, 0x2c, 0xd8, 0x54, 0x8e, 0x7d, 0x92, 0x5a, 0x4a, 0xec, 0xe0, 0xeb, 0xb8, 0x64, 0x81,
0x90, 0x78, 0x0a, 0x16, 0x88, 0x35, 0xaa, 0x58, 0xf0, 0x04, 0xac, 0x59, 0xf2, 0x06, 0xa0, 0x22,
0x84, 0xd8, 0xf2, 0x04, 0x28, 0xb6, 0xe3, 0xd8, 0x8d, 0xd3, 0xfc, 0x51, 0x84, 0xe4, 0x5d, 0x22,
0x7f, 0xe7, 0xf8, 0x9c, 0x5f, 0xbe, 0x7b, 0xcf, 0xbd, 0x81, 0x65, 0x8b, 0xe7, 0x64, 0x5d, 0x33,
0x25, 0x55, 0x43, 0x83, 0xab, 0x1a, 0x0d, 0x99, 0x23, 0x68, 0x58, 0xaa, 0x8c, 0x6c, 0xc3, 0xd0,
0x4d, 0x9d, 0xfe, 0x43, 0x43, 0x9d, 0xad, 0x10, 0xd6, 0xe2, 0x59, 0x4f, 0x97, 0x5e, 0xb4, 0x78,
0x4e, 0x92, 0x6b, 0x8e, 0xde, 0x6c, 0x35, 0x90, 0x38, 0xea, 0xf4, 0x5f, 0xbd, 0xe9, 0xfc, 0x8f,
0x53, 0x16, 0xcf, 0x19, 0x58, 0x21, 0xbd, 0x4f, 0x96, 0x2c, 0x9e, 0x23, 0x48, 0x88, 0xaa, 0x6b,
0x3d, 0x0f, 0x99, 0x8f, 0x14, 0xc0, 0x41, 0xd3, 0x14, 0xf1, 0x71, 0x13, 0x89, 0x49, 0x5f, 0x87,
0x78, 0x59, 0x57, 0x5a, 0xa9, 0x58, 0x36, 0xb6, 0x9a, 0xe0, 0xff, 0x65, 0x43, 0x2a, 0x64, 0xbb,
0x72, 0x76, 0x5b, 0x57, 0x5a, 0xa2, 0x1d, 0x41, 0xef, 0x40, 0xa2, 0x8e, 0xa6, 0x74, 0x74, 0x8c,
0x92, 0x82, 0x46, 0x8a, 0xea, 0x49, 0xe0, 0x96, 0xc0, 0xba, 0xb1, 0x77, 0xd1, 0x94, 0xf6, 0x6c,
0xad, 0x08, 0x75, 0xef, 0x33, 0x7d, 0x08, 0xb3, 0x16, 0x1a, 0x6a, 0xa5, 0xd5, 0x49, 0x34, 0x65,
0x27, 0x5a, 0xeb, 0x9f, 0xe8, 0x61, 0x5b, 0xae, 0xca, 0x92, 0xa9, 0xea, 0x9a, 0x9b, 0x30, 0xe9,
0xa4, 0x70, 0xbe, 0xa5, 0x9f, 0x42, 0xbc, 0x5d, 0x27, 0xbd, 0x09, 0x33, 0x5e, 0x13, 0x6e, 0x83,
0x99, 0xd0, 0x06, 0xf3, 0x9d, 0x4f, 0x62, 0x37, 0x80, 0xbe, 0x06, 0x33, 0x44, 0xad, 0x6a, 0x92,
0xd9, 0x34, 0xd0, 0xed, 0xee, 0x4f, 0x5f, 0x74, 0x1b, 0x3d, 0x5b, 0xea, 0x08, 0xc4, 0xae, 0x96,
0x79, 0x43, 0x41, 0xc2, 0x46, 0x46, 0x1a, 0xba, 0x46, 0x90, 0xbe, 0x11, 0x40, 0xbc, 0xd2, 0x1f,
0xb1, 0xa3, 0xf7, 0x33, 0xde, 0x0d, 0x63, 0xbc, 0x12, 0x8a, 0xc6, 0x09, 0xee, 0x03, 0x59, 0x0c,
0x87, 0x9c, 0xbb, 0x20, 0xd3, 0x40, 0xca, 0xbb, 0x2e, 0xe5, 0x5b, 0x90, 0xf4, 0xfa, 0x38, 0x52,
0x15, 0xb7, 0xcd, 0xa5, 0xf3, 0xa8, 0x3c, 0xc6, 0xc5, 0x82, 0x98, 0xf0, 0x02, 0x8a, 0x0a, 0xf3,
0x95, 0x82, 0xd9, 0x02, 0xd6, 0xd0, 0xc4, 0x8e, 0x27, 0x37, 0x02, 0xc0, 0xfe, 0x0f, 0x05, 0x16,
0x88, 0x88, 0x86, 0x2d, 0x9f, 0x4d, 0x06, 0xd8, 0xf8, 0xc6, 0xfc, 0x1e, 0x83, 0xb9, 0x0e, 0x37,
0xd7, 0x9b, 0x9b, 0x01, 0xd4, 0xab, 0x17, 0xa2, 0x8e, 0x96, 0x3d, 0xa7, 0x1d, 0xda, 0xcc, 0x6b,
0x0a, 0x40, 0xc0, 0x91, 0xf6, 0xbb, 0xae, 0x3c, 0x1a, 0xc6, 0x9a, 0xd4, 0x4a, 0x3c, 0xa5, 0x20,
0x61, 0xf7, 0x3e, 0xc2, 0xc6, 0xe5, 0xd3, 0x47, 0xc5, 0x19, 0x85, 0x49, 0x8c, 0x07, 0xe6, 0x15,
0x05, 0x89, 0x7d, 0x95, 0x78, 0xc6, 0x1a, 0x06, 0x96, 0x4f, 0x1f, 0x0d, 0x67, 0xad, 0xbb, 0xa8,
0x78, 0xf8, 0x4d, 0x3f, 0x09, 0xb8, 0x6a, 0xf1, 0xbc, 0xab, 0xee, 0x9f, 0x38, 0x8e, 0xfa, 0xd5,
0x16, 0x16, 0x15, 0xe6, 0x2d, 0x05, 0x49, 0xa7, 0x61, 0xd7, 0x4e, 0xeb, 0x01, 0x42, 0xff, 0x5d,
0x40, 0x28, 0x5a, 0x7e, 0xda, 0x73, 0x21, 0xdd, 0x86, 0x59, 0xff, 0xf2, 0x23, 0xa9, 0x58, 0x76,
0x6a, 0xd0, 0xfa, 0x4b, 0xfa, 0xd6, 0x1f, 0x61, 0xbe, 0x50, 0x30, 0x5f, 0x42, 0x73, 0xe7, 0x89,
0x89, 0x9a, 0x82, 0xca, 0x56, 0x7e, 0xbf, 0xe3, 0xae, 0x7c, 0x80, 0x1d, 0x17, 0xca, 0x2e, 0x34,
0x32, 0x1a, 0x3e, 0xab, 0xbb, 0x08, 0xd7, 0x20, 0x8e, 0x92, 0x5c, 0x73, 0xdb, 0x4c, 0xf9, 0x32,
0x4a, 0x72, 0x8d, 0xdd, 0xd9, 0xca, 0xef, 0x3f, 0x90, 0xca, 0x35, 0x14, 0x6d, 0xd5, 0xf8, 0x83,
0xf0, 0x39, 0x05, 0x0b, 0xe7, 0x69, 0xb9, 0x26, 0x2d, 0x04, 0x40, 0x5f, 0x19, 0x0a, 0x74, 0x34,
0x07, 0xe3, 0x3b, 0x0a, 0xe6, 0x85, 0xb1, 0xcd, 0x26, 0x44, 0xd7, 0x6c, 0x93, 0x1a, 0x97, 0xdf,
0x28, 0x58, 0x10, 0xc6, 0x77, 0x91, 0x10, 0x69, 0x17, 0xfd, 0xdc, 0x15, 0xcb, 0xbf, 0x8c, 0xc3,
0xef, 0xde, 0x0f, 0x51, 0x72, 0x2e, 0xd5, 0xf4, 0x1e, 0x4c, 0x1d, 0x34, 0x4d, 0x7a, 0x79, 0xc0,
0xa5, 0x35, 0x9d, 0x1d, 0x74, 0xe5, 0xa2, 0x0f, 0x61, 0xda, 0x39, 0xe5, 0xd2, 0xcc, 0xe0, 0xdb,
0x46, 0xfa, 0x9f, 0x21, 0x8e, 0xc9, 0xed, 0xe2, 0x04, 0xec, 0x57, 0x5c, 0xf7, 0x84, 0xd9, 0xa7,
0x38, 0xff, 0x31, 0xec, 0x0e, 0xc4, 0xdb, 0x63, 0x91, 0xce, 0x0e, 0x3a, 0x53, 0xa4, 0xff, 0x1e,
0x38, 0x53, 0x69, 0x15, 0xe6, 0x82, 0xdb, 0x17, 0x7d, 0x69, 0xf8, 0x61, 0x92, 0xbe, 0x3c, 0xc2,
0x7e, 0xd8, 0x7e, 0x95, 0x30, 0xcc, 0xab, 0x84, 0x11, 0x5e, 0x15, 0xbe, 0x68, 0xb6, 0x8f, 0xdf,
0x9f, 0x65, 0x62, 0x1f, 0xce, 0x32, 0xb1, 0x4f, 0x67, 0x99, 0xd8, 0x8b, 0xcf, 0x99, 0x5f, 0x1e,
0xdd, 0xac, 0xaa, 0xe6, 0x71, 0xb3, 0xcc, 0xca, 0x7a, 0x9d, 0xd3, 0x48, 0x43, 0x96, 0x73, 0x0a,
0x5a, 0x9c, 0x86, 0x7a, 0x85, 0xe4, 0xa4, 0x86, 0x9a, 0xab, 0xea, 0x5c, 0xcf, 0xdf, 0x2b, 0x1b,
0xde, 0xd7, 0x53, 0x6a, 0xe1, 0x1e, 0xea, 0xbb, 0x25, 0x76, 0xeb, 0xa0, 0xd8, 0x2e, 0xc0, 0xb3,
0x5e, 0x79, 0xda, 0xfe, 0x17, 0xe5, 0xea, 0x8f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xa1, 0x09, 0xe6,
0xa5, 0xec, 0x11, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
@ -3867,7 +3868,7 @@ func (m *PutRequest_Body) Unmarshal(dAtA []byte) error {
return io.ErrUnexpectedEOF
}
if m.Signature == nil {
m.Signature = &grpc.Signature{}
m.Signature = &grpc1.Signature{}
}
if err := m.Signature.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
@ -4407,7 +4408,7 @@ func (m *DeleteRequest_Body) Unmarshal(dAtA []byte) error {
return io.ErrUnexpectedEOF
}
if m.Signature == nil {
m.Signature = &grpc.Signature{}
m.Signature = &grpc1.Signature{}
}
if err := m.Signature.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
@ -5917,7 +5918,7 @@ func (m *SetExtendedACLRequest_Body) Unmarshal(dAtA []byte) error {
return io.ErrUnexpectedEOF
}
if m.Signature == nil {
m.Signature = &grpc.Signature{}
m.Signature = &grpc1.Signature{}
}
if err := m.Signature.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
@ -6673,7 +6674,7 @@ func (m *GetExtendedACLResponse_Body) Unmarshal(dAtA []byte) error {
return io.ErrUnexpectedEOF
}
if m.Signature == nil {
m.Signature = &grpc.Signature{}
m.Signature = &grpc1.Signature{}
}
if err := m.Signature.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err

View file

@ -6,9 +6,8 @@ package container
import (
fmt "fmt"
proto "github.com/golang/protobuf/proto"
grpc2 "github.com/nspcc-dev/neofs-api-go/v2/netmap/grpc"
grpc1 "github.com/nspcc-dev/neofs-api-go/v2/refs/grpc"
grpc "github.com/nspcc-dev/neofs-api-go/v2/service/grpc"
grpc1 "github.com/nspcc-dev/neofs-api-go/v2/netmap/grpc"
grpc "github.com/nspcc-dev/neofs-api-go/v2/refs/grpc"
io "io"
math "math"
math_bits "math/bits"
@ -34,7 +33,7 @@ type Container struct {
// Effectively the version of API library used to create container
Version *grpc.Version `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"`
// OwnerID carries identifier of the container owner.
OwnerId *grpc1.OwnerID `protobuf:"bytes,2,opt,name=owner_id,json=ownerId,proto3" json:"owner_id,omitempty"`
OwnerId *grpc.OwnerID `protobuf:"bytes,2,opt,name=owner_id,json=ownerId,proto3" json:"owner_id,omitempty"`
// Nonce is a 16 byte UUID, used to avoid collisions of container id.
Nonce []byte `protobuf:"bytes,3,opt,name=nonce,proto3" json:"nonce,omitempty"`
// BasicACL contains access control rules for owner, system, others groups and
@ -43,7 +42,7 @@ type Container struct {
// Attributes define any immutable characteristics of container.
Attributes []*Container_Attribute `protobuf:"bytes,5,rep,name=attributes,proto3" json:"attributes,omitempty"`
// Placement policy for the object inside the container.
PlacementPolicy *grpc2.PlacementPolicy `protobuf:"bytes,6,opt,name=placement_policy,json=placementPolicy,proto3" json:"placement_policy,omitempty"`
PlacementPolicy *grpc1.PlacementPolicy `protobuf:"bytes,6,opt,name=placement_policy,json=placementPolicy,proto3" json:"placement_policy,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
@ -89,7 +88,7 @@ func (m *Container) GetVersion() *grpc.Version {
return nil
}
func (m *Container) GetOwnerId() *grpc1.OwnerID {
func (m *Container) GetOwnerId() *grpc.OwnerID {
if m != nil {
return m.OwnerId
}
@ -117,7 +116,7 @@ func (m *Container) GetAttributes() []*Container_Attribute {
return nil
}
func (m *Container) GetPlacementPolicy() *grpc2.PlacementPolicy {
func (m *Container) GetPlacementPolicy() *grpc1.PlacementPolicy {
if m != nil {
return m.PlacementPolicy
}
@ -190,32 +189,31 @@ func init() {
func init() { proto.RegisterFile("v2/container/grpc/types.proto", fileDescriptor_3bfd95a81c72c35c) }
var fileDescriptor_3bfd95a81c72c35c = []byte{
// 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, 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,
// 383 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x52, 0x4d, 0xae, 0xd3, 0x30,
0x10, 0x26, 0x2d, 0xef, 0xb5, 0x71, 0x41, 0x54, 0x06, 0x41, 0x14, 0x44, 0x14, 0x58, 0x65, 0x53,
0x5b, 0xa4, 0x4b, 0xc4, 0xa2, 0x80, 0x10, 0x95, 0x10, 0x54, 0x46, 0x62, 0xc1, 0xa6, 0x72, 0xdc,
0x69, 0x6b, 0x91, 0xda, 0x56, 0xec, 0x06, 0xf5, 0x26, 0x9c, 0x81, 0x93, 0xb0, 0xe4, 0x08, 0xa8,
0xdc, 0x80, 0x13, 0xa0, 0x24, 0x4a, 0xe8, 0x53, 0xbb, 0xcb, 0xcc, 0xf7, 0x33, 0x33, 0x5f, 0x8c,
0x9e, 0x94, 0x29, 0x15, 0x5a, 0x39, 0x2e, 0x15, 0x14, 0x74, 0x53, 0x18, 0x41, 0xdd, 0xc1, 0x80,
0x25, 0xa6, 0xd0, 0x4e, 0xe3, 0xfb, 0x0a, 0x34, 0x59, 0x5b, 0x52, 0xa6, 0xa4, 0x63, 0x85, 0x61,
0x99, 0x52, 0x05, 0x6e, 0xc7, 0xcd, 0x99, 0x20, 0x0c, 0xca, 0x94, 0x16, 0xb0, 0xb6, 0x67, 0xc8,
0xb3, 0xbf, 0x3d, 0xe4, 0xbf, 0x6e, 0x3d, 0xf0, 0x73, 0x34, 0x28, 0xa1, 0xb0, 0x52, 0xab, 0xc0,
0x8b, 0xbd, 0x64, 0x94, 0x3e, 0x22, 0xff, 0x47, 0x55, 0x06, 0xe4, 0x73, 0x03, 0xb3, 0x96, 0x87,
0x53, 0x34, 0xd4, 0xdf, 0x14, 0x14, 0x4b, 0xb9, 0x0a, 0x7a, 0x97, 0x35, 0x1f, 0x2b, 0x7c, 0xfe,
0x86, 0x0d, 0x6a, 0xe2, 0x7c, 0x85, 0x1f, 0xa0, 0x2b, 0xa5, 0x95, 0x80, 0xa0, 0x1f, 0x7b, 0xc9,
0x1d, 0xd6, 0x14, 0xf8, 0x31, 0xf2, 0x33, 0x6e, 0xa5, 0x58, 0x72, 0x91, 0x07, 0xb7, 0x63, 0x2f,
0xb9, 0xcb, 0x86, 0x75, 0x63, 0x26, 0x72, 0xfc, 0x0e, 0x21, 0xee, 0x5c, 0x21, 0xb3, 0xbd, 0x03,
0x1b, 0x5c, 0xc5, 0xfd, 0x64, 0x94, 0x26, 0xe4, 0x42, 0x0e, 0xa4, 0xbb, 0x86, 0xcc, 0x5a, 0x01,
0x3b, 0xd1, 0xe2, 0xf7, 0x68, 0x6c, 0x72, 0x2e, 0x60, 0x07, 0xca, 0x2d, 0x8d, 0xce, 0xa5, 0x38,
0x04, 0xd7, 0xf5, 0xe2, 0x4f, 0x4f, 0xfc, 0x9a, 0x24, 0xc9, 0xa2, 0x65, 0x2e, 0x6a, 0x22, 0xbb,
0x67, 0x6e, 0x36, 0xc2, 0x29, 0xf2, 0xbb, 0x31, 0x78, 0x8c, 0xfa, 0x5f, 0xe1, 0x50, 0x47, 0xe7,
0xb3, 0xea, 0xb3, 0xba, 0xb4, 0xe4, 0xf9, 0x1e, 0xea, 0x68, 0x7c, 0xd6, 0x14, 0xaf, 0xb6, 0x3f,
0x8f, 0x91, 0xf7, 0xeb, 0x18, 0x79, 0xbf, 0x8f, 0x91, 0xf7, 0xfd, 0x4f, 0x74, 0xeb, 0xcb, 0xcb,
0x8d, 0x74, 0xdb, 0x7d, 0x46, 0x84, 0xde, 0x51, 0x65, 0x8d, 0x10, 0x93, 0x15, 0x94, 0x54, 0x81,
0x5e, 0xdb, 0x09, 0x37, 0x72, 0xb2, 0xd1, 0xf4, 0xec, 0x49, 0xbc, 0xe8, 0xca, 0x1f, 0xbd, 0x87,
0x1f, 0x40, 0xbf, 0xfd, 0x44, 0x66, 0x8b, 0x79, 0xb5, 0x7c, 0x17, 0x41, 0x76, 0x5d, 0xff, 0xe5,
0xe9, 0xbf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x57, 0x93, 0x14, 0xb3, 0x51, 0x02, 0x00, 0x00,
}
func (m *Container) Marshal() (dAtA []byte, err error) {
@ -517,7 +515,7 @@ func (m *Container) Unmarshal(dAtA []byte) error {
return io.ErrUnexpectedEOF
}
if m.OwnerId == nil {
m.OwnerId = &grpc1.OwnerID{}
m.OwnerId = &grpc.OwnerID{}
}
if err := m.OwnerId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
@ -640,7 +638,7 @@ func (m *Container) Unmarshal(dAtA []byte) error {
return io.ErrUnexpectedEOF
}
if m.PlacementPolicy == nil {
m.PlacementPolicy = &grpc2.PlacementPolicy{}
m.PlacementPolicy = &grpc1.PlacementPolicy{}
}
if err := m.PlacementPolicy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err

View file

@ -8,7 +8,7 @@ import (
fmt "fmt"
proto "github.com/golang/protobuf/proto"
grpc1 "github.com/nspcc-dev/neofs-api-go/v2/refs/grpc"
grpc "github.com/nspcc-dev/neofs-api-go/v2/service/grpc"
grpc "github.com/nspcc-dev/neofs-api-go/v2/session/grpc"
grpc2 "google.golang.org/grpc"
codes "google.golang.org/grpc/codes"
status "google.golang.org/grpc/status"
@ -323,7 +323,7 @@ type GetResponse_Body_Init struct {
// Object ID
ObjectId *grpc1.ObjectID `protobuf:"bytes,1,opt,name=object_id,json=objectId,proto3" json:"object_id,omitempty"`
// Object signature
Signature *grpc.Signature `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
Signature *grpc1.Signature `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
// Object header.
Header *Header `protobuf:"bytes,3,opt,name=header,proto3" json:"header,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
@ -371,7 +371,7 @@ func (m *GetResponse_Body_Init) GetObjectId() *grpc1.ObjectID {
return nil
}
func (m *GetResponse_Body_Init) GetSignature() *grpc.Signature {
func (m *GetResponse_Body_Init) GetSignature() *grpc1.Signature {
if m != nil {
return m.Signature
}
@ -550,7 +550,7 @@ type PutRequest_Body_Init struct {
// Object ID, where available
ObjectId *grpc1.ObjectID `protobuf:"bytes,1,opt,name=object_id,json=objectId,proto3" json:"object_id,omitempty"`
// Object signature, were available
Signature *grpc.Signature `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
Signature *grpc1.Signature `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
// Header of the object to save in the system.
Header *Header `protobuf:"bytes,3,opt,name=header,proto3" json:"header,omitempty"`
// Number of the object copies to store within the RPC call.
@ -602,7 +602,7 @@ func (m *PutRequest_Body_Init) GetObjectId() *grpc1.ObjectID {
return nil
}
func (m *PutRequest_Body_Init) GetSignature() *grpc.Signature {
func (m *PutRequest_Body_Init) GetSignature() *grpc1.Signature {
if m != nil {
return m.Signature
}
@ -1973,10 +1973,12 @@ type GetRangeHashRequest_Body struct {
// Carries the list of object payload range to calculate homomorphic hash.
Ranges []*Range `protobuf:"bytes,2,rep,name=ranges,proto3" json:"ranges,omitempty"`
// Carries binary salt to XOR object payload ranges before hash calculation.
Salt []byte `protobuf:"bytes,3,opt,name=salt,proto3" json:"salt,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
Salt []byte `protobuf:"bytes,3,opt,name=salt,proto3" json:"salt,omitempty"`
// Checksum algorithm type
Type grpc1.ChecksumType `protobuf:"varint,4,opt,name=type,proto3,enum=neo.fs.v2.refs.ChecksumType" json:"type,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *GetRangeHashRequest_Body) Reset() { *m = GetRangeHashRequest_Body{} }
@ -2033,6 +2035,13 @@ func (m *GetRangeHashRequest_Body) GetSalt() []byte {
return nil
}
func (m *GetRangeHashRequest_Body) GetType() grpc1.ChecksumType {
if m != nil {
return m.Type
}
return grpc1.ChecksumType_CHECKSUM_TYPE_UNSPECIFIED
}
// Get hash of object's payload part
type GetRangeHashResponse struct {
// Body of get range hash object response message.
@ -2105,8 +2114,10 @@ func (m *GetRangeHashResponse) GetVerifyHeader() *grpc.ResponseVerificationHeade
// Response body
type GetRangeHashResponse_Body struct {
// Carries list of homomorphic hashes in a binary format.
HashList [][]byte `protobuf:"bytes,1,rep,name=hash_list,json=hashList,proto3" json:"hash_list,omitempty"`
// Checksum algorithm type
Type grpc1.ChecksumType `protobuf:"varint,1,opt,name=type,proto3,enum=neo.fs.v2.refs.ChecksumType" json:"type,omitempty"`
// List of range hashes in a binary format.
HashList [][]byte `protobuf:"bytes,2,rep,name=hash_list,json=hashList,proto3" json:"hash_list,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
@ -2145,6 +2156,13 @@ func (m *GetRangeHashResponse_Body) XXX_DiscardUnknown() {
var xxx_messageInfo_GetRangeHashResponse_Body proto.InternalMessageInfo
func (m *GetRangeHashResponse_Body) GetType() grpc1.ChecksumType {
if m != nil {
return m.Type
}
return grpc1.ChecksumType_CHECKSUM_TYPE_UNSPECIFIED
}
func (m *GetRangeHashResponse_Body) GetHashList() [][]byte {
if m != nil {
return m.HashList
@ -2190,84 +2208,87 @@ func init() {
func init() { proto.RegisterFile("v2/object/grpc/service.proto", fileDescriptor_1d7d92b1e85e5b48) }
var fileDescriptor_1d7d92b1e85e5b48 = []byte{
// 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,
// 1267 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x58, 0xdd, 0x6e, 0x1b, 0xc5,
0x17, 0xcf, 0xae, 0x37, 0x6e, 0x7c, 0x6c, 0xe7, 0x1f, 0x4d, 0xa3, 0xd6, 0x7f, 0xe7, 0x83, 0x74,
0xdb, 0xa4, 0x11, 0x25, 0xeb, 0x60, 0x54, 0x42, 0x5b, 0x5a, 0xd4, 0x90, 0xa4, 0xb1, 0x4a, 0xda,
0xb0, 0x06, 0x2e, 0x90, 0x90, 0xb5, 0x59, 0x8f, 0xed, 0xa5, 0xf6, 0xae, 0xd9, 0x19, 0x1b, 0xf9,
0x05, 0x90, 0x78, 0x02, 0x90, 0x90, 0x10, 0xea, 0x15, 0xea, 0x15, 0xe2, 0x96, 0x17, 0x00, 0x24,
0x24, 0x78, 0x03, 0x14, 0x6e, 0x91, 0x78, 0x00, 0x84, 0x84, 0xe6, 0x63, 0x6d, 0xaf, 0xbf, 0x95,
0xbb, 0xe5, 0x6e, 0x66, 0xf6, 0x77, 0xce, 0xce, 0xf9, 0xcd, 0x6f, 0xce, 0x9c, 0x19, 0x58, 0x6d,
0xe7, 0x73, 0xde, 0xd9, 0xc7, 0xd8, 0xa6, 0xb9, 0xaa, 0xdf, 0xb4, 0x73, 0x04, 0xfb, 0x6d, 0xc7,
0xc6, 0x46, 0xd3, 0xf7, 0xa8, 0x87, 0x96, 0x5c, 0xec, 0x19, 0x15, 0x62, 0xb4, 0xf3, 0x86, 0x00,
0x65, 0xb3, 0x03, 0x78, 0xda, 0x69, 0x62, 0x22, 0xd0, 0xd9, 0x4c, 0x3b, 0x9f, 0xf3, 0x71, 0x85,
0x0c, 0x7f, 0x59, 0x69, 0xe7, 0x73, 0x04, 0x13, 0xe2, 0x78, 0xee, 0xd0, 0x47, 0xfd, 0x85, 0x0a,
0xf0, 0x08, 0x53, 0x13, 0x7f, 0xd2, 0xc2, 0x84, 0xa2, 0xdb, 0xa0, 0x9d, 0x79, 0xe5, 0x4e, 0x46,
0xd9, 0x50, 0xb6, 0x93, 0xf9, 0x6b, 0xc6, 0xe0, 0x14, 0x8c, 0x1e, 0xd6, 0xd8, 0xf7, 0xca, 0x1d,
0x93, 0xc3, 0xd1, 0x21, 0x24, 0x1b, 0x98, 0x5a, 0xa5, 0x1a, 0xb6, 0xca, 0xd8, 0xcf, 0xa8, 0xdc,
0xfa, 0x46, 0x9f, 0xb5, 0xfc, 0xbf, 0x21, 0x6d, 0x4f, 0x30, 0xb5, 0x8e, 0x39, 0xd6, 0x84, 0x46,
0xb7, 0x8d, 0xde, 0x85, 0x74, 0x1b, 0xfb, 0x4e, 0xa5, 0x13, 0x38, 0x8a, 0x71, 0x47, 0xaf, 0x8c,
0x77, 0xf4, 0x01, 0x83, 0x3b, 0xb6, 0x45, 0x1d, 0xcf, 0x95, 0x0e, 0x53, 0xc2, 0x85, 0xe8, 0x65,
0x1f, 0x83, 0xc6, 0xe6, 0x89, 0x5e, 0x85, 0x4b, 0x56, 0xb9, 0xec, 0x63, 0x42, 0x64, 0x6c, 0x57,
0xfb, 0x9c, 0x32, 0xde, 0x8c, 0x87, 0xe2, 0xb3, 0x19, 0xe0, 0xd0, 0x12, 0xc4, 0x7c, 0xeb, 0x53,
0x1e, 0xcc, 0x82, 0xc9, 0x9a, 0xfa, 0xdf, 0x31, 0x48, 0x72, 0x02, 0x48, 0xd3, 0x73, 0x09, 0x46,
0xaf, 0x87, 0xd8, 0xd2, 0xc7, 0xb0, 0x25, 0xc0, 0xfd, 0x74, 0x1d, 0x8d, 0xa2, 0x6b, 0x73, 0x64,
0x94, 0xc2, 0x78, 0x0c, 0x5f, 0xe6, 0x68, 0xbe, 0x76, 0x26, 0x78, 0x9a, 0x4a, 0xd8, 0x17, 0xaa,
0x64, 0xec, 0x3e, 0x68, 0x8e, 0xeb, 0x50, 0x19, 0xdc, 0xcd, 0xe9, 0xc1, 0x19, 0x05, 0xd7, 0xa1,
0xc7, 0x73, 0x26, 0x37, 0x43, 0x57, 0x60, 0xde, 0xae, 0xb5, 0xdc, 0x67, 0x3c, 0xba, 0xd4, 0xf1,
0x9c, 0x29, 0xba, 0xd9, 0x6f, 0x15, 0xd0, 0x18, 0x10, 0xdd, 0x86, 0x84, 0x70, 0x54, 0x72, 0xca,
0xf2, 0x27, 0x99, 0xc1, 0x35, 0x79, 0xca, 0x01, 0x85, 0x03, 0x73, 0x41, 0x40, 0x0b, 0x65, 0xb4,
0x07, 0x09, 0xe2, 0x54, 0x5d, 0x8b, 0xb6, 0x7c, 0x2c, 0x99, 0xfb, 0xff, 0xa0, 0x59, 0x31, 0x00,
0x98, 0x3d, 0x2c, 0xda, 0x85, 0x78, 0x88, 0xa5, 0xcc, 0x70, 0x44, 0x92, 0x10, 0x89, 0xdb, 0x4f,
0x43, 0x52, 0xce, 0xb0, 0x69, 0xf9, 0x54, 0xff, 0x4a, 0x03, 0x38, 0x6d, 0xcd, 0xbe, 0x55, 0x7a,
0xd8, 0x68, 0x6c, 0x95, 0x1f, 0x82, 0x95, 0x7f, 0x33, 0xb4, 0xf2, 0x5b, 0x53, 0x23, 0x9b, 0x6d,
0xe1, 0x7f, 0x89, 0xcc, 0xc2, 0xa3, 0xeb, 0x90, 0xb6, 0xbd, 0xa6, 0x83, 0x49, 0xc9, 0x6d, 0x35,
0xce, 0xb0, 0x9f, 0xd1, 0x36, 0x94, 0xed, 0xb4, 0x99, 0x12, 0x83, 0x4f, 0xf8, 0xd8, 0xa0, 0x3a,
0xbe, 0x51, 0x21, 0xc9, 0x79, 0x99, 0x35, 0x37, 0xf4, 0x81, 0xa3, 0x92, 0x1b, 0xee, 0x4b, 0x81,
0x5c, 0x6c, 0x05, 0xf5, 0xaf, 0x55, 0x48, 0x1f, 0xe0, 0x3a, 0xa6, 0x38, 0xd8, 0x43, 0x6f, 0x84,
0x48, 0xba, 0x31, 0x4c, 0x52, 0x08, 0x1e, 0x8d, 0x6d, 0x74, 0xe7, 0xc2, 0x27, 0x8e, 0xfe, 0x97,
0x02, 0x8b, 0x41, 0xc4, 0x52, 0x46, 0x77, 0x42, 0x0c, 0x6d, 0x8e, 0x67, 0x28, 0x5a, 0x4a, 0x8a,
0x0b, 0x92, 0xf4, 0x9f, 0x54, 0x48, 0xb2, 0xa1, 0x40, 0x10, 0x53, 0x77, 0x4d, 0x1f, 0x38, 0x1a,
0x72, 0xa8, 0x5d, 0xbc, 0x00, 0x59, 0x81, 0x44, 0xc3, 0x72, 0xdc, 0x92, 0xe7, 0xd6, 0x3b, 0xb2,
0x0c, 0x59, 0x60, 0x03, 0x4f, 0xdd, 0x7a, 0x27, 0xa8, 0x4e, 0x62, 0xbd, 0xea, 0xe4, 0x4f, 0x15,
0x52, 0x82, 0x1e, 0xa9, 0x9d, 0xbd, 0x10, 0x99, 0xd7, 0xc7, 0x91, 0x19, 0x2d, 0xe5, 0x7c, 0xa6,
0x48, 0x42, 0xf3, 0xdd, 0xb4, 0xae, 0x4c, 0x4e, 0xeb, 0xc7, 0x73, 0xdd, 0xc4, 0xbe, 0x0f, 0x29,
0x52, 0xf3, 0x7c, 0x1a, 0x8e, 0x6c, 0x6d, 0xd8, 0xb2, 0xc8, 0x50, 0x5d, 0xf3, 0x24, 0xe9, 0x75,
0xf7, 0xe3, 0xa0, 0x31, 0x6b, 0xfd, 0x9f, 0x18, 0xa4, 0x8b, 0xd8, 0xf2, 0xed, 0xda, 0xcc, 0xd9,
0x2c, 0x04, 0x8f, 0x86, 0x7c, 0xbb, 0xe5, 0xe0, 0x03, 0x48, 0xd9, 0x9e, 0x4b, 0x2d, 0xc7, 0xc5,
0x7e, 0x2f, 0xed, 0xaf, 0x0c, 0x8a, 0xf8, 0xed, 0x00, 0x53, 0x38, 0x30, 0x93, 0x5d, 0x83, 0x42,
0x19, 0x65, 0xe0, 0x52, 0x1b, 0xfb, 0xec, 0xdf, 0x3c, 0xbc, 0xb4, 0x19, 0x74, 0xd1, 0x21, 0x5c,
0xaa, 0x38, 0x75, 0x8a, 0x7d, 0x92, 0x89, 0x6d, 0xc4, 0xb6, 0x93, 0xf9, 0x5b, 0xb3, 0x30, 0x67,
0x1c, 0x71, 0x1b, 0x33, 0xb0, 0xcd, 0xba, 0x10, 0x17, 0x43, 0xe8, 0x2e, 0x40, 0xc3, 0xa2, 0x76,
0xad, 0xc4, 0x2e, 0x3a, 0x7c, 0xa2, 0x8b, 0xa1, 0x89, 0x4a, 0x9f, 0x27, 0x0c, 0xf3, 0x5e, 0xa7,
0x89, 0xcd, 0x44, 0x23, 0x68, 0x22, 0x04, 0x9a, 0x6b, 0x35, 0x44, 0x81, 0x91, 0x30, 0x79, 0x1b,
0x2d, 0xc3, 0x7c, 0xdb, 0xaa, 0xb7, 0x30, 0xa7, 0x33, 0x61, 0x8a, 0x8e, 0xfe, 0x5c, 0x85, 0xc5,
0x60, 0x5a, 0xb3, 0x26, 0xeb, 0x30, 0x3e, 0x2a, 0x5b, 0xae, 0xef, 0x44, 0x73, 0xca, 0xa5, 0xba,
0x43, 0x58, 0x69, 0x18, 0x9b, 0x78, 0xe8, 0xc7, 0x9d, 0xf2, 0x3b, 0x0e, 0xa1, 0xfa, 0x1e, 0xcc,
0x9b, 0x96, 0x5b, 0xc5, 0xe8, 0x0a, 0xc4, 0xbd, 0x4a, 0x85, 0x60, 0x51, 0x55, 0x6a, 0xa6, 0xec,
0xb1, 0xf1, 0x3a, 0x76, 0xab, 0xb4, 0xc6, 0x43, 0xd6, 0x4c, 0xd9, 0xd3, 0x7f, 0x53, 0xe1, 0x7f,
0xec, 0x82, 0xc1, 0x8c, 0x83, 0xfd, 0x75, 0x37, 0x44, 0xef, 0xd6, 0xe8, 0x1b, 0x49, 0x9f, 0xc1,
0x7f, 0xfe, 0x80, 0xd8, 0x81, 0x79, 0x9f, 0xc5, 0x2b, 0xc3, 0xb9, 0x3a, 0xcc, 0x88, 0xa0, 0x43,
0xa0, 0xf4, 0xcf, 0x55, 0x58, 0xea, 0x51, 0x24, 0x35, 0x7b, 0x2f, 0x44, 0xea, 0xcd, 0x49, 0xa4,
0x46, 0x4b, 0xb5, 0xab, 0x92, 0xd7, 0xe5, 0xe0, 0x3e, 0xc2, 0x22, 0x4c, 0xc9, 0xdb, 0x88, 0xfe,
0x3c, 0x06, 0x97, 0x83, 0xc8, 0x8e, 0x2d, 0xd2, 0xcd, 0xe1, 0x0f, 0x42, 0x74, 0xbc, 0x3c, 0x9e,
0x8e, 0x3e, 0xa3, 0x68, 0xe8, 0xec, 0x3b, 0xe5, 0xe2, 0x42, 0xcb, 0x41, 0x9c, 0x4b, 0x88, 0x64,
0x54, 0xbe, 0xf1, 0xc7, 0x2a, 0x4d, 0xc2, 0x58, 0x1a, 0x25, 0x56, 0x9d, 0xf2, 0x69, 0xa7, 0x4c,
0xde, 0x46, 0xbb, 0xa0, 0xf1, 0x84, 0xac, 0xf1, 0x84, 0xbc, 0x3a, 0x74, 0x72, 0xd4, 0xb0, 0xfd,
0x8c, 0xb4, 0x1a, 0x3c, 0x23, 0x73, 0xa4, 0xfe, 0xb3, 0x0a, 0xcb, 0x61, 0xbe, 0xa5, 0x68, 0xdf,
0x0a, 0xad, 0xd2, 0xad, 0x69, 0xab, 0x14, 0x2d, 0xe1, 0xbe, 0x2f, 0xd7, 0x29, 0xe0, 0x4b, 0x99,
0x95, 0x2f, 0x56, 0x30, 0xd6, 0x2c, 0x52, 0x13, 0x29, 0x9a, 0xad, 0x54, 0xca, 0x5c, 0x60, 0x03,
0x2c, 0x15, 0xe7, 0xbf, 0xd7, 0x20, 0x2d, 0xf2, 0x73, 0x51, 0x3c, 0x33, 0xa2, 0x03, 0x88, 0x3d,
0xc2, 0x14, 0xad, 0x4e, 0x7a, 0xe5, 0xcb, 0xae, 0x4d, 0x7c, 0xf8, 0xd9, 0x55, 0x98, 0x97, 0xd3,
0xd6, 0x48, 0x2f, 0xbd, 0x67, 0x82, 0x51, 0x5e, 0xfa, 0xee, 0xbf, 0xdb, 0x0a, 0x7a, 0x0c, 0x71,
0x71, 0x93, 0x41, 0x2f, 0x4d, 0xb9, 0x05, 0x66, 0x37, 0xa6, 0x5d, 0x82, 0xd0, 0x21, 0x68, 0x8c,
0x4b, 0xb4, 0x36, 0xf1, 0xfe, 0x90, 0x5d, 0x9f, 0x5c, 0x11, 0xa3, 0x13, 0x88, 0x8b, 0x03, 0x7b,
0xd4, 0x9c, 0x42, 0x15, 0xc9, 0xa8, 0x39, 0x85, 0xcf, 0xfa, 0x5d, 0x05, 0x15, 0x61, 0x21, 0x90,
0x25, 0xba, 0x36, 0xf5, 0xf0, 0xca, 0xea, 0xd3, 0x53, 0xf1, 0xae, 0x82, 0x3e, 0x82, 0x54, 0xbf,
0xd6, 0xd1, 0xe6, 0x4c, 0x19, 0x2b, 0xbb, 0x35, 0xdb, 0x96, 0xd9, 0x2f, 0xfd, 0x78, 0xbe, 0xae,
0xfc, 0x7a, 0xbe, 0xae, 0xfc, 0x7e, 0xbe, 0xae, 0x7c, 0xf9, 0xc7, 0xfa, 0xdc, 0x87, 0x7b, 0x55,
0x87, 0xd6, 0x5a, 0x67, 0x86, 0xed, 0x35, 0x72, 0x2e, 0x69, 0xda, 0xf6, 0x4e, 0x19, 0xb7, 0x73,
0x2e, 0xf6, 0x2a, 0x64, 0xc7, 0x6a, 0x3a, 0x3b, 0x55, 0x2f, 0x17, 0x7e, 0xa5, 0xbe, 0x27, 0xda,
0x2f, 0xd4, 0xcb, 0x4f, 0xb0, 0x77, 0x54, 0x34, 0x1e, 0x9e, 0x16, 0xd8, 0x5f, 0x85, 0x14, 0xcf,
0xe2, 0xfc, 0x19, 0xfa, 0xb5, 0x7f, 0x03, 0x00, 0x00, 0xff, 0xff, 0xc2, 0x71, 0xb6, 0x54, 0x0b,
0x17, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
@ -4410,6 +4431,11 @@ func (m *GetRangeHashRequest_Body) MarshalToSizedBuffer(dAtA []byte) (int, error
i -= len(m.XXX_unrecognized)
copy(dAtA[i:], m.XXX_unrecognized)
}
if m.Type != 0 {
i = encodeVarintService(dAtA, i, uint64(m.Type))
i--
dAtA[i] = 0x20
}
if len(m.Salt) > 0 {
i -= len(m.Salt)
copy(dAtA[i:], m.Salt)
@ -4539,9 +4565,14 @@ func (m *GetRangeHashResponse_Body) MarshalToSizedBuffer(dAtA []byte) (int, erro
copy(dAtA[i:], m.HashList[iNdEx])
i = encodeVarintService(dAtA, i, uint64(len(m.HashList[iNdEx])))
i--
dAtA[i] = 0xa
dAtA[i] = 0x12
}
}
if m.Type != 0 {
i = encodeVarintService(dAtA, i, uint64(m.Type))
i--
dAtA[i] = 0x8
}
return len(dAtA) - i, nil
}
@ -5261,6 +5292,9 @@ func (m *GetRangeHashRequest_Body) Size() (n int) {
if l > 0 {
n += 1 + l + sovService(uint64(l))
}
if m.Type != 0 {
n += 1 + sovService(uint64(m.Type))
}
if m.XXX_unrecognized != nil {
n += len(m.XXX_unrecognized)
}
@ -5297,6 +5331,9 @@ func (m *GetRangeHashResponse_Body) Size() (n int) {
}
var l int
_ = l
if m.Type != 0 {
n += 1 + sovService(uint64(m.Type))
}
if len(m.HashList) > 0 {
for _, b := range m.HashList {
l = len(b)
@ -5966,7 +6003,7 @@ func (m *GetResponse_Body_Init) Unmarshal(dAtA []byte) error {
return io.ErrUnexpectedEOF
}
if m.Signature == nil {
m.Signature = &grpc.Signature{}
m.Signature = &grpc1.Signature{}
}
if err := m.Signature.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
@ -6412,7 +6449,7 @@ func (m *PutRequest_Body_Init) Unmarshal(dAtA []byte) error {
return io.ErrUnexpectedEOF
}
if m.Signature == nil {
m.Signature = &grpc.Signature{}
m.Signature = &grpc1.Signature{}
}
if err := m.Signature.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
@ -9413,6 +9450,25 @@ func (m *GetRangeHashRequest_Body) Unmarshal(dAtA []byte) error {
m.Salt = []byte{}
}
iNdEx = postIndex
case 4:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
}
m.Type = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowService
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.Type |= grpc1.ChecksumType(b&0x7F) << shift
if b < 0x80 {
break
}
}
default:
iNdEx = preIndex
skippy, err := skipService(dAtA[iNdEx:])
@ -9630,6 +9686,25 @@ func (m *GetRangeHashResponse_Body) Unmarshal(dAtA []byte) error {
}
switch fieldNum {
case 1:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
}
m.Type = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowService
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.Type |= grpc1.ChecksumType(b&0x7F) << shift
if b < 0x80 {
break
}
}
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field HashList", wireType)
}

View file

@ -6,8 +6,8 @@ package object
import (
fmt "fmt"
proto "github.com/golang/protobuf/proto"
grpc1 "github.com/nspcc-dev/neofs-api-go/v2/refs/grpc"
grpc "github.com/nspcc-dev/neofs-api-go/v2/service/grpc"
grpc "github.com/nspcc-dev/neofs-api-go/v2/refs/grpc"
grpc1 "github.com/nspcc-dev/neofs-api-go/v2/session/grpc"
io "io"
math "math"
math_bits "math/bits"
@ -91,7 +91,7 @@ type ShortHeader struct {
// Epoch when the object was created
CreationEpoch uint64 `protobuf:"varint,2,opt,name=creation_epoch,json=creationEpoch,proto3" json:"creation_epoch,omitempty"`
// Object's owner
OwnerId *grpc1.OwnerID `protobuf:"bytes,3,opt,name=owner_id,json=ownerId,proto3" json:"owner_id,omitempty"`
OwnerId *grpc.OwnerID `protobuf:"bytes,3,opt,name=owner_id,json=ownerId,proto3" json:"owner_id,omitempty"`
// Type of the object payload content
ObjectType ObjectType `protobuf:"varint,4,opt,name=object_type,json=objectType,proto3,enum=neo.fs.v2.object.ObjectType" json:"object_type,omitempty"`
// Size of payload in bytes.
@ -149,7 +149,7 @@ func (m *ShortHeader) GetCreationEpoch() uint64 {
return 0
}
func (m *ShortHeader) GetOwnerId() *grpc1.OwnerID {
func (m *ShortHeader) GetOwnerId() *grpc.OwnerID {
if m != nil {
return m.OwnerId
}
@ -176,23 +176,23 @@ type Header struct {
// Effectively the version of API library used to create particular object
Version *grpc.Version `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"`
// Object's container
ContainerId *grpc1.ContainerID `protobuf:"bytes,2,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"`
ContainerId *grpc.ContainerID `protobuf:"bytes,2,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"`
// Object's owner
OwnerId *grpc1.OwnerID `protobuf:"bytes,3,opt,name=owner_id,json=ownerId,proto3" json:"owner_id,omitempty"`
OwnerId *grpc.OwnerID `protobuf:"bytes,3,opt,name=owner_id,json=ownerId,proto3" json:"owner_id,omitempty"`
// Object creation Epoch
CreationEpoch uint64 `protobuf:"varint,4,opt,name=creation_epoch,json=creationEpoch,proto3" json:"creation_epoch,omitempty"`
// Size of payload in bytes.
// 0xFFFFFFFFFFFFFFFF means `payload_length` is unknown
PayloadLength uint64 `protobuf:"varint,5,opt,name=payload_length,json=payloadLength,proto3" json:"payload_length,omitempty"`
// Hash of payload bytes
PayloadHash []byte `protobuf:"bytes,6,opt,name=payload_hash,json=payloadHash,proto3" json:"payload_hash,omitempty"`
PayloadHash *grpc.Checksum `protobuf:"bytes,6,opt,name=payload_hash,json=payloadHash,proto3" json:"payload_hash,omitempty"`
// Special object type
ObjectType ObjectType `protobuf:"varint,7,opt,name=object_type,json=objectType,proto3,enum=neo.fs.v2.object.ObjectType" json:"object_type,omitempty"`
// Homomorphic hash of the object payload.
HomomorphicHash []byte `protobuf:"bytes,8,opt,name=homomorphic_hash,json=homomorphicHash,proto3" json:"homomorphic_hash,omitempty"`
HomomorphicHash *grpc.Checksum `protobuf:"bytes,8,opt,name=homomorphic_hash,json=homomorphicHash,proto3" json:"homomorphic_hash,omitempty"`
// Session token, if it was used during Object creation.
// Need it to verify integrity and authenticity out of Request scope.
SessionToken *grpc.SessionToken `protobuf:"bytes,9,opt,name=session_token,json=sessionToken,proto3" json:"session_token,omitempty"`
SessionToken *grpc1.SessionToken `protobuf:"bytes,9,opt,name=session_token,json=sessionToken,proto3" json:"session_token,omitempty"`
// User-defined object attributes
Attributes []*Header_Attribute `protobuf:"bytes,10,rep,name=attributes,proto3" json:"attributes,omitempty"`
// Position of the object in the split hierarchy.
@ -242,14 +242,14 @@ func (m *Header) GetVersion() *grpc.Version {
return nil
}
func (m *Header) GetContainerId() *grpc1.ContainerID {
func (m *Header) GetContainerId() *grpc.ContainerID {
if m != nil {
return m.ContainerId
}
return nil
}
func (m *Header) GetOwnerId() *grpc1.OwnerID {
func (m *Header) GetOwnerId() *grpc.OwnerID {
if m != nil {
return m.OwnerId
}
@ -270,7 +270,7 @@ func (m *Header) GetPayloadLength() uint64 {
return 0
}
func (m *Header) GetPayloadHash() []byte {
func (m *Header) GetPayloadHash() *grpc.Checksum {
if m != nil {
return m.PayloadHash
}
@ -284,14 +284,14 @@ func (m *Header) GetObjectType() ObjectType {
return ObjectType_REGULAR
}
func (m *Header) GetHomomorphicHash() []byte {
func (m *Header) GetHomomorphicHash() *grpc.Checksum {
if m != nil {
return m.HomomorphicHash
}
return nil
}
func (m *Header) GetSessionToken() *grpc.SessionToken {
func (m *Header) GetSessionToken() *grpc1.SessionToken {
if m != nil {
return m.SessionToken
}
@ -375,18 +375,18 @@ type Header_Split struct {
// Identifier of the origin object.
// Parent and children objects must be within the same container.
// Parent object_id is known only to the minor child.
Parent *grpc1.ObjectID `protobuf:"bytes,1,opt,name=parent,proto3" json:"parent,omitempty"`
Parent *grpc.ObjectID `protobuf:"bytes,1,opt,name=parent,proto3" json:"parent,omitempty"`
// Previous carries identifier of the left split neighbor.
Previous *grpc1.ObjectID `protobuf:"bytes,2,opt,name=previous,proto3" json:"previous,omitempty"`
Previous *grpc.ObjectID `protobuf:"bytes,2,opt,name=previous,proto3" json:"previous,omitempty"`
// `signature` field of the parent object. Used to reconstruct parent.
ParentSignature *grpc.Signature `protobuf:"bytes,3,opt,name=parent_signature,json=parentSignature,proto3" json:"parent_signature,omitempty"`
// `header` field of the parent object. Used to reconstruct parent.
ParentHeader *Header `protobuf:"bytes,4,opt,name=parent_header,json=parentHeader,proto3" json:"parent_header,omitempty"`
// Children carries list of identifiers of the objects generated by splitting the current.
Children []*grpc1.ObjectID `protobuf:"bytes,5,rep,name=children,proto3" json:"children,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
Children []*grpc.ObjectID `protobuf:"bytes,5,rep,name=children,proto3" json:"children,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Header_Split) Reset() { *m = Header_Split{} }
@ -422,14 +422,14 @@ func (m *Header_Split) XXX_DiscardUnknown() {
var xxx_messageInfo_Header_Split proto.InternalMessageInfo
func (m *Header_Split) GetParent() *grpc1.ObjectID {
func (m *Header_Split) GetParent() *grpc.ObjectID {
if m != nil {
return m.Parent
}
return nil
}
func (m *Header_Split) GetPrevious() *grpc1.ObjectID {
func (m *Header_Split) GetPrevious() *grpc.ObjectID {
if m != nil {
return m.Previous
}
@ -450,7 +450,7 @@ func (m *Header_Split) GetParentHeader() *Header {
return nil
}
func (m *Header_Split) GetChildren() []*grpc1.ObjectID {
func (m *Header_Split) GetChildren() []*grpc.ObjectID {
if m != nil {
return m.Children
}
@ -463,7 +463,7 @@ type Object struct {
// Object is content-addressed. It means id will change if header or payload
// changes. It's calculated as a hash of header field, which contains hash of
// object's payload
ObjectId *grpc1.ObjectID `protobuf:"bytes,1,opt,name=object_id,json=objectId,proto3" json:"object_id,omitempty"`
ObjectId *grpc.ObjectID `protobuf:"bytes,1,opt,name=object_id,json=objectId,proto3" json:"object_id,omitempty"`
// Signed object_id
Signature *grpc.Signature `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
// Object metadata headers
@ -508,7 +508,7 @@ func (m *Object) XXX_DiscardUnknown() {
var xxx_messageInfo_Object proto.InternalMessageInfo
func (m *Object) GetObjectId() *grpc1.ObjectID {
func (m *Object) GetObjectId() *grpc.ObjectID {
if m != nil {
return m.ObjectId
}
@ -549,57 +549,57 @@ func init() {
func init() { proto.RegisterFile("v2/object/grpc/types.proto", fileDescriptor_545319325da7b9b1) }
var fileDescriptor_545319325da7b9b1 = []byte{
// 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, 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,
// 796 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x95, 0xdd, 0x6e, 0xe3, 0x44,
0x14, 0xc7, 0xeb, 0xb4, 0xf9, 0x3a, 0x4e, 0x76, 0xcd, 0x80, 0xc0, 0x64, 0x51, 0xa8, 0x2a, 0x21,
0x55, 0x2b, 0xd5, 0x06, 0x6f, 0xd1, 0x0a, 0x55, 0x8b, 0x94, 0x36, 0xde, 0xd6, 0x52, 0xdb, 0x94,
0xb1, 0x8b, 0x04, 0x37, 0x96, 0x6b, 0x4f, 0x63, 0xd3, 0xd4, 0x63, 0x79, 0x26, 0x46, 0xbd, 0xe4,
0x2d, 0x78, 0x86, 0x7d, 0x0e, 0x2e, 0xb8, 0xe4, 0x11, 0x56, 0xe5, 0x45, 0x90, 0x67, 0xec, 0xf4,
0x23, 0xbb, 0x04, 0xf6, 0xca, 0xf6, 0x99, 0xdf, 0xff, 0xcc, 0xf9, 0x9f, 0x39, 0x23, 0xc3, 0xa0,
0xb0, 0x4c, 0x7a, 0xf1, 0x0b, 0x09, 0xb9, 0x39, 0xcd, 0xb3, 0xd0, 0xe4, 0x37, 0x19, 0x61, 0x46,
0x96, 0x53, 0x4e, 0x91, 0x96, 0x12, 0x6a, 0x5c, 0x32, 0xa3, 0xb0, 0x0c, 0x89, 0x0c, 0xf4, 0xc2,
0x32, 0x73, 0x72, 0xc9, 0x96, 0xd8, 0xc1, 0xb3, 0xc2, 0x32, 0x19, 0x61, 0x2c, 0xa1, 0xe9, 0xd2,
0xe2, 0xd6, 0x6f, 0x0d, 0x50, 0xdd, 0x98, 0xe6, 0xfc, 0x88, 0x04, 0x11, 0xc9, 0xd1, 0x37, 0xd0,
0x2e, 0x48, 0x5e, 0xb2, 0xba, 0xb2, 0xa9, 0x6c, 0xab, 0xd6, 0x67, 0xc6, 0xdd, 0x56, 0x65, 0x7e,
0xe3, 0x47, 0xb9, 0x8c, 0x6b, 0x0e, 0x7d, 0x05, 0x4f, 0xc2, 0x9c, 0x04, 0x3c, 0xa1, 0xa9, 0x4f,
0x32, 0x1a, 0xc6, 0x7a, 0x63, 0x53, 0xd9, 0xde, 0xc0, 0xfd, 0x3a, 0x6a, 0x97, 0x41, 0x64, 0x41,
0x87, 0xfe, 0x9a, 0x92, 0xdc, 0x4f, 0x22, 0x7d, 0xfd, 0xdd, 0xa9, 0x27, 0xe5, 0xba, 0x33, 0xc6,
0x6d, 0x01, 0x3a, 0x11, 0x7a, 0x05, 0xaa, 0xb4, 0xe7, 0x97, 0x35, 0xeb, 0x1b, 0x9b, 0xca, 0xf6,
0x13, 0xeb, 0x0b, 0xe3, 0xb1, 0x79, 0x63, 0x22, 0x1e, 0xde, 0x4d, 0x46, 0x30, 0xd0, 0xc5, 0x7b,
0x59, 0x59, 0x16, 0xdc, 0xcc, 0x68, 0x10, 0xf9, 0x33, 0x92, 0x4e, 0x79, 0xac, 0x37, 0x65, 0x65,
0x55, 0xf4, 0x58, 0x04, 0xb7, 0xde, 0xb6, 0xa1, 0xf5, 0xe1, 0xf6, 0xbf, 0x87, 0x5e, 0x48, 0x53,
0x1e, 0x24, 0x95, 0xb7, 0x86, 0xd0, 0x3d, 0x7b, 0xac, 0x3b, 0xa8, 0x19, 0x67, 0x8c, 0xd5, 0x85,
0xc0, 0x89, 0x3e, 0xa8, 0x2f, 0xcb, 0x2d, 0xdf, 0x78, 0x57, 0xcb, 0xff, 0x9b, 0x7f, 0xb4, 0x07,
0xbd, 0x1a, 0x8b, 0x03, 0x16, 0xeb, 0x2d, 0x51, 0x85, 0xbe, 0xe4, 0x20, 0x26, 0xe1, 0x15, 0x9b,
0x5f, 0x63, 0xb5, 0xa2, 0x8f, 0x02, 0x16, 0x3f, 0x3e, 0xa2, 0xf6, 0xff, 0x3c, 0xa2, 0x03, 0xd0,
0x62, 0x7a, 0x4d, 0xaf, 0x69, 0x9e, 0xc5, 0x49, 0x28, 0xf7, 0xef, 0xac, 0xd8, 0xff, 0xe9, 0x3d,
0x85, 0xa8, 0x61, 0x0c, 0xfd, 0x6a, 0xc0, 0x7d, 0x4e, 0xaf, 0x48, 0xaa, 0x77, 0x45, 0x86, 0x2f,
0xef, 0x65, 0xa8, 0xd6, 0x0d, 0x57, 0x3e, 0xbd, 0x12, 0xc3, 0x3d, 0x76, 0xef, 0x0b, 0xed, 0x03,
0x04, 0x9c, 0xe7, 0xc9, 0xc5, 0x9c, 0x13, 0xa6, 0xc3, 0xe6, 0xfa, 0xb6, 0x6a, 0x6d, 0x2d, 0x1b,
0x91, 0x93, 0x62, 0x8c, 0x6a, 0x14, 0xdf, 0x53, 0xa1, 0x5d, 0x68, 0xb2, 0x6c, 0x96, 0x70, 0x5d,
0x15, 0x15, 0x0c, 0xdf, 0x2b, 0x77, 0x4b, 0x0a, 0x4b, 0x78, 0xf0, 0x02, 0xba, 0x8b, 0x74, 0x48,
0x83, 0xf5, 0x2b, 0x72, 0x23, 0xc6, 0xaf, 0x8b, 0xcb, 0x57, 0xf4, 0x09, 0x34, 0x8b, 0x60, 0x36,
0x27, 0x62, 0xb4, 0xba, 0x58, 0x7e, 0x0c, 0xde, 0x34, 0xa0, 0x29, 0xb2, 0xa0, 0xaf, 0xa1, 0x95,
0x05, 0x39, 0x49, 0x79, 0x35, 0xb3, 0x4b, 0x9d, 0x93, 0xbd, 0x77, 0xc6, 0xb8, 0xe2, 0xd0, 0x2e,
0x74, 0xb2, 0x9c, 0x14, 0x09, 0x9d, 0xb3, 0x6a, 0x5e, 0xdf, 0xaf, 0x59, 0x90, 0x68, 0x0c, 0x9a,
0xd4, 0xfb, 0x2c, 0x99, 0xa6, 0x01, 0x9f, 0xe7, 0xa4, 0x9a, 0xd8, 0xcf, 0x1f, 0xab, 0xdd, 0x1a,
0xc0, 0x4f, 0xa5, 0x64, 0x11, 0x40, 0xaf, 0xa0, 0x5f, 0x65, 0x89, 0x45, 0x2b, 0xc4, 0xe8, 0x3e,
0x2c, 0xe0, 0x41, 0xab, 0x70, 0x4f, 0xe2, 0xd5, 0x0d, 0xdd, 0x85, 0x4e, 0x18, 0x27, 0xb3, 0x28,
0x27, 0xa9, 0xde, 0x14, 0x67, 0xf4, 0x2f, 0xa5, 0xd7, 0xe4, 0xd6, 0x1f, 0x0a, 0xb4, 0x64, 0x18,
0x7d, 0x0b, 0xdd, 0x6a, 0x60, 0x93, 0x68, 0x65, 0xc3, 0x3a, 0x12, 0x75, 0x22, 0xf4, 0x12, 0xba,
0x77, 0xae, 0x1b, 0xab, 0x5c, 0xdf, 0xb1, 0xe5, 0xe9, 0x54, 0x46, 0xd7, 0x57, 0x18, 0xad, 0x38,
0xa4, 0x43, 0xbb, 0xba, 0x61, 0xa2, 0x37, 0x3d, 0x5c, 0x7f, 0x3e, 0xdf, 0x03, 0xb8, 0xbb, 0x47,
0x48, 0x85, 0x36, 0xb6, 0x0f, 0xcf, 0x8f, 0x47, 0x58, 0x5b, 0x43, 0x7d, 0xe8, 0x7a, 0x93, 0x93,
0x7d, 0xd7, 0x9b, 0x9c, 0xda, 0x9a, 0x82, 0x3e, 0x82, 0xbe, 0xeb, 0x4d, 0xf0, 0xe8, 0xd0, 0xf6,
0x0f, 0xf1, 0xe4, 0xfc, 0x4c, 0x6b, 0x3c, 0xff, 0x0e, 0xba, 0x27, 0x01, 0x0f, 0x63, 0xa1, 0x1d,
0xc0, 0xa7, 0x27, 0x23, 0xef, 0xe0, 0xc8, 0xf7, 0x7e, 0x3a, 0xb3, 0xfd, 0xf3, 0x53, 0xf7, 0xcc,
0x3e, 0x70, 0x5e, 0x3b, 0xf6, 0x58, 0x5b, 0x43, 0x1a, 0xf4, 0x5c, 0x0f, 0x3b, 0xa7, 0x87, 0xbe,
0xfd, 0xc3, 0xf9, 0xe8, 0x58, 0x53, 0xf6, 0xfd, 0x3f, 0x6f, 0x87, 0xca, 0x5f, 0xb7, 0x43, 0xe5,
0xed, 0xed, 0x50, 0xf9, 0xfd, 0xef, 0xe1, 0xda, 0xcf, 0x2f, 0xa7, 0x09, 0x8f, 0xe7, 0x17, 0x46,
0x48, 0xaf, 0xcd, 0x94, 0x65, 0x61, 0xb8, 0x13, 0x91, 0xc2, 0x4c, 0x09, 0xbd, 0x64, 0x3b, 0x41,
0x96, 0xec, 0x4c, 0xa9, 0xf9, 0xf0, 0xf7, 0xb5, 0x27, 0xdf, 0xdf, 0x34, 0x3e, 0x3e, 0x25, 0xf4,
0xb5, 0x6b, 0x8c, 0xce, 0x9c, 0xb2, 0x03, 0xd2, 0xce, 0x45, 0x4b, 0xfc, 0x8d, 0x5e, 0xfc, 0x13,
0x00, 0x00, 0xff, 0xff, 0x2c, 0x8c, 0x1d, 0x72, 0xf4, 0x06, 0x00, 0x00,
}
func (m *ShortHeader) Marshal() (dAtA []byte, err error) {
@ -730,10 +730,15 @@ func (m *Header) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i--
dAtA[i] = 0x4a
}
if len(m.HomomorphicHash) > 0 {
i -= len(m.HomomorphicHash)
copy(dAtA[i:], m.HomomorphicHash)
i = encodeVarintTypes(dAtA, i, uint64(len(m.HomomorphicHash)))
if m.HomomorphicHash != nil {
{
size, err := m.HomomorphicHash.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintTypes(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x42
}
@ -742,10 +747,15 @@ func (m *Header) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i--
dAtA[i] = 0x38
}
if len(m.PayloadHash) > 0 {
i -= len(m.PayloadHash)
copy(dAtA[i:], m.PayloadHash)
i = encodeVarintTypes(dAtA, i, uint64(len(m.PayloadHash)))
if m.PayloadHash != nil {
{
size, err := m.PayloadHash.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintTypes(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x32
}
@ -1062,15 +1072,15 @@ func (m *Header) Size() (n int) {
if m.PayloadLength != 0 {
n += 1 + sovTypes(uint64(m.PayloadLength))
}
l = len(m.PayloadHash)
if l > 0 {
if m.PayloadHash != nil {
l = m.PayloadHash.Size()
n += 1 + l + sovTypes(uint64(l))
}
if m.ObjectType != 0 {
n += 1 + sovTypes(uint64(m.ObjectType))
}
l = len(m.HomomorphicHash)
if l > 0 {
if m.HomomorphicHash != nil {
l = m.HomomorphicHash.Size()
n += 1 + l + sovTypes(uint64(l))
}
if m.SessionToken != nil {
@ -1295,7 +1305,7 @@ func (m *ShortHeader) Unmarshal(dAtA []byte) error {
return io.ErrUnexpectedEOF
}
if m.OwnerId == nil {
m.OwnerId = &grpc1.OwnerID{}
m.OwnerId = &grpc.OwnerID{}
}
if err := m.OwnerId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
@ -1459,7 +1469,7 @@ func (m *Header) Unmarshal(dAtA []byte) error {
return io.ErrUnexpectedEOF
}
if m.ContainerId == nil {
m.ContainerId = &grpc1.ContainerID{}
m.ContainerId = &grpc.ContainerID{}
}
if err := m.ContainerId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
@ -1495,7 +1505,7 @@ func (m *Header) Unmarshal(dAtA []byte) error {
return io.ErrUnexpectedEOF
}
if m.OwnerId == nil {
m.OwnerId = &grpc1.OwnerID{}
m.OwnerId = &grpc.OwnerID{}
}
if err := m.OwnerId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
@ -1543,7 +1553,7 @@ func (m *Header) Unmarshal(dAtA []byte) error {
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field PayloadHash", wireType)
}
var byteLen int
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
@ -1553,24 +1563,26 @@ func (m *Header) 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 ErrInvalidLengthTypes
}
postIndex := iNdEx + byteLen
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthTypes
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.PayloadHash = append(m.PayloadHash[:0], dAtA[iNdEx:postIndex]...)
if m.PayloadHash == nil {
m.PayloadHash = []byte{}
m.PayloadHash = &grpc.Checksum{}
}
if err := m.PayloadHash.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 7:
@ -1596,7 +1608,7 @@ func (m *Header) Unmarshal(dAtA []byte) error {
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field HomomorphicHash", wireType)
}
var byteLen int
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
@ -1606,24 +1618,26 @@ func (m *Header) 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 ErrInvalidLengthTypes
}
postIndex := iNdEx + byteLen
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthTypes
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.HomomorphicHash = append(m.HomomorphicHash[:0], dAtA[iNdEx:postIndex]...)
if m.HomomorphicHash == nil {
m.HomomorphicHash = []byte{}
m.HomomorphicHash = &grpc.Checksum{}
}
if err := m.HomomorphicHash.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 9:
@ -1656,7 +1670,7 @@ func (m *Header) Unmarshal(dAtA []byte) error {
return io.ErrUnexpectedEOF
}
if m.SessionToken == nil {
m.SessionToken = &grpc.SessionToken{}
m.SessionToken = &grpc1.SessionToken{}
}
if err := m.SessionToken.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
@ -1934,7 +1948,7 @@ func (m *Header_Split) Unmarshal(dAtA []byte) error {
return io.ErrUnexpectedEOF
}
if m.Parent == nil {
m.Parent = &grpc1.ObjectID{}
m.Parent = &grpc.ObjectID{}
}
if err := m.Parent.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
@ -1970,7 +1984,7 @@ func (m *Header_Split) Unmarshal(dAtA []byte) error {
return io.ErrUnexpectedEOF
}
if m.Previous == nil {
m.Previous = &grpc1.ObjectID{}
m.Previous = &grpc.ObjectID{}
}
if err := m.Previous.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
@ -2077,7 +2091,7 @@ func (m *Header_Split) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Children = append(m.Children, &grpc1.ObjectID{})
m.Children = append(m.Children, &grpc.ObjectID{})
if err := m.Children[len(m.Children)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
@ -2166,7 +2180,7 @@ func (m *Object) Unmarshal(dAtA []byte) error {
return io.ErrUnexpectedEOF
}
if m.ObjectId == nil {
m.ObjectId = &grpc1.ObjectID{}
m.ObjectId = &grpc.ObjectID{}
}
if err := m.ObjectId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err

View file

@ -22,6 +22,38 @@ var _ = math.Inf
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
// Checksum algorithm type
type ChecksumType int32
const (
// Unknown. Not used
ChecksumType_CHECKSUM_TYPE_UNSPECIFIED ChecksumType = 0
// Tillich-Zemor homomorphic hash funciton
ChecksumType_TZ ChecksumType = 1
// SHA-256
ChecksumType_SHA256 ChecksumType = 2
)
var ChecksumType_name = map[int32]string{
0: "CHECKSUM_TYPE_UNSPECIFIED",
1: "TZ",
2: "SHA256",
}
var ChecksumType_value = map[string]int32{
"CHECKSUM_TYPE_UNSPECIFIED": 0,
"TZ": 1,
"SHA256": 2,
}
func (x ChecksumType) String() string {
return proto.EnumName(ChecksumType_name, int32(x))
}
func (ChecksumType) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_08f084e5f91ec87c, []int{0}
}
// Address of object (container id + object id)
type Address struct {
// container_id carries container identifier.
@ -227,34 +259,222 @@ func (m *OwnerID) GetValue() []byte {
return nil
}
// Represents API version used by node.
type Version struct {
// Major API version.
Major uint32 `protobuf:"varint,1,opt,name=major,proto3" json:"major,omitempty"`
// Minor API version.
Minor uint32 `protobuf:"varint,2,opt,name=minor,proto3" json:"minor,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Version) Reset() { *m = Version{} }
func (m *Version) String() string { return proto.CompactTextString(m) }
func (*Version) ProtoMessage() {}
func (*Version) Descriptor() ([]byte, []int) {
return fileDescriptor_08f084e5f91ec87c, []int{4}
}
func (m *Version) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *Version) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_Version.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 *Version) XXX_Merge(src proto.Message) {
xxx_messageInfo_Version.Merge(m, src)
}
func (m *Version) XXX_Size() int {
return m.Size()
}
func (m *Version) XXX_DiscardUnknown() {
xxx_messageInfo_Version.DiscardUnknown(m)
}
var xxx_messageInfo_Version proto.InternalMessageInfo
func (m *Version) GetMajor() uint32 {
if m != nil {
return m.Major
}
return 0
}
func (m *Version) GetMinor() uint32 {
if m != nil {
return m.Minor
}
return 0
}
// Signature of something in NeoFS
type Signature struct {
// Public key used for signing.
Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
// Signature
Sign []byte `protobuf:"bytes,2,opt,name=sign,proto3" json:"sign,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Signature) Reset() { *m = Signature{} }
func (m *Signature) String() string { return proto.CompactTextString(m) }
func (*Signature) ProtoMessage() {}
func (*Signature) Descriptor() ([]byte, []int) {
return fileDescriptor_08f084e5f91ec87c, []int{5}
}
func (m *Signature) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *Signature) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_Signature.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 *Signature) XXX_Merge(src proto.Message) {
xxx_messageInfo_Signature.Merge(m, src)
}
func (m *Signature) XXX_Size() int {
return m.Size()
}
func (m *Signature) XXX_DiscardUnknown() {
xxx_messageInfo_Signature.DiscardUnknown(m)
}
var xxx_messageInfo_Signature proto.InternalMessageInfo
func (m *Signature) GetKey() []byte {
if m != nil {
return m.Key
}
return nil
}
func (m *Signature) GetSign() []byte {
if m != nil {
return m.Sign
}
return nil
}
// Checksum message
type Checksum struct {
// Checksum algorithm type
Type ChecksumType `protobuf:"varint,1,opt,name=type,proto3,enum=neo.fs.v2.refs.ChecksumType" json:"type,omitempty"`
// Checksum itself
Sum []byte `protobuf:"bytes,2,opt,name=sum,proto3" json:"sum,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Checksum) Reset() { *m = Checksum{} }
func (m *Checksum) String() string { return proto.CompactTextString(m) }
func (*Checksum) ProtoMessage() {}
func (*Checksum) Descriptor() ([]byte, []int) {
return fileDescriptor_08f084e5f91ec87c, []int{6}
}
func (m *Checksum) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *Checksum) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_Checksum.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 *Checksum) XXX_Merge(src proto.Message) {
xxx_messageInfo_Checksum.Merge(m, src)
}
func (m *Checksum) XXX_Size() int {
return m.Size()
}
func (m *Checksum) XXX_DiscardUnknown() {
xxx_messageInfo_Checksum.DiscardUnknown(m)
}
var xxx_messageInfo_Checksum proto.InternalMessageInfo
func (m *Checksum) GetType() ChecksumType {
if m != nil {
return m.Type
}
return ChecksumType_CHECKSUM_TYPE_UNSPECIFIED
}
func (m *Checksum) GetSum() []byte {
if m != nil {
return m.Sum
}
return nil
}
func init() {
proto.RegisterEnum("neo.fs.v2.refs.ChecksumType", ChecksumType_name, ChecksumType_value)
proto.RegisterType((*Address)(nil), "neo.fs.v2.refs.Address")
proto.RegisterType((*ObjectID)(nil), "neo.fs.v2.refs.ObjectID")
proto.RegisterType((*ContainerID)(nil), "neo.fs.v2.refs.ContainerID")
proto.RegisterType((*OwnerID)(nil), "neo.fs.v2.refs.OwnerID")
proto.RegisterType((*Version)(nil), "neo.fs.v2.refs.Version")
proto.RegisterType((*Signature)(nil), "neo.fs.v2.refs.Signature")
proto.RegisterType((*Checksum)(nil), "neo.fs.v2.refs.Checksum")
}
func init() { proto.RegisterFile("v2/refs/grpc/types.proto", fileDescriptor_08f084e5f91ec87c) }
var fileDescriptor_08f084e5f91ec87c = []byte{
// 265 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x28, 0x33, 0xd2, 0x2f,
0x4a, 0x4d, 0x2b, 0xd6, 0x4f, 0x2f, 0x2a, 0x48, 0xd6, 0x2f, 0xa9, 0x2c, 0x48, 0x2d, 0xd6, 0x2b,
0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0xcb, 0x4b, 0xcd, 0xd7, 0x4b, 0x2b, 0xd6, 0x2b, 0x33, 0xd2,
0x03, 0x29, 0x50, 0x6a, 0x60, 0xe4, 0x62, 0x77, 0x4c, 0x49, 0x29, 0x4a, 0x2d, 0x2e, 0x16, 0xb2,
0xe3, 0xe2, 0x49, 0xce, 0xcf, 0x2b, 0x49, 0xcc, 0xcc, 0x4b, 0x2d, 0x8a, 0xcf, 0x4c, 0x91, 0x60,
0x54, 0x60, 0xd4, 0xe0, 0x36, 0x92, 0xd6, 0x43, 0xd5, 0xa2, 0xe7, 0x0c, 0x53, 0xe3, 0xe9, 0x12,
0xc4, 0x0d, 0xd7, 0xe0, 0x99, 0x22, 0x64, 0xca, 0xc5, 0x99, 0x9f, 0x94, 0x95, 0x9a, 0x5c, 0x02,
0xd2, 0xcc, 0x04, 0xd6, 0x2c, 0x81, 0xae, 0xd9, 0x1f, 0xac, 0xc0, 0xd3, 0x25, 0x88, 0x03, 0xa2,
0xd4, 0x33, 0x45, 0x49, 0x81, 0x8b, 0x03, 0x26, 0x2a, 0x24, 0xc2, 0xc5, 0x5a, 0x96, 0x98, 0x53,
0x9a, 0x0a, 0xb6, 0x9b, 0x27, 0x08, 0xc2, 0x51, 0x52, 0xe6, 0xe2, 0x46, 0xb2, 0x14, 0x87, 0x22,
0x79, 0x2e, 0x76, 0xff, 0x72, 0x3c, 0x0a, 0x9c, 0x22, 0x4f, 0x3c, 0x92, 0x63, 0xbc, 0xf0, 0x48,
0x8e, 0xf1, 0xc1, 0x23, 0x39, 0xc6, 0x19, 0x8f, 0xe5, 0x18, 0xa2, 0x8c, 0xd3, 0x33, 0x4b, 0x32,
0x4a, 0x93, 0xf4, 0x92, 0xf3, 0x73, 0xf5, 0xf3, 0x8a, 0x0b, 0x92, 0x93, 0x75, 0x53, 0x52, 0xcb,
0xf4, 0xf3, 0x52, 0xf3, 0xd3, 0x8a, 0x75, 0x13, 0x0b, 0x32, 0x75, 0xd3, 0xf3, 0xf5, 0x91, 0x03,
0xd2, 0x1a, 0xc4, 0x5a, 0xc5, 0x24, 0xe8, 0x97, 0x9a, 0xef, 0x16, 0xac, 0xe7, 0x18, 0xe0, 0x09,
0xf2, 0x55, 0x50, 0x6a, 0x5a, 0x71, 0x12, 0x1b, 0x38, 0x70, 0x8d, 0x01, 0x01, 0x00, 0x00, 0xff,
0xff, 0x64, 0x50, 0x7b, 0x92, 0x78, 0x01, 0x00, 0x00,
// 427 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x92, 0xc1, 0x6e, 0xd3, 0x40,
0x10, 0x86, 0xeb, 0x50, 0x92, 0x74, 0x12, 0xaa, 0xb0, 0xe2, 0x10, 0x04, 0x84, 0xca, 0x5c, 0x10,
0x52, 0xd6, 0xe0, 0x2a, 0x5c, 0x90, 0x90, 0x82, 0x93, 0xaa, 0x16, 0x22, 0x8d, 0xec, 0x14, 0xa9,
0xbd, 0x44, 0x8e, 0x3d, 0x71, 0xb7, 0x25, 0xbb, 0xd6, 0xae, 0x6d, 0x94, 0x1b, 0x8f, 0xc1, 0x33,
0xf0, 0x24, 0x1c, 0x79, 0x04, 0x14, 0x5e, 0x04, 0xed, 0x26, 0x41, 0x01, 0x04, 0xb7, 0x7f, 0x46,
0xdf, 0xb7, 0x63, 0x8f, 0x06, 0xda, 0xa5, 0xeb, 0x48, 0x9c, 0x2b, 0x27, 0x95, 0x59, 0xec, 0xe4,
0xcb, 0x0c, 0x15, 0xcd, 0xa4, 0xc8, 0x05, 0x39, 0xe4, 0x28, 0xe8, 0x5c, 0xd1, 0xd2, 0xa5, 0x1a,
0xb0, 0x3f, 0x59, 0x50, 0xeb, 0x27, 0x89, 0x44, 0xa5, 0xc8, 0x6b, 0x68, 0xc6, 0x82, 0xe7, 0x11,
0xe3, 0x28, 0xa7, 0x2c, 0x69, 0x5b, 0x47, 0xd6, 0xd3, 0x86, 0xfb, 0x80, 0xfe, 0xae, 0x50, 0x6f,
0xcb, 0xf8, 0x83, 0xa0, 0xf1, 0x4b, 0xf0, 0x13, 0xd2, 0x83, 0x03, 0x31, 0xbb, 0xc6, 0x38, 0xd7,
0x72, 0xc5, 0xc8, 0xed, 0x3f, 0xe5, 0x33, 0x03, 0xf8, 0x83, 0xa0, 0xbe, 0x46, 0xfd, 0xc4, 0x3e,
0x82, 0xfa, 0xb6, 0x4b, 0xee, 0xc1, 0xed, 0x32, 0xfa, 0x50, 0xa0, 0x99, 0xdd, 0x0c, 0xd6, 0x85,
0xfd, 0x04, 0x1a, 0x3b, 0x43, 0xff, 0x01, 0x3d, 0x86, 0xda, 0xd9, 0xc7, 0xff, 0x01, 0x3d, 0xa8,
0xbd, 0x47, 0xa9, 0x98, 0xe0, 0x1a, 0x58, 0x44, 0xd7, 0x42, 0x1a, 0xe0, 0x4e, 0xb0, 0x2e, 0x4c,
0x97, 0x71, 0x21, 0xcd, 0xb7, 0xeb, 0xae, 0x2e, 0xec, 0x17, 0x70, 0x10, 0xb2, 0x94, 0x47, 0x79,
0x21, 0x91, 0xb4, 0xe0, 0xd6, 0x0d, 0x2e, 0x37, 0xef, 0xea, 0x48, 0x08, 0xec, 0x2b, 0x96, 0x72,
0xe3, 0x34, 0x03, 0x93, 0xed, 0x11, 0xd4, 0xbd, 0x2b, 0x8c, 0x6f, 0x54, 0xb1, 0x20, 0xcf, 0x61,
0x5f, 0xef, 0xdf, 0x28, 0x87, 0xee, 0xc3, 0xbf, 0x96, 0xb9, 0xe1, 0x26, 0xcb, 0x0c, 0x03, 0x43,
0xea, 0x19, 0xaa, 0x58, 0x6c, 0x1e, 0xd4, 0xf1, 0x59, 0x1f, 0x9a, 0xbb, 0x1c, 0x79, 0x04, 0xf7,
0xbd, 0xd3, 0xa1, 0xf7, 0x36, 0x3c, 0x7f, 0x37, 0x9d, 0x5c, 0x8c, 0x87, 0xd3, 0xf3, 0x51, 0x38,
0x1e, 0x7a, 0xfe, 0x89, 0x3f, 0x1c, 0xb4, 0xf6, 0x48, 0x15, 0x2a, 0x93, 0xcb, 0x96, 0x45, 0x00,
0xaa, 0xe1, 0x69, 0xdf, 0xed, 0xbd, 0x6c, 0x55, 0xde, 0x5c, 0x7c, 0x5d, 0x75, 0xac, 0x6f, 0xab,
0x8e, 0xf5, 0x7d, 0xd5, 0xb1, 0x3e, 0xff, 0xe8, 0xec, 0x5d, 0x1e, 0xa7, 0x2c, 0xbf, 0x2a, 0x66,
0x34, 0x16, 0x0b, 0x87, 0xab, 0x2c, 0x8e, 0xbb, 0x09, 0x96, 0x0e, 0x47, 0x31, 0x57, 0xdd, 0x28,
0x63, 0xdd, 0x54, 0x38, 0xbb, 0x57, 0xf4, 0x4a, 0xa7, 0x2f, 0x95, 0xbb, 0x23, 0x14, 0x27, 0x21,
0xed, 0x8f, 0x7d, 0xfd, 0x0b, 0x01, 0xce, 0xd5, 0xac, 0x6a, 0x2e, 0xeb, 0xf8, 0x67, 0x00, 0x00,
0x00, 0xff, 0xff, 0xbb, 0x23, 0xc5, 0xde, 0x75, 0x02, 0x00, 0x00,
}
func (m *Address) Marshal() (dAtA []byte, err error) {
@ -410,6 +630,123 @@ func (m *OwnerID) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil
}
func (m *Version) 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 *Version) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *Version) 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.Minor != 0 {
i = encodeVarintTypes(dAtA, i, uint64(m.Minor))
i--
dAtA[i] = 0x10
}
if m.Major != 0 {
i = encodeVarintTypes(dAtA, i, uint64(m.Major))
i--
dAtA[i] = 0x8
}
return len(dAtA) - i, nil
}
func (m *Signature) 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 *Signature) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *Signature) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if m.XXX_unrecognized != nil {
i -= len(m.XXX_unrecognized)
copy(dAtA[i:], m.XXX_unrecognized)
}
if len(m.Sign) > 0 {
i -= len(m.Sign)
copy(dAtA[i:], m.Sign)
i = encodeVarintTypes(dAtA, i, uint64(len(m.Sign)))
i--
dAtA[i] = 0x12
}
if len(m.Key) > 0 {
i -= len(m.Key)
copy(dAtA[i:], m.Key)
i = encodeVarintTypes(dAtA, i, uint64(len(m.Key)))
i--
dAtA[i] = 0xa
}
return len(dAtA) - i, nil
}
func (m *Checksum) 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 *Checksum) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *Checksum) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if m.XXX_unrecognized != nil {
i -= len(m.XXX_unrecognized)
copy(dAtA[i:], m.XXX_unrecognized)
}
if len(m.Sum) > 0 {
i -= len(m.Sum)
copy(dAtA[i:], m.Sum)
i = encodeVarintTypes(dAtA, i, uint64(len(m.Sum)))
i--
dAtA[i] = 0x12
}
if m.Type != 0 {
i = encodeVarintTypes(dAtA, i, uint64(m.Type))
i--
dAtA[i] = 0x8
}
return len(dAtA) - i, nil
}
func encodeVarintTypes(dAtA []byte, offset int, v uint64) int {
offset -= sovTypes(v)
base := offset
@ -489,6 +826,63 @@ func (m *OwnerID) Size() (n int) {
return n
}
func (m *Version) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
if m.Major != 0 {
n += 1 + sovTypes(uint64(m.Major))
}
if m.Minor != 0 {
n += 1 + sovTypes(uint64(m.Minor))
}
if m.XXX_unrecognized != nil {
n += len(m.XXX_unrecognized)
}
return n
}
func (m *Signature) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
l = len(m.Key)
if l > 0 {
n += 1 + l + sovTypes(uint64(l))
}
l = len(m.Sign)
if l > 0 {
n += 1 + l + sovTypes(uint64(l))
}
if m.XXX_unrecognized != nil {
n += len(m.XXX_unrecognized)
}
return n
}
func (m *Checksum) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
if m.Type != 0 {
n += 1 + sovTypes(uint64(m.Type))
}
l = len(m.Sum)
if l > 0 {
n += 1 + l + sovTypes(uint64(l))
}
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
}
@ -885,6 +1279,327 @@ func (m *OwnerID) Unmarshal(dAtA []byte) error {
}
return nil
}
func (m *Version) 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: Version: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: Version: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Major", wireType)
}
m.Major = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.Major |= uint32(b&0x7F) << shift
if b < 0x80 {
break
}
}
case 2:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Minor", wireType)
}
m.Minor = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.Minor |= 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 (m *Signature) 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: Signature: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: Signature: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
}
var byteLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
byteLen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if byteLen < 0 {
return ErrInvalidLengthTypes
}
postIndex := iNdEx + byteLen
if postIndex < 0 {
return ErrInvalidLengthTypes
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...)
if m.Key == nil {
m.Key = []byte{}
}
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Sign", wireType)
}
var byteLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
byteLen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if byteLen < 0 {
return ErrInvalidLengthTypes
}
postIndex := iNdEx + byteLen
if postIndex < 0 {
return ErrInvalidLengthTypes
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Sign = append(m.Sign[:0], dAtA[iNdEx:postIndex]...)
if m.Sign == nil {
m.Sign = []byte{}
}
iNdEx = postIndex
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 (m *Checksum) 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: Checksum: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: Checksum: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
}
m.Type = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.Type |= ChecksumType(b&0x7F) << shift
if b < 0x80 {
break
}
}
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Sum", wireType)
}
var byteLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
byteLen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if byteLen < 0 {
return ErrInvalidLengthTypes
}
postIndex := iNdEx + byteLen
if postIndex < 0 {
return ErrInvalidLengthTypes
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Sum = append(m.Sum[:0], dAtA[iNdEx:postIndex]...)
if m.Sum == nil {
m.Sum = []byte{}
}
iNdEx = postIndex
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

View file

@ -7,9 +7,8 @@ import (
context "context"
fmt "fmt"
proto "github.com/golang/protobuf/proto"
grpc1 "github.com/nspcc-dev/neofs-api-go/v2/refs/grpc"
grpc "github.com/nspcc-dev/neofs-api-go/v2/service/grpc"
grpc2 "google.golang.org/grpc"
grpc "github.com/nspcc-dev/neofs-api-go/v2/refs/grpc"
grpc1 "google.golang.org/grpc"
codes "google.golang.org/grpc/codes"
status "google.golang.org/grpc/status"
io "io"
@ -34,13 +33,13 @@ type CreateRequest struct {
Body *CreateRequest_Body `protobuf:"bytes,1,opt,name=body,proto3" json:"body,omitempty"`
// Carries request meta information. Header data is used only to regulate message
// transport and does not affect request execution.
MetaHeader *grpc.RequestMetaHeader `protobuf:"bytes,2,opt,name=meta_header,json=metaHeader,proto3" json:"meta_header,omitempty"`
MetaHeader *RequestMetaHeader `protobuf:"bytes,2,opt,name=meta_header,json=metaHeader,proto3" json:"meta_header,omitempty"`
// Carries request verification information. This header is used to authenticate
// the nodes of the message route and check the correctness of transmission.
VerifyHeader *grpc.RequestVerificationHeader `protobuf:"bytes,3,opt,name=verify_header,json=verifyHeader,proto3" json:"verify_header,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
VerifyHeader *RequestVerificationHeader `protobuf:"bytes,3,opt,name=verify_header,json=verifyHeader,proto3" json:"verify_header,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CreateRequest) Reset() { *m = CreateRequest{} }
@ -83,14 +82,14 @@ func (m *CreateRequest) GetBody() *CreateRequest_Body {
return nil
}
func (m *CreateRequest) GetMetaHeader() *grpc.RequestMetaHeader {
func (m *CreateRequest) GetMetaHeader() *RequestMetaHeader {
if m != nil {
return m.MetaHeader
}
return nil
}
func (m *CreateRequest) GetVerifyHeader() *grpc.RequestVerificationHeader {
func (m *CreateRequest) GetVerifyHeader() *RequestVerificationHeader {
if m != nil {
return m.VerifyHeader
}
@ -100,12 +99,12 @@ func (m *CreateRequest) GetVerifyHeader() *grpc.RequestVerificationHeader {
// Request body
type CreateRequest_Body struct {
// Carries an identifier of a session initiator.
OwnerId *grpc1.OwnerID `protobuf:"bytes,1,opt,name=owner_id,json=ownerId,proto3" json:"owner_id,omitempty"`
// Carries a lifetime of the session.
Lifetime *grpc.TokenLifetime `protobuf:"bytes,2,opt,name=lifetime,proto3" json:"lifetime,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
OwnerId *grpc.OwnerID `protobuf:"bytes,1,opt,name=owner_id,json=ownerId,proto3" json:"owner_id,omitempty"`
// Expiration Epoch
Expiration uint64 `protobuf:"varint,2,opt,name=expiration,proto3" json:"expiration,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CreateRequest_Body) Reset() { *m = CreateRequest_Body{} }
@ -141,18 +140,18 @@ func (m *CreateRequest_Body) XXX_DiscardUnknown() {
var xxx_messageInfo_CreateRequest_Body proto.InternalMessageInfo
func (m *CreateRequest_Body) GetOwnerId() *grpc1.OwnerID {
func (m *CreateRequest_Body) GetOwnerId() *grpc.OwnerID {
if m != nil {
return m.OwnerId
}
return nil
}
func (m *CreateRequest_Body) GetLifetime() *grpc.TokenLifetime {
func (m *CreateRequest_Body) GetExpiration() uint64 {
if m != nil {
return m.Lifetime
return m.Expiration
}
return nil
return 0
}
// CreateResponse carries an information about the opened session.
@ -161,14 +160,14 @@ type CreateResponse struct {
Body *CreateResponse_Body `protobuf:"bytes,1,opt,name=body,proto3" json:"body,omitempty"`
// Carries response meta information. Header data is used only to regulate
// message transport and does not affect request execution.
MetaHeader *grpc.ResponseMetaHeader `protobuf:"bytes,2,opt,name=meta_header,json=metaHeader,proto3" json:"meta_header,omitempty"`
MetaHeader *ResponseMetaHeader `protobuf:"bytes,2,opt,name=meta_header,json=metaHeader,proto3" json:"meta_header,omitempty"`
// Carries response verification information. This header is used to
// authenticate the nodes of the message route and check the correctness
// of transmission.
VerifyHeader *grpc.ResponseVerificationHeader `protobuf:"bytes,3,opt,name=verify_header,json=verifyHeader,proto3" json:"verify_header,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
VerifyHeader *ResponseVerificationHeader `protobuf:"bytes,3,opt,name=verify_header,json=verifyHeader,proto3" json:"verify_header,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CreateResponse) Reset() { *m = CreateResponse{} }
@ -211,14 +210,14 @@ func (m *CreateResponse) GetBody() *CreateResponse_Body {
return nil
}
func (m *CreateResponse) GetMetaHeader() *grpc.ResponseMetaHeader {
func (m *CreateResponse) GetMetaHeader() *ResponseMetaHeader {
if m != nil {
return m.MetaHeader
}
return nil
}
func (m *CreateResponse) GetVerifyHeader() *grpc.ResponseVerificationHeader {
func (m *CreateResponse) GetVerifyHeader() *ResponseVerificationHeader {
if m != nil {
return m.VerifyHeader
}
@ -293,63 +292,62 @@ func init() {
func init() { proto.RegisterFile("v2/session/grpc/service.proto", fileDescriptor_4ed1365cc8e16cd4) }
var fileDescriptor_4ed1365cc8e16cd4 = []byte{
// 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, 0x8a, 0x28, 0x65, 0x62, 0x88,
0x03, 0x75, 0xa4, 0x70, 0x40, 0x03, 0x2e, 0x0c, 0x98, 0xa8, 0x60, 0xfc, 0x71, 0x11, 0x07, 0x2e,
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,
// 444 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x93, 0x4d, 0x6f, 0xd3, 0x30,
0x18, 0xc7, 0x49, 0xa8, 0x06, 0x7a, 0xda, 0x55, 0xc2, 0x42, 0xa2, 0x2a, 0x22, 0x8c, 0x89, 0x21,
0x0e, 0xd4, 0x91, 0xc2, 0x01, 0x0d, 0x4e, 0x0c, 0x98, 0xa8, 0xd0, 0x78, 0x71, 0x25, 0x0e, 0xbb,
0x54, 0x79, 0x79, 0xd2, 0x59, 0xa8, 0x71, 0xb0, 0xbd, 0x40, 0xbe, 0x09, 0x57, 0xae, 0x7c, 0x0a,
0x8e, 0x1c, 0xf9, 0x08, 0xa8, 0x7c, 0x11, 0x14, 0xdb, 0x43, 0xd9, 0x96, 0xad, 0xb7, 0x38, 0xfe,
0x3f, 0x3f, 0x3f, 0xcf, 0x4f, 0x36, 0xdc, 0xa9, 0xa2, 0x50, 0xa1, 0x52, 0x5c, 0x14, 0xe1, 0x42,
0x96, 0x69, 0xa8, 0x50, 0x56, 0x3c, 0x45, 0x5a, 0x4a, 0xa1, 0x05, 0xb9, 0x51, 0xa0, 0xa0, 0xb9,
0xa2, 0x55, 0x44, 0x5d, 0x6a, 0x3c, 0xaa, 0xa2, 0x50, 0x62, 0xae, 0x6c, 0x5c, 0xd7, 0x25, 0x2a,
0x1b, 0x1e, 0xdf, 0x3e, 0xcb, 0x6a, 0x6d, 0x6e, 0xff, 0xf4, 0x61, 0xf3, 0x85, 0xc4, 0x58, 0x23,
0xc3, 0xcf, 0xc7, 0xa8, 0x34, 0xd9, 0x85, 0x5e, 0x22, 0xb2, 0x7a, 0xe4, 0x6d, 0x79, 0x0f, 0xfb,
0xd1, 0x0e, 0x3d, 0x77, 0x14, 0x3d, 0x95, 0xa7, 0x7b, 0x22, 0xab, 0x99, 0x29, 0x21, 0xaf, 0xa0,
0xbf, 0x44, 0x1d, 0xcf, 0x8f, 0x30, 0xce, 0x50, 0x8e, 0x7c, 0x43, 0xb8, 0xdf, 0x41, 0x70, 0xb5,
0x07, 0xa8, 0xe3, 0xd7, 0x26, 0xcb, 0x60, 0xf9, 0xff, 0x9b, 0x7c, 0x80, 0xcd, 0x0a, 0x25, 0xcf,
0xeb, 0x13, 0xd0, 0x55, 0x03, 0x7a, 0x74, 0x31, 0xe8, 0x63, 0x13, 0xe7, 0x69, 0xac, 0xb9, 0x28,
0x1c, 0x70, 0x60, 0x11, 0x76, 0x35, 0x3e, 0x84, 0x5e, 0xd3, 0x27, 0x89, 0xe0, 0xba, 0xf8, 0x52,
0xa0, 0x9c, 0xf3, 0xcc, 0x0d, 0x78, 0xab, 0x45, 0x6d, 0xfc, 0xd1, 0x77, 0xcd, 0xfe, 0xf4, 0x25,
0xbb, 0x66, 0x82, 0xd3, 0x8c, 0x04, 0x00, 0xf8, 0xb5, 0xe4, 0xd2, 0xd0, 0xcd, 0x50, 0x3d, 0xd6,
0xfa, 0xb3, 0xfd, 0xdd, 0x87, 0xe1, 0x89, 0x12, 0x55, 0x8a, 0x42, 0x21, 0x79, 0x7a, 0xca, 0xe1,
0x83, 0x4b, 0x1c, 0xda, 0x82, 0xb6, 0xc4, 0xfd, 0x2e, 0x89, 0x3b, 0x9d, 0xb3, 0xdb, 0xe2, 0x0b,
0x2c, 0xb2, 0x6e, 0x8b, 0x93, 0x4b, 0x48, 0x6b, 0x35, 0x3e, 0x71, 0x1a, 0x87, 0xe0, 0x3b, 0x81,
0x03, 0xe6, 0xf3, 0x8c, 0xdc, 0x85, 0xbe, 0x63, 0xcd, 0x3f, 0x61, 0x6d, 0x7a, 0x1e, 0x30, 0x70,
0xbf, 0xde, 0x60, 0x1d, 0xcd, 0x61, 0x38, 0xb3, 0xab, 0x99, 0xbd, 0xc8, 0xe4, 0x00, 0x36, 0xac,
0x03, 0xb2, 0xb5, 0xee, 0x8a, 0x8d, 0xef, 0xad, 0x15, 0xb8, 0x97, 0xfc, 0x5a, 0x05, 0xde, 0xef,
0x55, 0xe0, 0xfd, 0x59, 0x05, 0xde, 0xb7, 0xbf, 0xc1, 0x95, 0xc3, 0xdd, 0x05, 0xd7, 0x47, 0xc7,
0x09, 0x4d, 0xc5, 0x32, 0x2c, 0x54, 0x99, 0xa6, 0x93, 0x0c, 0xab, 0xb0, 0x40, 0x91, 0xab, 0x49,
0x5c, 0xf2, 0xc9, 0x42, 0x84, 0x67, 0x1e, 0xc6, 0x33, 0xb7, 0xf8, 0xe1, 0xdf, 0x7c, 0x8b, 0x62,
0x7f, 0x46, 0x9f, 0xbf, 0x9f, 0x36, 0x47, 0xba, 0xce, 0x93, 0x0d, 0xf3, 0x64, 0x1e, 0xff, 0x0b,
0x00, 0x00, 0xff, 0xff, 0xd3, 0xaa, 0x38, 0x65, 0x9d, 0x03, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc2.ClientConn
var _ grpc1.ClientConn
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc2.SupportPackageIsVersion4
const _ = grpc1.SupportPackageIsVersion4
// SessionServiceClient is the client API for SessionService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type SessionServiceClient interface {
// Create opens new session between the client and the server.
Create(ctx context.Context, in *CreateRequest, opts ...grpc2.CallOption) (*CreateResponse, error)
Create(ctx context.Context, in *CreateRequest, opts ...grpc1.CallOption) (*CreateResponse, error)
}
type sessionServiceClient struct {
cc *grpc2.ClientConn
cc *grpc1.ClientConn
}
func NewSessionServiceClient(cc *grpc2.ClientConn) SessionServiceClient {
func NewSessionServiceClient(cc *grpc1.ClientConn) SessionServiceClient {
return &sessionServiceClient{cc}
}
func (c *sessionServiceClient) Create(ctx context.Context, in *CreateRequest, opts ...grpc2.CallOption) (*CreateResponse, error) {
func (c *sessionServiceClient) Create(ctx context.Context, in *CreateRequest, opts ...grpc1.CallOption) (*CreateResponse, error) {
out := new(CreateResponse)
err := c.cc.Invoke(ctx, "/neo.fs.v2.session.SessionService/Create", in, out, opts...)
if err != nil {
@ -372,11 +370,11 @@ func (*UnimplementedSessionServiceServer) Create(ctx context.Context, req *Creat
return nil, status.Errorf(codes.Unimplemented, "method Create not implemented")
}
func RegisterSessionServiceServer(s *grpc2.Server, srv SessionServiceServer) {
func RegisterSessionServiceServer(s *grpc1.Server, srv SessionServiceServer) {
s.RegisterService(&_SessionService_serviceDesc, srv)
}
func _SessionService_Create_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc2.UnaryServerInterceptor) (interface{}, error) {
func _SessionService_Create_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc1.UnaryServerInterceptor) (interface{}, error) {
in := new(CreateRequest)
if err := dec(in); err != nil {
return nil, err
@ -384,7 +382,7 @@ func _SessionService_Create_Handler(srv interface{}, ctx context.Context, dec fu
if interceptor == nil {
return srv.(SessionServiceServer).Create(ctx, in)
}
info := &grpc2.UnaryServerInfo{
info := &grpc1.UnaryServerInfo{
Server: srv,
FullMethod: "/neo.fs.v2.session.SessionService/Create",
}
@ -394,16 +392,16 @@ func _SessionService_Create_Handler(srv interface{}, ctx context.Context, dec fu
return interceptor(ctx, in, info, handler)
}
var _SessionService_serviceDesc = grpc2.ServiceDesc{
var _SessionService_serviceDesc = grpc1.ServiceDesc{
ServiceName: "neo.fs.v2.session.SessionService",
HandlerType: (*SessionServiceServer)(nil),
Methods: []grpc2.MethodDesc{
Methods: []grpc1.MethodDesc{
{
MethodName: "Create",
Handler: _SessionService_Create_Handler,
},
},
Streams: []grpc2.StreamDesc{},
Streams: []grpc1.StreamDesc{},
Metadata: "v2/session/grpc/service.proto",
}
@ -494,17 +492,10 @@ func (m *CreateRequest_Body) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i -= len(m.XXX_unrecognized)
copy(dAtA[i:], m.XXX_unrecognized)
}
if m.Lifetime != nil {
{
size, err := m.Lifetime.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintService(dAtA, i, uint64(size))
}
if m.Expiration != 0 {
i = encodeVarintService(dAtA, i, uint64(m.Expiration))
i--
dAtA[i] = 0x12
dAtA[i] = 0x10
}
if m.OwnerId != nil {
{
@ -670,9 +661,8 @@ func (m *CreateRequest_Body) Size() (n int) {
l = m.OwnerId.Size()
n += 1 + l + sovService(uint64(l))
}
if m.Lifetime != nil {
l = m.Lifetime.Size()
n += 1 + l + sovService(uint64(l))
if m.Expiration != 0 {
n += 1 + sovService(uint64(m.Expiration))
}
if m.XXX_unrecognized != nil {
n += len(m.XXX_unrecognized)
@ -825,7 +815,7 @@ func (m *CreateRequest) Unmarshal(dAtA []byte) error {
return io.ErrUnexpectedEOF
}
if m.MetaHeader == nil {
m.MetaHeader = &grpc.RequestMetaHeader{}
m.MetaHeader = &RequestMetaHeader{}
}
if err := m.MetaHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
@ -861,7 +851,7 @@ func (m *CreateRequest) Unmarshal(dAtA []byte) error {
return io.ErrUnexpectedEOF
}
if m.VerifyHeader == nil {
m.VerifyHeader = &grpc.RequestVerificationHeader{}
m.VerifyHeader = &RequestVerificationHeader{}
}
if err := m.VerifyHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
@ -951,17 +941,17 @@ func (m *CreateRequest_Body) Unmarshal(dAtA []byte) error {
return io.ErrUnexpectedEOF
}
if m.OwnerId == nil {
m.OwnerId = &grpc1.OwnerID{}
m.OwnerId = &grpc.OwnerID{}
}
if err := m.OwnerId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Lifetime", wireType)
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Expiration", wireType)
}
var msglen int
m.Expiration = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowService
@ -971,28 +961,11 @@ func (m *CreateRequest_Body) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
m.Expiration |= uint64(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.Lifetime == nil {
m.Lifetime = &grpc.TokenLifetime{}
}
if err := m.Lifetime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipService(dAtA[iNdEx:])
@ -1113,7 +1086,7 @@ func (m *CreateResponse) Unmarshal(dAtA []byte) error {
return io.ErrUnexpectedEOF
}
if m.MetaHeader == nil {
m.MetaHeader = &grpc.ResponseMetaHeader{}
m.MetaHeader = &ResponseMetaHeader{}
}
if err := m.MetaHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
@ -1149,7 +1122,7 @@ func (m *CreateResponse) Unmarshal(dAtA []byte) error {
return io.ErrUnexpectedEOF
}
if m.VerifyHeader == nil {
m.VerifyHeader = &grpc.ResponseVerificationHeader{}
m.VerifyHeader = &ResponseVerificationHeader{}
}
if err := m.VerifyHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err

File diff suppressed because it is too large Load diff

View file

@ -33,7 +33,7 @@ type StorageGroup struct {
// payloads of the storage group members
// The order of concatenation is the same as the order of the members in the
// Members field.
ValidationHash []byte `protobuf:"bytes,2,opt,name=validation_hash,json=validationHash,proto3" json:"validation_hash,omitempty"`
ValidationHash *grpc.Checksum `protobuf:"bytes,2,opt,name=validation_hash,json=validationHash,proto3" json:"validation_hash,omitempty"`
// expiration_epoch carries last NeoFS epoch number of the storage group
// lifetime.
ExpirationEpoch uint64 `protobuf:"varint,3,opt,name=expiration_epoch,json=expirationEpoch,proto3" json:"expiration_epoch,omitempty"`
@ -85,7 +85,7 @@ func (m *StorageGroup) GetValidationDataSize() uint64 {
return 0
}
func (m *StorageGroup) GetValidationHash() []byte {
func (m *StorageGroup) GetValidationHash() *grpc.Checksum {
if m != nil {
return m.ValidationHash
}
@ -113,26 +113,27 @@ func init() {
func init() { proto.RegisterFile("v2/storagegroup/grpc/types.proto", fileDescriptor_f1685cc94b670845) }
var fileDescriptor_f1685cc94b670845 = []byte{
// 301 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x90, 0xcd, 0x4a, 0x33, 0x31,
0x18, 0x85, 0xbf, 0xb4, 0xe5, 0x13, 0x62, 0xb1, 0x12, 0x44, 0xa2, 0x8b, 0x61, 0x70, 0x63, 0x5d,
0x34, 0x91, 0x71, 0xe9, 0x4a, 0xad, 0x3f, 0xdd, 0xa8, 0xb4, 0x3b, 0x37, 0x25, 0x93, 0xbe, 0x9d,
0x89, 0xd8, 0x49, 0x4c, 0xd2, 0x41, 0x7b, 0x25, 0x5e, 0x83, 0x57, 0xd2, 0xa5, 0x97, 0x20, 0xe3,
0x8d, 0xc8, 0xb4, 0xc8, 0x0c, 0xe8, 0xf6, 0xc9, 0x73, 0xf2, 0x72, 0x0e, 0x0e, 0xf3, 0x88, 0x3b,
0xaf, 0xad, 0x48, 0x20, 0xb1, 0x7a, 0x6e, 0x78, 0x62, 0x8d, 0xe4, 0xfe, 0xd5, 0x80, 0x63, 0xc6,
0x6a, 0xaf, 0xc9, 0x6e, 0x06, 0x9a, 0x4d, 0x1d, 0xcb, 0x23, 0x56, 0x17, 0xf7, 0x69, 0x1e, 0x71,
0x0b, 0x53, 0xf7, 0x2b, 0x71, 0xb0, 0x44, 0xb8, 0x3d, 0x5a, 0xab, 0xd7, 0xa5, 0x4a, 0x8e, 0xf1,
0x4e, 0x2e, 0x9e, 0xd4, 0x44, 0x78, 0xa5, 0xb3, 0xf1, 0x44, 0x78, 0x31, 0x76, 0x6a, 0x01, 0x14,
0x85, 0xa8, 0xdb, 0x1a, 0x92, 0xea, 0xad, 0x2f, 0xbc, 0x18, 0xa9, 0x05, 0x90, 0x43, 0xdc, 0xa9,
0x25, 0x52, 0xe1, 0x52, 0xda, 0x08, 0x51, 0xb7, 0x3d, 0xdc, 0xaa, 0xf0, 0x8d, 0x70, 0x29, 0x39,
0xc2, 0xdb, 0xf0, 0x62, 0x94, 0x5d, 0x8b, 0x60, 0xb4, 0x4c, 0x69, 0x73, 0xf5, 0x6d, 0xa7, 0xe2,
0x97, 0x25, 0x26, 0x11, 0xde, 0x98, 0xc1, 0x2c, 0x06, 0xeb, 0x68, 0x2b, 0x6c, 0x76, 0x37, 0x23,
0xca, 0xaa, 0x6a, 0x65, 0x13, 0x76, 0x17, 0x3f, 0x82, 0xf4, 0x83, 0xfe, 0xf0, 0x47, 0x3c, 0x7f,
0x5e, 0x16, 0x01, 0xfa, 0x28, 0x02, 0xf4, 0x59, 0x04, 0xe8, 0xed, 0x2b, 0xf8, 0xf7, 0x70, 0x91,
0x28, 0x9f, 0xce, 0x63, 0x26, 0xf5, 0x8c, 0x67, 0xce, 0x48, 0xd9, 0x9b, 0x40, 0xce, 0x33, 0xd0,
0x53, 0xd7, 0x13, 0x46, 0xf5, 0x12, 0xcd, 0xff, 0x9a, 0xf4, 0xb4, 0x4e, 0xde, 0x1b, 0x7b, 0xb7,
0xa0, 0xaf, 0x46, 0xec, 0xec, 0x7e, 0x50, 0x1e, 0xaf, 0x8f, 0x15, 0xff, 0x5f, 0x8d, 0x78, 0xf2,
0x1d, 0x00, 0x00, 0xff, 0xff, 0xcd, 0x95, 0x67, 0x64, 0x9a, 0x01, 0x00, 0x00,
// 306 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x90, 0x3f, 0x4e, 0xc3, 0x30,
0x18, 0xc5, 0x71, 0x5b, 0x81, 0x14, 0x10, 0x45, 0x11, 0x42, 0x86, 0x21, 0x8a, 0x98, 0xca, 0x50,
0x1b, 0x85, 0x91, 0xa9, 0xb4, 0xfc, 0xe9, 0x02, 0xa8, 0xdd, 0x58, 0x2a, 0xc7, 0xfd, 0x1a, 0x1b,
0x48, 0x6c, 0x6c, 0x37, 0x82, 0x9e, 0x84, 0x33, 0x70, 0x12, 0x46, 0x8e, 0x80, 0xc2, 0x45, 0x50,
0x5a, 0xa1, 0x44, 0xa2, 0xeb, 0xf3, 0xef, 0xf9, 0xf7, 0xe9, 0x79, 0x61, 0x1e, 0x51, 0xeb, 0x94,
0x61, 0x09, 0x24, 0x46, 0xcd, 0x35, 0x4d, 0x8c, 0xe6, 0xd4, 0xbd, 0x69, 0xb0, 0x44, 0x1b, 0xe5,
0x94, 0x7f, 0x90, 0x81, 0x22, 0x33, 0x4b, 0xf2, 0x88, 0xd4, 0xc1, 0x23, 0x9c, 0x47, 0xd4, 0xc0,
0xcc, 0xfe, 0x6b, 0x1c, 0x17, 0xc8, 0xdb, 0x19, 0xaf, 0xd0, 0xeb, 0x12, 0xf5, 0x4f, 0xbd, 0xfd,
0x9c, 0x3d, 0xcb, 0x29, 0x73, 0x52, 0x65, 0x93, 0x29, 0x73, 0x6c, 0x62, 0xe5, 0x02, 0x30, 0x0a,
0x51, 0xa7, 0x35, 0xf2, 0xab, 0xb7, 0x01, 0x73, 0x6c, 0x2c, 0x17, 0xe0, 0xf7, 0xbc, 0x76, 0xad,
0x21, 0x98, 0x15, 0xb8, 0x11, 0xa2, 0xce, 0x76, 0x84, 0x49, 0x75, 0x4e, 0x69, 0x27, 0x7d, 0x01,
0xfc, 0xc9, 0xce, 0xd3, 0xd1, 0x6e, 0x55, 0xb8, 0x61, 0x56, 0xf8, 0x27, 0xde, 0x1e, 0xbc, 0x6a,
0x69, 0x56, 0x5f, 0x80, 0x56, 0x5c, 0xe0, 0xe6, 0x52, 0xd8, 0xae, 0xf2, 0xcb, 0x32, 0xf6, 0x23,
0x6f, 0x2b, 0x85, 0x34, 0x06, 0x63, 0x71, 0x2b, 0x6c, 0xae, 0xb3, 0xdc, 0xc5, 0x8f, 0xc0, 0xdd,
0x70, 0x30, 0xfa, 0x03, 0x2f, 0x5e, 0x3e, 0x8b, 0x00, 0x7d, 0x15, 0x01, 0xfa, 0x2e, 0x02, 0xf4,
0xfe, 0x13, 0x6c, 0x3c, 0xf4, 0x13, 0xe9, 0xc4, 0x3c, 0x26, 0x5c, 0xa5, 0x34, 0xb3, 0x9a, 0xf3,
0xee, 0x14, 0x72, 0x9a, 0x81, 0x9a, 0xd9, 0x2e, 0xd3, 0xb2, 0x9b, 0x28, 0xba, 0x6e, 0xec, 0xf3,
0x7a, 0xf2, 0xd1, 0x38, 0xbc, 0x05, 0x75, 0x35, 0x26, 0xbd, 0xfb, 0x61, 0x29, 0xaf, 0xcf, 0x18,
0x6f, 0x2e, 0xe7, 0x3d, 0xfb, 0x0d, 0x00, 0x00, 0xff, 0xff, 0x31, 0x2e, 0xd2, 0x63, 0xb4, 0x01,
0x00, 0x00,
}
func (m *StorageGroup) Marshal() (dAtA []byte, err error) {
@ -178,10 +179,15 @@ func (m *StorageGroup) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i--
dAtA[i] = 0x18
}
if len(m.ValidationHash) > 0 {
i -= len(m.ValidationHash)
copy(dAtA[i:], m.ValidationHash)
i = encodeVarintTypes(dAtA, i, uint64(len(m.ValidationHash)))
if m.ValidationHash != nil {
{
size, err := m.ValidationHash.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintTypes(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x12
}
@ -213,8 +219,8 @@ func (m *StorageGroup) Size() (n int) {
if m.ValidationDataSize != 0 {
n += 1 + sovTypes(uint64(m.ValidationDataSize))
}
l = len(m.ValidationHash)
if l > 0 {
if m.ValidationHash != nil {
l = m.ValidationHash.Size()
n += 1 + l + sovTypes(uint64(l))
}
if m.ExpirationEpoch != 0 {
@ -290,7 +296,7 @@ func (m *StorageGroup) Unmarshal(dAtA []byte) error {
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ValidationHash", wireType)
}
var byteLen int
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
@ -300,24 +306,26 @@ func (m *StorageGroup) 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 ErrInvalidLengthTypes
}
postIndex := iNdEx + byteLen
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthTypes
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.ValidationHash = append(m.ValidationHash[:0], dAtA[iNdEx:postIndex]...)
if m.ValidationHash == nil {
m.ValidationHash = []byte{}
m.ValidationHash = &grpc.Checksum{}
}
if err := m.ValidationHash.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 3: