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

Change pointerdb pointer to use time.Time for Creation date (#2483)

Browse Source
This commit is contained in:
Alexander Leitner 2019-07-08 18:16:50 -04:00 committed by Michal Niewrzal
parent 674742d1a7
commit 3587e1a579
16 changed files with 125 additions and 101 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
pkg/accounting/tally/tally_test.go
View File

@ -273,6 +273,7 @@ func makePointer(storageNodes []*storagenode.Peer, rs storj.RedundancyScheme,
if inline {
inlinePointer := &pb.Pointer{
CreationDate: time.Now(),
Type: pb.Pointer_INLINE,
InlineSegment: make([]byte, segmentSize),
SegmentSize: segmentSize,
@ -290,7 +291,8 @@ func makePointer(storageNodes []*storagenode.Peer, rs storj.RedundancyScheme,
}
pointer := &pb.Pointer{
Type: pb.Pointer_REMOTE,
CreationDate: time.Now(),
Type: pb.Pointer_REMOTE,
Remote: &pb.RemoteSegment{
Redundancy: &pb.RedundancyScheme{
Type: pb.RedundancyScheme_RS,

1
pkg/audit/cursor_test.go
View File

@ -173,6 +173,7 @@ func makePointer(path storj.Path, expiration *timestamp.Timestamp) *pb.Pointer {
NodeId: teststorj.NodeIDFromString("testId"),
})
return &pb.Pointer{
CreationDate: time.Now(),
ExpirationDate: expiration,
Type: pb.Pointer_REMOTE,
Remote: &pb.RemoteSegment{

3
pkg/audit/verifier.go
View File

@ -501,8 +501,7 @@ func (verifier *Verifier) checkIfSegmentDeleted(ctx context.Context, stripe *Str
return err
}
if pointer.GetCreationDate().GetSeconds() != stripe.Segment.GetCreationDate().GetSeconds() ||
pointer.GetCreationDate().GetNanos() != stripe.Segment.GetCreationDate().GetNanos() {
if !pointer.CreationDate.Equal(stripe.Segment.CreationDate) {
return ErrSegmentDeleted.New(stripe.SegmentPath)
}

4
pkg/audit/verifier_unit_test.go
View File

@ -6,6 +6,7 @@ package audit
import (
"context"
"testing"
"time"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
@ -129,7 +130,8 @@ func TestCreatePendingAudits(t *testing.T) {
stripe := Stripe{
Index: 3,
Segment: &pb.Pointer{
Type: pb.Pointer_REMOTE,
CreationDate: time.Now(),
Type: pb.Pointer_REMOTE,
Remote: &pb.RemoteSegment{
RootPieceId: storj.NewPieceID(),
Redundancy: &pb.RedundancyScheme{

8
pkg/datarepair/checker/checker.go
View File

@ -8,7 +8,6 @@ import (
"time"
"github.com/gogo/protobuf/proto"
"github.com/golang/protobuf/ptypes"
"github.com/zeebo/errs"
"go.uber.org/zap"
"golang.org/x/sync/errgroup"
@ -181,12 +180,7 @@ func (checker *Checker) updateSegmentStatus(ctx context.Context, pointer *pb.Poi
return nil
}
createdAt, err := ptypes.Timestamp(pointer.CreationDate)
if err != nil {
return Error.New("error parsing creation date %s", err)
}
missingPieces, err := checker.nodestate.MissingPieces(ctx, createdAt, pieces)
missingPieces, err := checker.nodestate.MissingPieces(ctx, pointer.CreationDate, pieces)
if err != nil {
return Error.New("error getting missing pieces %s", err)
}

3
pkg/datarepair/checker/checker_test.go
View File

@ -87,6 +87,7 @@ func TestIdentifyIrreparableSegments(t *testing.T) {
expectedLostPieces[int32(i)] = true
}
pointer := &pb.Pointer{
CreationDate: time.Now(),
Remote: &pb.RemoteSegment{
Redundancy: &pb.RedundancyScheme{
MinReq: int32(3),
@ -136,6 +137,7 @@ func TestIdentifyIrreparableSegments(t *testing.T) {
// make the pointer repairable
pointer = &pb.Pointer{
CreationDate: time.Now(),
Remote: &pb.RemoteSegment{
Redundancy: &pb.RedundancyScheme{
MinReq: int32(2),
@ -185,6 +187,7 @@ func makePointer(t *testing.T, planet *testplanet.Planet, pieceID string, create
minReq, repairThreshold = numOfStorageNodes-1, numOfStorageNodes+1
}
pointer := &pb.Pointer{
CreationDate: time.Now(),
Remote: &pb.RemoteSegment{
Redundancy: &pb.RedundancyScheme{
MinReq: int32(minReq),

60
pkg/datarepair/irreparable/irreparable_test.go
View File

@ -8,7 +8,8 @@ import (
"testing"
"time"
"github.com/stretchr/testify/assert"
"github.com/google/go-cmp/cmp"
"github.com/stretchr/testify/require"
"storj.io/storj/internal/testcontext"
"storj.io/storj/pkg/pb"
@ -27,70 +28,75 @@ func TestIrreparable(t *testing.T) {
var segments []*pb.IrreparableSegment
for i := 0; i < 3; i++ {
segments = append(segments, &pb.IrreparableSegment{
Path: []byte(strconv.Itoa(i)),
SegmentDetail: &pb.Pointer{},
Path: []byte(strconv.Itoa(i)),
SegmentDetail: &pb.Pointer{
CreationDate: time.Now(),
},
LostPieces: int32(i),
LastRepairAttempt: time.Now().Unix(),
RepairAttemptCount: int64(10),
})
err := irrdb.IncrementRepairAttempts(ctx, segments[i])
assert.NoError(t, err)
require.NoError(t, err)
}
{ // GetLimited limit 1, offset 0
segs, err := irrdb.GetLimited(ctx, 1, 0)
assert.NoError(t, err)
assert.Equal(t, 1, len(segs))
assert.Equal(t, segments[0], segs[0])
require.NoError(t, err)
require.Equal(t, 1, len(segs))
require.Empty(t, cmp.Diff(segments[0], segs[0], cmp.Comparer(pb.Equal)))
}
{ // GetLimited limit 1, offset 1
segs, err := irrdb.GetLimited(ctx, 1, 1)
assert.NoError(t, err)
assert.Equal(t, 1, len(segs))
assert.Equal(t, segments[1], segs[0])
require.NoError(t, err)
require.Equal(t, 1, len(segs))
require.Empty(t, cmp.Diff(segments[1], segs[0], cmp.Comparer(pb.Equal)))
}
{ // GetLimited limit 2, offset 0
segs, err := irrdb.GetLimited(ctx, 2, 0)
assert.NoError(t, err)
assert.Equal(t, 2, len(segs))
assert.Equal(t, segments[0], segs[0])
assert.Equal(t, segments[1], segs[1])
require.NoError(t, err)
require.Equal(t, 2, len(segs))
require.Empty(t, cmp.Diff(segments[0], segs[0], cmp.Comparer(pb.Equal)))
require.Empty(t, cmp.Diff(segments[1], segs[1], cmp.Comparer(pb.Equal)))
}
{ // GetLimited limit 2, offset 1
segs, err := irrdb.GetLimited(ctx, 2, 1)
assert.NoError(t, err)
assert.Equal(t, 2, len(segs))
assert.Equal(t, segments[1], segs[0])
assert.Equal(t, segments[2], segs[1])
require.NoError(t, err)
require.Equal(t, 2, len(segs))
require.Empty(t, cmp.Diff(segments[1], segs[0], cmp.Comparer(pb.Equal)))
require.Empty(t, cmp.Diff(segments[2], segs[1], cmp.Comparer(pb.Equal)))
}
{ // GetLimited limit 3, offset 1
segs, err := irrdb.GetLimited(ctx, 3, 1)
assert.NoError(t, err)
assert.Equal(t, 2, len(segs))
assert.Equal(t, segments[1], segs[0])
assert.Equal(t, segments[2], segs[1])
require.NoError(t, err)
require.Equal(t, 2, len(segs))
require.Empty(t, cmp.Diff(segments[1], segs[0], cmp.Comparer(pb.Equal)))
require.Empty(t, cmp.Diff(segments[2], segs[1], cmp.Comparer(pb.Equal)))
}
{ // Test repair count incrementation
err := irrdb.IncrementRepairAttempts(ctx, segments[0])
assert.NoError(t, err)
require.NoError(t, err)
segments[0].RepairAttemptCount++
dbxInfo, err := irrdb.Get(ctx, segments[0].Path)
assert.NoError(t, err)
assert.Equal(t, segments[0], dbxInfo)
require.NoError(t, err)
require.Empty(t, cmp.Diff(segments[0], dbxInfo, cmp.Comparer(pb.Equal)))
}
{ //Delete existing entry
err := irrdb.Delete(ctx, segments[0].Path)
assert.NoError(t, err)
require.NoError(t, err)
_, err = irrdb.Get(ctx, segments[0].Path)
assert.Error(t, err)
require.Error(t, err)
}
})
}

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

@ -271,7 +271,7 @@ func (db *DB) getInfo(ctx context.Context, bucket string, path storj.Path) (obj
}
lastSegmentMeta := segments.Meta{
Modified: convertTime(pointer.GetCreationDate()),
Modified: pointer.CreationDate,
Expiration: convertTime(pointer.GetExpirationDate()),
Size: pointer.GetSegmentSize(),
Data: pointer.GetMetadata(),

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

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

2
pkg/pb/pointerdb.proto
View File

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

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

@ -126,6 +126,7 @@ func (s *segmentStore) Put(ctx context.Context, data io.Reader, expiration time.
path = p
pointer = &pb.Pointer{
CreationDate: time.Now(),
Type: pb.Pointer_INLINE,
InlineSegment: peekReader.thresholdBuf,
SegmentSize: int64(len(peekReader.thresholdBuf)),
@ -256,7 +257,8 @@ func makeRemotePointer(nodes []*pb.Node, hashes []*pb.PieceHash, rs eestream.Red
}
pointer = &pb.Pointer{
Type: pb.Pointer_REMOTE,
CreationDate: time.Now(),
Type: pb.Pointer_REMOTE,
Remote: &pb.RemoteSegment{
Redundancy: &pb.RedundancyScheme{
Type: pb.RedundancyScheme_RS,
@ -356,7 +358,7 @@ func CalcNeededNodes(rs *pb.RedundancyScheme) int32 {
// convertMeta converts pointer to segment metadata
func convertMeta(pr *pb.Pointer) Meta {
return Meta{
Modified: convertTime(pr.GetCreationDate()),
Modified: pr.GetCreationDate(),
Expiration: convertTime(pr.GetExpirationDate()),
Size: pr.GetSegmentSize(),
Data: pr.GetMetadata(),

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

@ -57,7 +57,7 @@ func TestSegmentStoreMeta(t *testing.T) {
require.NoError(t, err)
assert.Equal(t, expectedSize, meta.Size)
assert.Equal(t, test.metadata, meta.Data)
assert.Equal(t, test.expiration, meta.Expiration)
assert.True(t, test.expiration.Equal(meta.Expiration))
assert.True(t, meta.Modified.After(beforeModified))
}
@ -66,7 +66,7 @@ func TestSegmentStoreMeta(t *testing.T) {
require.NoError(t, err)
assert.Equal(t, expectedSize, meta.Size)
assert.Equal(t, test.metadata, meta.Data)
assert.Equal(t, test.expiration, meta.Expiration)
assert.True(t, test.expiration.Equal(meta.Expiration))
assert.True(t, meta.Modified.After(beforeModified))
} else {
require.Contains(t, err.Error(), test.err)

12
proto.lock
View File

@ -3497,7 +3497,17 @@
{
"id": 6,
"name": "creation_date",
"type": "google.protobuf.Timestamp"
"type": "google.protobuf.Timestamp",
"options": [
{
"name": "(gogoproto.stdtime)",
"value": "true"
},
{
"name": "(gogoproto.nullable)",
"value": "false"
}
]
},
{
"id": 7,

10
satellite/metainfo/metainfo_test.go
View File

@ -333,8 +333,9 @@ func TestCommitSegment(t *testing.T) {
require.NoError(t, err)
pointer := &pb.Pointer{
Type: pb.Pointer_REMOTE,
SegmentSize: 10,
CreationDate: time.Now(),
Type: pb.Pointer_REMOTE,
SegmentSize: 10,
Remote: &pb.RemoteSegment{
RootPieceId: rootPieceID,
Redundancy: redundancy,
@ -746,8 +747,9 @@ func createTestPointer(t *testing.T) *pb.Pointer {
expiration, err := ptypes.TimestampProto(timestamp)
require.NoError(t, err)
pointer := &pb.Pointer{
Type: pb.Pointer_REMOTE,
SegmentSize: segmentSize,
CreationDate: time.Now(),
Type: pb.Pointer_REMOTE,
SegmentSize: segmentSize,
Remote: &pb.RemoteSegment{
Redundancy: rs,
RemotePieces: []*pb.RemotePiece{

4
satellite/metainfo/service.go
View File

@ -5,9 +5,9 @@ package metainfo
import (
"context"
"time"
"github.com/gogo/protobuf/proto"
"github.com/golang/protobuf/ptypes"
"github.com/zeebo/errs"
"go.uber.org/zap"
@ -32,7 +32,7 @@ func (s *Service) Put(ctx context.Context, path string, pointer *pb.Pointer) (er
defer mon.Task()(&ctx)(&err)
// Update the pointer with the creation date
pointer.CreationDate = ptypes.TimestampNow()
pointer.CreationDate = time.Now()
pointerBytes, err := proto.Marshal(pointer)
if err != nil {

2
storagenode/storagenodedb/vouchers.go
View File

@ -54,7 +54,7 @@ func (db *vouchersdb) Put(ctx context.Context, voucher *pb.Voucher) (err error)
func (db *vouchersdb) NeedVoucher(ctx context.Context, satelliteID storj.NodeID, expirationBuffer time.Duration) (need bool, err error) {
defer mon.Task()(&ctx)(&err)
expiresBefore := time.Now().Add(expirationBuffer)
expiresBefore := time.Now().UTC().Add(expirationBuffer)
// query returns row if voucher is good. If not, it is either expiring or does not exist
row := db.db.QueryRow(`