mirror of
https://github.com/seaweedfs/seaweedfs.git
synced 2026-08-16 20:26:45 +00:00
Chris LuandGitHub
7d6c83b126
* s3: delete a directory marker instead of versioning it The key "dir/" is stored as the filer directory itself, so a delete marker cannot stand in for it without hiding the children underneath, and its history has to sit inside the directory it describes, where listings keep meeting it. Delete it the way an unversioned bucket already does: remove the directory when nothing is left under it, demote it to a plain directory when children remain, and drop a history an older build recorded for it. * s3: stop resolving directory markers through a version history Nothing records one for them any more, so the lookups that read it are dead weight - and the one in the listing was a filer round trip per directory marker returned, which for a bucket that keeps a marker per directory is the whole listing cost. A listing reads what a directory stands for straight off the entry it already has; a unit test pins that N markers cost one ListEntries rather than N+1. The guard that keeps a history left inside a directory by an older build from surfacing as a key named after it stays. * s3: do not let deleting "dir/" destroy the object at "dir" Writing under an existing object turns that object's entry into a directory while it keeps its data, so the keys "m2" and "m2/" end up sharing one entry. Stripping the entry to delete "m2/" therefore wiped the object at "m2" - a different key, and in a versioned bucket one no delete marker records. Leave a directory holding uploaded data alone; "m2/" does not name it. * s3: make the directory-marker delete fail closed and take the write lock The guard that spares a promoted file only fired when the entry read succeeded, so a transient filer error fell through to the delete and could destroy the object at "dir" anyway. Fail the request instead, take the object write lock so the entry cannot change between the check and the delete, and report a stale history that cannot be removed rather than leaving it to keep naming the key in ListObjectVersions. * s3: check If-Match inside the directory-marker delete lock The lock belongs to the caller: taking it inside the delete nested it under the batch handler's own lock, and since every lock from a gateway shares one owner the inner release would have freed it while the outer caller still assumed it held it. Both callers now own the lock, the single-object path re-checks If-Match inside it the way the other delete paths do, and a batch delete of a trailing-slash key in an unversioned bucket goes through the same marker path instead of the raw delete. A history lookup that fails now fails the delete.
70 lines
3.3 KiB
Go
70 lines
3.3 KiB
Go
package s3api
|
|
|
|
import (
|
|
"errors"
|
|
"strings"
|
|
|
|
"github.com/seaweedfs/seaweedfs/weed/glog"
|
|
"github.com/seaweedfs/seaweedfs/weed/pb/filer_pb"
|
|
"github.com/seaweedfs/seaweedfs/weed/s3api/s3_constants"
|
|
"github.com/seaweedfs/seaweedfs/weed/s3api/s3err"
|
|
"github.com/seaweedfs/seaweedfs/weed/util"
|
|
)
|
|
|
|
// An explicit directory marker - the key "dir/" created by PutObject on a
|
|
// trailing-slash key - is stored as the filer directory itself rather than as an
|
|
// object beside it. That makes it a poor fit for versioning: a delete marker would
|
|
// have to replace an entry that other keys live under, and the history would have to
|
|
// sit inside the directory it describes, where a listing keeps meeting it.
|
|
//
|
|
// So the key is not versioned. Deleting it does what deleting it in an unversioned
|
|
// bucket already does: the directory is removed when nothing is left under it, and
|
|
// demoted to a plain directory when children remain. Listings need no version lookup
|
|
// to tell what a directory stands for, and a bucket made of directory markers costs
|
|
// the same to list versioned as unversioned.
|
|
|
|
// deleteDirectoryMarker removes the key "<dir>/". Callers hold the object write lock,
|
|
// so the entry this decides about cannot change between the read and the delete.
|
|
func (s3a *S3ApiServer) deleteDirectoryMarker(bucket, object string) s3err.ErrorCode {
|
|
markerDir := s3a.bucketDir(bucket) + "/" + strings.TrimSuffix(strings.TrimPrefix(object, "/"), "/")
|
|
dir, name := util.FullPath(markerDir).DirAndName()
|
|
|
|
entry, err := s3a.getEntry(dir, name)
|
|
switch {
|
|
case errors.Is(err, filer_pb.ErrNotFound):
|
|
return s3err.ErrNone // deleting a key that is not there is a success
|
|
case err != nil:
|
|
// The entry may be a file a child write promoted to a directory, whose data
|
|
// belongs to the key without the trailing slash. Deleting without knowing
|
|
// would destroy it, so fail and leave the retry to the client.
|
|
glog.Errorf("deleteDirectoryMarker: cannot read %s/%s: %v", bucket, object, err)
|
|
return s3err.ErrInternalError
|
|
case len(entry.GetChunks()) > 0 || entry.IsInRemoteOnly():
|
|
// A promoted file, not a marker: "dir/" does not name its data.
|
|
glog.V(2).Infof("deleteDirectoryMarker: %s/%s holds uploaded data, leaving it alone", bucket, object)
|
|
return s3err.ErrNone
|
|
}
|
|
|
|
// Drop a history an older build recorded for this key. Nothing writes one now, and
|
|
// leaving it behind keeps reporting the key in ListObjectVersions, so a history we
|
|
// cannot read or remove fails the delete rather than half finishing it.
|
|
switch _, historyErr := s3a.getEntry(markerDir, s3_constants.VersionsFolder); {
|
|
case historyErr == nil:
|
|
if rmErr := s3a.rm(markerDir, s3_constants.VersionsFolder, true, true); rmErr != nil {
|
|
glog.Errorf("deleteDirectoryMarker: failed to remove stale history of %s/%s: %v", bucket, object, rmErr)
|
|
return s3err.ErrInternalError
|
|
}
|
|
case !errors.Is(historyErr, filer_pb.ErrNotFound):
|
|
glog.Errorf("deleteDirectoryMarker: cannot read stale history of %s/%s: %v", bucket, object, historyErr)
|
|
return s3err.ErrInternalError
|
|
}
|
|
|
|
if err := s3a.WithFilerClient(false, func(client filer_pb.SeaweedFilerClient) error {
|
|
return s3a.deleteUnversionedObjectWithClient(client, bucket, object, false)
|
|
}); err != nil {
|
|
glog.Errorf("deleteDirectoryMarker: failed to delete %s/%s: %v", bucket, object, err)
|
|
return s3err.ErrInternalError
|
|
}
|
|
return s3err.ErrNone
|
|
}
|