2019-01-24 20:15:10 +00:00
|
|
|
// Copyright (C) 2019 Storj Labs, Inc.
|
2018-11-08 16:18:28 +00:00
|
|
|
// See LICENSE for copying information.
|
|
|
|
|
2019-01-23 19:58:44 +00:00
|
|
|
package tally_test
|
2018-11-08 16:18:28 +00:00
|
|
|
|
|
|
|
import (
|
2019-06-20 20:15:13 +01:00
|
|
|
"fmt"
|
2018-11-08 16:18:28 +00:00
|
|
|
"testing"
|
|
|
|
"time"
|
|
|
|
|
2019-02-07 19:22:49 +00:00
|
|
|
"github.com/stretchr/testify/assert"
|
2019-02-01 18:50:12 +00:00
|
|
|
"github.com/stretchr/testify/require"
|
2018-12-07 09:59:31 +00:00
|
|
|
|
2019-12-27 11:48:47 +00:00
|
|
|
"storj.io/common/memory"
|
|
|
|
"storj.io/common/storj"
|
|
|
|
"storj.io/common/testcontext"
|
|
|
|
"storj.io/common/testrand"
|
2020-03-30 10:08:50 +01:00
|
|
|
"storj.io/common/uuid"
|
2019-11-14 19:46:15 +00:00
|
|
|
"storj.io/storj/private/testplanet"
|
|
|
|
"storj.io/storj/private/teststorj"
|
2019-07-28 06:55:36 +01:00
|
|
|
"storj.io/storj/satellite/accounting"
|
2019-10-07 21:55:20 +01:00
|
|
|
"storj.io/storj/satellite/accounting/tally"
|
2021-04-21 13:42:57 +01:00
|
|
|
"storj.io/storj/satellite/metabase"
|
2018-11-08 16:18:28 +00:00
|
|
|
)
|
|
|
|
|
2019-05-10 20:05:42 +01:00
|
|
|
func TestDeleteTalliesBefore(t *testing.T) {
|
2019-04-03 04:55:24 +01:00
|
|
|
tests := []struct {
|
|
|
|
eraseBefore time.Time
|
|
|
|
expectedRaws int
|
|
|
|
}{
|
|
|
|
{
|
|
|
|
eraseBefore: time.Now(),
|
|
|
|
expectedRaws: 1,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
eraseBefore: time.Now().Add(24 * time.Hour),
|
|
|
|
expectedRaws: 0,
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, tt := range tests {
|
2019-05-29 14:30:16 +01:00
|
|
|
test := tt
|
2019-04-03 04:55:24 +01:00
|
|
|
testplanet.Run(t, testplanet.Config{
|
|
|
|
SatelliteCount: 1, StorageNodeCount: 0, UplinkCount: 0,
|
|
|
|
}, func(t *testing.T, ctx *testcontext.Context, planet *testplanet.Planet) {
|
|
|
|
id := teststorj.NodeIDFromBytes([]byte{})
|
|
|
|
nodeData := make(map[storj.NodeID]float64)
|
|
|
|
nodeData[id] = float64(1000)
|
|
|
|
|
2019-05-10 20:05:42 +01:00
|
|
|
err := planet.Satellites[0].DB.StoragenodeAccounting().SaveTallies(ctx, time.Now(), nodeData)
|
2019-04-03 04:55:24 +01:00
|
|
|
require.NoError(t, err)
|
|
|
|
|
2019-05-29 14:30:16 +01:00
|
|
|
err = planet.Satellites[0].DB.StoragenodeAccounting().DeleteTalliesBefore(ctx, test.eraseBefore)
|
2019-04-03 04:55:24 +01:00
|
|
|
require.NoError(t, err)
|
|
|
|
|
2019-05-10 20:05:42 +01:00
|
|
|
raws, err := planet.Satellites[0].DB.StoragenodeAccounting().GetTallies(ctx)
|
2019-04-03 04:55:24 +01:00
|
|
|
require.NoError(t, err)
|
2019-05-29 14:30:16 +01:00
|
|
|
assert.Len(t, raws, test.expectedRaws)
|
2019-04-03 04:55:24 +01:00
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
2019-04-09 14:48:35 +01:00
|
|
|
|
2019-04-29 18:46:38 +01:00
|
|
|
func TestOnlyInline(t *testing.T) {
|
|
|
|
testplanet.Run(t, testplanet.Config{
|
|
|
|
SatelliteCount: 1, StorageNodeCount: 6, UplinkCount: 1,
|
|
|
|
}, func(t *testing.T, ctx *testcontext.Context, planet *testplanet.Planet) {
|
2019-10-07 21:55:20 +01:00
|
|
|
planet.Satellites[0].Accounting.Tally.Loop.Pause()
|
2019-04-29 18:46:38 +01:00
|
|
|
uplink := planet.Uplinks[0]
|
2019-06-13 17:58:40 +01:00
|
|
|
|
2019-04-29 18:46:38 +01:00
|
|
|
// Setup: create data for the uplink to upload
|
2019-06-26 11:38:51 +01:00
|
|
|
expectedData := testrand.Bytes(1 * memory.KiB)
|
2019-04-29 18:46:38 +01:00
|
|
|
|
|
|
|
// Setup: get the expected size of the data that will be stored in pointer
|
2019-06-19 09:11:27 +01:00
|
|
|
// Since the data is small enough to be stored inline, when it is encrypted, we only
|
|
|
|
// add 16 bytes of encryption authentication overhead. No encryption block
|
|
|
|
// padding will be added since we are not chunking data that we store inline.
|
|
|
|
const encryptionAuthOverhead = 16 // bytes
|
|
|
|
expectedTotalBytes := len(expectedData) + encryptionAuthOverhead
|
2019-04-29 18:46:38 +01:00
|
|
|
|
|
|
|
// Setup: The data in this tally should match the pointer that the uplink.upload created
|
2019-06-13 17:58:40 +01:00
|
|
|
expectedBucketName := "testbucket"
|
2019-10-07 21:55:20 +01:00
|
|
|
expectedTally := &accounting.BucketTally{
|
2020-08-31 11:14:20 +01:00
|
|
|
BucketLocation: metabase.BucketLocation{
|
|
|
|
ProjectID: uplink.Projects[0].ID,
|
|
|
|
BucketName: expectedBucketName,
|
|
|
|
},
|
2019-09-13 14:51:41 +01:00
|
|
|
ObjectCount: 1,
|
2019-04-29 18:46:38 +01:00
|
|
|
InlineSegments: 1,
|
2019-06-19 09:11:27 +01:00
|
|
|
InlineBytes: int64(expectedTotalBytes),
|
2020-11-25 11:33:24 +00:00
|
|
|
MetadataSize: 0,
|
2019-04-29 18:46:38 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// Execute test: upload a file, then calculate at rest data
|
2019-06-26 11:38:51 +01:00
|
|
|
err := uplink.Upload(ctx, planet.Satellites[0], expectedBucketName, "test/path", expectedData)
|
2019-04-29 18:46:38 +01:00
|
|
|
assert.NoError(t, err)
|
|
|
|
|
2019-10-07 21:55:20 +01:00
|
|
|
// run multiple times to ensure we add tallies
|
2019-04-29 18:46:38 +01:00
|
|
|
for i := 0; i < 2; i++ {
|
2020-04-10 18:35:58 +01:00
|
|
|
obs := tally.NewObserver(planet.Satellites[0].Log.Named("observer"), time.Now())
|
2019-10-07 21:55:20 +01:00
|
|
|
err := planet.Satellites[0].Metainfo.Loop.Join(ctx, obs)
|
2019-04-29 18:46:38 +01:00
|
|
|
require.NoError(t, err)
|
|
|
|
|
2019-10-07 21:55:20 +01:00
|
|
|
now := time.Now().Add(time.Duration(i) * time.Second)
|
|
|
|
err = planet.Satellites[0].DB.ProjectAccounting().SaveTallies(ctx, now, obs.Bucket)
|
2019-04-29 18:46:38 +01:00
|
|
|
require.NoError(t, err)
|
|
|
|
|
2019-10-07 21:55:20 +01:00
|
|
|
assert.Equal(t, 1, len(obs.Bucket))
|
|
|
|
for _, actualTally := range obs.Bucket {
|
2020-11-25 11:33:24 +00:00
|
|
|
// checking the exact metadata size is brittle, instead, verify that it's not zero
|
|
|
|
assert.NotZero(t, actualTally.MetadataSize)
|
|
|
|
actualTally.MetadataSize = expectedTally.MetadataSize
|
2019-10-07 21:55:20 +01:00
|
|
|
assert.Equal(t, expectedTally, actualTally)
|
2019-04-29 18:46:38 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
2019-06-13 17:58:40 +01:00
|
|
|
func TestCalculateBucketAtRestData(t *testing.T) {
|
|
|
|
testplanet.Run(t, testplanet.Config{
|
2020-12-17 13:04:42 +00:00
|
|
|
SatelliteCount: 1, StorageNodeCount: 4, UplinkCount: 2,
|
|
|
|
Reconfigure: testplanet.Reconfigure{
|
|
|
|
Satellite: testplanet.Combine(
|
|
|
|
testplanet.ReconfigureRS(2, 3, 4, 4),
|
|
|
|
testplanet.MaxSegmentSize(20*memory.KiB),
|
|
|
|
),
|
|
|
|
},
|
2019-06-13 17:58:40 +01:00
|
|
|
}, func(t *testing.T, ctx *testcontext.Context, planet *testplanet.Planet) {
|
2020-12-17 13:04:42 +00:00
|
|
|
satellite := planet.Satellites[0]
|
|
|
|
|
|
|
|
err := planet.Uplinks[0].Upload(ctx, satellite, "alpha", "inline", make([]byte, 10*memory.KiB))
|
|
|
|
require.NoError(t, err)
|
|
|
|
|
|
|
|
err = planet.Uplinks[0].Upload(ctx, satellite, "alpha", "remote", make([]byte, 30*memory.KiB))
|
|
|
|
require.NoError(t, err)
|
|
|
|
|
|
|
|
err = planet.Uplinks[0].Upload(ctx, satellite, "beta", "remote", make([]byte, 30*memory.KiB))
|
|
|
|
require.NoError(t, err)
|
|
|
|
|
|
|
|
err = planet.Uplinks[1].Upload(ctx, satellite, "alpha", "remote", make([]byte, 30*memory.KiB))
|
|
|
|
require.NoError(t, err)
|
|
|
|
|
|
|
|
objects, err := satellite.Metainfo.Metabase.TestingAllObjects(ctx)
|
|
|
|
require.NoError(t, err)
|
|
|
|
|
|
|
|
segments, err := satellite.Metainfo.Metabase.TestingAllSegments(ctx)
|
|
|
|
require.NoError(t, err)
|
|
|
|
|
|
|
|
expectedTotal := map[metabase.BucketLocation]*accounting.BucketTally{}
|
|
|
|
ensure := func(loc metabase.BucketLocation) *accounting.BucketTally {
|
|
|
|
if t, ok := expectedTotal[loc]; ok {
|
|
|
|
return t
|
|
|
|
}
|
|
|
|
t := &accounting.BucketTally{BucketLocation: loc}
|
|
|
|
expectedTotal[loc] = t
|
|
|
|
return t
|
|
|
|
}
|
|
|
|
|
|
|
|
streamLocation := map[uuid.UUID]metabase.BucketLocation{}
|
|
|
|
for _, object := range objects {
|
|
|
|
loc := object.Location().Bucket()
|
|
|
|
streamLocation[object.StreamID] = loc
|
|
|
|
t := ensure(loc)
|
|
|
|
t.ObjectCount++
|
|
|
|
t.MetadataSize += int64(len(object.EncryptedMetadata))
|
2019-06-13 17:58:40 +01:00
|
|
|
}
|
2020-12-17 13:04:42 +00:00
|
|
|
for _, segment := range segments {
|
|
|
|
loc := streamLocation[segment.StreamID]
|
|
|
|
t := ensure(loc)
|
|
|
|
if len(segment.Pieces) > 0 {
|
|
|
|
t.RemoteSegments++
|
|
|
|
t.RemoteBytes += int64(segment.EncryptedSize)
|
|
|
|
} else {
|
|
|
|
t.InlineSegments++
|
|
|
|
t.InlineBytes += int64(segment.EncryptedSize)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
require.Len(t, expectedTotal, 3)
|
|
|
|
|
|
|
|
obs := tally.NewObserver(satellite.Log.Named("observer"), time.Now())
|
|
|
|
err = satellite.Metainfo.Loop.Join(ctx, obs)
|
|
|
|
require.NoError(t, err)
|
|
|
|
require.Equal(t, expectedTotal, obs.Bucket)
|
2019-06-20 20:15:13 +01:00
|
|
|
})
|
|
|
|
}
|
2019-06-13 17:58:40 +01:00
|
|
|
|
2020-04-10 18:35:58 +01:00
|
|
|
func TestTallyIgnoresExpiredPointers(t *testing.T) {
|
|
|
|
testplanet.Run(t, testplanet.Config{
|
|
|
|
SatelliteCount: 1, StorageNodeCount: 6, UplinkCount: 1,
|
|
|
|
}, func(t *testing.T, ctx *testcontext.Context, planet *testplanet.Planet) {
|
2020-12-17 13:04:42 +00:00
|
|
|
satellite := planet.Satellites[0]
|
2020-04-10 18:35:58 +01:00
|
|
|
|
2020-12-17 13:04:42 +00:00
|
|
|
now := time.Now()
|
|
|
|
err := planet.Uplinks[0].UploadWithExpiration(ctx, planet.Satellites[0], "bucket", "path", []byte{1}, now.Add(12*time.Hour))
|
2020-04-10 18:35:58 +01:00
|
|
|
require.NoError(t, err)
|
|
|
|
|
2020-12-17 13:04:42 +00:00
|
|
|
obs := tally.NewObserver(satellite.Log.Named("observer"), now.Add(24*time.Hour))
|
|
|
|
err = satellite.Metainfo.Loop.Join(ctx, obs)
|
2020-04-10 18:35:58 +01:00
|
|
|
require.NoError(t, err)
|
|
|
|
|
|
|
|
// there should be no observed buckets because all of the pointers are expired
|
2020-08-31 11:14:20 +01:00
|
|
|
require.Equal(t, obs.Bucket, map[metabase.BucketLocation]*accounting.BucketTally{})
|
2020-04-10 18:35:58 +01:00
|
|
|
})
|
|
|
|
}
|
|
|
|
|
2019-10-31 17:27:38 +00:00
|
|
|
func TestTallyLiveAccounting(t *testing.T) {
|
|
|
|
testplanet.Run(t, testplanet.Config{
|
|
|
|
SatelliteCount: 1, StorageNodeCount: 6, UplinkCount: 1,
|
|
|
|
}, func(t *testing.T, ctx *testcontext.Context, planet *testplanet.Planet) {
|
|
|
|
tally := planet.Satellites[0].Accounting.Tally
|
2020-04-16 13:12:46 +01:00
|
|
|
projectID := planet.Uplinks[0].Projects[0].ID
|
2019-10-31 17:27:38 +00:00
|
|
|
tally.Loop.Pause()
|
|
|
|
|
|
|
|
expectedData := testrand.Bytes(5 * memory.MB)
|
|
|
|
|
|
|
|
err := planet.Uplinks[0].Upload(ctx, planet.Satellites[0], "testbucket", "test/path", expectedData)
|
|
|
|
require.NoError(t, err)
|
|
|
|
|
2020-12-17 13:04:42 +00:00
|
|
|
segments, err := planet.Satellites[0].Metainfo.Metabase.TestingAllSegments(ctx)
|
2019-10-31 17:27:38 +00:00
|
|
|
require.NoError(t, err)
|
2020-12-17 13:04:42 +00:00
|
|
|
require.Len(t, segments, 1)
|
2019-10-31 17:27:38 +00:00
|
|
|
|
2020-12-17 13:04:42 +00:00
|
|
|
segmentSize := int64(segments[0].EncryptedSize)
|
2019-10-31 17:27:38 +00:00
|
|
|
|
|
|
|
tally.Loop.TriggerWait()
|
|
|
|
|
|
|
|
expectedSize := segmentSize
|
|
|
|
|
|
|
|
total, err := planet.Satellites[0].Accounting.ProjectUsage.GetProjectStorageTotals(ctx, projectID)
|
|
|
|
require.NoError(t, err)
|
|
|
|
require.Equal(t, expectedSize, total)
|
|
|
|
|
|
|
|
for i := 0; i < 5; i++ {
|
|
|
|
err := planet.Uplinks[0].Upload(ctx, planet.Satellites[0], "testbucket", fmt.Sprintf("test/path/%d", i), expectedData)
|
|
|
|
require.NoError(t, err)
|
|
|
|
|
|
|
|
tally.Loop.TriggerWait()
|
|
|
|
|
|
|
|
expectedSize += segmentSize
|
|
|
|
|
|
|
|
total, err := planet.Satellites[0].Accounting.ProjectUsage.GetProjectStorageTotals(ctx, projectID)
|
|
|
|
require.NoError(t, err)
|
|
|
|
require.Equal(t, expectedSize, total)
|
|
|
|
}
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
2020-01-29 14:34:12 +00:00
|
|
|
func TestTallyEmptyProjectUpdatesLiveAccounting(t *testing.T) {
|
|
|
|
testplanet.Run(t, testplanet.Config{
|
|
|
|
SatelliteCount: 1, StorageNodeCount: 6, UplinkCount: 2,
|
|
|
|
}, func(t *testing.T, ctx *testcontext.Context, planet *testplanet.Planet) {
|
|
|
|
planet.Satellites[0].Accounting.Tally.Loop.Pause()
|
|
|
|
|
2020-04-16 13:12:46 +01:00
|
|
|
project1 := planet.Uplinks[1].Projects[0].ID
|
2020-01-29 14:34:12 +00:00
|
|
|
|
|
|
|
data := testrand.Bytes(1 * memory.MB)
|
|
|
|
|
|
|
|
// we need an extra bucket with data for this test. If no buckets are found at all,
|
|
|
|
// the update block is skipped in tally
|
|
|
|
err := planet.Uplinks[0].Upload(ctx, planet.Satellites[0], "bucket", "test", data)
|
|
|
|
require.NoError(t, err)
|
|
|
|
|
|
|
|
err = planet.Uplinks[1].Upload(ctx, planet.Satellites[0], "bucket", "test", data)
|
|
|
|
require.NoError(t, err)
|
|
|
|
|
|
|
|
planet.Satellites[0].Accounting.Tally.Loop.TriggerWait()
|
|
|
|
planet.Satellites[0].Accounting.Tally.Loop.Pause()
|
|
|
|
|
|
|
|
total, err := planet.Satellites[0].Accounting.ProjectUsage.GetProjectStorageTotals(ctx, project1)
|
|
|
|
require.NoError(t, err)
|
|
|
|
require.True(t, total >= int64(len(data)))
|
|
|
|
|
|
|
|
err = planet.Uplinks[1].DeleteObject(ctx, planet.Satellites[0], "bucket", "test")
|
|
|
|
require.NoError(t, err)
|
|
|
|
|
|
|
|
planet.Satellites[0].Accounting.Tally.Loop.TriggerWait()
|
|
|
|
|
|
|
|
p1Total, err := planet.Satellites[0].Accounting.ProjectUsage.GetProjectStorageTotals(ctx, project1)
|
|
|
|
require.NoError(t, err)
|
|
|
|
require.Zero(t, p1Total)
|
|
|
|
})
|
|
|
|
}
|