// Creates 3 directories on a temporary dir: /mnt with the overlayed // (unionfs) mount, rw with modifiable data, and ro on the bottom. func setupUfs(t *testing.T) (workdir string, cleanup func()) { // Make sure system setting does not affect test. syscall.Umask(0) wd, _ := ioutil.TempDir("", "unionfs") err := os.Mkdir(wd+"/mnt", 0700) if err != nil { t.Fatalf("Mkdir failed: %v", err) } err = os.Mkdir(wd+"/rw", 0700) if err != nil { t.Fatalf("Mkdir failed: %v", err) } os.Mkdir(wd+"/ro", 0700) if err != nil { t.Fatalf("Mkdir failed: %v", err) } var fses []fuse.FileSystem fses = append(fses, fuse.NewLoopbackFileSystem(wd+"/rw")) fses = append(fses, NewCachingFileSystem(fuse.NewLoopbackFileSystem(wd+"/ro"), 0)) ufs := NewUnionFs(fses, testOpts) // We configure timeouts are smaller, so we can check for // UnionFs's cache consistency. opts := &fuse.FileSystemOptions{ EntryTimeout: entryTtl / 2, AttrTimeout: entryTtl / 2, NegativeTimeout: entryTtl / 2, } pathfs := fuse.NewPathNodeFs(ufs, &fuse.PathNodeFsOptions{ClientInodes: true}) state, conn, err := fuse.MountNodeFileSystem(wd+"/mnt", pathfs, opts) if err != nil { t.Fatalf("MountNodeFileSystem failed: %v", err) } conn.Debug = fuse.VerboseTest() state.Debug = fuse.VerboseTest() go state.Loop() return wd, func() { err := state.Unmount() if err != nil { return } setRecursiveWritable(t, wd, true) os.RemoveAll(wd) } }
func TestCachingFs(t *testing.T) { wd, _ := ioutil.TempDir("", "") defer os.RemoveAll(wd) fs := fuse.NewLoopbackFileSystem(wd) cfs := NewCachingFileSystem(fs, 0) os.Mkdir(wd+"/orig", 0755) fi, code := cfs.GetAttr("orig", nil) if !code.Ok() { t.Fatal("GetAttr failure", code) } if !fi.IsDir() { t.Error("unexpected attr", fi) } os.Symlink("orig", wd+"/symlink") val, code := cfs.Readlink("symlink", nil) if val != "orig" { t.Error("unexpected readlink", val) } if !code.Ok() { t.Error("code !ok ", code) } stream, code := cfs.OpenDir("", nil) if !code.Ok() { t.Fatal("Readdir fail", code) } results := make(map[string]uint32) for _, v := range stream { results[v.Name] = v.Mode &^ 07777 } expected := map[string]uint32{ "symlink": syscall.S_IFLNK, "orig": fuse.S_IFDIR, } if !modeMapEq(results, expected) { t.Error("Unexpected readdir result", results, expected) } }
func main() { // Scans the arg list and sets up flags debug := flag.Bool("debug", false, "print debugging messages.") other := flag.Bool("allow-other", false, "mount with -o allowother.") flag.Parse() if flag.NArg() < 2 { // TODO - where to get program name? fmt.Println("usage: main MOUNTPOINT ORIGINAL") os.Exit(2) } var finalFs fuse.FileSystem orig := flag.Arg(1) loopbackfs := fuse.NewLoopbackFileSystem(orig) finalFs = loopbackfs opts := &fuse.FileSystemOptions{ // These options are to be compatible with libfuse defaults, // making benchmarking easier. NegativeTimeout: time.Second, AttrTimeout: time.Second, EntryTimeout: time.Second, } pathFs := fuse.NewPathNodeFs(finalFs, nil) conn := fuse.NewFileSystemConnector(pathFs, opts) state := fuse.NewMountState(conn) state.Debug = *debug mountPoint := flag.Arg(0) fmt.Println("Mounting") mOpts := &fuse.MountOptions{ AllowOther: *other, } err := state.Mount(mountPoint, mOpts) if err != nil { fmt.Printf("Mount fail: %v\n", err) os.Exit(1) } fmt.Println("Mounted!") state.Loop() }
func NewUnionFsFromRoots(roots []string, opts *UnionFsOptions, roCaching bool) (*UnionFs, error) { fses := make([]fuse.FileSystem, 0) for i, r := range roots { var fs fuse.FileSystem fi, err := os.Stat(r) if err != nil { return nil, err } if fi.IsDir() { fs = fuse.NewLoopbackFileSystem(r) } if fs == nil { return nil, err } if i > 0 && roCaching { fs = NewCachingFileSystem(fs, 0) } fses = append(fses, fs) } return NewUnionFs(fses, *opts), nil }
func TestUnionFsDisappearing(t *testing.T) { // This init is like setupUfs, but we want access to the // writable Fs. wd, _ := ioutil.TempDir("", "") defer os.RemoveAll(wd) err := os.Mkdir(wd+"/mnt", 0700) if err != nil { t.Fatalf("Mkdir failed: %v", err) } err = os.Mkdir(wd+"/rw", 0700) if err != nil { t.Fatalf("Mkdir failed: %v", err) } os.Mkdir(wd+"/ro", 0700) if err != nil { t.Fatalf("Mkdir failed: %v", err) } wrFs := fuse.NewLoopbackFileSystem(wd + "/rw") var fses []fuse.FileSystem fses = append(fses, wrFs) fses = append(fses, fuse.NewLoopbackFileSystem(wd+"/ro")) ufs := NewUnionFs(fses, testOpts) opts := &fuse.FileSystemOptions{ EntryTimeout: entryTtl, AttrTimeout: entryTtl, NegativeTimeout: entryTtl, } nfs := fuse.NewPathNodeFs(ufs, nil) state, _, err := fuse.MountNodeFileSystem(wd+"/mnt", nfs, opts) if err != nil { t.Fatalf("MountNodeFileSystem failed: %v", err) } defer state.Unmount() state.Debug = fuse.VerboseTest() go state.Loop() log.Println("TestUnionFsDisappearing2") err = ioutil.WriteFile(wd+"/ro/file", []byte("blabla"), 0644) if err != nil { t.Fatalf("WriteFile failed: %v", err) } setRecursiveWritable(t, wd+"/ro", false) err = os.Remove(wd + "/mnt/file") if err != nil { t.Fatalf("Remove failed: %v", err) } state.ThreadSanitizerSync() oldRoot := wrFs.Root wrFs.Root = "/dev/null" state.ThreadSanitizerSync() time.Sleep((3 * entryTtl) / 2) _, err = ioutil.ReadDir(wd + "/mnt") if err == nil { t.Fatal("Readdir should have failed") } log.Println("expected readdir failure:", err) err = ioutil.WriteFile(wd+"/mnt/file2", []byte("blabla"), 0644) if err == nil { t.Fatal("write should have failed") } log.Println("expected write failure:", err) // Restore, and wait for caches to catch up. wrFs.Root = oldRoot state.ThreadSanitizerSync() time.Sleep((3 * entryTtl) / 2) _, err = ioutil.ReadDir(wd + "/mnt") if err != nil { t.Fatal("Readdir should succeed", err) } err = ioutil.WriteFile(wd+"/mnt/file2", []byte("blabla"), 0644) if err != nil { t.Fatal("write should succeed", err) } }