diff --git a/.github/workflows/s3-tigris-compat-tests.yml b/.github/workflows/s3-tigris-compat-tests.yml new file mode 100644 index 0000000000..dbdb9f8cb0 --- /dev/null +++ b/.github/workflows/s3-tigris-compat-tests.yml @@ -0,0 +1,57 @@ +name: "S3 Tigris Compatibility Tests" + +on: + push: + branches: [ master ] + paths: + - 'weed/s3api/**' + - 'weed/server/filer_server_handlers_*.go' + - 'test/s3/tigris_compat/**' + - '.github/workflows/s3-tigris-compat-tests.yml' + pull_request: + branches: [ master ] + paths: + - 'weed/s3api/**' + - 'weed/server/filer_server_handlers_*.go' + - 'test/s3/tigris_compat/**' + - '.github/workflows/s3-tigris-compat-tests.yml' + +concurrency: + group: ${{ github.workflow }}-${{ github.event.pull_request.number || (github.event_name == 'push' && github.ref) || github.run_id }} + cancel-in-progress: ${{ github.event_name == 'pull_request' || (github.event_name == 'push' && !startsWith(github.ref, 'refs/tags/')) }} + +permissions: + contents: read + +jobs: + s3-tigris-compat-tests: + name: s3-api-compat-tests (Tigris) + runs-on: ubuntu-24.04 + timeout-minutes: 20 + steps: + - name: Check out code + uses: actions/checkout@v7 + + - name: Set up Go + uses: actions/setup-go@v7 + with: + go-version-file: 'go.mod' + cache: ${{ runner.environment == 'github-hosted' }} + + - name: Run s3-api-compat-tests + working-directory: test/s3/tigris_compat + run: make test + + - name: Show server log on failure + if: failure() + working-directory: test/s3/tigris_compat + run: tail -200 weed-test.log || true + + - name: Upload report + if: always() + uses: actions/upload-artifact@v7 + with: + name: s3-tigris-compat-results + path: test/s3/tigris_compat/results.json + if-no-files-found: ignore + retention-days: 7 diff --git a/test/s3/acl/s3_ownership_controls_test.go b/test/s3/acl/s3_ownership_controls_test.go index 257908b88d..5d5127f1da 100644 --- a/test/s3/acl/s3_ownership_controls_test.go +++ b/test/s3/acl/s3_ownership_controls_test.go @@ -2,13 +2,16 @@ package acl import ( "context" + "net/http" "strings" "testing" "time" "github.com/aws/aws-sdk-go-v2/aws" + awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" "github.com/aws/aws-sdk-go-v2/service/s3" "github.com/aws/aws-sdk-go-v2/service/s3/types" + smithyhttp "github.com/aws/smithy-go/transport/http" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) @@ -63,12 +66,22 @@ func TestBucketOwnershipControlsLifecycle(t *testing.T) { putObjectOwnership(t, client, bucketName, types.ObjectOwnershipBucketOwnerEnforced) assert.Equal(t, types.ObjectOwnershipBucketOwnerEnforced, getObjectOwnership(t, client, bucketName)) - _, err := client.DeleteBucketOwnershipControls(context.TODO(), &s3.DeleteBucketOwnershipControlsInput{ + deleted, err := client.DeleteBucketOwnershipControls(context.TODO(), &s3.DeleteBucketOwnershipControlsInput{ Bucket: aws.String(bucketName), }) require.NoError(t, err) + raw, ok := awsmiddleware.GetRawResponse(deleted.ResultMetadata).(*smithyhttp.Response) + require.True(t, ok) + assert.Equal(t, http.StatusNoContent, raw.StatusCode) - assert.Equal(t, types.ObjectOwnershipBucketOwnerEnforced, getObjectOwnership(t, client, bucketName)) + _, err = client.GetBucketOwnershipControls(context.TODO(), &s3.GetBucketOwnershipControlsInput{ + Bucket: aws.String(bucketName), + }) + require.Error(t, err) + assert.Contains(t, err.Error(), "OwnershipControlsNotFoundError") + + putObjectOwnership(t, client, bucketName, types.ObjectOwnershipBucketOwnerPreferred) + assert.Equal(t, types.ObjectOwnershipBucketOwnerPreferred, getObjectOwnership(t, client, bucketName)) } // A bucket with nothing stored already reports BucketOwnerEnforced, so this put has diff --git a/test/s3/tigris_compat/.gitignore b/test/s3/tigris_compat/.gitignore new file mode 100644 index 0000000000..8ff527ae7c --- /dev/null +++ b/test/s3/tigris_compat/.gitignore @@ -0,0 +1,6 @@ +s3-api-compat-tests/ +test-volume-data/ +compat-runner +results.json +weed-test.log +weed-server.pid diff --git a/test/s3/tigris_compat/Makefile b/test/s3/tigris_compat/Makefile new file mode 100644 index 0000000000..a31f818ca3 --- /dev/null +++ b/test/s3/tigris_compat/Makefile @@ -0,0 +1,115 @@ +# Runs https://github.com/tigrisdata-community/s3-api-compat-tests against a +# local SeaweedFS S3 gateway and compares the report with expected_failures.txt. + +.PHONY: all test help build-weed build-suite start-server stop-server run-suite test-with-server logs clean + +SUITE_REPO := https://github.com/tigrisdata-community/s3-api-compat-tests.git +SUITE_COMMIT := e846275e489ec30b324344d462e698252c3a1f67 +SUITE_DIR := s3-api-compat-tests + +WEED_BINARY := ../../../weed/weed_binary +S3_PORT ?= 8335 +MASTER_PORT ?= 9335 +VOLUME_PORT ?= 8085 +FILER_PORT ?= 8889 +WEBDAV_PORT ?= 7335 +ADMIN_PORT ?= 23647 +SERVER_DIR := ./test-volume-data +S3_CONFIG := ./test_s3.json + +.DEFAULT_GOAL := help + +all: test + +test: test-with-server + +help: + @echo "s3-api-compat-tests (Tigris) against SeaweedFS" + @echo "" + @echo " build-weed - Build the SeaweedFS binary" + @echo " build-suite - Fetch the suite at $(SUITE_COMMIT) and build it" + @echo " start-server - Start weed mini with S3 on port $(S3_PORT)" + @echo " run-suite - Run the suite and check expected_failures.txt" + @echo " stop-server - Stop the test server" + @echo " test-with-server - Start server, run suite, stop server" + @echo " logs - Show server logs" + @echo " clean - Remove test artifacts" + +build-weed: + @cd ../../../weed && go build -o weed_binary . + +build-suite: + @if [ "$$(git -C $(SUITE_DIR) rev-parse HEAD 2>/dev/null)" != "$(SUITE_COMMIT)" ]; then \ + rm -rf $(SUITE_DIR) && mkdir -p $(SUITE_DIR) && \ + git -C $(SUITE_DIR) init -q && \ + git -C $(SUITE_DIR) fetch -q --depth 1 $(SUITE_REPO) $(SUITE_COMMIT) && \ + git -C $(SUITE_DIR) checkout -q FETCH_HEAD && \ + git -C $(SUITE_DIR) apply ../seaweedfs-provider.patch; \ + fi + @cd $(SUITE_DIR) && go build -o ../compat-runner . + +start-server: build-weed + @rm -f weed-server.pid + @mkdir -p $(SERVER_DIR) + @if curl -sS -o /dev/null http://127.0.0.1:$(S3_PORT)/ >/dev/null 2>&1; then \ + echo "port $(S3_PORT) is already served by another process; refusing to test against it"; \ + exit 1; \ + fi + @$(WEED_BINARY) mini \ + -dir=$(SERVER_DIR) \ + -ip=127.0.0.1 \ + -ip.bind=127.0.0.1 \ + -master.port=$(MASTER_PORT) \ + -volume.port=$(VOLUME_PORT) \ + -filer.port=$(FILER_PORT) \ + -webdav.port=$(WEBDAV_PORT) \ + -admin.port=$(ADMIN_PORT) \ + -admin.port.legacy=0 \ + -s3.port=$(S3_PORT) \ + -s3.config=$(S3_CONFIG) \ + -master.peers=none \ + > weed-test.log 2>&1 & echo $$! > weed-server.pid + @for i in $$(seq 1 60); do \ + kill -0 $$(cat weed-server.pid) 2>/dev/null || { \ + echo "SeaweedFS server exited during startup"; \ + cat weed-test.log; \ + exit 1; \ + }; \ + if curl -sS -o /dev/null http://127.0.0.1:$(S3_PORT)/ >/dev/null 2>&1; then \ + echo "SeaweedFS S3 server is ready on port $(S3_PORT)"; \ + exit 0; \ + fi; \ + sleep 1; \ + done; \ + echo "SeaweedFS S3 server failed to start"; \ + cat weed-test.log; \ + $(MAKE) --no-print-directory stop-server; \ + exit 1 + +stop-server: + @if [ -f weed-server.pid ]; then \ + pid=$$(cat weed-server.pid); \ + if ps -p $$pid -o comm= 2>/dev/null | grep -q weed; then \ + kill $$pid 2>/dev/null || true; \ + sleep 2; \ + fi; \ + rm -f weed-server.pid; \ + fi + +run-suite: build-suite + SEAWEEDFS_S3_ENDPOINT=http://127.0.0.1:$(S3_PORT) \ + SEAWEEDFS_S3_ACCESS_KEY_ID=admin \ + SEAWEEDFS_S3_SECRET_ACCESS_KEY=admin \ + ./compat-runner --providers=seaweedfs --output=results.json + python3 check_results.py results.json expected_failures.txt + +test-with-server: + @$(MAKE) start-server; START_RESULT=$$?; \ + if [ $$START_RESULT -eq 0 ]; then $(MAKE) run-suite; TEST_RESULT=$$?; else TEST_RESULT=$$START_RESULT; fi; \ + $(MAKE) stop-server; exit $$TEST_RESULT + +logs: + @test -f weed-test.log && tail -100 weed-test.log || echo "No log file found" + +clean: stop-server + @rm -rf $(SERVER_DIR) $(SUITE_DIR) compat-runner results.json weed-test.log weed-server.pid diff --git a/test/s3/tigris_compat/check_results.py b/test/s3/tigris_compat/check_results.py new file mode 100644 index 0000000000..3d81168358 --- /dev/null +++ b/test/s3/tigris_compat/check_results.py @@ -0,0 +1,61 @@ +#!/usr/bin/env python3 +"""Compare an s3-api-compat-tests JSON report with expected_failures.txt. + +Fails on any test that did not pass and is not listed, and on any listed test +that now passes or did not run, so the list only ever shrinks. +""" +import json +import sys + + +def load_expected(path): + expected = set() + with open(path) as f: + for line in f: + name = line.split("#", 1)[0].strip() + if name: + expected.add(name) + return expected + + +def main(): + if len(sys.argv) != 3: + sys.exit("usage: check_results.py ") + with open(sys.argv[1]) as f: + report = json.load(f) + expected = load_expected(sys.argv[2]) + + providers = report.get("providers") or [] + results = providers[0].get("results") if providers else None + if not results: + sys.exit("no test results in the report: the suite could not start against the server") + + seen = set() + regressions, fixed = [], [] + for r in results: + name, status = r["operation"], r["status"] + seen.add(name) + detail = r.get("error") or r.get("notes") or "" + if status == "pass": + if name in expected: + fixed.append(name) + elif name not in expected: + regressions.append(f"{name} [{status}]: {detail}") + else: + print(f"expected failure: {name} [{status}]") + + missing = sorted(expected - seen) + print(f"{len(results)} tests, {len(regressions)} unexpected failures, " + f"{len(fixed)} unexpected passes, {len(missing)} listed but not run") + for line in regressions: + print(f"UNEXPECTED FAILURE: {line}") + for name in fixed: + print(f"UNEXPECTED PASS: {name} (remove it from expected_failures.txt)") + for name in missing: + print(f"NOT RUN: {name} (remove it from expected_failures.txt)") + if regressions or fixed or missing: + sys.exit(1) + + +if __name__ == "__main__": + main() diff --git a/test/s3/tigris_compat/expected_failures.txt b/test/s3/tigris_compat/expected_failures.txt new file mode 100644 index 0000000000..469e2f09b0 --- /dev/null +++ b/test/s3/tigris_compat/expected_failures.txt @@ -0,0 +1,22 @@ +# Tests from s3-api-compat-tests that SeaweedFS is expected to fail. +# check_results.py fails CI on any other failure, and on any test listed here +# that passes, so remove an entry together with the fix that makes it pass. + +# AWS answers GetBucketPolicyStatus on a bucket without a policy with +# NoSuchBucketPolicy, and so does SeaweedFS; the suite expects a status. +GetBucketPolicyStatus + +# Glacier restore: SeaweedFS has no archive storage class to restore from, and +# AWS also refuses RestoreObject on a STANDARD object (InvalidObjectState). +RestoreObject + +# SeaweedFS reads x-amz-rename-source as a literal key first and then, when it +# starts with the request's bucket, as bucket/key, because AWS documents both +# spellings. A leading slash is dropped since filer paths cannot hold it. +RenameObject_SourceIsLiteralKey + +# Not yet fixed in SeaweedFS. +PutBucketAccelerateConfiguration +GetBucketAccelerateConfiguration +PutBucketNotificationConfiguration +PutObjectTagging_VersionId diff --git a/test/s3/tigris_compat/seaweedfs-provider.patch b/test/s3/tigris_compat/seaweedfs-provider.patch new file mode 100644 index 0000000000..34ae8b6e3f --- /dev/null +++ b/test/s3/tigris_compat/seaweedfs-provider.patch @@ -0,0 +1,19 @@ +diff --git a/providers.go b/providers.go +index 149f94c..bc7aeeb 100644 +--- a/providers.go ++++ b/providers.go +@@ -180,6 +180,14 @@ func (p *Provider) CreateVersionedBucket(ctx context.Context, client *s3.Client, + // If names is non-empty, only those named providers are returned. + func LoadProviders(names []string) []Provider { + all := []Provider{ ++ { ++ Name: "seaweedfs", ++ Endpoint: os.Getenv("SEAWEEDFS_S3_ENDPOINT"), ++ Region: envOr("SEAWEEDFS_S3_REGION", "us-east-1"), ++ PathStyle: true, ++ AccessKey: os.Getenv("SEAWEEDFS_S3_ACCESS_KEY_ID"), ++ SecretKey: os.Getenv("SEAWEEDFS_S3_SECRET_ACCESS_KEY"), ++ }, + { + Name: "tigris", + Endpoint: "https://t3.storage.dev", diff --git a/test/s3/tigris_compat/test_s3.json b/test/s3/tigris_compat/test_s3.json new file mode 100644 index 0000000000..1f9b460008 --- /dev/null +++ b/test/s3/tigris_compat/test_s3.json @@ -0,0 +1,20 @@ +{ + "identities": [ + { + "name": "admin", + "credentials": [ + { + "accessKey": "admin", + "secretKey": "admin" + } + ], + "actions": [ + "Admin", + "Read", + "List", + "Tagging", + "Write" + ] + } + ] +} diff --git a/weed/s3api/s3_constants/extend_key.go b/weed/s3api/s3_constants/extend_key.go index 00c256e1ef..be89e13399 100644 --- a/weed/s3api/s3_constants/extend_key.go +++ b/weed/s3api/s3_constants/extend_key.go @@ -5,6 +5,7 @@ const ( ExtAmzOwnerKey = "Seaweed-X-Amz-Owner" ExtAmzAclKey = "Seaweed-X-Amz-Acl" ExtOwnershipKey = "Seaweed-X-Amz-Ownership" + ExtOwnershipDeletedKey = "Seaweed-X-Amz-Ownership-Deleted" ExtPublicAccessBlockKey = "Seaweed-X-Amz-Public-Access-Block" ExtVersioningKey = "Seaweed-X-Amz-Versioning" ExtVersionIdKey = "Seaweed-X-Amz-Version-Id" diff --git a/weed/s3api/s3api_bucket_config.go b/weed/s3api/s3api_bucket_config.go index 5b5a884376..77e3c8d4a9 100644 --- a/weed/s3api/s3api_bucket_config.go +++ b/weed/s3api/s3api_bucket_config.go @@ -36,6 +36,7 @@ type BucketConfig struct { Name string Versioning string // "Enabled", "Suspended", or "" Ownership string + OwnershipDeleted bool // DeleteBucketOwnershipControls removed it; GET reports none ACL []byte Owner string IdentityId string // identity that created the bucket @@ -432,6 +433,7 @@ func (s3a *S3ApiServer) newBucketConfigFromEntry(bucket string, entry *filer_pb. if ownership, exists := entry.Extended[s3_constants.ExtOwnershipKey]; exists { config.Ownership = string(ownership) } + config.OwnershipDeleted = len(entry.Extended[s3_constants.ExtOwnershipDeletedKey]) > 0 if data, exists := entry.Extended[s3_constants.ExtPublicAccessBlockKey]; exists && len(data) > 0 { if pab, err := parsePublicAccessBlock(data); err == nil { config.PublicAccessBlock = pab @@ -587,6 +589,11 @@ func applyBucketConfigToExtended(config *BucketConfig, ext map[string][]byte) er } setOrDelete(s3_constants.ExtVersioningKey, []byte(config.Versioning)) setOrDelete(s3_constants.ExtOwnershipKey, []byte(config.Ownership)) + if config.OwnershipDeleted && config.Ownership == "" { + ext[s3_constants.ExtOwnershipDeletedKey] = []byte("true") + } else { + delete(ext, s3_constants.ExtOwnershipDeletedKey) + } if config.PublicAccessBlock != nil { data, err := xml.Marshal(config.PublicAccessBlock) if err != nil { @@ -767,6 +774,9 @@ func (s3a *S3ApiServer) getBucketOwnership(bucket string) (string, s3err.ErrorCo if errCode != s3err.ErrNone { return "", errCode } + if config.OwnershipDeleted && config.Ownership == "" { + return "", s3err.OwnershipControlsNotFoundError + } return s3_constants.EffectiveOwnership(config.Ownership), s3err.ErrNone } diff --git a/weed/s3api/s3api_bucket_handlers.go b/weed/s3api/s3api_bucket_handlers.go index 1d734c164a..e905caf978 100644 --- a/weed/s3api/s3api_bucket_handlers.go +++ b/weed/s3api/s3api_bucket_handlers.go @@ -1505,7 +1505,7 @@ func (s3a *S3ApiServer) GetBucketOwnershipControls(w http.ResponseWriter, r *htt // DeleteBucketOwnershipControls https://docs.aws.amazon.com/AmazonS3/latest/API/API_DeleteBucketOwnershipControls.html func (s3a *S3ApiServer) DeleteBucketOwnershipControls(w http.ResponseWriter, r *http.Request) { bucket, _ := s3_constants.GetBucketAndObject(r) - glog.V(3).Infof("PutBucketOwnershipControls %s", bucket) + glog.V(3).Infof("DeleteBucketOwnershipControls %s", bucket) errCode := s3a.checkAccessByOwnership(r, bucket) if errCode != s3err.ErrNone { @@ -1529,17 +1529,16 @@ func (s3a *S3ApiServer) DeleteBucketOwnershipControls(w http.ResponseWriter, r * return } - delete(bucketEntry.Extended, s3_constants.ExtOwnershipKey) - err = s3a.updateEntry(s3a.option.BucketsPath, bucketEntry) - if err != nil { - s3err.WriteErrorResponse(w, r, s3err.ErrInternalError) + if errCode := s3a.updateBucketConfig(bucket, func(config *BucketConfig) error { + config.Ownership = "" + config.OwnershipDeleted = true + return nil + }); errCode != s3err.ErrNone { + s3err.WriteErrorResponse(w, r, errCode) return } - emptyOwnershipControls := &s3.OwnershipControls{ - Rules: []*s3.OwnershipControlsRule{}, - } - s3err.WriteAwsXMLResponse(w, r, http.StatusOK, emptyOwnershipControls) + s3err.WriteEmptyResponse(w, r, http.StatusNoContent) } // GetBucketVersioningHandler Get Bucket Versioning status diff --git a/weed/s3api/s3api_bucket_handlers_misc_test.go b/weed/s3api/s3api_bucket_handlers_misc_test.go index a9f2058f8c..97479748f3 100644 --- a/weed/s3api/s3api_bucket_handlers_misc_test.go +++ b/weed/s3api/s3api_bucket_handlers_misc_test.go @@ -207,6 +207,55 @@ func TestGetBucketOwnershipControlsDefaultsToBucketOwnerEnforced(t *testing.T) { } } +func TestGetBucketOwnershipControlsAfterDelete(t *testing.T) { + ownerID := AccountAdmin.Id + s3a := newMiscTestServer(t, "b") + s3a.bucketConfigCache.Set("b", &BucketConfig{Name: "b", OwnershipDeleted: true}) + s3a.bucketRegistry = NewBucketRegistry(nil) + s3a.bucketRegistry.setMetadataCache(&BucketMetaData{ + Name: "b", + Owner: &s3.Owner{ID: &ownerID}, + }) + req := newBucketRequest(http.MethodGet, "b", "ownershipControls=", "") + req.Header.Set(s3_constants.AmzAccountId, AccountAdmin.Id) + req = req.WithContext(s3_constants.SetIdentityInContext(req.Context(), &Identity{ + Name: "admin", + Account: &AccountAdmin, + Actions: []Action{s3_constants.ACTION_ADMIN}, + })) + rec := httptest.NewRecorder() + + s3a.GetBucketOwnershipControls(rec, req) + + if rec.Code != http.StatusNotFound || !strings.Contains(rec.Body.String(), "OwnershipControlsNotFoundError") { + t.Fatalf("status = %d, body=%s, want 404 OwnershipControlsNotFoundError", rec.Code, rec.Body.String()) + } +} + +func TestBucketConfigOwnershipDeletedRoundTrip(t *testing.T) { + s3a := &S3ApiServer{} + ext := map[string][]byte{s3_constants.ExtOwnershipKey: []byte(s3_constants.OwnershipObjectWriter)} + + deleted := &BucketConfig{OwnershipDeleted: true} + if err := applyBucketConfigToExtended(deleted, ext); err != nil { + t.Fatal(err) + } + if _, ok := ext[s3_constants.ExtOwnershipKey]; ok { + t.Fatalf("ownership still stored after delete: %v", ext) + } + if got := s3a.newBucketConfigFromEntry("b", &filer_pb.Entry{Extended: ext}); !got.OwnershipDeleted || got.Ownership != "" { + t.Fatalf("reloaded config = %+v, want deleted ownership", got) + } + + put := &BucketConfig{Ownership: s3_constants.OwnershipBucketOwnerEnforced, OwnershipDeleted: true} + if err := applyBucketConfigToExtended(put, ext); err != nil { + t.Fatal(err) + } + if got := s3a.newBucketConfigFromEntry("b", &filer_pb.Entry{Extended: ext}); got.OwnershipDeleted || got.Ownership != s3_constants.OwnershipBucketOwnerEnforced { + t.Fatalf("reloaded config = %+v, want stored BucketOwnerEnforced", got) + } +} + func TestGetBucketAccelerateConfiguration(t *testing.T) { s3a := newMiscTestServer(t, "b") req := newBucketRequest(http.MethodGet, "b", "accelerate=", "")