func TestNonseekable(t *testing.T) { fs := &nonseekFs{FileSystem: pathfs.NewDefaultFileSystem()} fs.Length = 200 * 1024 dir, err := ioutil.TempDir("", "go-fuse-cache_test") if err != nil { t.Fatalf("failed: %v", err) } defer os.RemoveAll(dir) nfs := pathfs.NewPathNodeFs(fs, nil) state, _, err := nodefs.MountRoot(dir, nfs.Root(), nil) if err != nil { t.Fatalf("failed: %v", err) } state.SetDebug(VerboseTest()) defer state.Unmount() go state.Serve() f, err := os.Open(dir + "/file") if err != nil { t.Fatalf("failed: %v", err) } defer f.Close() b := make([]byte, 200) n, err := f.ReadAt(b, 20) if err == nil || n > 0 { t.Errorf("file was opened nonseekable, but seek successful") } }
func newNotifyFs() *NotifyFs { return &NotifyFs{ FileSystem: pathfs.NewDefaultFileSystem(), sizeChan: make(chan uint64, 1), existChan: make(chan bool, 1), } }
func NewUnionFs(fileSystems []pathfs.FileSystem, options UnionFsOptions) (pathfs.FileSystem, error) { g := &unionFS{ options: &options, fileSystems: fileSystems, FileSystem: pathfs.NewDefaultFileSystem(), } writable := g.fileSystems[0] code := g.createDeletionStore() if !code.Ok() { return nil, fmt.Errorf("could not create deletion path %v: %v", options.DeletionDirName, code) } g.deletionCache = newDirCache(writable, options.DeletionDirName, options.DeletionCacheTTL) g.branchCache = NewTimedCache( func(n string) (interface{}, bool) { return g.getBranchAttrNoCache(n), true }, options.BranchCacheTTL) g.hiddenFiles = make(map[string]bool) for _, name := range options.HiddenFiles { g.hiddenFiles[name] = true } return g, nil }
func NewStatFs() *StatFs { return &StatFs{ FileSystem: pathfs.NewDefaultFileSystem(), entries: make(map[string]*fuse.Attr), dirs: make(map[string][]fuse.DirEntry), } }
func NewMultiZipFs() *MultiZipFs { m := &MultiZipFs{ zips: make(map[string]nodefs.Node), zombie: make(map[string]bool), dirZipFileMap: make(map[string]string), FileSystem: pathfs.NewDefaultFileSystem(), } return m }
func main() { flag.Parse() if len(flag.Args()) < 1 { log.Fatal("Usage:\n hello MOUNTPOINT") } nfs := pathfs.NewPathNodeFs(&HelloFs{FileSystem: pathfs.NewDefaultFileSystem()}, nil) server, _, err := nodefs.MountRoot(flag.Arg(0), nfs.Root(), nil) if err != nil { log.Fatalf("Mount fail: %v\n", err) } server.Serve() }
func main() { flag.Parse() if len(flag.Args()) < 1 { log.Fatal("Usage:\n hello MOUNTPOINT") } pnf := pathfs.NewPathNodeFs(&NekoFs{FileSystem: pathfs.NewDefaultFileSystem()}, &pathfs.PathNodeFsOptions{ClientInodes: true}) // pnf.SetDebug(true) server, _, err := nodefs.MountRoot(flag.Arg(0), pnf.Root(), nil) if err != nil { log.Fatalf("Mount fail: %v\n", err) } server.Serve() }
func NewAutoUnionFs(directory string, options AutoUnionFsOptions) pathfs.FileSystem { if options.HideReadonly { options.HiddenFiles = append(options.HiddenFiles, _READONLY) } a := &autoUnionFs{ knownFileSystems: make(map[string]knownFs), nameRootMap: make(map[string]string), zombies: make(map[string]bool), options: &options, FileSystem: pathfs.NewDefaultFileSystem(), } directory, err := filepath.Abs(directory) if err != nil { panic("filepath.Abs returned err") } a.root = directory return a }
func TestDataReadLarge(t *testing.T) { fs := &FSetAttrFs{ FileSystem: pathfs.NewDefaultFileSystem(), } dir, clean := setupFAttrTest(t, fs) defer clean() content := RandomData(385 * 1023) fn := dir + "/file" err := ioutil.WriteFile(fn, []byte(content), 0644) if err != nil { t.Fatalf("WriteFile failed: %v", err) } back, err := ioutil.ReadFile(fn) if err != nil { t.Fatalf("ReadFile failed: %v", err) } CompareSlices(t, back, content) }
func TestFSetAttr(t *testing.T) { fs := pathfs.NewLockingFileSystem(&FSetAttrFs{ FileSystem: pathfs.NewDefaultFileSystem(), }) dir, clean := setupFAttrTest(t, fs) defer clean() fn := dir + "/file" f, err := os.OpenFile(fn, os.O_CREATE|os.O_WRONLY, 0755) if err != nil { t.Fatalf("OpenFile failed: %v", err) } defer f.Close() fi, err := f.Stat() if err != nil { t.Fatalf("Stat failed: %v", err) } _, err = f.WriteString("hello") if err != nil { t.Fatalf("WriteString failed: %v", err) } code := syscall.Ftruncate(int(f.Fd()), 3) if code != nil { t.Error("truncate retval", os.NewSyscallError("Ftruncate", code)) } if a, status := fs.GetAttr("file", nil); !status.Ok() { t.Fatalf("GetAttr: status %v", status) } else if a.Size != 3 { t.Errorf("truncate: size %d, status %v", a.Size, status) } if err := f.Chmod(024); err != nil { t.Fatalf("Chmod failed: %v", err) } if a, status := fs.GetAttr("file", nil); !status.Ok() { t.Errorf("chmod: %v", status) } else if a.Mode&07777 != 024 { t.Errorf("getattr after chmod: %o", a.Mode&0777) } if err := os.Chtimes(fn, time.Unix(0, 100e3), time.Unix(0, 101e3)); err != nil { t.Fatalf("Chtimes failed: %v", err) } if a, status := fs.GetAttr("file", nil); !status.Ok() { t.Errorf("GetAttr: %v", status) } else if a.Atimensec != 100e3 || a.Mtimensec != 101e3 { t.Errorf("Utimens: atime %d != 100e3 mtime %d != 101e3", a.Atimensec, a.Mtimensec) } newFi, err := f.Stat() if err != nil { t.Fatalf("Stat failed: %v", err) } i1 := fuse.ToStatT(fi).Ino i2 := fuse.ToStatT(newFi).Ino if i1 != i2 { t.Errorf("f.Lstat().Ino = %d. Returned %d before.", i2, i1) } // TODO - test chown if run as root. }
func TestXAttrCaching(t *testing.T) { wd, _ := ioutil.TempDir("", "unionfs") defer os.RemoveAll(wd) os.Mkdir(wd+"/mnt", 0700) err := os.Mkdir(wd+"/rw", 0700) if err != nil { t.Fatalf("Mkdir failed: %v", err) } rwFS := pathfs.NewLoopbackFileSystem(wd + "/rw") roFS := &TestFS{ FileSystem: pathfs.NewDefaultFileSystem(), } ufs, err := NewUnionFs([]pathfs.FileSystem{rwFS, NewCachingFileSystem(roFS, entryTtl)}, testOpts) if err != nil { t.Fatalf("NewUnionFs: %v", err) } opts := &nodefs.Options{ EntryTimeout: entryTtl / 2, AttrTimeout: entryTtl / 2, NegativeTimeout: entryTtl / 2, } pathfs := pathfs.NewPathNodeFs(ufs, &pathfs.PathNodeFsOptions{ClientInodes: true}) server, conn, err := nodefs.MountRoot(wd+"/mnt", pathfs.Root(), opts) if err != nil { t.Fatalf("MountNodeFileSystem failed: %v", err) } server.SetDebug(VerboseTest()) conn.SetDebug(VerboseTest()) pathfs.SetDebug(VerboseTest()) defer server.Unmount() go server.Serve() if fi, err := os.Lstat(wd + "/mnt"); err != nil || !fi.IsDir() { t.Fatalf("root not readable: %v, %v", err, fi) } buf := make([]byte, 1024) n, err := syscall.Getxattr(wd+"/mnt/file", "user.attr", buf) if err != nil { t.Fatalf("Getxattr: %v", err) } want := "\x2a" got := string(buf[:n]) if got != want { t.Fatalf("Got %q want %q", got, err) } time.Sleep(entryTtl / 2) n, err = syscall.Getxattr(wd+"/mnt/file", "user.attr", buf) if err != nil { t.Fatalf("Getxattr: %v", err) } got = string(buf[:n]) if got != want { t.Fatalf("Got %q want %q", got, err) } server.Unmount() if roFS.xattrRead != 1 { t.Errorf("got xattrRead=%d, want 1", roFS.xattrRead) } }