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

Change protobuf expirations to use time.Time (#2509)

Browse Source 
* Change protobuf expirations to use time.Time instead of timestamp.Timestamp
This commit is contained in:
Alexander Leitner 2019-07-09 17:54:00 -04:00 committed by GitHub
parent bbc25a2bf7
commit 1c5db71faf
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
29 changed files with 359 additions and 478 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
pkg/audit/cursor.go
View File

@ -11,7 +11,6 @@ import (
"sync" "sync"
"time" "time"
"github.com/golang/protobuf/ptypes"
"github.com/zeebo/errs" "github.com/zeebo/errs"
"storj.io/storj/pkg/eestream" "storj.io/storj/pkg/eestream"
@ -124,19 +123,12 @@ func (cursor *Cursor) getRandomValidPointer(ctx context.Context, pointerItems []
} }
//delete expired items rather than auditing them //delete expired items rather than auditing them
if expiration := pointer.GetExpirationDate(); expiration != nil { if !pointer.ExpirationDate.IsZero() && pointer.ExpirationDate.Before(time.Now()) {
t, err := ptypes.Timestamp(expiration) err := cursor.metainfo.Delete(ctx, path)
if err != nil { if err != nil {
errGroup.Add(err) errGroup.Add(err)
continue
}
if t.Before(time.Now()) {
err := cursor.metainfo.Delete(ctx, path)
if err != nil {
errGroup.Add(err)
}
continue
} }
continue
} }
if pointer.GetType() != pb.Pointer_REMOTE || pointer.GetSegmentSize() == 0 { if pointer.GetType() != pb.Pointer_REMOTE || pointer.GetSegmentSize() == 0 {

9
pkg/audit/cursor_test.go
View File

@ -10,7 +10,6 @@ import (
"testing" "testing"
"time" "time"
"github.com/golang/protobuf/ptypes/timestamp"
"github.com/stretchr/testify/require" "github.com/stretchr/testify/require"
"storj.io/storj/internal/testcontext" "storj.io/storj/internal/testcontext"
@ -37,7 +36,7 @@ func TestAuditSegment(t *testing.T) {
// change limit in library to 5 in // change limit in library to 5 in
// list api call, default is 0 == 1000 listing // list api call, default is 0 == 1000 listing
//populate metainfo with 10 non-expired pointers of test data //populate metainfo with 10 non-expired pointers of test data
tests, cursor, metainfo := populateTestData(t, planet, &timestamp.Timestamp{Seconds: time.Now().Unix() + 3000}) tests, cursor, metainfo := populateTestData(t, planet, time.Now().Add(3*time.Second))
t.Run("NextStripe", func(t *testing.T) { t.Run("NextStripe", func(t *testing.T) {
for _, tt := range tests { for _, tt := range tests {
@ -113,7 +112,7 @@ func TestDeleteExpired(t *testing.T) {
SatelliteCount: 1, StorageNodeCount: 4, UplinkCount: 1, SatelliteCount: 1, StorageNodeCount: 4, UplinkCount: 1,
}, func(t *testing.T, ctx *testcontext.Context, planet *testplanet.Planet) { }, func(t *testing.T, ctx *testcontext.Context, planet *testplanet.Planet) {
//populate metainfo with 10 expired pointers of test data //populate metainfo with 10 expired pointers of test data
_, cursor, metainfo := populateTestData(t, planet, &timestamp.Timestamp{}) _, cursor, metainfo := populateTestData(t, planet, time.Now().Add(-time.Second*1))
//make sure it they're in there //make sure it they're in there
list, _, err := metainfo.List(ctx, "", "", "", true, 10, meta.None) list, _, err := metainfo.List(ctx, "", "", "", true, 10, meta.None)
require.NoError(t, err) require.NoError(t, err)
@ -136,7 +135,7 @@ type testData struct {
path storj.Path path storj.Path
} }
func populateTestData(t *testing.T, planet *testplanet.Planet, expiration *timestamp.Timestamp) ([]testData, *audit.Cursor, *metainfo.Service) { func populateTestData(t *testing.T, planet *testplanet.Planet, expiration time.Time) ([]testData, *audit.Cursor, *metainfo.Service) {
ctx := context.TODO() ctx := context.TODO()
tests := []testData{ tests := []testData{
{bm: "success-1", path: "folder1/file1"}, {bm: "success-1", path: "folder1/file1"},
@ -166,7 +165,7 @@ func populateTestData(t *testing.T, planet *testplanet.Planet, expiration *times
return tests, cursor, metainfo return tests, cursor, metainfo
} }
func makePointer(path storj.Path, expiration *timestamp.Timestamp) *pb.Pointer { func makePointer(path storj.Path, expiration time.Time) *pb.Pointer {
var rps []*pb.RemotePiece var rps []*pb.RemotePiece
rps = append(rps, &pb.RemotePiece{ rps = append(rps, &pb.RemotePiece{
PieceNum: 1, PieceNum: 1,

18
pkg/metainfo/kvmetainfo/objects.go
View File

@ -6,12 +6,8 @@ package kvmetainfo
import ( import (
"context" "context"
"errors" "errors"
"time"
"github.com/gogo/protobuf/proto" "github.com/gogo/protobuf/proto"
"github.com/golang/protobuf/ptypes"
"github.com/golang/protobuf/ptypes/timestamp"
"go.uber.org/zap"
"storj.io/storj/internal/memory" "storj.io/storj/internal/memory"
"storj.io/storj/pkg/encryption" "storj.io/storj/pkg/encryption"
@ -272,7 +268,7 @@ func (db *DB) getInfo(ctx context.Context, bucket string, path storj.Path) (obj
lastSegmentMeta := segments.Meta{ lastSegmentMeta := segments.Meta{
Modified: pointer.CreationDate, Modified: pointer.CreationDate,
Expiration: convertTime(pointer.GetExpirationDate()), Expiration: pointer.GetExpirationDate(),
Size: pointer.GetSegmentSize(), Size: pointer.GetSegmentSize(),
Data: pointer.GetMetadata(), Data: pointer.GetMetadata(),
} }
@ -379,18 +375,6 @@ func objectStreamFromMeta(bucket storj.Bucket, path storj.Path, lastSegment segm
}, nil }, nil
} }
// convertTime converts gRPC timestamp to Go time
func convertTime(ts *timestamp.Timestamp) time.Time {
if ts == nil {
return time.Time{}
}
t, err := ptypes.Timestamp(ts)
if err != nil {
zap.S().Warnf("Failed converting timestamp %v: %v", ts, err)
}
return t
}
type mutableObject struct { type mutableObject struct {
db *DB db *DB
info storj.Object info storj.Object

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

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

2
pkg/pb/metainfo.proto
View File

@ -108,7 +108,7 @@ message SegmentWriteRequestOld {
int64 segment = 3; int64 segment = 3;
pointerdb.RedundancyScheme redundancy = 4; pointerdb.RedundancyScheme redundancy = 4;
int64 max_encrypted_segment_size = 5; int64 max_encrypted_segment_size = 5;
google.protobuf.Timestamp expiration = 6; google.protobuf.Timestamp expiration = 6 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false];
} }
message SegmentWriteResponseOld { message SegmentWriteResponseOld {

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

@ -8,7 +8,7 @@ import (
fmt "fmt" fmt "fmt"
_ "github.com/gogo/protobuf/gogoproto" _ "github.com/gogo/protobuf/gogoproto"
proto "github.com/gogo/protobuf/proto" proto "github.com/gogo/protobuf/proto"
timestamp "github.com/golang/protobuf/ptypes/timestamp" _ "github.com/golang/protobuf/ptypes/timestamp"
grpc "google.golang.org/grpc" grpc "google.golang.org/grpc"
math "math" math "math"
time "time" time "time"
@ -108,12 +108,12 @@ type OrderLimit struct {
// piece which is allowed to be touched // piece which is allowed to be touched
PieceId PieceID `protobuf:"bytes,5,opt,name=piece_id,json=pieceId,proto3,customtype=PieceID" json:"piece_id"` PieceId PieceID `protobuf:"bytes,5,opt,name=piece_id,json=pieceId,proto3,customtype=PieceID" json:"piece_id"`
// limit in bytes how much can be changed // limit in bytes how much can be changed
Limit int64 `protobuf:"varint,6,opt,name=limit,proto3" json:"limit,omitempty"` Limit int64 `protobuf:"varint,6,opt,name=limit,proto3" json:"limit,omitempty"`
Action PieceAction `protobuf:"varint,7,opt,name=action,proto3,enum=orders.PieceAction" json:"action,omitempty"` Action PieceAction `protobuf:"varint,7,opt,name=action,proto3,enum=orders.PieceAction" json:"action,omitempty"`
PieceExpiration *timestamp.Timestamp `protobuf:"bytes,8,opt,name=piece_expiration,json=pieceExpiration,proto3" json:"piece_expiration,omitempty"` PieceExpiration time.Time `protobuf:"bytes,8,opt,name=piece_expiration,json=pieceExpiration,proto3,stdtime" json:"piece_expiration"`
OrderExpiration *timestamp.Timestamp `protobuf:"bytes,9,opt,name=order_expiration,json=orderExpiration,proto3" json:"order_expiration,omitempty"` OrderExpiration time.Time `protobuf:"bytes,9,opt,name=order_expiration,json=orderExpiration,proto3,stdtime" json:"order_expiration"`
OrderCreation time.Time `protobuf:"bytes,12,opt,name=order_creation,json=orderCreation,proto3,stdtime" json:"order_creation"` OrderCreation time.Time `protobuf:"bytes,12,opt,name=order_creation,json=orderCreation,proto3,stdtime" json:"order_creation"`
SatelliteSignature []byte `protobuf:"bytes,10,opt,name=satellite_signature,json=satelliteSignature,proto3" json:"satellite_signature,omitempty"` SatelliteSignature []byte `protobuf:"bytes,10,opt,name=satellite_signature,json=satelliteSignature,proto3" json:"satellite_signature,omitempty"`
// satellites aren't necessarily discoverable in kademlia. this allows // satellites aren't necessarily discoverable in kademlia. this allows
// a storage node to find a satellite and handshake with it to get its key. // a storage node to find a satellite and handshake with it to get its key.
SatelliteAddress *NodeAddress `protobuf:"bytes,11,opt,name=satellite_address,json=satelliteAddress,proto3" json:"satellite_address,omitempty"` SatelliteAddress *NodeAddress `protobuf:"bytes,11,opt,name=satellite_address,json=satelliteAddress,proto3" json:"satellite_address,omitempty"`
@ -160,18 +160,18 @@ func (m *OrderLimit) GetAction() PieceAction {
return PieceAction_INVALID return PieceAction_INVALID
} }
func (m *OrderLimit) GetPieceExpiration() *timestamp.Timestamp { func (m *OrderLimit) GetPieceExpiration() time.Time {
if m != nil { if m != nil {
return m.PieceExpiration return m.PieceExpiration
} }
return nil return time.Time{}
} }
func (m *OrderLimit) GetOrderExpiration() *timestamp.Timestamp { func (m *OrderLimit) GetOrderExpiration() time.Time {
if m != nil { if m != nil {
return m.OrderExpiration return m.OrderExpiration
} }
return nil return time.Time{}
} }
func (m *OrderLimit) GetOrderCreation() time.Time { func (m *OrderLimit) GetOrderCreation() time.Time {
@ -412,53 +412,53 @@ func init() {
func init() { proto.RegisterFile("orders.proto", fileDescriptor_e0f5d4cf0fc9e41b) } func init() { proto.RegisterFile("orders.proto", fileDescriptor_e0f5d4cf0fc9e41b) }
var fileDescriptor_e0f5d4cf0fc9e41b = []byte{ var fileDescriptor_e0f5d4cf0fc9e41b = []byte{
// 727 bytes of a gzipped FileDescriptorProto // 731 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x54, 0x4d, 0x6f, 0xd3, 0x40, 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x54, 0xcb, 0x6e, 0x13, 0x4b,
0x10, 0xed, 0xe6, 0xc3, 0x49, 0x26, 0x5f, 0xee, 0xb6, 0x42, 0x21, 0x02, 0x25, 0x84, 0x4b, 0x68, 0x10, 0x4d, 0xfb, 0x31, 0xb6, 0xcb, 0xaf, 0x49, 0x27, 0xba, 0xf2, 0xb5, 0xee, 0x95, 0x8d, 0xd9,
0xa5, 0x94, 0x06, 0x09, 0xa9, 0x17, 0xa4, 0x7c, 0x58, 0xc5, 0x50, 0x95, 0x68, 0x93, 0x72, 0xe0, 0x98, 0x44, 0x72, 0x88, 0x91, 0x90, 0xb2, 0x41, 0xf2, 0x63, 0x14, 0x06, 0xa2, 0xc4, 0x6a, 0x3b,
0x12, 0x39, 0xf5, 0x92, 0x5a, 0x24, 0x76, 0xf0, 0x6e, 0x24, 0xd4, 0x3b, 0x77, 0xce, 0xfc, 0x17, 0x2c, 0xd8, 0x58, 0xe3, 0x4c, 0xe3, 0x8c, 0xb0, 0x67, 0xcc, 0x74, 0x5b, 0x42, 0xd9, 0xb3, 0xe7,
0xee, 0x1c, 0xf8, 0x05, 0x1c, 0xca, 0x5f, 0x41, 0x3b, 0xeb, 0xc4, 0x29, 0x14, 0x15, 0xa9, 0xb7, 0x4b, 0xf8, 0x03, 0xf6, 0x2c, 0xf8, 0x02, 0x16, 0xe1, 0x57, 0x50, 0x57, 0x8f, 0x3d, 0x0e, 0x04,
0x7d, 0x33, 0xef, 0xcd, 0x78, 0x76, 0xde, 0x1a, 0x0a, 0x41, 0xe8, 0xf2, 0x50, 0xb4, 0x16, 0x61, 0x41, 0x94, 0xdd, 0x9c, 0xaa, 0x73, 0xaa, 0xba, 0xba, 0x4e, 0x0f, 0x14, 0x82, 0xd0, 0xe5, 0xa1,
0x20, 0x03, 0x6a, 0x68, 0x54, 0x85, 0x69, 0x30, 0x0d, 0x74, 0xac, 0x5a, 0x9b, 0x06, 0xc1, 0x74, 0x68, 0x2d, 0xc2, 0x40, 0x06, 0xd4, 0xd0, 0xa8, 0x0a, 0xd3, 0x60, 0x1a, 0xe8, 0x58, 0xb5, 0x36,
0xc6, 0x0f, 0x10, 0x4d, 0x96, 0xef, 0x0f, 0xa4, 0x37, 0xe7, 0x42, 0x3a, 0xf3, 0x45, 0x44, 0x00, 0x0d, 0x82, 0xe9, 0x8c, 0x1f, 0x20, 0x9a, 0x2c, 0xdf, 0x1c, 0x48, 0x6f, 0xce, 0x85, 0x74, 0xe6,
0x3f, 0x70, 0xb9, 0x3e, 0x37, 0xbe, 0xa6, 0x01, 0xde, 0xa8, 0x1a, 0x27, 0xde, 0xdc, 0x93, 0xf4, 0x8b, 0x88, 0x00, 0x7e, 0xe0, 0x72, 0xfd, 0xdd, 0xf8, 0x94, 0x06, 0x38, 0x53, 0x35, 0x4e, 0xbc,
0x08, 0x8a, 0x82, 0x87, 0x9e, 0x33, 0x1b, 0xfb, 0xcb, 0xf9, 0x84, 0x87, 0x15, 0x52, 0x27, 0xcd, 0xb9, 0x27, 0xe9, 0x11, 0x14, 0x05, 0x0f, 0x3d, 0x67, 0x36, 0xf6, 0x97, 0xf3, 0x09, 0x0f, 0x2b,
0x42, 0x77, 0xf7, 0xfb, 0x55, 0x6d, 0xeb, 0xe7, 0x55, 0xad, 0x30, 0xc4, 0xe4, 0x29, 0xe6, 0x58, 0xa4, 0x4e, 0x9a, 0x85, 0xee, 0xee, 0x97, 0xeb, 0xda, 0xd6, 0xb7, 0xeb, 0x5a, 0x61, 0x88, 0xc9,
0x41, 0x6c, 0x20, 0x7a, 0x08, 0x05, 0xe1, 0x48, 0x3e, 0x9b, 0x79, 0x92, 0x8f, 0x3d, 0xb7, 0x92, 0x53, 0xcc, 0xb1, 0x82, 0xd8, 0x40, 0xf4, 0x10, 0x0a, 0xc2, 0x91, 0x7c, 0x36, 0xf3, 0x24, 0x1f,
0x40, 0x65, 0x29, 0x52, 0x1a, 0xa7, 0x81, 0xcb, 0xed, 0x3e, 0xcb, 0xaf, 0x39, 0xb6, 0x4b, 0xf7, 0x7b, 0x6e, 0x25, 0x81, 0xca, 0x52, 0xa4, 0x34, 0x4e, 0x03, 0x97, 0xdb, 0x7d, 0x96, 0x5f, 0x73,
0x21, 0xb7, 0x5c, 0xcc, 0x3c, 0xff, 0x83, 0xe2, 0x27, 0x6f, 0xe4, 0x67, 0x35, 0xc1, 0x76, 0xe9, 0x6c, 0x97, 0xee, 0x43, 0x6e, 0xb9, 0x98, 0x79, 0xfe, 0x5b, 0xc5, 0x4f, 0xde, 0xca, 0xcf, 0x6a,
0x73, 0x28, 0x0b, 0x19, 0x84, 0xce, 0x94, 0x8f, 0xd5, 0xf7, 0x2b, 0x49, 0xea, 0x46, 0x49, 0x31, 0x82, 0xed, 0xd2, 0xa7, 0x50, 0x16, 0x32, 0x08, 0x9d, 0x29, 0x1f, 0xab, 0xf3, 0x2b, 0x49, 0xea,
0xa2, 0x21, 0x74, 0xe9, 0x1e, 0x64, 0x17, 0x1e, 0x3f, 0x47, 0x41, 0x1a, 0x05, 0xe5, 0x48, 0x90, 0x56, 0x49, 0x31, 0xa2, 0x21, 0x74, 0xe9, 0x1e, 0x64, 0x17, 0x1e, 0xbf, 0x40, 0x41, 0x1a, 0x05,
0x19, 0xa8, 0xb8, 0xdd, 0x67, 0x19, 0x24, 0xd8, 0x2e, 0xdd, 0x85, 0xf4, 0x4c, 0xdd, 0x43, 0xc5, 0xe5, 0x48, 0x90, 0x19, 0xa8, 0xb8, 0xdd, 0x67, 0x19, 0x24, 0xd8, 0x2e, 0xdd, 0x85, 0xf4, 0x4c,
0xa8, 0x93, 0x66, 0x92, 0x69, 0x40, 0xf7, 0xc1, 0x70, 0xce, 0xa5, 0x17, 0xf8, 0x95, 0x4c, 0x9d, 0xdd, 0x43, 0xc5, 0xa8, 0x93, 0x66, 0x92, 0x69, 0x40, 0xf7, 0xc1, 0x70, 0x2e, 0xa4, 0x17, 0xf8,
0x34, 0x4b, 0xed, 0x9d, 0x56, 0xb4, 0x03, 0xd4, 0x77, 0x30, 0xc5, 0x22, 0x0a, 0xb5, 0xc0, 0xd4, 0x95, 0x4c, 0x9d, 0x34, 0x4b, 0xed, 0x9d, 0x56, 0xb4, 0x03, 0xd4, 0x77, 0x30, 0xc5, 0x22, 0x0a,
0xed, 0xf8, 0xa7, 0x85, 0x17, 0x3a, 0x28, 0xcb, 0xd6, 0x49, 0x33, 0xdf, 0xae, 0xb6, 0xf4, 0x62, 0x3d, 0x03, 0x53, 0xb7, 0xe3, 0xef, 0x17, 0x5e, 0xe8, 0xa0, 0x2c, 0x5b, 0x27, 0xcd, 0x7c, 0xbb,
0x5a, 0xab, 0xc5, 0xb4, 0x46, 0xab, 0xc5, 0xb0, 0x32, 0x6a, 0xac, 0xb5, 0x44, 0x95, 0xc1, 0x26, 0xda, 0xd2, 0x8b, 0x69, 0xad, 0x16, 0xd3, 0x1a, 0xad, 0x16, 0xd3, 0xcd, 0xaa, 0x23, 0x7d, 0xfc,
0x9b, 0x65, 0x72, 0xb7, 0x97, 0x41, 0xcd, 0x46, 0x99, 0xd7, 0x50, 0xd2, 0x65, 0xce, 0x43, 0xae, 0x5e, 0x23, 0xac, 0x8c, 0x6a, 0x6b, 0x2d, 0x56, 0x05, 0xb1, 0xdd, 0x66, 0xc1, 0xdc, 0x5d, 0x0a,
0x8b, 0x14, 0x6e, 0x2b, 0xd2, 0xcd, 0xaa, 0xeb, 0xf9, 0xf2, 0xab, 0x46, 0x58, 0x11, 0xb5, 0xbd, 0xa2, 0x7a, 0xa3, 0xe0, 0x4b, 0x28, 0xe9, 0x82, 0x17, 0x21, 0xd7, 0xe5, 0x0a, 0x77, 0x28, 0x57,
0x48, 0x4a, 0x0f, 0x60, 0x27, 0xde, 0xb0, 0xf0, 0xa6, 0xbe, 0x23, 0x97, 0x21, 0xaf, 0x80, 0xba, 0x44, 0x6d, 0x2f, 0x92, 0xd2, 0x03, 0xd8, 0x89, 0xb7, 0x2e, 0xbc, 0xa9, 0xef, 0xc8, 0x65, 0xc8,
0x54, 0x46, 0xd7, 0xa9, 0xe1, 0x2a, 0x43, 0x5f, 0xc0, 0x76, 0x2c, 0x70, 0x5c, 0x37, 0xe4, 0x42, 0x2b, 0xa0, 0x2e, 0x9a, 0xd1, 0x75, 0x6a, 0xb8, 0xca, 0xd0, 0x67, 0xb0, 0x1d, 0x0b, 0x1c, 0xd7,
0x54, 0xf2, 0xf8, 0x01, 0xdb, 0x2d, 0x34, 0xa1, 0xda, 0x51, 0x47, 0x27, 0x98, 0xb9, 0xe6, 0x46, 0x0d, 0xb9, 0x10, 0x95, 0x3c, 0x1e, 0x60, 0xbb, 0x85, 0xc6, 0x54, 0x7b, 0xeb, 0xe8, 0x04, 0x33,
0x91, 0xc6, 0x67, 0x02, 0x69, 0x34, 0xe7, 0x5d, 0x7c, 0x79, 0x0f, 0x0c, 0x67, 0x1e, 0x2c, 0x7d, 0xd7, 0xdc, 0x28, 0xd2, 0xf8, 0x40, 0x20, 0x8d, 0x86, 0xbd, 0x8f, 0x57, 0xff, 0x01, 0xc3, 0x99,
0x89, 0x8e, 0x4c, 0xb2, 0x08, 0xd1, 0x27, 0x60, 0x46, 0xe6, 0x8b, 0x47, 0x41, 0x0f, 0xb2, 0xb2, 0x07, 0x4b, 0x5f, 0xa2, 0x4b, 0x93, 0x2c, 0x42, 0xf4, 0x11, 0x98, 0x91, 0x21, 0xe3, 0x51, 0xd0,
0x8e, 0xaf, 0xe7, 0x68, 0xfc, 0x20, 0x90, 0xc3, 0x5d, 0xbf, 0x74, 0xc4, 0xc5, 0x35, 0x43, 0x91, 0x97, 0xac, 0xac, 0xe3, 0xeb, 0x39, 0x1a, 0x5f, 0x09, 0xe4, 0x70, 0xff, 0xcf, 0x1d, 0x71, 0x79,
0x5b, 0x0c, 0x45, 0x21, 0x75, 0xe1, 0x88, 0x0b, 0xfd, 0x18, 0x18, 0x9e, 0xe9, 0x03, 0xc8, 0xfd, 0xc3, 0x64, 0xe4, 0x0f, 0x26, 0xa3, 0x90, 0xba, 0x74, 0xc4, 0xa5, 0x7e, 0x20, 0x0c, 0xbf, 0xe9,
0xd9, 0x31, 0x0e, 0xd0, 0x87, 0x00, 0xba, 0xba, 0xf0, 0x2e, 0x39, 0x3a, 0x3c, 0xc9, 0x72, 0x18, 0x7f, 0x90, 0xfb, 0xb9, 0x63, 0x1c, 0xa0, 0xff, 0x03, 0xe8, 0xea, 0xc2, 0xbb, 0xe2, 0xe8, 0xfa,
0x19, 0x7a, 0x97, 0x9c, 0x76, 0x21, 0xb7, 0x7e, 0xce, 0x68, 0xe7, 0xff, 0xdd, 0x65, 0x2c, 0x6b, 0x24, 0xcb, 0x61, 0x64, 0xe8, 0x5d, 0x71, 0xda, 0x85, 0xdc, 0xfa, 0x89, 0xa3, 0xc5, 0xff, 0x76,
0x4c, 0x60, 0x7b, 0xc8, 0xa5, 0x9c, 0xf1, 0x39, 0xf7, 0x25, 0xe3, 0x1f, 0x97, 0x5c, 0x48, 0xda, 0x97, 0xb1, 0xac, 0x31, 0x81, 0xed, 0x21, 0x97, 0x72, 0xc6, 0xe7, 0xdc, 0x97, 0x8c, 0xbf, 0x5b,
0x5c, 0x59, 0x9f, 0x60, 0x51, 0xba, 0xf2, 0x78, 0xfc, 0x73, 0x58, 0x3d, 0x87, 0xc7, 0x90, 0xc6, 0x72, 0x21, 0x69, 0x73, 0xf5, 0x1c, 0x08, 0x16, 0xa5, 0x2b, 0xdf, 0xc7, 0x3f, 0x8c, 0xd5, 0x13,
0x1c, 0x0e, 0x95, 0x6f, 0x17, 0xaf, 0x31, 0x99, 0xce, 0x35, 0xbe, 0x11, 0xa0, 0x9b, 0x4d, 0xc4, 0x79, 0x08, 0x69, 0xcc, 0xe1, 0x50, 0xf9, 0x76, 0xf1, 0x06, 0x93, 0xe9, 0x5c, 0xe3, 0x33, 0x01,
0x22, 0xf0, 0x05, 0xbf, 0xcb, 0x1e, 0x8f, 0xc0, 0x10, 0xd2, 0x91, 0x4b, 0x81, 0x7d, 0x4b, 0xed, 0xba, 0xd9, 0x44, 0x2c, 0x02, 0x5f, 0xf0, 0xfb, 0xec, 0xf1, 0x08, 0x0c, 0x21, 0x1d, 0xb9, 0x14,
0x47, 0xab, 0xbe, 0x7f, 0xb7, 0x69, 0x0d, 0x91, 0xc8, 0x22, 0x41, 0xe3, 0x10, 0x0c, 0x1d, 0xa1, 0xd8, 0xb7, 0xd4, 0x7e, 0xb0, 0xea, 0xfb, 0x6b, 0x9b, 0xd6, 0x10, 0x89, 0x2c, 0x12, 0x34, 0x0e,
0x79, 0xc8, 0xd8, 0xa7, 0x6f, 0x3b, 0x27, 0x76, 0xdf, 0xdc, 0xa2, 0x05, 0xc8, 0x76, 0x7a, 0x3d, 0xc1, 0xd0, 0x11, 0x9a, 0x87, 0x8c, 0x7d, 0xfa, 0xaa, 0x73, 0x62, 0xf7, 0xcd, 0x2d, 0x5a, 0x80,
0x6b, 0x30, 0xb2, 0xfa, 0x26, 0x51, 0x88, 0x59, 0xaf, 0xac, 0x9e, 0x42, 0x89, 0xbd, 0x29, 0xe4, 0x6c, 0xa7, 0xd7, 0xb3, 0x06, 0x23, 0xab, 0x6f, 0x12, 0x85, 0x98, 0xf5, 0xc2, 0xea, 0x29, 0x94,
0x37, 0x5e, 0xf7, 0x75, 0x5d, 0x06, 0x92, 0x83, 0xb3, 0x91, 0x49, 0xd4, 0xe1, 0xd8, 0x1a, 0x99, 0xd8, 0x9b, 0x42, 0x7e, 0xe3, 0xc5, 0xdf, 0xd4, 0x65, 0x20, 0x39, 0x38, 0x1f, 0x99, 0x44, 0x7d,
0x09, 0x5a, 0x84, 0xdc, 0xb1, 0x35, 0x1a, 0x77, 0xce, 0xfa, 0xf6, 0xc8, 0x4c, 0xd2, 0x12, 0x80, 0x1c, 0x5b, 0x23, 0x33, 0x41, 0x8b, 0x90, 0x3b, 0xb6, 0x46, 0xe3, 0xce, 0x79, 0xdf, 0x1e, 0x99,
0x82, 0xcc, 0x1a, 0x74, 0x6c, 0x66, 0xa6, 0x14, 0x1e, 0x9c, 0xad, 0x71, 0x9a, 0x02, 0x18, 0x7d, 0x49, 0x5a, 0x02, 0x50, 0x90, 0x59, 0x83, 0x8e, 0xcd, 0xcc, 0x94, 0xc2, 0x83, 0xf3, 0x35, 0x4e,
0xeb, 0xc4, 0x1a, 0x59, 0xa6, 0xd1, 0x1e, 0x82, 0x81, 0x17, 0x27, 0xa8, 0x0d, 0x10, 0x8f, 0x42, 0x53, 0x00, 0xa3, 0x6f, 0x9d, 0x58, 0x23, 0xcb, 0x34, 0xda, 0x43, 0x30, 0xf0, 0xe2, 0x04, 0xb5,
0xef, 0xdf, 0x34, 0x1e, 0xae, 0xaa, 0x5a, 0xfd, 0xf7, 0xe4, 0x8d, 0xad, 0x26, 0x79, 0x4a, 0xba, 0x01, 0xe2, 0x51, 0xe8, 0xbf, 0xb7, 0x8d, 0x87, 0xab, 0xaa, 0x56, 0x7f, 0x3f, 0x79, 0x63, 0xab,
0xa9, 0x77, 0x89, 0xc5, 0x64, 0x62, 0xa0, 0x21, 0x9e, 0xfd, 0x0e, 0x00, 0x00, 0xff, 0xff, 0x71, 0x49, 0x1e, 0x93, 0x6e, 0xea, 0x75, 0x62, 0x31, 0x99, 0x18, 0x68, 0x88, 0x27, 0x3f, 0x02, 0x00,
0xd3, 0xb9, 0x60, 0x33, 0x06, 0x00, 0x00, 0x00, 0xff, 0xff, 0x68, 0x6d, 0x5d, 0xe7, 0x47, 0x06, 0x00, 0x00,
} }
// Reference imports to suppress errors if they are not otherwise used. // Reference imports to suppress errors if they are not otherwise used.

4
pkg/pb/orders.proto
View File

@ -38,8 +38,8 @@ message OrderLimit {
int64 limit = 6; int64 limit = 6;
PieceAction action = 7; PieceAction action = 7;
google.protobuf.Timestamp piece_expiration = 8; google.protobuf.Timestamp piece_expiration = 8 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false];
google.protobuf.Timestamp order_expiration = 9; google.protobuf.Timestamp order_expiration = 9 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false];
google.protobuf.Timestamp order_creation = 12 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false]; google.protobuf.Timestamp order_creation = 12 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false];
bytes satellite_signature = 10; bytes satellite_signature = 10;

120
pkg/pb/pointerdb.pb.go
View File

@ -7,7 +7,7 @@ import (
fmt "fmt" fmt "fmt"
_ "github.com/gogo/protobuf/gogoproto" _ "github.com/gogo/protobuf/gogoproto"
proto "github.com/gogo/protobuf/proto" proto "github.com/gogo/protobuf/proto"
timestamp "github.com/golang/protobuf/ptypes/timestamp" _ "github.com/golang/protobuf/ptypes/timestamp"
math "math" math "math"
time "time" time "time"
) )
@ -253,16 +253,16 @@ func (m *RemoteSegment) GetMerkleRoot() []byte {
} }
type Pointer struct { type Pointer struct {
Type Pointer_DataType `protobuf:"varint,1,opt,name=type,proto3,enum=pointerdb.Pointer_DataType" json:"type,omitempty"` Type Pointer_DataType `protobuf:"varint,1,opt,name=type,proto3,enum=pointerdb.Pointer_DataType" json:"type,omitempty"`
InlineSegment []byte `protobuf:"bytes,3,opt,name=inline_segment,json=inlineSegment,proto3" json:"inline_segment,omitempty"` InlineSegment []byte `protobuf:"bytes,3,opt,name=inline_segment,json=inlineSegment,proto3" json:"inline_segment,omitempty"`
Remote *RemoteSegment `protobuf:"bytes,4,opt,name=remote,proto3" json:"remote,omitempty"` Remote *RemoteSegment `protobuf:"bytes,4,opt,name=remote,proto3" json:"remote,omitempty"`
SegmentSize int64 `protobuf:"varint,5,opt,name=segment_size,json=segmentSize,proto3" json:"segment_size,omitempty"` SegmentSize int64 `protobuf:"varint,5,opt,name=segment_size,json=segmentSize,proto3" json:"segment_size,omitempty"`
CreationDate time.Time `protobuf:"bytes,6,opt,name=creation_date,json=creationDate,proto3,stdtime" json:"creation_date"` CreationDate time.Time `protobuf:"bytes,6,opt,name=creation_date,json=creationDate,proto3,stdtime" json:"creation_date"`
ExpirationDate *timestamp.Timestamp `protobuf:"bytes,7,opt,name=expiration_date,json=expirationDate,proto3" json:"expiration_date,omitempty"` ExpirationDate time.Time `protobuf:"bytes,7,opt,name=expiration_date,json=expirationDate,proto3,stdtime" json:"expiration_date"`
Metadata []byte `protobuf:"bytes,8,opt,name=metadata,proto3" json:"metadata,omitempty"` Metadata []byte `protobuf:"bytes,8,opt,name=metadata,proto3" json:"metadata,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"` XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"` XXX_sizecache int32 `json:"-"`
} }
func (m *Pointer) Reset() { *m = Pointer{} } func (m *Pointer) Reset() { *m = Pointer{} }
@ -324,11 +324,11 @@ func (m *Pointer) GetCreationDate() time.Time {
return time.Time{} return time.Time{}
} }
func (m *Pointer) GetExpirationDate() *timestamp.Timestamp { func (m *Pointer) GetExpirationDate() time.Time {
if m != nil { if m != nil {
return m.ExpirationDate return m.ExpirationDate
} }
return nil return time.Time{}
} }
func (m *Pointer) GetMetadata() []byte { func (m *Pointer) GetMetadata() []byte {
@ -453,51 +453,51 @@ func init() {
func init() { proto.RegisterFile("pointerdb.proto", fileDescriptor_75fef806d28fc810) } func init() { proto.RegisterFile("pointerdb.proto", fileDescriptor_75fef806d28fc810) }
var fileDescriptor_75fef806d28fc810 = []byte{ var fileDescriptor_75fef806d28fc810 = []byte{
// 723 bytes of a gzipped FileDescriptorProto // 721 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x53, 0xcd, 0x8e, 0xe3, 0x44, 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x53, 0xcd, 0x8e, 0xdb, 0x36,
0x10, 0x1e, 0xe7, 0xc7, 0xf1, 0x94, 0x9d, 0x9f, 0x6d, 0xad, 0xc0, 0xca, 0x22, 0x65, 0xb0, 0xb4, 0x10, 0x5e, 0xf9, 0x47, 0xd6, 0x8e, 0xe4, 0x9f, 0x10, 0x41, 0x2b, 0x38, 0x05, 0xbc, 0x15, 0x90,
0x30, 0x88, 0x95, 0x07, 0x79, 0x6f, 0xec, 0x6d, 0xc8, 0x48, 0x44, 0x5a, 0xc2, 0xa8, 0x93, 0x13, 0x76, 0x8b, 0x06, 0xda, 0x42, 0xb9, 0x35, 0xb7, 0x85, 0x17, 0xa8, 0x81, 0xc4, 0x5d, 0xd0, 0x3e,
0x17, 0xab, 0x13, 0xd7, 0xc6, 0x2d, 0x62, 0xb7, 0xb7, 0xbb, 0x23, 0xed, 0xcc, 0x03, 0x70, 0xe6, 0xf5, 0x22, 0xd0, 0xd6, 0xc4, 0x22, 0x6a, 0x89, 0x0a, 0x49, 0x03, 0xd9, 0x7d, 0x8a, 0x5c, 0xfb,
0xca, 0xc3, 0x70, 0xe7, 0x19, 0x38, 0xec, 0xbe, 0x0a, 0x72, 0xb7, 0x9d, 0x64, 0x59, 0x09, 0x2e, 0x30, 0xbd, 0xf7, 0x19, 0x7a, 0x48, 0x5e, 0xa5, 0x10, 0x29, 0xd9, 0x4e, 0x03, 0x14, 0xe8, 0x45,
0x76, 0xfd, 0x7c, 0xf5, 0xd3, 0x5f, 0x55, 0xc1, 0xb8, 0x12, 0xbc, 0xd4, 0x28, 0xb3, 0x4d, 0x5c, 0x9a, 0x9f, 0x6f, 0x7e, 0xf8, 0xcd, 0x0c, 0x8c, 0x2b, 0xc1, 0x4b, 0x8d, 0x32, 0xdb, 0xc4, 0x95,
0x49, 0xa1, 0x05, 0xb9, 0x3c, 0x1a, 0xa6, 0xb3, 0x9d, 0x10, 0xbb, 0x3d, 0xde, 0x18, 0xc7, 0xe6, 0x14, 0x5a, 0x90, 0xcb, 0xa3, 0x61, 0x3a, 0xdb, 0x09, 0xb1, 0xdb, 0xe3, 0x8d, 0x71, 0x6c, 0x0e,
0xf0, 0xe6, 0x46, 0xf3, 0x02, 0x95, 0x66, 0x45, 0x65, 0xb1, 0x53, 0xd8, 0x89, 0x9d, 0x68, 0xe5, 0x6f, 0x6f, 0x34, 0x2f, 0x50, 0x69, 0x56, 0x54, 0x16, 0x3b, 0x85, 0x9d, 0xd8, 0x89, 0x56, 0x2e,
0x52, 0x64, 0xd8, 0xc8, 0x81, 0x90, 0x19, 0x4a, 0x65, 0xb5, 0xe8, 0x8f, 0x0e, 0x4c, 0x28, 0x66, 0x45, 0x86, 0x8d, 0x1c, 0x08, 0x99, 0xa1, 0x54, 0x56, 0x8b, 0xfe, 0xe8, 0xc0, 0x84, 0x62, 0x76,
0x87, 0x32, 0x63, 0xe5, 0xf6, 0x61, 0xb5, 0xcd, 0xb1, 0x40, 0xf2, 0x3d, 0xf4, 0xf4, 0x43, 0x85, 0x28, 0x33, 0x56, 0x6e, 0x1f, 0x56, 0xdb, 0x1c, 0x0b, 0x24, 0x3f, 0x43, 0x4f, 0x3f, 0x54, 0x18,
0xa1, 0x73, 0xe5, 0x5c, 0x8f, 0x92, 0xaf, 0xe2, 0x53, 0x1b, 0xff, 0x86, 0xc6, 0xf6, 0xb7, 0x7e, 0x3a, 0x57, 0xce, 0xf5, 0x28, 0xf9, 0x2e, 0x3e, 0xb5, 0xf1, 0x6f, 0x68, 0x6c, 0x7f, 0xeb, 0x87,
0xa8, 0x90, 0x9a, 0x18, 0xf2, 0x39, 0x0c, 0x0a, 0x5e, 0xa6, 0x12, 0xdf, 0x86, 0x9d, 0x2b, 0xe7, 0x0a, 0xa9, 0x89, 0x21, 0x5f, 0xc3, 0xa0, 0xe0, 0x65, 0x2a, 0xf1, 0x5d, 0xd8, 0xb9, 0x72, 0xae,
0xba, 0x4f, 0xdd, 0x82, 0x97, 0x14, 0xdf, 0x92, 0xa7, 0xd0, 0xd7, 0x42, 0xb3, 0x7d, 0xd8, 0x35, 0xfb, 0xd4, 0x2d, 0x78, 0x49, 0xf1, 0x1d, 0x79, 0x0a, 0x7d, 0x2d, 0x34, 0xdb, 0x87, 0x5d, 0x63,
0x66, 0xab, 0x90, 0x6f, 0x60, 0x22, 0xb1, 0x62, 0x5c, 0xa6, 0x3a, 0x97, 0xa8, 0x72, 0xb1, 0xcf, 0xb6, 0x0a, 0xf9, 0x01, 0x26, 0x12, 0x2b, 0xc6, 0x65, 0xaa, 0x73, 0x89, 0x2a, 0x17, 0xfb, 0x2c,
0xc2, 0x9e, 0x01, 0x8c, 0xad, 0x7d, 0xdd, 0x9a, 0xc9, 0xb7, 0xf0, 0x44, 0x1d, 0xb6, 0x5b, 0x54, 0xec, 0x19, 0xc0, 0xd8, 0xda, 0xd7, 0xad, 0x99, 0xfc, 0x08, 0x4f, 0xd4, 0x61, 0xbb, 0x45, 0xa5,
0xea, 0x0c, 0xdb, 0x37, 0xd8, 0x49, 0xe3, 0x38, 0x81, 0x5f, 0x00, 0x41, 0xc9, 0xd4, 0x41, 0x62, 0xce, 0xb0, 0x7d, 0x83, 0x9d, 0x34, 0x8e, 0x13, 0xf8, 0x05, 0x10, 0x94, 0x4c, 0x1d, 0x24, 0xa6,
0xaa, 0x72, 0x56, 0x7f, 0xf9, 0x23, 0x86, 0xae, 0x45, 0x37, 0x9e, 0x55, 0xed, 0x58, 0xf1, 0x47, 0x2a, 0x67, 0xf5, 0x97, 0x3f, 0x62, 0xe8, 0x5a, 0x74, 0xe3, 0x59, 0xd5, 0x8e, 0x15, 0x7f, 0xc4,
0x8c, 0x9e, 0x02, 0x9c, 0x1e, 0x42, 0x5c, 0xe8, 0xd0, 0xd5, 0xe4, 0x22, 0x7a, 0x04, 0x9f, 0x62, 0xe8, 0x29, 0xc0, 0xe9, 0x21, 0xc4, 0x85, 0x0e, 0x5d, 0x4d, 0x2e, 0xa2, 0x47, 0xf0, 0x29, 0x16,
0x21, 0x34, 0xde, 0x73, 0xdc, 0x22, 0x79, 0x06, 0x97, 0x55, 0x2d, 0xa4, 0xe5, 0xa1, 0x30, 0xd4, 0x42, 0xe3, 0x3d, 0xc7, 0x2d, 0x92, 0x67, 0x70, 0x59, 0xd5, 0x42, 0x5a, 0x1e, 0x0a, 0x43, 0x4d,
0xf4, 0xa9, 0x67, 0x0c, 0xcb, 0x43, 0x41, 0xbe, 0x86, 0x41, 0xcd, 0x71, 0xca, 0x33, 0xf3, 0xec, 0x9f, 0x7a, 0xc6, 0xb0, 0x3c, 0x14, 0xe4, 0x7b, 0x18, 0xd4, 0x1c, 0xa7, 0x3c, 0x33, 0xcf, 0x0e,
0xe0, 0x76, 0xf4, 0xd7, 0xfb, 0xd9, 0xc5, 0xdf, 0xef, 0x67, 0xee, 0x52, 0x64, 0xb8, 0x98, 0x53, 0x6e, 0x47, 0x7f, 0x7d, 0x9c, 0x5d, 0xfc, 0xfd, 0x71, 0xe6, 0x2e, 0x45, 0x86, 0x8b, 0x39, 0x75,
0xb7, 0x76, 0x2f, 0x32, 0xf2, 0x1c, 0x7a, 0x39, 0x53, 0xb9, 0x61, 0xc1, 0x4f, 0x9e, 0xc4, 0xcd, 0x6b, 0xf7, 0x22, 0x23, 0xcf, 0xa1, 0x97, 0x33, 0x95, 0x1b, 0x16, 0xfc, 0xe4, 0x49, 0xdc, 0x4c,
0x34, 0x4c, 0x89, 0x1f, 0x99, 0xca, 0xa9, 0x71, 0x47, 0x1f, 0x1c, 0x18, 0xda, 0xe2, 0x2b, 0xdc, 0xc3, 0x94, 0xf8, 0x85, 0xa9, 0x9c, 0x1a, 0x77, 0xf4, 0xc9, 0x81, 0xa1, 0x2d, 0xbe, 0xc2, 0x5d,
0x15, 0x58, 0x6a, 0xf2, 0x0a, 0x40, 0x1e, 0xd9, 0x37, 0xf5, 0xfd, 0xe4, 0xd9, 0x7f, 0x8c, 0x86, 0x81, 0xa5, 0x26, 0xaf, 0x00, 0xe4, 0x91, 0x7d, 0x53, 0xdf, 0x4f, 0x9e, 0xfd, 0xc7, 0x68, 0xe8,
0x9e, 0xc1, 0xc9, 0x4b, 0x18, 0x4a, 0x21, 0x74, 0x6a, 0x1f, 0x70, 0x6c, 0x72, 0xdc, 0x34, 0x39, 0x19, 0x9c, 0xbc, 0x84, 0xa1, 0x14, 0x42, 0xa7, 0xf6, 0x01, 0xc7, 0x26, 0xc7, 0x4d, 0x93, 0x03,
0x30, 0xe5, 0x17, 0x73, 0xea, 0xd7, 0x28, 0xab, 0x64, 0xe4, 0x15, 0x0c, 0xa5, 0x69, 0xc1, 0x86, 0x53, 0x7e, 0x31, 0xa7, 0x7e, 0x8d, 0xb2, 0x4a, 0x46, 0x5e, 0xc1, 0x50, 0x9a, 0x16, 0x6c, 0x98,
0xa9, 0xb0, 0x7b, 0xd5, 0xbd, 0xf6, 0x93, 0xcf, 0x3e, 0x2a, 0x7a, 0xe4, 0x87, 0x06, 0xf2, 0xa4, 0x0a, 0xbb, 0x57, 0xdd, 0x6b, 0x3f, 0xf9, 0xea, 0xb3, 0xa2, 0x47, 0x7e, 0x68, 0x20, 0x4f, 0x8a,
0x28, 0x32, 0x03, 0xbf, 0x40, 0xf9, 0xeb, 0x1e, 0xd3, 0x3a, 0xa5, 0x99, 0x69, 0x40, 0xc1, 0x9a, 0x22, 0x33, 0xf0, 0x0b, 0x94, 0xbf, 0xef, 0x31, 0xad, 0x53, 0x9a, 0x99, 0x06, 0x14, 0xac, 0x89,
0xa8, 0x10, 0x3a, 0xfa, 0xad, 0x0b, 0x83, 0x7b, 0x9b, 0x88, 0xdc, 0x7c, 0xb4, 0x70, 0xe7, 0xaf, 0x0a, 0xa1, 0xa3, 0x0f, 0x5d, 0x18, 0xdc, 0xdb, 0x44, 0xe4, 0xe6, 0xb3, 0x85, 0x3b, 0x7f, 0x55,
0x6a, 0x10, 0xf1, 0x9c, 0x69, 0x76, 0xb6, 0x65, 0xcf, 0x61, 0xc4, 0xcb, 0x3d, 0x2f, 0x31, 0x55, 0x83, 0x88, 0xe7, 0x4c, 0xb3, 0xb3, 0x2d, 0x7b, 0x0e, 0x23, 0x5e, 0xee, 0x79, 0x89, 0xa9, 0xb2,
0x96, 0x1e, 0xc3, 0x67, 0x40, 0x87, 0xd6, 0xda, 0x72, 0xf6, 0x1d, 0xb8, 0xb6, 0x29, 0x53, 0xdf, 0xf4, 0x18, 0x3e, 0x03, 0x3a, 0xb4, 0xd6, 0x96, 0xb3, 0x9f, 0xc0, 0xb5, 0x4d, 0x99, 0xfa, 0x7e,
0x4f, 0xc2, 0x4f, 0x5a, 0x6f, 0x90, 0xb4, 0xc1, 0x91, 0x2f, 0x21, 0x68, 0x32, 0xda, 0x8d, 0xa9, 0x12, 0x7e, 0xd1, 0x7a, 0x83, 0xa4, 0x0d, 0x8e, 0x7c, 0x0b, 0x41, 0x93, 0xd1, 0x6e, 0x4c, 0xbd,
0xf7, 0xab, 0x4b, 0xfd, 0xc6, 0x56, 0x2f, 0x0b, 0x59, 0xc0, 0x70, 0x2b, 0x91, 0x69, 0x2e, 0xca, 0x5f, 0x5d, 0xea, 0x37, 0xb6, 0x7a, 0x59, 0xc8, 0x02, 0x86, 0x5b, 0x89, 0x4c, 0x73, 0x51, 0xa6,
0x34, 0x63, 0xda, 0x6e, 0x95, 0x9f, 0x4c, 0x63, 0x7b, 0x91, 0x71, 0x7b, 0x91, 0xf1, 0xba, 0xbd, 0x19, 0xd3, 0x76, 0xab, 0xfc, 0x64, 0x1a, 0xdb, 0x8b, 0x8c, 0xdb, 0x8b, 0x8c, 0xd7, 0xed, 0x45,
0xc8, 0x5b, 0xaf, 0xe6, 0xf9, 0xf7, 0x0f, 0x33, 0x87, 0x06, 0x6d, 0xe8, 0x9c, 0x69, 0x24, 0x3f, 0xde, 0x7a, 0x35, 0xcf, 0x1f, 0x3e, 0xcd, 0x1c, 0x1a, 0xb4, 0xa1, 0x73, 0xa6, 0x91, 0xbc, 0x81,
0xc0, 0x18, 0xdf, 0x55, 0x5c, 0x9e, 0x25, 0x1b, 0xfc, 0x5f, 0x32, 0x3a, 0x3a, 0x85, 0x98, 0x24, 0x31, 0xbe, 0xaf, 0xb8, 0x3c, 0x4b, 0x36, 0xf8, 0x1f, 0xc9, 0x46, 0xa7, 0x60, 0x93, 0x6e, 0x0a,
0x53, 0xf0, 0x0a, 0xd4, 0x2c, 0x63, 0x9a, 0x85, 0x9e, 0x61, 0xe1, 0xa8, 0x47, 0x11, 0x78, 0x2d, 0x5e, 0x81, 0x9a, 0x65, 0x4c, 0xb3, 0xd0, 0x33, 0x7c, 0x1c, 0xf5, 0x28, 0x02, 0xaf, 0xe5, 0x90,
0x73, 0x04, 0xc0, 0x5d, 0x2c, 0x5f, 0x2f, 0x96, 0x77, 0x93, 0x8b, 0x5a, 0xa6, 0x77, 0x3f, 0xfd, 0x00, 0xb8, 0x8b, 0xe5, 0xeb, 0xc5, 0xf2, 0x6e, 0x72, 0x51, 0xcb, 0xf4, 0xee, 0xcd, 0xaf, 0xeb,
0xbc, 0xbe, 0x9b, 0x38, 0xd1, 0x9f, 0x0e, 0x04, 0xaf, 0xb9, 0xd2, 0x14, 0x55, 0x25, 0x4a, 0x85, 0xbb, 0x89, 0x13, 0xfd, 0xe9, 0x40, 0xf0, 0x9a, 0x2b, 0x4d, 0x51, 0x55, 0xa2, 0x54, 0x48, 0x12,
0x24, 0x81, 0x3e, 0xd7, 0x58, 0xa8, 0xd0, 0x31, 0xf3, 0xfe, 0xe2, 0x8c, 0xb4, 0x73, 0x5c, 0xbc, 0xe8, 0x73, 0x8d, 0x85, 0x0a, 0x1d, 0x33, 0xf9, 0x6f, 0xce, 0xe8, 0x3b, 0xc7, 0xc5, 0x0b, 0x8d,
0xd0, 0x58, 0x50, 0x0b, 0x25, 0x04, 0x7a, 0x85, 0x90, 0x68, 0xf6, 0xca, 0xa3, 0x46, 0x9e, 0x22, 0x05, 0xb5, 0x50, 0x42, 0xa0, 0x57, 0x08, 0x89, 0x66, 0xc3, 0x3c, 0x6a, 0xe4, 0x29, 0x42, 0xaf,
0xf4, 0x6a, 0x48, 0xed, 0xab, 0x98, 0xce, 0xcd, 0x74, 0x2f, 0xa9, 0x91, 0xc9, 0x0b, 0x18, 0x34, 0x86, 0xd4, 0xbe, 0x8a, 0xe9, 0xdc, 0xcc, 0xf9, 0x92, 0x1a, 0x99, 0xbc, 0x80, 0x41, 0x93, 0xd5,
0x59, 0x4d, 0x88, 0x9f, 0x90, 0x4f, 0x87, 0x4e, 0x5b, 0x48, 0x7d, 0x7a, 0x5c, 0xa5, 0x95, 0xc4, 0x84, 0xf8, 0x09, 0xf9, 0x72, 0xfc, 0xb4, 0x85, 0xd4, 0x47, 0xc8, 0x55, 0x5a, 0x49, 0x7c, 0xcb,
0x37, 0xfc, 0x9d, 0x99, 0xb4, 0x47, 0x3d, 0xae, 0xee, 0x8d, 0x7e, 0xdb, 0xfb, 0xa5, 0x53, 0x6d, 0xdf, 0x9b, 0x99, 0x7b, 0xd4, 0xe3, 0xea, 0xde, 0xe8, 0xb7, 0xbd, 0xdf, 0x3a, 0xd5, 0x66, 0xe3,
0x36, 0xae, 0x61, 0xea, 0xe5, 0x3f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x6c, 0xaf, 0xb9, 0x48, 0x34, 0x1a, 0xce, 0x5e, 0xfe, 0x13, 0x00, 0x00, 0xff, 0xff, 0x35, 0x37, 0x11, 0xe0, 0x3e, 0x05, 0x00,
0x05, 0x00, 0x00, 0x00,
} }

2
pkg/pb/pointerdb.proto
View File

@ -52,7 +52,7 @@ message Pointer {
int64 segment_size = 5; int64 segment_size = 5;
google.protobuf.Timestamp creation_date = 6 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false]; google.protobuf.Timestamp creation_date = 6 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false];
google.protobuf.Timestamp expiration_date = 7; google.protobuf.Timestamp expiration_date = 7 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false];
bytes metadata = 8; bytes metadata = 8;
} }

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

@ -12,7 +12,6 @@ import (
"testing" "testing"
"time" "time"
"github.com/golang/protobuf/ptypes"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require" "github.com/stretchr/testify/require"
"github.com/vivint/infectious" "github.com/vivint/infectious"
@ -150,10 +149,7 @@ func newAddressedOrderLimit(ctx context.Context, action pb.PieceAction, satellit
// TODO refactor to avoid OrderLimit duplication // TODO refactor to avoid OrderLimit duplication
serialNumber := testrand.SerialNumber() serialNumber := testrand.SerialNumber()
orderExpiration, err := ptypes.TimestampProto(time.Now().Add(24 * time.Hour)) now := time.Now()
if err != nil {
return nil, err
}
limit := &pb.OrderLimit{ limit := &pb.OrderLimit{
SerialNumber: serialNumber, SerialNumber: serialNumber,
@ -163,12 +159,12 @@ func newAddressedOrderLimit(ctx context.Context, action pb.PieceAction, satellit
PieceId: pieceID, PieceId: pieceID,
Action: action, Action: action,
Limit: dataSize.Int64(), Limit: dataSize.Int64(),
PieceExpiration: nil, PieceExpiration: time.Time{},
OrderCreation: time.Now(), OrderCreation: now,
OrderExpiration: orderExpiration, OrderExpiration: now.Add(24 * time.Hour),
} }
limit, err = signing.SignOrderLimit(ctx, signing.SignerFromFullIdentity(satellite.Identity), limit) limit, err := signing.SignOrderLimit(ctx, signing.SignerFromFullIdentity(satellite.Identity), limit)
if err != nil { if err != nil {
return nil, err return nil, err
} }

2
pkg/storage/segments/repairer.go
View File

@ -153,7 +153,7 @@ func (repairer *Repairer) Repair(ctx context.Context, path storj.Path) (err erro
defer func() { err = errs.Combine(err, r.Close()) }() defer func() { err = errs.Combine(err, r.Close()) }()
// Upload the repaired pieces // Upload the repaired pieces
successfulNodes, hashes, err := repairer.ec.Repair(ctx, putLimits, redundancy, r, convertTime(expiration), repairer.timeout, path) successfulNodes, hashes, err := repairer.ec.Repair(ctx, putLimits, redundancy, r, expiration, repairer.timeout, path)
if err != nil { if err != nil {
return Error.Wrap(err) return Error.Wrap(err)
} }

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

@ -11,10 +11,7 @@ import (
"strings" "strings"
"time" "time"
"github.com/golang/protobuf/ptypes" "gopkg.in/spacemonkeygo/monkit.v2"
"github.com/golang/protobuf/ptypes/timestamp"
"go.uber.org/zap"
monkit "gopkg.in/spacemonkeygo/monkit.v2"
"storj.io/storj/pkg/eestream" "storj.io/storj/pkg/eestream"
"storj.io/storj/pkg/pb" "storj.io/storj/pkg/pb"
@ -101,14 +98,6 @@ func (s *segmentStore) Put(ctx context.Context, data io.Reader, expiration time.
ErasureShareSize: int32(s.rs.ErasureShareSize()), ErasureShareSize: int32(s.rs.ErasureShareSize()),
} }
var exp *timestamp.Timestamp
if !expiration.IsZero() {
exp, err = ptypes.TimestampProto(expiration)
if err != nil {
return Meta{}, Error.Wrap(err)
}
}
peekReader := NewPeekThresholdReader(data) peekReader := NewPeekThresholdReader(data)
remoteSized, err := peekReader.IsLargerThan(s.thresholdSize) remoteSized, err := peekReader.IsLargerThan(s.thresholdSize)
if err != nil { if err != nil {
@ -130,7 +119,7 @@ func (s *segmentStore) Put(ctx context.Context, data io.Reader, expiration time.
Type: pb.Pointer_INLINE, Type: pb.Pointer_INLINE,
InlineSegment: peekReader.thresholdBuf, InlineSegment: peekReader.thresholdBuf,
SegmentSize: int64(len(peekReader.thresholdBuf)), SegmentSize: int64(len(peekReader.thresholdBuf)),
ExpirationDate: exp, ExpirationDate: expiration,
Metadata: metadata, Metadata: metadata,
} }
} else { } else {
@ -163,7 +152,7 @@ func (s *segmentStore) Put(ctx context.Context, data io.Reader, expiration time.
} }
path = p path = p
pointer, err = makeRemotePointer(successfulNodes, successfulHashes, s.rs, rootPieceID, sizedReader.Size(), exp, metadata) pointer, err = makeRemotePointer(successfulNodes, successfulHashes, s.rs, rootPieceID, sizedReader.Size(), expiration, metadata)
if err != nil { if err != nil {
return Meta{}, Error.Wrap(err) return Meta{}, Error.Wrap(err)
} }
@ -239,7 +228,7 @@ func (s *segmentStore) Get(ctx context.Context, path storj.Path) (rr ranger.Rang
} }
// makeRemotePointer creates a pointer of type remote // makeRemotePointer creates a pointer of type remote
func makeRemotePointer(nodes []*pb.Node, hashes []*pb.PieceHash, rs eestream.RedundancyStrategy, pieceID storj.PieceID, readerSize int64, exp *timestamp.Timestamp, metadata []byte) (pointer *pb.Pointer, err error) { func makeRemotePointer(nodes []*pb.Node, hashes []*pb.PieceHash, rs eestream.RedundancyStrategy, pieceID storj.PieceID, readerSize int64, expiration time.Time, metadata []byte) (pointer *pb.Pointer, err error) {
if len(nodes) != len(hashes) { if len(nodes) != len(hashes) {
return nil, Error.New("unable to make pointer: size of nodes != size of hashes") return nil, Error.New("unable to make pointer: size of nodes != size of hashes")
} }
@ -272,7 +261,7 @@ func makeRemotePointer(nodes []*pb.Node, hashes []*pb.PieceHash, rs eestream.Red
RemotePieces: remotePieces, RemotePieces: remotePieces,
}, },
SegmentSize: readerSize, SegmentSize: readerSize,
ExpirationDate: exp, ExpirationDate: expiration,
Metadata: metadata, Metadata: metadata,
} }
return pointer, nil return pointer, nil
@ -359,24 +348,12 @@ func CalcNeededNodes(rs *pb.RedundancyScheme) int32 {
func convertMeta(pr *pb.Pointer) Meta { func convertMeta(pr *pb.Pointer) Meta {
return Meta{ return Meta{
Modified: pr.GetCreationDate(), Modified: pr.GetCreationDate(),
Expiration: convertTime(pr.GetExpirationDate()), Expiration: pr.GetExpirationDate(),
Size: pr.GetSegmentSize(), Size: pr.GetSegmentSize(),
Data: pr.GetMetadata(), Data: pr.GetMetadata(),
} }
} }
// convertTime converts gRPC timestamp to Go time
func convertTime(ts *timestamp.Timestamp) time.Time {
if ts == nil {
return time.Time{}
}
t, err := ptypes.Timestamp(ts)
if err != nil {
zap.S().Warnf("Failed converting timestamp %v: %v", ts, err)
}
return t
}
func splitPathFragments(path storj.Path) (bucket string, objectPath storj.Path, segmentIndex int64, err error) { func splitPathFragments(path storj.Path) (bucket string, objectPath storj.Path, segmentIndex int64, err error) {
components := storj.SplitPath(path) components := storj.SplitPath(path)
if len(components) < 1 { if len(components) < 1 {

48
proto.lock
View File

@ -1859,7 +1859,17 @@
{ {
"id": 6, "id": 6,
"name": "expiration", "name": "expiration",
"type": "google.protobuf.Timestamp" "type": "google.protobuf.Timestamp",
"options": [
{
"name": "(gogoproto.stdtime)",
"value": "true"
},
{
"name": "(gogoproto.nullable)",
"value": "false"
}
]
} }
] ]
}, },
@ -2786,12 +2796,32 @@
{ {
"id": 8, "id": 8,
"name": "piece_expiration", "name": "piece_expiration",
"type": "google.protobuf.Timestamp" "type": "google.protobuf.Timestamp",
"options": [
{
"name": "(gogoproto.stdtime)",
"value": "true"
},
{
"name": "(gogoproto.nullable)",
"value": "false"
}
]
}, },
{ {
"id": 9, "id": 9,
"name": "order_expiration", "name": "order_expiration",
"type": "google.protobuf.Timestamp" "type": "google.protobuf.Timestamp",
"options": [
{
"name": "(gogoproto.stdtime)",
"value": "true"
},
{
"name": "(gogoproto.nullable)",
"value": "false"
}
]
}, },
{ {
"id": 12, "id": 12,
@ -3502,7 +3532,17 @@
{ {
"id": 7, "id": 7,
"name": "expiration_date", "name": "expiration_date",
"type": "google.protobuf.Timestamp" "type": "google.protobuf.Timestamp",
"options": [
{
"name": "(gogoproto.stdtime)",
"value": "true"
},
{
"name": "(gogoproto.nullable)",
"value": "false"
}
]
}, },
{ {
"id": 8, "id": 8,

12
satellite/metainfo/metainfo.go
View File

@ -10,7 +10,6 @@ import (
"strconv" "strconv"
"time" "time"
"github.com/golang/protobuf/ptypes"
"github.com/skyrings/skyring-common/tools/uuid" "github.com/skyrings/skyring-common/tools/uuid"
"github.com/zeebo/errs" "github.com/zeebo/errs"
"go.uber.org/zap" "go.uber.org/zap"
@ -130,15 +129,8 @@ func (endpoint *Endpoint) SegmentInfoOld(ctx context.Context, req *pb.SegmentInf
func (endpoint *Endpoint) CreateSegmentOld(ctx context.Context, req *pb.SegmentWriteRequestOld) (resp *pb.SegmentWriteResponseOld, err error) { func (endpoint *Endpoint) CreateSegmentOld(ctx context.Context, req *pb.SegmentWriteRequestOld) (resp *pb.SegmentWriteResponseOld, err error) {
defer mon.Task()(&ctx)(&err) defer mon.Task()(&ctx)(&err)
if req.Expiration != nil { if !req.Expiration.IsZero() && !req.Expiration.After(time.Now()) {
exp, err := ptypes.Timestamp(req.Expiration) return nil, errs.New("Invalid expiration time")
if err != nil {
return nil, status.Errorf(codes.InvalidArgument, err.Error())
}
if !exp.After(time.Now()) {
return nil, errs.New("Invalid expiration time")
}
} }
keyInfo, err := endpoint.validateAuth(ctx, macaroon.Action{ keyInfo, err := endpoint.validateAuth(ctx, macaroon.Action{

16
satellite/metainfo/metainfo_test.go
View File

@ -9,7 +9,6 @@ import (
"testing" "testing"
"time" "time"
"github.com/golang/protobuf/ptypes"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require" "github.com/stretchr/testify/require"
"github.com/zeebo/errs" "github.com/zeebo/errs"
@ -329,9 +328,6 @@ func TestCommitSegment(t *testing.T) {
} }
} }
expirationDateProto, err := ptypes.TimestampProto(expirationDate)
require.NoError(t, err)
pointer := &pb.Pointer{ pointer := &pb.Pointer{
CreationDate: time.Now(), CreationDate: time.Now(),
Type: pb.Pointer_REMOTE, Type: pb.Pointer_REMOTE,
@ -341,7 +337,7 @@ func TestCommitSegment(t *testing.T) {
Redundancy: redundancy, Redundancy: redundancy,
RemotePieces: pieces, RemotePieces: pieces,
}, },
ExpirationDate: expirationDateProto, ExpirationDate: expirationDate,
} }
limits := make([]*pb.OrderLimit, len(addresedLimits)) limits := make([]*pb.OrderLimit, len(addresedLimits))
@ -528,7 +524,7 @@ func TestCommitSegmentPointer(t *testing.T) {
}{ }{
{ {
Modify: func(pointer *pb.Pointer) { Modify: func(pointer *pb.Pointer) {
pointer.ExpirationDate.Seconds += 100 pointer.ExpirationDate = pointer.ExpirationDate.Add(time.Second * 100)
}, },
ErrorMessage: "pointer expiration date does not match requested one", ErrorMessage: "pointer expiration date does not match requested one",
}, },
@ -708,10 +704,8 @@ func TestGetProjectInfo(t *testing.T) {
func runCreateSegment(ctx context.Context, t *testing.T, metainfo *metainfo.Client) (*pb.Pointer, []*pb.OrderLimit) { func runCreateSegment(ctx context.Context, t *testing.T, metainfo *metainfo.Client) (*pb.Pointer, []*pb.OrderLimit) {
pointer := createTestPointer(t) pointer := createTestPointer(t)
expirationDate, err := ptypes.Timestamp(pointer.ExpirationDate)
require.NoError(t, err)
addressedLimits, rootPieceID, err := metainfo.CreateSegment(ctx, "my-bucket-name", "file/path", -1, pointer.Remote.Redundancy, memory.MiB.Int64(), expirationDate) addressedLimits, rootPieceID, err := metainfo.CreateSegment(ctx, "my-bucket-name", "file/path", -1, pointer.Remote.Redundancy, memory.MiB.Int64(), pointer.ExpirationDate)
require.NoError(t, err) require.NoError(t, err)
pointer.Remote.RootPieceId = rootPieceID pointer.Remote.RootPieceId = rootPieceID
@ -744,8 +738,6 @@ func createTestPointer(t *testing.T) *pb.Pointer {
segmentSize := 4 * memory.KiB.Int64() segmentSize := 4 * memory.KiB.Int64()
pieceSize := eestream.CalcPieceSize(segmentSize, redundancy) pieceSize := eestream.CalcPieceSize(segmentSize, redundancy)
timestamp := time.Now().Add(time.Hour) timestamp := time.Now().Add(time.Hour)
expiration, err := ptypes.TimestampProto(timestamp)
require.NoError(t, err)
pointer := &pb.Pointer{ pointer := &pb.Pointer{
CreationDate: time.Now(), CreationDate: time.Now(),
Type: pb.Pointer_REMOTE, Type: pb.Pointer_REMOTE,
@ -769,7 +761,7 @@ func createTestPointer(t *testing.T) *pb.Pointer {
}, },
}, },
}, },
ExpirationDate: expiration, ExpirationDate: timestamp,
} }
return pointer return pointer
} }

5
satellite/metainfo/validation.go
View File

@ -11,7 +11,6 @@ import (
"time" "time"
"github.com/gogo/protobuf/proto" "github.com/gogo/protobuf/proto"
"github.com/golang/protobuf/ptypes/timestamp"
"github.com/zeebo/errs" "github.com/zeebo/errs"
"go.uber.org/zap" "go.uber.org/zap"
"google.golang.org/grpc/codes" "google.golang.org/grpc/codes"
@ -39,7 +38,7 @@ type TTLItem struct {
} }
type createRequest struct { type createRequest struct {
Expiration *timestamp.Timestamp Expiration time.Time
Redundancy *pb.RedundancyScheme Redundancy *pb.RedundancyScheme
ttl time.Time ttl time.Time
@ -220,7 +219,7 @@ func (endpoint *Endpoint) validateCommitSegment(ctx context.Context, req *pb.Seg
switch { switch {
case !found: case !found:
return Error.New("missing create request or request expired") return Error.New("missing create request or request expired")
case !proto.Equal(createRequest.Expiration, req.Pointer.ExpirationDate): case !createRequest.Expiration.Equal(req.Pointer.ExpirationDate):
return Error.New("pointer expiration date does not match requested one") return Error.New("pointer expiration date does not match requested one")
case !proto.Equal(createRequest.Redundancy, req.Pointer.Remote.Redundancy): case !proto.Equal(createRequest.Redundancy, req.Pointer.Remote.Redundancy):
return Error.New("pointer redundancy scheme date does not match requested one") return Error.New("pointer redundancy scheme date does not match requested one")

10
satellite/orders/endpoint.go
View File

@ -8,13 +8,12 @@ import (
"io" "io"
"time" "time"
"github.com/golang/protobuf/ptypes"
"github.com/skyrings/skyring-common/tools/uuid" "github.com/skyrings/skyring-common/tools/uuid"
"github.com/zeebo/errs" "github.com/zeebo/errs"
"go.uber.org/zap" "go.uber.org/zap"
"google.golang.org/grpc/codes" "google.golang.org/grpc/codes"
"google.golang.org/grpc/status" "google.golang.org/grpc/status"
monkit "gopkg.in/spacemonkeygo/monkit.v2" "gopkg.in/spacemonkeygo/monkit.v2"
"storj.io/storj/pkg/auth/signing" "storj.io/storj/pkg/auth/signing"
"storj.io/storj/pkg/certdb" "storj.io/storj/pkg/certdb"
@ -138,11 +137,6 @@ func (endpoint *Endpoint) Settlement(stream pb.Orders_SettlementServer) (err err
return status.Error(codes.Unauthenticated, "only specified storage node can settle order") return status.Error(codes.Unauthenticated, "only specified storage node can settle order")
} }
orderExpiration, err := ptypes.Timestamp(orderLimit.OrderExpiration)
if err != nil {
return status.Errorf(codes.InvalidArgument, err.Error())
}
rejectErr := func() error { rejectErr := func() error {
var uplinkSignee signing.Signee var uplinkSignee signing.Signee
@ -174,7 +168,7 @@ func (endpoint *Endpoint) Settlement(stream pb.Orders_SettlementServer) (err err
return Error.New("invalid serial number") return Error.New("invalid serial number")
} }
if orderExpiration.Before(time.Now()) { if orderLimit.OrderExpiration.Before(time.Now()) {
return Error.New("order limit expired") return Error.New("order limit expired")
} }
return nil return nil

94
satellite/orders/service.go
View File

@ -8,8 +8,6 @@ import (
"context" "context"
"time" "time"
"github.com/golang/protobuf/ptypes"
"github.com/golang/protobuf/ptypes/timestamp"
"github.com/skyrings/skyring-common/tools/uuid" "github.com/skyrings/skyring-common/tools/uuid"
"github.com/zeebo/errs" "github.com/zeebo/errs"
"go.uber.org/zap" "go.uber.org/zap"
@ -121,14 +119,8 @@ func (service *Service) updateBandwidth(ctx context.Context, projectID uuid.UUID
func (service *Service) CreateGetOrderLimits(ctx context.Context, uplink *identity.PeerIdentity, bucketID []byte, pointer *pb.Pointer) (_ []*pb.AddressedOrderLimit, err error) { func (service *Service) CreateGetOrderLimits(ctx context.Context, uplink *identity.PeerIdentity, bucketID []byte, pointer *pb.Pointer) (_ []*pb.AddressedOrderLimit, err error) {
defer mon.Task()(&ctx)(&err) defer mon.Task()(&ctx)(&err)
rootPieceID := pointer.GetRemote().RootPieceId rootPieceID := pointer.GetRemote().RootPieceId
expiration := pointer.ExpirationDate pieceExpiration := pointer.ExpirationDate
orderExpiration := time.Now().Add(service.orderExpiration)
// convert orderExpiration from duration to timestamp
orderExpirationTime := time.Now().UTC().Add(service.orderExpiration)
orderExpiration, err := ptypes.TimestampProto(orderExpirationTime)
if err != nil {
return nil, Error.Wrap(err)
}
serialNumber, err := service.createSerial(ctx) serialNumber, err := service.createSerial(ctx)
if err != nil { if err != nil {
@ -173,7 +165,7 @@ func (service *Service) CreateGetOrderLimits(ctx context.Context, uplink *identi
PieceId: rootPieceID.Derive(piece.NodeId, piece.PieceNum), PieceId: rootPieceID.Derive(piece.NodeId, piece.PieceNum),
Action: pb.PieceAction_GET, Action: pb.PieceAction_GET,
Limit: pieceSize, Limit: pieceSize,
PieceExpiration: expiration, PieceExpiration: pieceExpiration,
OrderCreation: time.Now(), OrderCreation: time.Now(),
OrderExpiration: orderExpiration, OrderExpiration: orderExpiration,
}) })
@ -197,7 +189,7 @@ func (service *Service) CreateGetOrderLimits(ctx context.Context, uplink *identi
return nil, Error.Wrap(err) return nil, Error.Wrap(err)
} }
err = service.saveSerial(ctx, serialNumber, bucketID, orderExpirationTime) err = service.saveSerial(ctx, serialNumber, bucketID, orderExpiration)
if err != nil { if err != nil {
return nil, Error.Wrap(err) return nil, Error.Wrap(err)
} }
@ -214,14 +206,10 @@ func (service *Service) CreateGetOrderLimits(ctx context.Context, uplink *identi
} }
// CreatePutOrderLimits creates the order limits for uploading pieces to nodes. // CreatePutOrderLimits creates the order limits for uploading pieces to nodes.
func (service *Service) CreatePutOrderLimits(ctx context.Context, uplink *identity.PeerIdentity, bucketID []byte, nodes []*pb.Node, expiration *timestamp.Timestamp, maxPieceSize int64) (_ storj.PieceID, _ []*pb.AddressedOrderLimit, err error) { func (service *Service) CreatePutOrderLimits(ctx context.Context, uplink *identity.PeerIdentity, bucketID []byte, nodes []*pb.Node, expiration time.Time, maxPieceSize int64) (_ storj.PieceID, _ []*pb.AddressedOrderLimit, err error) {
defer mon.Task()(&ctx)(&err) defer mon.Task()(&ctx)(&err)
// convert orderExpiration from duration to timestamp
orderExpirationTime := time.Now().UTC().Add(service.orderExpiration) orderExpiration := time.Now().Add(service.orderExpiration)
orderExpiration, err := ptypes.TimestampProto(orderExpirationTime)
if err != nil {
return storj.PieceID{}, nil, Error.Wrap(err)
}
serialNumber, err := service.createSerial(ctx) serialNumber, err := service.createSerial(ctx)
if err != nil { if err != nil {
@ -261,7 +249,7 @@ func (service *Service) CreatePutOrderLimits(ctx context.Context, uplink *identi
return storj.PieceID{}, nil, Error.Wrap(err) return storj.PieceID{}, nil, Error.Wrap(err)
} }
err = service.saveSerial(ctx, serialNumber, bucketID, orderExpirationTime) err = service.saveSerial(ctx, serialNumber, bucketID, orderExpiration)
if err != nil { if err != nil {
return storj.PieceID{}, nil, Error.Wrap(err) return storj.PieceID{}, nil, Error.Wrap(err)
} }
@ -281,14 +269,8 @@ func (service *Service) CreatePutOrderLimits(ctx context.Context, uplink *identi
func (service *Service) CreateDeleteOrderLimits(ctx context.Context, uplink *identity.PeerIdentity, bucketID []byte, pointer *pb.Pointer) (_ []*pb.AddressedOrderLimit, err error) { func (service *Service) CreateDeleteOrderLimits(ctx context.Context, uplink *identity.PeerIdentity, bucketID []byte, pointer *pb.Pointer) (_ []*pb.AddressedOrderLimit, err error) {
defer mon.Task()(&ctx)(&err) defer mon.Task()(&ctx)(&err)
rootPieceID := pointer.GetRemote().RootPieceId rootPieceID := pointer.GetRemote().RootPieceId
expiration := pointer.ExpirationDate pieceExpiration := pointer.ExpirationDate
orderExpiration := time.Now().Add(service.orderExpiration)
// convert orderExpiration from duration to timestamp
orderExpirationTime := time.Now().UTC().Add(service.orderExpiration)
orderExpiration, err := ptypes.TimestampProto(orderExpirationTime)
if err != nil {
return nil, Error.Wrap(err)
}
serialNumber, err := service.createSerial(ctx) serialNumber, err := service.createSerial(ctx)
if err != nil { if err != nil {
@ -326,7 +308,7 @@ func (service *Service) CreateDeleteOrderLimits(ctx context.Context, uplink *ide
PieceId: rootPieceID.Derive(piece.NodeId, piece.PieceNum), PieceId: rootPieceID.Derive(piece.NodeId, piece.PieceNum),
Action: pb.PieceAction_DELETE, Action: pb.PieceAction_DELETE,
Limit: 0, Limit: 0,
PieceExpiration: expiration, PieceExpiration: pieceExpiration,
OrderCreation: time.Now(), OrderCreation: time.Now(),
OrderExpiration: orderExpiration, OrderExpiration: orderExpiration,
}) })
@ -350,7 +332,7 @@ func (service *Service) CreateDeleteOrderLimits(ctx context.Context, uplink *ide
return nil, Error.Wrap(err) return nil, Error.Wrap(err)
} }
err = service.saveSerial(ctx, serialNumber, bucketID, orderExpirationTime) err = service.saveSerial(ctx, serialNumber, bucketID, orderExpiration)
if err != nil { if err != nil {
return nil, Error.Wrap(err) return nil, Error.Wrap(err)
} }
@ -365,14 +347,8 @@ func (service *Service) CreateAuditOrderLimits(ctx context.Context, auditor *ide
redundancy := pointer.GetRemote().GetRedundancy() redundancy := pointer.GetRemote().GetRedundancy()
shareSize := redundancy.GetErasureShareSize() shareSize := redundancy.GetErasureShareSize()
totalPieces := redundancy.GetTotal() totalPieces := redundancy.GetTotal()
expiration := pointer.ExpirationDate pieceExpiration := pointer.ExpirationDate
orderExpiration := time.Now().Add(service.orderExpiration)
// convert orderExpiration from duration to timestamp
orderExpirationTime := time.Now().UTC().Add(service.orderExpiration)
orderExpiration, err := ptypes.TimestampProto(orderExpirationTime)
if err != nil {
return nil, Error.Wrap(err)
}
serialNumber, err := service.createSerial(ctx) serialNumber, err := service.createSerial(ctx)
if err != nil { if err != nil {
@ -415,7 +391,7 @@ func (service *Service) CreateAuditOrderLimits(ctx context.Context, auditor *ide
PieceId: rootPieceID.Derive(piece.NodeId, piece.PieceNum), PieceId: rootPieceID.Derive(piece.NodeId, piece.PieceNum),
Action: pb.PieceAction_GET_AUDIT, Action: pb.PieceAction_GET_AUDIT,
Limit: int64(shareSize), Limit: int64(shareSize),
PieceExpiration: expiration, PieceExpiration: pieceExpiration,
OrderCreation: time.Now(), OrderCreation: time.Now(),
OrderExpiration: orderExpiration, OrderExpiration: orderExpiration,
}) })
@ -435,7 +411,7 @@ func (service *Service) CreateAuditOrderLimits(ctx context.Context, auditor *ide
return nil, errs.Combine(err, combinedErrs) return nil, errs.Combine(err, combinedErrs)
} }
err = service.saveSerial(ctx, serialNumber, bucketID, orderExpirationTime) err = service.saveSerial(ctx, serialNumber, bucketID, orderExpiration)
if err != nil { if err != nil {
return nil, Error.Wrap(err) return nil, Error.Wrap(err)
} }
@ -455,12 +431,8 @@ func (service *Service) CreateAuditOrderLimits(ctx context.Context, auditor *ide
func (service *Service) CreateAuditOrderLimit(ctx context.Context, auditor *identity.PeerIdentity, bucketID []byte, nodeID storj.NodeID, pieceNum int32, rootPieceID storj.PieceID, shareSize int32) (limit *pb.AddressedOrderLimit, err error) { func (service *Service) CreateAuditOrderLimit(ctx context.Context, auditor *identity.PeerIdentity, bucketID []byte, nodeID storj.NodeID, pieceNum int32, rootPieceID storj.PieceID, shareSize int32) (limit *pb.AddressedOrderLimit, err error) {
// TODO reduce number of params ? // TODO reduce number of params ?
defer mon.Task()(&ctx)(&err) defer mon.Task()(&ctx)(&err)
// convert orderExpiration from duration to timestamp
orderExpirationTime := time.Now().UTC().Add(service.orderExpiration) orderExpiration := time.Now().Add(service.orderExpiration)
orderExpiration, err := ptypes.TimestampProto(orderExpirationTime)
if err != nil {
return nil, Error.Wrap(err)
}
serialNumber, err := service.createSerial(ctx) serialNumber, err := service.createSerial(ctx)
if err != nil { if err != nil {
@ -501,7 +473,7 @@ func (service *Service) CreateAuditOrderLimit(ctx context.Context, auditor *iden
StorageNodeAddress: node.Address, StorageNodeAddress: node.Address,
} }
err = service.saveSerial(ctx, serialNumber, bucketID, orderExpirationTime) err = service.saveSerial(ctx, serialNumber, bucketID, orderExpiration)
if err != nil { if err != nil {
return nil, Error.Wrap(err) return nil, Error.Wrap(err)
} }
@ -527,14 +499,8 @@ func (service *Service) CreateGetRepairOrderLimits(ctx context.Context, repairer
} }
pieceSize := eestream.CalcPieceSize(pointer.GetSegmentSize(), redundancy) pieceSize := eestream.CalcPieceSize(pointer.GetSegmentSize(), redundancy)
totalPieces := redundancy.TotalCount() totalPieces := redundancy.TotalCount()
expiration := pointer.ExpirationDate pieceExpiration := pointer.ExpirationDate
orderExpiration := time.Now().Add(service.orderExpiration)
// convert orderExpiration from duration to timestamp
orderExpirationTime := time.Now().UTC().Add(service.orderExpiration)
orderExpiration, err := ptypes.TimestampProto(orderExpirationTime)
if err != nil {
return nil, Error.Wrap(err)
}
serialNumber, err := service.createSerial(ctx) serialNumber, err := service.createSerial(ctx)
if err != nil { if err != nil {
@ -573,7 +539,7 @@ func (service *Service) CreateGetRepairOrderLimits(ctx context.Context, repairer
PieceId: rootPieceID.Derive(piece.NodeId, piece.PieceNum), PieceId: rootPieceID.Derive(piece.NodeId, piece.PieceNum),
Action: pb.PieceAction_GET_REPAIR, Action: pb.PieceAction_GET_REPAIR,
Limit: pieceSize, Limit: pieceSize,
PieceExpiration: expiration, PieceExpiration: pieceExpiration,
OrderCreation: time.Now(), OrderCreation: time.Now(),
OrderExpiration: orderExpiration, OrderExpiration: orderExpiration,
}) })
@ -593,7 +559,7 @@ func (service *Service) CreateGetRepairOrderLimits(ctx context.Context, repairer
return nil, errs.Combine(err, combinedErrs) return nil, errs.Combine(err, combinedErrs)
} }
err = service.saveSerial(ctx, serialNumber, bucketID, orderExpirationTime) err = service.saveSerial(ctx, serialNumber, bucketID, orderExpiration)
if err != nil { if err != nil {
return nil, Error.Wrap(err) return nil, Error.Wrap(err)
} }
@ -619,14 +585,8 @@ func (service *Service) CreatePutRepairOrderLimits(ctx context.Context, repairer
} }
pieceSize := eestream.CalcPieceSize(pointer.GetSegmentSize(), redundancy) pieceSize := eestream.CalcPieceSize(pointer.GetSegmentSize(), redundancy)
totalPieces := redundancy.TotalCount() totalPieces := redundancy.TotalCount()
expiration := pointer.ExpirationDate pieceExpiration := pointer.ExpirationDate
orderExpiration := time.Now().Add(service.orderExpiration)
// convert orderExpiration from duration to timestamp
orderExpirationTime := time.Now().UTC().Add(service.orderExpiration)
orderExpiration, err := ptypes.TimestampProto(orderExpirationTime)
if err != nil {
return nil, Error.Wrap(err)
}
serialNumber, err := service.createSerial(ctx) serialNumber, err := service.createSerial(ctx)
if err != nil { if err != nil {
@ -653,7 +613,7 @@ func (service *Service) CreatePutRepairOrderLimits(ctx context.Context, repairer
PieceId: rootPieceID.Derive(node.Id, pieceNum), PieceId: rootPieceID.Derive(node.Id, pieceNum),
Action: pb.PieceAction_PUT_REPAIR, Action: pb.PieceAction_PUT_REPAIR,
Limit: pieceSize, Limit: pieceSize,
PieceExpiration: expiration, PieceExpiration: pieceExpiration,
OrderCreation: time.Now(), OrderCreation: time.Now(),
OrderExpiration: orderExpiration, OrderExpiration: orderExpiration,
}) })
@ -668,7 +628,7 @@ func (service *Service) CreatePutRepairOrderLimits(ctx context.Context, repairer
pieceNum++ pieceNum++
} }
err = service.saveSerial(ctx, serialNumber, bucketID, orderExpirationTime) err = service.saveSerial(ctx, serialNumber, bucketID, orderExpiration)
if err != nil { if err != nil {
return nil, Error.Wrap(err) return nil, Error.Wrap(err)
} }

7
satellite/satellitedb/pbold/order.pb.go
View File

@ -5,10 +5,11 @@ package pbold
import ( import (
fmt "fmt" fmt "fmt"
math "math"
_ "github.com/gogo/protobuf/gogoproto" _ "github.com/gogo/protobuf/gogoproto"
proto "github.com/gogo/protobuf/proto" proto "github.com/gogo/protobuf/proto"
_ "github.com/golang/protobuf/ptypes/duration" _ "github.com/golang/protobuf/ptypes/duration"
math "math"
pb "storj.io/storj/pkg/pb" pb "storj.io/storj/pkg/pb"
) )
@ -65,8 +66,8 @@ func (BandwidthAction) EnumDescriptor() ([]byte, []int) {
} }
type PayerBandwidthAllocation struct { type PayerBandwidthAllocation struct {
SatelliteId pb.NodeID `protobuf:"bytes,1,opt,name=satellite_id,json=satelliteId,proto3,customtype=NodeID" json:"satellite_id"` SatelliteId pb.NodeID `protobuf:"bytes,1,opt,name=satellite_id,json=satelliteId,proto3,customtype=NodeID" json:"satellite_id"`
UplinkId pb.NodeID `protobuf:"bytes,2,opt,name=uplink_id,json=uplinkId,proto3,customtype=NodeID" json:"uplink_id"` UplinkId pb.NodeID `protobuf:"bytes,2,opt,name=uplink_id,json=uplinkId,proto3,customtype=NodeID" json:"uplink_id"`
MaxSize int64 `protobuf:"varint,3,opt,name=max_size,json=maxSize,proto3" json:"max_size,omitempty"` MaxSize int64 `protobuf:"varint,3,opt,name=max_size,json=maxSize,proto3" json:"max_size,omitempty"`
ExpirationUnixSec int64 `protobuf:"varint,4,opt,name=expiration_unix_sec,json=expirationUnixSec,proto3" json:"expiration_unix_sec,omitempty"` ExpirationUnixSec int64 `protobuf:"varint,4,opt,name=expiration_unix_sec,json=expirationUnixSec,proto3" json:"expiration_unix_sec,omitempty"`
SerialNumber string `protobuf:"bytes,5,opt,name=serial_number,json=serialNumber,proto3" json:"serial_number,omitempty"` SerialNumber string `protobuf:"bytes,5,opt,name=serial_number,json=serialNumber,proto3" json:"serial_number,omitempty"`

7
storagenode/orders/db_test.go
View File

@ -7,7 +7,6 @@ import (
"testing" "testing"
"time" "time"
"github.com/golang/protobuf/ptypes"
"github.com/google/go-cmp/cmp" "github.com/google/go-cmp/cmp"
"github.com/stretchr/testify/require" "github.com/stretchr/testify/require"
@ -48,8 +47,6 @@ func TestOrders(t *testing.T) {
require.Len(t, emptyArchive, 0) require.Len(t, emptyArchive, 0)
now := time.Now() now := time.Now()
nowTimestamp, err := ptypes.TimestampProto(now)
require.NoError(t, err)
limit, err := signing.SignOrderLimit(ctx, signing.SignerFromFullIdentity(satellite0), &pb.OrderLimit{ limit, err := signing.SignOrderLimit(ctx, signing.SignerFromFullIdentity(satellite0), &pb.OrderLimit{
SerialNumber: serialNumber, SerialNumber: serialNumber,
@ -60,8 +57,8 @@ func TestOrders(t *testing.T) {
Limit: 100, Limit: 100,
Action: pb.PieceAction_GET, Action: pb.PieceAction_GET,
OrderCreation: now.AddDate(0, 0, -1), OrderCreation: now.AddDate(0, 0, -1),
PieceExpiration: nowTimestamp, PieceExpiration: now,
OrderExpiration: nowTimestamp, OrderExpiration: now,
}) })
require.NoError(t, err) require.NoError(t, err)

12
storagenode/pieces/db_test.go
View File

@ -53,8 +53,8 @@ func TestPieceInfo(t *testing.T) {
PieceID: pieceid0, PieceID: pieceid0,
PieceSize: 123, PieceSize: 123,
PieceCreation: &now, PieceCreation: now,
PieceExpiration: &now, PieceExpiration: now,
UplinkPieceHash: piecehash0, UplinkPieceHash: piecehash0,
} }
@ -72,8 +72,8 @@ func TestPieceInfo(t *testing.T) {
PieceID: pieceid0, PieceID: pieceid0,
PieceSize: 123, PieceSize: 123,
PieceCreation: &now, PieceCreation: now,
PieceExpiration: &now, PieceExpiration: now,
UplinkPieceHash: piecehash1, UplinkPieceHash: piecehash1,
} }
@ -91,8 +91,8 @@ func TestPieceInfo(t *testing.T) {
PieceID: pieceid0, PieceID: pieceid0,
PieceSize: 123, PieceSize: 123,
PieceCreation: &now, PieceCreation: now,
PieceExpiration: &now, PieceExpiration: now,
UplinkPieceHash: piecehash2, UplinkPieceHash: piecehash2,
} }

4
storagenode/pieces/store.go
View File

@ -38,8 +38,8 @@ type Info struct {
PieceID storj.PieceID PieceID storj.PieceID
PieceSize int64 PieceSize int64
PieceCreation *time.Time PieceCreation time.Time
PieceExpiration *time.Time PieceExpiration time.Time
UplinkPieceHash *pb.PieceHash UplinkPieceHash *pb.PieceHash
Uplink *identity.PeerIdentity Uplink *identity.PeerIdentity

16
storagenode/piecestore/endpoint.go
View File

@ -10,13 +10,12 @@ import (
"sync/atomic" "sync/atomic"
"time" "time"
"github.com/golang/protobuf/ptypes"
"github.com/zeebo/errs" "github.com/zeebo/errs"
"go.uber.org/zap" "go.uber.org/zap"
"golang.org/x/sync/errgroup" "golang.org/x/sync/errgroup"
"google.golang.org/grpc/codes" "google.golang.org/grpc/codes"
"google.golang.org/grpc/status" "google.golang.org/grpc/status"
monkit "gopkg.in/spacemonkeygo/monkit.v2" "gopkg.in/spacemonkeygo/monkit.v2"
"storj.io/storj/internal/memory" "storj.io/storj/internal/memory"
"storj.io/storj/internal/sync2" "storj.io/storj/internal/sync2"
@ -292,23 +291,14 @@ func (endpoint *Endpoint) Upload(stream pb.Piecestore_UploadServer) (err error)
// TODO: do this in a goroutine // TODO: do this in a goroutine
{ {
var expiration *time.Time
if limit.PieceExpiration != nil {
exp, err := ptypes.Timestamp(limit.PieceExpiration)
if err != nil {
return ErrInternal.Wrap(err)
}
expiration = &exp
}
// TODO: maybe this should be as a pieceWriter.Commit(ctx, info) // TODO: maybe this should be as a pieceWriter.Commit(ctx, info)
info := &pieces.Info{ info := &pieces.Info{
SatelliteID: limit.SatelliteId, SatelliteID: limit.SatelliteId,
PieceID: limit.PieceId, PieceID: limit.PieceId,
PieceSize: pieceWriter.Size(), PieceSize: pieceWriter.Size(),
PieceCreation: &limit.OrderCreation, PieceCreation: limit.OrderCreation,
PieceExpiration: expiration, PieceExpiration: limit.PieceExpiration,
UplinkPieceHash: message.Done, UplinkPieceHash: message.Done,
Uplink: peer, Uplink: peer,

11
storagenode/piecestore/endpoint_test.go
View File

@ -10,7 +10,6 @@ import (
"testing" "testing"
"time" "time"
"github.com/golang/protobuf/ptypes"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require" "github.com/stretchr/testify/require"
"github.com/zeebo/errs" "github.com/zeebo/errs"
@ -485,11 +484,7 @@ func TestTooManyRequests(t *testing.T) {
func GenerateOrderLimit(t *testing.T, satellite storj.NodeID, uplink storj.NodeID, storageNode storj.NodeID, pieceID storj.PieceID, 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.OrderLimit { action pb.PieceAction, serialNumber storj.SerialNumber, pieceExpiration, orderExpiration time.Duration, limit int64) *pb.OrderLimit {
pe, err := ptypes.TimestampProto(time.Now().Add(pieceExpiration)) now := time.Now()
require.NoError(t, err)
oe, err := ptypes.TimestampProto(time.Now().Add(orderExpiration))
require.NoError(t, err)
return &pb.OrderLimit{ return &pb.OrderLimit{
SatelliteId: satellite, SatelliteId: satellite,
@ -499,8 +494,8 @@ func GenerateOrderLimit(t *testing.T, satellite storj.NodeID, uplink storj.NodeI
Action: action, Action: action,
SerialNumber: serialNumber, SerialNumber: serialNumber,
OrderCreation: time.Now(), OrderCreation: time.Now(),
OrderExpiration: oe, OrderExpiration: now.Add(orderExpiration),
PieceExpiration: pe, PieceExpiration: now.Add(pieceExpiration),
Limit: limit, Limit: limit,
} }
} }

23
storagenode/piecestore/verification.go
View File

@ -8,8 +8,6 @@ import (
"context" "context"
"time" "time"
"github.com/golang/protobuf/ptypes"
"github.com/golang/protobuf/ptypes/timestamp"
"github.com/zeebo/errs" "github.com/zeebo/errs"
"storj.io/storj/internal/errs2" "storj.io/storj/internal/errs2"
@ -39,7 +37,7 @@ func (endpoint *Endpoint) VerifyOrderLimit(ctx context.Context, limit *pb.OrderL
return ErrProtocol.New("order limit is negative") return ErrProtocol.New("order limit is negative")
case endpoint.signer.ID() != limit.StorageNodeId: case endpoint.signer.ID() != limit.StorageNodeId:
return ErrProtocol.New("order intended for other storagenode: %v", limit.StorageNodeId) return ErrProtocol.New("order intended for other storagenode: %v", limit.StorageNodeId)
case limit.PieceExpiration != nil && endpoint.IsExpired(limit.PieceExpiration): case endpoint.IsExpired(limit.PieceExpiration):
return ErrProtocol.New("piece expired: %v", limit.PieceExpiration) return ErrProtocol.New("piece expired: %v", limit.PieceExpiration)
case endpoint.IsExpired(limit.OrderExpiration): case endpoint.IsExpired(limit.OrderExpiration):
return ErrProtocol.New("order expired: %v", limit.OrderExpiration) return ErrProtocol.New("order expired: %v", limit.OrderExpiration)
@ -77,10 +75,7 @@ func (endpoint *Endpoint) VerifyOrderLimit(ctx context.Context, limit *pb.OrderL
return ErrVerifyUntrusted.Wrap(err) return ErrVerifyUntrusted.Wrap(err)
} }
serialExpiration, err := ptypes.Timestamp(limit.OrderExpiration) serialExpiration := limit.OrderExpiration
if err != nil {
return ErrInternal.Wrap(err)
}
// Expire the serial earlier if the grace period is smaller than the serial expiration. // Expire the serial earlier if the grace period is smaller than the serial expiration.
if graceExpiration := now.Add(endpoint.config.OrderLimitGracePeriod); graceExpiration.Before(serialExpiration) { if graceExpiration := now.Add(endpoint.config.OrderLimitGracePeriod); graceExpiration.Before(serialExpiration) {
@ -157,17 +152,11 @@ func (endpoint *Endpoint) VerifyOrderLimitSignature(ctx context.Context, limit *
} }
// IsExpired checks whether the date has already expired (with a threshold) at the time of calling this function. // IsExpired checks whether the date has already expired (with a threshold) at the time of calling this function.
func (endpoint *Endpoint) IsExpired(expiration *timestamp.Timestamp) bool { func (endpoint *Endpoint) IsExpired(expiration time.Time) bool {
if expiration == nil { if expiration.IsZero() {
return true return false
}
expirationTime, err := ptypes.Timestamp(expiration)
if err != nil {
// TODO: return error
return true
} }
// TODO: return specific error about either exceeding the expiration completely or just the grace period // TODO: return specific error about either exceeding the expiration completely or just the grace period
return expirationTime.Before(time.Now().Add(-endpoint.config.ExpirationGracePeriod)) return expiration.Before(time.Now().Add(-endpoint.config.ExpirationGracePeriod))
} }

3
storagenode/piecestore/verification_test.go
View File

@ -327,7 +327,8 @@ func setSpace(ctx context.Context, t *testing.T, planet *testplanet.Planet, spac
SatelliteID: planet.Satellites[0].ID(), SatelliteID: planet.Satellites[0].ID(),
PieceID: storj.PieceID{99}, PieceID: storj.PieceID{99},
PieceSize: diff, PieceSize: diff,
PieceCreation: &now, PieceCreation: now,
PieceExpiration: time.Time{},
Uplink: planet.Uplinks[0].Identity.PeerIdentity(), Uplink: planet.Uplinks[0].Identity.PeerIdentity(),
UplinkPieceHash: &pb.PieceHash{}, UplinkPieceHash: &pb.PieceHash{},
}) })

9
storagenode/storagenodedb/orders.go
View File

@ -9,7 +9,6 @@ import (
"time" "time"
"github.com/gogo/protobuf/proto" "github.com/gogo/protobuf/proto"
"github.com/golang/protobuf/ptypes"
"github.com/zeebo/errs" "github.com/zeebo/errs"
"storj.io/storj/pkg/pb" "storj.io/storj/pkg/pb"
@ -39,19 +38,13 @@ func (db *ordersdb) Enqueue(ctx context.Context, info *orders.Info) (err error)
return ErrInfo.Wrap(err) return ErrInfo.Wrap(err)
} }
expirationTime, err := ptypes.Timestamp(info.Limit.OrderExpiration)
if err != nil {
return ErrInfo.Wrap(err)
}
// TODO remove `uplink_cert_id` from DB
_, err = db.db.Exec(` _, err = db.db.Exec(`
INSERT INTO unsent_order( INSERT INTO unsent_order(
satellite_id, serial_number, satellite_id, serial_number,
order_limit_serialized, order_serialized, order_limit_expiration, order_limit_serialized, order_serialized, order_limit_expiration,
uplink_cert_id uplink_cert_id
) VALUES (?,?, ?,?,?, ?) ) VALUES (?,?, ?,?,?, ?)
`, info.Limit.SatelliteId, info.Limit.SerialNumber, limitSerialized, orderSerialized, expirationTime, 0) `, info.Limit.SatelliteId, info.Limit.SerialNumber, limitSerialized, orderSerialized, info.Limit.OrderExpiration.UTC(), 0)
return ErrInfo.Wrap(err) return ErrInfo.Wrap(err)
} }

8
storagenode/storagenodedb/storagenodedbtest/run_test.go
View File

@ -7,8 +7,8 @@ import (
"runtime" "runtime"
"sync" "sync"
"testing" "testing"
"time"
"github.com/golang/protobuf/ptypes"
"github.com/skyrings/skyring-common/tools/uuid" "github.com/skyrings/skyring-common/tools/uuid"
"github.com/stretchr/testify/require" "github.com/stretchr/testify/require"
"go.uber.org/zap/zaptest" "go.uber.org/zap/zaptest"
@ -139,7 +139,7 @@ func createOrder(t *testing.T, ctx *testcontext.Context) (info *orders.Info) {
piece := storj.NewPieceID() piece := storj.NewPieceID()
serialNumber := testrand.SerialNumber() serialNumber := testrand.SerialNumber()
exp := ptypes.TimestampNow() expiration := time.Now()
limit, err := signing.SignOrderLimit(ctx, signing.SignerFromFullIdentity(satelliteIdentity), &pb.OrderLimit{ limit, err := signing.SignOrderLimit(ctx, signing.SignerFromFullIdentity(satelliteIdentity), &pb.OrderLimit{
SerialNumber: serialNumber, SerialNumber: serialNumber,
@ -149,8 +149,8 @@ func createOrder(t *testing.T, ctx *testcontext.Context) (info *orders.Info) {
PieceId: piece, PieceId: piece,
Limit: 100, Limit: 100,
Action: pb.PieceAction_GET, Action: pb.PieceAction_GET,
PieceExpiration: exp, PieceExpiration: expiration,
OrderExpiration: exp, OrderExpiration: expiration,
}) })
require.NoError(t, err) require.NoError(t, err)

14
uplink/metainfo/client.go
View File

@ -7,14 +7,12 @@ import (
"context" "context"
"time" "time"
"github.com/golang/protobuf/ptypes"
"github.com/golang/protobuf/ptypes/timestamp"
"github.com/skyrings/skyring-common/tools/uuid" "github.com/skyrings/skyring-common/tools/uuid"
"github.com/zeebo/errs" "github.com/zeebo/errs"
"google.golang.org/grpc" "google.golang.org/grpc"
"google.golang.org/grpc/codes" "google.golang.org/grpc/codes"
"google.golang.org/grpc/status" "google.golang.org/grpc/status"
monkit "gopkg.in/spacemonkeygo/monkit.v2" "gopkg.in/spacemonkeygo/monkit.v2"
"storj.io/storj/pkg/auth/grpcauth" "storj.io/storj/pkg/auth/grpcauth"
"storj.io/storj/pkg/pb" "storj.io/storj/pkg/pb"
@ -80,21 +78,13 @@ func (client *Client) Close() error {
func (client *Client) CreateSegment(ctx context.Context, bucket string, path storj.Path, segmentIndex int64, redundancy *pb.RedundancyScheme, maxEncryptedSegmentSize int64, expiration time.Time) (limits []*pb.AddressedOrderLimit, rootPieceID storj.PieceID, err error) { func (client *Client) CreateSegment(ctx context.Context, bucket string, path storj.Path, segmentIndex int64, redundancy *pb.RedundancyScheme, maxEncryptedSegmentSize int64, expiration time.Time) (limits []*pb.AddressedOrderLimit, rootPieceID storj.PieceID, err error) {
defer mon.Task()(&ctx)(&err) defer mon.Task()(&ctx)(&err)
var exp *timestamp.Timestamp
if !expiration.IsZero() {
exp, err = ptypes.TimestampProto(expiration)
if err != nil {
return nil, rootPieceID, err
}
}
response, err := client.client.CreateSegmentOld(ctx, &pb.SegmentWriteRequestOld{ response, err := client.client.CreateSegmentOld(ctx, &pb.SegmentWriteRequestOld{
Bucket: []byte(bucket), Bucket: []byte(bucket),
Path: []byte(path), Path: []byte(path),
Segment: segmentIndex, Segment: segmentIndex,
Redundancy: redundancy, Redundancy: redundancy,
MaxEncryptedSegmentSize: maxEncryptedSegmentSize, MaxEncryptedSegmentSize: maxEncryptedSegmentSize,
Expiration: exp, Expiration: expiration,
}) })
if err != nil { if err != nil {
return nil, rootPieceID, Error.Wrap(err) return nil, rootPieceID, Error.Wrap(err)