d70f6e3760
What: This change moves project-level bucket metadata encryption information to the volatile section, because it is unlikely to remain in future releases Why: Ultimately, the web user interface will allow bucket management (creation, removal, etc), but not object management as that requires an encryption key for sure and we don't want to have users give the satellite their encryption keys. At a high level, a (*Project) type should map to all of the things you can do inside the web user interface within a project, which by necessity cannot have an encryption key. So, we really don't want an encryption key in the non-volatile section of this library.
780 lines
26 KiB
Go
780 lines
26 KiB
Go
// Copyright (C) 2019 Storj Labs, Inc.
|
|
// See LICENSE for copying information.
|
|
|
|
package miniogw
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"encoding/hex"
|
|
"fmt"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
minio "github.com/minio/minio/cmd"
|
|
"github.com/minio/minio/pkg/auth"
|
|
"github.com/minio/minio/pkg/hash"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/vivint/infectious"
|
|
|
|
"storj.io/storj/internal/memory"
|
|
"storj.io/storj/internal/testcontext"
|
|
"storj.io/storj/internal/testplanet"
|
|
libuplink "storj.io/storj/lib/uplink"
|
|
"storj.io/storj/pkg/eestream"
|
|
"storj.io/storj/pkg/metainfo/kvmetainfo"
|
|
"storj.io/storj/pkg/pb"
|
|
"storj.io/storj/pkg/storage/buckets"
|
|
ecclient "storj.io/storj/pkg/storage/ec"
|
|
"storj.io/storj/pkg/storage/segments"
|
|
"storj.io/storj/pkg/storage/streams"
|
|
"storj.io/storj/pkg/storj"
|
|
"storj.io/storj/satellite/console"
|
|
)
|
|
|
|
const (
|
|
TestEncKey = "test-encryption-key"
|
|
TestBucket = "test-bucket"
|
|
TestFile = "test-file"
|
|
DestBucket = "dest-bucket"
|
|
DestFile = "dest-file"
|
|
)
|
|
|
|
var TestAPIKey = "test-api-key"
|
|
|
|
func TestMakeBucketWithLocation(t *testing.T) {
|
|
runTest(t, func(ctx context.Context, layer minio.ObjectLayer, metainfo storj.Metainfo, streams streams.Store) {
|
|
// Check the error when creating bucket with empty name
|
|
err := layer.MakeBucketWithLocation(ctx, "", "")
|
|
assert.Equal(t, minio.BucketNameInvalid{}, err)
|
|
|
|
// Create a bucket with the Minio API
|
|
err = layer.MakeBucketWithLocation(ctx, TestBucket, "")
|
|
assert.NoError(t, err)
|
|
|
|
// Check that the bucket is created using the Metainfo API
|
|
bucket, err := metainfo.GetBucket(ctx, TestBucket)
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, TestBucket, bucket.Name)
|
|
assert.True(t, time.Since(bucket.Created) < 1*time.Minute)
|
|
assert.Equal(t, storj.AESGCM, bucket.PathCipher)
|
|
|
|
// Check the error when trying to create an existing bucket
|
|
err = layer.MakeBucketWithLocation(ctx, TestBucket, "")
|
|
assert.Equal(t, minio.BucketAlreadyExists{Bucket: TestBucket}, err)
|
|
})
|
|
}
|
|
|
|
func TestGetBucketInfo(t *testing.T) {
|
|
runTest(t, func(ctx context.Context, layer minio.ObjectLayer, metainfo storj.Metainfo, streams streams.Store) {
|
|
// Check the error when getting info about bucket with empty name
|
|
_, err := layer.GetBucketInfo(ctx, "")
|
|
assert.Equal(t, minio.BucketNameInvalid{}, err)
|
|
|
|
// Check the error when getting info about non-existing bucket
|
|
_, err = layer.GetBucketInfo(ctx, TestBucket)
|
|
assert.Equal(t, minio.BucketNotFound{Bucket: TestBucket}, err)
|
|
|
|
// Create the bucket using the Metainfo API
|
|
info, err := metainfo.CreateBucket(ctx, TestBucket, nil)
|
|
assert.NoError(t, err)
|
|
|
|
// Check the bucket info using the Minio API
|
|
bucket, err := layer.GetBucketInfo(ctx, TestBucket)
|
|
if assert.NoError(t, err) {
|
|
assert.Equal(t, TestBucket, bucket.Name)
|
|
assert.Equal(t, info.Created, bucket.Created)
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestDeleteBucket(t *testing.T) {
|
|
runTest(t, func(ctx context.Context, layer minio.ObjectLayer, metainfo storj.Metainfo, streams streams.Store) {
|
|
// Check the error when deleting bucket with empty name
|
|
err := layer.DeleteBucket(ctx, "")
|
|
assert.Equal(t, minio.BucketNameInvalid{}, err)
|
|
|
|
// Check the error when deleting non-existing bucket
|
|
err = layer.DeleteBucket(ctx, TestBucket)
|
|
assert.Equal(t, minio.BucketNotFound{Bucket: TestBucket}, err)
|
|
|
|
// Create a bucket with a file using the Metainfo API
|
|
_, err = metainfo.CreateBucket(ctx, TestBucket, nil)
|
|
assert.NoError(t, err)
|
|
|
|
_, err = createFile(ctx, metainfo, streams, TestBucket, TestFile, nil, nil)
|
|
assert.NoError(t, err)
|
|
|
|
// Check the error when deleting non-empty bucket
|
|
err = layer.DeleteBucket(ctx, TestBucket)
|
|
assert.Equal(t, minio.BucketNotEmpty{Bucket: TestBucket}, err)
|
|
|
|
// Delete the file using the Metainfo API, so the bucket becomes empty
|
|
err = metainfo.DeleteObject(ctx, TestBucket, TestFile)
|
|
assert.NoError(t, err)
|
|
|
|
// Delete the bucket info using the Minio API
|
|
err = layer.DeleteBucket(ctx, TestBucket)
|
|
assert.NoError(t, err)
|
|
|
|
// Check that the bucket is deleted using the Metainfo API
|
|
_, err = metainfo.GetBucket(ctx, TestBucket)
|
|
assert.True(t, storj.ErrBucketNotFound.Has(err))
|
|
})
|
|
}
|
|
|
|
func TestListBuckets(t *testing.T) {
|
|
runTest(t, func(ctx context.Context, layer minio.ObjectLayer, metainfo storj.Metainfo, streams streams.Store) {
|
|
// Check that empty list is return if no buckets exist yet
|
|
bucketInfos, err := layer.ListBuckets(ctx)
|
|
assert.NoError(t, err)
|
|
assert.Empty(t, bucketInfos)
|
|
|
|
// Create all expected buckets using the Metainfo API
|
|
bucketNames := []string{"bucket 1", "bucket 2", "bucket 3"}
|
|
buckets := make([]storj.Bucket, len(bucketNames))
|
|
for i, bucketName := range bucketNames {
|
|
bucket, err := metainfo.CreateBucket(ctx, bucketName, nil)
|
|
buckets[i] = bucket
|
|
assert.NoError(t, err)
|
|
}
|
|
|
|
// Check that the expected buckets can be listed using the Minio API
|
|
bucketInfos, err = layer.ListBuckets(ctx)
|
|
if assert.NoError(t, err) {
|
|
assert.Equal(t, len(bucketNames), len(bucketInfos))
|
|
for i, bucketInfo := range bucketInfos {
|
|
assert.Equal(t, bucketNames[i], bucketInfo.Name)
|
|
assert.Equal(t, buckets[i].Created, bucketInfo.Created)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestPutObject(t *testing.T) {
|
|
data, err := hash.NewReader(bytes.NewReader([]byte("test")),
|
|
int64(len("test")),
|
|
"098f6bcd4621d373cade4e832627b4f6",
|
|
"9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
metadata := map[string]string{
|
|
"content-type": "media/foo",
|
|
"key1": "value1",
|
|
"key2": "value2",
|
|
}
|
|
|
|
serMetaInfo := pb.SerializableMeta{
|
|
ContentType: metadata["content-type"],
|
|
UserDefined: map[string]string{
|
|
"key1": metadata["key1"],
|
|
"key2": metadata["key2"],
|
|
},
|
|
}
|
|
|
|
runTest(t, func(ctx context.Context, layer minio.ObjectLayer, metainfo storj.Metainfo, streams streams.Store) {
|
|
// Check the error when putting an object to a bucket with empty name
|
|
_, err := layer.PutObject(ctx, "", "", nil, nil)
|
|
assert.Equal(t, minio.BucketNameInvalid{}, err)
|
|
|
|
// Check the error when putting an object to a non-existing bucket
|
|
_, err = layer.PutObject(ctx, TestBucket, TestFile, nil, nil)
|
|
assert.Equal(t, minio.BucketNotFound{Bucket: TestBucket}, err)
|
|
|
|
// Create the bucket using the Metainfo API
|
|
_, err = metainfo.CreateBucket(ctx, TestBucket, nil)
|
|
assert.NoError(t, err)
|
|
|
|
// Check the error when putting an object with empty name
|
|
_, err = layer.PutObject(ctx, TestBucket, "", nil, nil)
|
|
assert.Equal(t, minio.ObjectNameInvalid{Bucket: TestBucket}, err)
|
|
|
|
// Put the object using the Minio API
|
|
info, err := layer.PutObject(ctx, TestBucket, TestFile, data, metadata)
|
|
if assert.NoError(t, err) {
|
|
assert.Equal(t, TestFile, info.Name)
|
|
assert.Equal(t, TestBucket, info.Bucket)
|
|
assert.False(t, info.IsDir)
|
|
assert.True(t, time.Since(info.ModTime) < 1*time.Minute)
|
|
assert.Equal(t, data.Size(), info.Size)
|
|
// assert.Equal(t, data.SHA256HexString(), info.ETag) TODO: when we start calculating checksums
|
|
assert.Equal(t, serMetaInfo.ContentType, info.ContentType)
|
|
assert.Equal(t, serMetaInfo.UserDefined, info.UserDefined)
|
|
}
|
|
|
|
// Check that the object is uploaded using the Metainfo API
|
|
obj, err := metainfo.GetObject(ctx, TestBucket, TestFile)
|
|
if assert.NoError(t, err) {
|
|
assert.Equal(t, TestFile, obj.Path)
|
|
assert.Equal(t, TestBucket, obj.Bucket.Name)
|
|
assert.False(t, obj.IsPrefix)
|
|
assert.Equal(t, info.ModTime, obj.Modified)
|
|
assert.Equal(t, info.Size, obj.Size)
|
|
assert.Equal(t, info.ETag, hex.EncodeToString(obj.Checksum))
|
|
assert.Equal(t, info.ContentType, obj.ContentType)
|
|
assert.Equal(t, info.UserDefined, obj.Metadata)
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestGetObjectInfo(t *testing.T) {
|
|
runTest(t, func(ctx context.Context, layer minio.ObjectLayer, metainfo storj.Metainfo, streams streams.Store) {
|
|
// Check the error when getting an object from a bucket with empty name
|
|
_, err := layer.GetObjectInfo(ctx, "", "")
|
|
assert.Equal(t, minio.BucketNameInvalid{}, err)
|
|
|
|
// Check the error when getting an object from non-existing bucket
|
|
_, err = layer.GetObjectInfo(ctx, TestBucket, TestFile)
|
|
assert.Equal(t, minio.BucketNotFound{Bucket: TestBucket}, err)
|
|
|
|
// Create the bucket using the Metainfo API
|
|
_, err = metainfo.CreateBucket(ctx, TestBucket, nil)
|
|
assert.NoError(t, err)
|
|
|
|
// Check the error when getting an object with empty name
|
|
_, err = layer.GetObjectInfo(ctx, TestBucket, "")
|
|
assert.Equal(t, minio.ObjectNameInvalid{Bucket: TestBucket}, err)
|
|
|
|
// Check the error when getting a non-existing object
|
|
_, err = layer.GetObjectInfo(ctx, TestBucket, TestFile)
|
|
assert.Equal(t, minio.ObjectNotFound{Bucket: TestBucket, Object: TestFile}, err)
|
|
|
|
// Create the object using the Metainfo API
|
|
createInfo := storj.CreateObject{
|
|
ContentType: "text/plain",
|
|
Metadata: map[string]string{"key1": "value1", "key2": "value2"},
|
|
}
|
|
obj, err := createFile(ctx, metainfo, streams, TestBucket, TestFile, &createInfo, []byte("test"))
|
|
assert.NoError(t, err)
|
|
|
|
// Get the object info using the Minio API
|
|
info, err := layer.GetObjectInfo(ctx, TestBucket, TestFile)
|
|
if assert.NoError(t, err) {
|
|
assert.Equal(t, TestFile, info.Name)
|
|
assert.Equal(t, TestBucket, info.Bucket)
|
|
assert.False(t, info.IsDir)
|
|
assert.Equal(t, obj.Modified, info.ModTime)
|
|
assert.Equal(t, obj.Size, info.Size)
|
|
assert.Equal(t, hex.EncodeToString(obj.Checksum), info.ETag)
|
|
assert.Equal(t, createInfo.ContentType, info.ContentType)
|
|
assert.Equal(t, createInfo.Metadata, info.UserDefined)
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestGetObject(t *testing.T) {
|
|
runTest(t, func(ctx context.Context, layer minio.ObjectLayer, metainfo storj.Metainfo, streams streams.Store) {
|
|
// Check the error when getting an object from a bucket with empty name
|
|
err := layer.GetObject(ctx, "", "", 0, 0, nil, "")
|
|
assert.Equal(t, minio.BucketNameInvalid{}, err)
|
|
|
|
// Check the error when getting an object from non-existing bucket
|
|
err = layer.GetObject(ctx, TestBucket, TestFile, 0, 0, nil, "")
|
|
assert.Equal(t, minio.BucketNotFound{Bucket: TestBucket}, err)
|
|
|
|
// Create the bucket using the Metainfo API
|
|
_, err = metainfo.CreateBucket(ctx, TestBucket, nil)
|
|
assert.NoError(t, err)
|
|
|
|
// Check the error when getting an object with empty name
|
|
err = layer.GetObject(ctx, TestBucket, "", 0, 0, nil, "")
|
|
assert.Equal(t, minio.ObjectNameInvalid{Bucket: TestBucket}, err)
|
|
|
|
// Check the error when getting a non-existing object
|
|
err = layer.GetObject(ctx, TestBucket, TestFile, 0, 0, nil, "")
|
|
assert.Equal(t, minio.ObjectNotFound{Bucket: TestBucket, Object: TestFile}, err)
|
|
|
|
// Create the object using the Metainfo API
|
|
createInfo := storj.CreateObject{
|
|
ContentType: "text/plain",
|
|
Metadata: map[string]string{"key1": "value1", "key2": "value2"},
|
|
}
|
|
_, err = createFile(ctx, metainfo, streams, TestBucket, TestFile, &createInfo, []byte("abcdef"))
|
|
assert.NoError(t, err)
|
|
|
|
for i, tt := range []struct {
|
|
offset, length int64
|
|
substr string
|
|
err error
|
|
}{
|
|
{offset: 0, length: 0, substr: ""},
|
|
{offset: 3, length: 0, substr: ""},
|
|
{offset: 0, length: -1, substr: "abcdef"},
|
|
{offset: 0, length: 6, substr: "abcdef"},
|
|
{offset: 0, length: 5, substr: "abcde"},
|
|
{offset: 0, length: 4, substr: "abcd"},
|
|
{offset: 1, length: 4, substr: "bcde"},
|
|
{offset: 2, length: 4, substr: "cdef"},
|
|
{offset: 0, length: 7, substr: "", err: minio.InvalidRange{OffsetBegin: 0, OffsetEnd: 7, ResourceSize: 6}},
|
|
{offset: -1, length: 7, substr: "", err: minio.InvalidRange{OffsetBegin: -1, OffsetEnd: 6, ResourceSize: 6}},
|
|
{offset: 0, length: -2, substr: "", err: minio.InvalidRange{OffsetBegin: 0, OffsetEnd: -2, ResourceSize: 6}},
|
|
} {
|
|
errTag := fmt.Sprintf("%d. %+v", i, tt)
|
|
|
|
var buf bytes.Buffer
|
|
|
|
// Get the object info using the Minio API
|
|
err = layer.GetObject(ctx, TestBucket, TestFile, tt.offset, tt.length, &buf, "")
|
|
|
|
if tt.err != nil {
|
|
assert.Equal(t, tt.err, err, errTag)
|
|
} else if assert.NoError(t, err) {
|
|
assert.Equal(t, tt.substr, buf.String(), errTag)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestCopyObject(t *testing.T) {
|
|
runTest(t, func(ctx context.Context, layer minio.ObjectLayer, metainfo storj.Metainfo, streams streams.Store) {
|
|
// Check the error when copying an object from a bucket with empty name
|
|
_, err := layer.CopyObject(ctx, "", TestFile, DestBucket, DestFile, minio.ObjectInfo{})
|
|
assert.Equal(t, minio.BucketNameInvalid{}, err)
|
|
|
|
// Check the error when copying an object from non-existing bucket
|
|
_, err = layer.CopyObject(ctx, TestBucket, TestFile, DestBucket, DestFile, minio.ObjectInfo{})
|
|
assert.Equal(t, minio.BucketNotFound{Bucket: TestBucket}, err)
|
|
|
|
// Create the source bucket using the Metainfo API
|
|
_, err = metainfo.CreateBucket(ctx, TestBucket, nil)
|
|
assert.NoError(t, err)
|
|
|
|
// Check the error when copying an object with empty name
|
|
_, err = layer.CopyObject(ctx, TestBucket, "", DestBucket, DestFile, minio.ObjectInfo{})
|
|
assert.Equal(t, minio.ObjectNameInvalid{Bucket: TestBucket}, err)
|
|
|
|
// Create the source object using the Metainfo API
|
|
createInfo := storj.CreateObject{
|
|
ContentType: "text/plain",
|
|
Metadata: map[string]string{"key1": "value1", "key2": "value2"},
|
|
}
|
|
obj, err := createFile(ctx, metainfo, streams, TestBucket, TestFile, &createInfo, []byte("test"))
|
|
assert.NoError(t, err)
|
|
|
|
// Get the source object info using the Minio API
|
|
srcInfo, err := layer.GetObjectInfo(ctx, TestBucket, TestFile)
|
|
assert.NoError(t, err)
|
|
|
|
// Check the error when copying an object to a bucket with empty name
|
|
_, err = layer.CopyObject(ctx, TestBucket, TestFile, "", DestFile, srcInfo)
|
|
assert.Equal(t, minio.BucketNameInvalid{}, err)
|
|
|
|
// Check the error when copying an object to a non-existing bucket
|
|
_, err = layer.CopyObject(ctx, TestBucket, TestFile, DestBucket, DestFile, srcInfo)
|
|
assert.Equal(t, minio.BucketNotFound{Bucket: DestBucket}, err)
|
|
|
|
// Create the destination bucket using the Metainfo API
|
|
_, err = metainfo.CreateBucket(ctx, DestBucket, nil)
|
|
assert.NoError(t, err)
|
|
|
|
// Copy the object using the Minio API
|
|
info, err := layer.CopyObject(ctx, TestBucket, TestFile, DestBucket, DestFile, srcInfo)
|
|
if assert.NoError(t, err) {
|
|
assert.Equal(t, DestFile, info.Name)
|
|
assert.Equal(t, DestBucket, info.Bucket)
|
|
assert.False(t, info.IsDir)
|
|
assert.True(t, info.ModTime.Sub(obj.Modified) < 1*time.Minute)
|
|
assert.Equal(t, obj.Size, info.Size)
|
|
assert.Equal(t, hex.EncodeToString(obj.Checksum), info.ETag)
|
|
assert.Equal(t, createInfo.ContentType, info.ContentType)
|
|
assert.Equal(t, createInfo.Metadata, info.UserDefined)
|
|
}
|
|
|
|
// Check that the destination object is uploaded using the Metainfo API
|
|
obj, err = metainfo.GetObject(ctx, DestBucket, DestFile)
|
|
if assert.NoError(t, err) {
|
|
assert.Equal(t, DestFile, obj.Path)
|
|
assert.Equal(t, DestBucket, obj.Bucket.Name)
|
|
assert.False(t, obj.IsPrefix)
|
|
assert.Equal(t, info.ModTime, obj.Modified)
|
|
assert.Equal(t, info.Size, obj.Size)
|
|
assert.Equal(t, info.ETag, hex.EncodeToString(obj.Checksum))
|
|
assert.Equal(t, info.ContentType, obj.ContentType)
|
|
assert.Equal(t, info.UserDefined, obj.Metadata)
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestDeleteObject(t *testing.T) {
|
|
runTest(t, func(ctx context.Context, layer minio.ObjectLayer, metainfo storj.Metainfo, streams streams.Store) {
|
|
// Check the error when deleting an object from a bucket with empty name
|
|
err := layer.DeleteObject(ctx, "", "")
|
|
assert.Equal(t, minio.BucketNameInvalid{}, err)
|
|
|
|
// Check the error when deleting an object from non-existing bucket
|
|
err = layer.DeleteObject(ctx, TestBucket, TestFile)
|
|
assert.Equal(t, minio.BucketNotFound{Bucket: TestBucket}, err)
|
|
|
|
// Create the bucket using the Metainfo API
|
|
_, err = metainfo.CreateBucket(ctx, TestBucket, nil)
|
|
assert.NoError(t, err)
|
|
|
|
// Check the error when deleting an object with empty name
|
|
err = layer.DeleteObject(ctx, TestBucket, "")
|
|
assert.Equal(t, minio.ObjectNameInvalid{Bucket: TestBucket}, err)
|
|
|
|
// Check the error when deleting a non-existing object
|
|
err = layer.DeleteObject(ctx, TestBucket, TestFile)
|
|
assert.Equal(t, minio.ObjectNotFound{Bucket: TestBucket, Object: TestFile}, err)
|
|
|
|
// Create the object using the Metainfo API
|
|
_, err = createFile(ctx, metainfo, streams, TestBucket, TestFile, nil, nil)
|
|
assert.NoError(t, err)
|
|
|
|
// Delete the object info using the Minio API
|
|
err = layer.DeleteObject(ctx, TestBucket, TestFile)
|
|
assert.NoError(t, err)
|
|
|
|
// Check that the object is deleted using the Metainfo API
|
|
_, err = metainfo.GetObject(ctx, TestBucket, TestFile)
|
|
assert.True(t, storj.ErrObjectNotFound.Has(err))
|
|
})
|
|
}
|
|
|
|
func TestListObjects(t *testing.T) {
|
|
testListObjects(t, func(ctx context.Context, layer minio.ObjectLayer, bucket, prefix, marker, delimiter string, maxKeys int) ([]string, []minio.ObjectInfo, bool, error) {
|
|
list, err := layer.ListObjects(ctx, TestBucket, prefix, marker, delimiter, maxKeys)
|
|
if err != nil {
|
|
return nil, nil, false, err
|
|
}
|
|
return list.Prefixes, list.Objects, list.IsTruncated, nil
|
|
})
|
|
}
|
|
|
|
func TestListObjectsV2(t *testing.T) {
|
|
testListObjects(t, func(ctx context.Context, layer minio.ObjectLayer, bucket, prefix, marker, delimiter string, maxKeys int) ([]string, []minio.ObjectInfo, bool, error) {
|
|
list, err := layer.ListObjectsV2(ctx, TestBucket, prefix, marker, delimiter, maxKeys, false, "")
|
|
if err != nil {
|
|
return nil, nil, false, err
|
|
}
|
|
return list.Prefixes, list.Objects, list.IsTruncated, nil
|
|
})
|
|
}
|
|
|
|
func testListObjects(t *testing.T, listObjects func(context.Context, minio.ObjectLayer, string, string, string, string, int) ([]string, []minio.ObjectInfo, bool, error)) {
|
|
runTest(t, func(ctx context.Context, layer minio.ObjectLayer, metainfo storj.Metainfo, streams streams.Store) {
|
|
// Check the error when listing objects with unsupported delimiter
|
|
_, err := layer.ListObjects(ctx, TestBucket, "", "", "#", 0)
|
|
assert.Equal(t, minio.UnsupportedDelimiter{Delimiter: "#"}, err)
|
|
|
|
// Check the error when listing objects in a bucket with empty name
|
|
_, err = layer.ListObjects(ctx, "", "", "", "/", 0)
|
|
assert.Equal(t, minio.BucketNameInvalid{}, err)
|
|
|
|
// Check the error when listing objects in a non-existing bucket
|
|
_, err = layer.ListObjects(ctx, TestBucket, "", "", "", 0)
|
|
assert.Equal(t, minio.BucketNotFound{Bucket: TestBucket}, err)
|
|
|
|
// Create the bucket and files using the Metainfo API
|
|
_, err = metainfo.CreateBucket(ctx, TestBucket, &storj.Bucket{PathCipher: storj.Unencrypted})
|
|
assert.NoError(t, err)
|
|
|
|
filePaths := []string{
|
|
"a", "aa", "b", "bb", "c",
|
|
"a/xa", "a/xaa", "a/xb", "a/xbb", "a/xc",
|
|
"b/ya", "b/yaa", "b/yb", "b/ybb", "b/yc",
|
|
}
|
|
|
|
files := make(map[string]storj.Object, len(filePaths))
|
|
createInfo := storj.CreateObject{
|
|
ContentType: "text/plain",
|
|
Metadata: map[string]string{"key1": "value1", "key2": "value2"},
|
|
}
|
|
|
|
for _, filePath := range filePaths {
|
|
file, err := createFile(ctx, metainfo, streams, TestBucket, filePath, &createInfo, []byte("test"))
|
|
files[filePath] = file
|
|
assert.NoError(t, err)
|
|
}
|
|
|
|
for i, tt := range []struct {
|
|
prefix string
|
|
marker string
|
|
delimiter string
|
|
maxKeys int
|
|
more bool
|
|
prefixes []string
|
|
objects []string
|
|
}{
|
|
{
|
|
delimiter: "/",
|
|
prefixes: []string{"a/", "b/"},
|
|
objects: []string{"a", "aa", "b", "bb", "c"},
|
|
}, {
|
|
marker: "`",
|
|
delimiter: "/",
|
|
prefixes: []string{"a/", "b/"},
|
|
objects: []string{"a", "aa", "b", "bb", "c"},
|
|
}, {
|
|
marker: "b",
|
|
delimiter: "/",
|
|
prefixes: []string{"b/"},
|
|
objects: []string{"bb", "c"},
|
|
}, {
|
|
marker: "c",
|
|
delimiter: "/",
|
|
}, {
|
|
marker: "ca",
|
|
delimiter: "/",
|
|
}, {
|
|
delimiter: "/",
|
|
maxKeys: 1,
|
|
more: true,
|
|
objects: []string{"a"},
|
|
}, {
|
|
marker: "`",
|
|
delimiter: "/",
|
|
maxKeys: 1,
|
|
more: true,
|
|
objects: []string{"a"},
|
|
}, {
|
|
marker: "aa",
|
|
delimiter: "/",
|
|
maxKeys: 1,
|
|
more: true,
|
|
objects: []string{"b"},
|
|
}, {
|
|
marker: "c",
|
|
delimiter: "/",
|
|
maxKeys: 1,
|
|
}, {
|
|
marker: "ca",
|
|
delimiter: "/",
|
|
maxKeys: 1,
|
|
}, {
|
|
delimiter: "/",
|
|
maxKeys: 2,
|
|
more: true,
|
|
prefixes: []string{"a/"},
|
|
objects: []string{"a"},
|
|
}, {
|
|
marker: "`",
|
|
delimiter: "/",
|
|
maxKeys: 2,
|
|
more: true,
|
|
prefixes: []string{"a/"},
|
|
objects: []string{"a"},
|
|
}, {
|
|
marker: "aa",
|
|
delimiter: "/",
|
|
maxKeys: 2,
|
|
more: true,
|
|
prefixes: []string{"b/"},
|
|
objects: []string{"b"},
|
|
}, {
|
|
marker: "bb",
|
|
delimiter: "/",
|
|
maxKeys: 2,
|
|
objects: []string{"c"},
|
|
}, {
|
|
marker: "c",
|
|
delimiter: "/",
|
|
maxKeys: 2,
|
|
}, {
|
|
marker: "ca",
|
|
delimiter: "/",
|
|
maxKeys: 2,
|
|
}, {
|
|
objects: []string{"a", "a/xa", "a/xaa", "a/xb", "a/xbb", "a/xc", "aa", "b", "b/ya", "b/yaa", "b/yb", "b/ybb", "b/yc", "bb", "c"},
|
|
}, {
|
|
prefix: "a",
|
|
delimiter: "/",
|
|
objects: []string{"xa", "xaa", "xb", "xbb", "xc"},
|
|
}, {
|
|
prefix: "a/",
|
|
delimiter: "/",
|
|
objects: []string{"xa", "xaa", "xb", "xbb", "xc"},
|
|
}, {
|
|
prefix: "a/",
|
|
marker: "xb",
|
|
delimiter: "/",
|
|
objects: []string{"xbb", "xc"},
|
|
}, {
|
|
marker: "a/xbb",
|
|
maxKeys: 5,
|
|
more: true,
|
|
objects: []string{"a/xc", "aa", "b", "b/ya", "b/yaa"},
|
|
}, {
|
|
prefix: "a/",
|
|
marker: "xaa",
|
|
delimiter: "/",
|
|
maxKeys: 2,
|
|
more: true,
|
|
objects: []string{"xb", "xbb"},
|
|
},
|
|
} {
|
|
errTag := fmt.Sprintf("%d. %+v", i, tt)
|
|
|
|
// Check that the expected objects can be listed using the Minio API
|
|
prefixes, objects, isTruncated, err := listObjects(ctx, layer, TestBucket, tt.prefix, tt.marker, tt.delimiter, tt.maxKeys)
|
|
if assert.NoError(t, err, errTag) {
|
|
assert.Equal(t, tt.more, isTruncated, errTag)
|
|
assert.Equal(t, tt.prefixes, prefixes, errTag)
|
|
assert.Equal(t, len(tt.objects), len(objects), errTag)
|
|
for i, objectInfo := range objects {
|
|
path := objectInfo.Name
|
|
if tt.prefix != "" {
|
|
path = storj.JoinPaths(strings.TrimSuffix(tt.prefix, "/"), path)
|
|
}
|
|
obj := files[path]
|
|
|
|
assert.Equal(t, tt.objects[i], objectInfo.Name, errTag)
|
|
assert.Equal(t, TestBucket, objectInfo.Bucket, errTag)
|
|
assert.False(t, objectInfo.IsDir, errTag)
|
|
assert.Equal(t, obj.Modified, objectInfo.ModTime, errTag)
|
|
assert.Equal(t, obj.Size, objectInfo.Size, errTag)
|
|
assert.Equal(t, hex.EncodeToString(obj.Checksum), objectInfo.ETag, errTag)
|
|
assert.Equal(t, obj.ContentType, objectInfo.ContentType, errTag)
|
|
assert.Equal(t, obj.Metadata, objectInfo.UserDefined, errTag)
|
|
}
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
func runTest(t *testing.T, test func(context.Context, minio.ObjectLayer, storj.Metainfo, streams.Store)) {
|
|
ctx := testcontext.New(t)
|
|
defer ctx.Cleanup()
|
|
|
|
planet, err := testplanet.New(t, 1, 4, 1)
|
|
if !assert.NoError(t, err) {
|
|
return
|
|
}
|
|
|
|
defer ctx.Check(planet.Shutdown)
|
|
|
|
planet.Start(ctx)
|
|
|
|
layer, metainfo, streams, err := initEnv(ctx, planet)
|
|
if !assert.NoError(t, err) {
|
|
return
|
|
}
|
|
|
|
test(ctx, layer, metainfo, streams)
|
|
}
|
|
|
|
func initEnv(ctx context.Context, planet *testplanet.Planet) (minio.ObjectLayer, storj.Metainfo, streams.Store, error) {
|
|
// TODO(kaloyan): We should have a better way for configuring the Satellite's API Key
|
|
// add project to satisfy constraint
|
|
project, err := planet.Satellites[0].DB.Console().Projects().Insert(ctx, &console.Project{
|
|
Name: "testProject",
|
|
})
|
|
|
|
if err != nil {
|
|
return nil, nil, nil, err
|
|
}
|
|
|
|
apiKey := console.APIKey{}
|
|
apiKeyInfo := console.APIKeyInfo{
|
|
ProjectID: project.ID,
|
|
Name: "testKey",
|
|
}
|
|
|
|
// add api key to db
|
|
_, err = planet.Satellites[0].DB.Console().APIKeys().Create(ctx, apiKey, apiKeyInfo)
|
|
if err != nil {
|
|
return nil, nil, nil, err
|
|
}
|
|
|
|
metainfo, err := planet.Uplinks[0].DialMetainfo(ctx, planet.Satellites[0], apiKey.String())
|
|
if err != nil {
|
|
return nil, nil, nil, err
|
|
}
|
|
|
|
ec := ecclient.NewClient(planet.Uplinks[0].Transport, 0)
|
|
fc, err := infectious.NewFEC(2, 4)
|
|
if err != nil {
|
|
return nil, nil, nil, err
|
|
}
|
|
|
|
rs, err := eestream.NewRedundancyStrategy(eestream.NewRSScheme(fc, 1*memory.KiB.Int()), 3, 4)
|
|
if err != nil {
|
|
return nil, nil, nil, err
|
|
}
|
|
|
|
segments := segments.NewSegmentStore(metainfo, ec, rs, 4*memory.KiB.Int(), 8*memory.MiB.Int64())
|
|
|
|
encKey := new(storj.Key)
|
|
copy(encKey[:], TestEncKey)
|
|
|
|
streams, err := streams.NewStreamStore(segments, 64*memory.MiB.Int64(), encKey, 1*memory.KiB.Int(), storj.AESGCM)
|
|
if err != nil {
|
|
return nil, nil, nil, err
|
|
}
|
|
|
|
buckets := buckets.NewStore(streams)
|
|
|
|
kvmetainfo := kvmetainfo.New(metainfo, buckets, streams, segments, encKey, 1*memory.KiB.Int32(), rs, 64*memory.MiB.Int64())
|
|
|
|
cfg := libuplink.Config{}
|
|
cfg.Volatile.TLS = struct {
|
|
SkipPeerCAWhitelist bool
|
|
PeerCAWhitelistPath string
|
|
}{
|
|
SkipPeerCAWhitelist: true,
|
|
}
|
|
cfg.Volatile.UseIdentity = planet.Uplinks[0].Identity
|
|
|
|
uplink, err := libuplink.NewUplink(ctx, &cfg)
|
|
if err != nil {
|
|
return nil, nil, nil, err
|
|
}
|
|
|
|
parsedAPIKey, err := libuplink.ParseAPIKey(apiKey.String())
|
|
if err != nil {
|
|
return nil, nil, nil, err
|
|
}
|
|
|
|
var projectOptions libuplink.ProjectOptions
|
|
projectOptions.Volatile.EncryptionKey = encKey
|
|
proj, err := uplink.OpenProject(ctx, planet.Satellites[0].Addr(), parsedAPIKey, &projectOptions)
|
|
if err != nil {
|
|
return nil, nil, nil, err
|
|
}
|
|
|
|
gateway := NewStorjGateway(
|
|
proj,
|
|
encKey,
|
|
storj.EncAESGCM,
|
|
storj.EncryptionParameters{
|
|
CipherSuite: storj.EncAESGCM,
|
|
BlockSize: 1 * memory.KiB.Int32(),
|
|
},
|
|
storj.RedundancyScheme{
|
|
Algorithm: storj.ReedSolomon,
|
|
RequiredShares: int16(rs.RequiredCount()),
|
|
RepairShares: int16(rs.RepairThreshold()),
|
|
OptimalShares: int16(rs.OptimalThreshold()),
|
|
TotalShares: int16(rs.TotalCount()),
|
|
ShareSize: int32(rs.ErasureShareSize()),
|
|
},
|
|
8*memory.MiB,
|
|
)
|
|
|
|
layer, err := gateway.NewGatewayLayer(auth.Credentials{})
|
|
|
|
return layer, kvmetainfo, streams, err
|
|
}
|
|
|
|
func createFile(ctx context.Context, metainfo storj.Metainfo, streams streams.Store, bucket string, path storj.Path, createInfo *storj.CreateObject, data []byte) (storj.Object, error) {
|
|
mutableObject, err := metainfo.CreateObject(ctx, bucket, path, createInfo)
|
|
if err != nil {
|
|
return storj.Object{}, err
|
|
}
|
|
|
|
err = upload(ctx, streams, mutableObject, bytes.NewReader(data))
|
|
if err != nil {
|
|
return storj.Object{}, err
|
|
}
|
|
|
|
err = mutableObject.Commit(ctx)
|
|
if err != nil {
|
|
return storj.Object{}, err
|
|
}
|
|
|
|
return mutableObject.Info(), nil
|
|
}
|