build: gate releases on Object Lock regressions

Signed-off-by: Feng Ruohang <rh@vonng.com>

cmd/erasure-metadata-utils_test.go

@@ -20,7 +20,6 @@ package cmd
 import (
 	"context"
 	"encoding/hex"
-	"errors"
 	"fmt"
 	"math/rand"
 	"reflect"
@@ -111,96 +110,6 @@ func TestReduceErrs(t *testing.T) {
 	}
 }
 
-// TestReduceWriteQuorumErrsCommitMetaMissing verifies that an in-quorum
-// errCommitMetaMissing reduces to the sentinel, which renameData() converts
-// to errErasureWriteQuorum, while below-quorum reduces directly to
-// errErasureWriteQuorum.
-func TestReduceWriteQuorumErrsCommitMetaMissing(t *testing.T) {
-	errs := make([]error, 16)
-	for i := range 9 {
-		errs[i] = errCommitMetaMissing
-	}
-	if err := reduceWriteQuorumErrs(t.Context(), errs, objectOpIgnoredErrs, 9); !errors.Is(err, errCommitMetaMissing) {
-		t.Errorf("expected %s, got %s", errCommitMetaMissing, err)
-	}
-	// The sentinel must be distinguishable from errFileNotFound so that
-	// commit failures are never mapped to ObjectNotFound (404).
-	if errors.Is(errCommitMetaMissing, errFileNotFound) {
-		t.Error("errCommitMetaMissing must not match errFileNotFound")
-	}
-
-	// Below quorum the reduction must yield a write-quorum failure (503);
-	// eight sentinels against eight committed drives is not a quorum.
-	belowQuorum := make([]error, 16)
-	for i := range 8 {
-		belowQuorum[i] = errCommitMetaMissing
-	}
-	if err := reduceWriteQuorumErrs(t.Context(), belowQuorum, objectOpIgnoredErrs, 9); !errors.Is(err, errErasureWriteQuorum) {
-		t.Errorf("expected %s, got %s", errErasureWriteQuorum, err)
-	}
-}
-
-// renameDataFailingDisk is a StorageAPI stub returning a fixed error
-// from RenameData, enough to drive renameData() in unit tests.
-type renameDataFailingDisk struct {
-	StorageAPI
-	err       error
-	undoWrite bool
-}
-
-func (d *renameDataFailingDisk) RenameData(context.Context, string, string, FileInfo, string, string, RenameOptions) (RenameDataResp, error) {
-	return RenameDataResp{}, d.err
-}
-
-func (d *renameDataFailingDisk) DeleteVersion(_ context.Context, _, _ string, _ FileInfo, _ bool, opts DeleteOptions) error {
-	d.undoWrite = opts.UndoWrite
-	return nil
-}
-
-// TestRenameDataCommitMetaMissing verifies that renameData() converts an
-// in-quorum errCommitMetaMissing into errErasureWriteQuorum (HTTP 503),
-// while an in-quorum errFileNotFound keeps its meaning so that
-// PutObject() still reports IncompleteBody for client disconnects.
-func TestRenameDataCommitMetaMissing(t *testing.T) {
-	for _, tc := range []struct {
-		name     string
-		failures int
-		diskErr  error
-		wantErr  error
-	}{
-		{"all_commit_metadata_missing", 16, errCommitMetaMissing, errErasureWriteQuorum},
-		{"quorum_commit_metadata_missing", 9, errCommitMetaMissing, errErasureWriteQuorum},
-		{"neither_side_has_quorum", 8, errCommitMetaMissing, errErasureWriteQuorum},
-		{"successful_write_quorum", 7, errCommitMetaMissing, nil},
-		{"staging_failure", 16, errFileNotFound, errFileNotFound},
-	} {
-		t.Run(tc.name, func(t *testing.T) {
-			metadata := make([]FileInfo, 16)
-			disks := make([]StorageAPI, 16)
-			for i := range disks {
-				metadata[i] = FileInfo{Deleted: true} // valid without erasure info
-				disk := &renameDataFailingDisk{}
-				if i < tc.failures {
-					disk.err = tc.diskErr
-				}
-				disks[i] = disk
-			}
-			_, _, _, err := renameData(t.Context(), disks, minioMetaTmpBucket, "tmp", metadata, "bucket", "object", 9)
-			if !errors.Is(err, tc.wantErr) {
-				t.Fatalf("expected %v, got %v", tc.wantErr, err)
-			}
-			for i, disk := range disks {
-				// Failed writes undo only the drives that committed. A
-				// successful quorum must never be rolled back.
-				wantUndo := tc.wantErr != nil && i >= tc.failures
-				if got := disk.(*renameDataFailingDisk).undoWrite; got != wantUndo {
-					t.Errorf("disk %d: UndoWrite = %v, want %v", i, got, wantUndo)
-				}
-			}
-		})
-	}
-}
-
 // TestHashOrder - test order of ints in array
 func TestHashOrder(t *testing.T) {
 	testCases := []struct {

cmd/erasure-multipart-cleanup_test.go

@@ -1,177 +0,0 @@
-// Copyright (c) 2026 clown15
-//
-// This file is part of Silo Object Storage stack
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-package cmd
-
-import (
-	"context"
-	"encoding/base64"
-	"fmt"
-	"net/url"
-	"os"
-	"path/filepath"
-	"testing"
-	"time"
-)
-
-func TestExtractModTimeFromUploadIDDir(t *testing.T) {
-	now := time.Unix(1792056747, 123456789).UTC()
-	nano := now.UnixNano()
-	uuid := "d16ad42a-6fe5-4a3b-8092-69983142238f"
-
-	testCases := []struct {
-		name        string
-		dirName     string
-		expectedMod time.Time
-		wantZero    bool
-	}{
-		{
-			name:        "Modern Plaintext Format (<UUID>x<UnixNano>)",
-			dirName:     fmt.Sprintf("%sx%d", uuid, nano),
-			expectedMod: time.Unix(0, nano),
-			wantZero:    false,
-		},
-		{
-			// This valid UUID decodes to bytes containing 'x'. Checking
-			// for that byte before parsing plaintext loses the timestamp.
-			name:        "Plaintext Also Decodes To Base64 Containing x",
-			dirName:     fmt.Sprintf("4eacd477-e733-4851-b821-6fd42785ff87x%d", nano),
-			expectedMod: now,
-		},
-		{
-			name:        "Legacy Format Without Timestamp (<UUID>)",
-			dirName:     uuid,
-			expectedMod: time.Time{},
-			wantZero:    true,
-		},
-		{
-			name:        "Base64 Encoded Format",
-			dirName:     base64.RawURLEncoding.EncodeToString([]byte(fmt.Sprintf("%sx%d", uuid, nano))),
-			expectedMod: time.Unix(0, nano),
-			wantZero:    false,
-		},
-		{
-			name:        "Encoded Format With Deployment Prefix",
-			dirName:     base64.RawURLEncoding.EncodeToString([]byte(fmt.Sprintf("%s.%sx%d", uuid, uuid, nano))),
-			expectedMod: now,
-		},
-		{
-			name:        "Malformed Suffix (<UUID>xinvalid)",
-			dirName:     fmt.Sprintf("%sxnotanumber", uuid),
-			expectedMod: time.Time{},
-			wantZero:    true,
-		},
-		{
-			name:     "Timestamp Overflow",
-			dirName:  uuid + "x9223372036854775808",
-			wantZero: true,
-		},
-		{
-			name:     "Malformed Plaintext UUID",
-			dirName:  fmt.Sprintf("not-a-uuidx%d", nano),
-			wantZero: true,
-		},
-		{
-			name:        "Empty Directory Name",
-			dirName:     "",
-			expectedMod: time.Time{},
-			wantZero:    true,
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			got := extractModTimeFromUploadIDDir(tc.dirName)
-			if tc.wantZero {
-				if !got.IsZero() {
-					t.Fatalf("expected zero time for %q, got %v", tc.dirName, got)
-				}
-				return
-			}
-			if !got.Equal(tc.expectedMod) {
-				t.Fatalf("extractModTimeFromUploadIDDir(%q) = %v; want %v", tc.dirName, got, tc.expectedMod)
-			}
-		})
-	}
-}
-
-type multipartCleanupDisk struct {
-	StorageAPI
-	root    string
-	modTime time.Time
-	readErr error
-	reads   int
-}
-
-func (d *multipartCleanupDisk) Endpoint() Endpoint {
-	return Endpoint{URL: &url.URL{Path: d.root}}
-}
-
-func (d *multipartCleanupDisk) ReadVersion(context.Context, string, string, string, string, ReadOptions) (FileInfo, error) {
-	d.reads++
-	return FileInfo{ModTime: d.modTime}, d.readErr
-}
-
-func (d *multipartCleanupDisk) StatVol(context.Context, string) (VolInfo, error) {
-	return VolInfo{Created: time.Now()}, nil
-}
-
-func TestCleanupStaleUploadsOnDisk(t *testing.T) {
-	const uuid = "d16ad42a-6fe5-4a3b-8092-69983142238f"
-	expiry := globalAPIConfig.getStaleUploadsExpiry()
-	for _, tc := range []struct {
-		name, prefix string
-		age          time.Duration
-		legacy       bool
-		readErr      error
-		wantReads    int
-		wantDeleted  bool
-	}{
-		{name: "recent", prefix: uuid, age: expiry / 2, readErr: errFileNotFound},
-		{name: "plaintext_base64_collision", prefix: "4eacd477-e733-4851-b821-6fd42785ff87", age: expiry / 2, readErr: errFileNotFound},
-		{name: "expired", prefix: uuid, age: 2 * expiry, readErr: errFileNotFound, wantDeleted: true},
-		{name: "legacy_recent", prefix: uuid, age: expiry / 2, legacy: true, wantReads: 1},
-		{name: "legacy_expired", prefix: uuid, age: 2 * expiry, legacy: true, wantReads: 1, wantDeleted: true},
-		{name: "legacy_metadata_missing", prefix: uuid, age: 2 * expiry, legacy: true, readErr: errFileNotFound, wantReads: 1},
-		{name: "malformed_metadata_missing", prefix: "not-a-uuid", age: 2 * expiry, readErr: errFileNotFound, wantReads: 1},
-	} {
-		t.Run(tc.name, func(t *testing.T) {
-			modTime := time.Now().Add(-tc.age)
-			id := tc.prefix
-			if !tc.legacy {
-				id = fmt.Sprintf("%sx%d", tc.prefix, modTime.UnixNano())
-			}
-			disk := &multipartCleanupDisk{root: t.TempDir(), modTime: modTime, readErr: tc.readErr}
-			uploadDir := filepath.Join(disk.root, minioMetaMultipartBucket, "sha", id)
-			if err := os.MkdirAll(uploadDir, 0o755); err != nil {
-				t.Fatal(err)
-			}
-			erasureObjects{}.cleanupStaleUploadsOnDisk(t.Context(), disk)
-			if disk.reads != tc.wantReads {
-				t.Errorf("ReadVersion calls = %d, want %d", disk.reads, tc.wantReads)
-			}
-			_, err := os.Stat(uploadDir)
-			if tc.wantDeleted {
-				if !os.IsNotExist(err) {
-					t.Errorf("expired upload must be removed: %v", err)
-				}
-			} else if err != nil {
-				t.Errorf("upload must be preserved: %v", err)
-			}
-		})
-	}
-}

cmd/erasure-multipart.go

@@ -174,24 +174,6 @@ func (er erasureObjects) deleteAll(ctx context.Context, bucket, prefix string) {
 	wg.Wait()
 }
 
-// extractModTimeFromUploadIDDir extracts creation time from the upload ID directory on disk.
-// On-disk directory names are of the form <UUID>x<UnixNano>.
-// Parse the native format first: plaintext UUIDs can also be valid Base64.
-// Preserve the previous encoded-format parser for compatibility.
-func extractModTimeFromUploadIDDir(uploadIDDir string) time.Time {
-	if modTime, ok := multipartUploadTime(uploadIDDir); ok {
-		return modTime
-	}
-	if b64, err := base64.RawURLEncoding.DecodeString(uploadIDDir); err == nil {
-		if split := strings.Split(string(b64), "x"); len(split) == 2 {
-			if t, err := strconv.ParseInt(split[1], 10, 64); err == nil {
-				return time.Unix(0, t)
-			}
-		}
-	}
-	return time.Time{}
-}
-
 // Remove the old multipart uploads on the given disk.
 func (er erasureObjects) cleanupStaleUploadsOnDisk(ctx context.Context, disk StorageAPI) {
 	drivePath := disk.Endpoint().Path
@@ -199,7 +181,16 @@ func (er erasureObjects) cleanupStaleUploadsOnDisk(ctx context.Context, disk Sto
 	readDirFn(pathJoin(drivePath, minioMetaMultipartBucket), func(shaDir string, typ os.FileMode) error {
 		readDirFn(pathJoin(drivePath, minioMetaMultipartBucket, shaDir), func(uploadIDDir string, typ os.FileMode) error {
 			uploadIDPath := pathJoin(shaDir, uploadIDDir)
-			modTime := extractModTimeFromUploadIDDir(uploadIDDir)
+			var modTime time.Time
+			// Upload IDs are of the form base64_url(<UUID>x<UnixNano>), we can extract the time from the UUID.
+			if b64, err := base64.RawURLEncoding.DecodeString(uploadIDDir); err == nil {
+				if split := strings.Split(string(b64), "x"); len(split) == 2 {
+					t, err := strconv.ParseInt(split[1], 10, 64)
+					if err == nil {
+						modTime = time.Unix(0, t)
+					}
+				}
+			}
 			// Fallback for older uploads without time in the ID.
 			if modTime.IsZero() {
 				wait := deleteMultipartCleanupSleeper.Timer(ctx)

cmd/erasure-object.go

@@ -1083,12 +1083,6 @@ func renameData(ctx context.Context, disks []StorageAPI, srcBucket, srcEntry str
 	errs := g.Wait()
 
 	err := reduceWriteQuorumErrs(ctx, errs, objectOpIgnoredErrs, writeQuorum)
-	if errors.Is(err, errCommitMetaMissing) {
-		// Commit metadata went missing on a quorum of drives; the write
-		// did not commit. Return a 503 class error so clients retry
-		// instead of treating the object as absent (404).
-		err = errErasureWriteQuorum
-	}
 	if err != nil {
 		dg := errgroup.WithNErrs(len(disks))
 		for index, nerr := range errs {

cmd/object-api-errors.go

@@ -162,7 +162,7 @@ func toObjectErr(oerr error, params ...string) error {
 			apiErr.Type = v.Type
 		}
 		return apiErr
-	case errErasureWriteQuorum.Error(), errCommitMetaMissing.Error():
+	case errErasureWriteQuorum.Error():
 		apiErr := InsufficientWriteQuorum{}
 		if len(params) >= 1 {
 			apiErr.Bucket = params[0]

cmd/storage-errors.go

@@ -70,11 +70,6 @@ var errDiskAccessDenied = StorageErr("drive access denied")
 // errFileNotFound - cannot find the file.
 var errFileNotFound = StorageErr("file not found")
 
-// errCommitMetaMissing - the staged xl.meta disappeared between the
-// data rename and the meta-file commit; a write-quorum failure, not
-// a missing object.
-var errCommitMetaMissing = StorageErr("commit metadata is missing")
-
 // errFileNotFound - cannot find requested file version.
 var errFileVersionNotFound = StorageErr("file version not found")
 

cmd/storage-rest-client.go

@@ -106,8 +106,6 @@ func toStorageErr(err error) error {
 		return errVolumeExists
 	case errFileNotFound.Error():
 		return errFileNotFound
-	case errCommitMetaMissing.Error():
-		return errCommitMetaMissing
 	case errFileVersionNotFound.Error():
 		return errFileVersionNotFound
 	case errFileNameTooLong.Error():

cmd/xl-storage-errors_test.go

@@ -18,16 +18,10 @@
 package cmd
 
 import (
-	"context"
-	"errors"
-	"net/http"
 	"os"
-	"path/filepath"
 	"runtime"
-	"sync"
 	"syscall"
 	"testing"
-	"time"
 )
 
 func TestSysErrors(t *testing.T) {
@@ -62,120 +56,3 @@ func TestSysErrors(t *testing.T) {
 		}
 	}
 }
-
-// TestCommitMetaMissingMapping verifies the RPC and object-layer mapping
-// of errCommitMetaMissing, returned when the staged xl.meta disappears
-// between the data rename and the meta-file commit in RenameData().
-func TestCommitMetaMissingMapping(t *testing.T) {
-	// The sentinel must survive a storage REST/grid round-trip; errors
-	// cross the wire as strings and are remapped by toStorageErr().
-	if got := toStorageErr(errors.New(errCommitMetaMissing.Error())); !errors.Is(got, errCommitMetaMissing) {
-		t.Fatalf("expected %s, got %s", errCommitMetaMissing, got)
-	}
-	if got := toStorageErr(errCommitMetaMissing); got != errCommitMetaMissing {
-		t.Fatalf("expected %s, got %s", errCommitMetaMissing, got)
-	}
-
-	// toObjectErr() must map the sentinel to InsufficientWriteQuorum
-	// (503), never to ObjectNotFound (404).
-	err := toObjectErr(errCommitMetaMissing, "bucket", "object")
-	qerr, ok := err.(InsufficientWriteQuorum)
-	if !ok {
-		t.Fatalf("expected InsufficientWriteQuorum, got %s (%T)", err, err)
-	}
-	if qerr.Bucket != "bucket" || qerr.Object != "object" {
-		t.Fatalf("unexpected bucket/object %s/%s", qerr.Bucket, qerr.Object)
-	}
-	apiErr := toAPIError(t.Context(), err)
-	if apiErr.Code != "SlowDownWrite" || apiErr.HTTPStatusCode != http.StatusServiceUnavailable {
-		t.Fatalf("expected SlowDownWrite/503, got %+v", apiErr)
-	}
-}
-
-// missingCommitMetaContext removes staged metadata at an existing cancellation
-// check, after WriteAll and (for non-inline objects) the data rename succeeded.
-// This deterministically models concurrent cleanup without changing production
-// code or relying on a filesystem race. The context itself remains live.
-type missingCommitMetaContext struct {
-	context.Context
-	mu             sync.Mutex
-	meta, dataDest string
-	removed        bool
-	removeErr      error
-}
-
-func (c *missingCommitMetaContext) Done() <-chan struct{} {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-	if !c.removed {
-		if _, err := os.Stat(c.meta); err == nil {
-			dataMoved := c.dataDest == ""
-			if !dataMoved {
-				_, err = os.Stat(c.dataDest)
-				dataMoved = err == nil
-			}
-			if dataMoved {
-				c.removeErr = os.Remove(c.meta)
-				c.removed = c.removeErr == nil
-			}
-		}
-	}
-	return c.Context.Done()
-}
-
-func TestXLStorageRenameDataCommitMetaMissing(t *testing.T) {
-	for _, tc := range []struct {
-		name     string
-		dataFile bool
-	}{
-		{"empty_object", false},
-		{"data_directory", true},
-	} {
-		t.Run(tc.name, func(t *testing.T) {
-			disk, root, err := newXLStorageTestSetup(t)
-			if err != nil {
-				t.Fatal(err)
-			}
-			defer disk.Close()
-			s := disk.storage
-			if err := s.MakeVol(t.Context(), "bucket"); err != nil {
-				t.Fatal(err)
-			}
-			fi := newFileInfo("object", 2, 2)
-			fi.DataDir, fi.VersionID = mustGetUUID(), mustGetUUID()
-			fi.Erasure.Index = 1
-			fi.ModTime = time.Now().UTC()
-			fi.Fresh = true
-			ctx := &missingCommitMetaContext{
-				Context: t.Context(),
-				meta:    filepath.Join(root, minioMetaTmpBucket, "staged", xlStorageFormatFile),
-			}
-			if tc.dataFile {
-				fi.Size = 1
-				fi.AddObjectPart(1, "", 1, 1, fi.ModTime, nil, nil)
-				part := filepath.Join(root, minioMetaTmpBucket, "staged", fi.DataDir, "part.1")
-				if err := os.MkdirAll(filepath.Dir(part), 0o755); err != nil {
-					t.Fatal(err)
-				}
-				if err := os.WriteFile(part, []byte("a"), 0o644); err != nil {
-					t.Fatal(err)
-				}
-				ctx.dataDest = filepath.Join(root, "bucket", "object", fi.DataDir)
-			}
-			_, err = s.RenameData(ctx, minioMetaTmpBucket, "staged", fi, "bucket", "object", RenameOptions{})
-			if !ctx.removed {
-				t.Fatalf("metadata removal did not execute: removal error = %v, RenameData error = %v", ctx.removeErr, err)
-			}
-			if !errors.Is(err, errCommitMetaMissing) {
-				t.Fatalf("expected commit metadata missing, got %v", err)
-			}
-			apiErr := toAPIError(t.Context(), toObjectErr(err, "bucket", "object"))
-			if apiErr.Code != "SlowDownWrite" || apiErr.HTTPStatusCode != http.StatusServiceUnavailable {
-				t.Fatalf("expected SlowDownWrite/503, got %+v", apiErr)
-			}
-			if _, err := os.Stat(filepath.Join(root, "bucket", "object", xlStorageFormatFile)); !os.IsNotExist(err) {
-				t.Fatalf("failed commit must not produce destination metadata: %v", err)
-			}
-		})
-	}
-}

cmd/xl-storage.go

@@ -2925,15 +2925,7 @@ func (s *xlStorage) RenameData(ctx context.Context, srcVolume, srcPath string, f
 		// if its a partial rename() do not attempt to delete recursively.
 		// this can be healed since all parts are available.
 		s.deleteFile(dstVolumeDir, dstDataPath, false, false)
-		err = osErrToFileErr(err)
-		if errors.Is(err, errFileNotFound) {
-			// The staged xl.meta disappeared between staging and commit.
-			// This is a write-quorum failure, not a missing object; use a
-			// dedicated error so the object layer returns 503 instead of
-			// mapping it to ObjectNotFound (404).
-			err = errCommitMetaMissing
-		}
-		return res, err
+		return res, osErrToFileErr(err)
 	}
 
 	if srcVolume != minioMetaMultipartBucket {