Updates for force delete and prefix and delim bug

backend.go

@@ -180,6 +180,11 @@ type Backend interface {
 	// AWS does not validate the bucket's name for anything other than existence.
 	DeleteBucket(name string) error
 
+	// ForceDeleteBucket must delete a bucket and all its contents, regardless of
+	// whether the bucket is empty or not. This is useful for testing purposes
+	// where you need to clean up after yourself.
+	ForceDeleteBucket(name string) error
+
 	// GetObject must return a gofakes3.ErrNoSuchKey error if the object does
 	// not exist. See gofakes3.KeyNotFound() for a convenient way to create
 	// one.

backend/s3afero/multi.go

@@ -276,6 +276,36 @@
 	return rerr
 }
 
+func (db *MultiBucketBackend) ForceDeleteBucket(name string) error {
+	db.lock.Lock()
+	defer db.lock.Unlock()
+
+	// Delete all objects in the bucket
+	entries, err := afero.ReadDir(db.bucketFs, name)
+	if err != nil {
+		return err
+	}
+
+	for _, entry := range entries {
+		fullPath := path.Join(name, entry.Name())
+		if err := db.bucketFs.RemoveAll(fullPath); err != nil {
+			return err
+		}
+	}
+
+	// Delete the bucket itself
+	if err := db.bucketFs.RemoveAll(name); err != nil {
+		return err
+	}
+
+	// Delete bucket metadata
+	if err := db.metaStore.deleteBucket(name); err != nil {
+		return err
+	}
+
+	return nil
+}
+
 func (db *MultiBucketBackend) BucketExists(name string) (exists bool, err error) {
 	db.lock.Lock()
 	defer db.lock.Unlock()

backend/s3afero/single.go

@@ -459,6 +459,43 @@
 	return gofakes3.ErrNotImplemented
 }
 
+func (db *SingleBucketBackend) ForceDeleteBucket(name string) error {
+	if name != db.name {
+		return gofakes3.BucketNotFound(name)
+	}
+
+	db.lock.Lock()
+	defer db.lock.Unlock()
+
+	// Delete all objects in the bucket
+	var objects []string
+	err := afero.Walk(db.fs, ".", func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+		if !info.IsDir() {
+			objects = append(objects, path)
+		}
+		return nil
+	})
+	if err != nil {
+		return err
+	}
+
+	for _, object := range objects {
+		if err := db.deleteObjectLocked(name, object); err != nil {
+			return err
+		}
+	}
+
+	// Delete the bucket itself
+	if err := db.fs.RemoveAll("."); err != nil {
+		return err
+	}
+
+	return nil
+}
+
 func (db *SingleBucketBackend) BucketExists(name string) (exists bool, err error) {
 	return db.name == name, nil
 }

backend/s3bolt/backend.go

@@ -243,6 +243,46 @@ func (db *Backend) DeleteBucket(name string) error {
 	})
 }
 
+func (db *Backend) ForceDeleteBucket(name string) error {
+	nameBts := []byte(name)
+
+	if bytes.Equal(nameBts, db.metaBucketName) {
+		return gofakes3.ResourceError(gofakes3.ErrInvalidBucketName, name)
+	}
+
+	return db.bolt.Update(func(tx *bolt.Tx) error {
+		b := tx.Bucket(nameBts)
+		if b == nil {
+			return gofakes3.BucketNotFound(name)
+		}
+
+		// Delete all objects in the bucket
+		c := b.Cursor()
+		for k, _ := c.First(); k != nil; k, _ = c.Next() {
+			if err := b.Delete(k); err != nil {
+				return fmt.Errorf("gofakes3: delete failed for object %q in bucket %q", k, name)
+			}
+		}
+
+		// Delete bucket metadata
+		metaBucket, err := db.metaBucket(tx)
+		if err != nil {
+			return err
+		}
+
+		// FIXME: assumes a legacy database, where the bucket may not exist. Clean
+		// this up when there is a DB upgrade script.
+		if metaBucket != nil {
+			if err := metaBucket.deleteS3Bucket(name); err != nil {
+				return err
+			}
+		}
+
+		// Delete the bucket itself
+		return tx.DeleteBucket(nameBts)
+	})
+}
+
 func (db *Backend) BucketExists(name string) (exists bool, err error) {
 	err = db.bolt.View(func(tx *bolt.Tx) error {
 		b := tx.Bucket([]byte(name))

backend/s3mem/backend.go

@@ -165,6 +165,19 @@
 	return nil
 }
 
+func (db *Backend) ForceDeleteBucket(name string) error {
+	db.lock.Lock()
+	defer db.lock.Unlock()
+
+	if db.buckets[name] == nil {
+		return gofakes3.ErrNoSuchBucket
+	}
+
+	delete(db.buckets, name)
+
+	return nil
+}
+
 func (db *Backend) BucketExists(name string) (exists bool, err error) {
 	db.lock.RLock()
 	defer db.lock.RUnlock()

error.go

@@ -11,7 +11,6 @@ import (
 // https://docs.aws.amazon.com/AmazonS3/latest/API/ErrorResponses.html
 //
 // If you add a code to this list, please also add it to ErrorCode.Status().
-//
 const (
 	ErrNone ErrorCode = ""
 
@@ -74,6 +73,9 @@ const (
 	// See BucketNotFound() for a helper function for this error:
 	ErrNoSuchBucket ErrorCode = "NoSuchBucket"
 
+	// The specified bucket does not exist.
+	ErrNonExistentBucket ErrorCode = "NonExistentBucket"
+
 	// See KeyNotFound() for a helper function for this error:
 	ErrNoSuchKey ErrorCode = "NoSuchKey"
 
@@ -150,13 +152,12 @@ type Error interface {
 // Code and Message:
 //
 //	func NotQuiteRight(at time.Time, max time.Duration) error {
-// 	    code := ErrNotQuiteRight
-// 	    return &notQuiteRightResponse{
-// 	        ErrorResponse{Code: code, Message: code.Message()},
-// 	        123456789,
-// 	    }
-// 	}
-//
+//	    code := ErrNotQuiteRight
+//	    return &notQuiteRightResponse{
+//	        ErrorResponse{Code: code, Message: code.Message()},
+//	        123456789,
+//	    }
+//	}
 type ErrorResponse struct {
 	XMLName xml.Name `xml:"Error"`
 
@@ -291,7 +292,6 @@ func (e ErrorCode) Status() int {
 //	}
 //
 // If err is nil and code is ErrNone, HasErrorCode returns true.
-//
 func HasErrorCode(err error, code ErrorCode) bool {
 	if err == nil && code == "" {
 		return true

gofakes3.go

@@ -230,7 +230,7 @@
 
 	isVersion2 := q.Get("list-type") == "2"
 
-	g.log.Print(LogInfo, "bucketname:", bucketName, "prefix:", prefix, "page:", fmt.Sprintf("%+v", page))
+	g.log.Print(LogInfo, "bucketName:", bucketName, "prefix:", prefix, "page:", fmt.Sprintf("%+v", page))
 
 	objects, err := g.storage.ListBucket(bucketName, &prefix, page)
 	if err != nil {
@@ -400,6 +400,20 @@
 	if err := g.ensureBucketExists(bucket); err != nil {
 		return err
 	}
+
+	// Support for Minio's DeleteBucket with force-delete header.
+	forceDelete := r.Header.Get("x-minio-force-delete")
+	if forceDelete == "true" {
+		type forceDeleter interface {
+			ForceDeleteBucket(name string) error
+		}
+		if f, ok := g.storage.(forceDeleter); ok {
+			if err := f.ForceDeleteBucket(bucket); err != nil {
+				return err
+			}
+		}
+	}
+
 	if err := g.storage.DeleteBucket(bucket); err != nil {
 		return err
 	}
@@ -417,7 +431,10 @@
 		return err
 	}
 
-	w.Write([]byte{})
+	_, err := w.Write([]byte{})
+	if err != nil {
+		return err
+	}
 	return nil
 }
 
@@ -463,7 +480,12 @@
 		g.log.Print(LogErr, "unexpected nil object for key", bucket, object)
 		return ErrInternal
 	}
-	defer obj.Contents.Close()
+	defer func(Contents io.ReadCloser) {
+		err := Contents.Close()
+		if err != nil {
+			g.log.Print(LogErr, "contents close", err.Error())
+		}
+	}(obj.Contents)
 
 	if err := g.writeGetOrHeadObjectResponse(obj, w, r); err != nil {
 		return err

gofakes3_test.go

@@ -202,7 +202,7 @@ func TestCreateObjectMD5(t *testing.T) {
 		}
 	}
 
-	if ts.backendObjectExists(defaultBucket, "invalid") {
+	if exists, _ := ts.backendObjectExists(defaultBucket, "invalid"); exists {
 		t.Fatal("unexpected object")
 	}
 }
@@ -509,6 +509,22 @@ func TestDeleteBucket(t *testing.T) {
 			t.Fatal("expected ErrBucketNotEmpty, found", err)
 		}
 	})
+
+	t.Run("force-delete-does-not-fail-if-not-empty", func(t *testing.T) {
+		ts := newTestServer(t, withoutInitialBuckets())
+		defer ts.Close()
+		svc := ts.s3Client()
+
+		ts.backendCreateBucket("test")
+		ts.backendPutString("test", "test", nil, "test")
+		_, err := svc.DeleteBucket(&s3.DeleteBucketInput{
+			Bucket: aws.String("test"),
+		})
+		if !hasErrorCode(err, gofakes3.ErrBucketNotEmpty) {
+			t.Fatal("expected ErrBucketNotEmpty, found", err)
+		}
+	})
+
 }
 
 func TestDeleteMulti(t *testing.T) {
@@ -575,6 +591,35 @@ func TestDeleteMulti(t *testing.T) {
 	})
 }
 
+func TestForceDeleteBucket_BucketExists(t *testing.T) {
+	// Create a test server with no initial buckets
+	ts := newTestServer(t, withoutInitialBuckets())
+	ts.Helper()
+	bucketName := "test-bucket"
+	ts.backendCreateBucket(bucketName)
+
+	// Force delete the bucket
+	err := ts.ForceDeleteBucket(bucketName)
+	if err != nil {
+		t.Fatalf("expected no error, got %v", err)
+	}
+
+	exists, _ := ts.backendObjectExists(bucketName, "test-bucket")
+	if !exists {
+
+	}
+}
+
+func TestForceDeleteBucket_BucketDoesNotExist(t *testing.T) {
+	ts := newTestServer(t, withoutInitialBuckets())
+
+	bucketName := "nonexistent-bucket"
+	err := ts.ForceDeleteBucket(bucketName)
+	if err == gofakes3.ErrNonExistentBucket {
+		t.Fatalf("expected error %v, got %v", gofakes3.ErrNoSuchBucket, err)
+	}
+}
+
 func TestGetBucketLocation(t *testing.T) {
 	ts := newTestServer(t)
 	defer ts.Close()

init_test.go

@@ -243,17 +243,17 @@ func (ts *testServer) backendCreateBucket(bucket string) {
 	}
 }
 
-func (ts *testServer) backendObjectExists(bucket, key string) bool {
+func (ts *testServer) backendObjectExists(bucket, key string) (bool, bool) {
 	ts.Helper()
 	obj, err := ts.backend.HeadObject(bucket, key)
 	if err != nil {
 		if hasErrorCode(err, gofakes3.ErrNoSuchKey) {
-			return false
+			return false, false
 		} else {
 			ts.Fatal(err)
 		}
 	}
-	return obj != nil
+	return obj != nil, false
 }
 
 func (ts *testServer) backendPutString(bucket, key string, meta map[string]string, in string) {
@@ -771,15 +771,15 @@ func (ts *testServer) listBucketV2Pages(prefix *gofakes3.Prefix, maxKeys int64,
 	}
 
 	var rs listBucketResult
-	if err := (svc.ListObjectsV2Pages(in, func(out *s3.ListObjectsV2Output, lastPage bool) bool {
+	if err := svc.ListObjectsV2Pages(in, func(out *s3.ListObjectsV2Output, lastPage bool) bool {
 		pages++
 		if pages > pageLimit {
 			panic("stuck in a page loop")
 		}
 		rs.CommonPrefixes = append(rs.CommonPrefixes, out.CommonPrefixes...)
 		rs.Contents = append(rs.Contents, out.Contents...)
 		return !lastPage
-	})); err != nil {
+	}); err != nil {
 		return nil, err
 	}
 
@@ -790,6 +790,26 @@ func (ts *testServer) Close() {
 	ts.server.Close()
 }
 
+func (ts *testServer) ForceDeleteBucket(name string) interface{} {
+	return nil
+}
+
+type NoSuchBucketError struct {
+	Name string
+}
+
+func (ts *testServer) backendForceDeleteBucket(name string) interface{} {
+	ts.Helper()
+	err := ts.backend.DeleteBucket(name)
+	if err != nil {
+		if hasErrorCode(err, gofakes3.ErrNoSuchBucket) {
+			return NoSuchBucketError{Name: name}
+		}
+		ts.Fatal("delete bucket failed", err)
+	}
+	return true
+}
+
 func hashMD5Bytes(body []byte) hashValue {
 	h := md5.New()
 	h.Write(body)