seaweedfs/weed/mount/weedfs_file_write_test.go

//go:build !freebsd

package mount

import (
	"bytes"
	"context"
	"os"
	"path/filepath"
	"syscall"
	"testing"

	"github.com/seaweedfs/go-fuse/v2/fuse"
	"github.com/seaweedfs/seaweedfs/weed/filer"
	"github.com/seaweedfs/seaweedfs/weed/pb/filer_pb"
	"github.com/seaweedfs/seaweedfs/weed/util"
	"google.golang.org/protobuf/proto"
)

// A write the swap file cannot buffer fails, and must not grow the file: the
// next flush would publish that size with a hole where its data should be. A
// write that buffers only its first chunk is a short write of those bytes, or
// an error for kernel writeback, which would drop the rest silently.
func TestFailedWriteDoesNotGrowFile(t *testing.T) {
	t.Run("short write", func(t *testing.T) { testFailedWriteDoesNotGrowFile(t, 0) })
	t.Run("kernel writeback", func(t *testing.T) { testFailedWriteDoesNotGrowFile(t, fuse.WRITE_CACHE) })
}

func testFailedWriteDoesNotGrowFile(t *testing.T, writeFlags uint32) {
	base := attributeAppendEntry(1)
	base.CommitTsNs = 100
	peer := &g6ConditionalPeer{entry: proto.Clone(base).(*filer_pb.Entry)}
	peer.blobs = map[string][]byte{base.Chunks[0].GetFileIdString(): bytes.Repeat([]byte{'O'}, 256)}

	w := newInvalidateTestWFS(t)
	notADir := filepath.Join(t.TempDir(), "file")
	if err := os.WriteFile(notADir, nil, 0600); err != nil {
		t.Fatal(err)
	}
	w.option.uniqueCacheDirForWrite = filepath.Join(notADir, "swap")
	w.option.DefaultPermissions = true
	w.posixLocks = NewPosixLockTable()
	w.option.ConcurrentWriters = 1
	w.concurrentWriters = util.NewLimitedConcurrentExecutor(1)
	startFakeFiler(t, w, peer)
	w.inodeToPath.Lookup("/dir", 1, true, false, 0, false)
	w.inodeToPath.Lookup("/dir/file", 1, false, false, 42, true)
	w.inodeToPath.MarkChildrenCached("/dir")
	if err := w.metaCache.InsertEntry(context.Background(), filer.FromPbEntry("/dir", proto.Clone(base).(*filer_pb.Entry)), 1); err != nil {
		t.Fatal(err)
	}
	out := &fuse.OpenOut{}
	if code := w.Open(nil, &fuse.OpenIn{InHeader: fuse.InHeader{NodeId: 42}, Flags: syscall.O_WRONLY}, out); code != fuse.OK {
		t.Fatal(code)
	}
	fh := w.GetHandle(FileHandleId(out.Fh))
	g6AppendUploader(t, fh, 100, peer)

	write := func(offset uint64, size int, value byte) (uint32, fuse.Status) {
		return w.Write(nil, &fuse.WriteIn{InHeader: fuse.InHeader{NodeId: 42}, Fh: out.Fh, Offset: offset, Size: uint32(size), WriteFlags: writeFlags}, bytes.Repeat([]byte{value}, size))
	}
	if _, code := write(256, 256, 'A'); code != fuse.OK {
		t.Fatalf("buffered write: %v", code)
	}
	// The only writable chunk slot is taken, so this write needs the swap file.
	if _, code := write(4096, 256, 'B'); code == fuse.OK {
		t.Fatal("write through an unusable swap directory succeeded")
	}
	if size := fh.GetEntry().GetEntry().Attributes.FileSize; size != 512 {
		t.Fatalf("file size after the failed write = %d, want 512", size)
	}
	// The first 24 bytes fit the existing chunk; the next chunk needs the swap file.
	n, code := write(1000, 48, 'C')
	if writeFlags == 0 && (code != fuse.OK || n != 24) {
		t.Fatalf("boundary-crossing write = %d, %v; want a short write of 24", n, code)
	}
	if writeFlags != 0 && code == fuse.OK {
		t.Fatalf("boundary-crossing writeback = %d, OK; want an error", n)
	}
	if size := fh.GetEntry().GetEntry().Attributes.FileSize; size != 1024 {
		t.Fatalf("file size after the short write = %d, want 1024", size)
	}
	if code := w.Fsync(nil, &fuse.FsyncIn{InHeader: fuse.InHeader{NodeId: 42}, Fh: out.Fh}); code != fuse.OK {
		t.Fatal(code)
	}

	peer.mu.Lock()
	defer peer.mu.Unlock()
	want := append(bytes.Repeat([]byte{'O'}, 256), bytes.Repeat([]byte{'A'}, 256)...)
	want = append(want, make([]byte, 1000-512)...)
	want = append(want, bytes.Repeat([]byte{'C'}, 24)...)
	if got := g6StoredBytes(t, peer); peer.entry.Attributes.FileSize != 1024 || !bytes.Equal(got, want) {
		t.Fatalf("stored size %d, want 1024 with the original and buffered bytes", peer.entry.Attributes.FileSize)
	}
}