mirror of
https://github.com/seaweedfs/seaweedfs.git
synced 2026-10-12 17:27:50 +02:00
Chris LuandDevin
c3d13c60e9
* filer: fail writes when the existing-entry lookup fails CreateEntry only returned a FindEntry error for exclusive creates; a regular write treated a transient store error as "entry not found" and, on upsert stores, replaced the entry without loading its old chunks — leaving them out of the cleanup process. Return any lookup error except ErrNotFound for both paths. Generated with [Devin](https://devin.ai) Co-Authored-By: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com> * filer: test that a lookup failure fails a regular write Generated with [Devin](https://devin.ai) Co-Authored-By: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com> --------- Co-authored-by: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com>
293 lines
8.9 KiB
Go
293 lines
8.9 KiB
Go
package filer
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"math"
|
|
"os"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/seaweedfs/seaweedfs/weed/pb"
|
|
"github.com/seaweedfs/seaweedfs/weed/pb/filer_pb"
|
|
"github.com/seaweedfs/seaweedfs/weed/util"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
func TestEnsureEntryInodeMatchesFuseDerivation(t *testing.T) {
|
|
f := &Filer{}
|
|
crtime := time.Unix(1700000000, 0)
|
|
|
|
entry := &Entry{
|
|
FullPath: util.FullPath("/dir/file.txt"),
|
|
Attr: Attr{Crtime: crtime},
|
|
}
|
|
f.ensureEntryInode(entry)
|
|
|
|
// The filer stores exactly what the FUSE mount would compute for a
|
|
// non-hard-linked entry, and it is deterministic across calls.
|
|
assert.Equal(t, entry.FullPath.AsInode(crtime.Unix()), entry.Attr.Inode)
|
|
again := &Entry{FullPath: entry.FullPath, Attr: Attr{Crtime: crtime}}
|
|
f.ensureEntryInode(again)
|
|
assert.Equal(t, entry.Attr.Inode, again.Attr.Inode)
|
|
}
|
|
|
|
func TestEnsureEntryInodeSharesAcrossHardLinks(t *testing.T) {
|
|
f := &Filer{}
|
|
hardLinkId := NewHardLinkId()
|
|
|
|
a := &Entry{
|
|
FullPath: util.FullPath("/links/a.txt"),
|
|
Attr: Attr{Crtime: time.Unix(1700000000, 0)},
|
|
HardLinkId: hardLinkId,
|
|
}
|
|
b := &Entry{
|
|
FullPath: util.FullPath("/links/b.txt"),
|
|
Attr: Attr{Crtime: time.Unix(1800000000, 0)},
|
|
HardLinkId: hardLinkId,
|
|
}
|
|
f.ensureEntryInode(a)
|
|
f.ensureEntryInode(b)
|
|
|
|
// Every link to the same target resolves to one inode, independent of path
|
|
// or creation time.
|
|
assert.Equal(t, util.NormalizeInode(uint64(util.HashStringToLong(string(hardLinkId)))), a.Attr.Inode)
|
|
assert.Equal(t, a.Attr.Inode, b.Attr.Inode)
|
|
}
|
|
|
|
// TestEnsureEntryInodeFitsSignedLong pins the invariant that every generated
|
|
// inode is storable: the filer hands Attr.Inode to the backing store verbatim,
|
|
// and the Elasticsearch store indexes it as a signed `long`. Roughly half of
|
|
// the unsigned hash space sits above math.MaxInt64, so a store that rejects
|
|
// those values used to fail the metadata write for half of all entries.
|
|
func TestEnsureEntryInodeFitsSignedLong(t *testing.T) {
|
|
f := &Filer{}
|
|
crtime := time.Unix(1700000000, 0)
|
|
|
|
seen := make(map[uint64]string)
|
|
for i := 0; i < 5000; i++ {
|
|
fullPath := util.FullPath(fmt.Sprintf("/topics/.system/log/2026-10-02/entry-%d", i))
|
|
entry := &Entry{FullPath: fullPath, Attr: Attr{Crtime: crtime}}
|
|
f.ensureEntryInode(entry)
|
|
|
|
if entry.Attr.Inode > math.MaxInt64 {
|
|
t.Fatalf("ensureEntryInode(%q) = %d, above math.MaxInt64", fullPath, entry.Attr.Inode)
|
|
}
|
|
// Folding must not collapse distinct paths onto one inode.
|
|
if other, ok := seen[entry.Attr.Inode]; ok {
|
|
t.Fatalf("ensureEntryInode(%q) collided with %q on inode %d", fullPath, other, entry.Attr.Inode)
|
|
}
|
|
seen[entry.Attr.Inode] = string(fullPath)
|
|
}
|
|
}
|
|
|
|
// TestEnsureEntryInodeHardLinkFitsSignedLong covers the hard-link branch, which
|
|
// hashes HardLinkId instead of the path and so has no path-derived crtime term.
|
|
func TestEnsureEntryInodeHardLinkFitsSignedLong(t *testing.T) {
|
|
f := &Filer{}
|
|
crtime := time.Unix(1700000000, 0)
|
|
|
|
for i := 0; i < 5000; i++ {
|
|
entry := &Entry{
|
|
FullPath: util.FullPath(fmt.Sprintf("/links/target-%d.txt", i)),
|
|
Attr: Attr{Crtime: crtime},
|
|
HardLinkId: NewHardLinkId(),
|
|
}
|
|
f.ensureEntryInode(entry)
|
|
|
|
if entry.Attr.Inode > math.MaxInt64 {
|
|
t.Fatalf("ensureEntryInode(%q) = %d, above math.MaxInt64", entry.FullPath, entry.Attr.Inode)
|
|
}
|
|
}
|
|
}
|
|
|
|
func newTestFilerWithStubStore() (*Filer, *stubFilerStore) {
|
|
store := newStubFilerStore()
|
|
f := NewFiler(pb.ServerDiscovery{}, nil, "", "", "", "", "", 255, nil)
|
|
f.Store = NewFilerStoreWrapper(store)
|
|
return f, store
|
|
}
|
|
|
|
func TestCreateEntryAssignsInodeWhenMissing(t *testing.T) {
|
|
f, store := newTestFilerWithStubStore()
|
|
|
|
entry := &Entry{
|
|
FullPath: util.FullPath("/dir/file.txt"),
|
|
Attr: Attr{
|
|
Mode: 0o644,
|
|
},
|
|
}
|
|
|
|
err := f.CreateEntry(context.Background(), entry, nil, false, false, nil, false, f.MaxFilenameLength)
|
|
require.NoError(t, err)
|
|
|
|
stored, findErr := store.FindEntry(context.Background(), entry.FullPath)
|
|
require.NoError(t, findErr)
|
|
require.NotNil(t, stored)
|
|
assert.NotZero(t, stored.Attr.Inode)
|
|
assert.NotEqual(t, uint64(1), stored.Attr.Inode)
|
|
}
|
|
|
|
func TestCreateEntryAssignsInodesToAutoCreatedParents(t *testing.T) {
|
|
f, store := newTestFilerWithStubStore()
|
|
|
|
entry := &Entry{
|
|
FullPath: util.FullPath("/a/b/c.txt"),
|
|
Attr: Attr{
|
|
Mode: 0o644,
|
|
},
|
|
}
|
|
|
|
err := f.CreateEntry(context.Background(), entry, nil, false, false, nil, false, f.MaxFilenameLength)
|
|
require.NoError(t, err)
|
|
|
|
for _, path := range []string{"/a", "/a/b", "/a/b/c.txt"} {
|
|
stored, findErr := store.FindEntry(context.Background(), util.FullPath(path))
|
|
require.NoError(t, findErr, path)
|
|
require.NotNil(t, stored, path)
|
|
assert.NotZero(t, stored.Attr.Inode, path)
|
|
}
|
|
}
|
|
|
|
func TestCreateEntryOExclPreservesExistingEntry(t *testing.T) {
|
|
f, store := newTestFilerWithStubStore()
|
|
|
|
original := &Entry{
|
|
FullPath: util.FullPath("/buckets/my-bucket"),
|
|
Attr: Attr{Mode: os.ModeDir | 0o777},
|
|
Extended: map[string][]byte{
|
|
"lifecycle": []byte(`<LifecycleConfiguration/>`),
|
|
"owner": []byte("alice"),
|
|
},
|
|
}
|
|
require.NoError(t, store.InsertEntry(context.Background(), original))
|
|
|
|
replacement := &Entry{
|
|
FullPath: util.FullPath("/buckets/my-bucket"),
|
|
Attr: Attr{Mode: os.ModeDir | 0o777},
|
|
}
|
|
err := f.CreateEntry(context.Background(), replacement, original, true, false, nil, false, f.MaxFilenameLength)
|
|
require.ErrorIs(t, err, filer_pb.ErrEntryAlreadyExists)
|
|
|
|
stored, findErr := store.FindEntry(context.Background(), original.FullPath)
|
|
require.NoError(t, findErr)
|
|
assert.Equal(t, original.Extended, stored.Extended)
|
|
}
|
|
|
|
func TestCreateEntryOExclFailsOnLookupError(t *testing.T) {
|
|
f, store := newTestFilerWithStubStore()
|
|
|
|
original := &Entry{
|
|
FullPath: util.FullPath("/buckets/my-bucket"),
|
|
Attr: Attr{Mode: os.ModeDir | 0o777},
|
|
Extended: map[string][]byte{"owner": []byte("alice")},
|
|
}
|
|
require.NoError(t, store.InsertEntry(context.Background(), original))
|
|
|
|
// a failed lookup must not masquerade as "not found": without the check
|
|
// the insert path would upsert over the stored bucket entry
|
|
store.findErr = errors.New("transient store failure")
|
|
err := f.CreateEntry(context.Background(), &Entry{
|
|
FullPath: util.FullPath("/buckets/my-bucket"),
|
|
Attr: Attr{Mode: os.ModeDir | 0o777},
|
|
}, nil, true, false, nil, false, f.MaxFilenameLength)
|
|
require.Error(t, err)
|
|
assert.NotErrorIs(t, err, filer_pb.ErrEntryAlreadyExists)
|
|
|
|
store.findErr = nil
|
|
stored, findErr := store.FindEntry(context.Background(), original.FullPath)
|
|
require.NoError(t, findErr)
|
|
assert.Equal(t, original.Extended, stored.Extended)
|
|
}
|
|
|
|
func TestUpdateEntryPreservesExistingInode(t *testing.T) {
|
|
f, store := newTestFilerWithStubStore()
|
|
|
|
original := &Entry{
|
|
FullPath: util.FullPath("/doc.txt"),
|
|
Attr: Attr{
|
|
Mode: 0o644,
|
|
Inode: 12345,
|
|
},
|
|
}
|
|
require.NoError(t, store.InsertEntry(context.Background(), original))
|
|
|
|
updated := &Entry{
|
|
FullPath: util.FullPath("/doc.txt"),
|
|
Attr: Attr{
|
|
Mode: os.ModeDir | 0o755,
|
|
},
|
|
}
|
|
|
|
err := f.UpdateEntry(context.Background(), original, updated, false)
|
|
require.Error(t, err)
|
|
|
|
updated = &Entry{
|
|
FullPath: util.FullPath("/doc.txt"),
|
|
Attr: Attr{
|
|
Mode: 0o600,
|
|
},
|
|
}
|
|
err = f.UpdateEntry(context.Background(), original, updated, false)
|
|
require.NoError(t, err)
|
|
|
|
stored, findErr := store.FindEntry(context.Background(), original.FullPath)
|
|
require.NoError(t, findErr)
|
|
require.NotNil(t, stored)
|
|
assert.Equal(t, uint64(12345), stored.Attr.Inode)
|
|
}
|
|
|
|
func TestUpdateEntryBackfillsMissingLegacyInode(t *testing.T) {
|
|
f, store := newTestFilerWithStubStore()
|
|
|
|
original := &Entry{
|
|
FullPath: util.FullPath("/legacy.txt"),
|
|
Attr: Attr{
|
|
Mode: 0o644,
|
|
},
|
|
}
|
|
require.NoError(t, store.InsertEntry(context.Background(), original))
|
|
|
|
updated := &Entry{
|
|
FullPath: util.FullPath("/legacy.txt"),
|
|
Attr: Attr{
|
|
Mode: 0o640,
|
|
},
|
|
}
|
|
err := f.UpdateEntry(context.Background(), original, updated, false)
|
|
require.NoError(t, err)
|
|
|
|
stored, findErr := store.FindEntry(context.Background(), original.FullPath)
|
|
require.NoError(t, findErr)
|
|
require.NotNil(t, stored)
|
|
assert.NotZero(t, stored.Attr.Inode)
|
|
assert.NotEqual(t, uint64(1), stored.Attr.Inode)
|
|
}
|
|
|
|
// A transient store error must fail the write instead of being mistaken for a
|
|
// missing entry: on upsert stores proceeding would replace the entry without
|
|
// loading the old chunks, orphaning them from cleanup.
|
|
func TestCreateEntryFailsWhenLookupErrors(t *testing.T) {
|
|
f, store := newTestFilerWithStubStore()
|
|
path := util.FullPath("/dir/file.txt")
|
|
require.NoError(t, store.InsertEntry(context.Background(), &Entry{
|
|
FullPath: path,
|
|
Content: []byte("existing"),
|
|
}))
|
|
store.findErr = errors.New("transient store failure")
|
|
|
|
entry := &Entry{
|
|
FullPath: path,
|
|
Attr: Attr{Mode: 0o644},
|
|
Content: []byte("overwrite"),
|
|
}
|
|
require.Error(t, f.CreateEntry(context.Background(), entry, nil, false, false, nil, false, f.MaxFilenameLength))
|
|
|
|
store.findErr = nil
|
|
stored, findErr := store.FindEntry(context.Background(), path)
|
|
require.NoError(t, findErr)
|
|
assert.Equal(t, "existing", string(stored.Content))
|
|
}
|