package objectgateway import ( "bytes" "context" "errors" "io" "github.com/aws/aws-sdk-go-v2/aws" "github.com/aws/aws-sdk-go-v2/aws/signer/v4" "github.com/aws/aws-sdk-go-v2/service/s3" "github.com/aws/smithy-go" ) // S3Backend is for independently versioned S3/MinIO stores. No SDK mutation retries. type S3Backend struct { Client *s3.Client Bucket string MaxBytes int64 } func (s *S3Backend) Ready(ctx context.Context) error { r, e := s.Client.GetBucketVersioning(ctx, &s3.GetBucketVersioningInput{Bucket: aws.String(s.Bucket)}) if e != nil || string(r.Status) != "Enabled" { return errors.New("gateway_backend_versioning_unverified") } return nil } func (s *S3Backend) Observe(ctx context.Context, key, id string) (Version, bool, error) { req := &s3.GetObjectInput{Bucket: aws.String(s.Bucket), Key: aws.String(key)} if id != "" { req.VersionId = aws.String(id) } got, e := s.Client.GetObject(ctx, req) if e != nil { var api smithy.APIError if errors.As(e, &api) && (api.ErrorCode() == "NoSuchKey" || api.ErrorCode() == "NoSuchVersion") { return Version{}, false, nil } return Version{}, false, errors.New("gateway_backend_read_failed") } defer got.Body.Close() if got.ContentLength == nil || *got.ContentLength < 0 || *got.ContentLength > s.MaxBytes { return Version{}, false, errors.New("gateway_backend_size_invalid") } body, e := io.ReadAll(io.LimitReader(got.Body, s.MaxBytes+1)) if e != nil || int64(len(body)) != *got.ContentLength { return Version{}, false, errors.New("gateway_backend_body_incomplete") } v := Version{aws.ToString(got.VersionId), got.Metadata["kg-release-owner"], Digest(body), int64(len(body)), aws.ToString(got.ETag)} // Existing unowned objects are observable but cannot be claimed/deleted. if v.ID == "" || v.ID == "null" || v.ETag == "" || id != "" && v.ID != id { return Version{}, false, errors.New("gateway_backend_version_invalid") } return v, true, nil } func (s *S3Backend) List(ctx context.Context, key string) ([]Version, error) { got, e := s.Client.ListObjectVersions(ctx, &s3.ListObjectVersionsInput{Bucket: aws.String(s.Bucket), Prefix: aws.String(key), MaxKeys: aws.Int32(1000)}) if e != nil || aws.ToBool(got.IsTruncated) { return nil, errors.New("gateway_backend_listing_incomplete") } var versions []Version for _, m := range got.DeleteMarkers { if aws.ToString(m.Key) == key { return nil, errors.New("gateway_backend_delete_marker_conflict") } } for _, v := range got.Versions { if aws.ToString(v.Key) == key { one, exists, e := s.Observe(ctx, key, aws.ToString(v.VersionId)) if e != nil || !exists { return nil, errors.New("gateway_backend_listing_changed") } versions = append(versions, one) } } return versions, nil } func (s *S3Backend) Put(ctx context.Context, key string, body []byte, owner string) (Version, error) { // SDK hashing requires a seekable body. RetryMaxAttempts=1 prevents SDK // retries; PUT carries no HTTP idempotency header or replay authorization. reader := bytes.NewReader(body) got, e := s.Client.PutObject(v4.SetPayloadHash(ctx, Digest(body)), &s3.PutObjectInput{Bucket: aws.String(s.Bucket), Key: aws.String(key), Body: reader, ContentLength: aws.Int64(int64(len(body))), Metadata: map[string]string{"kg-release-owner": owner}}, func(o *s3.Options) { o.RetryMaxAttempts = 1 }) if e != nil || aws.ToString(got.VersionId) == "" { return Version{}, ErrHeld } v, exists, e := s.Observe(ctx, key, aws.ToString(got.VersionId)) if e != nil || !exists { return Version{}, ErrHeld } return v, nil } func (s *S3Backend) Delete(ctx context.Context, key string, v Version) error { if !validVersion(v) { return ErrConflict } _, e := s.Client.DeleteObject(ctx, &s3.DeleteObjectInput{Bucket: aws.String(s.Bucket), Key: aws.String(key), VersionId: aws.String(v.ID)}, func(o *s3.Options) { o.RetryMaxAttempts = 1 }) if e != nil { return ErrHeld } return nil }