JakeHillion/storj
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

pkg/pb: rename Order2 to Order, OrderLimit2 to OrderLimit (#2406)

Browse Source
This commit is contained in:
Egon Elbre 2019-07-01 18:54:11 +03:00 committed by GitHub
parent 3ffb42483f
commit 385c046723
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
26 changed files with 279 additions and 279 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
pkg/auth/signing/encode.go
View File

@ -12,7 +12,7 @@ import (
)
// EncodeOrderLimit encodes order limit into bytes for signing. Removes signature from serialized limit.
func EncodeOrderLimit(ctx context.Context, limit *pb.OrderLimit2) (_ []byte, err error) {
func EncodeOrderLimit(ctx context.Context, limit *pb.OrderLimit) (_ []byte, err error) {
defer mon.Task()(&ctx)(&err)
signature := limit.SatelliteSignature
limit.SatelliteSignature = nil
@ -22,7 +22,7 @@ func EncodeOrderLimit(ctx context.Context, limit *pb.OrderLimit2) (_ []byte, err
}
// EncodeOrder encodes order into bytes for signing. Removes signature from serialized order.
func EncodeOrder(ctx context.Context, order *pb.Order2) (_ []byte, err error) {
func EncodeOrder(ctx context.Context, order *pb.Order) (_ []byte, err error) {
defer mon.Task()(&ctx)(&err)
signature := order.UplinkSignature
order.UplinkSignature = nil

4
pkg/auth/signing/sign.go
View File

@ -24,7 +24,7 @@ type Signer interface {
// SignOrderLimit signs the order limit using the specified signer.
// Signer is a satellite.
func SignOrderLimit(ctx context.Context, satellite Signer, unsigned *pb.OrderLimit2) (_ *pb.OrderLimit2, err error) {
func SignOrderLimit(ctx context.Context, satellite Signer, unsigned *pb.OrderLimit) (_ *pb.OrderLimit, err error) {
defer mon.Task()(&ctx)(&err)
bytes, err := EncodeOrderLimit(ctx, unsigned)
if err != nil {
@ -42,7 +42,7 @@ func SignOrderLimit(ctx context.Context, satellite Signer, unsigned *pb.OrderLim
// SignOrder signs the order using the specified signer.
// Signer is an uplink.
func SignOrder(ctx context.Context, uplink Signer, unsigned *pb.Order2) (_ *pb.Order2, err error) {
func SignOrder(ctx context.Context, uplink Signer, unsigned *pb.Order) (_ *pb.Order, err error) {
defer mon.Task()(&ctx)(&err)
bytes, err := EncodeOrder(ctx, unsigned)
if err != nil {

4
pkg/auth/signing/verify.go
View File

@ -17,7 +17,7 @@ type Signee interface {
}
// VerifyOrderLimitSignature verifies that the signature inside order limit belongs to the satellite.
func VerifyOrderLimitSignature(ctx context.Context, satellite Signee, signed *pb.OrderLimit2) (err error) {
func VerifyOrderLimitSignature(ctx context.Context, satellite Signee, signed *pb.OrderLimit) (err error) {
defer mon.Task()(&ctx)(&err)
bytes, err := EncodeOrderLimit(ctx, signed)
if err != nil {
@ -28,7 +28,7 @@ func VerifyOrderLimitSignature(ctx context.Context, satellite Signee, signed *pb
}
// VerifyOrderSignature verifies that the signature inside order belongs to the uplink.
func VerifyOrderSignature(ctx context.Context, uplink Signee, signed *pb.Order2) (err error) {
func VerifyOrderSignature(ctx context.Context, uplink Signee, signed *pb.Order) (err error) {
defer mon.Task()(&ctx)(&err)
bytes, err := EncodeOrder(ctx, signed)
if err != nil {

144
pkg/pb/metainfo.pb.go
View File

@ -25,7 +25,7 @@ var _ = math.Inf
const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
type AddressedOrderLimit struct {
Limit *OrderLimit2 `protobuf:"bytes,1,opt,name=limit,proto3" json:"limit,omitempty"`
Limit *OrderLimit `protobuf:"bytes,1,opt,name=limit,proto3" json:"limit,omitempty"`
StorageNodeAddress *NodeAddress `protobuf:"bytes,2,opt,name=storage_node_address,json=storageNodeAddress,proto3" json:"storage_node_address,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
@ -56,7 +56,7 @@ func (m *AddressedOrderLimit) XXX_DiscardUnknown() {
var xxx_messageInfo_AddressedOrderLimit proto.InternalMessageInfo
func (m *AddressedOrderLimit) GetLimit() *OrderLimit2 {
func (m *AddressedOrderLimit) GetLimit() *OrderLimit {
if m != nil {
return m.Limit
}
@ -188,14 +188,14 @@ func (m *SegmentWriteResponse) GetAddressedLimits() []*AddressedOrderLimit {
}
type SegmentCommitRequest struct {
Bucket []byte `protobuf:"bytes,1,opt,name=bucket,proto3" json:"bucket,omitempty"`
Path []byte `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"`
Segment int64 `protobuf:"varint,3,opt,name=segment,proto3" json:"segment,omitempty"`
Pointer *Pointer `protobuf:"bytes,4,opt,name=pointer,proto3" json:"pointer,omitempty"`
OriginalLimits []*OrderLimit2 `protobuf:"bytes,5,rep,name=original_limits,json=originalLimits,proto3" json:"original_limits,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
Bucket []byte `protobuf:"bytes,1,opt,name=bucket,proto3" json:"bucket,omitempty"`
Path []byte `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"`
Segment int64 `protobuf:"varint,3,opt,name=segment,proto3" json:"segment,omitempty"`
Pointer *Pointer `protobuf:"bytes,4,opt,name=pointer,proto3" json:"pointer,omitempty"`
OriginalLimits []*OrderLimit `protobuf:"bytes,5,rep,name=original_limits,json=originalLimits,proto3" json:"original_limits,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *SegmentCommitRequest) Reset() { *m = SegmentCommitRequest{} }
@ -250,7 +250,7 @@ func (m *SegmentCommitRequest) GetPointer() *Pointer {
return nil
}
func (m *SegmentCommitRequest) GetOriginalLimits() []*OrderLimit2 {
func (m *SegmentCommitRequest) GetOriginalLimits() []*OrderLimit {
if m != nil {
return m.OriginalLimits
}
@ -933,68 +933,68 @@ func init() {
func init() { proto.RegisterFile("metainfo.proto", fileDescriptor_631e2f30a93cd64e) }
var fileDescriptor_631e2f30a93cd64e = []byte{
// 967 bytes of a gzipped FileDescriptorProto
// 965 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x56, 0xdd, 0x6e, 0x1b, 0x45,
0x14, 0x66, 0xed, 0x38, 0x8e, 0x8f, 0x9d, 0x18, 0xc6, 0x26, 0x5d, 0x6d, 0x1b, 0xec, 0x2e, 0x37,
0x41, 0x42, 0xae, 0x94, 0xde, 0x00, 0xe5, 0x26, 0x3f, 0x45, 0x04, 0xb5, 0xc1, 0x5a, 0x23, 0x2a,
0x55, 0x88, 0xd5, 0xd8, 0x7b, 0xec, 0x0e, 0x78, 0x77, 0x96, 0x99, 0x31, 0xa4, 0xbd, 0xe7, 0x01,
0x8a, 0xc4, 0x3b, 0xf5, 0x82, 0x07, 0x40, 0x5c, 0xf4, 0x59, 0xd0, 0xce, 0xcc, 0xda, 0xeb, 0xd8,
0x26, 0x54, 0xf2, 0xdd, 0x9c, 0x33, 0x67, 0xce, 0xcf, 0xf7, 0x1d, 0x7f, 0x6b, 0x38, 0x88, 0x51,
0x51, 0x96, 0x8c, 0x79, 0x2f, 0x15, 0x5c, 0x71, 0xb2, 0x97, 0xdb, 0x1e, 0x4c, 0xf8, 0xc4, 0x7a,
0xbd, 0xce, 0x84, 0xf3, 0xc9, 0x14, 0x1f, 0x68, 0x6b, 0x38, 0x1b, 0x3f, 0x50, 0x2c, 0x46, 0xa9,
0x68, 0x9c, 0xda, 0x00, 0x48, 0x78, 0x84, 0xf6, 0xdc, 0x4c, 0x39, 0x4b, 0x14, 0x8a, 0x68, 0x68,
0x1d, 0x0d, 0x2e, 0x22, 0x14, 0xd2, 0x58, 0xfe, 0xef, 0x0e, 0xb4, 0x4e, 0xa3, 0x48, 0xa0, 0x94,
0x18, 0x7d, 0x9b, 0xdd, 0x3c, 0x61, 0x31, 0x53, 0xe4, 0x13, 0xa8, 0x4c, 0xb3, 0x83, 0xeb, 0x74,
0x9d, 0xe3, 0xfa, 0x49, 0xab, 0x67, 0x5f, 0x2d, 0x42, 0x4e, 0x02, 0x13, 0x41, 0xce, 0xa1, 0x2d,
0x15, 0x17, 0x74, 0x82, 0x61, 0x56, 0x37, 0xa4, 0x26, 0x9d, 0x5b, 0xd2, 0x2f, 0x3f, 0xe8, 0xe9,
0x66, 0xae, 0x78, 0x84, 0xb6, 0x4e, 0x40, 0x6c, 0x78, 0xc1, 0xe7, 0xbf, 0x2e, 0x41, 0x6b, 0x80,
0x93, 0x18, 0x13, 0xf5, 0x4c, 0x30, 0x85, 0x01, 0xfe, 0x32, 0x43, 0xa9, 0xc8, 0x21, 0xec, 0x0e,
0x67, 0xa3, 0x9f, 0xd1, 0x34, 0xd2, 0x08, 0xac, 0x45, 0x08, 0xec, 0xa4, 0x54, 0xbd, 0xd0, 0x45,
0x1a, 0x81, 0x3e, 0x13, 0x17, 0xaa, 0xd2, 0xa4, 0x70, 0xcb, 0x5d, 0xe7, 0xb8, 0x1c, 0xe4, 0x26,
0x79, 0x04, 0x20, 0x30, 0x9a, 0x25, 0x11, 0x4d, 0x46, 0x2f, 0xdd, 0x1d, 0xdd, 0xd8, 0xdd, 0xde,
0x02, 0x99, 0x60, 0x7e, 0x39, 0x18, 0xbd, 0xc0, 0x18, 0x83, 0x42, 0x38, 0x79, 0x04, 0x5e, 0x4c,
0xaf, 0x43, 0x4c, 0x46, 0xe2, 0x65, 0xaa, 0x30, 0x0a, 0x6d, 0xd6, 0x50, 0xb2, 0x57, 0xe8, 0x56,
0x74, 0xa5, 0x3b, 0x31, 0xbd, 0x7e, 0x9c, 0x07, 0xd8, 0x39, 0x06, 0xec, 0x15, 0x92, 0x2f, 0x00,
0xf0, 0x3a, 0x65, 0x82, 0x2a, 0xc6, 0x13, 0x77, 0x57, 0x57, 0xf6, 0x7a, 0x86, 0xc0, 0x5e, 0x4e,
0x60, 0xef, 0xbb, 0x9c, 0xc0, 0xa0, 0x10, 0xed, 0xff, 0xe9, 0x40, 0x7b, 0x19, 0x13, 0x99, 0xf2,
0x44, 0x22, 0xf9, 0x1a, 0xde, 0xa7, 0x39, 0x67, 0xa1, 0x26, 0x41, 0xba, 0x4e, 0xb7, 0x7c, 0x5c,
0x3f, 0x39, 0xea, 0xcd, 0x37, 0x68, 0x0d, 0xab, 0x41, 0x73, 0xfe, 0x4c, 0xdb, 0x92, 0x3c, 0x84,
0x7d, 0xc1, 0xb9, 0x0a, 0x53, 0x86, 0x23, 0x0c, 0x59, 0x64, 0xf0, 0x3c, 0x6b, 0xbe, 0x79, 0xdb,
0x79, 0xef, 0x9f, 0xb7, 0x9d, 0x6a, 0x3f, 0xf3, 0x5f, 0x5e, 0x04, 0xf5, 0x2c, 0xca, 0x18, 0x91,
0xff, 0x66, 0xd1, 0xd7, 0x39, 0x8f, 0xb3, 0xbc, 0x5b, 0x25, 0xeb, 0x53, 0xa8, 0x5a, 0x66, 0x2c,
0x53, 0xa4, 0xc0, 0x54, 0xdf, 0x9c, 0x82, 0x3c, 0x84, 0x7c, 0x09, 0x4d, 0x2e, 0xd8, 0x84, 0x25,
0x74, 0x9a, 0x43, 0x51, 0xd1, 0x50, 0xac, 0x5d, 0xd9, 0x83, 0x3c, 0xd6, 0xcc, 0xef, 0x3f, 0x86,
0x0f, 0x6f, 0x4c, 0x62, 0x21, 0x2e, 0x34, 0xe1, 0xdc, 0xda, 0x84, 0xff, 0x23, 0x1c, 0xda, 0x34,
0x17, 0xfc, 0xb7, 0x64, 0xca, 0x69, 0xb4, 0x55, 0x48, 0xfc, 0xd7, 0x0e, 0xdc, 0x59, 0x29, 0xb0,
0xf5, 0x65, 0x28, 0xcc, 0x5c, 0xba, 0x7d, 0xe6, 0xe7, 0x40, 0x6c, 0x4b, 0x97, 0xc9, 0x98, 0x6f,
0x77, 0xde, 0xf3, 0xb9, 0x18, 0x98, 0xdc, 0xab, 0xa4, 0xfc, 0x8f, 0x06, 0x7f, 0x98, 0x6f, 0xe9,
0x05, 0x4e, 0x71, 0xcb, 0x92, 0xe2, 0xd3, 0xf9, 0xe6, 0xe4, 0xd9, 0xb7, 0xcd, 0x87, 0xff, 0xb7,
0x03, 0xad, 0x27, 0x4c, 0x2a, 0x5b, 0x47, 0xde, 0x36, 0xc0, 0x21, 0xec, 0xa6, 0x02, 0xc7, 0xec,
0xda, 0x8e, 0x60, 0x2d, 0xd2, 0x81, 0xba, 0x54, 0x54, 0xa8, 0x90, 0x8e, 0x33, 0xe8, 0xca, 0xfa,
0x12, 0xb4, 0xeb, 0x34, 0xf3, 0x90, 0x23, 0x00, 0x4c, 0xa2, 0x70, 0x88, 0x63, 0x2e, 0x50, 0xff,
0xe8, 0x1a, 0x41, 0x0d, 0x93, 0xe8, 0x4c, 0x3b, 0xc8, 0x3d, 0xa8, 0x09, 0x1c, 0xcd, 0x84, 0x64,
0xbf, 0x1a, 0xbd, 0xdb, 0x0b, 0x16, 0x0e, 0xd2, 0xce, 0xbf, 0x14, 0x99, 0xb8, 0x55, 0xf2, 0x8f,
0xc2, 0x11, 0x40, 0x36, 0x6c, 0x38, 0x9e, 0xd2, 0x89, 0x74, 0xab, 0x5d, 0xe7, 0xb8, 0x1a, 0xd4,
0x32, 0xcf, 0x57, 0x99, 0xc3, 0xff, 0xcb, 0x81, 0xf6, 0xf2, 0x68, 0x16, 0xbd, 0xcf, 0xa1, 0xc2,
0x14, 0xc6, 0x39, 0x64, 0x1f, 0x2f, 0x20, 0x5b, 0x17, 0xde, 0xbb, 0x54, 0x18, 0x07, 0xe6, 0x45,
0xc6, 0x5f, 0x9c, 0xf5, 0x5f, 0xd2, 0x1d, 0xea, 0xb3, 0x87, 0xb0, 0x93, 0x85, 0xcc, 0xb9, 0x75,
0x0a, 0xdc, 0xbe, 0xd3, 0x36, 0x91, 0xbb, 0x50, 0x63, 0x32, 0xb4, 0xf8, 0x96, 0x75, 0x89, 0x3d,
0x26, 0xfb, 0xda, 0xf6, 0x9f, 0x65, 0xcb, 0xa0, 0x4e, 0x95, 0x12, 0x6c, 0x38, 0xcb, 0xb4, 0x3b,
0xa7, 0xaa, 0x03, 0x75, 0x43, 0x4e, 0x98, 0xd0, 0x18, 0x6d, 0x79, 0x30, 0xae, 0x2b, 0x1a, 0x63,
0x86, 0x53, 0x4a, 0x85, 0x4a, 0x50, 0xcc, 0xd5, 0x37, 0xa8, 0x59, 0xcf, 0x65, 0xe4, 0xbb, 0x99,
0xb0, 0x2c, 0x27, 0x36, 0x93, 0xfb, 0x6d, 0x20, 0x7d, 0xc1, 0x7f, 0xc2, 0x51, 0xf1, 0xe7, 0xe7,
0x7f, 0x06, 0xad, 0x25, 0xaf, 0x45, 0xf5, 0x3e, 0x34, 0x52, 0xe3, 0x0e, 0x25, 0x9d, 0xe6, 0x7b,
0x53, 0xb7, 0xbe, 0x01, 0x9d, 0xaa, 0x93, 0x3f, 0x2a, 0xb0, 0xf7, 0xd4, 0x62, 0x4d, 0xae, 0x60,
0xff, 0x5c, 0x20, 0x55, 0x68, 0x01, 0x27, 0x85, 0xd5, 0x5d, 0xf3, 0x95, 0xf6, 0x3e, 0xda, 0x74,
0x6d, 0xeb, 0xf7, 0x61, 0xdf, 0xe8, 0x6b, 0x9e, 0x6f, 0xf5, 0xc1, 0xd2, 0x97, 0xc4, 0xeb, 0x6c,
0xbc, 0xb7, 0x19, 0xbf, 0x81, 0x7a, 0x41, 0x21, 0xc8, 0xbd, 0x95, 0xf8, 0x02, 0x2a, 0xde, 0xd1,
0x86, 0x5b, 0x9b, 0xeb, 0x7b, 0x68, 0xe6, 0xaa, 0x9a, 0xf7, 0xd7, 0x5d, 0x79, 0x71, 0x43, 0xd8,
0xbd, 0xfb, 0xff, 0x11, 0xb1, 0x98, 0xda, 0x68, 0xc3, 0xe6, 0xa9, 0x97, 0x94, 0x69, 0xcd, 0xd4,
0x37, 0xb4, 0xe5, 0x29, 0x34, 0x8a, 0x3f, 0x83, 0x22, 0x2d, 0x6b, 0x84, 0xa2, 0x48, 0xcb, 0xda,
0x1f, 0xdb, 0x00, 0x0e, 0x96, 0xb7, 0x8b, 0x2c, 0x75, 0xb0, 0x66, 0xa1, 0xbd, 0xee, 0xe6, 0x80,
0x05, 0x33, 0x85, 0x15, 0x2c, 0x32, 0xb3, 0xba, 0xaf, 0x45, 0x66, 0xd6, 0xec, 0xed, 0xd9, 0xce,
0xf3, 0x52, 0x3a, 0x1c, 0xee, 0xea, 0xff, 0x49, 0x0f, 0xff, 0x0d, 0x00, 0x00, 0xff, 0xff, 0x14,
0x86, 0xb1, 0x2d, 0x1e, 0x0b, 0x00, 0x00,
0x14, 0x66, 0xed, 0x38, 0x8e, 0x8f, 0x9d, 0x18, 0x26, 0x26, 0x5d, 0x6d, 0x1b, 0xec, 0x2e, 0x37,
0xbe, 0x40, 0xae, 0x94, 0xde, 0x00, 0xb9, 0xca, 0x4f, 0x11, 0x41, 0x6d, 0xb0, 0xd6, 0x88, 0x4a,
0x15, 0x62, 0x35, 0xf6, 0x1e, 0xbb, 0x03, 0xde, 0x9d, 0x65, 0x66, 0x0c, 0x69, 0xaf, 0x79, 0x81,
0x22, 0xf1, 0x4c, 0x70, 0xc1, 0x03, 0x20, 0x2e, 0xfa, 0x2c, 0x68, 0x67, 0x66, 0xed, 0x75, 0x6c,
0x13, 0x2a, 0xf9, 0x6e, 0xce, 0x99, 0x33, 0xe7, 0xe7, 0xfb, 0x8e, 0xbf, 0x35, 0x1c, 0xc4, 0xa8,
0x28, 0x4b, 0xc6, 0xbc, 0x97, 0x0a, 0xae, 0x38, 0xd9, 0xcb, 0x6d, 0x0f, 0x26, 0x7c, 0x62, 0xbd,
0x5e, 0x7b, 0xc2, 0xf9, 0x64, 0x8a, 0x8f, 0xb4, 0x35, 0x9c, 0x8d, 0x1f, 0x29, 0x16, 0xa3, 0x54,
0x34, 0x4e, 0x6d, 0x00, 0x24, 0x3c, 0x42, 0x7b, 0x6e, 0xa6, 0x9c, 0x25, 0x0a, 0x45, 0x34, 0xb4,
0x8e, 0x06, 0x17, 0x11, 0x0a, 0x69, 0x2c, 0xff, 0x57, 0x07, 0x0e, 0xcf, 0xa2, 0x48, 0xa0, 0x94,
0x18, 0x7d, 0x9d, 0xdd, 0x3c, 0x65, 0x31, 0x53, 0xa4, 0x0b, 0x95, 0x69, 0x76, 0x70, 0x9d, 0x8e,
0xd3, 0xad, 0x9f, 0x90, 0x9e, 0x7d, 0xb5, 0x08, 0x09, 0x4c, 0x00, 0xb9, 0x80, 0x96, 0x54, 0x5c,
0xd0, 0x09, 0x86, 0x59, 0xd9, 0x90, 0x9a, 0x6c, 0x6e, 0x49, 0x3f, 0xfc, 0xa0, 0xa7, 0x7b, 0xb9,
0xe6, 0x11, 0xda, 0x32, 0x01, 0xb1, 0xe1, 0x05, 0x9f, 0xff, 0xa6, 0x04, 0x87, 0x03, 0x9c, 0xc4,
0x98, 0xa8, 0xe7, 0x82, 0x29, 0x0c, 0xf0, 0xa7, 0x19, 0x4a, 0x45, 0x8e, 0x60, 0x77, 0x38, 0x1b,
0xfd, 0x88, 0xa6, 0x8f, 0x46, 0x60, 0x2d, 0x42, 0x60, 0x27, 0xa5, 0xea, 0xa5, 0x2e, 0xd2, 0x08,
0xf4, 0x99, 0xb8, 0x50, 0x95, 0x26, 0x85, 0x5b, 0xee, 0x38, 0xdd, 0x72, 0x90, 0x9b, 0xe4, 0x14,
0x40, 0x60, 0x34, 0x4b, 0x22, 0x9a, 0x8c, 0x5e, 0xb9, 0x3b, 0xba, 0xb1, 0xfb, 0xbd, 0x05, 0x30,
0xc1, 0xfc, 0x72, 0x30, 0x7a, 0x89, 0x31, 0x06, 0x85, 0x70, 0x72, 0x0a, 0x5e, 0x4c, 0x6f, 0x42,
0x4c, 0x46, 0xe2, 0x55, 0xaa, 0x30, 0x0a, 0x6d, 0xd6, 0x50, 0xb2, 0xd7, 0xe8, 0x56, 0x74, 0xa5,
0x7b, 0x31, 0xbd, 0x79, 0x92, 0x07, 0xd8, 0x39, 0x06, 0xec, 0x35, 0x92, 0xcf, 0x01, 0xf0, 0x26,
0x65, 0x82, 0x2a, 0xc6, 0x13, 0x77, 0x57, 0x57, 0xf6, 0x7a, 0x86, 0xbf, 0x5e, 0xce, 0x5f, 0xef,
0x9b, 0x9c, 0xbf, 0xa0, 0x10, 0xed, 0xff, 0xee, 0x40, 0x6b, 0x19, 0x13, 0x99, 0xf2, 0x44, 0x22,
0xf9, 0x12, 0xde, 0xa7, 0x39, 0x65, 0xa1, 0x26, 0x41, 0xba, 0x4e, 0xa7, 0xdc, 0xad, 0x9f, 0x1c,
0xf7, 0xe6, 0x0b, 0xb4, 0x86, 0xd4, 0xa0, 0x39, 0x7f, 0xa6, 0x6d, 0x49, 0x1e, 0xc3, 0xbe, 0xe0,
0x5c, 0x85, 0x29, 0xc3, 0x11, 0x86, 0x2c, 0x32, 0x78, 0x9e, 0x37, 0xff, 0x7c, 0xdb, 0x7e, 0xef,
0x9f, 0xb7, 0xed, 0x6a, 0x3f, 0xf3, 0x5f, 0x5d, 0x06, 0xf5, 0x2c, 0xca, 0x18, 0x91, 0xff, 0xc7,
0xa2, 0xaf, 0x0b, 0x1e, 0x67, 0x79, 0xb7, 0x4a, 0xd6, 0x27, 0x50, 0xb5, 0xcc, 0x58, 0xa6, 0x48,
0x81, 0xa9, 0xbe, 0x39, 0x05, 0x79, 0x08, 0x39, 0x85, 0x26, 0x17, 0x6c, 0xc2, 0x12, 0x3a, 0xcd,
0xa1, 0xa8, 0x68, 0x28, 0xd6, 0x6d, 0xec, 0x41, 0x1e, 0x6a, 0xc6, 0xf7, 0x9f, 0xc0, 0x87, 0xb7,
0x06, 0xb1, 0x08, 0x17, 0x7a, 0x70, 0xee, 0xec, 0xc1, 0xff, 0x1e, 0x8e, 0x6c, 0x9a, 0x4b, 0xfe,
0x4b, 0x32, 0xe5, 0x34, 0xda, 0x2a, 0x22, 0xfe, 0x1b, 0x07, 0xee, 0xad, 0x14, 0xd8, 0xfa, 0x2e,
0x14, 0x66, 0x2e, 0xdd, 0x3d, 0xf3, 0x0b, 0x20, 0xb6, 0xa5, 0xab, 0x64, 0xcc, 0xb7, 0x3b, 0xef,
0xc5, 0x5c, 0x0b, 0x4c, 0xee, 0x55, 0x52, 0xfe, 0x47, 0x83, 0xdf, 0xcd, 0x97, 0xf4, 0x12, 0xa7,
0xb8, 0x65, 0x45, 0xf1, 0xe9, 0x7c, 0x73, 0xf2, 0xec, 0xdb, 0xe6, 0xc3, 0xff, 0xdb, 0x81, 0xc3,
0xa7, 0x4c, 0x2a, 0x5b, 0x47, 0xde, 0x35, 0xc0, 0x11, 0xec, 0xa6, 0x02, 0xc7, 0xec, 0xc6, 0x8e,
0x60, 0x2d, 0xd2, 0x86, 0xba, 0x54, 0x54, 0xa8, 0x90, 0x8e, 0x33, 0xe8, 0xca, 0xfa, 0x12, 0xb4,
0xeb, 0x2c, 0xf3, 0x90, 0x63, 0x00, 0x4c, 0xa2, 0x70, 0x88, 0x63, 0x2e, 0x50, 0xff, 0xe6, 0x1a,
0x41, 0x0d, 0x93, 0xe8, 0x5c, 0x3b, 0xc8, 0x03, 0xa8, 0x09, 0x1c, 0xcd, 0x84, 0x64, 0x3f, 0x1b,
0xb9, 0xdb, 0x0b, 0x16, 0x0e, 0xd2, 0xca, 0xbf, 0x13, 0x99, 0xb6, 0x55, 0xf2, 0x6f, 0xc2, 0x31,
0x40, 0x36, 0x6c, 0x38, 0x9e, 0xd2, 0x89, 0x74, 0xab, 0x1d, 0xa7, 0x5b, 0x0d, 0x6a, 0x99, 0xe7,
0x8b, 0xcc, 0xe1, 0xff, 0xe5, 0x40, 0x6b, 0x79, 0x34, 0x8b, 0xde, 0x67, 0x50, 0x61, 0x0a, 0xe3,
0x1c, 0xb2, 0x8f, 0x17, 0x90, 0xad, 0x0b, 0xef, 0x5d, 0x29, 0x8c, 0x03, 0xf3, 0x22, 0xe3, 0x2f,
0xce, 0xfa, 0x2f, 0xe9, 0x0e, 0xf5, 0xd9, 0x43, 0xd8, 0xc9, 0x42, 0xe6, 0xdc, 0x3a, 0x05, 0x6e,
0xdf, 0x69, 0x9b, 0xc8, 0x7d, 0xa8, 0x31, 0x19, 0x5a, 0x7c, 0xcb, 0xba, 0xc4, 0x1e, 0x93, 0x7d,
0x6d, 0xfb, 0xcf, 0xb3, 0x65, 0x50, 0x67, 0x4a, 0x09, 0x36, 0x9c, 0x65, 0xd2, 0x9d, 0x53, 0xd5,
0x86, 0xba, 0x21, 0x27, 0x4c, 0x68, 0x8c, 0xb6, 0x3c, 0x18, 0xd7, 0x35, 0x8d, 0x31, 0xc3, 0x29,
0xa5, 0x42, 0x25, 0x28, 0xe6, 0xe2, 0x1b, 0xd4, 0xac, 0xe7, 0x2a, 0xf2, 0xdd, 0x4c, 0x58, 0x96,
0x13, 0x9b, 0xc9, 0xfd, 0x16, 0x90, 0xbe, 0xe0, 0x3f, 0xe0, 0xa8, 0xf8, 0xf3, 0xf3, 0x3f, 0x85,
0xc3, 0x25, 0xaf, 0x45, 0xf5, 0x21, 0x34, 0x52, 0xe3, 0x0e, 0x25, 0x9d, 0xe6, 0x7b, 0x53, 0xb7,
0xbe, 0x01, 0x9d, 0xaa, 0x93, 0xdf, 0x2a, 0xb0, 0xf7, 0xcc, 0x62, 0x4d, 0xae, 0x61, 0xff, 0x42,
0x20, 0x55, 0x68, 0x01, 0x27, 0x85, 0xd5, 0x5d, 0xf3, 0x91, 0xf6, 0x3e, 0xda, 0x74, 0x6d, 0xeb,
0xf7, 0x61, 0xdf, 0xe8, 0x6b, 0x9e, 0x6f, 0xf5, 0xc1, 0xd2, 0x87, 0xc4, 0x6b, 0x6f, 0xbc, 0xb7,
0x19, 0xbf, 0x82, 0x7a, 0x41, 0x21, 0xc8, 0x83, 0x95, 0xf8, 0x02, 0x2a, 0xde, 0xf1, 0x86, 0x5b,
0x9b, 0xeb, 0x5b, 0x68, 0xe6, 0xaa, 0x9a, 0xf7, 0xd7, 0x59, 0x79, 0x71, 0x4b, 0xd8, 0xbd, 0x87,
0xff, 0x11, 0xb1, 0x98, 0xda, 0x68, 0xc3, 0xe6, 0xa9, 0x97, 0x94, 0x69, 0xcd, 0xd4, 0xb7, 0xb4,
0xe5, 0x19, 0x34, 0x8a, 0x3f, 0x83, 0x22, 0x2d, 0x6b, 0x84, 0xa2, 0x48, 0xcb, 0xda, 0x1f, 0xdb,
0x00, 0x0e, 0x96, 0xb7, 0x8b, 0x2c, 0x75, 0xb0, 0x66, 0xa1, 0xbd, 0xce, 0xe6, 0x80, 0x05, 0x33,
0x85, 0x15, 0x2c, 0x32, 0xb3, 0xba, 0xaf, 0x45, 0x66, 0xd6, 0xec, 0xed, 0xf9, 0xce, 0x8b, 0x52,
0x3a, 0x1c, 0xee, 0xea, 0xbf, 0x49, 0x8f, 0xff, 0x0d, 0x00, 0x00, 0xff, 0xff, 0x06, 0xec, 0x5b,
0x84, 0x1c, 0x0b, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.

4
pkg/pb/metainfo.proto
View File

@ -25,7 +25,7 @@ service Metainfo {
}
message AddressedOrderLimit {
orders.OrderLimit2 limit = 1;
orders.OrderLimit limit = 1;
node.NodeAddress storage_node_address = 2;
}
@ -48,7 +48,7 @@ message SegmentCommitRequest {
bytes path = 2;
int64 segment = 3;
pointerdb.Pointer pointer = 4;
repeated orders.OrderLimit2 original_limits = 5;
repeated orders.OrderLimit original_limits = 5;
}
message SegmentCommitResponse {

184
pkg/pb/orders.pb.go
View File

@ -93,8 +93,8 @@ func (SettlementResponse_Status) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_e0f5d4cf0fc9e41b, []int{4, 0}
}
// OrderLimit2 is provided by satellite to execute specific action on storage node within some limits
type OrderLimit2 struct {
// OrderLimit is provided by satellite to execute specific action on storage node within some limits
type OrderLimit struct {
// unique serial to avoid replay attacks
SerialNumber SerialNumber `protobuf:"bytes,1,opt,name=serial_number,json=serialNumber,proto3,customtype=SerialNumber" json:"serial_number"`
// satellite who issued this order limit allowing orderer to do the specified action
@ -119,74 +119,74 @@ type OrderLimit2 struct {
XXX_sizecache int32 `json:"-"`
}
func (m *OrderLimit2) Reset() { *m = OrderLimit2{} }
func (m *OrderLimit2) String() string { return proto.CompactTextString(m) }
func (*OrderLimit2) ProtoMessage() {}
func (*OrderLimit2) Descriptor() ([]byte, []int) {
func (m *OrderLimit) Reset() { *m = OrderLimit{} }
func (m *OrderLimit) String() string { return proto.CompactTextString(m) }
func (*OrderLimit) ProtoMessage() {}
func (*OrderLimit) Descriptor() ([]byte, []int) {
return fileDescriptor_e0f5d4cf0fc9e41b, []int{0}
}
func (m *OrderLimit2) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_OrderLimit2.Unmarshal(m, b)
func (m *OrderLimit) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_OrderLimit.Unmarshal(m, b)
}
func (m *OrderLimit2) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_OrderLimit2.Marshal(b, m, deterministic)
func (m *OrderLimit) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_OrderLimit.Marshal(b, m, deterministic)
}
func (m *OrderLimit2) XXX_Merge(src proto.Message) {
xxx_messageInfo_OrderLimit2.Merge(m, src)
func (m *OrderLimit) XXX_Merge(src proto.Message) {
xxx_messageInfo_OrderLimit.Merge(m, src)
}
func (m *OrderLimit2) XXX_Size() int {
return xxx_messageInfo_OrderLimit2.Size(m)
func (m *OrderLimit) XXX_Size() int {
return xxx_messageInfo_OrderLimit.Size(m)
}
func (m *OrderLimit2) XXX_DiscardUnknown() {
xxx_messageInfo_OrderLimit2.DiscardUnknown(m)
func (m *OrderLimit) XXX_DiscardUnknown() {
xxx_messageInfo_OrderLimit.DiscardUnknown(m)
}
var xxx_messageInfo_OrderLimit2 proto.InternalMessageInfo
var xxx_messageInfo_OrderLimit proto.InternalMessageInfo
func (m *OrderLimit2) GetLimit() int64 {
func (m *OrderLimit) GetLimit() int64 {
if m != nil {
return m.Limit
}
return 0
}
func (m *OrderLimit2) GetAction() PieceAction {
func (m *OrderLimit) GetAction() PieceAction {
if m != nil {
return m.Action
}
return PieceAction_INVALID
}
func (m *OrderLimit2) GetPieceExpiration() *timestamp.Timestamp {
func (m *OrderLimit) GetPieceExpiration() *timestamp.Timestamp {
if m != nil {
return m.PieceExpiration
}
return nil
}
func (m *OrderLimit2) GetOrderExpiration() *timestamp.Timestamp {
func (m *OrderLimit) GetOrderExpiration() *timestamp.Timestamp {
if m != nil {
return m.OrderExpiration
}
return nil
}
func (m *OrderLimit2) GetSatelliteSignature() []byte {
func (m *OrderLimit) GetSatelliteSignature() []byte {
if m != nil {
return m.SatelliteSignature
}
return nil
}
func (m *OrderLimit2) GetSatelliteAddress() *NodeAddress {
func (m *OrderLimit) GetSatelliteAddress() *NodeAddress {
if m != nil {
return m.SatelliteAddress
}
return nil
}
// Order2 is a one step of fullfilling Amount number of bytes from an OrderLimit2 with SerialNumber
type Order2 struct {
// Order is a one step of fullfilling Amount number of bytes from an OrderLimit with SerialNumber
type Order struct {
// serial of the order limit that was signed
SerialNumber SerialNumber `protobuf:"bytes,1,opt,name=serial_number,json=serialNumber,proto3,customtype=SerialNumber" json:"serial_number"`
// amount to be signed for
@ -198,38 +198,38 @@ type Order2 struct {
XXX_sizecache int32 `json:"-"`
}
func (m *Order2) Reset() { *m = Order2{} }
func (m *Order2) String() string { return proto.CompactTextString(m) }
func (*Order2) ProtoMessage() {}
func (*Order2) Descriptor() ([]byte, []int) {
func (m *Order) Reset() { *m = Order{} }
func (m *Order) String() string { return proto.CompactTextString(m) }
func (*Order) ProtoMessage() {}
func (*Order) Descriptor() ([]byte, []int) {
return fileDescriptor_e0f5d4cf0fc9e41b, []int{1}
}
func (m *Order2) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Order2.Unmarshal(m, b)
func (m *Order) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Order.Unmarshal(m, b)
}
func (m *Order2) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Order2.Marshal(b, m, deterministic)
func (m *Order) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Order.Marshal(b, m, deterministic)
}
func (m *Order2) XXX_Merge(src proto.Message) {
xxx_messageInfo_Order2.Merge(m, src)
func (m *Order) XXX_Merge(src proto.Message) {
xxx_messageInfo_Order.Merge(m, src)
}
func (m *Order2) XXX_Size() int {
return xxx_messageInfo_Order2.Size(m)
func (m *Order) XXX_Size() int {
return xxx_messageInfo_Order.Size(m)
}
func (m *Order2) XXX_DiscardUnknown() {
xxx_messageInfo_Order2.DiscardUnknown(m)
func (m *Order) XXX_DiscardUnknown() {
xxx_messageInfo_Order.DiscardUnknown(m)
}
var xxx_messageInfo_Order2 proto.InternalMessageInfo
var xxx_messageInfo_Order proto.InternalMessageInfo
func (m *Order2) GetAmount() int64 {
func (m *Order) GetAmount() int64 {
if m != nil {
return m.Amount
}
return 0
}
func (m *Order2) GetUplinkSignature() []byte {
func (m *Order) GetUplinkSignature() []byte {
if m != nil {
return m.UplinkSignature
}
@ -287,11 +287,11 @@ func (m *PieceHash) GetSignature() []byte {
}
type SettlementRequest struct {
Limit *OrderLimit2 `protobuf:"bytes,1,opt,name=limit,proto3" json:"limit,omitempty"`
Order *Order2 `protobuf:"bytes,2,opt,name=order,proto3" json:"order,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
Limit *OrderLimit `protobuf:"bytes,1,opt,name=limit,proto3" json:"limit,omitempty"`
Order *Order `protobuf:"bytes,2,opt,name=order,proto3" json:"order,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *SettlementRequest) Reset() { *m = SettlementRequest{} }
@ -318,14 +318,14 @@ func (m *SettlementRequest) XXX_DiscardUnknown() {
var xxx_messageInfo_SettlementRequest proto.InternalMessageInfo
func (m *SettlementRequest) GetLimit() *OrderLimit2 {
func (m *SettlementRequest) GetLimit() *OrderLimit {
if m != nil {
return m.Limit
}
return nil
}
func (m *SettlementRequest) GetOrder() *Order2 {
func (m *SettlementRequest) GetOrder() *Order {
if m != nil {
return m.Order
}
@ -374,8 +374,8 @@ func (m *SettlementResponse) GetStatus() SettlementResponse_Status {
func init() {
proto.RegisterEnum("orders.PieceAction", PieceAction_name, PieceAction_value)
proto.RegisterEnum("orders.SettlementResponse_Status", SettlementResponse_Status_name, SettlementResponse_Status_value)
proto.RegisterType((*OrderLimit2)(nil), "orders.OrderLimit2")
proto.RegisterType((*Order2)(nil), "orders.Order2")
proto.RegisterType((*OrderLimit)(nil), "orders.OrderLimit")
proto.RegisterType((*Order)(nil), "orders.Order")
proto.RegisterType((*PieceHash)(nil), "orders.PieceHash")
proto.RegisterType((*SettlementRequest)(nil), "orders.SettlementRequest")
proto.RegisterType((*SettlementResponse)(nil), "orders.SettlementResponse")
@ -386,47 +386,47 @@ func init() { proto.RegisterFile("orders.proto", fileDescriptor_e0f5d4cf0fc9e41b
var fileDescriptor_e0f5d4cf0fc9e41b = []byte{
// 667 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x53, 0xcd, 0x6e, 0xd3, 0x40,
0x10, 0xae, 0xf3, 0xe3, 0x24, 0x93, 0x34, 0x71, 0xb7, 0x15, 0x0a, 0x11, 0x52, 0x83, 0xc5, 0x21,
0xb4, 0x92, 0x4b, 0x8d, 0x84, 0xd4, 0x0b, 0x52, 0xda, 0x58, 0xc5, 0xa8, 0x2a, 0xd1, 0xc6, 0xe5,
0xc0, 0x25, 0x72, 0xea, 0xc5, 0xb5, 0x70, 0x6c, 0xe3, 0x5d, 0x4b, 0x3c, 0x01, 0x6f, 0xc5, 0x9d,
0x13, 0x0f, 0xc0, 0xa1, 0xcf, 0x82, 0x76, 0xec, 0x38, 0x29, 0x14, 0xf5, 0xd0, 0x9b, 0xbf, 0x99,
0xef, 0x9b, 0xf1, 0xcc, 0x7c, 0x0b, 0x9d, 0x38, 0xf5, 0x58, 0xca, 0x8d, 0x24, 0x8d, 0x45, 0x4c,
0xd4, 0x1c, 0x0d, 0xc0, 0x8f, 0xfd, 0x38, 0x8f, 0x0d, 0xf6, 0xfd, 0x38, 0xf6, 0x43, 0x76, 0x84,
0x68, 0x91, 0x7d, 0x3e, 0x12, 0xc1, 0x92, 0x71, 0xe1, 0x2e, 0x93, 0x82, 0x00, 0x51, 0xec, 0xb1,
0xfc, 0x5b, 0xff, 0x55, 0x83, 0xf6, 0x07, 0x59, 0xe3, 0x22, 0x58, 0x06, 0xc2, 0x24, 0x27, 0xb0,
0xcd, 0x59, 0x1a, 0xb8, 0xe1, 0x3c, 0xca, 0x96, 0x0b, 0x96, 0xf6, 0x95, 0xa1, 0x32, 0xea, 0x9c,
0xee, 0xfd, 0xbc, 0xdd, 0xdf, 0xfa, 0x7d, 0xbb, 0xdf, 0x99, 0x61, 0xf2, 0x12, 0x73, 0xb4, 0xc3,
0x37, 0x10, 0x39, 0x86, 0x0e, 0x77, 0x05, 0x0b, 0xc3, 0x40, 0xb0, 0x79, 0xe0, 0xf5, 0x2b, 0xa8,
0xec, 0x16, 0x4a, 0xf5, 0x32, 0xf6, 0x98, 0x3d, 0xa1, 0xed, 0x92, 0x63, 0x7b, 0xe4, 0x10, 0x5a,
0x59, 0x12, 0x06, 0xd1, 0x17, 0xc9, 0xaf, 0xde, 0xcb, 0x6f, 0xe6, 0x04, 0xdb, 0x23, 0x6f, 0xa0,
0xc7, 0x45, 0x9c, 0xba, 0x3e, 0x9b, 0xcb, 0x01, 0xa4, 0xa4, 0x76, 0xaf, 0x64, 0xbb, 0xa0, 0x21,
0xf4, 0xc8, 0x01, 0x34, 0x93, 0x80, 0x5d, 0xa3, 0xa0, 0x8e, 0x82, 0x5e, 0x21, 0x68, 0x4c, 0x65,
0xdc, 0x9e, 0xd0, 0x06, 0x12, 0x6c, 0x8f, 0xec, 0x41, 0x3d, 0x94, 0x8b, 0xe8, 0xab, 0x43, 0x65,
0x54, 0xa5, 0x39, 0x20, 0x87, 0xa0, 0xba, 0xd7, 0x22, 0x88, 0xa3, 0x7e, 0x63, 0xa8, 0x8c, 0xba,
0xe6, 0xae, 0x51, 0x1c, 0x01, 0xf5, 0x63, 0x4c, 0xd1, 0x82, 0x42, 0x2c, 0xd0, 0xf2, 0x76, 0xec,
0x5b, 0x12, 0xa4, 0x2e, 0xca, 0x9a, 0x43, 0x65, 0xd4, 0x36, 0x07, 0x46, 0x7e, 0x19, 0x63, 0x75,
0x19, 0xc3, 0x59, 0x5d, 0x86, 0xf6, 0x50, 0x63, 0x95, 0x12, 0x59, 0x06, 0x9b, 0x6c, 0x96, 0x69,
0x3d, 0x5c, 0x06, 0x35, 0x1b, 0x65, 0x8e, 0x60, 0x77, 0x7d, 0x14, 0x1e, 0xf8, 0x91, 0x2b, 0xb2,
0x94, 0xf5, 0x41, 0xee, 0x81, 0x92, 0x32, 0x35, 0x5b, 0x65, 0xc8, 0x5b, 0xd8, 0x59, 0x0b, 0x5c,
0xcf, 0x4b, 0x19, 0xe7, 0xfd, 0x36, 0x36, 0xde, 0x31, 0xd0, 0x38, 0x72, 0xad, 0xe3, 0x3c, 0x41,
0xb5, 0x92, 0x5b, 0x44, 0xf4, 0xef, 0x0a, 0xa8, 0x68, 0xa8, 0x47, 0x79, 0xe9, 0x09, 0xa8, 0xee,
0x32, 0xce, 0x22, 0x81, 0x2e, 0xaa, 0xd2, 0x02, 0x91, 0x97, 0xa0, 0x15, 0x86, 0x59, 0xcf, 0x82,
0xbe, 0xa1, 0xbd, 0x3c, 0x5e, 0x0e, 0xa2, 0x07, 0xd0, 0xc2, 0xf3, 0xbc, 0x73, 0xf9, 0xcd, 0x1d,
0x0f, 0x28, 0x0f, 0x78, 0x80, 0x40, 0xed, 0xc6, 0xe5, 0x37, 0xb9, 0x7f, 0x29, 0x7e, 0x93, 0x67,
0xd0, 0xfa, 0xbb, 0xe1, 0x3a, 0xa0, 0x7b, 0xb0, 0x33, 0x63, 0x42, 0x84, 0x6c, 0xc9, 0x22, 0x41,
0xd9, 0xd7, 0x8c, 0x71, 0xf9, 0xab, 0x85, 0x95, 0x14, 0x5c, 0x5e, 0xe9, 0x99, 0x8d, 0xd7, 0xb6,
0xf2, 0xd7, 0x0b, 0xa8, 0x63, 0x12, 0x5b, 0xb6, 0xcd, 0xee, 0x1d, 0xaa, 0x49, 0xf3, 0xa4, 0xfe,
0x43, 0x01, 0xb2, 0xd9, 0x86, 0x27, 0x71, 0xc4, 0xd9, 0x63, 0xb6, 0x7c, 0x02, 0x2a, 0x17, 0xae,
0xc8, 0x38, 0x36, 0xee, 0x9a, 0xcf, 0x57, 0x8d, 0xff, 0x6d, 0x63, 0xcc, 0x90, 0x48, 0x0b, 0x81,
0x7e, 0x0c, 0x6a, 0x1e, 0x21, 0x6d, 0x68, 0xd8, 0x97, 0x1f, 0xc7, 0x17, 0xf6, 0x44, 0xdb, 0x22,
0x1d, 0x68, 0x8e, 0xcf, 0xce, 0xac, 0xa9, 0x63, 0x4d, 0x34, 0x45, 0x22, 0x6a, 0xbd, 0xb7, 0xce,
0x24, 0xaa, 0x1c, 0xf8, 0xd0, 0xde, 0x78, 0x2f, 0x77, 0x75, 0x0d, 0xa8, 0x4e, 0xaf, 0x1c, 0x4d,
0x91, 0x1f, 0xe7, 0x96, 0xa3, 0x55, 0xc8, 0x36, 0xb4, 0xce, 0x2d, 0x67, 0x3e, 0xbe, 0x9a, 0xd8,
0x8e, 0x56, 0x25, 0x5d, 0x00, 0x09, 0xa9, 0x35, 0x1d, 0xdb, 0x54, 0xab, 0x49, 0x3c, 0xbd, 0x2a,
0x71, 0x9d, 0x00, 0xa8, 0x13, 0xeb, 0xc2, 0x72, 0x2c, 0x4d, 0x35, 0x67, 0x85, 0x03, 0x39, 0xb1,
0x01, 0xd6, 0xa3, 0x90, 0xa7, 0xf7, 0x8d, 0x87, 0xc7, 0x1a, 0x0c, 0xfe, 0x3f, 0xb9, 0xbe, 0x35,
0x52, 0x5e, 0x29, 0xa7, 0xb5, 0x4f, 0x95, 0x64, 0xb1, 0x50, 0xf1, 0xcd, 0xbd, 0xfe, 0x13, 0x00,
0x00, 0xff, 0xff, 0xab, 0x0a, 0xc7, 0x5c, 0x86, 0x05, 0x00, 0x00,
0x10, 0xae, 0xf3, 0xe3, 0x24, 0x93, 0x3f, 0x77, 0x5b, 0xa1, 0x10, 0x21, 0x35, 0x98, 0x4b, 0x68,
0x25, 0x97, 0x06, 0x09, 0xa9, 0x17, 0xa4, 0xb4, 0xb1, 0x8a, 0x51, 0x55, 0xa2, 0x8d, 0xcb, 0x81,
0x4b, 0xe4, 0xd4, 0x8b, 0x6b, 0xe1, 0xd8, 0xc6, 0xbb, 0x96, 0x78, 0x01, 0x1e, 0x8b, 0x3b, 0x17,
0x5e, 0x80, 0x43, 0x9f, 0x05, 0xed, 0xd8, 0x4e, 0x52, 0x08, 0xea, 0xa1, 0x37, 0x7f, 0x33, 0xdf,
0x37, 0xe3, 0x99, 0xf9, 0x16, 0x5a, 0x51, 0xe2, 0xb2, 0x84, 0x1b, 0x71, 0x12, 0x89, 0x88, 0xa8,
0x19, 0xea, 0x83, 0x17, 0x79, 0x51, 0x16, 0xeb, 0x1f, 0x78, 0x51, 0xe4, 0x05, 0xec, 0x18, 0xd1,
0x22, 0xfd, 0x7c, 0x2c, 0xfc, 0x25, 0xe3, 0xc2, 0x59, 0xc6, 0x39, 0x01, 0xc2, 0xc8, 0x65, 0xd9,
0xb7, 0xfe, 0xab, 0x02, 0xf0, 0x41, 0xd6, 0xb8, 0xf4, 0x97, 0xbe, 0x20, 0xa7, 0xd0, 0xe6, 0x2c,
0xf1, 0x9d, 0x60, 0x1e, 0xa6, 0xcb, 0x05, 0x4b, 0x7a, 0xca, 0x40, 0x19, 0xb6, 0xce, 0xf6, 0x7f,
0xde, 0x1d, 0xec, 0xfc, 0xbe, 0x3b, 0x68, 0xcd, 0x30, 0x79, 0x85, 0x39, 0xda, 0xe2, 0x1b, 0x88,
0x9c, 0x40, 0x8b, 0x3b, 0x82, 0x05, 0x81, 0x2f, 0xd8, 0xdc, 0x77, 0x7b, 0x25, 0x54, 0x76, 0x72,
0xa5, 0x7a, 0x15, 0xb9, 0xcc, 0x9a, 0xd0, 0xe6, 0x8a, 0x63, 0xb9, 0xe4, 0x08, 0x1a, 0x69, 0x1c,
0xf8, 0xe1, 0x17, 0xc9, 0x2f, 0x6f, 0xe5, 0xd7, 0x33, 0x82, 0xe5, 0x92, 0x37, 0xd0, 0xe5, 0x22,
0x4a, 0x1c, 0x8f, 0xcd, 0xe5, 0xff, 0x4b, 0x49, 0x65, 0xab, 0xa4, 0x9d, 0xd3, 0x10, 0xba, 0xe4,
0x10, 0xea, 0xb1, 0xcf, 0x6e, 0x50, 0x50, 0x45, 0x41, 0x37, 0x17, 0xd4, 0xa6, 0x32, 0x6e, 0x4d,
0x68, 0x0d, 0x09, 0x96, 0x4b, 0xf6, 0xa1, 0x1a, 0xc8, 0x3d, 0xf4, 0xd4, 0x81, 0x32, 0x2c, 0xd3,
0x0c, 0x90, 0x23, 0x50, 0x9d, 0x1b, 0xe1, 0x47, 0x61, 0xaf, 0x36, 0x50, 0x86, 0x9d, 0xd1, 0x9e,
0x91, 0xdf, 0x00, 0xf5, 0x63, 0x4c, 0xd1, 0x9c, 0x42, 0x4c, 0xd0, 0xb2, 0x76, 0xec, 0x5b, 0xec,
0x27, 0x0e, 0xca, 0xea, 0x03, 0x65, 0xd8, 0x1c, 0xf5, 0x8d, 0xec, 0x30, 0x46, 0x71, 0x18, 0xc3,
0x2e, 0x0e, 0x43, 0xbb, 0xa8, 0x31, 0x57, 0x12, 0x59, 0x06, 0x9b, 0x6c, 0x96, 0x69, 0x3c, 0x5c,
0x06, 0x35, 0x1b, 0x65, 0x8e, 0x61, 0x6f, 0x7d, 0x14, 0xee, 0x7b, 0xa1, 0x23, 0xd2, 0x84, 0xf5,
0x40, 0xee, 0x81, 0x92, 0x55, 0x6a, 0x56, 0x64, 0xc8, 0x5b, 0xd8, 0x5d, 0x0b, 0x1c, 0xd7, 0x4d,
0x18, 0xe7, 0xbd, 0x26, 0x36, 0xde, 0x35, 0xd0, 0x37, 0x72, 0xad, 0xe3, 0x2c, 0x41, 0xb5, 0x15,
0x37, 0x8f, 0xe8, 0xdf, 0x15, 0xa8, 0xa2, 0x9f, 0x1e, 0x63, 0xa5, 0x27, 0xa0, 0x3a, 0xcb, 0x28,
0x0d, 0x05, 0x9a, 0xa8, 0x4c, 0x73, 0x44, 0x5e, 0x82, 0x96, 0xfb, 0x65, 0x3d, 0x0a, 0xda, 0x86,
0x76, 0xb3, 0xf8, 0x6a, 0x0e, 0xdd, 0x87, 0x06, 0x5e, 0xe7, 0x9d, 0xc3, 0x6f, 0xef, 0x59, 0x40,
0x79, 0xc0, 0x02, 0x04, 0x2a, 0xb7, 0x0e, 0xbf, 0xcd, 0xec, 0x4b, 0xf1, 0x9b, 0x3c, 0x83, 0xc6,
0xdf, 0x0d, 0xd7, 0x01, 0x7d, 0x01, 0xbb, 0x33, 0x26, 0x44, 0xc0, 0x96, 0x2c, 0x14, 0x94, 0x7d,
0x4d, 0x19, 0x17, 0x64, 0x58, 0x38, 0x49, 0xc1, 0xdd, 0x91, 0xc2, 0x32, 0xeb, 0xb7, 0x56, 0xb8,
0xeb, 0x05, 0x54, 0x31, 0x87, 0x1d, 0x9b, 0xa3, 0xf6, 0x3d, 0x26, 0xcd, 0x72, 0xfa, 0x0f, 0x05,
0xc8, 0x66, 0x13, 0x1e, 0x47, 0x21, 0x67, 0x8f, 0xd9, 0xf1, 0x29, 0xa8, 0x5c, 0x38, 0x22, 0xe5,
0xd8, 0xb7, 0x33, 0x7a, 0x5e, 0xf4, 0xfd, 0xb7, 0x8d, 0x31, 0x43, 0x22, 0xcd, 0x05, 0xfa, 0x09,
0xa8, 0x59, 0x84, 0x34, 0xa1, 0x66, 0x5d, 0x7d, 0x1c, 0x5f, 0x5a, 0x13, 0x6d, 0x87, 0xb4, 0xa0,
0x3e, 0x3e, 0x3f, 0x37, 0xa7, 0xb6, 0x39, 0xd1, 0x14, 0x89, 0xa8, 0xf9, 0xde, 0x3c, 0x97, 0xa8,
0x74, 0xe8, 0x41, 0x73, 0xe3, 0xb1, 0xdc, 0xd7, 0xd5, 0xa0, 0x3c, 0xbd, 0xb6, 0x35, 0x45, 0x7e,
0x5c, 0x98, 0xb6, 0x56, 0x22, 0x6d, 0x68, 0x5c, 0x98, 0xf6, 0x7c, 0x7c, 0x3d, 0xb1, 0x6c, 0xad,
0x4c, 0x3a, 0x00, 0x12, 0x52, 0x73, 0x3a, 0xb6, 0xa8, 0x56, 0x91, 0x78, 0x7a, 0xbd, 0xc2, 0x55,
0x02, 0xa0, 0x4e, 0xcc, 0x4b, 0xd3, 0x36, 0x35, 0x75, 0x34, 0x03, 0x15, 0x17, 0xc7, 0x89, 0x05,
0xb0, 0x1e, 0x85, 0x3c, 0xdd, 0x36, 0x1e, 0x9e, 0xaa, 0xdf, 0xff, 0xff, 0xe4, 0xfa, 0xce, 0x50,
0x79, 0xa5, 0x9c, 0x55, 0x3e, 0x95, 0xe2, 0xc5, 0x42, 0xc5, 0x07, 0xf7, 0xfa, 0x4f, 0x00, 0x00,
0x00, 0xff, 0xff, 0xb4, 0x80, 0xc7, 0x0e, 0x82, 0x05, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.

12
pkg/pb/orders.proto
View File

@ -21,8 +21,8 @@ enum PieceAction {
DELETE = 6;
}
// OrderLimit2 is provided by satellite to execute specific action on storage node within some limits
message OrderLimit2 {
// OrderLimit is provided by satellite to execute specific action on storage node within some limits
message OrderLimit {
// unique serial to avoid replay attacks
bytes serial_number = 1 [(gogoproto.customtype) = "SerialNumber", (gogoproto.nullable) = false];
// satellite who issued this order limit allowing orderer to do the specified action
@ -48,8 +48,8 @@ message OrderLimit2 {
node.NodeAddress satellite_address = 11;
}
// Order2 is a one step of fullfilling Amount number of bytes from an OrderLimit2 with SerialNumber
message Order2 {
// Order is a one step of fullfilling Amount number of bytes from an OrderLimit with SerialNumber
message Order {
// serial of the order limit that was signed
bytes serial_number = 1 [(gogoproto.customtype) = "SerialNumber", (gogoproto.nullable) = false];
// amount to be signed for
@ -73,8 +73,8 @@ service Orders {
}
message SettlementRequest {
OrderLimit2 limit = 1;
Order2 order = 2;
OrderLimit limit = 1;
Order order = 2;
}
message SettlementResponse {

78
pkg/pb/piecestore2.pb.go
View File

@ -33,9 +33,9 @@ const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
//
type PieceUploadRequest struct {
// first message to show that we are allowed to upload
Limit *OrderLimit2 `protobuf:"bytes,1,opt,name=limit,proto3" json:"limit,omitempty"`
Limit *OrderLimit `protobuf:"bytes,1,opt,name=limit,proto3" json:"limit,omitempty"`
// order for uploading
Order *Order2 `protobuf:"bytes,2,opt,name=order,proto3" json:"order,omitempty"`
Order *Order `protobuf:"bytes,2,opt,name=order,proto3" json:"order,omitempty"`
Chunk *PieceUploadRequest_Chunk `protobuf:"bytes,3,opt,name=chunk,proto3" json:"chunk,omitempty"`
// final message
Done *PieceHash `protobuf:"bytes,4,opt,name=done,proto3" json:"done,omitempty"`
@ -68,14 +68,14 @@ func (m *PieceUploadRequest) XXX_DiscardUnknown() {
var xxx_messageInfo_PieceUploadRequest proto.InternalMessageInfo
func (m *PieceUploadRequest) GetLimit() *OrderLimit2 {
func (m *PieceUploadRequest) GetLimit() *OrderLimit {
if m != nil {
return m.Limit
}
return nil
}
func (m *PieceUploadRequest) GetOrder() *Order2 {
func (m *PieceUploadRequest) GetOrder() *Order {
if m != nil {
return m.Order
}
@ -189,9 +189,9 @@ func (m *PieceUploadResponse) GetDone() *PieceHash {
// <- PieceDownloadResponse.Chunk
type PieceDownloadRequest struct {
// first message to show that we are allowed to upload
Limit *OrderLimit2 `protobuf:"bytes,1,opt,name=limit,proto3" json:"limit,omitempty"`
Limit *OrderLimit `protobuf:"bytes,1,opt,name=limit,proto3" json:"limit,omitempty"`
// order for downloading
Order *Order2 `protobuf:"bytes,2,opt,name=order,proto3" json:"order,omitempty"`
Order *Order `protobuf:"bytes,2,opt,name=order,proto3" json:"order,omitempty"`
// request for the chunk
Chunk *PieceDownloadRequest_Chunk `protobuf:"bytes,3,opt,name=chunk,proto3" json:"chunk,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
@ -223,14 +223,14 @@ func (m *PieceDownloadRequest) XXX_DiscardUnknown() {
var xxx_messageInfo_PieceDownloadRequest proto.InternalMessageInfo
func (m *PieceDownloadRequest) GetLimit() *OrderLimit2 {
func (m *PieceDownloadRequest) GetLimit() *OrderLimit {
if m != nil {
return m.Limit
}
return nil
}
func (m *PieceDownloadRequest) GetOrder() *Order2 {
func (m *PieceDownloadRequest) GetOrder() *Order {
if m != nil {
return m.Order
}
@ -377,10 +377,10 @@ func (m *PieceDownloadResponse_Chunk) GetData() []byte {
}
type PieceDeleteRequest struct {
Limit *OrderLimit2 `protobuf:"bytes,1,opt,name=limit,proto3" json:"limit,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
Limit *OrderLimit `protobuf:"bytes,1,opt,name=limit,proto3" json:"limit,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *PieceDeleteRequest) Reset() { *m = PieceDeleteRequest{} }
@ -407,7 +407,7 @@ func (m *PieceDeleteRequest) XXX_DiscardUnknown() {
var xxx_messageInfo_PieceDeleteRequest proto.InternalMessageInfo
func (m *PieceDeleteRequest) GetLimit() *OrderLimit2 {
func (m *PieceDeleteRequest) GetLimit() *OrderLimit {
if m != nil {
return m.Limit
}
@ -460,32 +460,32 @@ func init() { proto.RegisterFile("piecestore2.proto", fileDescriptor_23ff32dd550
var fileDescriptor_23ff32dd550c2439 = []byte{
// 404 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x94, 0x51, 0x4f, 0xea, 0x30,
0x14, 0xc7, 0x29, 0x6c, 0xcb, 0xbd, 0xe7, 0x92, 0x9b, 0x50, 0xc4, 0x2c, 0x4b, 0x54, 0x5c, 0x50,
0xf1, 0x65, 0x31, 0xe3, 0xcd, 0xa0, 0x26, 0xca, 0x83, 0x89, 0x1a, 0x49, 0x0d, 0x2f, 0xbe, 0x98,
0xc1, 0x0a, 0x2c, 0xe2, 0x3a, 0xd7, 0x11, 0x13, 0xbe, 0x82, 0x9f, 0xd3, 0x8f, 0x61, 0x34, 0x6b,
0x37, 0xc8, 0x00, 0x21, 0x9a, 0xf8, 0x04, 0x3d, 0xe7, 0x7f, 0xfa, 0xff, 0xf5, 0xdf, 0x66, 0x50,
0x0a, 0x3c, 0xda, 0xa3, 0x3c, 0x62, 0x21, 0xb5, 0xad, 0x20, 0x64, 0x11, 0xc3, 0x30, 0x2b, 0x19,
0x30, 0x60, 0x03, 0x26, 0xeb, 0x46, 0x91, 0x85, 0x2e, 0x0d, 0xb9, 0x5c, 0x99, 0xef, 0x08, 0x70,
0x3b, 0x16, 0x76, 0x82, 0x11, 0x73, 0x5c, 0x42, 0x9f, 0xc7, 0x94, 0x47, 0xf8, 0x10, 0xd4, 0x91,
0xf7, 0xe4, 0x45, 0x3a, 0xaa, 0xa2, 0xfa, 0x3f, 0xbb, 0x6c, 0x25, 0x43, 0xb7, 0xf1, 0xcf, 0x75,
0xdc, 0xb1, 0x89, 0x54, 0xe0, 0x1a, 0xa8, 0xa2, 0xa9, 0xe7, 0x85, 0xf4, 0x7f, 0x46, 0x6a, 0x13,
0xd9, 0xc4, 0xc7, 0xa0, 0xf6, 0x86, 0x63, 0xff, 0x51, 0x2f, 0x08, 0x55, 0xcd, 0x9a, 0xd1, 0x59,
0x8b, 0xfe, 0xd6, 0x45, 0xac, 0x25, 0x72, 0x04, 0xef, 0x81, 0xe2, 0x32, 0x9f, 0xea, 0x8a, 0x18,
0x2d, 0xa5, 0x06, 0x62, 0xec, 0xd2, 0xe1, 0x43, 0x22, 0xda, 0x46, 0x03, 0x54, 0x31, 0x86, 0x37,
0x41, 0x63, 0xfd, 0x3e, 0xa7, 0x92, 0xbe, 0x40, 0x92, 0x15, 0xc6, 0xa0, 0xb8, 0x4e, 0xe4, 0x08,
0xd0, 0x22, 0x11, 0xff, 0xcd, 0x26, 0x94, 0x33, 0xf6, 0x3c, 0x60, 0x3e, 0xa7, 0x53, 0x4b, 0xb4,
0xd2, 0xd2, 0x7c, 0x43, 0xb0, 0x21, 0x6a, 0x2d, 0xf6, 0xe2, 0xff, 0x6a, 0x7e, 0xcd, 0x6c, 0x7e,
0xfb, 0x0b, 0xf9, 0xcd, 0x11, 0x64, 0x12, 0x34, 0x4e, 0xd7, 0x45, 0xb3, 0x05, 0x20, 0x94, 0x0f,
0xdc, 0x9b, 0x50, 0x41, 0x52, 0x20, 0x7f, 0x45, 0xe5, 0xce, 0x9b, 0x50, 0xf3, 0x15, 0x41, 0x65,
0xce, 0x25, 0x09, 0xea, 0x24, 0xe5, 0x92, 0x07, 0x3d, 0x58, 0xc1, 0x25, 0x27, 0xb2, 0x60, 0x3f,
0xba, 0xb3, 0xb3, 0xe4, 0xc9, 0xb6, 0xe8, 0x88, 0x46, 0xf4, 0xfb, 0x91, 0x9b, 0x95, 0xe4, 0xd2,
0xd3, 0x0d, 0x24, 0x99, 0xfd, 0x81, 0x00, 0xda, 0x53, 0x7c, 0x7c, 0x03, 0x9a, 0x7c, 0x15, 0x78,
0x7b, 0xf5, 0x6b, 0x35, 0x76, 0xbe, 0xec, 0xcb, 0x9d, 0xcd, 0x5c, 0x1d, 0xe1, 0x0e, 0xfc, 0x49,
0xb3, 0xc0, 0xd5, 0x75, 0xd7, 0x67, 0xec, 0xae, 0x0d, 0x32, 0xde, 0xf4, 0x08, 0xe1, 0x2b, 0xd0,
0xe4, 0x31, 0x96, 0x50, 0x66, 0x02, 0x5a, 0x42, 0x99, 0x3d, 0xbf, 0x99, 0x3b, 0x57, 0xee, 0xf3,
0x41, 0xb7, 0xab, 0x89, 0x4f, 0x43, 0xe3, 0x33, 0x00, 0x00, 0xff, 0xff, 0xf5, 0xfa, 0xf7, 0xbe,
0x55, 0x04, 0x00, 0x00,
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x54, 0xcf, 0x4f, 0xe2, 0x40,
0x14, 0x66, 0xa0, 0x6d, 0x76, 0xdf, 0xb2, 0x07, 0xde, 0x2e, 0x9b, 0xa6, 0xc9, 0xee, 0xb2, 0x5d,
0x7f, 0x70, 0x6a, 0x0c, 0xdc, 0x0c, 0x72, 0x50, 0x0e, 0x26, 0x6a, 0x24, 0x63, 0xb8, 0x78, 0x31,
0x85, 0x0e, 0xd0, 0x88, 0x9d, 0xda, 0x29, 0x31, 0xe1, 0x5f, 0xf0, 0xcf, 0xf4, 0xcf, 0xf0, 0xa0,
0xe9, 0x4c, 0x0b, 0x29, 0x20, 0x44, 0x13, 0x4f, 0x30, 0xef, 0x7d, 0xdf, 0x7c, 0xdf, 0x7c, 0xef,
0xa5, 0x50, 0x09, 0x7d, 0x36, 0x60, 0x22, 0xe6, 0x11, 0x6b, 0x38, 0x61, 0xc4, 0x63, 0x8e, 0xb0,
0x28, 0x59, 0x30, 0xe2, 0x23, 0xae, 0xea, 0x56, 0x99, 0x47, 0x1e, 0x8b, 0x84, 0x3a, 0xd9, 0xcf,
0x04, 0xb0, 0x9b, 0x00, 0x7b, 0xe1, 0x84, 0xbb, 0x1e, 0x65, 0xf7, 0x53, 0x26, 0x62, 0xac, 0x83,
0x3e, 0xf1, 0xef, 0xfc, 0xd8, 0x24, 0x35, 0x52, 0xff, 0xd6, 0x40, 0x27, 0x25, 0x5d, 0x26, 0x3f,
0xe7, 0x49, 0x87, 0x2a, 0x00, 0xfe, 0x07, 0x5d, 0xf6, 0xcc, 0xa2, 0x44, 0x7e, 0xcf, 0x21, 0xa9,
0xea, 0xe1, 0x21, 0xe8, 0x83, 0xf1, 0x34, 0xb8, 0x35, 0x4b, 0x12, 0xb4, 0xe3, 0x2c, 0xbc, 0x39,
0xab, 0xea, 0xce, 0x49, 0x82, 0xa5, 0x8a, 0x82, 0xbb, 0xa0, 0x79, 0x3c, 0x60, 0xa6, 0x26, 0xa9,
0x95, 0xec, 0x7e, 0x49, 0x3b, 0x75, 0xc5, 0x98, 0xca, 0xb6, 0xd5, 0x04, 0x5d, 0xd2, 0xf0, 0x17,
0x18, 0x7c, 0x38, 0x14, 0x4c, 0x79, 0x2f, 0xd1, 0xf4, 0x84, 0x08, 0x9a, 0xe7, 0xc6, 0xae, 0xf4,
0x59, 0xa6, 0xf2, 0xbf, 0xdd, 0x82, 0x1f, 0x39, 0x79, 0x11, 0xf2, 0x40, 0xb0, 0xb9, 0x24, 0xd9,
0x28, 0x69, 0x3f, 0x11, 0xf8, 0x29, 0x6b, 0x1d, 0xfe, 0x10, 0x7c, 0x62, 0x7a, 0xad, 0x7c, 0x7a,
0x7b, 0x2b, 0xe9, 0x2d, 0xe9, 0xe7, 0xf2, 0xb3, 0xda, 0xdb, 0x82, 0xf9, 0x0d, 0x20, 0x91, 0x37,
0xc2, 0x9f, 0x31, 0x69, 0xa4, 0x44, 0xbf, 0xca, 0xca, 0x95, 0x3f, 0x63, 0xf6, 0x23, 0x81, 0xea,
0x92, 0x4a, 0x1a, 0xd3, 0x51, 0xe6, 0x4b, 0x3d, 0x73, 0x7f, 0x83, 0x2f, 0xc5, 0xc8, 0x1b, 0xfb,
0xd0, 0xc4, 0xda, 0xe9, 0xba, 0x76, 0xd8, 0x84, 0xc5, 0xec, 0xdd, 0x81, 0xdb, 0xd5, 0x74, 0xe2,
0x19, 0x5f, 0x19, 0x6b, 0xbc, 0x10, 0x80, 0xee, 0xdc, 0x3d, 0x5e, 0x80, 0xa1, 0x56, 0x02, 0xff,
0x6c, 0x5e, 0x55, 0xeb, 0xef, 0x9b, 0x7d, 0x75, 0xb3, 0x5d, 0xa8, 0x13, 0xec, 0xc1, 0x97, 0x2c,
0x0a, 0xac, 0x6d, 0x9b, 0x9e, 0xf5, 0x6f, 0x6b, 0x8e, 0xc9, 0xa5, 0x07, 0x04, 0xcf, 0xc0, 0x50,
0xcf, 0x58, 0xe3, 0x32, 0x97, 0xcf, 0x1a, 0x97, 0xf9, 0xf7, 0xdb, 0x85, 0x63, 0xed, 0xba, 0x18,
0xf6, 0xfb, 0x86, 0xfc, 0x2a, 0x34, 0x5f, 0x03, 0x00, 0x00, 0xff, 0xff, 0xe0, 0x9d, 0xac, 0xb7,
0x50, 0x04, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.

10
pkg/pb/piecestore2.proto
View File

@ -25,9 +25,9 @@ service Piecestore {
//
message PieceUploadRequest {
// first message to show that we are allowed to upload
orders.OrderLimit2 limit = 1;
orders.OrderLimit limit = 1;
// order for uploading
orders.Order2 order = 2;
orders.Order order = 2;
// data message
message Chunk {
@ -51,9 +51,9 @@ message PieceUploadResponse {
// <- PieceDownloadResponse.Chunk
message PieceDownloadRequest {
// first message to show that we are allowed to upload
orders.OrderLimit2 limit = 1;
orders.OrderLimit limit = 1;
// order for downloading
orders.Order2 order = 2;
orders.Order order = 2;
// Chunk that we wish to download
message Chunk {
@ -75,7 +75,7 @@ message PieceDownloadResponse {
}
message PieceDeleteRequest {
orders.OrderLimit2 limit = 1;
orders.OrderLimit limit = 1;
}
message PieceDeleteResponse {

2
pkg/storage/ec/client_planet_test.go
View File

@ -154,7 +154,7 @@ func newAddressedOrderLimit(ctx context.Context, action pb.PieceAction, satellit
if err != nil {
return nil, err
}
limit := &pb.OrderLimit2{
limit := &pb.OrderLimit{
SerialNumber: serialNumber,
SatelliteId: satellite.ID(),
UplinkId: uplink.ID(),

2
pkg/storage/ec/client_test.go
View File

@ -17,7 +17,7 @@ func TestUnique(t *testing.T) {
limits := make([]*pb.AddressedOrderLimit, 4)
for i := 0; i < len(limits); i++ {
limits[i] = &pb.AddressedOrderLimit{
Limit: &pb.OrderLimit2{
Limit: &pb.OrderLimit{
StorageNodeId: teststorj.NodeIDFromString(fmt.Sprintf("node-%d", i)),
},
}

4
pkg/storage/segments/store.go
View File

@ -117,7 +117,7 @@ func (s *segmentStore) Put(ctx context.Context, data io.Reader, expiration time.
var path storj.Path
var pointer *pb.Pointer
var originalLimits []*pb.OrderLimit2
var originalLimits []*pb.OrderLimit
if !remoteSized {
p, metadata, err := segmentInfo()
if err != nil {
@ -167,7 +167,7 @@ func (s *segmentStore) Put(ctx context.Context, data io.Reader, expiration time.
return Meta{}, Error.Wrap(err)
}
originalLimits = make([]*pb.OrderLimit2, len(limits))
originalLimits = make([]*pb.OrderLimit, len(limits))
for i, addressedLimit := range limits {
originalLimits[i] = addressedLimit.GetLimit()
}

22
proto.lock
View File

@ -1550,7 +1550,7 @@
{
"id": 1,
"name": "limit",
"type": "orders.OrderLimit2"
"type": "orders.OrderLimit"
},
{
"id": 2,
@ -1646,7 +1646,7 @@
{
"id": 5,
"name": "original_limits",
"type": "orders.OrderLimit2",
"type": "orders.OrderLimit",
"is_repeated": true
}
]
@ -2278,7 +2278,7 @@
],
"messages": [
{
"name": "OrderLimit2",
"name": "OrderLimit",
"fields": [
{
"id": 1,
@ -2388,7 +2388,7 @@
]
},
{
"name": "Order2",
"name": "Order",
"fields": [
{
"id": 1,
@ -2453,12 +2453,12 @@
{
"id": 1,
"name": "limit",
"type": "OrderLimit2"
"type": "OrderLimit"
},
{
"id": 2,
"name": "order",
"type": "Order2"
"type": "Order"
}
]
},
@ -2713,12 +2713,12 @@
{
"id": 1,
"name": "limit",
"type": "orders.OrderLimit2"
"type": "orders.OrderLimit"
},
{
"id": 2,
"name": "order",
"type": "orders.Order2"
"type": "orders.Order"
},
{
"id": 3,
@ -2765,12 +2765,12 @@
{
"id": 1,
"name": "limit",
"type": "orders.OrderLimit2"
"type": "orders.OrderLimit"
},
{
"id": 2,
"name": "order",
"type": "orders.Order2"
"type": "orders.Order"
},
{
"id": 3,
@ -2829,7 +2829,7 @@
{
"id": 1,
"name": "limit",
"type": "orders.OrderLimit2"
"type": "orders.OrderLimit"
}
]
},

8
satellite/metainfo/metainfo_test.go
View File

@ -303,7 +303,7 @@ func TestCommitSegment(t *testing.T) {
{
// error if pointer is nil
_, err = metainfo.CommitSegment(ctx, "bucket", "path", -1, nil, []*pb.OrderLimit2{})
_, err = metainfo.CommitSegment(ctx, "bucket", "path", -1, nil, []*pb.OrderLimit{})
require.Error(t, err)
}
{
@ -342,7 +342,7 @@ func TestCommitSegment(t *testing.T) {
ExpirationDate: expirationDateProto,
}
limits := make([]*pb.OrderLimit2, len(addresedLimits))
limits := make([]*pb.OrderLimit, len(addresedLimits))
for i, addresedLimit := range addresedLimits {
limits[i] = addresedLimit.Limit
}
@ -628,7 +628,7 @@ func TestGetProjectInfo(t *testing.T) {
})
}
func runCreateSegment(ctx context.Context, t *testing.T, metainfo *metainfo.Client) (*pb.Pointer, []*pb.OrderLimit2) {
func runCreateSegment(ctx context.Context, t *testing.T, metainfo *metainfo.Client) (*pb.Pointer, []*pb.OrderLimit) {
pointer := createTestPointer(t)
expirationDate, err := ptypes.Timestamp(pointer.ExpirationDate)
require.NoError(t, err)
@ -640,7 +640,7 @@ func runCreateSegment(ctx context.Context, t *testing.T, metainfo *metainfo.Clie
pointer.Remote.RemotePieces[0].NodeId = addressedLimits[0].Limit.StorageNodeId
pointer.Remote.RemotePieces[1].NodeId = addressedLimits[1].Limit.StorageNodeId
limits := make([]*pb.OrderLimit2, len(addressedLimits))
limits := make([]*pb.OrderLimit, len(addressedLimits))
for i, addressedLimit := range addressedLimits {
limits[i] = addressedLimit.Limit
}

16
satellite/orders/service.go
View File

@ -54,7 +54,7 @@ func NewService(log *zap.Logger, satellite signing.Signer, cache *overlay.Cache,
}
// VerifyOrderLimitSignature verifies that the signature inside order limit belongs to the satellite.
func (service *Service) VerifyOrderLimitSignature(ctx context.Context, signed *pb.OrderLimit2) (err error) {
func (service *Service) VerifyOrderLimitSignature(ctx context.Context, signed *pb.OrderLimit) (err error) {
defer mon.Task()(&ctx)(&err)
return signing.VerifyOrderLimitSignature(ctx, service.satellite, signed)
}
@ -164,7 +164,7 @@ func (service *Service) CreateGetOrderLimits(ctx context.Context, uplink *identi
continue
}
orderLimit, err := signing.SignOrderLimit(ctx, service.satellite, &pb.OrderLimit2{
orderLimit, err := signing.SignOrderLimit(ctx, service.satellite, &pb.OrderLimit{
SerialNumber: serialNumber,
SatelliteId: service.satellite.ID(),
SatelliteAddress: service.satelliteAddress,
@ -231,7 +231,7 @@ func (service *Service) CreatePutOrderLimits(ctx context.Context, uplink *identi
limits := make([]*pb.AddressedOrderLimit, len(nodes))
var pieceNum int32
for _, node := range nodes {
orderLimit, err := signing.SignOrderLimit(ctx, service.satellite, &pb.OrderLimit2{
orderLimit, err := signing.SignOrderLimit(ctx, service.satellite, &pb.OrderLimit{
SerialNumber: serialNumber,
SatelliteId: service.satellite.ID(),
SatelliteAddress: service.satelliteAddress,
@ -315,7 +315,7 @@ func (service *Service) CreateDeleteOrderLimits(ctx context.Context, uplink *ide
continue
}
orderLimit, err := signing.SignOrderLimit(ctx, service.satellite, &pb.OrderLimit2{
orderLimit, err := signing.SignOrderLimit(ctx, service.satellite, &pb.OrderLimit{
SerialNumber: serialNumber,
SatelliteId: service.satellite.ID(),
SatelliteAddress: service.satelliteAddress,
@ -403,7 +403,7 @@ func (service *Service) CreateAuditOrderLimits(ctx context.Context, auditor *ide
continue
}
orderLimit, err := signing.SignOrderLimit(ctx, service.satellite, &pb.OrderLimit2{
orderLimit, err := signing.SignOrderLimit(ctx, service.satellite, &pb.OrderLimit{
SerialNumber: serialNumber,
SatelliteId: service.satellite.ID(),
SatelliteAddress: service.satelliteAddress,
@ -475,7 +475,7 @@ func (service *Service) CreateAuditOrderLimit(ctx context.Context, auditor *iden
return nil, overlay.ErrNodeOffline.New(nodeID.String())
}
orderLimit, err := signing.SignOrderLimit(ctx, service.satellite, &pb.OrderLimit2{
orderLimit, err := signing.SignOrderLimit(ctx, service.satellite, &pb.OrderLimit{
SerialNumber: serialNumber,
SatelliteId: service.satellite.ID(),
SatelliteAddress: service.satelliteAddress,
@ -558,7 +558,7 @@ func (service *Service) CreateGetRepairOrderLimits(ctx context.Context, repairer
continue
}
orderLimit, err := signing.SignOrderLimit(ctx, service.satellite, &pb.OrderLimit2{
orderLimit, err := signing.SignOrderLimit(ctx, service.satellite, &pb.OrderLimit{
SerialNumber: serialNumber,
SatelliteId: service.satellite.ID(),
SatelliteAddress: service.satelliteAddress,
@ -637,7 +637,7 @@ func (service *Service) CreatePutRepairOrderLimits(ctx context.Context, repairer
return nil, Error.New("piece num greater than total pieces: %d >= %d", pieceNum, totalPieces)
}
orderLimit, err := signing.SignOrderLimit(ctx, service.satellite, &pb.OrderLimit2{
orderLimit, err := signing.SignOrderLimit(ctx, service.satellite, &pb.OrderLimit{
SerialNumber: serialNumber,
SatelliteId: service.satellite.ID(),
SatelliteAddress: service.satelliteAddress,

4
storagenode/orders/db_test.go
View File

@ -48,7 +48,7 @@ func TestOrders(t *testing.T) {
now := ptypes.TimestampNow()
limit, err := signing.SignOrderLimit(ctx, signing.SignerFromFullIdentity(satellite0), &pb.OrderLimit2{
limit, err := signing.SignOrderLimit(ctx, signing.SignerFromFullIdentity(satellite0), &pb.OrderLimit{
SerialNumber: serialNumber,
SatelliteId: satellite0.ID,
UplinkId: uplink.ID,
@ -61,7 +61,7 @@ func TestOrders(t *testing.T) {
})
require.NoError(t, err)
order, err := signing.SignOrder(ctx, signing.SignerFromFullIdentity(uplink), &pb.Order2{
order, err := signing.SignOrder(ctx, signing.SignerFromFullIdentity(uplink), &pb.Order{
SerialNumber: serialNumber,
Amount: 50,
})

8
storagenode/orders/sender.go
View File

@ -30,15 +30,15 @@ var (
// Info contains full information about an order.
type Info struct {
Limit *pb.OrderLimit2
Order *pb.Order2
Limit *pb.OrderLimit
Order *pb.Order
Uplink *identity.PeerIdentity
}
// ArchivedInfo contains full information about an archived order.
type ArchivedInfo struct {
Limit *pb.OrderLimit2
Order *pb.Order2
Limit *pb.OrderLimit
Order *pb.Order
Uplink *identity.PeerIdentity
Status Status

6
storagenode/piecestore/endpoint.go
View File

@ -213,7 +213,7 @@ func (endpoint *Endpoint) Upload(stream pb.Piecestore_UploadServer) (err error)
return ErrInternal.Wrap(err)
}
largestOrder := pb.Order2{}
largestOrder := pb.Order{}
defer endpoint.SaveOrder(ctx, limit, &largestOrder, peer)
for {
@ -460,7 +460,7 @@ func (endpoint *Endpoint) Download(stream pb.Piecestore_DownloadServer) (err err
})
recvErr := func() (err error) {
largestOrder := pb.Order2{}
largestOrder := pb.Order{}
defer endpoint.SaveOrder(ctx, limit, &largestOrder, peer)
// ensure that we always terminate sending goroutine
@ -503,7 +503,7 @@ func (endpoint *Endpoint) Download(stream pb.Piecestore_DownloadServer) (err err
}
// SaveOrder saves the order with all necessary information. It assumes it has been already verified.
func (endpoint *Endpoint) SaveOrder(ctx context.Context, limit *pb.OrderLimit2, order *pb.Order2, uplink *identity.PeerIdentity) {
func (endpoint *Endpoint) SaveOrder(ctx context.Context, limit *pb.OrderLimit, order *pb.Order, uplink *identity.PeerIdentity) {
var err error
defer mon.Task()(&ctx)(&err)

4
storagenode/piecestore/endpoint_test.go
View File

@ -362,13 +362,13 @@ func TestDelete(t *testing.T) {
}
func GenerateOrderLimit(t *testing.T, satellite storj.NodeID, uplink storj.NodeID, storageNode storj.NodeID, pieceID storj.PieceID,
action pb.PieceAction, serialNumber storj.SerialNumber, pieceExpiration, orderExpiration time.Duration, limit int64) *pb.OrderLimit2 {
action pb.PieceAction, serialNumber storj.SerialNumber, pieceExpiration, orderExpiration time.Duration, limit int64) *pb.OrderLimit {
pe, err := ptypes.TimestampProto(time.Now().Add(pieceExpiration))
require.NoError(t, err)
oe, err := ptypes.TimestampProto(time.Now().Add(orderExpiration))
require.NoError(t, err)
orderLimit := &pb.OrderLimit2{
orderLimit := &pb.OrderLimit{
SatelliteId: satellite,
UplinkId: uplink,
StorageNodeId: storageNode,

8
storagenode/piecestore/verification.go
View File

@ -29,7 +29,7 @@ var (
// VerifyOrderLimit verifies that the order limit is properly signed and has sane values.
// It also verifies that the serial number has not been used.
func (endpoint *Endpoint) VerifyOrderLimit(ctx context.Context, limit *pb.OrderLimit2) (err error) {
func (endpoint *Endpoint) VerifyOrderLimit(ctx context.Context, limit *pb.OrderLimit) (err error) {
defer mon.Task()(&ctx)(&err)
// sanity checks
@ -88,7 +88,7 @@ func (endpoint *Endpoint) VerifyOrderLimit(ctx context.Context, limit *pb.OrderL
}
// VerifyOrder verifies that the order corresponds to the order limit and has all the necessary fields.
func (endpoint *Endpoint) VerifyOrder(ctx context.Context, peer *identity.PeerIdentity, limit *pb.OrderLimit2, order *pb.Order2, largestOrderAmount int64) (err error) {
func (endpoint *Endpoint) VerifyOrder(ctx context.Context, peer *identity.PeerIdentity, limit *pb.OrderLimit, order *pb.Order, largestOrderAmount int64) (err error) {
defer mon.Task()(&ctx)(&err)
if order.SerialNumber != limit.SerialNumber {
@ -110,7 +110,7 @@ func (endpoint *Endpoint) VerifyOrder(ctx context.Context, peer *identity.PeerId
}
// VerifyPieceHash verifies whether the piece hash is properly signed and matches the locally computed hash.
func (endpoint *Endpoint) VerifyPieceHash(ctx context.Context, peer *identity.PeerIdentity, limit *pb.OrderLimit2, hash *pb.PieceHash, expectedHash []byte) (err error) {
func (endpoint *Endpoint) VerifyPieceHash(ctx context.Context, peer *identity.PeerIdentity, limit *pb.OrderLimit, hash *pb.PieceHash, expectedHash []byte) (err error) {
defer mon.Task()(&ctx)(&err)
if peer == nil || limit == nil || hash == nil || len(expectedHash) == 0 {
@ -131,7 +131,7 @@ func (endpoint *Endpoint) VerifyPieceHash(ctx context.Context, peer *identity.Pe
}
// VerifyOrderLimitSignature verifies that the order limit signature is valid.
func (endpoint *Endpoint) VerifyOrderLimitSignature(ctx context.Context, limit *pb.OrderLimit2) (err error) {
func (endpoint *Endpoint) VerifyOrderLimitSignature(ctx context.Context, limit *pb.OrderLimit) (err error) {
defer mon.Task()(&ctx)(&err)
signee, err := endpoint.trust.GetSignee(ctx, limit.SatelliteId)

12
storagenode/storagenodedb/orders.go
View File

@ -95,8 +95,8 @@ func (db *ordersdb) ListUnsent(ctx context.Context, limit int) (_ []*orders.Info
}
var info orders.Info
info.Limit = &pb.OrderLimit2{}
info.Order = &pb.Order2{}
info.Limit = &pb.OrderLimit{}
info.Order = &pb.Order{}
err = proto.Unmarshal(limitSerialized, info.Limit)
if err != nil {
@ -149,8 +149,8 @@ func (db *ordersdb) ListUnsentBySatellite(ctx context.Context) (_ map[storj.Node
}
var info orders.Info
info.Limit = &pb.OrderLimit2{}
info.Order = &pb.Order2{}
info.Limit = &pb.OrderLimit{}
info.Order = &pb.Order{}
err = proto.Unmarshal(limitSerialized, info.Limit)
if err != nil {
@ -240,8 +240,8 @@ func (db *ordersdb) ListArchived(ctx context.Context, limit int) (_ []*orders.Ar
}
var info orders.ArchivedInfo
info.Limit = &pb.OrderLimit2{}
info.Order = &pb.Order2{}
info.Limit = &pb.OrderLimit{}
info.Order = &pb.Order{}
info.Status = orders.Status(status)
info.ArchivedAt = archivedAt

2
uplink/metainfo/client.go
View File

@ -104,7 +104,7 @@ func (client *Client) CreateSegment(ctx context.Context, bucket string, path sto
}
// CommitSegment requests to store the pointer for the segment
func (client *Client) CommitSegment(ctx context.Context, bucket string, path storj.Path, segmentIndex int64, pointer *pb.Pointer, originalLimits []*pb.OrderLimit2) (savedPointer *pb.Pointer, err error) {
func (client *Client) CommitSegment(ctx context.Context, bucket string, path storj.Path, segmentIndex int64, pointer *pb.Pointer, originalLimits []*pb.OrderLimit) (savedPointer *pb.Pointer, err error) {
defer mon.Task()(&ctx)(&err)
response, err := client.client.CommitSegment(ctx, &pb.SegmentCommitRequest{

2
uplink/piecestore/client.go
View File

@ -64,7 +64,7 @@ func Dial(ctx context.Context, transport transport.Client, target *pb.Node, log
}
// Delete uses delete order limit to delete a piece on piece store.
func (client *Client) Delete(ctx context.Context, limit *pb.OrderLimit2) (err error) {
func (client *Client) Delete(ctx context.Context, limit *pb.OrderLimit) (err error) {
defer mon.Task()(&ctx)(&err)
_, err = client.client.Delete(ctx, &pb.PieceDeleteRequest{
Limit: limit,

6
uplink/piecestore/download.go
View File

@ -25,7 +25,7 @@ type Downloader interface {
// Download implements downloading from a piecestore.
type Download struct {
client *Client
limit *pb.OrderLimit2
limit *pb.OrderLimit
peer *identity.PeerIdentity
stream pb.Piecestore_DownloadClient
ctx context.Context
@ -42,7 +42,7 @@ type Download struct {
}
// Download starts a new download using the specified order limit at the specified offset and size.
func (client *Client) Download(ctx context.Context, limit *pb.OrderLimit2, offset, size int64) (_ Downloader, err error) {
func (client *Client) Download(ctx context.Context, limit *pb.OrderLimit, offset, size int64) (_ Downloader, err error) {
defer mon.Task()(&ctx)(&err)
stream, err := client.client.Download(ctx)
@ -126,7 +126,7 @@ func (client *Download) Read(data []byte) (read int, err error) {
// send an order
if newAllocation > 0 {
// sign the order
order, err := signing.SignOrder(ctx, client.client.signer, &pb.Order2{
order, err := signing.SignOrder(ctx, client.client.signer, &pb.Order{
SerialNumber: client.limit.SerialNumber,
Amount: newAllocation,
})

6
uplink/piecestore/upload.go
View File

@ -32,7 +32,7 @@ type Uploader interface {
// Upload implements uploading to the storage node.
type Upload struct {
client *Client
limit *pb.OrderLimit2
limit *pb.OrderLimit
peer *identity.PeerIdentity
stream pb.Piecestore_UploadClient
ctx context.Context
@ -47,7 +47,7 @@ type Upload struct {
}
// Upload initiates an upload to the storage node.
func (client *Client) Upload(ctx context.Context, limit *pb.OrderLimit2) (_ Uploader, err error) {
func (client *Client) Upload(ctx context.Context, limit *pb.OrderLimit) (_ Uploader, err error) {
defer mon.Task()(&ctx, "node: "+limit.StorageNodeId.String()[0:8])(&err)
stream, err := client.client.Upload(ctx)
@ -118,7 +118,7 @@ func (client *Upload) Write(data []byte) (written int, err error) {
}
// create a signed order for the next chunk
order, err := signing.SignOrder(ctx, client.client.signer, &pb.Order2{
order, err := signing.SignOrder(ctx, client.client.signer, &pb.Order{
SerialNumber: client.limit.SerialNumber,
Amount: client.offset + int64(len(sendData)),
})

2
uplink/piecestore/verification.go
View File

@ -24,7 +24,7 @@ var (
)
// VerifyPieceHash verifies piece hash which is sent by peer.
func (client *Client) VerifyPieceHash(ctx context.Context, peer *identity.PeerIdentity, limit *pb.OrderLimit2, hash *pb.PieceHash, expectedHash []byte) (err error) {
func (client *Client) VerifyPieceHash(ctx context.Context, peer *identity.PeerIdentity, limit *pb.OrderLimit, hash *pb.PieceHash, expectedHash []byte) (err error) {
defer mon.Task()(&ctx)(&err)
if peer == nil || limit == nil || hash == nil || len(expectedHash) == 0 {
return ErrProtocol.New("invalid arguments")