mirror of
https://github.com/versity/versitygw.git
synced 2026-09-22 07:54:14 +00:00
Stefan Markmann
e05d0df3ed
Since 9bde1ddb (tagging support for CreateBucket) the api layer always
populates CreateBucketConfiguration, so the aws-sdk serializes an empty
<CreateBucketConfiguration/> element on every CreateBucket the s3proxy
backend issues. Strict backends reject that request — Ceph RGW answers
400 InvalidArgument — which breaks bucket creation through the gateway
entirely for those backends. MinIO and SeaweedFS tolerate the empty
element, which is why this went unnoticed.
Drop the configuration before calling the backend when it carries no
content; a bodyless CreateBucket is accepted by all tested backends for
this no-location case. Configurations that carry tags, a location
constraint, or location/bucket info are still forwarded unchanged.
Adds wire-level unit tests via an injected capturing HTTP client:
CreateBucket without tags must send no body (fails before this fix),
and configurations carrying tags, a location constraint, location info
or bucket info must be forwarded. Verified end-to-end against Ceph RGW
(Quincy 17.2.8 and Squid 19.2.0): CreateBucket through the patched
gateway succeeds (200) where it previously failed with 400
InvalidArgument, and the created bucket is usable and deletable.
1934 lines
63 KiB
Go
1934 lines
63 KiB
Go
// Copyright 2023 Versity Software
|
|
// This file is licensed under the Apache License, Version 2.0
|
|
// (the "License"); you may not use this file except in compliance
|
|
// with the License. You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing,
|
|
// software distributed under the License is distributed on an
|
|
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
|
// KIND, either express or implied. See the License for the
|
|
// specific language governing permissions and limitations
|
|
// under the License.
|
|
|
|
package s3proxy
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"strconv"
|
|
"time"
|
|
|
|
"github.com/aws/aws-sdk-go-v2/aws"
|
|
v4 "github.com/aws/aws-sdk-go-v2/aws/signer/v4"
|
|
awshttp "github.com/aws/aws-sdk-go-v2/aws/transport/http"
|
|
"github.com/aws/aws-sdk-go-v2/service/s3"
|
|
"github.com/aws/aws-sdk-go-v2/service/s3/types"
|
|
"github.com/aws/smithy-go"
|
|
"github.com/versity/versitygw/auth"
|
|
"github.com/versity/versitygw/backend"
|
|
"github.com/versity/versitygw/s3err"
|
|
"github.com/versity/versitygw/s3response"
|
|
)
|
|
|
|
type metaPrefix string
|
|
|
|
const (
|
|
metaPrefixAcl metaPrefix = "vgw-meta-acl-"
|
|
metaPrefixPolicy metaPrefix = "vgw-meta-policy-"
|
|
metaPrefixCors metaPrefix = "vgw-meta-cors-"
|
|
metaPrefixWebsite metaPrefix = "vgw-meta-website-"
|
|
)
|
|
|
|
type S3Proxy struct {
|
|
backend.BackendUnsupported
|
|
|
|
client *s3.Client
|
|
|
|
access string
|
|
secret string
|
|
anonymousCredentials bool
|
|
endpoint string
|
|
awsRegion string
|
|
metaBucket string
|
|
disableChecksum bool
|
|
disableDataIntegrityCheck bool
|
|
sslSkipVerify bool
|
|
usePathStyle bool
|
|
debug bool
|
|
gcsCompatibility bool
|
|
}
|
|
|
|
var _ backend.Backend = &S3Proxy{}
|
|
|
|
func NewWithClient(ctx context.Context, client *s3.Client, metaBucket string) (*S3Proxy, error) {
|
|
s := &S3Proxy{
|
|
metaBucket: metaBucket,
|
|
}
|
|
s.client = client
|
|
return s, s.validate(ctx)
|
|
}
|
|
|
|
func New(ctx context.Context, access, secret, endpoint, region, metaBucket string, anonymousCredentials, disableChecksum, disableDataIntegrityCheck, sslSkipVerify, usePathStyle, debug, gcsCompatibility bool) (*S3Proxy, error) {
|
|
s := &S3Proxy{
|
|
access: access,
|
|
secret: secret,
|
|
anonymousCredentials: anonymousCredentials,
|
|
endpoint: endpoint,
|
|
awsRegion: region,
|
|
metaBucket: metaBucket,
|
|
disableChecksum: disableChecksum,
|
|
disableDataIntegrityCheck: disableDataIntegrityCheck,
|
|
sslSkipVerify: sslSkipVerify,
|
|
usePathStyle: usePathStyle,
|
|
debug: debug,
|
|
gcsCompatibility: gcsCompatibility,
|
|
}
|
|
client, err := s.getClientWithCtx(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
s.client = client
|
|
return s, s.validate(ctx)
|
|
}
|
|
|
|
func (s *S3Proxy) validate(ctx context.Context) error {
|
|
if s.metaBucket != "" && !s.bucketExists(ctx, s.metaBucket) {
|
|
return fmt.Errorf("the provided meta bucket doesn't exist")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (s *S3Proxy) ListBuckets(ctx context.Context, input s3response.ListBucketsInput) (s3response.ListAllMyBucketsResult, error) {
|
|
output, err := s.client.ListBuckets(ctx, &s3.ListBucketsInput{
|
|
ContinuationToken: &input.ContinuationToken,
|
|
MaxBuckets: &input.MaxBuckets,
|
|
Prefix: &input.Prefix,
|
|
})
|
|
if err != nil {
|
|
return s3response.ListAllMyBucketsResult{}, handleError(err)
|
|
}
|
|
|
|
var buckets []s3response.ListAllMyBucketsEntry
|
|
for _, b := range output.Buckets {
|
|
if *b.Name == s.metaBucket {
|
|
continue
|
|
}
|
|
if input.IsAdmin || s.metaBucket == "" {
|
|
buckets = append(buckets, s3response.ListAllMyBucketsEntry{
|
|
Name: *b.Name,
|
|
CreationDate: *b.CreationDate,
|
|
})
|
|
continue
|
|
}
|
|
|
|
data, err := s.getMetaBucketObjData(ctx, *b.Name, metaPrefixAcl, false)
|
|
if err != nil {
|
|
return s3response.ListAllMyBucketsResult{}, handleError(err)
|
|
}
|
|
|
|
acl, err := auth.ParseACL(data)
|
|
if err != nil {
|
|
return s3response.ListAllMyBucketsResult{}, err
|
|
}
|
|
|
|
if acl.Owner == input.Owner {
|
|
buckets = append(buckets, s3response.ListAllMyBucketsEntry{
|
|
Name: *b.Name,
|
|
CreationDate: *b.CreationDate,
|
|
})
|
|
}
|
|
}
|
|
|
|
return s3response.ListAllMyBucketsResult{
|
|
Owner: s3response.CanonicalUser{
|
|
ID: *output.Owner.ID,
|
|
},
|
|
Buckets: s3response.ListAllMyBucketsList{
|
|
Bucket: buckets,
|
|
},
|
|
ContinuationToken: backend.GetStringFromPtr(output.ContinuationToken),
|
|
Prefix: backend.GetStringFromPtr(output.Prefix),
|
|
}, nil
|
|
}
|
|
|
|
func (s *S3Proxy) HeadBucket(ctx context.Context, input *s3.HeadBucketInput) (*s3.HeadBucketOutput, error) {
|
|
if input.ExpectedBucketOwner != nil && *input.ExpectedBucketOwner == "" {
|
|
input.ExpectedBucketOwner = nil
|
|
}
|
|
out, err := s.client.HeadBucket(ctx, input)
|
|
return out, handleError(err)
|
|
}
|
|
|
|
func (s *S3Proxy) CreateBucket(ctx context.Context, input *s3.CreateBucketInput, acl []byte) error {
|
|
if input.GrantFullControl != nil && *input.GrantFullControl == "" {
|
|
input.GrantFullControl = nil
|
|
}
|
|
if input.GrantRead != nil && *input.GrantRead == "" {
|
|
input.GrantRead = nil
|
|
}
|
|
if input.GrantReadACP != nil && *input.GrantReadACP == "" {
|
|
input.GrantReadACP = nil
|
|
}
|
|
if input.GrantWrite != nil && *input.GrantWrite == "" {
|
|
input.GrantWrite = nil
|
|
}
|
|
if input.GrantWriteACP != nil && *input.GrantWriteACP == "" {
|
|
input.GrantWriteACP = nil
|
|
}
|
|
if *input.Bucket == s.metaBucket {
|
|
return s3err.GetBucketErr(s3err.ErrBucketAlreadyExists, *input.Bucket)
|
|
}
|
|
|
|
acct, ok := ctx.Value("account").(auth.Account)
|
|
if !ok {
|
|
acct = auth.Account{}
|
|
}
|
|
|
|
if s.metaBucket != "" {
|
|
data, err := s.getMetaBucketObjData(ctx, *input.Bucket, metaPrefixAcl, true)
|
|
if err == nil {
|
|
acl, err := auth.ParseACL(data)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if acl.Owner == acct.Access {
|
|
return s3err.GetBucketErr(s3err.ErrBucketAlreadyOwnedByYou, *input.Bucket)
|
|
}
|
|
return s3err.GetBucketErr(s3err.ErrBucketAlreadyExists, *input.Bucket)
|
|
}
|
|
}
|
|
|
|
// drop an empty CreateBucketConfiguration: strict backends (Ceph RGW) reject the empty element
|
|
if input.CreateBucketConfiguration != nil &&
|
|
len(input.CreateBucketConfiguration.Tags) == 0 &&
|
|
input.CreateBucketConfiguration.LocationConstraint == "" &&
|
|
input.CreateBucketConfiguration.Location == nil &&
|
|
input.CreateBucketConfiguration.Bucket == nil {
|
|
input.CreateBucketConfiguration = nil
|
|
}
|
|
|
|
_, err := s.client.CreateBucket(ctx, input)
|
|
if err != nil {
|
|
return handleError(err)
|
|
}
|
|
|
|
// Store bucket default acl
|
|
if s.metaBucket != "" {
|
|
err = s.putMetaBucketObj(ctx, *input.Bucket, acl, metaPrefixAcl)
|
|
if err != nil {
|
|
// attempt to cleanup
|
|
_ = s.DeleteBucket(ctx, *input.Bucket)
|
|
return handleError(err)
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (s *S3Proxy) DeleteBucket(ctx context.Context, bucket string) error {
|
|
if bucket == s.metaBucket {
|
|
return s3err.GetAPIError(s3err.ErrAccessDenied)
|
|
}
|
|
_, err := s.client.DeleteBucket(ctx, &s3.DeleteBucketInput{
|
|
Bucket: &bucket,
|
|
})
|
|
return handleError(err)
|
|
}
|
|
|
|
func (s *S3Proxy) PutBucketOwnershipControls(ctx context.Context, bucket string, ownership types.ObjectOwnership) error {
|
|
if bucket == s.metaBucket {
|
|
return s3err.GetAPIError(s3err.ErrAccessDenied)
|
|
}
|
|
_, err := s.client.PutBucketOwnershipControls(ctx, &s3.PutBucketOwnershipControlsInput{
|
|
Bucket: &bucket,
|
|
OwnershipControls: &types.OwnershipControls{
|
|
Rules: []types.OwnershipControlsRule{
|
|
{
|
|
ObjectOwnership: ownership,
|
|
},
|
|
},
|
|
},
|
|
})
|
|
return handleError(err)
|
|
}
|
|
|
|
func (s *S3Proxy) GetBucketOwnershipControls(ctx context.Context, bucket string) (types.ObjectOwnership, error) {
|
|
if bucket == s.metaBucket {
|
|
return "", s3err.GetAPIError(s3err.ErrAccessDenied)
|
|
}
|
|
var ownship types.ObjectOwnership
|
|
resp, err := s.client.GetBucketOwnershipControls(ctx, &s3.GetBucketOwnershipControlsInput{
|
|
Bucket: &bucket,
|
|
})
|
|
if err != nil {
|
|
return ownship, handleError(err)
|
|
}
|
|
if resp.OwnershipControls == nil || len(resp.OwnershipControls.Rules) == 0 {
|
|
return ownship, s3err.GetBucketErr(s3err.ErrOwnershipControlsNotFound, bucket)
|
|
}
|
|
return resp.OwnershipControls.Rules[0].ObjectOwnership, nil
|
|
}
|
|
func (s *S3Proxy) DeleteBucketOwnershipControls(ctx context.Context, bucket string) error {
|
|
if bucket == s.metaBucket {
|
|
return s3err.GetAPIError(s3err.ErrAccessDenied)
|
|
}
|
|
_, err := s.client.DeleteBucketOwnershipControls(ctx, &s3.DeleteBucketOwnershipControlsInput{
|
|
Bucket: &bucket,
|
|
})
|
|
return handleError(err)
|
|
}
|
|
|
|
func (s *S3Proxy) PutBucketVersioning(ctx context.Context, bucket string, status types.BucketVersioningStatus) error {
|
|
if bucket == s.metaBucket {
|
|
return s3err.GetAPIError(s3err.ErrAccessDenied)
|
|
}
|
|
_, err := s.client.PutBucketVersioning(ctx, &s3.PutBucketVersioningInput{
|
|
Bucket: &bucket,
|
|
VersioningConfiguration: &types.VersioningConfiguration{
|
|
Status: status,
|
|
},
|
|
})
|
|
|
|
return handleError(err)
|
|
}
|
|
|
|
func (s *S3Proxy) GetBucketVersioning(ctx context.Context, bucket string) (s3response.GetBucketVersioningOutput, error) {
|
|
if bucket == s.metaBucket {
|
|
return s3response.GetBucketVersioningOutput{}, s3err.GetAPIError(s3err.ErrAccessDenied)
|
|
}
|
|
out, err := s.client.GetBucketVersioning(ctx, &s3.GetBucketVersioningInput{
|
|
Bucket: &bucket,
|
|
})
|
|
if err != nil {
|
|
return s3response.GetBucketVersioningOutput{}, handleError(err)
|
|
}
|
|
|
|
return s3response.GetBucketVersioningOutput{
|
|
Status: &out.Status,
|
|
MFADelete: &out.MFADelete,
|
|
}, nil
|
|
}
|
|
|
|
func (s *S3Proxy) ListObjectVersions(ctx context.Context, input *s3.ListObjectVersionsInput) (s3response.ListVersionsResult, error) {
|
|
if *input.Bucket == s.metaBucket {
|
|
return s3response.ListVersionsResult{}, s3err.GetAPIError(s3err.ErrAccessDenied)
|
|
}
|
|
if input.Delimiter != nil && *input.Delimiter == "" {
|
|
input.Delimiter = nil
|
|
}
|
|
if input.Prefix != nil && *input.Prefix == "" {
|
|
input.Prefix = nil
|
|
}
|
|
if input.KeyMarker != nil && *input.KeyMarker == "" {
|
|
input.KeyMarker = nil
|
|
}
|
|
if input.VersionIdMarker != nil && *input.VersionIdMarker == "" {
|
|
input.VersionIdMarker = nil
|
|
}
|
|
if input.MaxKeys != nil && *input.MaxKeys == 0 {
|
|
input.MaxKeys = nil
|
|
}
|
|
if input.ExpectedBucketOwner != nil && *input.ExpectedBucketOwner == "" {
|
|
input.ExpectedBucketOwner = nil
|
|
}
|
|
|
|
out, err := s.client.ListObjectVersions(ctx, input)
|
|
if err != nil {
|
|
return s3response.ListVersionsResult{}, handleError(err)
|
|
}
|
|
|
|
return s3response.ListVersionsResult{
|
|
CommonPrefixes: out.CommonPrefixes,
|
|
DeleteMarkers: out.DeleteMarkers,
|
|
Delimiter: out.Delimiter,
|
|
EncodingType: out.EncodingType,
|
|
IsTruncated: out.IsTruncated,
|
|
KeyMarker: out.KeyMarker,
|
|
MaxKeys: out.MaxKeys,
|
|
Name: out.Name,
|
|
NextKeyMarker: out.NextKeyMarker,
|
|
NextVersionIdMarker: out.NextVersionIdMarker,
|
|
Prefix: out.Prefix,
|
|
VersionIdMarker: input.VersionIdMarker,
|
|
Versions: convertObjectVersions(out.Versions),
|
|
}, nil
|
|
}
|
|
|
|
var defTime = time.Time{}
|
|
|
|
func (s *S3Proxy) CreateMultipartUpload(ctx context.Context, input s3response.CreateMultipartUploadInput) (s3response.InitiateMultipartUploadResult, error) {
|
|
if *input.Bucket == s.metaBucket {
|
|
return s3response.InitiateMultipartUploadResult{}, s3err.GetAPIError(s3err.ErrAccessDenied)
|
|
}
|
|
if input.CacheControl != nil && *input.CacheControl == "" {
|
|
input.CacheControl = nil
|
|
}
|
|
if input.ContentDisposition != nil && *input.ContentDisposition == "" {
|
|
input.ContentDisposition = nil
|
|
}
|
|
if input.ContentEncoding != nil && *input.ContentEncoding == "" {
|
|
input.ContentEncoding = nil
|
|
}
|
|
if input.ContentLanguage != nil && *input.ContentLanguage == "" {
|
|
input.ContentLanguage = nil
|
|
}
|
|
if input.ContentType != nil && *input.ContentType == "" {
|
|
input.ContentType = nil
|
|
}
|
|
if input.Expires != nil && *input.Expires == "" {
|
|
input.Expires = nil
|
|
}
|
|
if input.GrantFullControl != nil && *input.GrantFullControl == "" {
|
|
input.GrantFullControl = nil
|
|
}
|
|
if input.GrantRead != nil && *input.GrantRead == "" {
|
|
input.GrantRead = nil
|
|
}
|
|
if input.GrantReadACP != nil && *input.GrantReadACP == "" {
|
|
input.GrantReadACP = nil
|
|
}
|
|
if input.GrantWriteACP != nil && *input.GrantWriteACP == "" {
|
|
input.GrantWriteACP = nil
|
|
}
|
|
if input.ExpectedBucketOwner != nil && *input.ExpectedBucketOwner == "" {
|
|
input.ExpectedBucketOwner = nil
|
|
}
|
|
if input.ObjectLockRetainUntilDate != nil && (*input.ObjectLockRetainUntilDate).Equal(defTime) {
|
|
input.ObjectLockRetainUntilDate = nil
|
|
}
|
|
if input.SSECustomerAlgorithm != nil && *input.SSECustomerAlgorithm == "" {
|
|
input.SSECustomerAlgorithm = nil
|
|
}
|
|
if input.SSECustomerKey != nil && *input.SSECustomerKey == "" {
|
|
input.SSECustomerKey = nil
|
|
}
|
|
if input.SSECustomerKeyMD5 != nil && *input.SSECustomerKeyMD5 == "" {
|
|
input.SSECustomerKeyMD5 = nil
|
|
}
|
|
if input.SSEKMSKeyId != nil && *input.SSEKMSKeyId == "" {
|
|
input.SSEKMSKeyId = nil
|
|
}
|
|
if input.SSEKMSEncryptionContext != nil && *input.SSEKMSEncryptionContext == "" {
|
|
input.SSEKMSEncryptionContext = nil
|
|
}
|
|
if input.Tagging != nil && *input.Tagging == "" {
|
|
input.Tagging = nil
|
|
}
|
|
if input.WebsiteRedirectLocation != nil && *input.WebsiteRedirectLocation == "" {
|
|
input.WebsiteRedirectLocation = nil
|
|
}
|
|
|
|
var expires *time.Time
|
|
if input.Expires != nil {
|
|
exp, err := time.Parse(time.RFC1123, *input.Expires)
|
|
if err == nil {
|
|
expires = &exp
|
|
}
|
|
}
|
|
|
|
out, err := s.client.CreateMultipartUpload(ctx, &s3.CreateMultipartUploadInput{
|
|
Bucket: input.Bucket,
|
|
Key: input.Key,
|
|
ExpectedBucketOwner: input.ExpectedBucketOwner,
|
|
CacheControl: input.CacheControl,
|
|
ContentDisposition: input.ContentDisposition,
|
|
ContentEncoding: input.ContentEncoding,
|
|
ContentLanguage: input.ContentLanguage,
|
|
ContentType: input.ContentType,
|
|
Expires: expires,
|
|
SSECustomerAlgorithm: input.SSECustomerAlgorithm,
|
|
SSECustomerKey: input.SSECustomerKey,
|
|
SSECustomerKeyMD5: input.SSECustomerKeyMD5,
|
|
SSEKMSEncryptionContext: input.SSEKMSEncryptionContext,
|
|
SSEKMSKeyId: input.SSEKMSKeyId,
|
|
GrantFullControl: input.GrantFullControl,
|
|
GrantRead: input.GrantRead,
|
|
GrantReadACP: input.GrantReadACP,
|
|
GrantWriteACP: input.GrantWriteACP,
|
|
Tagging: input.Tagging,
|
|
WebsiteRedirectLocation: input.WebsiteRedirectLocation,
|
|
BucketKeyEnabled: input.BucketKeyEnabled,
|
|
ObjectLockRetainUntilDate: input.ObjectLockRetainUntilDate,
|
|
Metadata: input.Metadata,
|
|
ACL: input.ACL,
|
|
ChecksumAlgorithm: input.ChecksumAlgorithm,
|
|
ChecksumType: input.ChecksumType,
|
|
ObjectLockLegalHoldStatus: input.ObjectLockLegalHoldStatus,
|
|
ObjectLockMode: input.ObjectLockMode,
|
|
RequestPayer: input.RequestPayer,
|
|
ServerSideEncryption: input.ServerSideEncryption,
|
|
StorageClass: input.StorageClass,
|
|
})
|
|
if err != nil {
|
|
return s3response.InitiateMultipartUploadResult{}, handleError(err)
|
|
}
|
|
|
|
return s3response.InitiateMultipartUploadResult{
|
|
Bucket: *out.Bucket,
|
|
Key: *out.Key,
|
|
UploadId: *out.UploadId,
|
|
}, nil
|
|
}
|
|
|
|
func (s *S3Proxy) CompleteMultipartUpload(ctx context.Context, input *s3.CompleteMultipartUploadInput) (s3response.CompleteMultipartUploadResult, string, error) {
|
|
var res s3response.CompleteMultipartUploadResult
|
|
|
|
if *input.Bucket == s.metaBucket {
|
|
return res, "", s3err.GetAPIError(s3err.ErrAccessDenied)
|
|
}
|
|
if input.ChecksumCRC32 != nil && *input.ChecksumCRC32 == "" {
|
|
input.ChecksumCRC32 = nil
|
|
}
|
|
if input.ChecksumCRC32C != nil && *input.ChecksumCRC32C == "" {
|
|
input.ChecksumCRC32C = nil
|
|
}
|
|
if input.ChecksumCRC64NVME != nil && *input.ChecksumCRC64NVME == "" {
|
|
input.ChecksumCRC64NVME = nil
|
|
}
|
|
if input.ChecksumSHA1 != nil && *input.ChecksumSHA1 == "" {
|
|
input.ChecksumSHA1 = nil
|
|
}
|
|
if input.ChecksumSHA256 != nil && *input.ChecksumSHA256 == "" {
|
|
input.ChecksumSHA256 = nil
|
|
}
|
|
if input.ChecksumSHA512 != nil && *input.ChecksumSHA512 == "" {
|
|
input.ChecksumSHA512 = nil
|
|
}
|
|
if input.ChecksumMD5 != nil && *input.ChecksumMD5 == "" {
|
|
input.ChecksumMD5 = nil
|
|
}
|
|
if input.ChecksumXXHASH64 != nil && *input.ChecksumXXHASH64 == "" {
|
|
input.ChecksumXXHASH64 = nil
|
|
}
|
|
if input.ChecksumXXHASH3 != nil && *input.ChecksumXXHASH3 == "" {
|
|
input.ChecksumXXHASH3 = nil
|
|
}
|
|
if input.ChecksumXXHASH128 != nil && *input.ChecksumXXHASH128 == "" {
|
|
input.ChecksumXXHASH128 = nil
|
|
}
|
|
if input.ExpectedBucketOwner != nil && *input.ExpectedBucketOwner == "" {
|
|
input.ExpectedBucketOwner = nil
|
|
}
|
|
if input.IfMatch != nil && *input.IfMatch == "" {
|
|
input.IfMatch = nil
|
|
}
|
|
if input.IfNoneMatch != nil && *input.IfNoneMatch == "" {
|
|
input.IfNoneMatch = nil
|
|
}
|
|
if input.MpuObjectSize != nil && *input.MpuObjectSize == 0 {
|
|
input.MpuObjectSize = nil
|
|
}
|
|
if input.SSECustomerAlgorithm != nil && *input.SSECustomerAlgorithm == "" {
|
|
input.SSECustomerAlgorithm = nil
|
|
}
|
|
if input.SSECustomerKey != nil && *input.SSECustomerKey == "" {
|
|
input.SSECustomerKey = nil
|
|
}
|
|
if input.SSECustomerKeyMD5 != nil && *input.SSECustomerKeyMD5 == "" {
|
|
input.SSECustomerKeyMD5 = nil
|
|
}
|
|
|
|
var versionid string
|
|
out, err := s.client.CompleteMultipartUpload(ctx, input)
|
|
if out != nil {
|
|
res = s3response.CompleteMultipartUploadResult{
|
|
Location: out.Location,
|
|
Bucket: out.Bucket,
|
|
Key: out.Key,
|
|
ETag: out.ETag,
|
|
ChecksumCRC32: out.ChecksumCRC32,
|
|
ChecksumCRC32C: out.ChecksumCRC32C,
|
|
ChecksumCRC64NVME: out.ChecksumCRC64NVME,
|
|
ChecksumSHA1: out.ChecksumSHA1,
|
|
ChecksumSHA256: out.ChecksumSHA256,
|
|
ChecksumSHA512: out.ChecksumSHA512,
|
|
ChecksumMD5: out.ChecksumMD5,
|
|
ChecksumXXHASH64: out.ChecksumXXHASH64,
|
|
ChecksumXXHASH3: out.ChecksumXXHASH3,
|
|
ChecksumXXHASH128: out.ChecksumXXHASH128,
|
|
ChecksumType: &out.ChecksumType,
|
|
}
|
|
if out.VersionId != nil {
|
|
versionid = *out.VersionId
|
|
}
|
|
}
|
|
|
|
return res, versionid, handleError(err)
|
|
}
|
|
|
|
func (s *S3Proxy) AbortMultipartUpload(ctx context.Context, input *s3.AbortMultipartUploadInput) error {
|
|
if *input.Bucket == s.metaBucket {
|
|
return s3err.GetAPIError(s3err.ErrAccessDenied)
|
|
}
|
|
if input.ExpectedBucketOwner != nil && *input.ExpectedBucketOwner == "" {
|
|
input.ExpectedBucketOwner = nil
|
|
}
|
|
if input.IfMatchInitiatedTime != nil && (*input.IfMatchInitiatedTime).Equal(defTime) {
|
|
input.IfMatchInitiatedTime = nil
|
|
}
|
|
_, err := s.client.AbortMultipartUpload(ctx, input)
|
|
return handleError(err)
|
|
}
|
|
|
|
// s3ProxyOwner nil-safely converts an SDK owner pointer to s3response.Owner.
|
|
// The real S3 response omits this element entirely in some cases (e.g. cross-
|
|
// account or directory bucket responses), leaving it nil.
|
|
func s3ProxyOwner(o *types.Owner) s3response.Owner {
|
|
if o == nil {
|
|
return s3response.Owner{}
|
|
}
|
|
return s3response.Owner{
|
|
ID: aws.ToString(o.ID),
|
|
DisplayName: aws.ToString(o.DisplayName),
|
|
}
|
|
}
|
|
|
|
// s3ProxyInitiator nil-safely converts an SDK initiator pointer to s3response.Owner
|
|
// (s3response.Initiator is a type alias of s3response.Owner).
|
|
func s3ProxyInitiator(i *types.Initiator) s3response.Owner {
|
|
if i == nil {
|
|
return s3response.Owner{}
|
|
}
|
|
return s3response.Owner{
|
|
ID: aws.ToString(i.ID),
|
|
DisplayName: aws.ToString(i.DisplayName),
|
|
}
|
|
}
|
|
|
|
func (s *S3Proxy) ListMultipartUploads(ctx context.Context, input *s3.ListMultipartUploadsInput) (s3response.ListMultipartUploadsResult, error) {
|
|
if *input.Bucket == s.metaBucket {
|
|
return s3response.ListMultipartUploadsResult{}, s3err.GetAPIError(s3err.ErrAccessDenied)
|
|
}
|
|
if input.Delimiter != nil && *input.Delimiter == "" {
|
|
input.Delimiter = nil
|
|
}
|
|
if input.ExpectedBucketOwner != nil && *input.ExpectedBucketOwner == "" {
|
|
input.ExpectedBucketOwner = nil
|
|
}
|
|
if input.KeyMarker != nil && *input.KeyMarker == "" {
|
|
input.KeyMarker = nil
|
|
}
|
|
if input.MaxUploads != nil && *input.MaxUploads == 0 {
|
|
input.MaxUploads = nil
|
|
}
|
|
if input.Prefix != nil && *input.Prefix == "" {
|
|
input.Prefix = nil
|
|
}
|
|
if input.UploadIdMarker != nil && *input.UploadIdMarker == "" {
|
|
input.UploadIdMarker = nil
|
|
}
|
|
|
|
output, err := s.client.ListMultipartUploads(ctx, input)
|
|
if err != nil {
|
|
return s3response.ListMultipartUploadsResult{}, handleError(err)
|
|
}
|
|
|
|
var uploads []s3response.Upload
|
|
for _, u := range output.Uploads {
|
|
uploads = append(uploads, s3response.Upload{
|
|
Key: aws.ToString(u.Key),
|
|
UploadID: aws.ToString(u.UploadId),
|
|
Initiator: s3response.Initiator(s3ProxyInitiator(u.Initiator)),
|
|
Owner: s3ProxyOwner(u.Owner),
|
|
StorageClass: u.StorageClass,
|
|
Initiated: aws.ToTime(u.Initiated),
|
|
ChecksumAlgorithm: u.ChecksumAlgorithm,
|
|
ChecksumType: u.ChecksumType,
|
|
})
|
|
}
|
|
|
|
var cps []s3response.CommonPrefix
|
|
for _, c := range output.CommonPrefixes {
|
|
cps = append(cps, s3response.CommonPrefix{
|
|
Prefix: aws.ToString(c.Prefix),
|
|
})
|
|
}
|
|
|
|
return s3response.ListMultipartUploadsResult{
|
|
Bucket: aws.ToString(output.Bucket),
|
|
KeyMarker: aws.ToString(output.KeyMarker),
|
|
UploadIDMarker: aws.ToString(output.UploadIdMarker),
|
|
NextKeyMarker: aws.ToString(output.NextKeyMarker),
|
|
NextUploadIDMarker: aws.ToString(output.NextUploadIdMarker),
|
|
Delimiter: aws.ToString(output.Delimiter),
|
|
Prefix: aws.ToString(output.Prefix),
|
|
EncodingType: string(output.EncodingType),
|
|
MaxUploads: int(aws.ToInt32(output.MaxUploads)),
|
|
IsTruncated: aws.ToBool(output.IsTruncated),
|
|
Uploads: uploads,
|
|
CommonPrefixes: cps,
|
|
}, nil
|
|
}
|
|
|
|
func (s *S3Proxy) ListParts(ctx context.Context, input *s3.ListPartsInput) (s3response.ListPartsResult, error) {
|
|
if *input.Bucket == s.metaBucket {
|
|
return s3response.ListPartsResult{}, s3err.GetAPIError(s3err.ErrAccessDenied)
|
|
}
|
|
if input.ExpectedBucketOwner != nil && *input.ExpectedBucketOwner == "" {
|
|
input.ExpectedBucketOwner = nil
|
|
}
|
|
if input.MaxParts != nil && *input.MaxParts == 0 {
|
|
input.MaxParts = nil
|
|
}
|
|
if input.PartNumberMarker != nil && *input.PartNumberMarker == "" {
|
|
input.PartNumberMarker = nil
|
|
}
|
|
if input.SSECustomerAlgorithm != nil && *input.SSECustomerAlgorithm == "" {
|
|
input.SSECustomerAlgorithm = nil
|
|
}
|
|
if input.SSECustomerKey != nil && *input.SSECustomerKey == "" {
|
|
input.SSECustomerKey = nil
|
|
}
|
|
if input.SSECustomerKeyMD5 != nil && *input.SSECustomerKeyMD5 == "" {
|
|
input.SSECustomerKeyMD5 = nil
|
|
}
|
|
|
|
output, err := s.client.ListParts(ctx, input)
|
|
if err != nil {
|
|
return s3response.ListPartsResult{}, handleError(err)
|
|
}
|
|
|
|
var parts []s3response.Part
|
|
for _, p := range output.Parts {
|
|
parts = append(parts, s3response.Part{
|
|
PartNumber: int(aws.ToInt32(p.PartNumber)),
|
|
LastModified: aws.ToTime(p.LastModified),
|
|
ETag: aws.ToString(p.ETag),
|
|
Size: aws.ToInt64(p.Size),
|
|
ChecksumCRC32: p.ChecksumCRC32,
|
|
ChecksumCRC32C: p.ChecksumCRC32C,
|
|
ChecksumCRC64NVME: p.ChecksumCRC64NVME,
|
|
ChecksumSHA1: p.ChecksumSHA1,
|
|
ChecksumSHA256: p.ChecksumSHA256,
|
|
ChecksumSHA512: p.ChecksumSHA512,
|
|
ChecksumMD5: p.ChecksumMD5,
|
|
ChecksumXXHASH64: p.ChecksumXXHASH64,
|
|
ChecksumXXHASH3: p.ChecksumXXHASH3,
|
|
ChecksumXXHASH128: p.ChecksumXXHASH128,
|
|
})
|
|
}
|
|
|
|
// PartNumberMarker/NextPartNumberMarker are absent from the response
|
|
// whenever no part-number-marker was requested, or the list isn't
|
|
// truncated, respectively - in both cases there's no marker value to
|
|
// parse, so default to 0 (the same meaning as "no marker").
|
|
var pnm int
|
|
if output.PartNumberMarker != nil {
|
|
pnm, err = strconv.Atoi(*output.PartNumberMarker)
|
|
if err != nil {
|
|
return s3response.ListPartsResult{},
|
|
fmt.Errorf("parse part number marker: %w", err)
|
|
}
|
|
}
|
|
|
|
var npmn int
|
|
if output.NextPartNumberMarker != nil {
|
|
npmn, err = strconv.Atoi(*output.NextPartNumberMarker)
|
|
if err != nil {
|
|
return s3response.ListPartsResult{},
|
|
fmt.Errorf("parse next part number marker: %w", err)
|
|
}
|
|
}
|
|
|
|
return s3response.ListPartsResult{
|
|
Bucket: aws.ToString(output.Bucket),
|
|
Key: aws.ToString(output.Key),
|
|
UploadID: aws.ToString(output.UploadId),
|
|
Initiator: s3response.Initiator(s3ProxyInitiator(output.Initiator)),
|
|
Owner: s3ProxyOwner(output.Owner),
|
|
StorageClass: output.StorageClass,
|
|
PartNumberMarker: pnm,
|
|
NextPartNumberMarker: npmn,
|
|
MaxParts: int(aws.ToInt32(output.MaxParts)),
|
|
IsTruncated: aws.ToBool(output.IsTruncated),
|
|
Parts: parts,
|
|
ChecksumAlgorithm: output.ChecksumAlgorithm,
|
|
ChecksumType: output.ChecksumType,
|
|
}, nil
|
|
}
|
|
|
|
func (s *S3Proxy) UploadPart(ctx context.Context, input *s3.UploadPartInput) (*s3.UploadPartOutput, error) {
|
|
if *input.Bucket == s.metaBucket {
|
|
return nil, s3err.GetAPIError(s3err.ErrAccessDenied)
|
|
}
|
|
if input.ChecksumCRC32 != nil && *input.ChecksumCRC32 == "" {
|
|
input.ChecksumCRC32 = nil
|
|
}
|
|
if input.ChecksumCRC32C != nil && *input.ChecksumCRC32C == "" {
|
|
input.ChecksumCRC32C = nil
|
|
}
|
|
if input.ChecksumCRC64NVME != nil && *input.ChecksumCRC64NVME == "" {
|
|
input.ChecksumCRC64NVME = nil
|
|
}
|
|
if input.ChecksumSHA1 != nil && *input.ChecksumSHA1 == "" {
|
|
input.ChecksumSHA1 = nil
|
|
}
|
|
if input.ChecksumSHA256 != nil && *input.ChecksumSHA256 == "" {
|
|
input.ChecksumSHA256 = nil
|
|
}
|
|
if input.ChecksumSHA512 != nil && *input.ChecksumSHA512 == "" {
|
|
input.ChecksumSHA512 = nil
|
|
}
|
|
if input.ChecksumMD5 != nil && *input.ChecksumMD5 == "" {
|
|
input.ChecksumMD5 = nil
|
|
}
|
|
if input.ChecksumXXHASH64 != nil && *input.ChecksumXXHASH64 == "" {
|
|
input.ChecksumXXHASH64 = nil
|
|
}
|
|
if input.ChecksumXXHASH3 != nil && *input.ChecksumXXHASH3 == "" {
|
|
input.ChecksumXXHASH3 = nil
|
|
}
|
|
if input.ChecksumXXHASH128 != nil && *input.ChecksumXXHASH128 == "" {
|
|
input.ChecksumXXHASH128 = nil
|
|
}
|
|
if input.ContentMD5 != nil && *input.ContentMD5 == "" {
|
|
input.ContentMD5 = nil
|
|
}
|
|
if input.ExpectedBucketOwner != nil && *input.ExpectedBucketOwner == "" {
|
|
input.ExpectedBucketOwner = nil
|
|
}
|
|
if input.SSECustomerAlgorithm != nil && *input.SSECustomerAlgorithm == "" {
|
|
input.SSECustomerAlgorithm = nil
|
|
}
|
|
if input.SSECustomerKey != nil && *input.SSECustomerKey == "" {
|
|
input.SSECustomerKey = nil
|
|
}
|
|
if input.SSECustomerKeyMD5 != nil && *input.SSECustomerKeyMD5 == "" {
|
|
input.SSECustomerKeyMD5 = nil
|
|
}
|
|
|
|
// streaming backend is not seekable,
|
|
// use unsigned payload for streaming ops
|
|
output, err := s.client.UploadPart(ctx, input, s3.WithAPIOptions(
|
|
v4.SwapComputePayloadSHA256ForUnsignedPayloadMiddleware,
|
|
))
|
|
return output, handleError(err)
|
|
}
|
|
|
|
func (s *S3Proxy) UploadPartCopy(ctx context.Context, input *s3.UploadPartCopyInput) (s3response.CopyPartResult, error) {
|
|
if *input.Bucket == s.metaBucket {
|
|
return s3response.CopyPartResult{}, s3err.GetAPIError(s3err.ErrAccessDenied)
|
|
}
|
|
if input.CopySourceIfMatch != nil && *input.CopySourceIfMatch == "" {
|
|
input.CopySourceIfMatch = nil
|
|
}
|
|
if input.CopySourceIfModifiedSince != nil && (*input.CopySourceIfModifiedSince).Equal(defTime) {
|
|
input.CopySourceIfModifiedSince = nil
|
|
}
|
|
if input.CopySourceIfNoneMatch != nil && *input.CopySourceIfNoneMatch == "" {
|
|
input.CopySourceIfNoneMatch = nil
|
|
}
|
|
if input.CopySourceIfUnmodifiedSince != nil && (*input.CopySourceIfUnmodifiedSince).Equal(defTime) {
|
|
input.CopySourceIfUnmodifiedSince = nil
|
|
}
|
|
if input.CopySourceRange != nil && *input.CopySourceRange == "" {
|
|
input.CopySourceRange = nil
|
|
}
|
|
if input.CopySourceSSECustomerAlgorithm != nil && *input.CopySourceSSECustomerAlgorithm == "" {
|
|
input.CopySourceSSECustomerAlgorithm = nil
|
|
}
|
|
if input.CopySourceSSECustomerKey != nil && *input.CopySourceSSECustomerKey == "" {
|
|
input.CopySourceSSECustomerKey = nil
|
|
}
|
|
if input.CopySourceSSECustomerKeyMD5 != nil && *input.CopySourceSSECustomerKeyMD5 == "" {
|
|
input.CopySourceSSECustomerKeyMD5 = nil
|
|
}
|
|
if input.ExpectedBucketOwner != nil && *input.ExpectedBucketOwner == "" {
|
|
input.ExpectedBucketOwner = nil
|
|
}
|
|
if input.ExpectedSourceBucketOwner != nil && *input.ExpectedSourceBucketOwner == "" {
|
|
input.ExpectedSourceBucketOwner = nil
|
|
}
|
|
if input.SSECustomerAlgorithm != nil && *input.SSECustomerAlgorithm == "" {
|
|
input.SSECustomerAlgorithm = nil
|
|
}
|
|
if input.SSECustomerKey != nil && *input.SSECustomerKey == "" {
|
|
input.SSECustomerKey = nil
|
|
}
|
|
if input.SSECustomerKeyMD5 != nil && *input.SSECustomerKeyMD5 == "" {
|
|
input.SSECustomerKeyMD5 = nil
|
|
}
|
|
|
|
output, err := s.client.UploadPartCopy(ctx, input)
|
|
if err != nil {
|
|
return s3response.CopyPartResult{}, handleError(err)
|
|
}
|
|
|
|
return s3response.CopyPartResult{
|
|
LastModified: *output.CopyPartResult.LastModified,
|
|
ETag: output.CopyPartResult.ETag,
|
|
ChecksumCRC32: output.CopyPartResult.ChecksumCRC32,
|
|
ChecksumCRC32C: output.CopyPartResult.ChecksumCRC32C,
|
|
ChecksumCRC64NVME: output.CopyPartResult.ChecksumCRC64NVME,
|
|
ChecksumSHA1: output.CopyPartResult.ChecksumSHA1,
|
|
ChecksumSHA256: output.CopyPartResult.ChecksumSHA256,
|
|
ChecksumSHA512: output.CopyPartResult.ChecksumSHA512,
|
|
ChecksumMD5: output.CopyPartResult.ChecksumMD5,
|
|
ChecksumXXHASH64: output.CopyPartResult.ChecksumXXHASH64,
|
|
ChecksumXXHASH3: output.CopyPartResult.ChecksumXXHASH3,
|
|
ChecksumXXHASH128: output.CopyPartResult.ChecksumXXHASH128,
|
|
}, nil
|
|
}
|
|
|
|
func (s *S3Proxy) PutObject(ctx context.Context, input s3response.PutObjectInput) (s3response.PutObjectOutput, error) {
|
|
if *input.Bucket == s.metaBucket {
|
|
return s3response.PutObjectOutput{}, s3err.GetAPIError(s3err.ErrAccessDenied)
|
|
}
|
|
if input.CacheControl != nil && *input.CacheControl == "" {
|
|
input.CacheControl = nil
|
|
}
|
|
if input.ChecksumCRC32 != nil && *input.ChecksumCRC32 == "" {
|
|
input.ChecksumCRC32 = nil
|
|
}
|
|
if input.ChecksumCRC32C != nil && *input.ChecksumCRC32C == "" {
|
|
input.ChecksumCRC32C = nil
|
|
}
|
|
if input.ChecksumCRC64NVME != nil && *input.ChecksumCRC64NVME == "" {
|
|
input.ChecksumCRC64NVME = nil
|
|
}
|
|
if input.ChecksumSHA1 != nil && *input.ChecksumSHA1 == "" {
|
|
input.ChecksumSHA1 = nil
|
|
}
|
|
if input.ChecksumSHA256 != nil && *input.ChecksumSHA256 == "" {
|
|
input.ChecksumSHA256 = nil
|
|
}
|
|
if input.ChecksumSHA512 != nil && *input.ChecksumSHA512 == "" {
|
|
input.ChecksumSHA512 = nil
|
|
}
|
|
if input.ChecksumMD5 != nil && *input.ChecksumMD5 == "" {
|
|
input.ChecksumMD5 = nil
|
|
}
|
|
if input.ChecksumXXHASH64 != nil && *input.ChecksumXXHASH64 == "" {
|
|
input.ChecksumXXHASH64 = nil
|
|
}
|
|
if input.ChecksumXXHASH3 != nil && *input.ChecksumXXHASH3 == "" {
|
|
input.ChecksumXXHASH3 = nil
|
|
}
|
|
if input.ChecksumXXHASH128 != nil && *input.ChecksumXXHASH128 == "" {
|
|
input.ChecksumXXHASH128 = nil
|
|
}
|
|
if input.ContentDisposition != nil && *input.ContentDisposition == "" {
|
|
input.ContentDisposition = nil
|
|
}
|
|
if input.ContentEncoding != nil && *input.ContentEncoding == "" {
|
|
input.ContentEncoding = nil
|
|
}
|
|
if input.ContentLanguage != nil && *input.ContentLanguage == "" {
|
|
input.ContentLanguage = nil
|
|
}
|
|
if input.ContentMD5 != nil && *input.ContentMD5 == "" {
|
|
input.ContentMD5 = nil
|
|
}
|
|
if input.ContentType != nil && *input.ContentType == "" {
|
|
input.ContentType = nil
|
|
}
|
|
if input.ExpectedBucketOwner != nil && *input.ExpectedBucketOwner == "" {
|
|
input.ExpectedBucketOwner = nil
|
|
}
|
|
if input.Expires != nil && *input.Expires == "" {
|
|
input.Expires = nil
|
|
}
|
|
if input.GrantFullControl != nil && *input.GrantFullControl == "" {
|
|
input.GrantFullControl = nil
|
|
}
|
|
if input.GrantRead != nil && *input.GrantRead == "" {
|
|
input.GrantRead = nil
|
|
}
|
|
if input.GrantReadACP != nil && *input.GrantReadACP == "" {
|
|
input.GrantReadACP = nil
|
|
}
|
|
if input.GrantWriteACP != nil && *input.GrantWriteACP == "" {
|
|
input.GrantWriteACP = nil
|
|
}
|
|
if input.IfMatch != nil && *input.IfMatch == "" {
|
|
input.IfMatch = nil
|
|
}
|
|
if input.IfNoneMatch != nil && *input.IfNoneMatch == "" {
|
|
input.IfNoneMatch = nil
|
|
}
|
|
if input.SSECustomerAlgorithm != nil && *input.SSECustomerAlgorithm == "" {
|
|
input.SSECustomerAlgorithm = nil
|
|
}
|
|
if input.SSECustomerKey != nil && *input.SSECustomerKey == "" {
|
|
input.SSECustomerKey = nil
|
|
}
|
|
if input.SSECustomerKeyMD5 != nil && *input.SSECustomerKeyMD5 == "" {
|
|
input.SSECustomerKeyMD5 = nil
|
|
}
|
|
if input.SSEKMSEncryptionContext != nil && *input.SSEKMSEncryptionContext == "" {
|
|
input.SSEKMSEncryptionContext = nil
|
|
}
|
|
if input.SSEKMSKeyId != nil && *input.SSEKMSKeyId == "" {
|
|
input.SSEKMSKeyId = nil
|
|
}
|
|
if input.Tagging != nil && *input.Tagging == "" {
|
|
input.Tagging = nil
|
|
}
|
|
if input.WebsiteRedirectLocation != nil && *input.WebsiteRedirectLocation == "" {
|
|
input.WebsiteRedirectLocation = nil
|
|
}
|
|
|
|
// no object lock for backend
|
|
input.ObjectLockRetainUntilDate = nil
|
|
input.ObjectLockMode = ""
|
|
input.ObjectLockLegalHoldStatus = ""
|
|
|
|
var expire *time.Time
|
|
if input.Expires != nil {
|
|
exp, err := time.Parse(time.RFC1123, *input.Expires)
|
|
if err == nil {
|
|
expire = &exp
|
|
}
|
|
}
|
|
|
|
// streaming backend is not seekable,
|
|
// use unsigned payload for streaming ops
|
|
output, err := s.client.PutObject(ctx, &s3.PutObjectInput{
|
|
Bucket: input.Bucket,
|
|
Key: input.Key,
|
|
ContentLength: input.ContentLength,
|
|
ContentType: input.ContentType,
|
|
ContentEncoding: input.ContentEncoding,
|
|
ContentDisposition: input.ContentDisposition,
|
|
ContentLanguage: input.ContentLanguage,
|
|
CacheControl: input.CacheControl,
|
|
Expires: expire,
|
|
Metadata: input.Metadata,
|
|
Body: input.Body,
|
|
Tagging: input.Tagging,
|
|
ObjectLockRetainUntilDate: input.ObjectLockRetainUntilDate,
|
|
ObjectLockMode: input.ObjectLockMode,
|
|
ObjectLockLegalHoldStatus: input.ObjectLockLegalHoldStatus,
|
|
ChecksumAlgorithm: input.ChecksumAlgorithm,
|
|
ChecksumCRC32: input.ChecksumCRC32,
|
|
ChecksumCRC32C: input.ChecksumCRC32C,
|
|
ChecksumSHA1: input.ChecksumSHA1,
|
|
ChecksumSHA256: input.ChecksumSHA256,
|
|
ChecksumCRC64NVME: input.ChecksumCRC64NVME,
|
|
ChecksumSHA512: input.ChecksumSHA512,
|
|
ChecksumMD5: input.ChecksumMD5,
|
|
ChecksumXXHASH64: input.ChecksumXXHASH64,
|
|
ChecksumXXHASH3: input.ChecksumXXHASH3,
|
|
ChecksumXXHASH128: input.ChecksumXXHASH128,
|
|
ContentMD5: input.ContentMD5,
|
|
ExpectedBucketOwner: input.ExpectedBucketOwner,
|
|
GrantFullControl: input.GrantFullControl,
|
|
GrantRead: input.GrantRead,
|
|
GrantReadACP: input.GrantReadACP,
|
|
GrantWriteACP: input.GrantWriteACP,
|
|
IfMatch: input.IfMatch,
|
|
IfNoneMatch: input.IfNoneMatch,
|
|
SSECustomerAlgorithm: input.SSECustomerAlgorithm,
|
|
SSECustomerKey: input.SSECustomerKey,
|
|
SSECustomerKeyMD5: input.SSECustomerKeyMD5,
|
|
SSEKMSEncryptionContext: input.SSEKMSEncryptionContext,
|
|
SSEKMSKeyId: input.SSEKMSKeyId,
|
|
WebsiteRedirectLocation: input.WebsiteRedirectLocation,
|
|
}, s3.WithAPIOptions(
|
|
v4.SwapComputePayloadSHA256ForUnsignedPayloadMiddleware,
|
|
))
|
|
if err != nil {
|
|
return s3response.PutObjectOutput{}, handleError(err)
|
|
}
|
|
|
|
var versionID string
|
|
if output.VersionId != nil {
|
|
versionID = *output.VersionId
|
|
}
|
|
|
|
return s3response.PutObjectOutput{
|
|
ETag: *output.ETag,
|
|
VersionID: versionID,
|
|
ChecksumCRC32: output.ChecksumCRC32,
|
|
ChecksumCRC32C: output.ChecksumCRC32C,
|
|
ChecksumCRC64NVME: output.ChecksumCRC64NVME,
|
|
ChecksumSHA1: output.ChecksumSHA1,
|
|
ChecksumSHA256: output.ChecksumSHA256,
|
|
ChecksumSHA512: output.ChecksumSHA512,
|
|
ChecksumMD5: output.ChecksumMD5,
|
|
ChecksumXXHASH64: output.ChecksumXXHASH64,
|
|
ChecksumXXHASH3: output.ChecksumXXHASH3,
|
|
ChecksumXXHASH128: output.ChecksumXXHASH128,
|
|
Size: output.Size,
|
|
}, nil
|
|
}
|
|
|
|
func (s *S3Proxy) HeadObject(ctx context.Context, input *s3.HeadObjectInput) (*s3.HeadObjectOutput, error) {
|
|
if *input.Bucket == s.metaBucket {
|
|
return nil, s3err.GetAPIError(s3err.ErrAccessDenied)
|
|
}
|
|
if input.ExpectedBucketOwner != nil && *input.ExpectedBucketOwner == "" {
|
|
input.ExpectedBucketOwner = nil
|
|
}
|
|
if input.IfMatch != nil && *input.IfMatch == "" {
|
|
input.IfMatch = nil
|
|
}
|
|
if input.IfModifiedSince != nil && (*input.IfModifiedSince).Equal(defTime) {
|
|
input.IfModifiedSince = nil
|
|
}
|
|
if input.IfNoneMatch != nil && *input.IfNoneMatch == "" {
|
|
input.IfNoneMatch = nil
|
|
}
|
|
if input.IfUnmodifiedSince != nil && (*input.IfUnmodifiedSince).Equal(defTime) {
|
|
input.IfUnmodifiedSince = nil
|
|
}
|
|
if input.PartNumber != nil && *input.PartNumber == 0 {
|
|
input.PartNumber = nil
|
|
}
|
|
if input.Range != nil && *input.Range == "" {
|
|
input.Range = nil
|
|
}
|
|
if input.ResponseCacheControl != nil && *input.ResponseCacheControl == "" {
|
|
input.ResponseCacheControl = nil
|
|
}
|
|
if input.ResponseContentDisposition != nil && *input.ResponseContentDisposition == "" {
|
|
input.ResponseContentDisposition = nil
|
|
}
|
|
if input.ResponseContentEncoding != nil && *input.ResponseContentEncoding == "" {
|
|
input.ResponseContentEncoding = nil
|
|
}
|
|
if input.ResponseContentLanguage != nil && *input.ResponseContentLanguage == "" {
|
|
input.ResponseContentLanguage = nil
|
|
}
|
|
if input.ResponseContentType != nil && *input.ResponseContentType == "" {
|
|
input.ResponseContentType = nil
|
|
}
|
|
if input.ResponseExpires != nil && (*input.ResponseExpires).Equal(defTime) {
|
|
input.ResponseExpires = nil
|
|
}
|
|
if input.SSECustomerAlgorithm != nil && *input.SSECustomerAlgorithm == "" {
|
|
input.SSECustomerAlgorithm = nil
|
|
}
|
|
if input.SSECustomerKey != nil && *input.SSECustomerKey == "" {
|
|
input.SSECustomerKey = nil
|
|
}
|
|
if input.SSECustomerKeyMD5 != nil && *input.SSECustomerKeyMD5 == "" {
|
|
input.SSECustomerKeyMD5 = nil
|
|
}
|
|
if input.VersionId != nil && *input.VersionId == "" {
|
|
input.VersionId = nil
|
|
}
|
|
|
|
out, err := s.client.HeadObject(ctx, input)
|
|
return out, handleError(err)
|
|
}
|
|
|
|
func (s *S3Proxy) GetObject(ctx context.Context, input *s3.GetObjectInput) (*s3.GetObjectOutput, error) {
|
|
if *input.Bucket == s.metaBucket {
|
|
return nil, s3err.GetAPIError(s3err.ErrAccessDenied)
|
|
}
|
|
if input.ExpectedBucketOwner != nil && *input.ExpectedBucketOwner == "" {
|
|
input.ExpectedBucketOwner = nil
|
|
}
|
|
if input.IfMatch != nil && *input.IfMatch == "" {
|
|
input.IfMatch = nil
|
|
}
|
|
if input.IfModifiedSince != nil && (*input.IfModifiedSince).Equal(defTime) {
|
|
input.IfModifiedSince = nil
|
|
}
|
|
if input.IfNoneMatch != nil && *input.IfNoneMatch == "" {
|
|
input.IfNoneMatch = nil
|
|
}
|
|
if input.IfUnmodifiedSince != nil && (*input.IfUnmodifiedSince).Equal(defTime) {
|
|
input.IfUnmodifiedSince = nil
|
|
}
|
|
if input.PartNumber != nil && *input.PartNumber == 0 {
|
|
input.PartNumber = nil
|
|
}
|
|
if input.Range != nil && *input.Range == "" {
|
|
input.Range = nil
|
|
}
|
|
if input.ResponseCacheControl != nil && *input.ResponseCacheControl == "" {
|
|
input.ResponseCacheControl = nil
|
|
}
|
|
if input.ResponseContentDisposition != nil && *input.ResponseContentDisposition == "" {
|
|
input.ResponseContentDisposition = nil
|
|
}
|
|
if input.ResponseContentEncoding != nil && *input.ResponseContentEncoding == "" {
|
|
input.ResponseContentEncoding = nil
|
|
}
|
|
if input.ResponseContentLanguage != nil && *input.ResponseContentLanguage == "" {
|
|
input.ResponseContentLanguage = nil
|
|
}
|
|
if input.ResponseContentType != nil && *input.ResponseContentType == "" {
|
|
input.ResponseContentType = nil
|
|
}
|
|
if input.ResponseExpires != nil && (*input.ResponseExpires).Equal(defTime) {
|
|
input.ResponseExpires = nil
|
|
}
|
|
if input.SSECustomerAlgorithm != nil && *input.SSECustomerAlgorithm == "" {
|
|
input.SSECustomerAlgorithm = nil
|
|
}
|
|
if input.SSECustomerKey != nil && *input.SSECustomerKey == "" {
|
|
input.SSECustomerKey = nil
|
|
}
|
|
if input.SSECustomerKeyMD5 != nil && *input.SSECustomerKeyMD5 == "" {
|
|
input.SSECustomerKeyMD5 = nil
|
|
}
|
|
if input.VersionId != nil && *input.VersionId == "" {
|
|
input.VersionId = nil
|
|
}
|
|
|
|
output, err := s.client.GetObject(ctx, input)
|
|
if err != nil {
|
|
return nil, handleError(err)
|
|
}
|
|
|
|
return output, nil
|
|
}
|
|
|
|
func (s *S3Proxy) GetObjectAttributes(ctx context.Context, input *s3.GetObjectAttributesInput) (s3response.GetObjectAttributesResponse, error) {
|
|
if *input.Bucket == s.metaBucket {
|
|
return s3response.GetObjectAttributesResponse{}, s3err.GetAPIError(s3err.ErrAccessDenied)
|
|
}
|
|
if input.ExpectedBucketOwner != nil && *input.ExpectedBucketOwner == "" {
|
|
input.ExpectedBucketOwner = nil
|
|
}
|
|
if input.MaxParts != nil && *input.MaxParts == 0 {
|
|
input.MaxParts = nil
|
|
}
|
|
if input.PartNumberMarker != nil && *input.PartNumberMarker == "" {
|
|
input.PartNumberMarker = nil
|
|
}
|
|
if input.SSECustomerAlgorithm != nil && *input.SSECustomerAlgorithm == "" {
|
|
input.SSECustomerAlgorithm = nil
|
|
}
|
|
if input.SSECustomerKey != nil && *input.SSECustomerKey == "" {
|
|
input.SSECustomerKey = nil
|
|
}
|
|
if input.SSECustomerKeyMD5 != nil && *input.SSECustomerKeyMD5 == "" {
|
|
input.SSECustomerKeyMD5 = nil
|
|
}
|
|
if input.VersionId != nil && *input.VersionId == "" {
|
|
input.VersionId = nil
|
|
}
|
|
|
|
out, err := s.client.GetObjectAttributes(ctx, input)
|
|
if err != nil {
|
|
return s3response.GetObjectAttributesResponse{}, handleError(err)
|
|
}
|
|
|
|
parts := s3response.ObjectParts{}
|
|
objParts := out.ObjectParts
|
|
if objParts != nil {
|
|
if objParts.PartNumberMarker != nil {
|
|
partNumberMarker, err := strconv.Atoi(*objParts.PartNumberMarker)
|
|
if err != nil {
|
|
parts.PartNumberMarker = partNumberMarker
|
|
}
|
|
if objParts.NextPartNumberMarker != nil {
|
|
nextPartNumberMarker, err := strconv.Atoi(*objParts.NextPartNumberMarker)
|
|
if err != nil {
|
|
parts.NextPartNumberMarker = nextPartNumberMarker
|
|
}
|
|
}
|
|
if objParts.IsTruncated != nil {
|
|
parts.IsTruncated = *objParts.IsTruncated
|
|
}
|
|
if objParts.MaxParts != nil {
|
|
parts.MaxParts = int(*objParts.MaxParts)
|
|
}
|
|
parts.Parts = objParts.Parts
|
|
}
|
|
}
|
|
|
|
return s3response.GetObjectAttributesResponse{
|
|
ETag: out.ETag,
|
|
LastModified: out.LastModified,
|
|
ObjectSize: out.ObjectSize,
|
|
StorageClass: out.StorageClass,
|
|
ObjectParts: &parts,
|
|
Checksum: out.Checksum,
|
|
}, nil
|
|
}
|
|
|
|
func (s *S3Proxy) CopyObject(ctx context.Context, input s3response.CopyObjectInput) (s3response.CopyObjectOutput, error) {
|
|
if *input.Bucket == s.metaBucket {
|
|
return s3response.CopyObjectOutput{}, s3err.GetAPIError(s3err.ErrAccessDenied)
|
|
}
|
|
if input.CacheControl != nil && *input.CacheControl == "" {
|
|
input.CacheControl = nil
|
|
}
|
|
if input.ContentDisposition != nil && *input.ContentDisposition == "" {
|
|
input.ContentDisposition = nil
|
|
}
|
|
if input.ContentEncoding != nil && *input.ContentEncoding == "" {
|
|
input.ContentEncoding = nil
|
|
}
|
|
if input.ContentLanguage != nil && *input.ContentLanguage == "" {
|
|
input.ContentLanguage = nil
|
|
}
|
|
if input.ContentType != nil && *input.ContentType == "" {
|
|
input.ContentType = nil
|
|
}
|
|
if input.CopySourceIfMatch != nil && *input.CopySourceIfMatch == "" {
|
|
input.CopySourceIfMatch = nil
|
|
}
|
|
if input.CopySourceIfModifiedSince != nil && (*input.CopySourceIfModifiedSince).Equal(defTime) {
|
|
input.CopySourceIfModifiedSince = nil
|
|
}
|
|
if input.CopySourceIfNoneMatch != nil && *input.CopySourceIfNoneMatch == "" {
|
|
input.CopySourceIfNoneMatch = nil
|
|
}
|
|
if input.CopySourceIfUnmodifiedSince != nil && (*input.CopySourceIfUnmodifiedSince).Equal(defTime) {
|
|
input.CopySourceIfUnmodifiedSince = nil
|
|
}
|
|
if input.CopySourceSSECustomerAlgorithm != nil && *input.CopySourceSSECustomerAlgorithm == "" {
|
|
input.CopySourceSSECustomerAlgorithm = nil
|
|
}
|
|
if input.CopySourceSSECustomerKey != nil && *input.CopySourceSSECustomerKey == "" {
|
|
input.CopySourceSSECustomerKey = nil
|
|
}
|
|
if input.CopySourceSSECustomerKeyMD5 != nil && *input.CopySourceSSECustomerKeyMD5 == "" {
|
|
input.CopySourceSSECustomerKeyMD5 = nil
|
|
}
|
|
if input.ExpectedBucketOwner != nil && *input.ExpectedBucketOwner == "" {
|
|
input.ExpectedBucketOwner = nil
|
|
}
|
|
if input.ExpectedSourceBucketOwner != nil && *input.ExpectedSourceBucketOwner == "" {
|
|
input.ExpectedSourceBucketOwner = nil
|
|
}
|
|
if input.Expires != nil && *input.Expires == "" {
|
|
input.Expires = nil
|
|
}
|
|
if input.GrantFullControl != nil && *input.GrantFullControl == "" {
|
|
input.GrantFullControl = nil
|
|
}
|
|
if input.GrantRead != nil && *input.GrantRead == "" {
|
|
input.GrantRead = nil
|
|
}
|
|
if input.GrantReadACP != nil && *input.GrantReadACP == "" {
|
|
input.GrantReadACP = nil
|
|
}
|
|
if input.GrantWriteACP != nil && *input.GrantWriteACP == "" {
|
|
input.GrantWriteACP = nil
|
|
}
|
|
if input.ObjectLockRetainUntilDate != nil && (*input.ObjectLockRetainUntilDate).Equal(defTime) {
|
|
input.ObjectLockRetainUntilDate = nil
|
|
}
|
|
if input.SSECustomerAlgorithm != nil && *input.SSECustomerAlgorithm == "" {
|
|
input.SSECustomerAlgorithm = nil
|
|
}
|
|
if input.SSECustomerKey != nil && *input.SSECustomerKey == "" {
|
|
input.SSECustomerKey = nil
|
|
}
|
|
if input.SSECustomerKeyMD5 != nil && *input.SSECustomerKeyMD5 == "" {
|
|
input.SSECustomerKeyMD5 = nil
|
|
}
|
|
if input.SSEKMSEncryptionContext != nil && *input.SSEKMSEncryptionContext == "" {
|
|
input.SSEKMSEncryptionContext = nil
|
|
}
|
|
if input.SSEKMSKeyId != nil && *input.SSEKMSKeyId == "" {
|
|
input.SSEKMSKeyId = nil
|
|
}
|
|
if input.Tagging != nil && *input.Tagging == "" {
|
|
input.Tagging = nil
|
|
}
|
|
if input.WebsiteRedirectLocation != nil && *input.WebsiteRedirectLocation == "" {
|
|
input.WebsiteRedirectLocation = nil
|
|
}
|
|
|
|
var expires *time.Time
|
|
if input.Expires != nil {
|
|
exp, err := time.Parse(time.RFC1123, *input.Expires)
|
|
if err == nil {
|
|
expires = &exp
|
|
}
|
|
}
|
|
|
|
out, err := s.client.CopyObject(ctx,
|
|
&s3.CopyObjectInput{
|
|
Metadata: input.Metadata,
|
|
Bucket: input.Bucket,
|
|
CopySource: input.CopySource,
|
|
Key: input.Key,
|
|
CacheControl: input.CacheControl,
|
|
ContentDisposition: input.ContentDisposition,
|
|
ContentEncoding: input.ContentEncoding,
|
|
ContentLanguage: input.ContentLanguage,
|
|
ContentType: input.ContentType,
|
|
CopySourceIfMatch: input.CopySourceIfMatch,
|
|
CopySourceIfNoneMatch: input.CopySourceIfNoneMatch,
|
|
CopySourceSSECustomerAlgorithm: input.CopySourceSSECustomerAlgorithm,
|
|
CopySourceSSECustomerKey: input.CopySourceSSECustomerKey,
|
|
CopySourceSSECustomerKeyMD5: input.CopySourceSSECustomerKeyMD5,
|
|
ExpectedBucketOwner: input.ExpectedBucketOwner,
|
|
ExpectedSourceBucketOwner: input.ExpectedSourceBucketOwner,
|
|
Expires: expires,
|
|
GrantFullControl: input.GrantFullControl,
|
|
GrantRead: input.GrantRead,
|
|
GrantReadACP: input.GrantReadACP,
|
|
GrantWriteACP: input.GrantWriteACP,
|
|
SSECustomerAlgorithm: input.SSECustomerAlgorithm,
|
|
SSECustomerKey: input.SSECustomerKey,
|
|
SSECustomerKeyMD5: input.SSECustomerKeyMD5,
|
|
SSEKMSEncryptionContext: input.SSEKMSEncryptionContext,
|
|
SSEKMSKeyId: input.SSEKMSKeyId,
|
|
Tagging: input.Tagging,
|
|
WebsiteRedirectLocation: input.WebsiteRedirectLocation,
|
|
CopySourceIfModifiedSince: input.CopySourceIfModifiedSince,
|
|
CopySourceIfUnmodifiedSince: input.CopySourceIfUnmodifiedSince,
|
|
ObjectLockRetainUntilDate: input.ObjectLockRetainUntilDate,
|
|
BucketKeyEnabled: input.BucketKeyEnabled,
|
|
ACL: input.ACL,
|
|
ChecksumAlgorithm: input.ChecksumAlgorithm,
|
|
MetadataDirective: input.MetadataDirective,
|
|
ObjectLockLegalHoldStatus: input.ObjectLockLegalHoldStatus,
|
|
ObjectLockMode: input.ObjectLockMode,
|
|
RequestPayer: input.RequestPayer,
|
|
ServerSideEncryption: input.ServerSideEncryption,
|
|
StorageClass: input.StorageClass,
|
|
TaggingDirective: input.TaggingDirective,
|
|
})
|
|
if err != nil {
|
|
return s3response.CopyObjectOutput{}, handleError(err)
|
|
}
|
|
if out.CopyObjectResult == nil {
|
|
out.CopyObjectResult = &types.CopyObjectResult{}
|
|
}
|
|
return s3response.CopyObjectOutput{
|
|
BucketKeyEnabled: out.BucketKeyEnabled,
|
|
CopyObjectResult: &s3response.CopyObjectResult{
|
|
ChecksumCRC32: out.CopyObjectResult.ChecksumCRC32,
|
|
ChecksumCRC32C: out.CopyObjectResult.ChecksumCRC32C,
|
|
ChecksumCRC64NVME: out.CopyObjectResult.ChecksumCRC64NVME,
|
|
ChecksumSHA1: out.CopyObjectResult.ChecksumSHA1,
|
|
ChecksumSHA256: out.CopyObjectResult.ChecksumSHA256,
|
|
ChecksumSHA512: out.CopyObjectResult.ChecksumSHA512,
|
|
ChecksumMD5: out.CopyObjectResult.ChecksumMD5,
|
|
ChecksumXXHASH64: out.CopyObjectResult.ChecksumXXHASH64,
|
|
ChecksumXXHASH3: out.CopyObjectResult.ChecksumXXHASH3,
|
|
ChecksumXXHASH128: out.CopyObjectResult.ChecksumXXHASH128,
|
|
ChecksumType: out.CopyObjectResult.ChecksumType,
|
|
ETag: out.CopyObjectResult.ETag,
|
|
LastModified: out.CopyObjectResult.LastModified,
|
|
},
|
|
CopySourceVersionId: out.CopySourceVersionId,
|
|
Expiration: out.Expiration,
|
|
SSECustomerAlgorithm: out.SSECustomerAlgorithm,
|
|
SSECustomerKeyMD5: out.SSECustomerKeyMD5,
|
|
SSEKMSEncryptionContext: out.SSEKMSEncryptionContext,
|
|
SSEKMSKeyId: out.SSEKMSKeyId,
|
|
ServerSideEncryption: out.ServerSideEncryption,
|
|
VersionId: out.VersionId,
|
|
}, handleError(err)
|
|
}
|
|
|
|
func (s *S3Proxy) ListObjects(ctx context.Context, input *s3.ListObjectsInput) (s3response.ListObjectsResult, error) {
|
|
if *input.Bucket == s.metaBucket {
|
|
return s3response.ListObjectsResult{}, s3err.GetAPIError(s3err.ErrAccessDenied)
|
|
}
|
|
if input.Delimiter != nil && *input.Delimiter == "" {
|
|
input.Delimiter = nil
|
|
}
|
|
if input.ExpectedBucketOwner != nil && *input.ExpectedBucketOwner == "" {
|
|
input.ExpectedBucketOwner = nil
|
|
}
|
|
if input.Marker != nil && *input.Marker == "" {
|
|
input.Marker = nil
|
|
}
|
|
if input.MaxKeys != nil && *input.MaxKeys == 0 {
|
|
input.MaxKeys = nil
|
|
}
|
|
if input.Prefix != nil && *input.Prefix == "" {
|
|
input.Prefix = nil
|
|
}
|
|
|
|
out, err := s.client.ListObjects(ctx, input)
|
|
if err != nil {
|
|
return s3response.ListObjectsResult{}, handleError(err)
|
|
}
|
|
|
|
contents := convertObjects(out.Contents)
|
|
|
|
return s3response.ListObjectsResult{
|
|
CommonPrefixes: out.CommonPrefixes,
|
|
Contents: contents,
|
|
Delimiter: out.Delimiter,
|
|
IsTruncated: out.IsTruncated,
|
|
Marker: out.Marker,
|
|
MaxKeys: out.MaxKeys,
|
|
Name: out.Name,
|
|
NextMarker: out.NextMarker,
|
|
Prefix: out.Prefix,
|
|
}, nil
|
|
}
|
|
|
|
func (s *S3Proxy) ListObjectsV2(ctx context.Context, input *s3.ListObjectsV2Input) (s3response.ListObjectsV2Result, error) {
|
|
if *input.Bucket == s.metaBucket {
|
|
return s3response.ListObjectsV2Result{}, s3err.GetAPIError(s3err.ErrAccessDenied)
|
|
}
|
|
if input.ContinuationToken != nil && *input.ContinuationToken == "" {
|
|
input.ContinuationToken = nil
|
|
}
|
|
if input.Delimiter != nil && *input.Delimiter == "" {
|
|
input.Delimiter = nil
|
|
}
|
|
if input.ExpectedBucketOwner != nil && *input.ExpectedBucketOwner == "" {
|
|
input.ExpectedBucketOwner = nil
|
|
}
|
|
if input.MaxKeys != nil && *input.MaxKeys == 0 {
|
|
input.MaxKeys = nil
|
|
}
|
|
if input.Prefix != nil && *input.Prefix == "" {
|
|
input.Prefix = nil
|
|
}
|
|
if input.StartAfter != nil && *input.StartAfter == "" {
|
|
input.StartAfter = nil
|
|
}
|
|
|
|
out, err := s.client.ListObjectsV2(ctx, input)
|
|
if err != nil {
|
|
return s3response.ListObjectsV2Result{}, handleError(err)
|
|
}
|
|
|
|
contents := convertObjects(out.Contents)
|
|
|
|
return s3response.ListObjectsV2Result{
|
|
CommonPrefixes: out.CommonPrefixes,
|
|
Contents: contents,
|
|
Delimiter: out.Delimiter,
|
|
IsTruncated: out.IsTruncated,
|
|
ContinuationToken: out.ContinuationToken,
|
|
MaxKeys: out.MaxKeys,
|
|
Name: out.Name,
|
|
NextContinuationToken: out.NextContinuationToken,
|
|
Prefix: out.Prefix,
|
|
KeyCount: out.KeyCount,
|
|
}, nil
|
|
}
|
|
|
|
func (s *S3Proxy) DeleteObject(ctx context.Context, input *s3.DeleteObjectInput) (*s3.DeleteObjectOutput, error) {
|
|
if *input.Bucket == s.metaBucket {
|
|
return nil, s3err.GetAPIError(s3err.ErrAccessDenied)
|
|
}
|
|
if input.ExpectedBucketOwner != nil && *input.ExpectedBucketOwner == "" {
|
|
input.ExpectedBucketOwner = nil
|
|
}
|
|
if input.IfMatch != nil && *input.IfMatch == "" {
|
|
input.IfMatch = nil
|
|
}
|
|
if input.IfMatchLastModifiedTime != nil && (*input.IfMatchLastModifiedTime).Equal(defTime) {
|
|
input.IfMatchLastModifiedTime = nil
|
|
}
|
|
if input.IfMatchSize != nil && *input.IfMatchSize == 0 {
|
|
input.IfMatchSize = nil
|
|
}
|
|
if input.MFA != nil && *input.MFA == "" {
|
|
input.MFA = nil
|
|
}
|
|
if input.VersionId != nil && *input.VersionId == "" {
|
|
input.VersionId = nil
|
|
}
|
|
|
|
res, err := s.client.DeleteObject(ctx, input)
|
|
return res, handleError(err)
|
|
}
|
|
|
|
func (s *S3Proxy) DeleteObjects(ctx context.Context, input *s3.DeleteObjectsInput) (s3response.DeleteResult, error) {
|
|
if *input.Bucket == s.metaBucket {
|
|
return s3response.DeleteResult{}, s3err.GetAPIError(s3err.ErrAccessDenied)
|
|
}
|
|
if input.ExpectedBucketOwner != nil && *input.ExpectedBucketOwner == "" {
|
|
input.ExpectedBucketOwner = nil
|
|
}
|
|
if input.MFA != nil && *input.MFA == "" {
|
|
input.MFA = nil
|
|
}
|
|
|
|
if len(input.Delete.Objects) == 0 {
|
|
input.Delete.Objects = []types.ObjectIdentifier{}
|
|
}
|
|
|
|
output, err := s.client.DeleteObjects(ctx, input)
|
|
if err != nil {
|
|
return s3response.DeleteResult{}, handleError(err)
|
|
}
|
|
|
|
return s3response.DeleteResult{
|
|
Deleted: output.Deleted,
|
|
Error: output.Errors,
|
|
}, nil
|
|
}
|
|
|
|
func (s *S3Proxy) GetBucketAcl(ctx context.Context, input *s3.GetBucketAclInput) ([]byte, error) {
|
|
data, err := s.getMetaBucketObjData(ctx, *input.Bucket, metaPrefixAcl, false)
|
|
if err != nil {
|
|
return nil, handleError(err)
|
|
}
|
|
|
|
return data, nil
|
|
}
|
|
|
|
func (s *S3Proxy) PutBucketAcl(ctx context.Context, bucket string, data []byte) error {
|
|
return handleError(s.putMetaBucketObj(ctx, bucket, data, metaPrefixAcl))
|
|
}
|
|
|
|
func (s *S3Proxy) PutObjectTagging(ctx context.Context, bucket, object, versionId string, tags map[string]string) error {
|
|
if bucket == s.metaBucket {
|
|
return s3err.GetAPIError(s3err.ErrAccessDenied)
|
|
}
|
|
tagging := &types.Tagging{
|
|
TagSet: []types.Tag{},
|
|
}
|
|
for key, val := range tags {
|
|
tagging.TagSet = append(tagging.TagSet, types.Tag{
|
|
Key: &key,
|
|
Value: &val,
|
|
})
|
|
}
|
|
|
|
_, err := s.client.PutObjectTagging(ctx, &s3.PutObjectTaggingInput{
|
|
Bucket: &bucket,
|
|
Key: &object,
|
|
VersionId: &versionId,
|
|
Tagging: tagging,
|
|
})
|
|
return handleError(err)
|
|
}
|
|
|
|
func (s *S3Proxy) GetObjectTagging(ctx context.Context, bucket, object, versionId string) (map[string]string, error) {
|
|
if bucket == s.metaBucket {
|
|
return nil, s3err.GetAPIError(s3err.ErrAccessDenied)
|
|
}
|
|
output, err := s.client.GetObjectTagging(ctx, &s3.GetObjectTaggingInput{
|
|
Bucket: &bucket,
|
|
Key: &object,
|
|
VersionId: &versionId,
|
|
})
|
|
if err != nil {
|
|
return nil, handleError(err)
|
|
}
|
|
|
|
tags := make(map[string]string)
|
|
for _, el := range output.TagSet {
|
|
tags[*el.Key] = *el.Value
|
|
}
|
|
|
|
return tags, nil
|
|
}
|
|
|
|
func (s *S3Proxy) DeleteObjectTagging(ctx context.Context, bucket, object, versionId string) error {
|
|
if bucket == s.metaBucket {
|
|
return s3err.GetAPIError(s3err.ErrAccessDenied)
|
|
}
|
|
_, err := s.client.DeleteObjectTagging(ctx, &s3.DeleteObjectTaggingInput{
|
|
Bucket: &bucket,
|
|
Key: &object,
|
|
VersionId: &versionId,
|
|
})
|
|
return handleError(err)
|
|
}
|
|
|
|
func (s *S3Proxy) PutBucketCors(ctx context.Context, bucket string, cors []byte) error {
|
|
return handleError(s.putMetaBucketObj(ctx, bucket, cors, metaPrefixCors))
|
|
}
|
|
|
|
func (s *S3Proxy) GetBucketCors(ctx context.Context, bucket string) ([]byte, error) {
|
|
data, err := s.getMetaBucketObjData(ctx, bucket, metaPrefixCors, false)
|
|
if err != nil {
|
|
return nil, handleError(err)
|
|
}
|
|
|
|
return data, nil
|
|
}
|
|
|
|
func (s *S3Proxy) DeleteBucketCors(ctx context.Context, bucket string) error {
|
|
key := getMetaKey(bucket, metaPrefixCors)
|
|
_, err := s.client.DeleteObject(ctx, &s3.DeleteObjectInput{
|
|
Bucket: &s.metaBucket,
|
|
Key: &key,
|
|
})
|
|
if err != nil && !areErrSame(err, s3err.GetAPIError(s3err.ErrNoSuchKey)) {
|
|
return handleError(err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (s *S3Proxy) PutBucketWebsite(ctx context.Context, bucket string, website []byte) error {
|
|
return handleError(s.putMetaBucketObj(ctx, bucket, website, metaPrefixWebsite))
|
|
}
|
|
|
|
func (s *S3Proxy) GetBucketWebsite(ctx context.Context, bucket string) ([]byte, error) {
|
|
data, err := s.getMetaBucketObjData(ctx, bucket, metaPrefixWebsite, false)
|
|
if err != nil {
|
|
return nil, handleError(err)
|
|
}
|
|
|
|
return data, nil
|
|
}
|
|
|
|
func (s *S3Proxy) DeleteBucketWebsite(ctx context.Context, bucket string) error {
|
|
key := getMetaKey(bucket, metaPrefixWebsite)
|
|
_, err := s.client.DeleteObject(ctx, &s3.DeleteObjectInput{
|
|
Bucket: &s.metaBucket,
|
|
Key: &key,
|
|
})
|
|
if err != nil && !areErrSame(err, s3err.GetAPIError(s3err.ErrNoSuchKey)) {
|
|
return handleError(err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (s *S3Proxy) PutBucketPolicy(ctx context.Context, bucket string, policy []byte) error {
|
|
return handleError(s.putMetaBucketObj(ctx, bucket, policy, metaPrefixPolicy))
|
|
}
|
|
|
|
func (s *S3Proxy) GetBucketPolicy(ctx context.Context, bucket string) ([]byte, error) {
|
|
data, err := s.getMetaBucketObjData(ctx, bucket, metaPrefixPolicy, false)
|
|
if err != nil {
|
|
return nil, handleError(err)
|
|
}
|
|
|
|
return data, nil
|
|
}
|
|
|
|
func (s *S3Proxy) DeleteBucketPolicy(ctx context.Context, bucket string) error {
|
|
key := getMetaKey(bucket, metaPrefixPolicy)
|
|
_, err := s.client.DeleteObject(ctx, &s3.DeleteObjectInput{
|
|
Bucket: &s.metaBucket,
|
|
Key: &key,
|
|
})
|
|
if err != nil && !areErrSame(err, s3err.GetAPIError(s3err.ErrNoSuchKey)) {
|
|
return handleError(err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (s *S3Proxy) PutObjectLockConfiguration(ctx context.Context, bucket string, config []byte) error {
|
|
return s3err.GetAPIError(s3err.ErrNotImplemented)
|
|
}
|
|
|
|
func (s *S3Proxy) GetObjectLockConfiguration(ctx context.Context, bucket string) ([]byte, error) {
|
|
return nil, s3err.GetBucketErr(s3err.ErrObjectLockConfigurationNotFound, bucket)
|
|
}
|
|
|
|
func (s *S3Proxy) PutObjectRetention(ctx context.Context, bucket, object, versionId string, retention []byte) error {
|
|
return s3err.GetAPIError(s3err.ErrNotImplemented)
|
|
}
|
|
|
|
func (s *S3Proxy) GetObjectRetention(ctx context.Context, bucket, object, versionId string) ([]byte, error) {
|
|
return nil, s3err.GetAPIError(s3err.ErrNotImplemented)
|
|
|
|
}
|
|
|
|
func (s *S3Proxy) PutObjectLegalHold(ctx context.Context, bucket, object, versionId string, status bool) error {
|
|
return s3err.GetAPIError(s3err.ErrNotImplemented)
|
|
}
|
|
|
|
func (s *S3Proxy) GetObjectLegalHold(ctx context.Context, bucket, object, versionId string) (*bool, error) {
|
|
return nil, s3err.GetAPIError(s3err.ErrNotImplemented)
|
|
}
|
|
|
|
func (s *S3Proxy) ChangeBucketOwner(ctx context.Context, bucket, owner string) error {
|
|
return auth.UpdateBucketACLOwner(ctx, s, bucket, owner)
|
|
}
|
|
|
|
func (s *S3Proxy) ListBucketsAndOwners(ctx context.Context) ([]s3response.Bucket, error) {
|
|
var buckets []s3response.Bucket
|
|
|
|
paginator := s3.NewListBucketsPaginator(s.client, &s3.ListBucketsInput{})
|
|
|
|
for paginator.HasMorePages() {
|
|
page, err := paginator.NextPage(ctx)
|
|
if err != nil {
|
|
return nil, handleError(err)
|
|
}
|
|
for _, bucket := range page.Buckets {
|
|
if *bucket.Name == s.metaBucket {
|
|
continue
|
|
}
|
|
aclJSON, err := s.getMetaBucketObjData(ctx, *bucket.Name, metaPrefixAcl, false)
|
|
if err != nil {
|
|
return nil, handleError(err)
|
|
}
|
|
|
|
acl, err := auth.ParseACL(aclJSON)
|
|
if err != nil {
|
|
return buckets, fmt.Errorf("parse acl tag: %w", err)
|
|
}
|
|
|
|
buckets = append(buckets, s3response.Bucket{
|
|
Name: *bucket.Name,
|
|
Owner: acl.Owner,
|
|
})
|
|
}
|
|
}
|
|
|
|
return buckets, nil
|
|
}
|
|
|
|
func (s *S3Proxy) bucketExists(ctx context.Context, bucket string) bool {
|
|
_, err := s.client.HeadBucket(ctx, &s3.HeadBucketInput{
|
|
Bucket: &bucket,
|
|
})
|
|
return err == nil
|
|
}
|
|
|
|
func (s *S3Proxy) putMetaBucketObj(ctx context.Context, bucket string, data []byte, prefix metaPrefix) error {
|
|
// if meta bucket is not provided, return successful response
|
|
if s.metaBucket == "" {
|
|
return nil
|
|
}
|
|
|
|
key := getMetaKey(bucket, prefix)
|
|
// store the provided bucket acl/policy as an object in meta bucket
|
|
_, err := s.client.PutObject(ctx, &s3.PutObjectInput{
|
|
Bucket: &s.metaBucket,
|
|
Key: &key,
|
|
Body: bytes.NewReader(data),
|
|
})
|
|
return err
|
|
}
|
|
|
|
// set checkExists to true if using to check for existence of bucket, in
|
|
// this case it will not return default acl/policy if the metadata does
|
|
// not exist
|
|
func (s *S3Proxy) getMetaBucketObjData(ctx context.Context, bucket string, prefix metaPrefix, checkExists bool) ([]byte, error) {
|
|
// return default bahviour of get bucket policy/acl, if meta bucket is not provided
|
|
if s.metaBucket == "" {
|
|
return handleMetaBucketObjectNotFoundErr(bucket, prefix)
|
|
}
|
|
|
|
key := getMetaKey(bucket, prefix)
|
|
// get meta bucket object
|
|
res, err := s.client.GetObject(ctx, &s3.GetObjectInput{
|
|
Bucket: &s.metaBucket,
|
|
Key: &key,
|
|
})
|
|
if areErrSame(err, s3err.GetAPIError(s3err.ErrNoSuchKey)) {
|
|
if checkExists {
|
|
return nil, err
|
|
}
|
|
|
|
return handleMetaBucketObjectNotFoundErr(bucket, prefix)
|
|
}
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
data, err := io.ReadAll(res.Body)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("read meta object data: %w", err)
|
|
}
|
|
|
|
return data, nil
|
|
}
|
|
|
|
// handles the case when an object with the given metprefix
|
|
// is not found in meta bucket. Aggregates the not found errors
|
|
// for each meta prefix
|
|
func handleMetaBucketObjectNotFoundErr(bucket string, prefix metaPrefix) ([]byte, error) {
|
|
switch prefix {
|
|
case metaPrefixAcl:
|
|
// If bucket acl is not found, return default acl
|
|
return []byte{}, nil
|
|
case metaPrefixPolicy:
|
|
return nil, s3err.GetBucketErr(s3err.ErrNoSuchBucketPolicy, bucket)
|
|
case metaPrefixCors:
|
|
return nil, s3err.GetBucketErr(s3err.ErrNoSuchCORSConfiguration, bucket)
|
|
case metaPrefixWebsite:
|
|
return nil, s3err.GetBucketErr(s3err.ErrNoSuchWebsiteConfiguration, bucket)
|
|
}
|
|
|
|
return []byte{}, nil
|
|
}
|
|
|
|
// Checks if the provided err is a type of smithy.APIError
|
|
// and if the error code and message match with the provided apiErr
|
|
func areErrSame(err error, apiErr s3err.APIError) bool {
|
|
if err == nil {
|
|
return false
|
|
}
|
|
var ae smithy.APIError
|
|
if errors.As(err, &ae) {
|
|
if ae.ErrorCode() != apiErr.Code {
|
|
return false
|
|
}
|
|
|
|
// 404 errors are not well serialized by aws-sdk-go-v2
|
|
if ae.ErrorCode() != "NoSuchKey" && ae.ErrorMessage() != apiErr.Description {
|
|
return false
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
return false
|
|
}
|
|
|
|
// generates meta object key with bucket name and meta prefix
|
|
func getMetaKey(bucket string, prefix metaPrefix) string {
|
|
return string(prefix) + bucket
|
|
}
|
|
|
|
func handleError(err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
|
|
var ae smithy.APIError
|
|
if errors.As(err, &ae) {
|
|
apiErr := s3err.APIError{
|
|
Code: ae.ErrorCode(),
|
|
Description: ae.ErrorMessage(),
|
|
}
|
|
var re *awshttp.ResponseError
|
|
if errors.As(err, &re) {
|
|
apiErr.HTTPStatusCode = re.Response.StatusCode
|
|
}
|
|
return apiErr
|
|
}
|
|
return err
|
|
}
|
|
|
|
func convertObjects(objs []types.Object) []s3response.Object {
|
|
result := make([]s3response.Object, 0, len(objs))
|
|
|
|
for _, obj := range objs {
|
|
result = append(result, s3response.Object{
|
|
ETag: obj.ETag,
|
|
Key: obj.Key,
|
|
LastModified: obj.LastModified,
|
|
Owner: obj.Owner,
|
|
Size: obj.Size,
|
|
RestoreStatus: obj.RestoreStatus,
|
|
StorageClass: obj.StorageClass,
|
|
ChecksumAlgorithm: obj.ChecksumAlgorithm,
|
|
ChecksumType: obj.ChecksumType,
|
|
})
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
func convertObjectVersions(versions []types.ObjectVersion) []s3response.ObjectVersion {
|
|
result := make([]s3response.ObjectVersion, 0, len(versions))
|
|
for _, v := range versions {
|
|
result = append(result, s3response.ObjectVersion{
|
|
ChecksumAlgorithm: v.ChecksumAlgorithm,
|
|
ChecksumType: v.ChecksumType,
|
|
ETag: v.ETag,
|
|
IsLatest: v.IsLatest,
|
|
Key: v.Key,
|
|
LastModified: v.LastModified,
|
|
Owner: v.Owner,
|
|
RestoreStatus: v.RestoreStatus,
|
|
Size: v.Size,
|
|
StorageClass: v.StorageClass,
|
|
VersionId: v.VersionId,
|
|
})
|
|
}
|
|
|
|
return result
|
|
}
|