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

Update structure with grpc subdir

Browse source 
Signed-off-by: Alex Vanin <alexey@nspcc.ru>
This commit is contained in:
Alex Vanin 2020-08-14 19:00:16 +03:00 committed by Stanislav Bogatyrev
parent 6191903326
commit 60e9c3d0d3
40 changed files with 1624 additions and 1595 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

11
prepare.sh
View file

@ -16,13 +16,16 @@ cd $API_PATH
ARGS=$(find ./ -name '*.proto' -not -path './vendor/*')
for file in $ARGS; do
dir=$(dirname $file)
cp -r $dir $API_GO_PATH/$prefix
mkdir -p $API_GO_PATH/$prefix/$dir/grpc
cp -r $dir/* $API_GO_PATH/$prefix/$dir/grpc
done
# MODIFY FILES
cd $API_GO_PATH/$prefix
for file in $ARGS; do
sed -i "s/import\ \"\(.*\)\";/import\ \"$prefix\/\1\";/" $file
ARGS2=$(find ./ -name '*.proto')
for file in $ARGS2; do
echo $file
sed -i "s/import\ \"\(.*\)\/\(.*\)\.proto\";/import\ \"$prefix\/\1\/grpc\/\2\.proto\";/" $file
done
cd $API_GO_PATH
@ -30,7 +33,7 @@ cd $API_GO_PATH
make protoc
# REMOVE PROTO DEFINITIONS
ARGS=$(find ./ -name '*.proto' -not -path './vendor/*')
ARGS=$(find ./$prefix -name '*.proto' -not -path './vendor/*')
for file in $ARGS; do
rm $file
done

25
v2/accounting.go → v2/accounting/accounting.go
View file

@ -1,18 +1,23 @@
package v2
package accounting
import (
"github.com/nspcc-dev/neofs-api-go/v2/refs"
"github.com/nspcc-dev/neofs-api-go/v2/service"
)
type BalanceRequestBody struct {
ownerID *OwnerID
ownerID *refs.OwnerID
}
type BalanceRequest struct {
body *BalanceRequestBody
metaHeader *RequestMetaHeader
metaHeader *service.RequestMetaHeader
verifyHeader *RequestVerificationHeader
verifyHeader *service.RequestVerificationHeader
}
func (b *BalanceRequestBody) GetOwnerID() *OwnerID {
func (b *BalanceRequestBody) GetOwnerID() *refs.OwnerID {
if b != nil {
return b.ownerID
}
@ -20,7 +25,7 @@ func (b *BalanceRequestBody) GetOwnerID() *OwnerID {
return nil
}
func (b *BalanceRequestBody) SetOwnerID(v *OwnerID) {
func (b *BalanceRequestBody) SetOwnerID(v *refs.OwnerID) {
if b != nil {
b.ownerID = v
}
@ -56,7 +61,7 @@ func (b *BalanceRequest) SetBody(v *BalanceRequestBody) {
}
}
func (b *BalanceRequest) GetRequestMetaHeader() *RequestMetaHeader {
func (b *BalanceRequest) GetRequestMetaHeader() *service.RequestMetaHeader {
if b != nil {
return b.metaHeader
}
@ -64,13 +69,13 @@ func (b *BalanceRequest) GetRequestMetaHeader() *RequestMetaHeader {
return nil
}
func (b *BalanceRequest) SetRequestMetaHeader(v *RequestMetaHeader) {
func (b *BalanceRequest) SetRequestMetaHeader(v *service.RequestMetaHeader) {
if b != nil {
b.metaHeader = v
}
}
func (b *BalanceRequest) GetRequestVerificationHeader() *RequestVerificationHeader {
func (b *BalanceRequest) GetRequestVerificationHeader() *service.RequestVerificationHeader {
if b != nil {
return b.verifyHeader
}
@ -78,7 +83,7 @@ func (b *BalanceRequest) GetRequestVerificationHeader() *RequestVerificationHead
return nil
}
func (b *BalanceRequest) SetRequestVerificationHeader(v *RequestVerificationHeader) {
func (b *BalanceRequest) SetRequestVerificationHeader(v *service.RequestVerificationHeader) {
if b != nil {
b.verifyHeader = v
}

106
v2/accounting/convert.go Normal file
View file

@ -0,0 +1,106 @@
package accounting
import (
accounting "github.com/nspcc-dev/neofs-api-go/v2/accounting/grpc"
"github.com/nspcc-dev/neofs-api-go/v2/refs"
"github.com/nspcc-dev/neofs-api-go/v2/service"
grpcService "github.com/nspcc-dev/neofs-api-go/v2/service/grpc"
)
func BalanceRequestBodyToGRPCMessage(b *BalanceRequestBody) *accounting.BalanceRequest_Body {
if b == nil {
return nil
}
m := new(accounting.BalanceRequest_Body)
m.SetOwnerId(
refs.OwnerIDToGRPCMessage(b.GetOwnerID()),
)
return m
}
func BalanceRequestBodyFromGRPCMessage(m *accounting.BalanceRequest_Body) *BalanceRequestBody {
if m == nil {
return nil
}
b := new(BalanceRequestBody)
b.SetOwnerID(
refs.OwnerIDFromGRPCMessage(m.GetOwnerId()),
)
return b
}
func headersToGRPC(
src interface {
GetRequestMetaHeader() *service.RequestMetaHeader
GetRequestVerificationHeader() *service.RequestVerificationHeader
},
dst interface {
SetMetaHeader(*grpcService.RequestMetaHeader)
SetVerifyHeader(*grpcService.RequestVerificationHeader)
},
) {
dst.SetMetaHeader(
service.RequestMetaHeaderToGRPCMessage(src.GetRequestMetaHeader()),
)
dst.SetVerifyHeader(
service.RequestVerificationHeaderToGRPCMessage(src.GetRequestVerificationHeader()),
)
}
func headersFromGRPC(
src interface {
GetMetaHeader() *grpcService.RequestMetaHeader
GetVerifyHeader() *grpcService.RequestVerificationHeader
},
dst interface {
SetRequestMetaHeader(*service.RequestMetaHeader)
SetRequestVerificationHeader(*service.RequestVerificationHeader)
},
) {
dst.SetRequestMetaHeader(
service.RequestMetaHeaderFromGRPCMessage(src.GetMetaHeader()),
)
dst.SetRequestVerificationHeader(
service.RequestVerificationHeaderFromGRPCMessage(src.GetVerifyHeader()),
)
}
func BalanceRequestToGRPCMessage(b *BalanceRequest) *accounting.BalanceRequest {
if b == nil {
return nil
}
m := new(accounting.BalanceRequest)
m.SetBody(
BalanceRequestBodyToGRPCMessage(b.GetBody()),
)
headersToGRPC(b, m)
return m
}
func BalanceRequestFromGRPCMessage(m *accounting.BalanceRequest) *BalanceRequest {
if m == nil {
return nil
}
b := new(BalanceRequest)
b.SetBody(
BalanceRequestBodyFromGRPCMessage(m.GetBody()),
)
headersFromGRPC(m, b)
return b
}

4
v2/accounting/service.go → v2/accounting/grpc/service.go
View file

@ -1,8 +1,8 @@
package accounting
import (
"github.com/nspcc-dev/neofs-api-go/v2/refs"
"github.com/nspcc-dev/neofs-api-go/v2/service"
refs "github.com/nspcc-dev/neofs-api-go/v2/refs/grpc"
service "github.com/nspcc-dev/neofs-api-go/v2/service/grpc"
)
// SetValue sets value of the decimal number.

158
v2/accounting/service.pb.go → v2/accounting/grpc/service.pb.go
View file

@ -1,5 +1,5 @@
// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: v2/accounting/service.proto
// source: v2/accounting/grpc/service.proto
package accounting
@ -7,9 +7,9 @@ import (
context "context"
fmt "fmt"
proto "github.com/golang/protobuf/proto"
refs "github.com/nspcc-dev/neofs-api-go/v2/refs"
service "github.com/nspcc-dev/neofs-api-go/v2/service"
grpc "google.golang.org/grpc"
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"
codes "google.golang.org/grpc/codes"
status "google.golang.org/grpc/status"
io "io"
@ -40,21 +40,21 @@ type BalanceRequest struct {
Body *BalanceRequest_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 *service.RequestMetaHeader `protobuf:"bytes,2,opt,name=meta_header,json=metaHeader,proto3" json:"meta_header,omitempty"`
MetaHeader *grpc.RequestMetaHeader `protobuf:"bytes,2,opt,name=meta_header,json=metaHeader,proto3" json:"meta_header,omitempty"`
// Carries request verification information. This header is used to
// authenticate the nodes of the message route and check the correctness
// of transmission.
VerifyHeader *service.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 *grpc.RequestVerificationHeader `protobuf:"bytes,3,opt,name=verify_header,json=verifyHeader,proto3" json:"verify_header,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *BalanceRequest) Reset() { *m = BalanceRequest{} }
func (m *BalanceRequest) String() string { return proto.CompactTextString(m) }
func (*BalanceRequest) ProtoMessage() {}
func (*BalanceRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_484f6b0e24e3172f, []int{0}
return fileDescriptor_d9dd5af2ff2bbb25, []int{0}
}
func (m *BalanceRequest) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -90,14 +90,14 @@ func (m *BalanceRequest) GetBody() *BalanceRequest_Body {
return nil
}
func (m *BalanceRequest) GetMetaHeader() *service.RequestMetaHeader {
func (m *BalanceRequest) GetMetaHeader() *grpc.RequestMetaHeader {
if m != nil {
return m.MetaHeader
}
return nil
}
func (m *BalanceRequest) GetVerifyHeader() *service.RequestVerificationHeader {
func (m *BalanceRequest) GetVerifyHeader() *grpc.RequestVerificationHeader {
if m != nil {
return m.VerifyHeader
}
@ -108,17 +108,17 @@ func (m *BalanceRequest) GetVerifyHeader() *service.RequestVerificationHeader {
type BalanceRequest_Body struct {
// Carries user identifier in NeoFS system for which the balance
// is requested.
OwnerId *refs.OwnerID `protobuf:"bytes,1,opt,name=owner_id,json=ownerId,proto3" json:"owner_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
OwnerId *grpc1.OwnerID `protobuf:"bytes,1,opt,name=owner_id,json=ownerId,proto3" json:"owner_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *BalanceRequest_Body) Reset() { *m = BalanceRequest_Body{} }
func (m *BalanceRequest_Body) String() string { return proto.CompactTextString(m) }
func (*BalanceRequest_Body) ProtoMessage() {}
func (*BalanceRequest_Body) Descriptor() ([]byte, []int) {
return fileDescriptor_484f6b0e24e3172f, []int{0, 0}
return fileDescriptor_d9dd5af2ff2bbb25, []int{0, 0}
}
func (m *BalanceRequest_Body) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -147,7 +147,7 @@ func (m *BalanceRequest_Body) XXX_DiscardUnknown() {
var xxx_messageInfo_BalanceRequest_Body proto.InternalMessageInfo
func (m *BalanceRequest_Body) GetOwnerId() *refs.OwnerID {
func (m *BalanceRequest_Body) GetOwnerId() *grpc1.OwnerID {
if m != nil {
return m.OwnerId
}
@ -169,7 +169,7 @@ func (m *Decimal) Reset() { *m = Decimal{} }
func (m *Decimal) String() string { return proto.CompactTextString(m) }
func (*Decimal) ProtoMessage() {}
func (*Decimal) Descriptor() ([]byte, []int) {
return fileDescriptor_484f6b0e24e3172f, []int{1}
return fileDescriptor_d9dd5af2ff2bbb25, []int{1}
}
func (m *Decimal) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -220,21 +220,21 @@ type BalanceResponse struct {
Body *BalanceResponse_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 *service.ResponseMetaHeader `protobuf:"bytes,2,opt,name=meta_header,json=metaHeader,proto3" json:"meta_header,omitempty"`
MetaHeader *grpc.ResponseMetaHeader `protobuf:"bytes,2,opt,name=meta_header,json=metaHeader,proto3" json:"meta_header,omitempty"`
// Carries response verification information. This header is used to
// authenticate the nodes of the message route and check the correctness
// of transmission.
VerifyHeader *service.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 *grpc.ResponseVerificationHeader `protobuf:"bytes,3,opt,name=verify_header,json=verifyHeader,proto3" json:"verify_header,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *BalanceResponse) Reset() { *m = BalanceResponse{} }
func (m *BalanceResponse) String() string { return proto.CompactTextString(m) }
func (*BalanceResponse) ProtoMessage() {}
func (*BalanceResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_484f6b0e24e3172f, []int{2}
return fileDescriptor_d9dd5af2ff2bbb25, []int{2}
}
func (m *BalanceResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -270,14 +270,14 @@ func (m *BalanceResponse) GetBody() *BalanceResponse_Body {
return nil
}
func (m *BalanceResponse) GetMetaHeader() *service.ResponseMetaHeader {
func (m *BalanceResponse) GetMetaHeader() *grpc.ResponseMetaHeader {
if m != nil {
return m.MetaHeader
}
return nil
}
func (m *BalanceResponse) GetVerifyHeader() *service.ResponseVerificationHeader {
func (m *BalanceResponse) GetVerifyHeader() *grpc.ResponseVerificationHeader {
if m != nil {
return m.VerifyHeader
}
@ -297,7 +297,7 @@ func (m *BalanceResponse_Body) Reset() { *m = BalanceResponse_Body{} }
func (m *BalanceResponse_Body) String() string { return proto.CompactTextString(m) }
func (*BalanceResponse_Body) ProtoMessage() {}
func (*BalanceResponse_Body) Descriptor() ([]byte, []int) {
return fileDescriptor_484f6b0e24e3172f, []int{2, 0}
return fileDescriptor_d9dd5af2ff2bbb25, []int{2, 0}
}
func (m *BalanceResponse_Body) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -341,67 +341,67 @@ func init() {
proto.RegisterType((*BalanceResponse_Body)(nil), "neo.fs.v2.accounting.BalanceResponse.Body")
}
func init() { proto.RegisterFile("v2/accounting/service.proto", fileDescriptor_484f6b0e24e3172f) }
func init() { proto.RegisterFile("v2/accounting/grpc/service.proto", fileDescriptor_d9dd5af2ff2bbb25) }
var fileDescriptor_484f6b0e24e3172f = []byte{
// 472 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x93, 0xdf, 0x6e, 0xd3, 0x30,
0x18, 0xc5, 0x49, 0x37, 0x28, 0x78, 0x0c, 0x84, 0x19, 0xea, 0x54, 0xa0, 0x42, 0xd5, 0x26, 0x01,
0xa2, 0x8e, 0x14, 0x2e, 0x90, 0x86, 0x06, 0x5a, 0x35, 0x26, 0x7a, 0xc1, 0xbf, 0x4c, 0xda, 0x05,
0x37, 0x93, 0xeb, 0x7c, 0xe9, 0x2c, 0x5a, 0x3b, 0xc4, 0xae, 0x51, 0xdf, 0x84, 0x17, 0xe0, 0x86,
0x0b, 0x9e, 0x83, 0x4b, 0x1e, 0x01, 0x95, 0x17, 0x41, 0xb1, 0xdd, 0x36, 0x95, 0xb2, 0xad, 0x77,
0xb1, 0x7d, 0xce, 0xf9, 0x7c, 0x7e, 0x8a, 0xd1, 0x7d, 0x13, 0x85, 0x94, 0x31, 0x39, 0x16, 0x9a,
0x8b, 0x41, 0xa8, 0x20, 0x37, 0x9c, 0x01, 0xc9, 0x72, 0xa9, 0x25, 0xde, 0x12, 0x20, 0x49, 0xaa,
0x88, 0x89, 0xc8, 0x42, 0xd3, 0xbc, 0x6b, 0xa2, 0x30, 0x87, 0x54, 0x85, 0x7a, 0x92, 0x81, 0x72,
0xd2, 0xe6, 0x3d, 0x13, 0xcd, 0xcc, 0xe1, 0x08, 0x34, 0xf5, 0xdb, 0x8d, 0xd2, 0xb6, 0x81, 0x9c,
0xa7, 0x13, 0x77, 0xd0, 0xfe, 0x51, 0x43, 0xb7, 0xba, 0x74, 0x48, 0x05, 0x83, 0x18, 0xbe, 0x8e,
0x41, 0x69, 0xbc, 0x8f, 0xd6, 0xfb, 0x32, 0x99, 0x6c, 0x07, 0x8f, 0x82, 0xc7, 0x1b, 0xd1, 0x13,
0x52, 0x35, 0x9c, 0x2c, 0x7b, 0x48, 0x57, 0x26, 0x93, 0xd8, 0xda, 0xf0, 0x1b, 0xb4, 0x51, 0x0c,
0x3e, 0x3d, 0x03, 0x9a, 0x40, 0xbe, 0x5d, 0xb3, 0x29, 0x3b, 0xa5, 0x94, 0x59, 0x37, 0xef, 0x7d,
0x07, 0x9a, 0xbe, 0xb5, 0xda, 0x18, 0x8d, 0xe6, 0xdf, 0xf8, 0x13, 0xda, 0x74, 0x17, 0x9d, 0x05,
0xad, 0xd9, 0xa0, 0x67, 0xe7, 0x07, 0x9d, 0x14, 0x72, 0xce, 0xa8, 0xe6, 0x52, 0xf8, 0xc0, 0x9b,
0x2e, 0xc2, 0xad, 0x9a, 0x7b, 0x68, 0xbd, 0xb8, 0x27, 0x8e, 0xd0, 0x75, 0xf9, 0x4d, 0x40, 0x7e,
0xca, 0x13, 0x5f, 0xb2, 0x51, 0x4a, 0x2d, 0x90, 0x92, 0x0f, 0xc5, 0x79, 0xef, 0x30, 0xae, 0x5b,
0x61, 0x2f, 0x69, 0xef, 0xa3, 0xfa, 0x21, 0x30, 0x3e, 0xa2, 0x43, 0xbc, 0x85, 0xae, 0x1a, 0x3a,
0x1c, 0x83, 0xf5, 0xae, 0xc5, 0x6e, 0x81, 0x1f, 0xa0, 0x1b, 0x59, 0x0e, 0x8c, 0x2b, 0x2e, 0x85,
0x2d, 0xbd, 0x19, 0x2f, 0x36, 0xda, 0xbf, 0x6a, 0xe8, 0xf6, 0x1c, 0x99, 0xca, 0xa4, 0x50, 0x80,
0x5f, 0x2d, 0x71, 0x7e, 0x7a, 0x09, 0x67, 0x67, 0x2a, 0x83, 0x3e, 0xaa, 0x02, 0xbd, 0x5b, 0xc9,
0xc7, 0x99, 0xcf, 0x21, 0x1d, 0x57, 0x93, 0xee, 0x5c, 0x90, 0x74, 0x29, 0xea, 0xd7, 0x1e, 0xf5,
0x0b, 0x54, 0xef, 0xbb, 0x06, 0xbe, 0xe6, 0xc3, 0xea, 0x9a, 0x9e, 0x6d, 0x3c, 0x53, 0x47, 0x5f,
0xd0, 0x9d, 0x83, 0xf9, 0xf1, 0xb1, 0x1b, 0x8f, 0x4f, 0x50, 0xdd, 0xf3, 0xc0, 0x3b, 0xab, 0xfc,
0x96, 0xcd, 0xdd, 0x95, 0xa0, 0x76, 0xd3, 0xdf, 0xd3, 0x56, 0xf0, 0x67, 0xda, 0x0a, 0xfe, 0x4e,
0x5b, 0xc1, 0xf7, 0x7f, 0xad, 0x2b, 0x9f, 0xf7, 0x06, 0x5c, 0x9f, 0x8d, 0xfb, 0x84, 0xc9, 0x51,
0x28, 0x54, 0xc6, 0x58, 0x27, 0x01, 0x13, 0x0a, 0x90, 0xa9, 0xea, 0xd0, 0x8c, 0x77, 0x06, 0x32,
0x5c, 0x7a, 0xb0, 0x2f, 0x17, 0x9f, 0x3f, 0x6b, 0x8d, 0xf7, 0x20, 0x8f, 0x8e, 0xc9, 0xc1, 0xc7,
0x5e, 0x31, 0x77, 0x51, 0xa3, 0x7f, 0xcd, 0xbe, 0xb9, 0xe7, 0xff, 0x03, 0x00, 0x00, 0xff, 0xff,
0x1e, 0x24, 0x48, 0xec, 0xed, 0x03, 0x00, 0x00,
var fileDescriptor_d9dd5af2ff2bbb25 = []byte{
// 478 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x93, 0x4f, 0x6e, 0x13, 0x31,
0x18, 0xc5, 0x99, 0xb4, 0x10, 0x70, 0x29, 0x08, 0xab, 0x52, 0xa3, 0x51, 0x89, 0xaa, 0xa8, 0x95,
0x00, 0x11, 0x8f, 0x34, 0x2c, 0x90, 0x40, 0xa5, 0x6a, 0x54, 0x2a, 0xb2, 0xe0, 0xdf, 0x54, 0xea,
0x82, 0x4d, 0xe5, 0x78, 0xbe, 0xa4, 0x56, 0x13, 0x7b, 0x18, 0x3b, 0x46, 0xb9, 0x09, 0x17, 0x60,
0xc3, 0x82, 0x73, 0xb0, 0xe4, 0x08, 0x28, 0x5c, 0x04, 0x8d, 0xed, 0x64, 0x52, 0x98, 0xb6, 0xd9,
0xc5, 0xf9, 0xde, 0x7b, 0xfe, 0xde, 0x4f, 0x63, 0xb4, 0x6d, 0xe2, 0x88, 0x32, 0x26, 0xc7, 0x42,
0x73, 0x31, 0x88, 0x06, 0x79, 0xc6, 0x22, 0x05, 0xb9, 0xe1, 0x0c, 0x48, 0x96, 0x4b, 0x2d, 0xf1,
0x86, 0x00, 0x49, 0xfa, 0x8a, 0x98, 0x98, 0x94, 0xc2, 0xb0, 0x61, 0xe2, 0x28, 0x87, 0xbe, 0x72,
0x0e, 0x3d, 0xc9, 0x40, 0x39, 0x7d, 0x18, 0x9a, 0x78, 0x96, 0xe0, 0x86, 0x23, 0xd0, 0xd4, 0xcf,
0xb6, 0xfe, 0x9d, 0x19, 0xc8, 0x79, 0x7f, 0xe2, 0xa6, 0xad, 0x6f, 0x35, 0x74, 0xaf, 0x43, 0x87,
0x54, 0x30, 0x48, 0xe0, 0xf3, 0x18, 0x94, 0xc6, 0x7b, 0x68, 0xb5, 0x27, 0xd3, 0x49, 0x23, 0xd8,
0x0e, 0x1e, 0xad, 0xc5, 0x8f, 0x49, 0xd5, 0x2e, 0xe4, 0xa2, 0x87, 0x74, 0x64, 0x3a, 0x49, 0xac,
0x0d, 0xbf, 0x46, 0x6b, 0xc5, 0xed, 0xa7, 0x67, 0x40, 0x53, 0xc8, 0x1b, 0x35, 0x9b, 0xb2, 0xb3,
0x90, 0x32, 0xab, 0xea, 0xbd, 0x6f, 0x41, 0xd3, 0x37, 0x56, 0x9b, 0xa0, 0xd1, 0xfc, 0x37, 0xfe,
0x88, 0xd6, 0xdd, 0xa2, 0xb3, 0xa0, 0x15, 0x1b, 0xf4, 0xf4, 0xf2, 0xa0, 0x93, 0x42, 0xce, 0x19,
0xd5, 0x5c, 0x0a, 0x1f, 0x78, 0xd7, 0x45, 0xb8, 0x53, 0xf8, 0x02, 0xad, 0x16, 0x7b, 0xe2, 0x18,
0xdd, 0x96, 0x5f, 0x04, 0xe4, 0xa7, 0x3c, 0xf5, 0x25, 0x37, 0x17, 0x52, 0x0b, 0xc2, 0xe4, 0x7d,
0x31, 0xef, 0x1e, 0x26, 0x75, 0x2b, 0xec, 0xa6, 0xad, 0x3d, 0x54, 0x3f, 0x04, 0xc6, 0x47, 0x74,
0x88, 0x37, 0xd0, 0x4d, 0x43, 0x87, 0x63, 0xb0, 0xde, 0x95, 0xc4, 0x1d, 0xf0, 0x16, 0xba, 0x93,
0xe5, 0xc0, 0xb8, 0xe2, 0x52, 0xd8, 0xd2, 0xeb, 0x49, 0xf9, 0x47, 0xeb, 0x47, 0x0d, 0xdd, 0x9f,
0x23, 0x53, 0x99, 0x14, 0x0a, 0xf0, 0xab, 0x0b, 0x9c, 0x9f, 0x5c, 0xc3, 0xd9, 0x99, 0x16, 0x41,
0x1f, 0x55, 0x81, 0xde, 0xad, 0xe4, 0xe3, 0xcc, 0x97, 0x90, 0x4e, 0xaa, 0x49, 0xb7, 0xaf, 0x48,
0xba, 0x16, 0xf5, 0xbe, 0x47, 0xfd, 0x1c, 0xd5, 0x7b, 0xae, 0x81, 0xaf, 0xf9, 0xb0, 0xba, 0xa6,
0x67, 0x9b, 0xcc, 0xd4, 0xf1, 0x39, 0x7a, 0x70, 0x30, 0x1f, 0x1f, 0xbb, 0xeb, 0xf1, 0x09, 0xaa,
0x7b, 0x1e, 0x78, 0x67, 0x99, 0xcf, 0x32, 0xdc, 0x5d, 0x0a, 0x6a, 0xe7, 0xfc, 0xe7, 0xb4, 0x19,
0xfc, 0x9a, 0x36, 0x83, 0xdf, 0xd3, 0x66, 0xf0, 0xf5, 0x4f, 0xf3, 0xc6, 0xa7, 0xfd, 0x01, 0xd7,
0x67, 0xe3, 0x1e, 0x61, 0x72, 0x14, 0x09, 0x95, 0x31, 0xd6, 0x4e, 0xc1, 0x44, 0x02, 0x64, 0x5f,
0xb5, 0x69, 0xc6, 0xdb, 0x03, 0x19, 0xfd, 0xff, 0x88, 0x5f, 0x96, 0xe7, 0xef, 0xb5, 0xcd, 0x77,
0x20, 0x8f, 0x8e, 0xc9, 0xc1, 0x87, 0x6e, 0x71, 0x79, 0xd9, 0xa5, 0x77, 0xcb, 0x3e, 0xbc, 0x67,
0x7f, 0x03, 0x00, 0x00, 0xff, 0xff, 0x34, 0x56, 0xa2, 0x45, 0x06, 0x04, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn
var _ grpc2.ClientConn
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4
const _ = grpc2.SupportPackageIsVersion4
// AccountingServiceClient is the client API for AccountingService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type AccountingServiceClient interface {
// Returns the amount of funds for the requested NeoFS account.
Balance(ctx context.Context, in *BalanceRequest, opts ...grpc.CallOption) (*BalanceResponse, error)
Balance(ctx context.Context, in *BalanceRequest, opts ...grpc2.CallOption) (*BalanceResponse, error)
}
type accountingServiceClient struct {
cc *grpc.ClientConn
cc *grpc2.ClientConn
}
func NewAccountingServiceClient(cc *grpc.ClientConn) AccountingServiceClient {
func NewAccountingServiceClient(cc *grpc2.ClientConn) AccountingServiceClient {
return &accountingServiceClient{cc}
}
func (c *accountingServiceClient) Balance(ctx context.Context, in *BalanceRequest, opts ...grpc.CallOption) (*BalanceResponse, error) {
func (c *accountingServiceClient) Balance(ctx context.Context, in *BalanceRequest, opts ...grpc2.CallOption) (*BalanceResponse, error) {
out := new(BalanceResponse)
err := c.cc.Invoke(ctx, "/neo.fs.v2.accounting.AccountingService/Balance", in, out, opts...)
if err != nil {
@ -424,11 +424,11 @@ func (*UnimplementedAccountingServiceServer) Balance(ctx context.Context, req *B
return nil, status.Errorf(codes.Unimplemented, "method Balance not implemented")
}
func RegisterAccountingServiceServer(s *grpc.Server, srv AccountingServiceServer) {
func RegisterAccountingServiceServer(s *grpc2.Server, srv AccountingServiceServer) {
s.RegisterService(&_AccountingService_serviceDesc, srv)
}
func _AccountingService_Balance_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
func _AccountingService_Balance_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc2.UnaryServerInterceptor) (interface{}, error) {
in := new(BalanceRequest)
if err := dec(in); err != nil {
return nil, err
@ -436,7 +436,7 @@ func _AccountingService_Balance_Handler(srv interface{}, ctx context.Context, de
if interceptor == nil {
return srv.(AccountingServiceServer).Balance(ctx, in)
}
info := &grpc.UnaryServerInfo{
info := &grpc2.UnaryServerInfo{
Server: srv,
FullMethod: "/neo.fs.v2.accounting.AccountingService/Balance",
}
@ -446,17 +446,17 @@ func _AccountingService_Balance_Handler(srv interface{}, ctx context.Context, de
return interceptor(ctx, in, info, handler)
}
var _AccountingService_serviceDesc = grpc.ServiceDesc{
var _AccountingService_serviceDesc = grpc2.ServiceDesc{
ServiceName: "neo.fs.v2.accounting.AccountingService",
HandlerType: (*AccountingServiceServer)(nil),
Methods: []grpc.MethodDesc{
Methods: []grpc2.MethodDesc{
{
MethodName: "Balance",
Handler: _AccountingService_Balance_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "v2/accounting/service.proto",
Streams: []grpc2.StreamDesc{},
Metadata: "v2/accounting/grpc/service.proto",
}
func (m *BalanceRequest) Marshal() (dAtA []byte, err error) {
@ -910,7 +910,7 @@ func (m *BalanceRequest) Unmarshal(dAtA []byte) error {
return io.ErrUnexpectedEOF
}
if m.MetaHeader == nil {
m.MetaHeader = &service.RequestMetaHeader{}
m.MetaHeader = &grpc.RequestMetaHeader{}
}
if err := m.MetaHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
@ -946,7 +946,7 @@ func (m *BalanceRequest) Unmarshal(dAtA []byte) error {
return io.ErrUnexpectedEOF
}
if m.VerifyHeader == nil {
m.VerifyHeader = &service.RequestVerificationHeader{}
m.VerifyHeader = &grpc.RequestVerificationHeader{}
}
if err := m.VerifyHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
@ -1036,7 +1036,7 @@ func (m *BalanceRequest_Body) Unmarshal(dAtA []byte) error {
return io.ErrUnexpectedEOF
}
if m.OwnerId == nil {
m.OwnerId = &refs.OwnerID{}
m.OwnerId = &grpc1.OwnerID{}
}
if err := m.OwnerId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
@ -1254,7 +1254,7 @@ func (m *BalanceResponse) Unmarshal(dAtA []byte) error {
return io.ErrUnexpectedEOF
}
if m.MetaHeader == nil {
m.MetaHeader = &service.ResponseMetaHeader{}
m.MetaHeader = &grpc.ResponseMetaHeader{}
}
if err := m.MetaHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
@ -1290,7 +1290,7 @@ func (m *BalanceResponse) Unmarshal(dAtA []byte) error {
return io.ErrUnexpectedEOF
}
if m.VerifyHeader == nil {
m.VerifyHeader = &service.ResponseVerificationHeader{}
m.VerifyHeader = &grpc.ResponseVerificationHeader{}
}
if err := m.VerifyHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err

2
v2/acl/types.go → v2/acl/grpc/types.go
View file

@ -1,7 +1,7 @@
package acl
import (
"github.com/nspcc-dev/neofs-api-go/v2/refs"
refs "github.com/nspcc-dev/neofs-api-go/v2/refs/grpc"
)
// SetContainerId sets container identifier of the eACL table.

123
v2/acl/types.pb.go → v2/acl/grpc/types.pb.go
View file

@ -1,12 +1,12 @@
// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: v2/acl/types.proto
// source: v2/acl/grpc/types.proto
package acl
import (
fmt "fmt"
proto "github.com/golang/protobuf/proto"
refs "github.com/nspcc-dev/neofs-api-go/v2/refs"
grpc "github.com/nspcc-dev/neofs-api-go/v2/refs/grpc"
io "io"
math "math"
math_bits "math/bits"
@ -57,7 +57,7 @@ func (x Target) String() string {
}
func (Target) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_d237ab7979f0d6cf, []int{0}
return fileDescriptor_8233b6696fb3e24f, []int{0}
}
// Operation is an enumeration of operation types.
@ -109,7 +109,7 @@ func (x EACLRecord_Operation) String() string {
}
func (EACLRecord_Operation) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_d237ab7979f0d6cf, []int{0, 0}
return fileDescriptor_8233b6696fb3e24f, []int{0, 0}
}
// Action is an enumeration of EACL actions.
@ -141,7 +141,7 @@ func (x EACLRecord_Action) String() string {
}
func (EACLRecord_Action) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_d237ab7979f0d6cf, []int{0, 1}
return fileDescriptor_8233b6696fb3e24f, []int{0, 1}
}
// Header is an enumeration of filtering header types.
@ -173,7 +173,7 @@ func (x EACLRecord_FilterInfo_Header) String() string {
}
func (EACLRecord_FilterInfo_Header) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_d237ab7979f0d6cf, []int{0, 0, 0}
return fileDescriptor_8233b6696fb3e24f, []int{0, 0, 0}
}
// MatchType is an enumeration of match types.
@ -205,7 +205,7 @@ func (x EACLRecord_FilterInfo_MatchType) String() string {
}
func (EACLRecord_FilterInfo_MatchType) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_d237ab7979f0d6cf, []int{0, 0, 1}
return fileDescriptor_8233b6696fb3e24f, []int{0, 0, 1}
}
// EACLRecord groups information about extended ACL rule.
@ -227,7 +227,7 @@ func (m *EACLRecord) Reset() { *m = EACLRecord{} }
func (m *EACLRecord) String() string { return proto.CompactTextString(m) }
func (*EACLRecord) ProtoMessage() {}
func (*EACLRecord) Descriptor() ([]byte, []int) {
return fileDescriptor_d237ab7979f0d6cf, []int{0}
return fileDescriptor_8233b6696fb3e24f, []int{0}
}
func (m *EACLRecord) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -303,7 +303,7 @@ func (m *EACLRecord_FilterInfo) Reset() { *m = EACLRecord_FilterInfo{} }
func (m *EACLRecord_FilterInfo) String() string { return proto.CompactTextString(m) }
func (*EACLRecord_FilterInfo) ProtoMessage() {}
func (*EACLRecord_FilterInfo) Descriptor() ([]byte, []int) {
return fileDescriptor_d237ab7979f0d6cf, []int{0, 0}
return fileDescriptor_8233b6696fb3e24f, []int{0, 0}
}
func (m *EACLRecord_FilterInfo) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -375,7 +375,7 @@ func (m *EACLRecord_TargetInfo) Reset() { *m = EACLRecord_TargetInfo{} }
func (m *EACLRecord_TargetInfo) String() string { return proto.CompactTextString(m) }
func (*EACLRecord_TargetInfo) ProtoMessage() {}
func (*EACLRecord_TargetInfo) Descriptor() ([]byte, []int) {
return fileDescriptor_d237ab7979f0d6cf, []int{0, 1}
return fileDescriptor_8233b6696fb3e24f, []int{0, 1}
}
func (m *EACLRecord_TargetInfo) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -422,7 +422,7 @@ func (m *EACLRecord_TargetInfo) GetKeyList() [][]byte {
type EACLTable struct {
// Carries identifier of the container that should use given
// access control rules.
ContainerId *refs.ContainerID `protobuf:"bytes,1,opt,name=container_id,json=ContainerID,proto3" json:"container_id,omitempty"`
ContainerId *grpc.ContainerID `protobuf:"bytes,1,opt,name=container_id,json=ContainerID,proto3" json:"container_id,omitempty"`
// Records carries list of extended ACL rule records.
Records []*EACLRecord `protobuf:"bytes,2,rep,name=records,json=Records,proto3" json:"records,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
@ -434,7 +434,7 @@ func (m *EACLTable) Reset() { *m = EACLTable{} }
func (m *EACLTable) String() string { return proto.CompactTextString(m) }
func (*EACLTable) ProtoMessage() {}
func (*EACLTable) Descriptor() ([]byte, []int) {
return fileDescriptor_d237ab7979f0d6cf, []int{1}
return fileDescriptor_8233b6696fb3e24f, []int{1}
}
func (m *EACLTable) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -463,7 +463,7 @@ func (m *EACLTable) XXX_DiscardUnknown() {
var xxx_messageInfo_EACLTable proto.InternalMessageInfo
func (m *EACLTable) GetContainerId() *refs.ContainerID {
func (m *EACLTable) GetContainerId() *grpc.ContainerID {
if m != nil {
return m.ContainerId
}
@ -489,54 +489,55 @@ func init() {
proto.RegisterType((*EACLTable)(nil), "neo.fs.v2.acl.EACLTable")
}
func init() { proto.RegisterFile("v2/acl/types.proto", fileDescriptor_d237ab7979f0d6cf) }
func init() { proto.RegisterFile("v2/acl/grpc/types.proto", fileDescriptor_8233b6696fb3e24f) }
var fileDescriptor_d237ab7979f0d6cf = []byte{
// 703 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x54, 0xd1, 0x6e, 0xda, 0x3c,
0x18, 0x6d, 0x42, 0x1a, 0xe0, 0x83, 0xff, 0x97, 0xe5, 0xad, 0x88, 0x32, 0x09, 0x21, 0xb6, 0x0b,
0xb4, 0xae, 0x41, 0xa2, 0x9a, 0xb4, 0x69, 0x52, 0xa5, 0x14, 0x5c, 0x60, 0x83, 0x00, 0x8e, 0xd9,
0xd4, 0xdd, 0xa0, 0x34, 0x98, 0x16, 0x2d, 0x24, 0x28, 0x49, 0x91, 0xd8, 0xd5, 0x1e, 0x63, 0xcf,
0xb0, 0x27, 0xd9, 0xe5, 0x1e, 0x61, 0xea, 0xa4, 0x3d, 0xc3, 0x2e, 0x27, 0x27, 0xd0, 0x32, 0xb4,
0x6a, 0xbd, 0xf2, 0x17, 0xfb, 0x9c, 0xcf, 0xc7, 0xc7, 0x27, 0x06, 0xbc, 0xa8, 0x55, 0x2d, 0xdb,
0xa9, 0x86, 0xcb, 0x39, 0x0f, 0xb4, 0xb9, 0xef, 0x85, 0x1e, 0xfe, 0xcf, 0xe5, 0x9e, 0x36, 0x09,
0xb4, 0x45, 0x4d, 0xb3, 0x6c, 0xa7, 0xf0, 0x60, 0x51, 0xab, 0xfa, 0x7c, 0x12, 0x6c, 0x62, 0xca,
0xbf, 0x54, 0x00, 0xa2, 0xd7, 0x3b, 0x94, 0xdb, 0x9e, 0x3f, 0xc6, 0x3a, 0xa4, 0xbd, 0x39, 0xf7,
0xad, 0x70, 0xea, 0xb9, 0x79, 0xa9, 0x24, 0x55, 0xfe, 0xaf, 0x3d, 0xd6, 0xfe, 0x68, 0xa3, 0xdd,
0xa2, 0xb5, 0xde, 0x1a, 0x4a, 0xd3, 0x37, 0x25, 0x7e, 0x01, 0xaa, 0x65, 0x47, 0x7c, 0x39, 0xe2,
0x97, 0xee, 0xe6, 0xeb, 0x11, 0x8e, 0xaa, 0xf1, 0x88, 0x8f, 0x21, 0x39, 0x99, 0x3a, 0x21, 0xf7,
0x83, 0x7c, 0xa2, 0x94, 0xa8, 0x64, 0x6a, 0x4f, 0xee, 0xa6, 0x9e, 0x46, 0xc0, 0xb6, 0x3b, 0xf1,
0x68, 0x32, 0xae, 0x03, 0xc1, 0x0f, 0x2d, 0xff, 0x82, 0x87, 0x41, 0x5e, 0xf9, 0x17, 0x9f, 0x45,
0xc0, 0x98, 0x1f, 0xd7, 0x41, 0xe1, 0xa7, 0x0c, 0x70, 0xdb, 0x17, 0x37, 0x41, 0xbd, 0xe4, 0xd6,
0x98, 0xfb, 0x2b, 0x23, 0x0e, 0xee, 0xa3, 0x46, 0x6b, 0x45, 0x14, 0x0a, 0xf1, 0xc8, 0x96, 0x73,
0x8e, 0xbb, 0x00, 0x33, 0x2b, 0xb4, 0x2f, 0x47, 0xc2, 0xf8, 0x95, 0x2b, 0xda, 0xbd, 0x9a, 0x75,
0x05, 0x4d, 0xf4, 0xa0, 0xe9, 0x9b, 0x12, 0xef, 0x43, 0x26, 0xd6, 0x35, 0x72, 0xad, 0x19, 0xcf,
0x27, 0x4a, 0x52, 0x25, 0x4d, 0x15, 0xc3, 0x9a, 0x89, 0x25, 0x58, 0x2d, 0x2d, 0x2c, 0x27, 0xaf,
0x44, 0x2b, 0xbb, 0x6f, 0x2d, 0xe7, 0x8a, 0x97, 0x5f, 0x82, 0x1a, 0x4b, 0xc2, 0x39, 0xc0, 0x2d,
0xa2, 0x37, 0x08, 0x1d, 0x0d, 0x0d, 0xb3, 0x4f, 0xea, 0xed, 0xd3, 0x36, 0x69, 0xa0, 0x1d, 0x9c,
0x81, 0x24, 0x25, 0x83, 0x21, 0x31, 0x19, 0x92, 0x30, 0x80, 0xda, 0x3b, 0x79, 0x4d, 0xea, 0x0c,
0xc9, 0xe5, 0x1e, 0x6c, 0xec, 0x5e, 0x80, 0x5c, 0x57, 0x67, 0xf5, 0xd6, 0x88, 0x9d, 0xf5, 0xc9,
0x56, 0x07, 0x04, 0x59, 0x93, 0xd1, 0xb6, 0xd1, 0x1c, 0x91, 0xc1, 0x50, 0xef, 0x20, 0x09, 0x3f,
0x04, 0xb4, 0x9a, 0x31, 0x7a, 0x6c, 0x35, 0x2b, 0x17, 0x06, 0x00, 0xb7, 0xfe, 0xe3, 0x03, 0x50,
0xe3, 0x6b, 0x5b, 0xf9, 0xbc, 0xb7, 0x65, 0x4d, 0x0c, 0xa5, 0x0a, 0xf5, 0x1c, 0x8e, 0x73, 0x90,
0xfa, 0xc0, 0x97, 0x23, 0x67, 0x1a, 0x84, 0x79, 0xb9, 0x94, 0xa8, 0x64, 0xa9, 0xf2, 0x86, 0x2f,
0x83, 0xf2, 0x47, 0xd8, 0x88, 0xe0, 0x3e, 0xec, 0xf5, 0xfa, 0x84, 0xea, 0xac, 0xdd, 0x33, 0xb6,
0x24, 0x26, 0x21, 0xd1, 0x24, 0xe2, 0x80, 0x29, 0x50, 0x84, 0x0b, 0x48, 0x16, 0x53, 0xfd, 0x21,
0x43, 0x09, 0x71, 0xe6, 0x06, 0xe9, 0x10, 0x46, 0x90, 0x22, 0x6a, 0x93, 0xe8, 0xb4, 0xde, 0x42,
0xbb, 0x38, 0x0b, 0xa9, 0x26, 0x61, 0x54, 0x37, 0x9a, 0x04, 0xa9, 0xe2, 0x90, 0xeb, 0xaf, 0x96,
0x6e, 0xb6, 0x50, 0xb2, 0xfc, 0x1c, 0xd6, 0x09, 0xce, 0x01, 0xd6, 0xeb, 0x7f, 0xd9, 0x35, 0x0d,
0xbb, 0x7a, 0xa7, 0xd3, 0x7b, 0x17, 0xef, 0xdb, 0x20, 0xc6, 0x19, 0x92, 0xcb, 0x9f, 0x24, 0x48,
0x8b, 0x6b, 0x67, 0xd6, 0xb9, 0xc3, 0xf1, 0x31, 0x64, 0x6d, 0xcf, 0x0d, 0xad, 0xa9, 0xcb, 0xfd,
0xd1, 0x74, 0x1c, 0x79, 0x91, 0xa9, 0x3d, 0xda, 0xf0, 0x42, 0xfc, 0xbb, 0x5a, 0x7d, 0x8d, 0x69,
0x37, 0x68, 0x66, 0xe3, 0x03, 0x1f, 0x41, 0xd2, 0x8f, 0xf2, 0x13, 0x44, 0xbe, 0x64, 0x6a, 0xfb,
0x77, 0x26, 0x8c, 0x26, 0xe3, 0x31, 0x78, 0x7a, 0x02, 0x6a, 0xec, 0xae, 0x50, 0xce, 0x74, 0xda,
0x24, 0x6c, 0x4b, 0x79, 0x0a, 0x94, 0xa1, 0x49, 0x68, 0x9c, 0x08, 0xf3, 0xcc, 0x64, 0xa4, 0x8b,
0xe4, 0x28, 0x1d, 0xac, 0x45, 0xa8, 0x89, 0x12, 0x27, 0x83, 0xaf, 0xd7, 0x45, 0xe9, 0xdb, 0x75,
0x51, 0xfa, 0x7e, 0x5d, 0x94, 0x3e, 0xff, 0x28, 0xee, 0xbc, 0x7f, 0x76, 0x31, 0x0d, 0x2f, 0xaf,
0xce, 0x35, 0xdb, 0x9b, 0x55, 0xdd, 0x60, 0x6e, 0xdb, 0x87, 0x63, 0xbe, 0xa8, 0xba, 0xdc, 0x9b,
0x04, 0x87, 0xd6, 0x7c, 0x7a, 0x78, 0xe1, 0x55, 0xe3, 0xd7, 0xea, 0x95, 0x65, 0x3b, 0x5f, 0x64,
0x64, 0x70, 0xef, 0xd4, 0xd4, 0xf4, 0x7e, 0x5b, 0x48, 0xd5, 0x6d, 0xe7, 0x5c, 0x8d, 0xde, 0xa6,
0xa3, 0xdf, 0x01, 0x00, 0x00, 0xff, 0xff, 0xaa, 0x0d, 0x90, 0x3a, 0xd5, 0x04, 0x00, 0x00,
var fileDescriptor_8233b6696fb3e24f = []byte{
// 710 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x54, 0xd1, 0x6e, 0xda, 0x3a,
0x18, 0x6e, 0x42, 0x1a, 0xe0, 0x87, 0x73, 0x64, 0x59, 0xa7, 0x1c, 0xca, 0x91, 0x10, 0xe2, 0xec,
0x02, 0xad, 0x6a, 0xd0, 0xa8, 0x26, 0x6d, 0x9a, 0x54, 0x29, 0x05, 0x17, 0xd8, 0x20, 0x50, 0xc7,
0x74, 0xea, 0x6e, 0x50, 0x1a, 0x0c, 0x45, 0x0b, 0x09, 0x4a, 0x52, 0x24, 0x76, 0xb5, 0xc7, 0xd8,
0x33, 0xec, 0x49, 0x76, 0xb9, 0x47, 0x98, 0x3a, 0x69, 0xcf, 0xb0, 0xcb, 0xc9, 0x09, 0xb4, 0x8c,
0xad, 0x5a, 0xaf, 0xfc, 0xc7, 0xfe, 0xbe, 0xdf, 0x9f, 0x3f, 0x7f, 0x31, 0xfc, 0xbb, 0xa8, 0x55,
0x2d, 0xdb, 0xa9, 0x4e, 0xfc, 0xb9, 0x5d, 0x0d, 0x97, 0x73, 0x1e, 0x68, 0x73, 0xdf, 0x0b, 0x3d,
0xfc, 0x97, 0xcb, 0x3d, 0x6d, 0x1c, 0x68, 0x8b, 0x9a, 0x66, 0xd9, 0x4e, 0x21, 0xbf, 0xa8, 0x55,
0x7d, 0x3e, 0x0e, 0x7e, 0x01, 0x96, 0xbf, 0xab, 0x00, 0x44, 0xaf, 0x77, 0x28, 0xb7, 0x3d, 0x7f,
0x84, 0x75, 0x48, 0x7b, 0x73, 0xee, 0x5b, 0xe1, 0xd4, 0x73, 0xf3, 0x52, 0x49, 0xaa, 0xfc, 0x5d,
0xfb, 0x5f, 0xfb, 0xa9, 0x97, 0x76, 0x87, 0xd6, 0x7a, 0x6b, 0x28, 0x4d, 0xdf, 0x96, 0xf8, 0x19,
0xa8, 0x96, 0x1d, 0xf1, 0xe5, 0x88, 0x5f, 0xba, 0x9f, 0xaf, 0x47, 0x38, 0xaa, 0xc6, 0x23, 0x3e,
0x86, 0xe4, 0x78, 0xea, 0x84, 0xdc, 0x0f, 0xf2, 0x89, 0x52, 0xa2, 0x92, 0xa9, 0x3d, 0xba, 0x9f,
0x7a, 0x1a, 0x01, 0xdb, 0xee, 0xd8, 0xa3, 0xc9, 0xb8, 0x0e, 0x04, 0x3f, 0xb4, 0xfc, 0x09, 0x0f,
0x83, 0xbc, 0xf2, 0x27, 0x3e, 0x8b, 0x80, 0x31, 0x3f, 0xae, 0x83, 0xc2, 0x37, 0x19, 0xe0, 0xae,
0x2f, 0x6e, 0x82, 0x7a, 0xc5, 0xad, 0x11, 0xf7, 0x57, 0x46, 0x1c, 0x3c, 0x44, 0x8d, 0xd6, 0x8a,
0x28, 0x14, 0xe2, 0x91, 0x2d, 0xe7, 0x1c, 0x77, 0x01, 0x66, 0x56, 0x68, 0x5f, 0x0d, 0x85, 0xf1,
0x2b, 0x57, 0xb4, 0x07, 0x35, 0xeb, 0x0a, 0x9a, 0xe8, 0x41, 0xd3, 0xb7, 0x25, 0xde, 0x87, 0x4c,
0xac, 0x6b, 0xe8, 0x5a, 0x33, 0x9e, 0x4f, 0x94, 0xa4, 0x4a, 0x9a, 0x2a, 0x86, 0x35, 0x13, 0x4b,
0xb0, 0x5a, 0x5a, 0x58, 0x4e, 0x5e, 0x89, 0x56, 0x76, 0xcf, 0x2d, 0xe7, 0x9a, 0x97, 0x9f, 0x83,
0x1a, 0x4b, 0xc2, 0x39, 0xc0, 0x2d, 0xa2, 0x37, 0x08, 0x1d, 0x0e, 0x0c, 0xb3, 0x4f, 0xea, 0xed,
0xd3, 0x36, 0x69, 0xa0, 0x1d, 0x9c, 0x81, 0x24, 0x25, 0x67, 0x03, 0x62, 0x32, 0x24, 0x61, 0x00,
0xb5, 0x77, 0xf2, 0x92, 0xd4, 0x19, 0x92, 0xcb, 0x3d, 0xd8, 0xd8, 0xbd, 0x00, 0xb9, 0xae, 0xce,
0xea, 0xad, 0x21, 0xbb, 0xe8, 0x93, 0xad, 0x0e, 0x08, 0xb2, 0x26, 0xa3, 0x6d, 0xa3, 0x39, 0x24,
0x67, 0x03, 0xbd, 0x83, 0x24, 0xfc, 0x0f, 0xa0, 0xd5, 0x8c, 0xd1, 0x63, 0xab, 0x59, 0xb9, 0x70,
0x06, 0x70, 0xe7, 0x3f, 0x3e, 0x00, 0x35, 0xbe, 0xb6, 0x95, 0xcf, 0x7b, 0x5b, 0xd6, 0xc4, 0x50,
0xaa, 0x50, 0xcf, 0xe1, 0x38, 0x07, 0xa9, 0xb7, 0x7c, 0x39, 0x74, 0xa6, 0x41, 0x98, 0x97, 0x4b,
0x89, 0x4a, 0x96, 0x2a, 0xaf, 0xf8, 0x32, 0x28, 0xbf, 0x83, 0x8d, 0x08, 0xee, 0xc3, 0x5e, 0xaf,
0x4f, 0xa8, 0xce, 0xda, 0x3d, 0x63, 0x4b, 0x62, 0x12, 0x12, 0x4d, 0x22, 0x0e, 0x98, 0x02, 0x45,
0xb8, 0x80, 0x64, 0x31, 0xd5, 0x1f, 0x30, 0x94, 0x10, 0x67, 0x6e, 0x90, 0x0e, 0x61, 0x04, 0x29,
0xa2, 0x36, 0x89, 0x4e, 0xeb, 0x2d, 0xb4, 0x8b, 0xb3, 0x90, 0x6a, 0x12, 0x46, 0x75, 0xa3, 0x49,
0x90, 0x2a, 0x0e, 0xb9, 0xfe, 0x6a, 0xe9, 0x66, 0x0b, 0x25, 0xcb, 0x4f, 0x61, 0x9d, 0xe0, 0x1c,
0x60, 0xbd, 0xfe, 0x9b, 0x5d, 0xd3, 0xb0, 0xab, 0x77, 0x3a, 0xbd, 0xd7, 0xf1, 0xbe, 0x0d, 0x62,
0x5c, 0x20, 0xb9, 0xfc, 0x5e, 0x82, 0xb4, 0xb8, 0x76, 0x66, 0x5d, 0x3a, 0x1c, 0x1f, 0x43, 0xd6,
0xf6, 0xdc, 0xd0, 0x9a, 0xba, 0xdc, 0x1f, 0x4e, 0x47, 0x91, 0x17, 0x99, 0xda, 0x7f, 0x1b, 0x5e,
0x88, 0x1f, 0x58, 0xab, 0xaf, 0x31, 0xed, 0x06, 0xcd, 0x6c, 0x7c, 0xe0, 0x23, 0x48, 0xfa, 0x51,
0x7e, 0x82, 0xc8, 0x97, 0x4c, 0x6d, 0xff, 0xde, 0x84, 0xd1, 0x64, 0x3c, 0x06, 0x8f, 0x4f, 0x40,
0x8d, 0xdd, 0x15, 0xca, 0x99, 0x4e, 0x9b, 0x84, 0x6d, 0x29, 0x4f, 0x81, 0x32, 0x30, 0x09, 0x8d,
0x13, 0x61, 0x5e, 0x98, 0x8c, 0x74, 0x91, 0x1c, 0xa5, 0x83, 0xb5, 0x08, 0x35, 0x51, 0xe2, 0xe4,
0xfc, 0xd3, 0x4d, 0x51, 0xfa, 0x7c, 0x53, 0x94, 0xbe, 0xdc, 0x14, 0xa5, 0x0f, 0x5f, 0x8b, 0x3b,
0x6f, 0x9e, 0x4c, 0xa6, 0xe1, 0xd5, 0xf5, 0xa5, 0x66, 0x7b, 0xb3, 0xaa, 0x1b, 0xcc, 0x6d, 0xfb,
0x70, 0xc4, 0x17, 0x55, 0x97, 0x7b, 0xe3, 0xe0, 0xd0, 0x9a, 0x4f, 0x0f, 0x27, 0x5e, 0x75, 0xe3,
0xdd, 0x7a, 0x61, 0xd9, 0xce, 0x47, 0x19, 0x19, 0xdc, 0x3b, 0x35, 0x35, 0xbd, 0xdf, 0x16, 0x7a,
0x75, 0xdb, 0xb9, 0x54, 0xa3, 0x07, 0xea, 0xe8, 0x47, 0x00, 0x00, 0x00, 0xff, 0xff, 0xf6, 0x1c,
0x01, 0xad, 0xe4, 0x04, 0x00, 0x00,
}
func (m *EACLRecord) Marshal() (dAtA []byte, err error) {
@ -1345,7 +1346,7 @@ func (m *EACLTable) Unmarshal(dAtA []byte) error {
return io.ErrUnexpectedEOF
}
if m.ContainerId == nil {
m.ContainerId = &refs.ContainerID{}
m.ContainerId = &grpc.ContainerID{}
}
if err := m.ContainerId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err

0
v2/container/marshal.go → v2/container/grpc/marshal.go
View file

4
v2/container/marshal_test.go → v2/container/grpc/marshal_test.go
View file

@ -3,8 +3,8 @@ package container
import (
"testing"
"github.com/nspcc-dev/neofs-api-go/v2/netmap"
"github.com/nspcc-dev/neofs-api-go/v2/refs"
netmap "github.com/nspcc-dev/neofs-api-go/v2/netmap/grpc"
refs "github.com/nspcc-dev/neofs-api-go/v2/refs/grpc"
"github.com/stretchr/testify/require"
)

6
v2/container/service.go → v2/container/grpc/service.go
View file

@ -1,9 +1,9 @@
package container
import (
"github.com/nspcc-dev/neofs-api-go/v2/acl"
"github.com/nspcc-dev/neofs-api-go/v2/refs"
"github.com/nspcc-dev/neofs-api-go/v2/service"
acl "github.com/nspcc-dev/neofs-api-go/v2/acl/grpc"
refs "github.com/nspcc-dev/neofs-api-go/v2/refs/grpc"
service "github.com/nspcc-dev/neofs-api-go/v2/service/grpc"
)
// SetContainer sets container of the request.

530
v2/container/service.pb.go → v2/container/grpc/service.pb.go
View file

File diff suppressed because it is too large Load diff

0
v2/container/signature.go → v2/container/grpc/signature.go
View file

4
v2/container/types.go → v2/container/grpc/types.go
View file

@ -1,8 +1,8 @@
package container
import (
"github.com/nspcc-dev/neofs-api-go/v2/netmap"
"github.com/nspcc-dev/neofs-api-go/v2/refs"
netmap "github.com/nspcc-dev/neofs-api-go/v2/netmap/grpc"
refs "github.com/nspcc-dev/neofs-api-go/v2/refs/grpc"
)
// SetKey sets key to the container attribute.

80
v2/container/types.pb.go → v2/container/grpc/types.pb.go
View file

@ -1,13 +1,13 @@
// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: v2/container/types.proto
// source: v2/container/grpc/types.proto
package container
import (
fmt "fmt"
proto "github.com/golang/protobuf/proto"
netmap "github.com/nspcc-dev/neofs-api-go/v2/netmap"
refs "github.com/nspcc-dev/neofs-api-go/v2/refs"
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"
@ -30,7 +30,7 @@ const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
// SHA256 hash of stable-marshalled container message.
type Container struct {
// OwnerID carries identifier of the container owner.
OwnerId *refs.OwnerID `protobuf:"bytes,1,opt,name=owner_id,json=ownerId,proto3" json:"owner_id,omitempty"`
OwnerId *grpc.OwnerID `protobuf:"bytes,1,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,2,opt,name=nonce,proto3" json:"nonce,omitempty"`
// BasicACL contains access control rules for owner, system, others groups and
@ -39,17 +39,17 @@ type Container struct {
// Attributes define any immutable characteristics of container.
Attributes []*Container_Attribute `protobuf:"bytes,4,rep,name=attributes,proto3" json:"attributes,omitempty"`
// Placement policy for the object inside the container.
PlacementPolicy *netmap.PlacementPolicy `protobuf:"bytes,5,opt,name=placement_policy,json=placementPolicy,proto3" json:"placement_policy,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
PlacementPolicy *grpc1.PlacementPolicy `protobuf:"bytes,5,opt,name=placement_policy,json=placementPolicy,proto3" json:"placement_policy,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Container) Reset() { *m = Container{} }
func (m *Container) String() string { return proto.CompactTextString(m) }
func (*Container) ProtoMessage() {}
func (*Container) Descriptor() ([]byte, []int) {
return fileDescriptor_ece71f25e6ae314e, []int{0}
return fileDescriptor_3bfd95a81c72c35c, []int{0}
}
func (m *Container) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -78,7 +78,7 @@ func (m *Container) XXX_DiscardUnknown() {
var xxx_messageInfo_Container proto.InternalMessageInfo
func (m *Container) GetOwnerId() *refs.OwnerID {
func (m *Container) GetOwnerId() *grpc.OwnerID {
if m != nil {
return m.OwnerId
}
@ -106,7 +106,7 @@ func (m *Container) GetAttributes() []*Container_Attribute {
return nil
}
func (m *Container) GetPlacementPolicy() *netmap.PlacementPolicy {
func (m *Container) GetPlacementPolicy() *grpc1.PlacementPolicy {
if m != nil {
return m.PlacementPolicy
}
@ -128,7 +128,7 @@ func (m *Container_Attribute) Reset() { *m = Container_Attribute{} }
func (m *Container_Attribute) String() string { return proto.CompactTextString(m) }
func (*Container_Attribute) ProtoMessage() {}
func (*Container_Attribute) Descriptor() ([]byte, []int) {
return fileDescriptor_ece71f25e6ae314e, []int{0, 0}
return fileDescriptor_3bfd95a81c72c35c, []int{0, 0}
}
func (m *Container_Attribute) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -176,33 +176,33 @@ func init() {
proto.RegisterType((*Container_Attribute)(nil), "neo.fs.v2.container.Container.Attribute")
}
func init() { proto.RegisterFile("v2/container/types.proto", fileDescriptor_ece71f25e6ae314e) }
func init() { proto.RegisterFile("v2/container/grpc/types.proto", fileDescriptor_3bfd95a81c72c35c) }
var fileDescriptor_ece71f25e6ae314e = []byte{
// 357 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x51, 0xcd, 0x4a, 0xc3, 0x40,
0x10, 0x36, 0xad, 0xd5, 0x66, 0xab, 0x58, 0x52, 0x7f, 0x42, 0x85, 0x10, 0x3d, 0xe5, 0xd2, 0x0d,
0xa4, 0x17, 0xc1, 0x53, 0x55, 0xc4, 0x82, 0x68, 0x89, 0x37, 0x2f, 0x65, 0xb3, 0x9d, 0xd6, 0xc5,
0x74, 0x77, 0xc9, 0x6e, 0x23, 0x7d, 0x13, 0x9f, 0xc1, 0x97, 0xf0, 0xea, 0xd1, 0x47, 0x90, 0xfa,
0x22, 0x92, 0x84, 0xc6, 0x08, 0xde, 0x66, 0xbe, 0xfd, 0xbe, 0x9d, 0xef, 0x9b, 0x41, 0x76, 0x1a,
0xf8, 0x54, 0x70, 0x4d, 0x18, 0x87, 0xc4, 0xd7, 0x4b, 0x09, 0x0a, 0xcb, 0x44, 0x68, 0x61, 0x75,
0x38, 0x08, 0x3c, 0x55, 0x38, 0x0d, 0x70, 0x49, 0xe8, 0x1e, 0xa4, 0x81, 0xcf, 0x41, 0xcf, 0x89,
0xac, 0x72, 0xbb, 0x9d, 0x34, 0xf0, 0x13, 0x98, 0xaa, 0x2a, 0x78, 0xfa, 0x5e, 0x43, 0xe6, 0xe5,
0x5a, 0x69, 0x05, 0xa8, 0x29, 0x5e, 0x38, 0x24, 0x63, 0x36, 0xb1, 0x0d, 0xd7, 0xf0, 0x5a, 0xc1,
0x11, 0xfe, 0x9d, 0x90, 0x89, 0xf1, 0x7d, 0xf6, 0x3e, 0xbc, 0x0a, 0xb7, 0x73, 0xe2, 0x70, 0x62,
0xed, 0xa3, 0x06, 0x17, 0x9c, 0x82, 0x5d, 0x73, 0x0d, 0x6f, 0x27, 0x2c, 0x1a, 0xeb, 0x18, 0x99,
0x11, 0x51, 0x8c, 0x8e, 0x09, 0x8d, 0xed, 0xba, 0x6b, 0x78, 0xbb, 0x61, 0x33, 0x07, 0x06, 0x34,
0xb6, 0x6e, 0x10, 0x22, 0x5a, 0x27, 0x2c, 0x5a, 0x68, 0x50, 0xf6, 0xa6, 0x5b, 0xf7, 0x5a, 0x81,
0x87, 0xff, 0x89, 0x82, 0x4b, 0x6b, 0x78, 0xb0, 0x16, 0x84, 0x15, 0xad, 0x75, 0x8b, 0xda, 0x32,
0x26, 0x14, 0xe6, 0xc0, 0xf5, 0x58, 0x8a, 0x98, 0xd1, 0xa5, 0xdd, 0xc8, 0x8d, 0x9f, 0x54, 0xfe,
0x2b, 0x96, 0x81, 0x47, 0x6b, 0xe6, 0x28, 0x27, 0x86, 0x7b, 0xf2, 0x2f, 0xd0, 0xed, 0x23, 0xb3,
0x1c, 0x63, 0xb5, 0x51, 0xfd, 0x19, 0x96, 0xf9, 0x1a, 0xcc, 0x30, 0x2b, 0xb3, 0xa4, 0x29, 0x89,
0x17, 0x45, 0x52, 0x33, 0x2c, 0x9a, 0x0b, 0xfa, 0xb1, 0x72, 0x8c, 0xcf, 0x95, 0x63, 0x7c, 0xad,
0x1c, 0xe3, 0xf5, 0xdb, 0xd9, 0x78, 0x3c, 0x9b, 0x31, 0xfd, 0xb4, 0x88, 0x30, 0x15, 0x73, 0x9f,
0x2b, 0x49, 0x69, 0x6f, 0x02, 0xa9, 0xcf, 0x41, 0x4c, 0x55, 0x8f, 0x48, 0xd6, 0x9b, 0x09, 0xbf,
0x7a, 0xd0, 0xf3, 0xb2, 0x7a, 0xab, 0x1d, 0xde, 0x81, 0xb8, 0x7e, 0xc0, 0x83, 0xd1, 0x30, 0xf3,
0x5d, 0xa6, 0x8f, 0xb6, 0xf2, 0x6b, 0xf5, 0x7f, 0x02, 0x00, 0x00, 0xff, 0xff, 0x38, 0xf7, 0x99,
0x45, 0x0a, 0x02, 0x00, 0x00,
var fileDescriptor_3bfd95a81c72c35c = []byte{
// 363 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x51, 0xc1, 0x4e, 0xea, 0x40,
0x14, 0x7d, 0x85, 0xc7, 0x7b, 0x74, 0xd0, 0x48, 0xaa, 0xd1, 0xa6, 0xc6, 0xa6, 0xba, 0xea, 0x86,
0x99, 0xa4, 0x2c, 0x8d, 0x0b, 0xd4, 0x18, 0x49, 0x8c, 0x92, 0xba, 0x73, 0x43, 0xa6, 0xc3, 0x05,
0x1a, 0xcb, 0xcc, 0xa4, 0x33, 0xd4, 0xf0, 0x27, 0x7e, 0x83, 0x3f, 0xe1, 0xd6, 0xa5, 0x9f, 0x60,
0xf0, 0x47, 0x4c, 0xdb, 0x50, 0x31, 0xb8, 0x9b, 0x3b, 0xf7, 0xdc, 0x73, 0xcf, 0x39, 0x17, 0x1d,
0x65, 0x01, 0x61, 0x82, 0x6b, 0x1a, 0x73, 0x48, 0xc9, 0x24, 0x95, 0x8c, 0xe8, 0x85, 0x04, 0x85,
0x65, 0x2a, 0xb4, 0xb0, 0x76, 0x39, 0x08, 0x3c, 0x56, 0x38, 0x0b, 0x70, 0x85, 0x72, 0x9c, 0x2c,
0x20, 0x1c, 0xf4, 0x8c, 0xca, 0x8d, 0x01, 0xc7, 0xce, 0x02, 0x92, 0xc2, 0x58, 0x6d, 0x74, 0x4e,
0x5e, 0x6b, 0xc8, 0xbc, 0x58, 0x71, 0x58, 0x01, 0x6a, 0x8a, 0x27, 0x0e, 0xe9, 0x30, 0x1e, 0xd9,
0x86, 0x67, 0xf8, 0xad, 0xe0, 0x00, 0x7f, 0xef, 0xca, 0x19, 0xf0, 0x5d, 0xde, 0xef, 0x5f, 0x86,
0xff, 0x0b, 0x60, 0x7f, 0x64, 0xed, 0xa1, 0x06, 0x17, 0x9c, 0x81, 0x5d, 0xf3, 0x0c, 0x7f, 0x2b,
0x2c, 0x0b, 0xeb, 0x10, 0x99, 0x11, 0x55, 0x31, 0x1b, 0x52, 0x96, 0xd8, 0x75, 0xcf, 0xf0, 0xb7,
0xc3, 0x66, 0xf1, 0xd1, 0x63, 0x89, 0x75, 0x8d, 0x10, 0xd5, 0x3a, 0x8d, 0xa3, 0xb9, 0x06, 0x65,
0xff, 0xf5, 0xea, 0x7e, 0x2b, 0xf0, 0xf1, 0x2f, 0xa6, 0x70, 0x25, 0x0d, 0xf7, 0x56, 0x03, 0xe1,
0xda, 0xac, 0x75, 0x83, 0xda, 0x32, 0xa1, 0x0c, 0x66, 0xc0, 0xf5, 0x50, 0x8a, 0x24, 0x66, 0x0b,
0xbb, 0x51, 0x08, 0x3f, 0x5e, 0xe3, 0x2b, 0x63, 0xc1, 0x83, 0x15, 0x72, 0x50, 0x00, 0xc3, 0x1d,
0xf9, 0xf3, 0xc3, 0xe9, 0x22, 0xb3, 0x5a, 0x63, 0xb5, 0x51, 0xfd, 0x11, 0x16, 0x45, 0x0c, 0x66,
0x98, 0x3f, 0x73, 0xa7, 0x19, 0x4d, 0xe6, 0xa5, 0x53, 0x33, 0x2c, 0x8b, 0xf3, 0xe9, 0xdb, 0xd2,
0x35, 0xde, 0x97, 0xae, 0xf1, 0xb1, 0x74, 0x8d, 0xe7, 0x4f, 0xf7, 0xcf, 0xc3, 0xd9, 0x24, 0xd6,
0xd3, 0x79, 0x84, 0x99, 0x98, 0x11, 0xae, 0x24, 0x63, 0x9d, 0x11, 0x64, 0x84, 0x83, 0x18, 0xab,
0x0e, 0x95, 0x71, 0x67, 0x22, 0xc8, 0xc6, 0x7d, 0x4f, 0xab, 0xf2, 0xa5, 0xb6, 0x7f, 0x0b, 0xe2,
0xea, 0x1e, 0xf7, 0x06, 0xfd, 0x5c, 0x7c, 0x15, 0x41, 0xf4, 0xaf, 0x38, 0x59, 0xf7, 0x2b, 0x00,
0x00, 0xff, 0xff, 0x83, 0x61, 0x0e, 0xc4, 0x1e, 0x02, 0x00, 0x00,
}
func (m *Container) Marshal() (dAtA []byte, err error) {
@ -452,7 +452,7 @@ func (m *Container) Unmarshal(dAtA []byte) error {
return io.ErrUnexpectedEOF
}
if m.OwnerId == nil {
m.OwnerId = &refs.OwnerID{}
m.OwnerId = &grpc.OwnerID{}
}
if err := m.OwnerId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
@ -575,7 +575,7 @@ func (m *Container) Unmarshal(dAtA []byte) error {
return io.ErrUnexpectedEOF
}
if m.PlacementPolicy == nil {
m.PlacementPolicy = &netmap.PlacementPolicy{}
m.PlacementPolicy = &grpc1.PlacementPolicy{}
}
if err := m.PlacementPolicy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err

350
v2/convert.go
View file

@ -1,351 +1 @@
package v2
import (
"github.com/nspcc-dev/neofs-api-go/v2/accounting"
"github.com/nspcc-dev/neofs-api-go/v2/refs"
"github.com/nspcc-dev/neofs-api-go/v2/service"
)
func SignatureToGRPCMessage(s *Signature) *service.Signature {
if s == nil {
return nil
}
m := new(service.Signature)
m.SetKey(s.GetKey())
m.SetSign(s.GetSign())
return m
}
func SignatureFromGRPCMessage(m *service.Signature) *Signature {
if m == nil {
return nil
}
s := new(Signature)
s.SetKey(m.GetKey())
s.SetSign(m.GetSign())
return s
}
func VersionToGRPCMessage(v *Version) *service.Version {
if v == nil {
return nil
}
msg := new(service.Version)
msg.SetMajor(v.GetMajor())
msg.SetMinor(v.GetMinor())
return msg
}
func VersionFromGRPCMessage(m *service.Version) *Version {
if m == nil {
return nil
}
v := new(Version)
v.SetMajor(m.GetMajor())
v.SetMinor(m.GetMinor())
return v
}
func XHeaderToGRPCMessage(x *XHeader) *service.XHeader {
if x == nil {
return nil
}
m := new(service.XHeader)
m.SetKey(x.GetKey())
m.SetValue(x.GetValue())
return m
}
func XHeaderFromGRPCMessage(m *service.XHeader) *XHeader {
if m == nil {
return nil
}
x := new(XHeader)
x.SetKey(m.GetKey())
x.SetValue(m.GetValue())
return x
}
func SessionTokenToGRPCMessage(t *SessionToken) *service.SessionToken {
// TODO: fill me
return nil
}
func SessionTokenFromGRPCMessage(m *service.SessionToken) *SessionToken {
// TODO: fill me
return nil
}
func BearerTokenToGRPCMessage(t *BearerToken) *service.BearerToken {
// TODO: fill me
return nil
}
func BearerTokenFromGRPCMessage(m *service.BearerToken) *BearerToken {
// TODO: fill me
return nil
}
func RequestVerificationHeaderToGRPCMessage(r *RequestVerificationHeader) *service.RequestVerificationHeader {
if r == nil {
return nil
}
m := new(service.RequestVerificationHeader)
m.SetBodySignature(
SignatureToGRPCMessage(r.GetBodySignature()),
)
m.SetMetaSignature(
SignatureToGRPCMessage(r.GetMetaSignature()),
)
m.SetOriginSignature(
SignatureToGRPCMessage(r.GetOriginSignature()),
)
m.SetOrigin(
RequestVerificationHeaderToGRPCMessage(r.GetOrigin()),
)
return m
}
func RequestVerificationHeaderFromGRPCMessage(m *service.RequestVerificationHeader) *RequestVerificationHeader {
if m == nil {
return nil
}
r := new(RequestVerificationHeader)
r.SetBodySignature(
SignatureFromGRPCMessage(m.GetBodySignature()),
)
r.SetMetaSignature(
SignatureFromGRPCMessage(m.GetMetaSignature()),
)
r.SetOriginSignature(
SignatureFromGRPCMessage(m.GetOriginSignature()),
)
r.SetOrigin(
RequestVerificationHeaderFromGRPCMessage(m.GetOrigin()),
)
return r
}
func RequestMetaHeaderToGRPCMessage(r *RequestMetaHeader) *service.RequestMetaHeader {
if r == nil {
return nil
}
m := new(service.RequestMetaHeader)
m.SetTtl(r.GetTTL())
m.SetEpoch(r.GetEpoch())
m.SetVersion(
VersionToGRPCMessage(r.GetVersion()),
)
m.SetSessionToken(
SessionTokenToGRPCMessage(r.GetSessionToken()),
)
m.SetBearerToken(
BearerTokenToGRPCMessage(r.GetBearerToken()),
)
m.SetOrigin(
RequestMetaHeaderToGRPCMessage(r.GetOrigin()),
)
xHeaders := r.GetXHeaders()
xHdrMsg := make([]*service.XHeader, 0, len(xHeaders))
for i := range xHeaders {
xHdrMsg = append(xHdrMsg, XHeaderToGRPCMessage(xHeaders[i]))
}
return m
}
func RequestMetaHeaderFromGRPCMessage(m *service.RequestMetaHeader) *RequestMetaHeader {
if m == nil {
return nil
}
r := new(RequestMetaHeader)
r.SetTTL(m.GetTtl())
r.SetEpoch(m.GetEpoch())
r.SetVersion(
VersionFromGRPCMessage(m.GetVersion()),
)
r.SetSessionToken(
SessionTokenFromGRPCMessage(m.GetSessionToken()),
)
r.SetBearerToken(
BearerTokenFromGRPCMessage(m.GetBearerToken()),
)
r.SetOrigin(
RequestMetaHeaderFromGRPCMessage(m.GetOrigin()),
)
xHdrMsg := m.GetXHeaders()
xHeaders := make([]*XHeader, 0, len(xHdrMsg))
for i := range xHdrMsg {
xHeaders = append(xHeaders, XHeaderFromGRPCMessage(xHdrMsg[i]))
}
return r
}
func OwnerIDToGRPCMessage(o *OwnerID) *refs.OwnerID {
if o == nil {
return nil
}
m := new(refs.OwnerID)
m.SetValue(o.GetValue())
return m
}
func OwnerIDFromGRPCMessage(m *refs.OwnerID) *OwnerID {
if m == nil {
return nil
}
o := new(OwnerID)
o.SetValue(m.GetValue())
return o
}
func BalanceRequestBodyToGRPCMessage(b *BalanceRequestBody) *accounting.BalanceRequest_Body {
if b == nil {
return nil
}
m := new(accounting.BalanceRequest_Body)
m.SetOwnerId(
OwnerIDToGRPCMessage(b.GetOwnerID()),
)
return m
}
func BalanceRequestBodyFromGRPCMessage(m *accounting.BalanceRequest_Body) *BalanceRequestBody {
if m == nil {
return nil
}
b := new(BalanceRequestBody)
b.SetOwnerID(
OwnerIDFromGRPCMessage(m.GetOwnerId()),
)
return b
}
func headersToGRPC(
src interface {
GetRequestMetaHeader() *RequestMetaHeader
GetRequestVerificationHeader() *RequestVerificationHeader
},
dst interface {
SetMetaHeader(*service.RequestMetaHeader)
SetVerifyHeader(*service.RequestVerificationHeader)
},
) {
dst.SetMetaHeader(
RequestMetaHeaderToGRPCMessage(src.GetRequestMetaHeader()),
)
dst.SetVerifyHeader(
RequestVerificationHeaderToGRPCMessage(src.GetRequestVerificationHeader()),
)
}
func headersFromGRPC(
src interface {
GetMetaHeader() *service.RequestMetaHeader
GetVerifyHeader() *service.RequestVerificationHeader
},
dst interface {
SetRequestMetaHeader(*RequestMetaHeader)
SetRequestVerificationHeader(*RequestVerificationHeader)
},
) {
dst.SetRequestMetaHeader(
RequestMetaHeaderFromGRPCMessage(src.GetMetaHeader()),
)
dst.SetRequestVerificationHeader(
RequestVerificationHeaderFromGRPCMessage(src.GetVerifyHeader()),
)
}
func BalanceRequestToGRPCMessage(b *BalanceRequest) *accounting.BalanceRequest {
if b == nil {
return nil
}
m := new(accounting.BalanceRequest)
m.SetBody(
BalanceRequestBodyToGRPCMessage(b.GetBody()),
)
headersToGRPC(b, m)
return m
}
func BalanceRequestFromGRPCMessage(m *accounting.BalanceRequest) *BalanceRequest {
if m == nil {
return nil
}
b := new(BalanceRequest)
b.SetBody(
BalanceRequestBodyFromGRPCMessage(m.GetBody()),
)
headersFromGRPC(m, b)
return b
}

0
v2/netmap/marshal.go → v2/netmap/grpc/marshal.go
View file

0
v2/netmap/types.go → v2/netmap/grpc/types.go
View file

112
v2/netmap/types.pb.go → v2/netmap/grpc/types.pb.go
View file

@ -1,5 +1,5 @@
// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: v2/netmap/types.proto
// source: v2/netmap/grpc/types.proto
package netmap
@ -75,7 +75,7 @@ func (x PlacementPolicy_FilterGroup_Filter_SimpleFilter_Operation) String() stri
}
func (PlacementPolicy_FilterGroup_Filter_SimpleFilter_Operation) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_1207dc80bd67ddec, []int{0, 0, 0, 0, 0}
return fileDescriptor_91a1332b2376641a, []int{0, 0, 0, 0, 0}
}
// Represents the enumeration of various states of the NeoFS node.
@ -107,7 +107,7 @@ func (x NodeInfo_State) String() string {
}
func (NodeInfo_State) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_1207dc80bd67ddec, []int{1, 0}
return fileDescriptor_91a1332b2376641a, []int{1, 0}
}
// Set of rules to select a subset of nodes able to store container's objects
@ -125,7 +125,7 @@ func (m *PlacementPolicy) Reset() { *m = PlacementPolicy{} }
func (m *PlacementPolicy) String() string { return proto.CompactTextString(m) }
func (*PlacementPolicy) ProtoMessage() {}
func (*PlacementPolicy) Descriptor() ([]byte, []int) {
return fileDescriptor_1207dc80bd67ddec, []int{0}
return fileDescriptor_91a1332b2376641a, []int{0}
}
func (m *PlacementPolicy) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -185,7 +185,7 @@ func (m *PlacementPolicy_FilterGroup) Reset() { *m = PlacementPolicy_Fil
func (m *PlacementPolicy_FilterGroup) String() string { return proto.CompactTextString(m) }
func (*PlacementPolicy_FilterGroup) ProtoMessage() {}
func (*PlacementPolicy_FilterGroup) Descriptor() ([]byte, []int) {
return fileDescriptor_1207dc80bd67ddec, []int{0, 0}
return fileDescriptor_91a1332b2376641a, []int{0, 0}
}
func (m *PlacementPolicy_FilterGroup) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -250,7 +250,7 @@ func (m *PlacementPolicy_FilterGroup_Filter) Reset() { *m = PlacementPol
func (m *PlacementPolicy_FilterGroup_Filter) String() string { return proto.CompactTextString(m) }
func (*PlacementPolicy_FilterGroup_Filter) ProtoMessage() {}
func (*PlacementPolicy_FilterGroup_Filter) Descriptor() ([]byte, []int) {
return fileDescriptor_1207dc80bd67ddec, []int{0, 0, 0}
return fileDescriptor_91a1332b2376641a, []int{0, 0, 0}
}
func (m *PlacementPolicy_FilterGroup_Filter) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -316,7 +316,7 @@ func (m *PlacementPolicy_FilterGroup_Filter_SimpleFilter) String() string {
}
func (*PlacementPolicy_FilterGroup_Filter_SimpleFilter) ProtoMessage() {}
func (*PlacementPolicy_FilterGroup_Filter_SimpleFilter) Descriptor() ([]byte, []int) {
return fileDescriptor_1207dc80bd67ddec, []int{0, 0, 0, 0}
return fileDescriptor_91a1332b2376641a, []int{0, 0, 0, 0}
}
func (m *PlacementPolicy_FilterGroup_Filter_SimpleFilter) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -416,7 +416,7 @@ func (m *PlacementPolicy_FilterGroup_Filter_SimpleFilter_SimpleFilters) String()
}
func (*PlacementPolicy_FilterGroup_Filter_SimpleFilter_SimpleFilters) ProtoMessage() {}
func (*PlacementPolicy_FilterGroup_Filter_SimpleFilter_SimpleFilters) Descriptor() ([]byte, []int) {
return fileDescriptor_1207dc80bd67ddec, []int{0, 0, 0, 0, 0}
return fileDescriptor_91a1332b2376641a, []int{0, 0, 0, 0, 0}
}
func (m *PlacementPolicy_FilterGroup_Filter_SimpleFilter_SimpleFilters) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -467,7 +467,7 @@ func (m *PlacementPolicy_FilterGroup_Selector) Reset() { *m = PlacementP
func (m *PlacementPolicy_FilterGroup_Selector) String() string { return proto.CompactTextString(m) }
func (*PlacementPolicy_FilterGroup_Selector) ProtoMessage() {}
func (*PlacementPolicy_FilterGroup_Selector) Descriptor() ([]byte, []int) {
return fileDescriptor_1207dc80bd67ddec, []int{0, 0, 1}
return fileDescriptor_91a1332b2376641a, []int{0, 0, 1}
}
func (m *PlacementPolicy_FilterGroup_Selector) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -529,7 +529,7 @@ func (m *NodeInfo) Reset() { *m = NodeInfo{} }
func (m *NodeInfo) String() string { return proto.CompactTextString(m) }
func (*NodeInfo) ProtoMessage() {}
func (*NodeInfo) Descriptor() ([]byte, []int) {
return fileDescriptor_1207dc80bd67ddec, []int{1}
return fileDescriptor_91a1332b2376641a, []int{1}
}
func (m *NodeInfo) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -601,7 +601,7 @@ func (m *NodeInfo_Attribute) Reset() { *m = NodeInfo_Attribute{} }
func (m *NodeInfo_Attribute) String() string { return proto.CompactTextString(m) }
func (*NodeInfo_Attribute) ProtoMessage() {}
func (*NodeInfo_Attribute) Descriptor() ([]byte, []int) {
return fileDescriptor_1207dc80bd67ddec, []int{1, 0}
return fileDescriptor_91a1332b2376641a, []int{1, 0}
}
func (m *NodeInfo_Attribute) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -657,52 +657,52 @@ func init() {
proto.RegisterType((*NodeInfo_Attribute)(nil), "neo.fs.v2.netmap.NodeInfo.Attribute")
}
func init() { proto.RegisterFile("v2/netmap/types.proto", fileDescriptor_1207dc80bd67ddec) }
func init() { proto.RegisterFile("v2/netmap/grpc/types.proto", fileDescriptor_91a1332b2376641a) }
var fileDescriptor_1207dc80bd67ddec = []byte{
// 660 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x54, 0xc1, 0x6e, 0xd3, 0x4c,
0x10, 0xae, 0xed, 0xc4, 0x69, 0x26, 0xcd, 0x5f, 0x6b, 0xff, 0x16, 0x99, 0x48, 0x84, 0x28, 0xe2,
0x90, 0x4b, 0x1c, 0xe1, 0xa2, 0x5e, 0x38, 0xa5, 0xd4, 0x29, 0x51, 0x2b, 0x3b, 0x38, 0xe1, 0xd2,
0x1e, 0x22, 0xc7, 0x59, 0xa7, 0x16, 0x8e, 0xd7, 0xf2, 0xae, 0x23, 0xf2, 0x26, 0xbc, 0x02, 0x3c,
0x02, 0x07, 0xae, 0x70, 0xe0, 0xc0, 0x23, 0xa0, 0xf2, 0x22, 0xc8, 0xeb, 0x38, 0x4d, 0x0b, 0x42,
0x2a, 0xe5, 0xf4, 0xf9, 0x9b, 0xd9, 0xf9, 0xc6, 0x33, 0xfe, 0xbc, 0xb0, 0xbf, 0xd0, 0x3b, 0x21,
0x66, 0x73, 0x27, 0xea, 0xb0, 0x65, 0x84, 0xa9, 0x16, 0xc5, 0x84, 0x11, 0xa4, 0x84, 0x98, 0x68,
0x1e, 0xd5, 0x16, 0xba, 0x96, 0x65, 0x9b, 0x9f, 0x4b, 0xb0, 0x3b, 0x08, 0x1c, 0x17, 0xcf, 0x71,
0xc8, 0x06, 0x24, 0xf0, 0xdd, 0x25, 0x7a, 0x0c, 0x95, 0x18, 0x47, 0xc1, 0xd8, 0x73, 0x5c, 0x46,
0x62, 0x55, 0x68, 0x08, 0xad, 0xaa, 0x0d, 0x69, 0xa8, 0xc7, 0x23, 0xc8, 0x86, 0xaa, 0xe7, 0x07,
0x0c, 0xc7, 0xe3, 0x59, 0x4c, 0x92, 0x88, 0xaa, 0x62, 0x43, 0x6a, 0x55, 0xf4, 0xb6, 0x76, 0x5b,
0x5e, 0xbb, 0x25, 0xad, 0xf5, 0x78, 0xd9, 0x49, 0x5a, 0x65, 0xef, 0x78, 0xd7, 0x84, 0xd6, 0x3e,
0xc9, 0x50, 0xd9, 0xc8, 0x22, 0x13, 0x4a, 0x59, 0x9e, 0xaa, 0x02, 0x57, 0x7f, 0x76, 0x27, 0xf5,
0xd5, 0xb3, 0x9d, 0x8b, 0xa0, 0x11, 0x94, 0x29, 0x0e, 0x70, 0xfa, 0xfe, 0xf9, 0xfb, 0x1e, 0xde,
0x4d, 0x71, 0xb8, 0x2a, 0xb7, 0xaf, 0x85, 0x90, 0x0a, 0x25, 0xfc, 0xd6, 0x0d, 0x92, 0x29, 0x56,
0xa5, 0x86, 0xd4, 0xaa, 0xda, 0x39, 0xad, 0x7d, 0x2c, 0x80, 0x9c, 0x55, 0x23, 0x05, 0xa4, 0x37,
0x78, 0xc9, 0xf7, 0x58, 0xb6, 0xd3, 0x47, 0x64, 0x81, 0xe0, 0xa9, 0x62, 0x43, 0x68, 0x55, 0xf4,
0xee, 0xdf, 0x8c, 0xa5, 0x0d, 0xfd, 0x79, 0x14, 0xe0, 0xd5, 0x8c, 0x82, 0x57, 0xfb, 0x2a, 0xc1,
0xce, 0x66, 0x0c, 0x5d, 0x80, 0x48, 0x22, 0xde, 0xf2, 0x3f, 0xfd, 0xf4, 0xde, 0x2d, 0x34, 0x2b,
0xc2, 0xb1, 0xc3, 0x7c, 0x12, 0xda, 0x22, 0x89, 0xd0, 0x03, 0x28, 0x2e, 0x9c, 0x20, 0xc1, 0x7c,
0x84, 0xf2, 0xcb, 0x2d, 0x3b, 0xa3, 0xe8, 0x12, 0x64, 0x6f, 0xec, 0xc4, 0x33, 0xaa, 0x4a, 0x7c,
0x36, 0xeb, 0xfe, 0x8d, 0x37, 0x09, 0x4d, 0x3b, 0x79, 0xdd, 0x78, 0x46, 0x6b, 0x01, 0x54, 0x6f,
0x64, 0xd0, 0xc5, 0x6d, 0xbb, 0xfc, 0x83, 0xbd, 0xe6, 0x8a, 0xcd, 0x19, 0x94, 0xd7, 0x0b, 0x40,
0x0f, 0x61, 0xdf, 0x1a, 0x18, 0x76, 0x77, 0xd4, 0xb7, 0xcc, 0xf1, 0x6b, 0x73, 0x38, 0x30, 0x5e,
0xf4, 0x7b, 0x7d, 0xe3, 0x58, 0xd9, 0x42, 0x32, 0x88, 0xc6, 0x2b, 0x45, 0x48, 0xd1, 0x34, 0x14,
0x31, 0xc5, 0x93, 0x91, 0x22, 0x71, 0x34, 0x94, 0x42, 0x8a, 0x67, 0x23, 0xa5, 0xc8, 0xd1, 0x50,
0xe4, 0x14, 0x2d, 0x5b, 0x29, 0xa1, 0x12, 0x48, 0x5d, 0xf3, 0x58, 0xd9, 0x3e, 0x92, 0xa1, 0x90,
0xae, 0xaf, 0xa6, 0xc3, 0x76, 0xee, 0x36, 0xb4, 0x07, 0x45, 0x97, 0x24, 0x21, 0x5b, 0xfd, 0x87,
0x19, 0xc9, 0x3d, 0x25, 0xae, 0x3d, 0xd5, 0x7c, 0x2f, 0xc2, 0xb6, 0x49, 0xa6, 0xb8, 0x1f, 0x7a,
0x24, 0xf5, 0xa5, 0x33, 0x9d, 0xc6, 0x98, 0xd2, 0x95, 0xed, 0x72, 0x8a, 0x1e, 0x01, 0x44, 0xc9,
0x24, 0xf0, 0xdd, 0x71, 0x5e, 0xbf, 0x63, 0x97, 0xb3, 0xc8, 0x29, 0x5e, 0xa2, 0x63, 0x00, 0x87,
0xb1, 0xd8, 0x9f, 0x24, 0x0c, 0x53, 0xee, 0xe9, 0x8a, 0xfe, 0xe4, 0xd7, 0x55, 0xe6, 0x8d, 0xb4,
0x6e, 0x7e, 0xd8, 0xde, 0xa8, 0x43, 0x87, 0x50, 0xa4, 0xcc, 0x61, 0x58, 0x2d, 0x70, 0x03, 0x36,
0xfe, 0x20, 0x30, 0x4c, 0xcf, 0xd9, 0xd9, 0xf1, 0xda, 0x01, 0x94, 0xd7, 0x82, 0xbf, 0xf9, 0x6d,
0xf6, 0x6e, 0xf8, 0x6e, 0xe5, 0xba, 0xe6, 0x53, 0x28, 0x72, 0x11, 0xb4, 0x0b, 0x95, 0x9b, 0xdf,
0x03, 0x40, 0xb6, 0xcc, 0xb3, 0xbe, 0x69, 0x28, 0x02, 0xaa, 0x40, 0xc9, 0xea, 0xf5, 0x38, 0x11,
0x8f, 0xce, 0xbf, 0x5c, 0xd5, 0x85, 0x6f, 0x57, 0x75, 0xe1, 0xfb, 0x55, 0x5d, 0x78, 0xf7, 0xa3,
0xbe, 0x75, 0xae, 0xcf, 0x7c, 0x76, 0x99, 0x4c, 0x34, 0x97, 0xcc, 0x3b, 0x21, 0x8d, 0x5c, 0xb7,
0x3d, 0xc5, 0x8b, 0x4e, 0x88, 0x89, 0x47, 0xdb, 0x4e, 0xe4, 0xb7, 0x67, 0xa4, 0xb3, 0xbe, 0x52,
0x9f, 0x67, 0xf0, 0x41, 0xfc, 0xdf, 0xc4, 0xa4, 0x37, 0xd4, 0xba, 0x83, 0x7e, 0x3a, 0x99, 0xc9,
0xa3, 0x13, 0x99, 0x5f, 0xb5, 0x07, 0x3f, 0x03, 0x00, 0x00, 0xff, 0xff, 0x2d, 0xc4, 0x82, 0xde,
0x83, 0x05, 0x00, 0x00,
var fileDescriptor_91a1332b2376641a = []byte{
// 663 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x54, 0xcd, 0x6e, 0xd3, 0x40,
0x10, 0xae, 0xed, 0xc4, 0x69, 0x26, 0x0d, 0xb5, 0x96, 0x82, 0x4c, 0x24, 0x42, 0x14, 0x71, 0xc8,
0x25, 0x8e, 0x48, 0x51, 0x39, 0x70, 0x4a, 0xa9, 0x53, 0xa2, 0x56, 0x76, 0xd8, 0x84, 0x0b, 0x3d,
0x44, 0x8e, 0xb3, 0x4e, 0x2d, 0x1c, 0xaf, 0xe5, 0xdd, 0x44, 0xe4, 0x4d, 0x78, 0x05, 0x78, 0x04,
0x0e, 0x5c, 0xe1, 0xc0, 0x81, 0x47, 0x40, 0xe5, 0x45, 0x90, 0xd7, 0x71, 0x9b, 0x14, 0x84, 0x54,
0xca, 0x69, 0xf6, 0x9b, 0x9f, 0x6f, 0x3c, 0xe3, 0x6f, 0x17, 0x2a, 0x8b, 0x76, 0x2b, 0x24, 0x7c,
0xe6, 0x44, 0xad, 0x69, 0x1c, 0xb9, 0x2d, 0xbe, 0x8c, 0x08, 0x33, 0xa2, 0x98, 0x72, 0x8a, 0xb4,
0x90, 0x50, 0xc3, 0x63, 0xc6, 0xa2, 0x6d, 0xa4, 0x29, 0xf5, 0x2f, 0x05, 0xd8, 0xed, 0x07, 0x8e,
0x4b, 0x66, 0x24, 0xe4, 0x7d, 0x1a, 0xf8, 0xee, 0x12, 0x3d, 0x82, 0x52, 0x4c, 0xa2, 0x60, 0xe4,
0x39, 0x2e, 0xa7, 0xb1, 0x2e, 0xd5, 0xa4, 0x46, 0x19, 0x43, 0xe2, 0xea, 0x0a, 0x0f, 0xc2, 0x50,
0xf6, 0xfc, 0x80, 0x93, 0x78, 0x34, 0x8d, 0xe9, 0x3c, 0x62, 0xba, 0x5c, 0x53, 0x1a, 0xa5, 0x76,
0xd3, 0xb8, 0x4e, 0x6f, 0x5c, 0xa3, 0x36, 0xba, 0xa2, 0xec, 0x38, 0xa9, 0xc2, 0x3b, 0xde, 0x15,
0x60, 0x95, 0xcf, 0x2a, 0x94, 0xd6, 0xa2, 0xc8, 0x82, 0x42, 0x1a, 0x67, 0xba, 0x24, 0xd8, 0x9f,
0xde, 0x88, 0x7d, 0x75, 0xc6, 0x19, 0x09, 0x1a, 0x42, 0x91, 0x91, 0x80, 0x24, 0xdf, 0x9f, 0x7d,
0xef, 0xc1, 0xcd, 0x18, 0x07, 0xab, 0x72, 0x7c, 0x45, 0x84, 0x74, 0x28, 0x90, 0x77, 0x6e, 0x30,
0x9f, 0x10, 0x5d, 0xa9, 0x29, 0x8d, 0x32, 0xce, 0x60, 0xe5, 0x53, 0x0e, 0xd4, 0xb4, 0x1a, 0x69,
0xa0, 0xbc, 0x25, 0x4b, 0xb1, 0xc7, 0x22, 0x4e, 0x8e, 0xc8, 0x06, 0xc9, 0xd3, 0xe5, 0x9a, 0xd4,
0x28, 0xb5, 0x3b, 0xff, 0x32, 0x96, 0x31, 0xf0, 0x67, 0x51, 0x40, 0x56, 0x33, 0x4a, 0x5e, 0xe5,
0x9b, 0x02, 0x3b, 0xeb, 0x3e, 0x74, 0x06, 0x32, 0x8d, 0x44, 0xcb, 0x3b, 0xed, 0x93, 0x5b, 0xb7,
0x30, 0xec, 0x88, 0xc4, 0x0e, 0xf7, 0x69, 0x88, 0x65, 0x1a, 0xa1, 0xfb, 0x90, 0x5f, 0x38, 0xc1,
0x9c, 0x88, 0x11, 0x8a, 0x2f, 0xb7, 0x70, 0x0a, 0xd1, 0x39, 0xa8, 0xde, 0xc8, 0x89, 0xa7, 0x4c,
0x57, 0xc4, 0x6c, 0xf6, 0xed, 0x1b, 0xaf, 0x03, 0x96, 0x74, 0xf2, 0x3a, 0xf1, 0x94, 0x55, 0x02,
0x28, 0x6f, 0x44, 0xd0, 0xd9, 0x75, 0xb9, 0xfc, 0x87, 0xbd, 0x66, 0x8c, 0xf5, 0x29, 0x14, 0x2f,
0x17, 0x80, 0x1e, 0xc0, 0x3d, 0xbb, 0x6f, 0xe2, 0xce, 0xb0, 0x67, 0x5b, 0xa3, 0xd7, 0xd6, 0xa0,
0x6f, 0xbe, 0xe8, 0x75, 0x7b, 0xe6, 0x91, 0xb6, 0x85, 0x54, 0x90, 0xcd, 0x57, 0x9a, 0x94, 0x58,
0xcb, 0xd4, 0xe4, 0xc4, 0x1e, 0x0f, 0x35, 0x45, 0x58, 0x53, 0xcb, 0x25, 0xf6, 0x74, 0xa8, 0xe5,
0x85, 0x35, 0x35, 0x35, 0xb1, 0x36, 0xd6, 0x0a, 0xa8, 0x00, 0x4a, 0xc7, 0x3a, 0xd2, 0xb6, 0x0f,
0x55, 0xc8, 0x25, 0xeb, 0xab, 0xb4, 0x61, 0x3b, 0x53, 0x1b, 0xda, 0x83, 0xbc, 0x4b, 0xe7, 0x21,
0x5f, 0xdd, 0xc3, 0x14, 0x64, 0x9a, 0x92, 0x2f, 0x35, 0x55, 0xff, 0x20, 0xc3, 0xb6, 0x45, 0x27,
0xa4, 0x17, 0x7a, 0x34, 0xd1, 0xa5, 0x33, 0x99, 0xc4, 0x84, 0xb1, 0x95, 0xec, 0x32, 0x88, 0x1e,
0x02, 0x44, 0xf3, 0x71, 0xe0, 0xbb, 0xa3, 0xac, 0x7e, 0x07, 0x17, 0x53, 0xcf, 0x09, 0x59, 0xa2,
0x23, 0x00, 0x87, 0xf3, 0xd8, 0x1f, 0xcf, 0x39, 0x61, 0x42, 0xd3, 0xa5, 0xf6, 0xe3, 0xdf, 0x57,
0x99, 0x35, 0x32, 0x3a, 0x59, 0x32, 0x5e, 0xab, 0x43, 0x07, 0x90, 0x67, 0xdc, 0xe1, 0x44, 0xcf,
0x09, 0x01, 0xd6, 0xfe, 0x42, 0x30, 0x48, 0xf2, 0x70, 0x9a, 0x5e, 0xd9, 0x87, 0xe2, 0x25, 0xe1,
0x1f, 0xae, 0xcd, 0xde, 0x86, 0xee, 0x56, 0xaa, 0xab, 0x3f, 0x81, 0xbc, 0x20, 0x41, 0xbb, 0x50,
0xda, 0xfc, 0x1f, 0x00, 0xaa, 0x6d, 0x9d, 0xf6, 0x2c, 0x53, 0x93, 0x50, 0x09, 0x0a, 0x76, 0xb7,
0x2b, 0x80, 0x7c, 0x38, 0xfa, 0x7a, 0x51, 0x95, 0xbe, 0x5f, 0x54, 0xa5, 0x1f, 0x17, 0x55, 0xe9,
0xfd, 0xcf, 0xea, 0xd6, 0x9b, 0x67, 0x53, 0x9f, 0x9f, 0xcf, 0xc7, 0x86, 0x4b, 0x67, 0xad, 0x90,
0x45, 0xae, 0xdb, 0x9c, 0x90, 0x45, 0x2b, 0x24, 0xd4, 0x63, 0x4d, 0x27, 0xf2, 0x9b, 0x53, 0xda,
0xda, 0x7c, 0x57, 0x9f, 0xa7, 0xe7, 0x8f, 0xf2, 0x5d, 0x8b, 0xd0, 0xee, 0xc0, 0xe8, 0xf4, 0x7b,
0xc9, 0x78, 0x96, 0xf0, 0x8e, 0x55, 0xf1, 0xde, 0xee, 0xff, 0x0a, 0x00, 0x00, 0xff, 0xff, 0x87,
0xfe, 0x8e, 0x55, 0x8d, 0x05, 0x00, 0x00,
}
func (m *PlacementPolicy) Marshal() (dAtA []byte, err error) {

4
v2/object/service.go → v2/object/grpc/service.go
View file

@ -1,8 +1,8 @@
package object
import (
"github.com/nspcc-dev/neofs-api-go/v2/refs"
"github.com/nspcc-dev/neofs-api-go/v2/service"
refs "github.com/nspcc-dev/neofs-api-go/v2/refs/grpc"
service "github.com/nspcc-dev/neofs-api-go/v2/service/grpc"
)
// SetAddress sets address of the requested object.

716
v2/object/service.pb.go → v2/object/grpc/service.pb.go
View file

File diff suppressed because it is too large Load diff

4
v2/object/types.go → v2/object/grpc/types.go
View file

@ -1,8 +1,8 @@
package object
import (
"github.com/nspcc-dev/neofs-api-go/v2/refs"
"github.com/nspcc-dev/neofs-api-go/v2/service"
refs "github.com/nspcc-dev/neofs-api-go/v2/refs/grpc"
service "github.com/nspcc-dev/neofs-api-go/v2/service/grpc"
)
// SetKey sets key to the object attribute.

173
v2/object/types.pb.go → v2/object/grpc/types.pb.go
View file

@ -1,13 +1,13 @@
// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: v2/object/types.proto
// source: v2/object/grpc/types.proto
package object
import (
fmt "fmt"
proto "github.com/golang/protobuf/proto"
refs "github.com/nspcc-dev/neofs-api-go/v2/refs"
service "github.com/nspcc-dev/neofs-api-go/v2/service"
grpc "github.com/nspcc-dev/neofs-api-go/v2/refs/grpc"
grpc1 "github.com/nspcc-dev/neofs-api-go/v2/service/grpc"
io "io"
math "math"
math_bits "math/bits"
@ -53,20 +53,20 @@ func (x ObjectType) String() string {
}
func (ObjectType) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_fcb9e8df342f43c6, []int{0}
return fileDescriptor_545319325da7b9b1, []int{0}
}
// Object Headers
type Header struct {
// Object's container
ContainerId *refs.ContainerID `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"`
ContainerId *grpc.ContainerID `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"`
// Object's owner
OwnerId *refs.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"`
// Epoch when the object was created
CreationEpoch uint64 `protobuf:"varint,3,opt,name=creation_epoch,json=creationEpoch,proto3" json:"creation_epoch,omitempty"`
// Object format version.
// Effectively the version of API library used to create particular object
Version *service.Version `protobuf:"bytes,4,opt,name=version,proto3" json:"version,omitempty"`
Version *grpc1.Version `protobuf:"bytes,4,opt,name=version,proto3" json:"version,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"`
@ -78,7 +78,7 @@ type Header struct {
HomomorphicHash []byte `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 *service.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.
@ -92,7 +92,7 @@ func (m *Header) Reset() { *m = Header{} }
func (m *Header) String() string { return proto.CompactTextString(m) }
func (*Header) ProtoMessage() {}
func (*Header) Descriptor() ([]byte, []int) {
return fileDescriptor_fcb9e8df342f43c6, []int{0}
return fileDescriptor_545319325da7b9b1, []int{0}
}
func (m *Header) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -121,14 +121,14 @@ func (m *Header) XXX_DiscardUnknown() {
var xxx_messageInfo_Header proto.InternalMessageInfo
func (m *Header) GetContainerId() *refs.ContainerID {
func (m *Header) GetContainerId() *grpc.ContainerID {
if m != nil {
return m.ContainerId
}
return nil
}
func (m *Header) GetOwnerId() *refs.OwnerID {
func (m *Header) GetOwnerId() *grpc.OwnerID {
if m != nil {
return m.OwnerId
}
@ -142,7 +142,7 @@ func (m *Header) GetCreationEpoch() uint64 {
return 0
}
func (m *Header) GetVersion() *service.Version {
func (m *Header) GetVersion() *grpc1.Version {
if m != nil {
return m.Version
}
@ -177,7 +177,7 @@ func (m *Header) GetHomomorphicHash() []byte {
return nil
}
func (m *Header) GetSessionToken() *service.SessionToken {
func (m *Header) GetSessionToken() *grpc1.SessionToken {
if m != nil {
return m.SessionToken
}
@ -213,7 +213,7 @@ func (m *Header_Attribute) Reset() { *m = Header_Attribute{} }
func (m *Header_Attribute) String() string { return proto.CompactTextString(m) }
func (*Header_Attribute) ProtoMessage() {}
func (*Header_Attribute) Descriptor() ([]byte, []int) {
return fileDescriptor_fcb9e8df342f43c6, []int{0, 0}
return fileDescriptor_545319325da7b9b1, []int{0, 0}
}
func (m *Header_Attribute) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -261,15 +261,15 @@ 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 *refs.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 *refs.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 *service.Signature `protobuf:"bytes,3,opt,name=parent_signature,json=parentSignature,proto3" json:"parent_signature,omitempty"`
ParentSignature *grpc1.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 []*refs.ObjectID `protobuf:"bytes,5,rep,name=children,proto3" json:"children,omitempty"`
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:"-"`
@ -279,7 +279,7 @@ func (m *Header_Split) Reset() { *m = Header_Split{} }
func (m *Header_Split) String() string { return proto.CompactTextString(m) }
func (*Header_Split) ProtoMessage() {}
func (*Header_Split) Descriptor() ([]byte, []int) {
return fileDescriptor_fcb9e8df342f43c6, []int{0, 1}
return fileDescriptor_545319325da7b9b1, []int{0, 1}
}
func (m *Header_Split) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -308,21 +308,21 @@ func (m *Header_Split) XXX_DiscardUnknown() {
var xxx_messageInfo_Header_Split proto.InternalMessageInfo
func (m *Header_Split) GetParent() *refs.ObjectID {
func (m *Header_Split) GetParent() *grpc.ObjectID {
if m != nil {
return m.Parent
}
return nil
}
func (m *Header_Split) GetPrevious() *refs.ObjectID {
func (m *Header_Split) GetPrevious() *grpc.ObjectID {
if m != nil {
return m.Previous
}
return nil
}
func (m *Header_Split) GetParentSignature() *service.Signature {
func (m *Header_Split) GetParentSignature() *grpc1.Signature {
if m != nil {
return m.ParentSignature
}
@ -336,7 +336,7 @@ func (m *Header_Split) GetParentHeader() *Header {
return nil
}
func (m *Header_Split) GetChildren() []*refs.ObjectID {
func (m *Header_Split) GetChildren() []*grpc.ObjectID {
if m != nil {
return m.Children
}
@ -349,9 +349,9 @@ 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 *refs.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 *service.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 metadata headers
Header *Header `protobuf:"bytes,3,opt,name=header,proto3" json:"header,omitempty"`
// Payload bytes.
@ -365,7 +365,7 @@ func (m *Object) Reset() { *m = Object{} }
func (m *Object) String() string { return proto.CompactTextString(m) }
func (*Object) ProtoMessage() {}
func (*Object) Descriptor() ([]byte, []int) {
return fileDescriptor_fcb9e8df342f43c6, []int{1}
return fileDescriptor_545319325da7b9b1, []int{1}
}
func (m *Object) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -394,14 +394,14 @@ func (m *Object) XXX_DiscardUnknown() {
var xxx_messageInfo_Object proto.InternalMessageInfo
func (m *Object) GetObjectId() *refs.ObjectID {
func (m *Object) GetObjectId() *grpc.ObjectID {
if m != nil {
return m.ObjectId
}
return nil
}
func (m *Object) GetSignature() *service.Signature {
func (m *Object) GetSignature() *grpc1.Signature {
if m != nil {
return m.Signature
}
@ -430,55 +430,56 @@ func init() {
proto.RegisterType((*Object)(nil), "neo.fs.v2.object.Object")
}
func init() { proto.RegisterFile("v2/object/types.proto", fileDescriptor_fcb9e8df342f43c6) }
func init() { proto.RegisterFile("v2/object/grpc/types.proto", fileDescriptor_545319325da7b9b1) }
var fileDescriptor_fcb9e8df342f43c6 = []byte{
// 720 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x94, 0xcf, 0x6e, 0xd3, 0x4e,
0x10, 0xc7, 0xeb, 0xa4, 0xf9, 0x37, 0x4e, 0xda, 0xfc, 0xb6, 0x3f, 0x54, 0x2b, 0xa0, 0x10, 0x2a,
0x21, 0x05, 0xa4, 0x3a, 0xc8, 0x0d, 0x17, 0xaa, 0x22, 0xa5, 0x34, 0xa4, 0x91, 0x4a, 0x53, 0x6d,
0x52, 0x0e, 0xbd, 0x44, 0x8e, 0xbd, 0x89, 0x4d, 0x13, 0xaf, 0xe5, 0x75, 0x5c, 0xe5, 0x4d, 0x78,
0x06, 0x24, 0x2e, 0xbc, 0x04, 0x1c, 0x79, 0x04, 0x54, 0x5e, 0x04, 0x79, 0xd7, 0x76, 0x42, 0x4b,
0x0b, 0x27, 0x7b, 0xbf, 0xfe, 0x7c, 0x67, 0x76, 0x66, 0x67, 0x0d, 0x0f, 0x02, 0xad, 0x41, 0x47,
0x1f, 0x88, 0xe1, 0x37, 0xfc, 0x85, 0x4b, 0x98, 0xea, 0x7a, 0xd4, 0xa7, 0xa8, 0xec, 0x10, 0xaa,
0x8e, 0x99, 0x1a, 0x68, 0xaa, 0xf8, 0x5a, 0xd9, 0x0a, 0xb4, 0x86, 0x47, 0xc6, 0x6c, 0x15, 0xab,
0x84, 0x6e, 0x46, 0xbc, 0xc0, 0x36, 0x48, 0x63, 0x46, 0x7c, 0x3d, 0x92, 0xb7, 0x57, 0xe4, 0x80,
0x78, 0xf6, 0x78, 0x21, 0x3e, 0xec, 0x7c, 0xc9, 0x41, 0xf6, 0x98, 0xe8, 0x26, 0xf1, 0xd0, 0x6b,
0x28, 0x1a, 0xd4, 0xf1, 0x75, 0xdb, 0x21, 0xde, 0xd0, 0x36, 0x15, 0xa9, 0x26, 0xd5, 0x65, 0xed,
0xa1, 0xba, 0x4c, 0x1c, 0x66, 0x53, 0xdf, 0xc4, 0x4c, 0xf7, 0x08, 0xcb, 0x89, 0xa1, 0x6b, 0x22,
0x0d, 0xf2, 0xf4, 0x2a, 0xf2, 0xa6, 0xb8, 0x77, 0xfb, 0xa6, 0xb7, 0x77, 0x25, 0x7c, 0x39, 0x0e,
0x76, 0x4d, 0xf4, 0x14, 0x36, 0x0c, 0x8f, 0xe8, 0xbe, 0x4d, 0x9d, 0x21, 0x71, 0xa9, 0x61, 0x29,
0xe9, 0x9a, 0x54, 0x5f, 0xc7, 0xa5, 0x58, 0x6d, 0x87, 0x22, 0x6a, 0x42, 0x2e, 0x20, 0x1e, 0xb3,
0xa9, 0xa3, 0xac, 0xf3, 0xc8, 0x95, 0x95, 0xc8, 0x51, 0x5d, 0xea, 0x7b, 0x41, 0xe0, 0x18, 0x0d,
0x83, 0xbb, 0xfa, 0x62, 0x4a, 0x75, 0x73, 0x38, 0x25, 0xce, 0xc4, 0xb7, 0x94, 0x8c, 0x08, 0x1e,
0xa9, 0x27, 0x5c, 0x44, 0x4f, 0xa0, 0x18, 0x63, 0x96, 0xce, 0x2c, 0x25, 0x5b, 0x93, 0xea, 0x45,
0x2c, 0x47, 0xda, 0xb1, 0xce, 0x2c, 0x74, 0x00, 0xb2, 0x68, 0xfa, 0x30, 0xec, 0xb5, 0x92, 0xab,
0x49, 0xf5, 0x0d, 0xed, 0x91, 0x7a, 0xf3, 0x48, 0xd4, 0x1e, 0x7f, 0x0c, 0x16, 0x2e, 0xc1, 0x40,
0x93, 0x77, 0xf4, 0x0c, 0xca, 0x16, 0x9d, 0xd1, 0x19, 0xf5, 0x5c, 0xcb, 0x36, 0x44, 0x96, 0x3c,
0xcf, 0xb2, 0xb9, 0xa2, 0xf3, 0x4c, 0x47, 0x50, 0x62, 0x84, 0x85, 0xdb, 0x1f, 0xfa, 0xf4, 0x92,
0x38, 0x4a, 0x81, 0xd7, 0xfb, 0xf8, 0x0f, 0xf5, 0xf6, 0x05, 0x37, 0x08, 0x31, 0x5c, 0x64, 0x2b,
0x2b, 0x74, 0x08, 0xa0, 0xfb, 0xbe, 0x67, 0x8f, 0xe6, 0x3e, 0x61, 0x0a, 0xd4, 0xd2, 0x75, 0x59,
0xdb, 0xb9, 0xbd, 0x5d, 0x71, 0xf0, 0x6a, 0x2b, 0x46, 0xf1, 0x8a, 0x0b, 0x35, 0x21, 0xc3, 0xdc,
0xa9, 0xed, 0x2b, 0x32, 0xdf, 0x41, 0xf5, 0x4e, 0x7b, 0x3f, 0xa4, 0xb0, 0x80, 0x2b, 0x7b, 0x50,
0x48, 0xc2, 0xa1, 0x32, 0xa4, 0x2f, 0xc9, 0x82, 0x0f, 0x52, 0x01, 0x87, 0xaf, 0xe8, 0x7f, 0xc8,
0x04, 0xfa, 0x74, 0x4e, 0xf8, 0x80, 0x14, 0xb0, 0x58, 0x54, 0x3e, 0xa7, 0x20, 0xc3, 0xa3, 0xa0,
0x17, 0x90, 0x75, 0x75, 0x8f, 0x38, 0x7e, 0x34, 0x7d, 0xca, 0xad, 0x09, 0xe2, 0xa9, 0xbb, 0x47,
0x38, 0xe2, 0x50, 0x13, 0xf2, 0xae, 0x47, 0x02, 0x9b, 0xce, 0x59, 0x34, 0x75, 0x77, 0x7b, 0x12,
0x12, 0x75, 0xa0, 0x2c, 0xfc, 0x43, 0x66, 0x4f, 0x1c, 0xdd, 0x9f, 0x7b, 0x84, 0x4f, 0x9e, 0xfc,
0xdb, 0xa9, 0x26, 0x9d, 0x8e, 0x19, 0xbc, 0x29, 0x5c, 0x89, 0x80, 0x0e, 0xa0, 0x14, 0x05, 0xb2,
0x78, 0x37, 0xa2, 0xf9, 0x54, 0xee, 0xea, 0x16, 0x2e, 0x0a, 0x3c, 0xba, 0x73, 0x4d, 0xc8, 0x1b,
0x96, 0x3d, 0x35, 0x3d, 0xe2, 0x28, 0x19, 0x7e, 0x4c, 0xf7, 0xec, 0x3e, 0x26, 0x77, 0xbe, 0x4a,
0x90, 0x15, 0x32, 0x7a, 0x09, 0x85, 0x68, 0x32, 0x93, 0x1b, 0x7b, 0x4f, 0x04, 0x81, 0x76, 0x4d,
0xf4, 0x0a, 0x0a, 0xcb, 0xc2, 0x53, 0xff, 0x50, 0xf8, 0x12, 0x0f, 0xcf, 0x28, 0xaa, 0x35, 0xfd,
0x97, 0x5a, 0x23, 0x0e, 0x29, 0x90, 0x8b, 0x6e, 0x13, 0x6f, 0x4f, 0x11, 0xc7, 0xcb, 0xe7, 0xfb,
0x00, 0xcb, 0x3b, 0x83, 0x64, 0xc8, 0xe1, 0x76, 0xe7, 0xfc, 0xa4, 0x85, 0xcb, 0x6b, 0xa8, 0x04,
0x85, 0x41, 0xef, 0xdd, 0x61, 0x7f, 0xd0, 0x3b, 0x6d, 0x97, 0x25, 0xf4, 0x1f, 0x94, 0xfa, 0x83,
0x1e, 0x6e, 0x75, 0xda, 0xc3, 0x0e, 0xee, 0x9d, 0x9f, 0x95, 0x53, 0x87, 0x17, 0xdf, 0xae, 0xab,
0xd2, 0xf7, 0xeb, 0xaa, 0xf4, 0xe3, 0xba, 0x2a, 0x7d, 0xfc, 0x59, 0x5d, 0xbb, 0xd0, 0x26, 0xb6,
0x6f, 0xcd, 0x47, 0xaa, 0x41, 0x67, 0x0d, 0x87, 0xb9, 0x86, 0xb1, 0x6b, 0x92, 0xa0, 0xe1, 0x10,
0x3a, 0x66, 0xbb, 0xba, 0x6b, 0xef, 0x4e, 0x68, 0x23, 0xf9, 0xbb, 0xee, 0x8b, 0xc7, 0xa7, 0xd4,
0xd6, 0x29, 0xa1, 0x6f, 0xfb, 0x6a, 0xeb, 0xac, 0x1b, 0x56, 0x20, 0xb6, 0x33, 0xca, 0xf2, 0xdf,
0xe3, 0xde, 0xaf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xd6, 0x66, 0x06, 0xbc, 0x8e, 0x05, 0x00, 0x00,
var fileDescriptor_545319325da7b9b1 = []byte{
// 726 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x94, 0xdd, 0x6e, 0xda, 0x48,
0x14, 0xc7, 0x63, 0x08, 0x5f, 0xc7, 0x90, 0xb0, 0xb3, 0x2b, 0xad, 0xc5, 0x46, 0x2c, 0x1b, 0x69,
0x25, 0x5a, 0x29, 0xa6, 0x22, 0x54, 0x95, 0x1a, 0xa5, 0x12, 0x69, 0x28, 0x41, 0x4a, 0x43, 0x34,
0x90, 0x5e, 0xf4, 0xc6, 0x32, 0xf6, 0x80, 0xdd, 0x80, 0xc7, 0xf2, 0x18, 0x47, 0xbc, 0x49, 0x9f,
0xa1, 0x52, 0x6f, 0xfa, 0x12, 0xed, 0x65, 0x1f, 0xa1, 0x4a, 0x5f, 0xa4, 0xf2, 0xcc, 0x18, 0x48,
0xd2, 0xa4, 0xbd, 0xf2, 0xcc, 0x99, 0xdf, 0xff, 0xcc, 0xf9, 0x1a, 0x43, 0x25, 0x6a, 0x36, 0xe8,
0xe8, 0x1d, 0xb1, 0xc2, 0xc6, 0x24, 0xf0, 0xad, 0x46, 0xb8, 0xf0, 0x09, 0xd3, 0xfd, 0x80, 0x86,
0x14, 0x95, 0x3d, 0x42, 0xf5, 0x31, 0xd3, 0xa3, 0xa6, 0x2e, 0x90, 0x8a, 0x16, 0x35, 0x1b, 0x01,
0x19, 0xb3, 0x3b, 0x6c, 0x25, 0xf6, 0xc3, 0x48, 0x10, 0xb9, 0x16, 0x11, 0x87, 0x33, 0x12, 0x9a,
0xf2, 0x6c, 0xe7, 0xf6, 0x59, 0x44, 0x02, 0x77, 0xbc, 0x10, 0xa7, 0xbb, 0x9f, 0x72, 0x90, 0x3d,
0x21, 0xa6, 0x4d, 0x02, 0xf4, 0x02, 0x8a, 0x16, 0xf5, 0x42, 0xd3, 0xf5, 0x48, 0x60, 0xb8, 0xb6,
0xa6, 0xd4, 0x94, 0xba, 0xda, 0xfc, 0x47, 0x5f, 0xc5, 0x11, 0x5f, 0xae, 0xbf, 0x4c, 0x98, 0xde,
0x31, 0x56, 0x97, 0x82, 0x9e, 0x8d, 0x9a, 0x90, 0xa7, 0x57, 0x52, 0x9b, 0xe2, 0xda, 0xbf, 0x6f,
0x6b, 0xfb, 0x57, 0x42, 0x97, 0xe3, 0x60, 0xcf, 0x46, 0xff, 0xc3, 0x96, 0x15, 0x10, 0x33, 0x74,
0xa9, 0x67, 0x10, 0x9f, 0x5a, 0x8e, 0x96, 0xae, 0x29, 0xf5, 0x4d, 0x5c, 0x4a, 0xac, 0x9d, 0xd8,
0x88, 0x5a, 0x90, 0x8b, 0x48, 0xc0, 0x5c, 0xea, 0x69, 0x9b, 0xdc, 0x73, 0x65, 0xcd, 0xb3, 0x4c,
0x4e, 0x7f, 0x23, 0x08, 0x9c, 0xa0, 0xb1, 0x73, 0xdf, 0x5c, 0x4c, 0xa9, 0x69, 0x1b, 0x53, 0xe2,
0x4d, 0x42, 0x47, 0xcb, 0x08, 0xe7, 0xd2, 0x7a, 0xca, 0x8d, 0xe8, 0x3f, 0x28, 0x26, 0x98, 0x63,
0x32, 0x47, 0xcb, 0xd6, 0x94, 0x7a, 0x11, 0xab, 0xd2, 0x76, 0x62, 0x32, 0x07, 0x1d, 0x82, 0x2a,
0x7a, 0x60, 0xc4, 0x55, 0xd7, 0x72, 0x35, 0xa5, 0xbe, 0xd5, 0xdc, 0xd1, 0x6f, 0x77, 0x48, 0xef,
0xf3, 0xcf, 0x70, 0xe1, 0x13, 0x0c, 0x74, 0xb9, 0x46, 0x8f, 0xa0, 0xec, 0xd0, 0x19, 0x9d, 0xd1,
0xc0, 0x77, 0x5c, 0x4b, 0xdc, 0x92, 0xe7, 0xb7, 0x6c, 0xaf, 0xd9, 0xf9, 0x4d, 0xc7, 0x50, 0x62,
0x84, 0xc5, 0xe1, 0x1b, 0x21, 0xbd, 0x24, 0x9e, 0x56, 0xe0, 0xf9, 0xfe, 0xfb, 0x93, 0x7c, 0x07,
0x82, 0x1b, 0xc6, 0x18, 0x2e, 0xb2, 0xb5, 0x1d, 0x3a, 0x02, 0x30, 0xc3, 0x30, 0x70, 0x47, 0xf3,
0x90, 0x30, 0x0d, 0x6a, 0xe9, 0xba, 0xda, 0xdc, 0xbd, 0x1b, 0xae, 0x68, 0xbc, 0xde, 0x4e, 0x50,
0xbc, 0xa6, 0x42, 0x2d, 0xc8, 0x30, 0x7f, 0xea, 0x86, 0x9a, 0xca, 0x23, 0xa8, 0xde, 0x2b, 0x1f,
0xc4, 0x14, 0x16, 0x70, 0x65, 0x1f, 0x0a, 0x4b, 0x77, 0xa8, 0x0c, 0xe9, 0x4b, 0xb2, 0xe0, 0x83,
0x54, 0xc0, 0xf1, 0x12, 0xfd, 0x05, 0x99, 0xc8, 0x9c, 0xce, 0x09, 0x1f, 0x90, 0x02, 0x16, 0x9b,
0xca, 0xc7, 0x14, 0x64, 0xb8, 0x17, 0xf4, 0x04, 0xb2, 0xbe, 0x19, 0x10, 0x2f, 0x94, 0xd3, 0xa7,
0xdd, 0x99, 0x20, 0x7e, 0x75, 0xef, 0x18, 0x4b, 0x0e, 0xb5, 0x20, 0xef, 0x07, 0x24, 0x72, 0xe9,
0x9c, 0xc9, 0xa9, 0xbb, 0x5f, 0xb3, 0x24, 0x51, 0x17, 0xca, 0x42, 0x6f, 0x30, 0x77, 0xe2, 0x99,
0xe1, 0x3c, 0x20, 0x7c, 0xf2, 0xd4, 0x1b, 0x5d, 0x5d, 0x56, 0x3a, 0x61, 0xf0, 0xb6, 0x50, 0x2d,
0x0d, 0xe8, 0x10, 0x4a, 0xd2, 0x91, 0xc3, 0xab, 0x21, 0xe7, 0x53, 0xbb, 0xaf, 0x5a, 0xb8, 0x28,
0x70, 0xf9, 0xe6, 0x5a, 0x90, 0xb7, 0x1c, 0x77, 0x6a, 0x07, 0xc4, 0xd3, 0x32, 0xbc, 0x4d, 0x0f,
0x44, 0x9f, 0x90, 0xbb, 0x9f, 0x15, 0xc8, 0x0a, 0x33, 0x7a, 0x0a, 0x05, 0x39, 0x99, 0xcb, 0x17,
0xfb, 0x80, 0x07, 0x81, 0xf6, 0x6c, 0xf4, 0x1c, 0x0a, 0xab, 0xc4, 0x53, 0xbf, 0x91, 0xf8, 0x0a,
0x8f, 0x7b, 0x24, 0x73, 0x4d, 0xff, 0x22, 0x57, 0xc9, 0x21, 0x0d, 0x72, 0xf2, 0x35, 0xf1, 0xf2,
0x14, 0x71, 0xb2, 0x7d, 0x7c, 0x00, 0xb0, 0x7a, 0x33, 0x48, 0x85, 0x1c, 0xee, 0x74, 0x2f, 0x4e,
0xdb, 0xb8, 0xbc, 0x81, 0x4a, 0x50, 0x18, 0xf6, 0x5f, 0x1f, 0x0d, 0x86, 0xfd, 0xb3, 0x4e, 0x59,
0x41, 0x7f, 0x40, 0x69, 0x30, 0xec, 0xe3, 0x76, 0xb7, 0x63, 0x74, 0x71, 0xff, 0xe2, 0xbc, 0x9c,
0x3a, 0x32, 0xbe, 0x5c, 0x57, 0x95, 0xaf, 0xd7, 0x55, 0xe5, 0xdb, 0x75, 0x55, 0x79, 0xff, 0xbd,
0xba, 0xf1, 0xf6, 0xd9, 0xc4, 0x0d, 0x9d, 0xf9, 0x48, 0xb7, 0xe8, 0xac, 0xe1, 0x31, 0xdf, 0xb2,
0xf6, 0x6c, 0x12, 0x35, 0x3c, 0x42, 0xc7, 0x6c, 0xcf, 0xf4, 0xdd, 0xbd, 0x09, 0x6d, 0xdc, 0xfc,
0xe3, 0x1e, 0x88, 0xf5, 0x87, 0xd4, 0x9f, 0x67, 0x84, 0xbe, 0x1a, 0xe8, 0xed, 0xf3, 0x5e, 0x9c,
0x86, 0x88, 0x69, 0x94, 0xe5, 0xff, 0xc8, 0xfd, 0x1f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x65, 0x74,
0xce, 0xc4, 0xa7, 0x05, 0x00, 0x00,
}
func (m *Header) Marshal() (dAtA []byte, err error) {
@ -1024,7 +1025,7 @@ func (m *Header) Unmarshal(dAtA []byte) error {
return io.ErrUnexpectedEOF
}
if m.ContainerId == nil {
m.ContainerId = &refs.ContainerID{}
m.ContainerId = &grpc.ContainerID{}
}
if err := m.ContainerId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
@ -1060,7 +1061,7 @@ func (m *Header) Unmarshal(dAtA []byte) error {
return io.ErrUnexpectedEOF
}
if m.OwnerId == nil {
m.OwnerId = &refs.OwnerID{}
m.OwnerId = &grpc.OwnerID{}
}
if err := m.OwnerId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
@ -1115,7 +1116,7 @@ func (m *Header) Unmarshal(dAtA []byte) error {
return io.ErrUnexpectedEOF
}
if m.Version == nil {
m.Version = &service.Version{}
m.Version = &grpc1.Version{}
}
if err := m.Version.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
@ -1257,7 +1258,7 @@ func (m *Header) Unmarshal(dAtA []byte) error {
return io.ErrUnexpectedEOF
}
if m.SessionToken == nil {
m.SessionToken = &service.SessionToken{}
m.SessionToken = &grpc1.SessionToken{}
}
if err := m.SessionToken.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
@ -1535,7 +1536,7 @@ func (m *Header_Split) Unmarshal(dAtA []byte) error {
return io.ErrUnexpectedEOF
}
if m.Parent == nil {
m.Parent = &refs.ObjectID{}
m.Parent = &grpc.ObjectID{}
}
if err := m.Parent.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
@ -1571,7 +1572,7 @@ func (m *Header_Split) Unmarshal(dAtA []byte) error {
return io.ErrUnexpectedEOF
}
if m.Previous == nil {
m.Previous = &refs.ObjectID{}
m.Previous = &grpc.ObjectID{}
}
if err := m.Previous.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
@ -1607,7 +1608,7 @@ func (m *Header_Split) Unmarshal(dAtA []byte) error {
return io.ErrUnexpectedEOF
}
if m.ParentSignature == nil {
m.ParentSignature = &service.Signature{}
m.ParentSignature = &grpc1.Signature{}
}
if err := m.ParentSignature.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
@ -1678,7 +1679,7 @@ func (m *Header_Split) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Children = append(m.Children, &refs.ObjectID{})
m.Children = append(m.Children, &grpc.ObjectID{})
if err := m.Children[len(m.Children)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
@ -1767,7 +1768,7 @@ func (m *Object) Unmarshal(dAtA []byte) error {
return io.ErrUnexpectedEOF
}
if m.ObjectId == nil {
m.ObjectId = &refs.ObjectID{}
m.ObjectId = &grpc.ObjectID{}
}
if err := m.ObjectId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
@ -1803,7 +1804,7 @@ func (m *Object) Unmarshal(dAtA []byte) error {
return io.ErrUnexpectedEOF
}
if m.Signature == nil {
m.Signature = &service.Signature{}
m.Signature = &grpc1.Signature{}
}
if err := m.Signature.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err

29
v2/refs/convert.go Normal file
View file

@ -0,0 +1,29 @@
package refs
import (
refs "github.com/nspcc-dev/neofs-api-go/v2/refs/grpc"
)
func OwnerIDToGRPCMessage(o *OwnerID) *refs.OwnerID {
if o == nil {
return nil
}
m := new(refs.OwnerID)
m.SetValue(o.GetValue())
return m
}
func OwnerIDFromGRPCMessage(m *refs.OwnerID) *OwnerID {
if m == nil {
return nil
}
o := new(OwnerID)
o.SetValue(m.GetValue())
return o
}

0
v2/refs/marshal.go → v2/refs/grpc/marshal.go
View file

0
v2/refs/marshal_test.go → v2/refs/grpc/marshal_test.go
View file

0
v2/refs/types.go → v2/refs/grpc/types.go
View file

50
v2/refs/types.pb.go → v2/refs/grpc/types.pb.go
View file

@ -1,5 +1,5 @@
// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: v2/refs/types.proto
// source: v2/refs/grpc/types.proto
package refs
@ -37,7 +37,7 @@ func (m *Address) Reset() { *m = Address{} }
func (m *Address) String() string { return proto.CompactTextString(m) }
func (*Address) ProtoMessage() {}
func (*Address) Descriptor() ([]byte, []int) {
return fileDescriptor_8ea16029b13f1cfa, []int{0}
return fileDescriptor_08f084e5f91ec87c, []int{0}
}
func (m *Address) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -93,7 +93,7 @@ func (m *ObjectID) Reset() { *m = ObjectID{} }
func (m *ObjectID) String() string { return proto.CompactTextString(m) }
func (*ObjectID) ProtoMessage() {}
func (*ObjectID) Descriptor() ([]byte, []int) {
return fileDescriptor_8ea16029b13f1cfa, []int{1}
return fileDescriptor_08f084e5f91ec87c, []int{1}
}
func (m *ObjectID) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -142,7 +142,7 @@ func (m *ContainerID) Reset() { *m = ContainerID{} }
func (m *ContainerID) String() string { return proto.CompactTextString(m) }
func (*ContainerID) ProtoMessage() {}
func (*ContainerID) Descriptor() ([]byte, []int) {
return fileDescriptor_8ea16029b13f1cfa, []int{2}
return fileDescriptor_08f084e5f91ec87c, []int{2}
}
func (m *ContainerID) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -191,7 +191,7 @@ func (m *OwnerID) Reset() { *m = OwnerID{} }
func (m *OwnerID) String() string { return proto.CompactTextString(m) }
func (*OwnerID) ProtoMessage() {}
func (*OwnerID) Descriptor() ([]byte, []int) {
return fileDescriptor_8ea16029b13f1cfa, []int{3}
return fileDescriptor_08f084e5f91ec87c, []int{3}
}
func (m *OwnerID) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -234,27 +234,27 @@ func init() {
proto.RegisterType((*OwnerID)(nil), "neo.fs.v2.refs.OwnerID")
}
func init() { proto.RegisterFile("v2/refs/types.proto", fileDescriptor_8ea16029b13f1cfa) }
func init() { proto.RegisterFile("v2/refs/grpc/types.proto", fileDescriptor_08f084e5f91ec87c) }
var fileDescriptor_8ea16029b13f1cfa = []byte{
// 259 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x12, 0x2e, 0x33, 0xd2, 0x2f,
0x4a, 0x4d, 0x2b, 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, 0xc9, 0x29, 0x35, 0x30,
0x72, 0xb1, 0x3b, 0xa6, 0xa4, 0x14, 0xa5, 0x16, 0x17, 0x0b, 0xd9, 0x71, 0xf1, 0x24, 0xe7, 0xe7,
0x95, 0x24, 0x66, 0xe6, 0xa5, 0x16, 0xc5, 0x67, 0xa6, 0x48, 0x30, 0x2a, 0x30, 0x6a, 0x70, 0x1b,
0x49, 0xeb, 0xa1, 0x6a, 0xd1, 0x73, 0x86, 0xa9, 0xf1, 0x74, 0x09, 0xe2, 0x86, 0x6b, 0xf0, 0x4c,
0x11, 0x32, 0xe5, 0xe2, 0xcc, 0x4f, 0xca, 0x4a, 0x4d, 0x2e, 0x01, 0x69, 0x66, 0x02, 0x6b, 0x96,
0x40, 0xd7, 0xec, 0x0f, 0x56, 0xe0, 0xe9, 0x12, 0xc4, 0x01, 0x51, 0xea, 0x99, 0xa2, 0xa4, 0xc0,
0xc5, 0x01, 0x13, 0x15, 0x12, 0xe1, 0x62, 0x2d, 0x4b, 0xcc, 0x29, 0x4d, 0x05, 0xdb, 0xcd, 0x13,
0x04, 0xe1, 0x28, 0x29, 0x73, 0x71, 0x23, 0x59, 0x8a, 0x43, 0x91, 0x3c, 0x17, 0xbb, 0x7f, 0x39,
0x1e, 0x05, 0x4e, 0x21, 0x27, 0x1e, 0xc9, 0x31, 0x5e, 0x78, 0x24, 0xc7, 0xf8, 0xe0, 0x91, 0x1c,
0xe3, 0x8c, 0xc7, 0x72, 0x0c, 0x51, 0x7a, 0xe9, 0x99, 0x25, 0x19, 0xa5, 0x49, 0x7a, 0xc9, 0xf9,
0xb9, 0xfa, 0x79, 0xc5, 0x05, 0xc9, 0xc9, 0xba, 0x29, 0xa9, 0x65, 0xfa, 0x79, 0xa9, 0xf9, 0x69,
0xc5, 0xba, 0x89, 0x05, 0x99, 0xba, 0xe9, 0xf9, 0xfa, 0xd0, 0x30, 0xb4, 0x06, 0x11, 0xab, 0x98,
0x04, 0xfd, 0x52, 0xf3, 0xdd, 0x82, 0xf5, 0x1c, 0x03, 0x3c, 0x41, 0x1e, 0x0a, 0x4a, 0x4d, 0x2b,
0x4e, 0x62, 0x03, 0x87, 0xab, 0x31, 0x20, 0x00, 0x00, 0xff, 0xff, 0xd0, 0xa5, 0x8b, 0x04, 0x6e,
0x01, 0x00, 0x00,
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,
}
func (m *Address) Marshal() (dAtA []byte, err error) {

19
v2/refs/owner.go Normal file
View file

@ -0,0 +1,19 @@
package refs
type OwnerID struct {
val []byte
}
func (o *OwnerID) GetValue() []byte {
if o != nil {
return o.val
}
return nil
}
func (o *OwnerID) SetValue(v []byte) {
if o != nil {
o.val = v
}
}

201
v2/service/convert.go Normal file
View file

@ -0,0 +1,201 @@
package service
import (
service "github.com/nspcc-dev/neofs-api-go/v2/service/grpc"
)
func VersionToGRPCMessage(v *Version) *service.Version {
if v == nil {
return nil
}
msg := new(service.Version)
msg.SetMajor(v.GetMajor())
msg.SetMinor(v.GetMinor())
return msg
}
func VersionFromGRPCMessage(m *service.Version) *Version {
if m == nil {
return nil
}
v := new(Version)
v.SetMajor(m.GetMajor())
v.SetMinor(m.GetMinor())
return v
}
func XHeaderToGRPCMessage(x *XHeader) *service.XHeader {
if x == nil {
return nil
}
m := new(service.XHeader)
m.SetKey(x.GetKey())
m.SetValue(x.GetValue())
return m
}
func XHeaderFromGRPCMessage(m *service.XHeader) *XHeader {
if m == nil {
return nil
}
x := new(XHeader)
x.SetKey(m.GetKey())
x.SetValue(m.GetValue())
return x
}
func SessionTokenToGRPCMessage(t *SessionToken) *service.SessionToken {
// TODO: fill me
return nil
}
func SessionTokenFromGRPCMessage(m *service.SessionToken) *SessionToken {
// TODO: fill me
return nil
}
func BearerTokenToGRPCMessage(t *BearerToken) *service.BearerToken {
// TODO: fill me
return nil
}
func BearerTokenFromGRPCMessage(m *service.BearerToken) *BearerToken {
// TODO: fill me
return nil
}
func RequestVerificationHeaderToGRPCMessage(r *RequestVerificationHeader) *service.RequestVerificationHeader {
if r == nil {
return nil
}
m := new(service.RequestVerificationHeader)
m.SetBodySignature(
SignatureToGRPCMessage(r.GetBodySignature()),
)
m.SetMetaSignature(
SignatureToGRPCMessage(r.GetMetaSignature()),
)
m.SetOriginSignature(
SignatureToGRPCMessage(r.GetOriginSignature()),
)
m.SetOrigin(
RequestVerificationHeaderToGRPCMessage(r.GetOrigin()),
)
return m
}
func RequestVerificationHeaderFromGRPCMessage(m *service.RequestVerificationHeader) *RequestVerificationHeader {
if m == nil {
return nil
}
r := new(RequestVerificationHeader)
r.SetBodySignature(
SignatureFromGRPCMessage(m.GetBodySignature()),
)
r.SetMetaSignature(
SignatureFromGRPCMessage(m.GetMetaSignature()),
)
r.SetOriginSignature(
SignatureFromGRPCMessage(m.GetOriginSignature()),
)
r.SetOrigin(
RequestVerificationHeaderFromGRPCMessage(m.GetOrigin()),
)
return r
}
func RequestMetaHeaderToGRPCMessage(r *RequestMetaHeader) *service.RequestMetaHeader {
if r == nil {
return nil
}
m := new(service.RequestMetaHeader)
m.SetTtl(r.GetTTL())
m.SetEpoch(r.GetEpoch())
m.SetVersion(
VersionToGRPCMessage(r.GetVersion()),
)
m.SetSessionToken(
SessionTokenToGRPCMessage(r.GetSessionToken()),
)
m.SetBearerToken(
BearerTokenToGRPCMessage(r.GetBearerToken()),
)
m.SetOrigin(
RequestMetaHeaderToGRPCMessage(r.GetOrigin()),
)
xHeaders := r.GetXHeaders()
xHdrMsg := make([]*service.XHeader, 0, len(xHeaders))
for i := range xHeaders {
xHdrMsg = append(xHdrMsg, XHeaderToGRPCMessage(xHeaders[i]))
}
return m
}
func RequestMetaHeaderFromGRPCMessage(m *service.RequestMetaHeader) *RequestMetaHeader {
if m == nil {
return nil
}
r := new(RequestMetaHeader)
r.SetTTL(m.GetTtl())
r.SetEpoch(m.GetEpoch())
r.SetVersion(
VersionFromGRPCMessage(m.GetVersion()),
)
r.SetSessionToken(
SessionTokenFromGRPCMessage(m.GetSessionToken()),
)
r.SetBearerToken(
BearerTokenFromGRPCMessage(m.GetBearerToken()),
)
r.SetOrigin(
RequestMetaHeaderFromGRPCMessage(m.GetOrigin()),
)
xHdrMsg := m.GetXHeaders()
xHeaders := make([]*XHeader, 0, len(xHdrMsg))
for i := range xHdrMsg {
xHeaders = append(xHeaders, XHeaderFromGRPCMessage(xHdrMsg[i]))
}
return r
}

4
v2/service/meta.go → v2/service/grpc/meta.go
View file

@ -1,8 +1,8 @@
package service
import (
"github.com/nspcc-dev/neofs-api-go/v2/acl"
"github.com/nspcc-dev/neofs-api-go/v2/refs"
acl "github.com/nspcc-dev/neofs-api-go/v2/acl/grpc"
refs "github.com/nspcc-dev/neofs-api-go/v2/refs/grpc"
)
// SetKey sets key to the X-Header.

158
v2/service/meta.pb.go → v2/service/grpc/meta.pb.go
View file

@ -1,13 +1,13 @@
// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: v2/service/meta.proto
// source: v2/service/grpc/meta.proto
package service
import (
fmt "fmt"
proto "github.com/golang/protobuf/proto"
acl "github.com/nspcc-dev/neofs-api-go/v2/acl"
refs "github.com/nspcc-dev/neofs-api-go/v2/refs"
grpc1 "github.com/nspcc-dev/neofs-api-go/v2/acl/grpc"
grpc "github.com/nspcc-dev/neofs-api-go/v2/refs/grpc"
io "io"
math "math"
math_bits "math/bits"
@ -73,7 +73,7 @@ func (x SessionToken_Body_Verb) String() string {
}
func (SessionToken_Body_Verb) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_932e020d69aee3f0, []int{3, 0, 0}
return fileDescriptor_174eb6ef9ee2b356, []int{3, 0, 0}
}
// Extended headers for Request/Response
@ -91,7 +91,7 @@ func (m *XHeader) Reset() { *m = XHeader{} }
func (m *XHeader) String() string { return proto.CompactTextString(m) }
func (*XHeader) ProtoMessage() {}
func (*XHeader) Descriptor() ([]byte, []int) {
return fileDescriptor_932e020d69aee3f0, []int{0}
return fileDescriptor_174eb6ef9ee2b356, []int{0}
}
func (m *XHeader) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -149,7 +149,7 @@ 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_932e020d69aee3f0, []int{1}
return fileDescriptor_174eb6ef9ee2b356, []int{1}
}
func (m *Version) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -209,7 +209,7 @@ func (m *TokenLifetime) Reset() { *m = TokenLifetime{} }
func (m *TokenLifetime) String() string { return proto.CompactTextString(m) }
func (*TokenLifetime) ProtoMessage() {}
func (*TokenLifetime) Descriptor() ([]byte, []int) {
return fileDescriptor_932e020d69aee3f0, []int{2}
return fileDescriptor_174eb6ef9ee2b356, []int{2}
}
func (m *TokenLifetime) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -274,7 +274,7 @@ func (m *SessionToken) Reset() { *m = SessionToken{} }
func (m *SessionToken) String() string { return proto.CompactTextString(m) }
func (*SessionToken) ProtoMessage() {}
func (*SessionToken) Descriptor() ([]byte, []int) {
return fileDescriptor_932e020d69aee3f0, []int{3}
return fileDescriptor_174eb6ef9ee2b356, []int{3}
}
func (m *SessionToken) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -322,7 +322,7 @@ type SessionToken_Body struct {
// ID is a token identifier. valid UUIDv4 represented in bytes
Id []byte `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
// OwnerID carries identifier of the session initiator.
OwnerId *refs.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"`
// Verb is a type of request for which the token is issued
Verb SessionToken_Body_Verb `protobuf:"varint,3,opt,name=verb,proto3,enum=neo.fs.v2.service.SessionToken_Body_Verb" json:"verb,omitempty"`
// Lifetime is a lifetime of the session
@ -343,7 +343,7 @@ func (m *SessionToken_Body) Reset() { *m = SessionToken_Body{} }
func (m *SessionToken_Body) String() string { return proto.CompactTextString(m) }
func (*SessionToken_Body) ProtoMessage() {}
func (*SessionToken_Body) Descriptor() ([]byte, []int) {
return fileDescriptor_932e020d69aee3f0, []int{3, 0}
return fileDescriptor_174eb6ef9ee2b356, []int{3, 0}
}
func (m *SessionToken_Body) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -379,7 +379,7 @@ type isSessionToken_Body_Context interface {
}
type SessionToken_Body_ObjectAddress struct {
ObjectAddress *refs.Address `protobuf:"bytes,6,opt,name=object_address,json=objectAddress,proto3,oneof" json:"object_address,omitempty"`
ObjectAddress *grpc.Address `protobuf:"bytes,6,opt,name=object_address,json=objectAddress,proto3,oneof" json:"object_address,omitempty"`
}
func (*SessionToken_Body_ObjectAddress) isSessionToken_Body_Context() {}
@ -398,7 +398,7 @@ func (m *SessionToken_Body) GetId() []byte {
return nil
}
func (m *SessionToken_Body) GetOwnerId() *refs.OwnerID {
func (m *SessionToken_Body) GetOwnerId() *grpc.OwnerID {
if m != nil {
return m.OwnerId
}
@ -426,7 +426,7 @@ func (m *SessionToken_Body) GetSessionKey() []byte {
return nil
}
func (m *SessionToken_Body) GetObjectAddress() *refs.Address {
func (m *SessionToken_Body) GetObjectAddress() *grpc.Address {
if x, ok := m.GetContext().(*SessionToken_Body_ObjectAddress); ok {
return x.ObjectAddress
}
@ -455,7 +455,7 @@ 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_932e020d69aee3f0, []int{4}
return fileDescriptor_174eb6ef9ee2b356, []int{4}
}
func (m *BearerToken) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -501,9 +501,9 @@ func (m *BearerToken) GetSignature() *Signature {
// Bearer Token body
type BearerToken_Body struct {
// EACLTable carries table of extended ACL rules
EaclTable *acl.EACLTable `protobuf:"bytes,1,opt,name=eacl_table,json=eaclTable,proto3" json:"eacl_table,omitempty"`
EaclTable *grpc1.EACLTable `protobuf:"bytes,1,opt,name=eacl_table,json=eaclTable,proto3" json:"eacl_table,omitempty"`
// OwnerID carries identifier of the token owner
OwnerId *refs.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"`
// Token expiration and valid time period parameters
Lifetime *TokenLifetime `protobuf:"bytes,3,opt,name=lifetime,proto3" json:"lifetime,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
@ -515,7 +515,7 @@ 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_932e020d69aee3f0, []int{4, 0}
return fileDescriptor_174eb6ef9ee2b356, []int{4, 0}
}
func (m *BearerToken_Body) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -544,14 +544,14 @@ func (m *BearerToken_Body) XXX_DiscardUnknown() {
var xxx_messageInfo_BearerToken_Body proto.InternalMessageInfo
func (m *BearerToken_Body) GetEaclTable() *acl.EACLTable {
func (m *BearerToken_Body) GetEaclTable() *grpc1.EACLTable {
if m != nil {
return m.EaclTable
}
return nil
}
func (m *BearerToken_Body) GetOwnerId() *refs.OwnerID {
func (m *BearerToken_Body) GetOwnerId() *grpc.OwnerID {
if m != nil {
return m.OwnerId
}
@ -590,7 +590,7 @@ func (m *RequestMetaHeader) Reset() { *m = RequestMetaHeader{} }
func (m *RequestMetaHeader) String() string { return proto.CompactTextString(m) }
func (*RequestMetaHeader) ProtoMessage() {}
func (*RequestMetaHeader) Descriptor() ([]byte, []int) {
return fileDescriptor_932e020d69aee3f0, []int{5}
return fileDescriptor_174eb6ef9ee2b356, []int{5}
}
func (m *RequestMetaHeader) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -689,7 +689,7 @@ func (m *ResponseMetaHeader) Reset() { *m = ResponseMetaHeader{} }
func (m *ResponseMetaHeader) String() string { return proto.CompactTextString(m) }
func (*ResponseMetaHeader) ProtoMessage() {}
func (*ResponseMetaHeader) Descriptor() ([]byte, []int) {
return fileDescriptor_932e020d69aee3f0, []int{6}
return fileDescriptor_174eb6ef9ee2b356, []int{6}
}
func (m *ResponseMetaHeader) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -766,63 +766,63 @@ func init() {
proto.RegisterType((*ResponseMetaHeader)(nil), "neo.fs.v2.service.ResponseMetaHeader")
}
func init() { proto.RegisterFile("v2/service/meta.proto", fileDescriptor_932e020d69aee3f0) }
func init() { proto.RegisterFile("v2/service/grpc/meta.proto", fileDescriptor_174eb6ef9ee2b356) }
var fileDescriptor_932e020d69aee3f0 = []byte{
// 834 bytes of a gzipped FileDescriptorProto
var fileDescriptor_174eb6ef9ee2b356 = []byte{
// 838 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x55, 0xcd, 0x6e, 0x23, 0x45,
0x10, 0xce, 0xd8, 0x93, 0x38, 0x2e, 0xdb, 0x61, 0xd2, 0x04, 0xad, 0x15, 0x21, 0x6f, 0x64, 0x40,
0x82, 0x43, 0xc6, 0x62, 0x58, 0x14, 0x04, 0xbb, 0x12, 0x76, 0x3c, 0xbb, 0x36, 0x84, 0x6c, 0xd4,
0xf6, 0x46, 0x08, 0x09, 0x59, 0xf3, 0x53, 0x4e, 0x66, 0xd7, 0x99, 0x36, 0xd3, 0x9d, 0x21, 0x7e,
0x10, 0xce, 0xd8, 0x93, 0x38, 0x2e, 0xdb, 0x61, 0xd2, 0x8a, 0xb4, 0x23, 0x6b, 0xe5, 0x8d, 0x0c,
0x48, 0x70, 0xc8, 0x58, 0x0c, 0xa0, 0xf0, 0xb3, 0x2b, 0x61, 0xc7, 0xb3, 0x6b, 0x43, 0xc8, 0x46,
0x6d, 0x6f, 0x84, 0xb8, 0x58, 0xf3, 0x53, 0x76, 0x66, 0xd7, 0x99, 0x36, 0xd3, 0x93, 0x21, 0x7e,
0x13, 0x24, 0xde, 0x80, 0x1b, 0x17, 0x9e, 0x81, 0x23, 0x12, 0x37, 0x4e, 0x28, 0xdc, 0xb8, 0xf1,
0x06, 0xa8, 0x7f, 0xbc, 0x3b, 0x61, 0xbd, 0xfc, 0x89, 0x03, 0x27, 0x57, 0x7d, 0x5d, 0xf5, 0x55,
0x57, 0xf5, 0xe7, 0x1a, 0x78, 0x25, 0xf7, 0x3a, 0x1c, 0xb3, 0x3c, 0x89, 0xb0, 0x73, 0x81, 0x22,
0x70, 0xe7, 0x19, 0x13, 0x8c, 0x6c, 0xa7, 0xc8, 0xdc, 0x29, 0x77, 0x73, 0xcf, 0x35, 0xa7, 0xbb,
0x24, 0xf7, 0x3a, 0x41, 0x34, 0xeb, 0x88, 0xc5, 0x1c, 0xb9, 0x0e, 0xdb, 0x7d, 0x39, 0xf7, 0x3a,
0x19, 0x4e, 0xf9, 0x0d, 0xf0, 0x56, 0x81, 0x32, 0xc7, 0x2c, 0x99, 0x2e, 0xf4, 0x41, 0xfb, 0x6d,
0xa8, 0x7c, 0x3a, 0xc0, 0x20, 0xc6, 0x8c, 0x38, 0x50, 0x7e, 0x82, 0x8b, 0xa6, 0xb5, 0x67, 0xbd,
0x59, 0xa5, 0xd2, 0x24, 0x3b, 0xb0, 0x9e, 0x07, 0xb3, 0x4b, 0x6c, 0x96, 0x14, 0xa6, 0x9d, 0xf6,
0xbb, 0x50, 0x39, 0xc5, 0x8c, 0x27, 0x2c, 0x95, 0x01, 0x17, 0xc1, 0x63, 0x96, 0xa9, 0xa4, 0x06,
0xd5, 0x8e, 0x42, 0x93, 0x94, 0x65, 0x2a, 0x4d, 0xa2, 0xd2, 0x69, 0xfb, 0xd0, 0x18, 0xb3, 0x27,
0x98, 0x1e, 0x25, 0x53, 0x14, 0xc9, 0x05, 0xca, 0x7a, 0x78, 0x35, 0x57, 0xa9, 0x36, 0x95, 0xa6,
0x44, 0xd2, 0x70, 0xaa, 0xd2, 0x6c, 0x2a, 0x4d, 0x89, 0x24, 0x81, 0x68, 0x96, 0x35, 0x92, 0x04,
0xa2, 0xfd, 0x93, 0x0d, 0xf5, 0x11, 0x72, 0x59, 0x5e, 0xd1, 0x91, 0xf7, 0xc0, 0x0e, 0x59, 0xac,
0xef, 0x5d, 0xf3, 0x5e, 0x77, 0x9f, 0x9b, 0x92, 0x5b, 0x0c, 0x77, 0x7b, 0x2c, 0x5e, 0x50, 0x95,
0x41, 0xde, 0x87, 0x2a, 0x4f, 0xce, 0xd2, 0x40, 0x5c, 0x66, 0xba, 0xc5, 0x9a, 0xf7, 0xea, 0xaa,
0xf4, 0x65, 0x0c, 0x7d, 0x16, 0xbe, 0xfb, 0x63, 0x19, 0x6c, 0x49, 0x45, 0xb6, 0xa0, 0x94, 0xc4,
0xaa, 0x78, 0x9d, 0x96, 0x92, 0x98, 0x78, 0xb0, 0xc9, 0xbe, 0x4c, 0x31, 0x9b, 0x24, 0xb1, 0xe1,
0xbc, 0x55, 0xe0, 0x94, 0x0f, 0xe3, 0x3e, 0x94, 0xe7, 0xc3, 0x3e, 0xad, 0xa8, 0xc0, 0x61, 0x4c,
0xee, 0x81, 0x9d, 0x63, 0x16, 0xaa, 0x36, 0xb7, 0xbc, 0xb7, 0xfe, 0x4e, 0x0b, 0xee, 0x29, 0x66,
0x21, 0x55, 0x69, 0xe4, 0x2e, 0x6c, 0xce, 0xcc, 0x50, 0x9b, 0xb6, 0x2a, 0xb9, 0xb7, 0x82, 0xe2,
0xc6, 0xf0, 0xe9, 0xd3, 0x0c, 0x72, 0x1b, 0x6a, 0x5c, 0xb3, 0x4f, 0xe4, 0xf3, 0xaf, 0xab, 0x4e,
0xc0, 0x40, 0x1f, 0xe3, 0x82, 0x7c, 0x08, 0x5b, 0x2c, 0x7c, 0x8c, 0x91, 0x98, 0x04, 0x71, 0x9c,
0x21, 0xe7, 0xcd, 0x8d, 0xd5, 0x7d, 0x75, 0xf5, 0xf1, 0x60, 0x8d, 0x36, 0x74, 0x82, 0x01, 0xda,
0x5f, 0x5b, 0x60, 0xcb, 0xfb, 0x92, 0x1d, 0x70, 0x4e, 0x7d, 0xda, 0x9b, 0x3c, 0x3a, 0x1e, 0x9d,
0xf8, 0x87, 0xc3, 0xfb, 0x43, 0xbf, 0xef, 0xac, 0x91, 0x2d, 0x80, 0x87, 0xbd, 0x8f, 0xfc, 0xc3,
0xf1, 0xe4, 0xe4, 0xd1, 0xd8, 0xb1, 0x0a, 0xfe, 0x03, 0x7f, 0xec, 0x94, 0xc8, 0x4b, 0x50, 0x33,
0xfe, 0xc0, 0xef, 0xf6, 0x9d, 0x32, 0xd9, 0x86, 0x86, 0x01, 0x46, 0x7e, 0x97, 0x1e, 0x0e, 0x1c,
0xbb, 0x00, 0xf5, 0xfd, 0x23, 0x7f, 0xec, 0x3b, 0xeb, 0xc4, 0x81, 0xba, 0x81, 0x68, 0xf7, 0xf8,
0x81, 0xef, 0x6c, 0xc8, 0xf2, 0x45, 0x64, 0xd0, 0x1d, 0x0d, 0x9c, 0x4a, 0xaf, 0x0a, 0x95, 0x88,
0xa5, 0x02, 0xaf, 0x44, 0xfb, 0xbb, 0x12, 0xd4, 0x7a, 0x18, 0x64, 0x98, 0x69, 0x6d, 0x1d, 0xdc,
0xd0, 0xd6, 0x6b, 0x2b, 0xa6, 0x5a, 0x88, 0xfe, 0xaf, 0xa4, 0xf5, 0xad, 0x65, 0xa4, 0x75, 0x00,
0x80, 0x41, 0x34, 0x9b, 0x88, 0x20, 0x9c, 0xa1, 0xb9, 0x43, 0xb3, 0xc0, 0x12, 0x44, 0x33, 0xd7,
0xef, 0x1e, 0x1e, 0x8d, 0xe5, 0x39, 0xad, 0xca, 0x58, 0x65, 0xfe, 0x2b, 0x0d, 0x16, 0x45, 0x54,
0xfe, 0xa7, 0x22, 0x6a, 0xff, 0x56, 0x82, 0x6d, 0x8a, 0x5f, 0x5c, 0x22, 0x17, 0x9f, 0xa0, 0x08,
0xcc, 0x46, 0xb9, 0x03, 0x95, 0x5c, 0x6f, 0x0a, 0x73, 0xfb, 0xdd, 0x15, 0x94, 0x66, 0x97, 0xd0,
0x65, 0xa8, 0x5c, 0x1f, 0x38, 0x67, 0xd1, 0xb9, 0xd9, 0x03, 0xda, 0x91, 0x9b, 0x40, 0x88, 0x99,
0xba, 0x5a, 0x83, 0x4a, 0x93, 0x1c, 0x40, 0xf5, 0x6a, 0x72, 0xae, 0x2a, 0xf1, 0xa6, 0xbd, 0x57,
0x7e, 0x01, 0xbf, 0x59, 0x6f, 0x74, 0xf3, 0x4a, 0x1b, 0x9c, 0xf4, 0xa1, 0xb1, 0x54, 0xbc, 0x90,
0xfd, 0x28, 0xcd, 0xd7, 0xbc, 0xdb, 0x7f, 0xf1, 0xbf, 0xa3, 0x75, 0x5e, 0xdc, 0x3b, 0x5d, 0xa8,
0x87, 0xea, 0xf1, 0x0d, 0x89, 0xfe, 0x53, 0xb4, 0xfe, 0x5c, 0x23, 0xb4, 0x16, 0x16, 0xe4, 0x75,
0x17, 0x36, 0x58, 0x96, 0x9c, 0x25, 0x69, 0xb3, 0xf2, 0xc2, 0xe5, 0xf5, 0xdc, 0x54, 0xa9, 0xc9,
0x69, 0xff, 0x6a, 0x01, 0xa1, 0xc8, 0xe7, 0x2c, 0xe5, 0xf8, 0xff, 0x1f, 0xfa, 0xbd, 0xa7, 0xbd,
0xea, 0x69, 0xbf, 0xb1, 0xb2, 0xd7, 0x3f, 0x76, 0xb3, 0x6c, 0xb6, 0xf7, 0xf9, 0xf7, 0xd7, 0x2d,
0xeb, 0x87, 0xeb, 0x96, 0xf5, 0xf3, 0x75, 0xcb, 0xfa, 0xea, 0x97, 0xd6, 0xda, 0x67, 0x77, 0xce,
0x12, 0x71, 0x7e, 0x19, 0xba, 0x11, 0xbb, 0xe8, 0xa4, 0x7c, 0x1e, 0x45, 0xfb, 0x31, 0xe6, 0x9d,
0x14, 0xd9, 0x94, 0xef, 0x07, 0xf3, 0x64, 0xff, 0x8c, 0x75, 0x9e, 0x7d, 0xf4, 0x3e, 0x30, 0xbf,
0xdf, 0x94, 0x76, 0x8e, 0x91, 0xdd, 0x1f, 0xb9, 0xdd, 0x93, 0xa1, 0xac, 0x3c, 0xd2, 0x70, 0xb8,
0xa1, 0xbe, 0x86, 0xef, 0xfc, 0x1e, 0x00, 0x00, 0xff, 0xff, 0xf6, 0xba, 0x8b, 0x7f, 0x7b, 0x07,
0x00, 0x00,
0x06, 0xa8, 0x7f, 0xbc, 0xcc, 0x26, 0x5e, 0xfe, 0xc4, 0x81, 0x5b, 0xd5, 0xd7, 0x5f, 0x55, 0x75,
0x55, 0x7f, 0x53, 0x03, 0xcd, 0xdc, 0xed, 0x70, 0x4c, 0xf3, 0x38, 0xc4, 0xce, 0x2c, 0x5d, 0x84,
0x9d, 0x0b, 0xcc, 0x7c, 0x67, 0x91, 0xb2, 0x8c, 0x91, 0xdd, 0x04, 0x99, 0x33, 0xe5, 0x4e, 0xee,
0x3a, 0x9a, 0xd2, 0xbc, 0x93, 0xbb, 0x1d, 0x3f, 0x9c, 0x2b, 0x6a, 0xb6, 0x5c, 0x20, 0x57, 0xdc,
0xa6, 0x9d, 0xbb, 0x9d, 0x14, 0xa7, 0xfc, 0xf6, 0xc9, 0xdd, 0x9b, 0x15, 0x72, 0x4c, 0xe3, 0xe9,
0x52, 0x9d, 0xb6, 0xdf, 0x82, 0xca, 0x67, 0x03, 0xf4, 0x23, 0x4c, 0x89, 0x05, 0xe5, 0x67, 0xb8,
0xb4, 0x8d, 0x7d, 0xe3, 0x8d, 0x2a, 0x15, 0x26, 0xd9, 0x83, 0xcd, 0xdc, 0x9f, 0x5f, 0xa2, 0x5d,
0x92, 0x98, 0x72, 0xda, 0xef, 0x42, 0xe5, 0x0c, 0x53, 0x1e, 0xb3, 0x44, 0x10, 0x2e, 0xfc, 0xa7,
0x2c, 0x95, 0x41, 0x0d, 0xaa, 0x1c, 0x89, 0xc6, 0x09, 0x4b, 0x65, 0x98, 0x40, 0x85, 0xd3, 0xf6,
0xa0, 0x31, 0x66, 0xcf, 0x30, 0x39, 0x8e, 0xa7, 0x98, 0xc5, 0x17, 0x28, 0xea, 0xe1, 0xd5, 0x42,
0x86, 0x9a, 0x54, 0x98, 0x02, 0x49, 0x82, 0xa9, 0x0c, 0x33, 0xa9, 0x30, 0x05, 0x12, 0xfb, 0x99,
0x5d, 0x56, 0x48, 0xec, 0x67, 0xed, 0x9f, 0x4c, 0xa8, 0x8f, 0x90, 0x8b, 0xf2, 0x32, 0x1d, 0x79,
0x0f, 0xcc, 0x80, 0x45, 0xea, 0xde, 0x35, 0xf7, 0x35, 0xe7, 0xd6, 0xd0, 0x9c, 0x22, 0xdd, 0xe9,
0xb1, 0x68, 0x49, 0x65, 0x04, 0xf9, 0x00, 0xaa, 0x3c, 0x9e, 0x25, 0x7e, 0x76, 0x99, 0xaa, 0x16,
0x6b, 0xee, 0xdd, 0x75, 0xe1, 0x2b, 0x0e, 0xfd, 0x83, 0xde, 0xfc, 0xb1, 0x0c, 0xa6, 0x48, 0x45,
0x76, 0xa0, 0x14, 0x47, 0xb2, 0x78, 0x9d, 0x96, 0xe2, 0x88, 0xb8, 0xb0, 0xcd, 0xbe, 0x4c, 0x30,
0x9d, 0xc4, 0x91, 0xce, 0x79, 0xa7, 0x90, 0x53, 0x3c, 0x91, 0xf3, 0x58, 0x9c, 0x0f, 0xfb, 0xb4,
0x22, 0x89, 0xc3, 0x88, 0x3c, 0x00, 0x33, 0xc7, 0x34, 0x90, 0x6d, 0xee, 0xb8, 0x6f, 0xfe, 0x9d,
0x16, 0x9c, 0x33, 0x4c, 0x03, 0x2a, 0xc3, 0xc8, 0x7d, 0xd8, 0x9e, 0xeb, 0xa1, 0xda, 0xa6, 0x2c,
0xb9, 0xbf, 0x26, 0xc5, 0x0b, 0xc3, 0xa7, 0xcf, 0x23, 0xc8, 0x3d, 0xa8, 0x71, 0x95, 0x7d, 0x22,
0x9e, 0x7f, 0x53, 0x76, 0x02, 0x1a, 0xfa, 0x04, 0x97, 0xe4, 0x23, 0xd8, 0x61, 0xc1, 0x53, 0x0c,
0xb3, 0x89, 0x1f, 0x45, 0x29, 0x72, 0x6e, 0x6f, 0xad, 0xef, 0xab, 0xab, 0x8e, 0x07, 0x1b, 0xb4,
0xa1, 0x02, 0x34, 0xd0, 0xfe, 0xda, 0x00, 0x53, 0xdc, 0x97, 0xec, 0x81, 0x75, 0xe6, 0xd1, 0xde,
0xe4, 0xc9, 0xc9, 0xe8, 0xd4, 0x3b, 0x1a, 0x3e, 0x1c, 0x7a, 0x7d, 0x6b, 0x83, 0xec, 0x00, 0x3c,
0xee, 0x7d, 0xec, 0x1d, 0x8d, 0x27, 0xa7, 0x4f, 0xc6, 0x96, 0x51, 0xf0, 0x1f, 0x79, 0x63, 0xab,
0x44, 0x5e, 0x81, 0x9a, 0xf6, 0x07, 0x5e, 0xb7, 0x6f, 0x95, 0xc9, 0x2e, 0x34, 0x34, 0x30, 0xf2,
0xba, 0xf4, 0x68, 0x60, 0x99, 0x05, 0xa8, 0xef, 0x1d, 0x7b, 0x63, 0xcf, 0xda, 0x24, 0x16, 0xd4,
0x35, 0x44, 0xbb, 0x27, 0x8f, 0x3c, 0x6b, 0x4b, 0x94, 0x2f, 0x22, 0x83, 0xee, 0x68, 0x60, 0x55,
0x7a, 0x55, 0xa8, 0x84, 0x2c, 0xc9, 0xf0, 0x2a, 0x6b, 0x7f, 0x57, 0x82, 0x5a, 0x0f, 0xfd, 0x14,
0x53, 0xa5, 0xad, 0xc3, 0x17, 0xb4, 0xf5, 0xea, 0x9a, 0xa9, 0x16, 0xd8, 0xff, 0x95, 0xb4, 0xbe,
0x35, 0xb4, 0xb4, 0x0e, 0x01, 0xd0, 0x0f, 0xe7, 0x93, 0xcc, 0x0f, 0xe6, 0xa8, 0xef, 0x60, 0x17,
0xb2, 0xf8, 0xe1, 0xdc, 0xf1, 0xba, 0x47, 0xc7, 0x63, 0x71, 0x4e, 0xab, 0x82, 0x2b, 0xcd, 0x7f,
0xa5, 0xc1, 0xa2, 0x88, 0xca, 0xff, 0x54, 0x44, 0xed, 0xdf, 0x4a, 0xb0, 0x4b, 0xf1, 0x8b, 0x4b,
0xe4, 0xd9, 0xa7, 0x98, 0xf9, 0x7a, 0xa3, 0xbc, 0x03, 0x95, 0x5c, 0x6d, 0x0a, 0x7d, 0xfb, 0xe6,
0x9a, 0x94, 0x7a, 0x97, 0xd0, 0x15, 0x55, 0xac, 0x0f, 0x5c, 0xb0, 0xf0, 0x5c, 0xef, 0x01, 0xe5,
0x88, 0x4d, 0x90, 0x65, 0x73, 0x79, 0xb5, 0x06, 0x15, 0x26, 0x39, 0x84, 0xea, 0xd5, 0xe4, 0x5c,
0x56, 0xe2, 0xb6, 0xb9, 0x5f, 0x7e, 0x49, 0x7e, 0xbd, 0xde, 0xe8, 0xf6, 0x95, 0x32, 0x38, 0xe9,
0x43, 0x63, 0xa5, 0xf8, 0x4c, 0xf4, 0x23, 0x35, 0x5f, 0x73, 0xef, 0xfd, 0xc5, 0x77, 0x47, 0xeb,
0xbc, 0xb8, 0x77, 0xba, 0x50, 0x0f, 0xe4, 0xe3, 0xeb, 0x24, 0xea, 0xa3, 0x68, 0xfd, 0xb9, 0x46,
0x68, 0x2d, 0x28, 0xc8, 0xeb, 0x3e, 0x6c, 0xb1, 0x34, 0x9e, 0xc5, 0x89, 0x5d, 0x79, 0xe9, 0xf2,
0xba, 0x35, 0x55, 0xaa, 0x63, 0xda, 0xbf, 0x1a, 0x40, 0x28, 0xf2, 0x05, 0x4b, 0x38, 0xfe, 0xff,
0x87, 0xfe, 0xe0, 0x79, 0xaf, 0x6a, 0xda, 0xaf, 0xaf, 0xed, 0xf5, 0x66, 0x37, 0xab, 0x66, 0x7b,
0xc1, 0xf7, 0xd7, 0x2d, 0xe3, 0x87, 0xeb, 0x96, 0xf1, 0xf3, 0x75, 0xcb, 0xf8, 0xea, 0x97, 0xd6,
0xc6, 0xe7, 0xef, 0xcf, 0xe2, 0xec, 0xfc, 0x32, 0x70, 0x42, 0x76, 0xd1, 0x49, 0xf8, 0x22, 0x0c,
0x0f, 0x22, 0xcc, 0x3b, 0x09, 0xb2, 0x29, 0x3f, 0xf0, 0x17, 0xf1, 0xc1, 0x8c, 0x75, 0x6e, 0xfc,
0xf9, 0x3e, 0xd4, 0xce, 0x37, 0xa5, 0xbd, 0x13, 0x64, 0x0f, 0x47, 0x4e, 0xf7, 0x74, 0x28, 0xca,
0x8f, 0x14, 0x1c, 0x6c, 0xc9, 0x5f, 0xe2, 0xdb, 0xbf, 0x07, 0x00, 0x00, 0xff, 0xff, 0xb8, 0xaf,
0x1e, 0xa2, 0x94, 0x07, 0x00, 0x00,
}
func (m *XHeader) Marshal() (dAtA []byte, err error) {
@ -2182,7 +2182,7 @@ func (m *SessionToken_Body) Unmarshal(dAtA []byte) error {
return io.ErrUnexpectedEOF
}
if m.OwnerId == nil {
m.OwnerId = &refs.OwnerID{}
m.OwnerId = &grpc.OwnerID{}
}
if err := m.OwnerId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
@ -2306,7 +2306,7 @@ func (m *SessionToken_Body) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
v := &refs.Address{}
v := &grpc.Address{}
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
@ -2522,7 +2522,7 @@ func (m *BearerToken_Body) Unmarshal(dAtA []byte) error {
return io.ErrUnexpectedEOF
}
if m.EaclTable == nil {
m.EaclTable = &acl.EACLTable{}
m.EaclTable = &grpc1.EACLTable{}
}
if err := m.EaclTable.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
@ -2558,7 +2558,7 @@ func (m *BearerToken_Body) Unmarshal(dAtA []byte) error {
return io.ErrUnexpectedEOF
}
if m.OwnerId == nil {
m.OwnerId = &refs.OwnerID{}
m.OwnerId = &grpc.OwnerID{}
}
if err := m.OwnerId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err

0
v2/service/verify.go → v2/service/grpc/verify.go
View file

64
v2/service/verify.pb.go → v2/service/grpc/verify.pb.go
View file

@ -1,13 +1,13 @@
// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: v2/service/verify.proto
// source: v2/service/grpc/verify.proto
package service
import (
fmt "fmt"
proto "github.com/golang/protobuf/proto"
_ "github.com/nspcc-dev/neofs-api-go/v2/acl"
_ "github.com/nspcc-dev/neofs-api-go/v2/refs"
_ "github.com/nspcc-dev/neofs-api-go/v2/acl/grpc"
_ "github.com/nspcc-dev/neofs-api-go/v2/refs/grpc"
io "io"
math "math"
math_bits "math/bits"
@ -39,7 +39,7 @@ 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_848d62e0ecc8b6b6, []int{0}
return fileDescriptor_333853833d6163d3, []int{0}
}
func (m *Signature) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -101,7 +101,7 @@ func (m *RequestVerificationHeader) Reset() { *m = RequestVerificationHe
func (m *RequestVerificationHeader) String() string { return proto.CompactTextString(m) }
func (*RequestVerificationHeader) ProtoMessage() {}
func (*RequestVerificationHeader) Descriptor() ([]byte, []int) {
return fileDescriptor_848d62e0ecc8b6b6, []int{1}
return fileDescriptor_333853833d6163d3, []int{1}
}
func (m *RequestVerificationHeader) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -177,7 +177,7 @@ func (m *ResponseVerificationHeader) Reset() { *m = ResponseVerification
func (m *ResponseVerificationHeader) String() string { return proto.CompactTextString(m) }
func (*ResponseVerificationHeader) ProtoMessage() {}
func (*ResponseVerificationHeader) Descriptor() ([]byte, []int) {
return fileDescriptor_848d62e0ecc8b6b6, []int{2}
return fileDescriptor_333853833d6163d3, []int{2}
}
func (m *ResponseVerificationHeader) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -240,33 +240,33 @@ func init() {
proto.RegisterType((*ResponseVerificationHeader)(nil), "neo.fs.v2.service.ResponseVerificationHeader")
}
func init() { proto.RegisterFile("v2/service/verify.proto", fileDescriptor_848d62e0ecc8b6b6) }
func init() { proto.RegisterFile("v2/service/grpc/verify.proto", fileDescriptor_333853833d6163d3) }
var fileDescriptor_848d62e0ecc8b6b6 = []byte{
// 353 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x93, 0x4f, 0x4b, 0xc3, 0x30,
0x18, 0xc6, 0x6d, 0x37, 0x06, 0x46, 0x9d, 0xb3, 0x0a, 0xce, 0x21, 0x45, 0x76, 0xf2, 0x60, 0x13,
0xac, 0xde, 0x3c, 0xe9, 0xfc, 0x7b, 0x11, 0xe9, 0xc0, 0x83, 0x20, 0xd2, 0x75, 0x6f, 0x6b, 0xd0,
0x25, 0x35, 0xc9, 0x02, 0xfd, 0x26, 0x7e, 0x06, 0xcf, 0xe2, 0x67, 0xf0, 0xe8, 0x47, 0x90, 0xf9,
0x45, 0xa4, 0xed, 0x66, 0x87, 0x6e, 0xb0, 0xbb, 0xa7, 0xbc, 0x3c, 0xc9, 0xf3, 0xcb, 0xc3, 0x03,
0x2f, 0x5a, 0xd7, 0x2e, 0x91, 0x20, 0x34, 0x0d, 0x80, 0x68, 0x10, 0x34, 0x4c, 0x70, 0x2c, 0xb8,
0xe2, 0xd6, 0x0a, 0x03, 0x8e, 0x43, 0x89, 0xb5, 0x8b, 0x87, 0xf7, 0x0d, 0x4b, 0xbb, 0xc4, 0x0f,
0x1e, 0x89, 0x4a, 0x62, 0x90, 0xf9, 0xb3, 0xc6, 0xaa, 0x76, 0x89, 0x80, 0x50, 0x8e, 0x8b, 0xcd,
0x5d, 0x34, 0xdf, 0xa6, 0x11, 0xf3, 0x55, 0x5f, 0x80, 0x55, 0x43, 0xa5, 0x07, 0x48, 0xea, 0xc6,
0x96, 0xb1, 0xbd, 0xe8, 0xa5, 0xa3, 0x65, 0xa1, 0xb2, 0xa4, 0x11, 0xab, 0x9b, 0x99, 0x94, 0xcd,
0xcd, 0x57, 0x13, 0x6d, 0x78, 0xf0, 0xd4, 0x07, 0xa9, 0xae, 0xd3, 0x18, 0x34, 0xf0, 0x15, 0xe5,
0xec, 0x1c, 0xfc, 0x2e, 0x08, 0xab, 0x85, 0xaa, 0x1d, 0xde, 0x4d, 0xee, 0xe4, 0x88, 0x9a, 0xe1,
0x16, 0xdc, 0x4d, 0xfc, 0x27, 0x25, 0xfe, 0xf9, 0xd9, 0x5b, 0x4a, 0x3d, 0x45, 0x90, 0x16, 0xaa,
0xf6, 0x40, 0xf9, 0x63, 0x10, 0x73, 0x16, 0x48, 0xea, 0x29, 0x20, 0x67, 0xa8, 0xc6, 0x05, 0x8d,
0x28, 0x1b, 0xc3, 0x94, 0x66, 0xc0, 0x2c, 0xe7, 0xae, 0x02, 0x74, 0x8c, 0x2a, 0xb9, 0x54, 0x2f,
0x67, 0xf6, 0x9d, 0x09, 0xf6, 0xa9, 0x85, 0x78, 0x43, 0x6f, 0xf3, 0xcd, 0x44, 0x0d, 0x0f, 0x64,
0xcc, 0x99, 0x84, 0xff, 0xd1, 0xdb, 0xc9, 0xaf, 0xde, 0x9c, 0x89, 0xbd, 0x4d, 0x6b, 0x64, 0x54,
0xdc, 0xd1, 0xed, 0xfb, 0xc0, 0x36, 0x3e, 0x06, 0xb6, 0xf1, 0x39, 0xb0, 0x8d, 0xe7, 0x2f, 0x7b,
0xee, 0x66, 0x3f, 0xa2, 0xea, 0xbe, 0xdf, 0xc1, 0x01, 0xef, 0x11, 0x26, 0xe3, 0x20, 0x70, 0xba,
0xa0, 0x09, 0x03, 0x1e, 0x4a, 0xc7, 0x8f, 0xa9, 0x13, 0x71, 0x52, 0xec, 0xca, 0xc1, 0xf0, 0x7c,
0x31, 0xd7, 0x2e, 0x81, 0x9f, 0xb6, 0xf1, 0xe1, 0xd5, 0x45, 0x9a, 0xa0, 0x9d, 0xcb, 0x9d, 0x4a,
0xb6, 0x08, 0x7b, 0xdf, 0x01, 0x00, 0x00, 0xff, 0xff, 0x8d, 0x87, 0x6a, 0x4d, 0x5f, 0x03, 0x00,
0x00,
var fileDescriptor_333853833d6163d3 = []byte{
// 361 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x93, 0xcf, 0x4a, 0xeb, 0x40,
0x14, 0xc6, 0x6f, 0xd2, 0x52, 0xb8, 0x73, 0xef, 0xed, 0xad, 0x41, 0x30, 0x96, 0x12, 0xa4, 0x2b,
0x17, 0x66, 0x06, 0xe3, 0x4a, 0x5c, 0x69, 0xfd, 0xbb, 0x11, 0x49, 0xc1, 0x85, 0x1b, 0x49, 0xd2,
0x93, 0x38, 0x68, 0x67, 0xe2, 0xcc, 0x74, 0x20, 0x6f, 0xe2, 0x33, 0xb8, 0x16, 0x9f, 0xc1, 0xa5,
0x8f, 0x20, 0xf5, 0x45, 0x24, 0x49, 0x6b, 0x4b, 0xff, 0x40, 0xf7, 0xee, 0x4e, 0x4e, 0xbe, 0xef,
0x37, 0x1f, 0x1f, 0x1c, 0xd4, 0xd2, 0x1e, 0x91, 0x20, 0x34, 0x8d, 0x80, 0x24, 0x22, 0x8d, 0x88,
0x06, 0x41, 0xe3, 0x0c, 0xa7, 0x82, 0x2b, 0x6e, 0xad, 0x31, 0xe0, 0x38, 0x96, 0x58, 0x7b, 0x78,
0x24, 0x6a, 0x6e, 0x68, 0x8f, 0x04, 0xd1, 0x43, 0x29, 0x56, 0x59, 0x0a, 0xb2, 0xd4, 0x36, 0x6d,
0xed, 0x11, 0x01, 0xb1, 0x9c, 0xfb, 0xd3, 0xde, 0x45, 0xbf, 0xbb, 0x34, 0x61, 0x81, 0x1a, 0x08,
0xb0, 0x1a, 0xa8, 0x72, 0x0f, 0x99, 0x6d, 0x6c, 0x19, 0xdb, 0x7f, 0xfd, 0x7c, 0xb4, 0x2c, 0x54,
0x95, 0x34, 0x61, 0xb6, 0x59, 0xac, 0x8a, 0xb9, 0xfd, 0x62, 0xa2, 0x4d, 0x1f, 0x1e, 0x07, 0x20,
0xd5, 0x75, 0x1e, 0x88, 0x46, 0x81, 0xa2, 0x9c, 0x9d, 0x43, 0xd0, 0x03, 0x61, 0x75, 0x50, 0x3d,
0xe4, 0xbd, 0xec, 0x56, 0x8e, 0xa9, 0x05, 0xee, 0x8f, 0xd7, 0xc2, 0x73, 0x79, 0xf1, 0xf7, 0xcb,
0xfe, 0xbf, 0xdc, 0x33, 0x09, 0xd2, 0x41, 0xf5, 0x3e, 0xa8, 0x60, 0x0a, 0x62, 0xae, 0x02, 0xc9,
0x3d, 0x13, 0xc8, 0x19, 0x6a, 0x70, 0x41, 0x13, 0xca, 0xa6, 0x30, 0x95, 0x15, 0x30, 0xff, 0x4b,
0xd7, 0x04, 0x74, 0x8c, 0x6a, 0xe5, 0xca, 0xae, 0x16, 0xf6, 0x9d, 0x05, 0xf6, 0xa5, 0x85, 0xf8,
0x23, 0x6f, 0xfb, 0xd5, 0x44, 0x4d, 0x1f, 0x64, 0xca, 0x99, 0x84, 0x9f, 0xd1, 0xdb, 0xc9, 0x4c,
0x6f, 0xee, 0xc2, 0xde, 0x96, 0x35, 0x32, 0x2e, 0xee, 0x28, 0x7c, 0x1b, 0x3a, 0xc6, 0xfb, 0xd0,
0x31, 0x3e, 0x86, 0x8e, 0xf1, 0xf4, 0xe9, 0xfc, 0xba, 0xd9, 0x4f, 0xa8, 0xba, 0x1b, 0x84, 0x38,
0xe2, 0x7d, 0xc2, 0x64, 0x1a, 0x45, 0x6e, 0x0f, 0x34, 0x61, 0xc0, 0x63, 0xe9, 0x06, 0x29, 0x75,
0x13, 0x4e, 0x66, 0x4e, 0xe7, 0x60, 0xf4, 0xf1, 0x6c, 0xae, 0x5f, 0x02, 0x3f, 0xed, 0xe2, 0xc3,
0xab, 0x8b, 0x3c, 0x46, 0xb7, 0x5c, 0x87, 0xb5, 0xe2, 0x1a, 0xf6, 0xbe, 0x02, 0x00, 0x00, 0xff,
0xff, 0x66, 0xc2, 0xc4, 0xb8, 0x73, 0x03, 0x00, 0x00,
}
func (m *Signature) Marshal() (dAtA []byte, err error) {

0
v2/service/version.go → v2/service/grpc/version.go
View file

36
v2/service.go → v2/service/service.go
View file

@ -1,4 +1,8 @@
package v2
package service
import (
service "github.com/nspcc-dev/neofs-api-go/v2/service/grpc"
)
type Signature struct {
key, sign []byte
@ -42,10 +46,6 @@ type RequestMetaHeader struct {
origin *RequestMetaHeader
}
type OwnerID struct {
val []byte
}
func (s *Signature) GetKey() []byte {
if s != nil {
return s.key
@ -316,16 +316,28 @@ func (r *RequestMetaHeader) StableSize() int {
return RequestMetaHeaderToGRPCMessage(r).Size()
}
func (o *OwnerID) GetValue() []byte {
if o != nil {
return o.val
func SignatureToGRPCMessage(s *Signature) *service.Signature {
if s == nil {
return nil
}
return nil
m := new(service.Signature)
m.SetKey(s.GetKey())
m.SetSign(s.GetSign())
return m
}
func (o *OwnerID) SetValue(v []byte) {
if o != nil {
o.val = v
func SignatureFromGRPCMessage(m *service.Signature) *Signature {
if m == nil {
return nil
}
s := new(Signature)
s.SetKey(m.GetKey())
s.SetSign(m.GetSign())
return s
}

4
v2/session/service.go → v2/session/grpc/service.go
View file

@ -1,8 +1,8 @@
package session
import (
"github.com/nspcc-dev/neofs-api-go/v2/refs"
"github.com/nspcc-dev/neofs-api-go/v2/service"
refs "github.com/nspcc-dev/neofs-api-go/v2/refs/grpc"
service "github.com/nspcc-dev/neofs-api-go/v2/service/grpc"
)
// SetOwnerId sets identifier of the session initiator.

161
v2/session/service.pb.go → v2/session/grpc/service.pb.go
View file

@ -1,5 +1,5 @@
// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: v2/session/service.proto
// source: v2/session/grpc/service.proto
package session
@ -7,9 +7,9 @@ import (
context "context"
fmt "fmt"
proto "github.com/golang/protobuf/proto"
refs "github.com/nspcc-dev/neofs-api-go/v2/refs"
service "github.com/nspcc-dev/neofs-api-go/v2/service"
grpc "google.golang.org/grpc"
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"
codes "google.golang.org/grpc/codes"
status "google.golang.org/grpc/status"
io "io"
@ -34,20 +34,20 @@ 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 *service.RequestMetaHeader `protobuf:"bytes,2,opt,name=meta_header,json=metaHeader,proto3" json:"meta_header,omitempty"`
MetaHeader *grpc.RequestMetaHeader `protobuf:"bytes,2,opt,name=meta_header,json=metaHeader,proto3" json:"meta_header,omitempty"`
// Carries request verification information. This header is used to authenticate
// the nodes of the message route and check the correctness of transmission.
VerifyHeader *service.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 *grpc.RequestVerificationHeader `protobuf:"bytes,3,opt,name=verify_header,json=verifyHeader,proto3" json:"verify_header,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CreateRequest) Reset() { *m = CreateRequest{} }
func (m *CreateRequest) String() string { return proto.CompactTextString(m) }
func (*CreateRequest) ProtoMessage() {}
func (*CreateRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_ab0074a16885b32c, []int{0}
return fileDescriptor_4ed1365cc8e16cd4, []int{0}
}
func (m *CreateRequest) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -83,14 +83,14 @@ func (m *CreateRequest) GetBody() *CreateRequest_Body {
return nil
}
func (m *CreateRequest) GetMetaHeader() *service.RequestMetaHeader {
func (m *CreateRequest) GetMetaHeader() *grpc.RequestMetaHeader {
if m != nil {
return m.MetaHeader
}
return nil
}
func (m *CreateRequest) GetVerifyHeader() *service.RequestVerificationHeader {
func (m *CreateRequest) GetVerifyHeader() *grpc.RequestVerificationHeader {
if m != nil {
return m.VerifyHeader
}
@ -100,19 +100,19 @@ func (m *CreateRequest) GetVerifyHeader() *service.RequestVerificationHeader {
// Request body
type CreateRequest_Body struct {
// Carries an identifier of a session initiator.
OwnerId *refs.OwnerID `protobuf:"bytes,1,opt,name=owner_id,json=ownerId,proto3" json:"owner_id,omitempty"`
OwnerId *grpc1.OwnerID `protobuf:"bytes,1,opt,name=owner_id,json=ownerId,proto3" json:"owner_id,omitempty"`
// Carries a lifetime of the session.
Lifetime *service.TokenLifetime `protobuf:"bytes,2,opt,name=lifetime,proto3" json:"lifetime,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
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:"-"`
}
func (m *CreateRequest_Body) Reset() { *m = CreateRequest_Body{} }
func (m *CreateRequest_Body) String() string { return proto.CompactTextString(m) }
func (*CreateRequest_Body) ProtoMessage() {}
func (*CreateRequest_Body) Descriptor() ([]byte, []int) {
return fileDescriptor_ab0074a16885b32c, []int{0, 0}
return fileDescriptor_4ed1365cc8e16cd4, []int{0, 0}
}
func (m *CreateRequest_Body) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -141,14 +141,14 @@ func (m *CreateRequest_Body) XXX_DiscardUnknown() {
var xxx_messageInfo_CreateRequest_Body proto.InternalMessageInfo
func (m *CreateRequest_Body) GetOwnerId() *refs.OwnerID {
func (m *CreateRequest_Body) GetOwnerId() *grpc1.OwnerID {
if m != nil {
return m.OwnerId
}
return nil
}
func (m *CreateRequest_Body) GetLifetime() *service.TokenLifetime {
func (m *CreateRequest_Body) GetLifetime() *grpc.TokenLifetime {
if m != nil {
return m.Lifetime
}
@ -161,21 +161,21 @@ 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 *service.ResponseMetaHeader `protobuf:"bytes,2,opt,name=meta_header,json=metaHeader,proto3" json:"meta_header,omitempty"`
MetaHeader *grpc.ResponseMetaHeader `protobuf:"bytes,2,opt,name=meta_header,json=metaHeader,proto3" json:"meta_header,omitempty"`
// Carries response verification information. This header is used to
// authenticate the nodes of the message route and check the correctness
// of transmission.
VerifyHeader *service.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 *grpc.ResponseVerificationHeader `protobuf:"bytes,3,opt,name=verify_header,json=verifyHeader,proto3" json:"verify_header,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CreateResponse) Reset() { *m = CreateResponse{} }
func (m *CreateResponse) String() string { return proto.CompactTextString(m) }
func (*CreateResponse) ProtoMessage() {}
func (*CreateResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_ab0074a16885b32c, []int{1}
return fileDescriptor_4ed1365cc8e16cd4, []int{1}
}
func (m *CreateResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -211,14 +211,14 @@ func (m *CreateResponse) GetBody() *CreateResponse_Body {
return nil
}
func (m *CreateResponse) GetMetaHeader() *service.ResponseMetaHeader {
func (m *CreateResponse) GetMetaHeader() *grpc.ResponseMetaHeader {
if m != nil {
return m.MetaHeader
}
return nil
}
func (m *CreateResponse) GetVerifyHeader() *service.ResponseVerificationHeader {
func (m *CreateResponse) GetVerifyHeader() *grpc.ResponseVerificationHeader {
if m != nil {
return m.VerifyHeader
}
@ -240,7 +240,7 @@ func (m *CreateResponse_Body) Reset() { *m = CreateResponse_Body{} }
func (m *CreateResponse_Body) String() string { return proto.CompactTextString(m) }
func (*CreateResponse_Body) ProtoMessage() {}
func (*CreateResponse_Body) Descriptor() ([]byte, []int) {
return fileDescriptor_ab0074a16885b32c, []int{1, 0}
return fileDescriptor_4ed1365cc8e16cd4, []int{1, 0}
}
func (m *CreateResponse_Body) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -290,66 +290,67 @@ func init() {
proto.RegisterType((*CreateResponse_Body)(nil), "neo.fs.v2.session.CreateResponse.Body")
}
func init() { proto.RegisterFile("v2/session/service.proto", fileDescriptor_ab0074a16885b32c) }
func init() { proto.RegisterFile("v2/session/grpc/service.proto", fileDescriptor_4ed1365cc8e16cd4) }
var fileDescriptor_ab0074a16885b32c = []byte{
// 463 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x93, 0xdf, 0x6e, 0xd3, 0x30,
0x14, 0xc6, 0x49, 0x98, 0xc6, 0xe4, 0x76, 0x95, 0x30, 0xa0, 0x55, 0xbd, 0x28, 0x65, 0x62, 0x88,
0x0b, 0x62, 0x4b, 0x01, 0x09, 0xf1, 0xe7, 0x86, 0x01, 0x13, 0x15, 0x8c, 0x3f, 0x2e, 0xe2, 0x02,
0x09, 0x45, 0x69, 0x72, 0xb2, 0x59, 0x23, 0x76, 0x88, 0xbd, 0x40, 0xde, 0x84, 0x5b, 0x6e, 0x79,
0x12, 0x2e, 0x79, 0x02, 0x84, 0xca, 0x8b, 0xa0, 0xd8, 0xde, 0x68, 0x45, 0xd6, 0x5e, 0xb5, 0x3e,
0xfe, 0xbe, 0xef, 0x9c, 0xf3, 0x53, 0x8c, 0xfa, 0x55, 0x48, 0x15, 0x28, 0xc5, 0xa5, 0xa0, 0x0a,
0xca, 0x8a, 0x27, 0x40, 0x8a, 0x52, 0x6a, 0x89, 0x2f, 0x0a, 0x90, 0x24, 0x53, 0xa4, 0x0a, 0x89,
0x13, 0x0c, 0x2e, 0x55, 0x21, 0x2d, 0x21, 0x53, 0x54, 0xd7, 0x05, 0x28, 0xab, 0x1b, 0x5c, 0x31,
0x09, 0xc6, 0x49, 0x73, 0xd0, 0xb1, 0x2b, 0x6f, 0xcd, 0x95, 0x2b, 0x28, 0x79, 0x56, 0xdb, 0x8b,
0xed, 0x5f, 0x3e, 0xda, 0x7c, 0x5c, 0x42, 0xac, 0x81, 0xc1, 0xa7, 0x63, 0x50, 0x1a, 0xdf, 0x43,
0x6b, 0x53, 0x99, 0xd6, 0x7d, 0x6f, 0xe4, 0xdd, 0xec, 0x84, 0x3b, 0xe4, 0xbf, 0xc6, 0x64, 0x41,
0x4f, 0x76, 0x65, 0x5a, 0x33, 0x63, 0xc1, 0x4f, 0x51, 0xa7, 0xe9, 0x19, 0x1d, 0x42, 0x9c, 0x42,
0xd9, 0xf7, 0x4d, 0xc2, 0xf5, 0x85, 0x04, 0xbb, 0x93, 0xf3, 0xee, 0x83, 0x8e, 0x9f, 0x19, 0x2d,
0x43, 0xf9, 0xe9, 0x7f, 0xfc, 0x06, 0x6d, 0xda, 0x19, 0x4f, 0x82, 0xce, 0x9b, 0xa0, 0x5b, 0x67,
0x07, 0xbd, 0x6b, 0xe4, 0x3c, 0x89, 0x35, 0x97, 0xc2, 0x05, 0x76, 0x6d, 0x84, 0x3d, 0x0d, 0xbe,
0xa0, 0xb5, 0x66, 0x4e, 0x1c, 0xa2, 0x0d, 0xf9, 0x59, 0x40, 0x19, 0xf1, 0xd4, 0x2d, 0xb8, 0x35,
0x97, 0xda, 0xd0, 0x24, 0xaf, 0x9a, 0xfb, 0xf1, 0x13, 0x76, 0xc1, 0x08, 0xc7, 0x29, 0x7e, 0x88,
0x36, 0x3e, 0xf2, 0x0c, 0x34, 0xcf, 0xc1, 0xad, 0x34, 0x6a, 0x99, 0xe4, 0xad, 0x3c, 0x02, 0xf1,
0xc2, 0xe9, 0xd8, 0xa9, 0x63, 0xfb, 0x9b, 0x8f, 0x7a, 0x27, 0xc0, 0x54, 0x21, 0x85, 0x02, 0x7c,
0x7f, 0x81, 0xf0, 0x8d, 0x25, 0x84, 0xad, 0x61, 0x1e, 0xf1, 0x5e, 0x1b, 0xe2, 0x9d, 0x56, 0x32,
0xd6, 0x7c, 0x06, 0x63, 0xd6, 0xce, 0x38, 0x58, 0x92, 0xb4, 0x12, 0xf2, 0x5d, 0x07, 0xb9, 0x87,
0x7c, 0x87, 0xb7, 0xcb, 0x7c, 0x9e, 0xe2, 0xab, 0xa8, 0xe3, 0x16, 0x8b, 0x8e, 0xa0, 0x36, 0x33,
0x77, 0x19, 0x72, 0xa5, 0xe7, 0x50, 0x87, 0x11, 0xea, 0x4d, 0xec, 0x69, 0x62, 0x7b, 0xe2, 0x7d,
0xb4, 0x6e, 0x19, 0xe0, 0xd1, 0xaa, 0x0f, 0x70, 0x70, 0x6d, 0x25, 0xc0, 0xdd, 0x0f, 0x3f, 0x66,
0x43, 0xef, 0xe7, 0x6c, 0xe8, 0xfd, 0x9e, 0x0d, 0xbd, 0xaf, 0x7f, 0x86, 0xe7, 0xde, 0xdf, 0x39,
0xe0, 0xfa, 0xf0, 0x78, 0x4a, 0x12, 0x99, 0x53, 0xa1, 0x8a, 0x24, 0x09, 0x52, 0xa8, 0xa8, 0x00,
0x99, 0xa9, 0x20, 0x2e, 0x78, 0x70, 0x20, 0xe9, 0xbf, 0xb7, 0xf8, 0xc0, 0xfd, 0x7e, 0xf7, 0x2f,
0xbf, 0x04, 0xb9, 0x37, 0x21, 0x8f, 0x5e, 0x8f, 0x9b, 0x6e, 0x6e, 0xe8, 0xe9, 0xba, 0x79, 0x4b,
0xb7, 0xff, 0x06, 0x00, 0x00, 0xff, 0xff, 0x38, 0xb7, 0xac, 0xe1, 0xbf, 0x03, 0x00, 0x00,
var fileDescriptor_4ed1365cc8e16cd4 = []byte{
// 466 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x93, 0x4f, 0x6f, 0xd3, 0x30,
0x18, 0xc6, 0x49, 0x98, 0xc6, 0xe4, 0x76, 0x95, 0xb0, 0x90, 0xa8, 0x22, 0x28, 0x65, 0x62, 0x88,
0x03, 0x75, 0xa4, 0x70, 0x40, 0x03, 0x2e, 0x0c, 0x98, 0xa8, 0x60, 0xfc, 0x71, 0x11, 0x07, 0x2e,
0x55, 0xfe, 0xbc, 0xe9, 0xac, 0x11, 0x3b, 0xd8, 0x5e, 0x20, 0xdf, 0x84, 0x2b, 0x57, 0x3e, 0x09,
0x47, 0x3e, 0x01, 0x42, 0xe5, 0x8b, 0xa0, 0xd8, 0xde, 0xb4, 0x6e, 0x59, 0x7b, 0xab, 0xfb, 0x3e,
0xcf, 0xe3, 0xe7, 0xfd, 0x29, 0x46, 0x37, 0xab, 0x28, 0x54, 0xa0, 0x14, 0x13, 0x3c, 0x9c, 0xc9,
0x32, 0x0d, 0x15, 0xc8, 0x8a, 0xa5, 0x40, 0x4a, 0x29, 0xb4, 0xc0, 0x57, 0x39, 0x08, 0x92, 0x2b,
0x52, 0x45, 0xc4, 0xa9, 0x82, 0x7e, 0x15, 0x85, 0x12, 0x72, 0x65, 0xe5, 0xba, 0x2e, 0x41, 0x59,
0x71, 0x10, 0x98, 0x2c, 0x63, 0xb7, 0xc3, 0x02, 0x74, 0xec, 0x66, 0x37, 0xce, 0xce, 0x2a, 0x90,
0x2c, 0xaf, 0xed, 0x74, 0xeb, 0x8f, 0x8f, 0x36, 0x9f, 0x49, 0x88, 0x35, 0x50, 0xf8, 0x72, 0x04,
0x4a, 0xe3, 0x1d, 0xb4, 0x96, 0x88, 0xac, 0xee, 0x7b, 0x43, 0xef, 0x5e, 0x27, 0xda, 0x26, 0xe7,
0x7a, 0x90, 0x05, 0x3d, 0xd9, 0x15, 0x59, 0x4d, 0x8d, 0x05, 0xbf, 0x40, 0x9d, 0xe6, 0xe2, 0xe9,
0x01, 0xc4, 0x19, 0xc8, 0xbe, 0x6f, 0x12, 0xee, 0x2c, 0x24, 0xd8, 0x15, 0x9d, 0x77, 0x1f, 0x74,
0xfc, 0xd2, 0x68, 0x29, 0x2a, 0x4e, 0x7e, 0xe3, 0xf7, 0x68, 0xd3, 0x76, 0x3c, 0x0e, 0xba, 0x6c,
0x82, 0xee, 0x5f, 0x1c, 0xf4, 0xb1, 0x91, 0xb3, 0x34, 0xd6, 0x4c, 0x70, 0x17, 0xd8, 0xb5, 0x11,
0xf6, 0x14, 0x7c, 0x43, 0x6b, 0x4d, 0x4f, 0x1c, 0xa1, 0x0d, 0xf1, 0x95, 0x83, 0x9c, 0xb2, 0xcc,
0x2d, 0x78, 0xfd, 0x54, 0x6a, 0x03, 0x97, 0xbc, 0x6d, 0xe6, 0xe3, 0xe7, 0xf4, 0x8a, 0x11, 0x8e,
0x33, 0xfc, 0x04, 0x6d, 0x7c, 0x66, 0x39, 0x68, 0x56, 0x80, 0x5b, 0x69, 0xd8, 0xd2, 0xe4, 0x83,
0x38, 0x04, 0xfe, 0xda, 0xe9, 0xe8, 0x89, 0x63, 0xeb, 0x87, 0x8f, 0x7a, 0xc7, 0xc0, 0x54, 0x29,
0xb8, 0x02, 0xfc, 0x68, 0x81, 0xf0, 0xdd, 0x25, 0x84, 0xad, 0xe1, 0x34, 0xe2, 0xbd, 0x36, 0xc4,
0xdb, 0xad, 0x64, 0xac, 0xf9, 0x02, 0xc6, 0xb4, 0x9d, 0xf1, 0x68, 0x49, 0xd2, 0x4a, 0xc8, 0x0f,
0x1d, 0xe4, 0x1e, 0xf2, 0x1d, 0xde, 0x2e, 0xf5, 0x59, 0x86, 0x6f, 0xa1, 0x8e, 0x5b, 0x6c, 0x7a,
0x08, 0xb5, 0xe9, 0xdc, 0xa5, 0xc8, 0xfd, 0xf5, 0x0a, 0xea, 0x68, 0x8a, 0x7a, 0x13, 0x7b, 0x9a,
0xd8, 0x3b, 0xf1, 0x3e, 0x5a, 0xb7, 0x0c, 0xf0, 0x70, 0xd5, 0x07, 0x18, 0xdc, 0x5e, 0x09, 0x70,
0x37, 0xf9, 0x35, 0x1f, 0x78, 0xbf, 0xe7, 0x03, 0xef, 0xef, 0x7c, 0xe0, 0x7d, 0xff, 0x37, 0xb8,
0xf4, 0x69, 0x67, 0xc6, 0xf4, 0xc1, 0x51, 0x42, 0x52, 0x51, 0x84, 0x5c, 0x95, 0x69, 0x3a, 0xca,
0xa0, 0x0a, 0x39, 0x88, 0x5c, 0x8d, 0xe2, 0x92, 0x8d, 0x66, 0x22, 0x3c, 0xf3, 0x3e, 0x1f, 0xbb,
0xc3, 0x4f, 0xff, 0xda, 0x1b, 0x10, 0x7b, 0x13, 0xf2, 0xf4, 0xdd, 0xb8, 0xb9, 0xd2, 0x35, 0x4f,
0xd6, 0xcd, 0x83, 0x7a, 0xf0, 0x3f, 0x00, 0x00, 0xff, 0xff, 0xc2, 0x58, 0x7b, 0xc5, 0xd8, 0x03,
0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn
var _ grpc2.ClientConn
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4
const _ = grpc2.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 ...grpc.CallOption) (*CreateResponse, error)
Create(ctx context.Context, in *CreateRequest, opts ...grpc2.CallOption) (*CreateResponse, error)
}
type sessionServiceClient struct {
cc *grpc.ClientConn
cc *grpc2.ClientConn
}
func NewSessionServiceClient(cc *grpc.ClientConn) SessionServiceClient {
func NewSessionServiceClient(cc *grpc2.ClientConn) SessionServiceClient {
return &sessionServiceClient{cc}
}
func (c *sessionServiceClient) Create(ctx context.Context, in *CreateRequest, opts ...grpc.CallOption) (*CreateResponse, error) {
func (c *sessionServiceClient) Create(ctx context.Context, in *CreateRequest, opts ...grpc2.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 +373,11 @@ func (*UnimplementedSessionServiceServer) Create(ctx context.Context, req *Creat
return nil, status.Errorf(codes.Unimplemented, "method Create not implemented")
}
func RegisterSessionServiceServer(s *grpc.Server, srv SessionServiceServer) {
func RegisterSessionServiceServer(s *grpc2.Server, srv SessionServiceServer) {
s.RegisterService(&_SessionService_serviceDesc, srv)
}
func _SessionService_Create_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
func _SessionService_Create_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc2.UnaryServerInterceptor) (interface{}, error) {
in := new(CreateRequest)
if err := dec(in); err != nil {
return nil, err
@ -384,7 +385,7 @@ func _SessionService_Create_Handler(srv interface{}, ctx context.Context, dec fu
if interceptor == nil {
return srv.(SessionServiceServer).Create(ctx, in)
}
info := &grpc.UnaryServerInfo{
info := &grpc2.UnaryServerInfo{
Server: srv,
FullMethod: "/neo.fs.v2.session.SessionService/Create",
}
@ -394,17 +395,17 @@ func _SessionService_Create_Handler(srv interface{}, ctx context.Context, dec fu
return interceptor(ctx, in, info, handler)
}
var _SessionService_serviceDesc = grpc.ServiceDesc{
var _SessionService_serviceDesc = grpc2.ServiceDesc{
ServiceName: "neo.fs.v2.session.SessionService",
HandlerType: (*SessionServiceServer)(nil),
Methods: []grpc.MethodDesc{
Methods: []grpc2.MethodDesc{
{
MethodName: "Create",
Handler: _SessionService_Create_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "v2/session/service.proto",
Streams: []grpc2.StreamDesc{},
Metadata: "v2/session/grpc/service.proto",
}
func (m *CreateRequest) Marshal() (dAtA []byte, err error) {
@ -825,7 +826,7 @@ func (m *CreateRequest) Unmarshal(dAtA []byte) error {
return io.ErrUnexpectedEOF
}
if m.MetaHeader == nil {
m.MetaHeader = &service.RequestMetaHeader{}
m.MetaHeader = &grpc.RequestMetaHeader{}
}
if err := m.MetaHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
@ -861,7 +862,7 @@ func (m *CreateRequest) Unmarshal(dAtA []byte) error {
return io.ErrUnexpectedEOF
}
if m.VerifyHeader == nil {
m.VerifyHeader = &service.RequestVerificationHeader{}
m.VerifyHeader = &grpc.RequestVerificationHeader{}
}
if err := m.VerifyHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
@ -951,7 +952,7 @@ func (m *CreateRequest_Body) Unmarshal(dAtA []byte) error {
return io.ErrUnexpectedEOF
}
if m.OwnerId == nil {
m.OwnerId = &refs.OwnerID{}
m.OwnerId = &grpc1.OwnerID{}
}
if err := m.OwnerId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
@ -987,7 +988,7 @@ func (m *CreateRequest_Body) Unmarshal(dAtA []byte) error {
return io.ErrUnexpectedEOF
}
if m.Lifetime == nil {
m.Lifetime = &service.TokenLifetime{}
m.Lifetime = &grpc.TokenLifetime{}
}
if err := m.Lifetime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
@ -1113,7 +1114,7 @@ func (m *CreateResponse) Unmarshal(dAtA []byte) error {
return io.ErrUnexpectedEOF
}
if m.MetaHeader == nil {
m.MetaHeader = &service.ResponseMetaHeader{}
m.MetaHeader = &grpc.ResponseMetaHeader{}
}
if err := m.MetaHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
@ -1149,7 +1150,7 @@ func (m *CreateResponse) Unmarshal(dAtA []byte) error {
return io.ErrUnexpectedEOF
}
if m.VerifyHeader == nil {
m.VerifyHeader = &service.ResponseVerificationHeader{}
m.VerifyHeader = &grpc.ResponseVerificationHeader{}
}
if err := m.VerifyHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err

23
v2/signature/sign.go
View file

@ -5,14 +5,15 @@ import (
"fmt"
"github.com/nspcc-dev/neofs-api-go/util/signature"
v2 "github.com/nspcc-dev/neofs-api-go/v2"
"github.com/nspcc-dev/neofs-api-go/v2/accounting"
"github.com/nspcc-dev/neofs-api-go/v2/service"
"github.com/pkg/errors"
)
type SignedRequest interface {
GetRequestMetaHeader() *v2.RequestMetaHeader
GetRequestVerificationHeader() *v2.RequestVerificationHeader
SetRequestVerificationHeader(*v2.RequestVerificationHeader)
GetRequestMetaHeader() *service.RequestMetaHeader
GetRequestVerificationHeader() *service.RequestVerificationHeader
SetRequestVerificationHeader(*service.RequestVerificationHeader)
}
type stableMarshaler interface {
@ -32,14 +33,14 @@ func (s stableMarshalerWrapper) SignedDataSize() int {
return s.sm.StableSize()
}
func keySignatureHandler(s *v2.Signature) signature.KeySignatureHandler {
func keySignatureHandler(s *service.Signature) signature.KeySignatureHandler {
return func(key []byte, sig []byte) {
s.SetKey(key)
s.SetSign(sig)
}
}
func keySignatureSource(s *v2.Signature) signature.KeySignatureSource {
func keySignatureSource(s *service.Signature) signature.KeySignatureSource {
return func() ([]byte, []byte) {
return s.GetKey(), s.GetSign()
}
@ -47,7 +48,7 @@ func keySignatureSource(s *v2.Signature) signature.KeySignatureSource {
func requestBody(req SignedRequest) stableMarshaler {
switch v := req.(type) {
case *v2.BalanceRequest:
case *accounting.BalanceRequest:
return v.GetBody()
default:
panic(fmt.Sprintf("unknown request %T", req))
@ -60,7 +61,7 @@ func SignRequest(key *ecdsa.PrivateKey, req SignedRequest) error {
}
// create new level of matryoshka
verifyHdr := new(v2.RequestVerificationHeader)
verifyHdr := new(service.RequestVerificationHeader)
// attach the previous matryoshka
verifyHdr.SetOrigin(req.GetRequestVerificationHeader())
@ -86,8 +87,8 @@ func SignRequest(key *ecdsa.PrivateKey, req SignedRequest) error {
return nil
}
func signRequestPart(key *ecdsa.PrivateKey, part stableMarshaler, sigWrite func(*v2.Signature)) error {
sig := new(v2.Signature)
func signRequestPart(key *ecdsa.PrivateKey, part stableMarshaler, sigWrite func(*service.Signature)) error {
sig := new(service.Signature)
// sign part
if err := signature.SignDataWithHandler(
@ -125,7 +126,7 @@ func VerifyRequest(req SignedRequest) error {
return nil
}
func verifyRequestPart(part stableMarshaler, sigRdr func() *v2.Signature) error {
func verifyRequestPart(part stableMarshaler, sigRdr func() *service.Signature) error {
if err := signature.VerifyDataWithSource(
&stableMarshalerWrapper{part},
keySignatureSource(sigRdr()),

2
v2/storagegroup/types.go → v2/storagegroup/grpc/types.go
View file

@ -1,7 +1,7 @@
package storagegroup
import (
"github.com/nspcc-dev/neofs-api-go/v2/refs"
refs "github.com/nspcc-dev/neofs-api-go/v2/refs/grpc"
)
// SetValidationDataSize sets the total size of the payloads of the storage group.

56
v2/storagegroup/types.pb.go → v2/storagegroup/grpc/types.pb.go
View file

@ -1,12 +1,12 @@
// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: v2/storagegroup/types.proto
// source: v2/storagegroup/grpc/types.proto
package storagegroup
import (
fmt "fmt"
proto "github.com/golang/protobuf/proto"
refs "github.com/nspcc-dev/neofs-api-go/v2/refs"
grpc "github.com/nspcc-dev/neofs-api-go/v2/refs/grpc"
io "io"
math "math"
math_bits "math/bits"
@ -39,7 +39,7 @@ type StorageGroup struct {
ExpirationEpoch uint64 `protobuf:"varint,3,opt,name=expiration_epoch,json=expirationEpoch,proto3" json:"expiration_epoch,omitempty"`
// Members carries the list of identifiers of the object storage group members.
// The list is strictly ordered.
Members []*refs.ObjectID `protobuf:"bytes,4,rep,name=members,proto3" json:"members,omitempty"`
Members []*grpc.ObjectID `protobuf:"bytes,4,rep,name=members,proto3" json:"members,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
@ -49,7 +49,7 @@ func (m *StorageGroup) Reset() { *m = StorageGroup{} }
func (m *StorageGroup) String() string { return proto.CompactTextString(m) }
func (*StorageGroup) ProtoMessage() {}
func (*StorageGroup) Descriptor() ([]byte, []int) {
return fileDescriptor_593772eae6c18cdf, []int{0}
return fileDescriptor_f1685cc94b670845, []int{0}
}
func (m *StorageGroup) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -99,7 +99,7 @@ func (m *StorageGroup) GetExpirationEpoch() uint64 {
return 0
}
func (m *StorageGroup) GetMembers() []*refs.ObjectID {
func (m *StorageGroup) GetMembers() []*grpc.ObjectID {
if m != nil {
return m.Members
}
@ -110,29 +110,29 @@ func init() {
proto.RegisterType((*StorageGroup)(nil), "neo.fs.v2.storagegroup.StorageGroup")
}
func init() { proto.RegisterFile("v2/storagegroup/types.proto", fileDescriptor_593772eae6c18cdf) }
func init() { proto.RegisterFile("v2/storagegroup/grpc/types.proto", fileDescriptor_f1685cc94b670845) }
var fileDescriptor_593772eae6c18cdf = []byte{
// 297 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x5c, 0x90, 0xdf, 0x4a, 0xc3, 0x30,
0x14, 0xc6, 0xcd, 0x36, 0x14, 0xe2, 0x70, 0x12, 0x45, 0xaa, 0x42, 0x19, 0xde, 0x38, 0x2f, 0x96,
0x48, 0xbd, 0x14, 0x04, 0x65, 0xfe, 0xd9, 0x8d, 0xca, 0x7a, 0xe7, 0xcd, 0x48, 0xdb, 0xd3, 0x36,
0xb2, 0x36, 0x21, 0xc9, 0x8a, 0xee, 0x49, 0x7c, 0x06, 0x9f, 0x64, 0x97, 0x3e, 0x82, 0xd4, 0x17,
0x91, 0x6e, 0x48, 0x8b, 0x97, 0xf9, 0xf2, 0x3b, 0xe7, 0xf0, 0xfd, 0xf0, 0x71, 0xe1, 0x31, 0x63,
0xa5, 0xe6, 0x09, 0x24, 0x5a, 0xce, 0x15, 0xb3, 0xef, 0x0a, 0x0c, 0x55, 0x5a, 0x5a, 0x49, 0x0e,
0x72, 0x90, 0x34, 0x36, 0xb4, 0xf0, 0x68, 0x93, 0x39, 0xda, 0x2b, 0x3c, 0xa6, 0x21, 0x36, 0x4d,
0xf8, 0x64, 0x89, 0x70, 0xd7, 0x5f, 0x53, 0xf7, 0x15, 0x45, 0xce, 0xf1, 0x7e, 0xc1, 0x67, 0x22,
0xe2, 0x56, 0xc8, 0x7c, 0x1a, 0x71, 0xcb, 0xa7, 0x46, 0x2c, 0xc0, 0x41, 0x7d, 0x34, 0xe8, 0x4c,
0x48, 0xfd, 0x37, 0xe2, 0x96, 0xfb, 0x62, 0x01, 0xe4, 0x14, 0xf7, 0x1a, 0x13, 0x29, 0x37, 0xa9,
0xd3, 0xea, 0xa3, 0x41, 0x77, 0xb2, 0x53, 0xc7, 0x0f, 0xdc, 0xa4, 0xe4, 0x0c, 0xef, 0xc2, 0x9b,
0x12, 0x7a, 0x0d, 0x82, 0x92, 0x61, 0xea, 0xb4, 0x57, 0x6b, 0x7b, 0x75, 0x7e, 0x5b, 0xc5, 0xc4,
0xc3, 0x5b, 0x19, 0x64, 0x01, 0x68, 0xe3, 0x74, 0xfa, 0xed, 0xc1, 0xb6, 0xe7, 0xd0, 0xba, 0x55,
0x55, 0x82, 0x3e, 0x05, 0xaf, 0x10, 0xda, 0xf1, 0x68, 0xf2, 0x07, 0xde, 0xcc, 0x96, 0xa5, 0x8b,
0xbe, 0x4a, 0x17, 0x7d, 0x97, 0x2e, 0xfa, 0xf8, 0x71, 0x37, 0x5e, 0xae, 0x12, 0x61, 0xd3, 0x79,
0x40, 0x43, 0x99, 0xb1, 0xdc, 0xa8, 0x30, 0x1c, 0x46, 0x50, 0xb0, 0x1c, 0x64, 0x6c, 0x86, 0x5c,
0x89, 0x61, 0x22, 0xd9, 0x3f, 0x91, 0x97, 0xcd, 0xc7, 0x67, 0xeb, 0xf0, 0x11, 0xe4, 0x9d, 0x4f,
0xaf, 0x9f, 0xc7, 0xd5, 0xdd, 0xa6, 0xa7, 0x60, 0x73, 0xe5, 0xef, 0xe2, 0x37, 0x00, 0x00, 0xff,
0xff, 0xec, 0x24, 0x17, 0x69, 0x8b, 0x01, 0x00, 0x00,
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,
}
func (m *StorageGroup) Marshal() (dAtA []byte, err error) {
@ -368,7 +368,7 @@ func (m *StorageGroup) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Members = append(m.Members, &refs.ObjectID{})
m.Members = append(m.Members, &grpc.ObjectID{})
if err := m.Members[len(m.Members)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}