mirror of
https://github.com/seaweedfs/seaweedfs.git
synced 2026-11-16 08:45:22 +01:00
* mount: fail the write when the swap file chunk cannot be created #7957 added a nil check after NewSwapFileChunk so a failed swap file creation returns an error instead of panicking. The result was assigned to pageChunk, a PageChunk interface, before the check, and an interface holding a nil *SwapFileChunk is not nil, so the check never fired: SaveDataAt stored the nil chunk and panicked in WriteDataAt. Check the *SwapFileChunk before converting it. The new test points the swap directory below a regular file; on master it panics in SwapFileChunk.WriteDataAt. Signed-off-by: anant <170962632+antcybersec@users.noreply.github.com> * mount: grow the file only after its write is buffered Write set the new size, times, pending append offset and uncommitted bytes before AddPage. When AddPage failed (now that a swap file chunk that cannot be created returns an error), the write was reported as failed but the larger size stayed on the handle's entry, so the next flush published it with a hole where the data should be. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * mount: report a partly buffered write as a short write PageWriter.AddPage fills one chunk at a time, so when a later chunk cannot be created the earlier chunks already hold their bytes. Return how much was buffered, and let Write grow the size and times over that prefix and report it, instead of failing the whole write while the prefix still reaches the next flush. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * mount: report the bytes a failed copy_file_range already buffered A streaming copy whose page fails partway returned an error even though earlier pages, or the start of the failing one, were already buffered and would reach the next flush with the destination size left short. Count the buffered bytes, grow the destination over them, and return them as a short copy. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * mount: free the copy test's destination pages The buffered memory chunk counts toward the process-wide memory chunk ceiling, so repeated runs of the test pushed later ones onto the unusable swap directory. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * mount: count only the bytes a swap chunk stored A swap chunk whose file write fails stores a prefix or nothing, but SaveDataAt returned no error and AddPage counted the whole span as buffered. SaveDataAt now reports the short write, and AddPage passes the stored count up so a write is never acknowledged past it. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * mount: fail a partly buffered writeback write Kernel writeback ignores the count in a WRITE reply, so a short write there drops the unbuffered rest without an error. A write flagged as page-cache writeback now keeps its buffered prefix but returns the error, which the kernel reports on fsync. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --------- Signed-off-by: anant <170962632+antcybersec@users.noreply.github.com> Co-authored-by: anant <170962632+antcybersec@users.noreply.github.com> Co-authored-by: Chris Lu <chrislusf@users.noreply.github.com> Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
487 lines
16 KiB
Go
487 lines
16 KiB
Go
package mount
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"errors"
|
|
"os"
|
|
"path/filepath"
|
|
"testing"
|
|
|
|
"github.com/seaweedfs/go-fuse/v2/fuse"
|
|
"github.com/seaweedfs/seaweedfs/weed/mount/meta_cache"
|
|
"github.com/seaweedfs/seaweedfs/weed/pb"
|
|
"github.com/seaweedfs/seaweedfs/weed/pb/filer_pb"
|
|
"github.com/seaweedfs/seaweedfs/weed/util"
|
|
)
|
|
|
|
func TestWholeFileServerCopyCandidate(t *testing.T) {
|
|
wfs := newCopyRangeTestWFS()
|
|
|
|
srcPath := util.FullPath("/src.txt")
|
|
dstPath := util.FullPath("/dst.txt")
|
|
srcInode := wfs.inodeToPath.Lookup(srcPath, 1, false, false, 0, true)
|
|
dstInode := wfs.inodeToPath.Lookup(dstPath, 1, false, false, 0, true)
|
|
|
|
srcHandle, _, _, _ := wfs.fhMap.AcquireFileHandle(wfs, srcInode, &filer_pb.Entry{
|
|
Name: "src.txt",
|
|
Attributes: &filer_pb.FuseAttributes{
|
|
FileMode: 0100644,
|
|
FileSize: 5,
|
|
Inode: srcInode,
|
|
},
|
|
Content: []byte("hello"),
|
|
}, 0, 0)
|
|
dstHandle, _, _, _ := wfs.fhMap.AcquireFileHandle(wfs, dstInode, &filer_pb.Entry{
|
|
Name: "dst.txt",
|
|
Attributes: &filer_pb.FuseAttributes{
|
|
FileMode: 0100644,
|
|
Inode: dstInode,
|
|
},
|
|
}, 0, 0)
|
|
|
|
srcHandle.RememberPath(srcPath)
|
|
dstHandle.RememberPath(dstPath)
|
|
|
|
in := &fuse.CopyFileRangeIn{
|
|
FhIn: uint64(srcHandle.fh),
|
|
FhOut: uint64(dstHandle.fh),
|
|
OffIn: 0,
|
|
OffOut: 0,
|
|
Len: 8,
|
|
}
|
|
|
|
copyRequest, ok := wholeFileServerCopyCandidate(srcHandle, dstHandle, in)
|
|
if !ok {
|
|
t.Fatal("expected whole-file server copy candidate")
|
|
}
|
|
if copyRequest.srcPath != srcPath {
|
|
t.Fatalf("source path = %q, want %q", copyRequest.srcPath, srcPath)
|
|
}
|
|
if copyRequest.dstPath != dstPath {
|
|
t.Fatalf("destination path = %q, want %q", copyRequest.dstPath, dstPath)
|
|
}
|
|
if copyRequest.sourceSize != 5 {
|
|
t.Fatalf("source size = %d, want 5", copyRequest.sourceSize)
|
|
}
|
|
if copyRequest.srcInode == 0 || copyRequest.dstInode == 0 {
|
|
t.Fatalf("expected inode preconditions, got src=%d dst=%d", copyRequest.srcInode, copyRequest.dstInode)
|
|
}
|
|
|
|
srcHandle.dirtyMetadata = true
|
|
if _, ok := wholeFileServerCopyCandidate(srcHandle, dstHandle, in); ok {
|
|
t.Fatal("dirty source handle should disable whole-file server copy")
|
|
}
|
|
srcHandle.dirtyMetadata = false
|
|
|
|
for _, h := range []*FileHandle{srcHandle, dstHandle} {
|
|
h.dirtyContent = true
|
|
if _, ok := wholeFileServerCopyCandidate(srcHandle, dstHandle, in); ok {
|
|
t.Fatal("handle with unpublished content should disable whole-file server copy")
|
|
}
|
|
h.dirtyContent = false
|
|
}
|
|
|
|
in.Len = 4
|
|
if _, ok := wholeFileServerCopyCandidate(srcHandle, dstHandle, in); ok {
|
|
t.Fatal("short copy request should disable whole-file server copy")
|
|
}
|
|
}
|
|
|
|
func TestCopyFileRangeUsesServerSideWholeFileCopy(t *testing.T) {
|
|
wfs := newCopyRangeTestWFS()
|
|
|
|
srcPath := util.FullPath("/src.txt")
|
|
dstPath := util.FullPath("/dst.txt")
|
|
srcInode := wfs.inodeToPath.Lookup(srcPath, 1, false, false, 0, true)
|
|
dstInode := wfs.inodeToPath.Lookup(dstPath, 1, false, false, 0, true)
|
|
|
|
srcHandle, _, _, _ := wfs.fhMap.AcquireFileHandle(wfs, srcInode, &filer_pb.Entry{
|
|
Name: "src.txt",
|
|
Attributes: &filer_pb.FuseAttributes{
|
|
FileMode: 0100644,
|
|
FileSize: 5,
|
|
Inode: srcInode,
|
|
},
|
|
Content: []byte("hello"),
|
|
}, 0, 0)
|
|
dstHandle, _, _, _ := wfs.fhMap.AcquireFileHandle(wfs, dstInode, &filer_pb.Entry{
|
|
Name: "dst.txt",
|
|
Attributes: &filer_pb.FuseAttributes{
|
|
FileMode: 0100644,
|
|
Inode: dstInode,
|
|
},
|
|
}, 0, 0)
|
|
|
|
srcHandle.RememberPath(srcPath)
|
|
dstHandle.RememberPath(dstPath)
|
|
|
|
originalCopy := performServerSideWholeFileCopy
|
|
defer func() {
|
|
performServerSideWholeFileCopy = originalCopy
|
|
}()
|
|
|
|
var called bool
|
|
performServerSideWholeFileCopy = func(cancel <-chan struct{}, gotWFS *WFS, copyRequest wholeFileServerCopyRequest) (*filer_pb.Entry, entryVersion, serverSideWholeFileCopyOutcome, error) {
|
|
called = true
|
|
if gotWFS != wfs {
|
|
t.Fatalf("wfs = %p, want %p", gotWFS, wfs)
|
|
}
|
|
if copyRequest.srcPath != srcPath {
|
|
t.Fatalf("source path = %q, want %q", copyRequest.srcPath, srcPath)
|
|
}
|
|
if copyRequest.dstPath != dstPath {
|
|
t.Fatalf("destination path = %q, want %q", copyRequest.dstPath, dstPath)
|
|
}
|
|
return &filer_pb.Entry{
|
|
Name: "dst.txt",
|
|
Attributes: &filer_pb.FuseAttributes{
|
|
FileMode: 0100644,
|
|
FileSize: 5,
|
|
Mime: "text/plain; charset=utf-8",
|
|
},
|
|
Content: []byte("hello"),
|
|
}, entryVersion{tsNs: 2000}, serverSideWholeFileCopyCommitted, nil
|
|
}
|
|
|
|
written, status := wfs.CopyFileRange(make(chan struct{}), &fuse.CopyFileRangeIn{
|
|
FhIn: uint64(srcHandle.fh),
|
|
FhOut: uint64(dstHandle.fh),
|
|
OffIn: 0,
|
|
OffOut: 0,
|
|
Len: 8,
|
|
})
|
|
if status != fuse.OK {
|
|
t.Fatalf("CopyFileRange status = %v, want OK", status)
|
|
}
|
|
if written != 5 {
|
|
t.Fatalf("CopyFileRange wrote %d bytes, want 5", written)
|
|
}
|
|
if !called {
|
|
t.Fatal("expected server-side whole-file copy path to be used")
|
|
}
|
|
|
|
gotEntry := dstHandle.GetEntry().GetEntry()
|
|
if gotEntry.Attributes == nil || gotEntry.Attributes.FileSize != 5 {
|
|
t.Fatalf("destination size = %v, want 5", gotEntry.GetAttributes().GetFileSize())
|
|
}
|
|
if string(gotEntry.Content) != "hello" {
|
|
t.Fatalf("destination content = %q, want %q", string(gotEntry.Content), "hello")
|
|
}
|
|
if dstHandle.dirtyMetadata {
|
|
t.Fatal("server-side whole-file copy should leave destination handle clean")
|
|
}
|
|
}
|
|
|
|
func TestCopyFileRangeDoesNotFallbackAfterCommittedServerCopyRefreshFailure(t *testing.T) {
|
|
wfs := newCopyRangeTestWFSWithMetaCache(t)
|
|
|
|
srcPath := util.FullPath("/src.txt")
|
|
dstPath := util.FullPath("/dst.txt")
|
|
srcInode := wfs.inodeToPath.Lookup(srcPath, 1, false, false, 0, true)
|
|
dstInode := wfs.inodeToPath.Lookup(dstPath, 1, false, false, 0, true)
|
|
|
|
srcHandle, _, _, _ := wfs.fhMap.AcquireFileHandle(wfs, srcInode, &filer_pb.Entry{
|
|
Name: "src.txt",
|
|
Attributes: &filer_pb.FuseAttributes{
|
|
FileMode: 0100644,
|
|
FileSize: 5,
|
|
Mime: "text/plain; charset=utf-8",
|
|
Md5: []byte("abcde"),
|
|
Inode: srcInode,
|
|
},
|
|
Content: []byte("hello"),
|
|
}, 0, 0)
|
|
dstHandle, _, _, _ := wfs.fhMap.AcquireFileHandle(wfs, dstInode, &filer_pb.Entry{
|
|
Name: "dst.txt",
|
|
Attributes: &filer_pb.FuseAttributes{
|
|
FileMode: 0100600,
|
|
Inode: dstInode,
|
|
},
|
|
}, 0, 0)
|
|
|
|
srcHandle.RememberPath(srcPath)
|
|
dstHandle.RememberPath(dstPath)
|
|
|
|
originalCopy := performServerSideWholeFileCopy
|
|
defer func() {
|
|
performServerSideWholeFileCopy = originalCopy
|
|
}()
|
|
|
|
performServerSideWholeFileCopy = func(cancel <-chan struct{}, gotWFS *WFS, copyRequest wholeFileServerCopyRequest) (*filer_pb.Entry, entryVersion, serverSideWholeFileCopyOutcome, error) {
|
|
if gotWFS != wfs || copyRequest.srcPath != srcPath || copyRequest.dstPath != dstPath {
|
|
t.Fatalf("unexpected server-side copy call: wfs=%p src=%q dst=%q", gotWFS, copyRequest.srcPath, copyRequest.dstPath)
|
|
}
|
|
return nil, entryVersion{}, serverSideWholeFileCopyCommitted, errors.New("reload copied entry: transient filer read failure")
|
|
}
|
|
|
|
written, status := wfs.CopyFileRange(make(chan struct{}), &fuse.CopyFileRangeIn{
|
|
FhIn: uint64(srcHandle.fh),
|
|
FhOut: uint64(dstHandle.fh),
|
|
OffIn: 0,
|
|
OffOut: 0,
|
|
Len: 8,
|
|
})
|
|
if status != fuse.OK {
|
|
t.Fatalf("CopyFileRange status = %v, want OK", status)
|
|
}
|
|
if written != 5 {
|
|
t.Fatalf("CopyFileRange wrote %d bytes, want 5", written)
|
|
}
|
|
if dstHandle.dirtyMetadata {
|
|
t.Fatal("committed server-side copy should not fall back to dirty-page copy")
|
|
}
|
|
|
|
gotEntry := dstHandle.GetEntry().GetEntry()
|
|
if gotEntry.GetAttributes().GetFileSize() != 5 {
|
|
t.Fatalf("destination size = %d, want 5", gotEntry.GetAttributes().GetFileSize())
|
|
}
|
|
if gotEntry.GetAttributes().GetFileMode() != 0100600 {
|
|
t.Fatalf("destination mode = %#o, want %#o", gotEntry.GetAttributes().GetFileMode(), uint32(0100600))
|
|
}
|
|
if string(gotEntry.GetContent()) != "hello" {
|
|
t.Fatalf("destination content = %q, want %q", string(gotEntry.GetContent()), "hello")
|
|
}
|
|
|
|
cachedEntry, _, err := wfs.metaCache.FindEntry(context.Background(), dstPath)
|
|
if err != nil {
|
|
t.Fatalf("metaCache find entry: %v", err)
|
|
}
|
|
if cachedEntry.FileSize != 5 {
|
|
t.Fatalf("metaCache destination size = %d, want 5", cachedEntry.FileSize)
|
|
}
|
|
if cachedEntry.Mime != "text/plain; charset=utf-8" {
|
|
t.Fatalf("metaCache destination mime = %q, want %q", cachedEntry.Mime, "text/plain; charset=utf-8")
|
|
}
|
|
}
|
|
|
|
func TestCopyFileRangeReturnsEIOForAmbiguousServerSideCopy(t *testing.T) {
|
|
wfs := newCopyRangeTestWFS()
|
|
|
|
srcPath := util.FullPath("/src.txt")
|
|
dstPath := util.FullPath("/dst.txt")
|
|
srcInode := wfs.inodeToPath.Lookup(srcPath, 1, false, false, 0, true)
|
|
dstInode := wfs.inodeToPath.Lookup(dstPath, 1, false, false, 0, true)
|
|
|
|
srcHandle, _, _, _ := wfs.fhMap.AcquireFileHandle(wfs, srcInode, &filer_pb.Entry{
|
|
Name: "src.txt",
|
|
Attributes: &filer_pb.FuseAttributes{
|
|
FileMode: 0100644,
|
|
FileSize: 5,
|
|
Inode: srcInode,
|
|
},
|
|
Content: []byte("hello"),
|
|
}, 0, 0)
|
|
dstHandle, _, _, _ := wfs.fhMap.AcquireFileHandle(wfs, dstInode, &filer_pb.Entry{
|
|
Name: "dst.txt",
|
|
Attributes: &filer_pb.FuseAttributes{
|
|
FileMode: 0100600,
|
|
Inode: dstInode,
|
|
},
|
|
}, 0, 0)
|
|
|
|
srcHandle.RememberPath(srcPath)
|
|
dstHandle.RememberPath(dstPath)
|
|
|
|
originalCopy := performServerSideWholeFileCopy
|
|
defer func() {
|
|
performServerSideWholeFileCopy = originalCopy
|
|
}()
|
|
|
|
performServerSideWholeFileCopy = func(cancel <-chan struct{}, gotWFS *WFS, copyRequest wholeFileServerCopyRequest) (*filer_pb.Entry, entryVersion, serverSideWholeFileCopyOutcome, error) {
|
|
if gotWFS != wfs || copyRequest.srcPath != srcPath || copyRequest.dstPath != dstPath {
|
|
t.Fatalf("unexpected server-side copy call: wfs=%p src=%q dst=%q", gotWFS, copyRequest.srcPath, copyRequest.dstPath)
|
|
}
|
|
return nil, entryVersion{}, serverSideWholeFileCopyAmbiguous, errors.New("transport timeout after request dispatch")
|
|
}
|
|
|
|
written, status := wfs.CopyFileRange(make(chan struct{}), &fuse.CopyFileRangeIn{
|
|
FhIn: uint64(srcHandle.fh),
|
|
FhOut: uint64(dstHandle.fh),
|
|
OffIn: 0,
|
|
OffOut: 0,
|
|
Len: 8,
|
|
})
|
|
if status != fuse.EIO {
|
|
t.Fatalf("CopyFileRange status = %v, want EIO", status)
|
|
}
|
|
if written != 0 {
|
|
t.Fatalf("CopyFileRange wrote %d bytes, want 0", written)
|
|
}
|
|
if dstHandle.dirtyMetadata {
|
|
t.Fatal("ambiguous server-side copy should not fall back to dirty-page copy")
|
|
}
|
|
if dstHandle.GetEntry().GetEntry().GetAttributes().GetFileSize() != 0 {
|
|
t.Fatalf("destination size = %d, want 0", dstHandle.GetEntry().GetEntry().GetAttributes().GetFileSize())
|
|
}
|
|
}
|
|
|
|
func newCopyRangeTestWFS() *WFS {
|
|
wfs := &WFS{
|
|
option: &Option{
|
|
ChunkSizeLimit: 1024,
|
|
ConcurrentReaders: 1,
|
|
VolumeServerAccess: "filerProxy",
|
|
FilerAddresses: []pb.ServerAddress{"127.0.0.1:8888"},
|
|
},
|
|
inodeToPath: NewInodeToPath(util.FullPath("/"), 0),
|
|
fhMap: NewFileHandleToInode(),
|
|
fhLockTable: util.NewLockTable[FileHandleId](),
|
|
hardLinkLockTable: util.NewLockTable[string](),
|
|
}
|
|
wfs.copyBufferPool.New = func() any {
|
|
return make([]byte, 1024)
|
|
}
|
|
return wfs
|
|
}
|
|
|
|
func newCopyRangeTestWFSWithMetaCache(t *testing.T) *WFS {
|
|
t.Helper()
|
|
|
|
wfs := newCopyRangeTestWFS()
|
|
root := util.FullPath("/")
|
|
wfs.inodeToPath.MarkChildrenCached(root)
|
|
uidGidMapper, err := meta_cache.NewUidGidMapper("", "")
|
|
if err != nil {
|
|
t.Fatalf("create uid/gid mapper: %v", err)
|
|
}
|
|
wfs.metaCache = meta_cache.NewMetaCache(
|
|
filepath.Join(t.TempDir(), "meta"),
|
|
uidGidMapper,
|
|
root,
|
|
false,
|
|
func(path util.FullPath) {
|
|
wfs.inodeToPath.MarkChildrenCached(path)
|
|
},
|
|
func(path util.FullPath) bool {
|
|
return wfs.inodeToPath.IsChildrenCached(path)
|
|
},
|
|
func(meta_cache.EntryInvalidation) {},
|
|
nil,
|
|
)
|
|
t.Cleanup(func() {
|
|
wfs.metaCache.Shutdown()
|
|
})
|
|
|
|
return wfs
|
|
}
|
|
|
|
func TestStreamingCopyMarksOnlyAcceptedContentDirty(t *testing.T) {
|
|
for _, c := range []struct {
|
|
name string
|
|
addFails bool
|
|
wantOK bool
|
|
wantDirty bool
|
|
}{
|
|
{"accepted", false, true, true},
|
|
{"rejected first page", true, false, false},
|
|
} {
|
|
t.Run(c.name, func(t *testing.T) {
|
|
wfs := newCopyRangeTestWFS()
|
|
srcInode := wfs.inodeToPath.Lookup(util.FullPath("/src.txt"), 1, false, false, 0, true)
|
|
dstInode := wfs.inodeToPath.Lookup(util.FullPath("/dst.txt"), 1, false, false, 0, true)
|
|
srcHandle, _, _, _ := wfs.fhMap.AcquireFileHandle(wfs, srcInode, &filer_pb.Entry{
|
|
Name: "src.txt",
|
|
Attributes: &filer_pb.FuseAttributes{FileMode: 0100644, FileSize: 5, Inode: srcInode},
|
|
Content: []byte("hello"),
|
|
}, 0, 0)
|
|
dstHandle, _, _, _ := wfs.fhMap.AcquireFileHandle(wfs, dstInode, &filer_pb.Entry{
|
|
Name: "dst.txt",
|
|
Attributes: &filer_pb.FuseAttributes{FileMode: 0100644, Inode: dstInode},
|
|
}, 0, 0)
|
|
if c.addFails {
|
|
dstHandle.dirtyPages.randomWriter.(*ChunkedDirtyPages).setLastError(errors.New("swap file unavailable"))
|
|
}
|
|
|
|
_, status := wfs.CopyFileRange(make(chan struct{}), &fuse.CopyFileRangeIn{
|
|
FhIn: uint64(srcHandle.fh),
|
|
FhOut: uint64(dstHandle.fh),
|
|
OffIn: 1,
|
|
OffOut: 0,
|
|
Len: 4,
|
|
})
|
|
if (status == fuse.OK) != c.wantOK {
|
|
t.Fatalf("CopyFileRange status = %v, want OK = %v", status, c.wantOK)
|
|
}
|
|
if dstHandle.dirtyContent != c.wantDirty {
|
|
t.Fatalf("dirtyContent = %v, want %v", dstHandle.dirtyContent, c.wantDirty)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// Bytes the copy buffered before a page failed stay in the handle, so the
|
|
// copy reports them and grows the destination over them.
|
|
func TestStreamingCopyReportsPartlyBufferedCopy(t *testing.T) {
|
|
wfs := newCopyRangeTestWFS()
|
|
wfs.option.ConcurrentWriters = 1
|
|
notADir := filepath.Join(t.TempDir(), "file")
|
|
if err := os.WriteFile(notADir, nil, 0600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
wfs.option.uniqueCacheDirForWrite = filepath.Join(notADir, "swap")
|
|
srcInode := wfs.inodeToPath.Lookup(util.FullPath("/src.txt"), 1, false, false, 0, true)
|
|
dstInode := wfs.inodeToPath.Lookup(util.FullPath("/dst.txt"), 1, false, false, 0, true)
|
|
srcHandle, _, _, _ := wfs.fhMap.AcquireFileHandle(wfs, srcInode, &filer_pb.Entry{
|
|
Name: "src.txt",
|
|
Attributes: &filer_pb.FuseAttributes{FileMode: 0100644, FileSize: 1024, Inode: srcInode},
|
|
Content: bytes.Repeat([]byte{'s'}, 1024),
|
|
}, 0, 0)
|
|
dstHandle, _, _, _ := wfs.fhMap.AcquireFileHandle(wfs, dstInode, &filer_pb.Entry{
|
|
Name: "dst.txt",
|
|
Attributes: &filer_pb.FuseAttributes{FileMode: 0100644, Inode: dstInode},
|
|
}, 0, 0)
|
|
t.Cleanup(dstHandle.dirtyPages.Destroy)
|
|
|
|
// The destination range crosses into a second chunk, which needs the swap file.
|
|
written, status := wfs.CopyFileRange(make(chan struct{}), &fuse.CopyFileRangeIn{
|
|
FhIn: uint64(srcHandle.fh),
|
|
FhOut: uint64(dstHandle.fh),
|
|
OffOut: 512,
|
|
Len: 1024,
|
|
})
|
|
if status != fuse.OK || written != 512 {
|
|
t.Fatalf("CopyFileRange = %d, %v; want a short copy of 512", written, status)
|
|
}
|
|
if size := dstHandle.GetEntry().GetEntry().GetAttributes().GetFileSize(); size != 1024 {
|
|
t.Fatalf("destination size = %d, want 1024", size)
|
|
}
|
|
if !dstHandle.dirtyContent || !dstHandle.dirtyMetadata {
|
|
t.Fatal("the buffered prefix must leave the destination dirty")
|
|
}
|
|
}
|
|
|
|
func TestServerSideCopySkipsFencedDestination(t *testing.T) {
|
|
wfs := newCopyRangeTestWFS()
|
|
wfs.option.WritebackCache = true
|
|
srcInode := wfs.inodeToPath.Lookup(util.FullPath("/src.txt"), 1, false, false, 0, true)
|
|
dstInode := wfs.inodeToPath.Lookup(util.FullPath("/dst.txt"), 1, false, false, 0, true)
|
|
srcHandle, _, _, _ := wfs.fhMap.AcquireFileHandle(wfs, srcInode, &filer_pb.Entry{
|
|
Name: "src.txt",
|
|
Attributes: &filer_pb.FuseAttributes{FileMode: 0100644, FileSize: 5, Inode: srcInode},
|
|
Content: []byte("hello"),
|
|
}, 0, 0)
|
|
dstHandle, _, _, _ := wfs.fhMap.AcquireFileHandle(wfs, dstInode, &filer_pb.Entry{
|
|
Name: "dst.txt",
|
|
Attributes: &filer_pb.FuseAttributes{FileMode: 0100644, Inode: dstInode},
|
|
}, 0, 0)
|
|
srcHandle.RememberPath("/src.txt")
|
|
dstHandle.RememberPath("/dst.txt")
|
|
dstHandle.writebackContentError.Store(true)
|
|
|
|
originalCopy := performServerSideWholeFileCopy
|
|
t.Cleanup(func() { performServerSideWholeFileCopy = originalCopy })
|
|
performServerSideWholeFileCopy = func(<-chan struct{}, *WFS, wholeFileServerCopyRequest) (*filer_pb.Entry, entryVersion, serverSideWholeFileCopyOutcome, error) {
|
|
t.Fatal("fenced destination must not publish through the filer copy")
|
|
return nil, entryVersion{}, serverSideWholeFileCopyCommitted, nil
|
|
}
|
|
|
|
if _, handled, _ := wfs.tryServerSideWholeFileCopy(make(chan struct{}), &fuse.CopyFileRangeIn{
|
|
FhIn: uint64(srcHandle.fh),
|
|
FhOut: uint64(dstHandle.fh),
|
|
Len: 8,
|
|
}, srcHandle, dstHandle); handled {
|
|
t.Fatal("fenced destination should fall back to the streaming copy")
|
|
}
|
|
}
|