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 setupCacheTest(t *testing.T) (string, *pathfs.PathNodeFs, func()) { dir, err := ioutil.TempDir("", "go-fuse-cachetest") if err != nil { t.Fatalf("TempDir failed: %v", err) } os.Mkdir(dir+"/mnt", 0755) os.Mkdir(dir+"/orig", 0755) fs := &cacheFs{ pathfs.NewLoopbackFileSystem(dir + "/orig"), } pfs := pathfs.NewPathNodeFs(fs, nil) state, conn, err := nodefs.MountRoot(dir+"/mnt", pfs.Root(), nil) if err != nil { t.Fatalf("MountNodeFileSystem failed: %v", err) } state.SetDebug(VerboseTest()) conn.SetDebug(VerboseTest()) pfs.SetDebug(VerboseTest()) go state.Serve() return dir, pfs, func() { err := state.Unmount() if err == nil { os.RemoveAll(dir) } } }
func main() { if len(os.Args) != 2 { fmt.Println("Usage: %s <mountpath>") os.Exit(1) } root := os.Args[1] dialOpts := []grpc.DialOption{grpc.WithInsecure()} conn, err := grpc.Dial("127.0.0.1:50000", dialOpts...) if err != nil { log.Fatal(err) } cli := pb.NewPathFSClient(conn) fs := grpcfs.New(cli) nfs := pathfs.NewPathNodeFs(fs, nil) server, _, err := nodefs.MountRoot(root, nfs.Root(), nil) if err != nil { log.Fatal(err) } go server.Serve() log.Printf("Fs mounted to root %s", root) sigCh := make(chan os.Signal) signal.Notify(sigCh, os.Interrupt) for range sigCh { server.Unmount() os.Exit(0) } }
func main() { if len(os.Args) != 2 { fmt.Println("Usage: %s <mountpath>") os.Exit(1) } root := os.Args[1] hfs := &HelloFs{FileSystem: pathfs.NewDefaultFileSystem()} nfs := pathfs.NewPathNodeFs(hfs, nil) fuseSrv, _, err := nodefs.MountRoot(root, nfs.Root(), nil) if err != nil { log.Fatal(err) } go fuseSrv.Serve() l, err := net.Listen("tcp", "127.0.0.1:50000") if err != nil { log.Fatal(err) } s := grpc.NewServer() pb.RegisterPathFSServer(s, server.New(hfs)) go s.Serve(l) log.Printf("Listen on %s for dir %s", l.Addr(), root) sigCh := make(chan os.Signal) signal.Notify(sigCh, os.Interrupt) for range sigCh { fuseSrv.Unmount() s.Stop() os.Exit(0) } }
func New(config *conf.Fuse, logger log_driver.Logger) (*GitFs, error) { gitfsDir, err := gitfsDir(logger) if err != nil { return nil, err } defaultfs := pathfs.NewDefaultFileSystem() gitfs := &GitFs{FileSystem: pathfs.NewReadonlyFileSystem(defaultfs), GitRepoDir: config.GitRepoDir, GitFsDir: gitfsDir, logger: logger} fs := pathfs.NewPathNodeFs(gitfs, nil) server, _, err := nodefs.MountRoot(gitfsDir, fs.Root(), nil) if err != nil { logger.Errorf("Failed to mount GitFS on %s due to %s", gitfsDir, err) return nil, err } logger.Debugf("Mount GitFs on %s", gitfsDir) gitfs.server = server server.SetDebug(config.Debug) gitfs.cache, err = cache.New(1024) if err != nil { logger.Errorf("Failed to initialize object cache due to %s\n", err) return nil, err } return gitfs, nil }
func TestLiveness(t *testing.T) { dir := testutil.TempDir() defer os.RemoveAll(dir) root := nodefs.NewDefaultNode() s, _, err := nodefs.MountRoot(dir, root, nil) if err != nil { t.Fatalf("MountRoot: %v", err) } go s.Serve() if err := s.WaitMount(); err != nil { t.Fatal("WaitMount", err) } defer s.Unmount() if _, err := ioutil.ReadDir(dir); err != nil { t.Fatalf("ReadDir: %v", err) } // We previously encountered a sitation where a finalizer would close our fd out from under us. Try to force both finalizers to run and object destruction to complete. runtime.GC() runtime.GC() if _, err := ioutil.ReadDir(dir); err != nil { t.Fatalf("ReadDir: %v", err) } }
func setupFs(fs pathfs.FileSystem) (string, func()) { opts := &nodefs.Options{ EntryTimeout: 0.0, AttrTimeout: 0.0, NegativeTimeout: 0.0, } mountPoint, _ := ioutil.TempDir("", "stat_test") nfs := pathfs.NewPathNodeFs(fs, nil) state, _, err := nodefs.MountRoot(mountPoint, nfs.Root(), opts) if err != nil { panic(fmt.Sprintf("cannot mount %v", err)) // ugh - benchmark has no error methods. } lmap := NewLatencyMap() state.RecordLatencies(lmap) // state.SetDebug(true) go state.Serve() return mountPoint, func() { lc, lns := lmap.Get("LOOKUP") gc, gns := lmap.Get("GETATTR") fmt.Printf("GETATTR %v/call n=%d, LOOKUP %v/call n=%d\n", gns/time.Duration(gc), gc, lns/time.Duration(lc), lc) err := state.Unmount() if err != nil { log.Println("error during unmount", err) } else { os.RemoveAll(mountPoint) } } }
func (d *etcDriver) Create(rq dkvolume.Request) dkvolume.Response { var res dkvolume.Response if !strings.HasPrefix(rq.Name, "@") { return responseErrorString("a etcd path has to start with a @") } d.mux.Lock() defer d.mux.Unlock() _, ok := d.mountpoints[rq.Name] if ok { return res } pt := d.createPath(rq.Name) if err := os.MkdirAll(pt, 0755); err != nil { return responseError(fmt.Errorf("cannot mkdir: %s", err)) } rootfs := "/" + d.asEtcdRoot(rq.Name) root := pathfs.NewPrefixFileSystem(&d.etcdbackend, rootfs) nfs := pathfs.NewPathNodeFs(root, nil) server, _, err := nodefs.MountRoot(pt, nfs.Root(), nil) if err != nil { return responseError(fmt.Errorf("cannot mount root : %s", err)) } es := etcdFuseServer{pt, server, 0} d.mountpoints[rq.Name] = &es go server.Serve() return res }
func TestDefaultNodeMount(t *testing.T) { dir, err := ioutil.TempDir("", "go-fuse") if err != nil { t.Fatalf("TempDir: %v", err) } defer os.RemoveAll(dir) root := nodefs.NewDefaultNode() s, conn, err := nodefs.MountRoot(dir, root, nil) if err != nil { t.Fatalf("MountRoot: %v", err) } go s.Serve() defer s.Unmount() if err := conn.Mount(root.Inode(), "sub", nodefs.NewDefaultNode(), nil); !err.Ok() { t.Fatalf("Mount: %v", err) } if entries, err := ioutil.ReadDir(dir); err != nil { t.Fatalf("ReadDir: %v", err) } else if len(entries) != 1 { t.Fatalf("got %d entries", len(entries)) } else if entries[0].Name() != "sub" { t.Fatalf("got %q, want %q", entries[0].Name(), "sub") } }
func NewNotifyTest(t *testing.T) *NotifyTest { me := &NotifyTest{} me.fs = newNotifyFs() var err error me.dir, err = ioutil.TempDir("", "go-fuse-notify_test") if err != nil { t.Fatalf("TempDir failed: %v", err) } entryTtl := 100 * time.Millisecond opts := &nodefs.Options{ EntryTimeout: entryTtl, AttrTimeout: entryTtl, NegativeTimeout: entryTtl, Debug: VerboseTest(), } me.pathfs = pathfs.NewPathNodeFs(me.fs, nil) me.state, me.connector, err = nodefs.MountRoot(me.dir, me.pathfs.Root(), opts) if err != nil { t.Fatalf("MountNodeFileSystem failed: %v", err) } go me.state.Serve() if err := me.state.WaitMount(); err != nil { t.Fatal("WaitMount", err) } return me }
func TestDefaultXAttr(t *testing.T) { dir := testutil.TempDir() defer os.RemoveAll(dir) root := &xattrNode{ Node: nodefs.NewDefaultNode(), } opts := nodefs.NewOptions() opts.Debug = testutil.VerboseTest() s, _, err := nodefs.MountRoot(dir, root, opts) if err != nil { t.Fatalf("MountRoot: %v", err) } go s.Serve() if err := s.WaitMount(); err != nil { t.Fatal("WaitMount", err) } defer s.Unmount() var data [1024]byte sz, err := syscall.Getxattr(filepath.Join(dir, "child"), "attr", data[:]) if err != nil { t.Fatalf("Getxattr: %v", err) } else if val := string(data[:sz]); val != "value" { t.Fatalf("got %v, want 'value'", val) } }
func setup(t *testing.T) (workdir string, cleanup func()) { wd, _ := ioutil.TempDir("", "") err := os.Mkdir(wd+"/mnt", 0700) if err != nil { t.Fatalf("Mkdir failed: %v", err) } err = os.Mkdir(wd+"/store", 0700) if err != nil { t.Fatalf("Mkdir failed: %v", err) } os.Mkdir(wd+"/ro", 0700) if err != nil { t.Fatalf("Mkdir failed: %v", err) } WriteFile(t, wd+"/ro/file1", "file1") WriteFile(t, wd+"/ro/file2", "file2") fs := NewAutoUnionFs(wd+"/store", testAOpts) nfs := pathfs.NewPathNodeFs(fs, nil) state, _, err := nodefs.MountRoot(wd+"/mnt", nfs.Root(), &testAOpts.Options) if err != nil { t.Fatalf("MountNodeFileSystem failed: %v", err) } fs.SetDebug(VerboseTest()) go state.Serve() return wd, func() { state.Unmount() os.RemoveAll(wd) } }
func defaultReadTest(t *testing.T) (root string, cleanup func()) { fs := &DefaultReadFS{ FileSystem: pathfs.NewDefaultFileSystem(), size: 22, } var err error dir, err := ioutil.TempDir("", "go-fuse") if err != nil { t.Fatalf("TempDir failed: %v", err) } pathfs := pathfs.NewPathNodeFs(fs, nil) opts := nodefs.NewOptions() opts.Debug = VerboseTest() state, _, err := nodefs.MountRoot(dir, pathfs.Root(), opts) if err != nil { t.Fatalf("MountNodeFileSystem failed: %v", err) } go state.Serve() if err := state.WaitMount(); err != nil { t.Fatal("WaitMount", err) } return dir, func() { state.Unmount() os.Remove(dir) } }
func setupMulti() (*testCase, error) { dir, err := ioutil.TempDir("", "fs_test") if err != nil { return nil, err } repo, err := setupRepo(filepath.Join(dir, "repo")) if err != nil { return nil, err } root := NewMultiGitFSRoot(nil) if err != nil { return nil, err } mnt := filepath.Join(dir, "mnt") if err := os.Mkdir(mnt, 0755); err != nil { return nil, err } server, _, err := nodefs.MountRoot(mnt, root, nil) go server.Serve() if err != nil { return nil, err } return &testCase{ repo, server, mnt, }, nil }
func setupBasic(opts *GitFSOptions) (*testCase, error) { dir, err := ioutil.TempDir("", "fs_test") if err != nil { return nil, err } repo, err := setupRepo(filepath.Join(dir, "repo")) if err != nil { return nil, err } root, err := NewTreeFSRoot(repo, "refs/heads/master", nil) if err != nil { return nil, err } mnt := filepath.Join(dir, "mnt") if err := os.Mkdir(mnt, 0755); err != nil { return nil, err } server, _, err := nodefs.MountRoot(mnt, root, nil) server.SetDebug(true) go server.Serve() if err != nil { return nil, err } return &testCase{ repo, server, mnt, }, nil }
func TestNonseekable(t *testing.T) { fs := &nonseekFs{FileSystem: pathfs.NewDefaultFileSystem()} fs.Length = 200 * 1024 dir := testutil.TempDir() defer os.RemoveAll(dir) nfs := pathfs.NewPathNodeFs(fs, nil) opts := nodefs.NewOptions() opts.Debug = testutil.VerboseTest() state, _, err := nodefs.MountRoot(dir, nfs.Root(), opts) if err != nil { t.Fatalf("failed: %v", err) } defer state.Unmount() go state.Serve() if err := state.WaitMount(); err != nil { t.Fatal("WaitMount", err) } 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 setupCacheTest(t *testing.T) (string, *pathfs.PathNodeFs, func()) { dir := testutil.TempDir() os.Mkdir(dir+"/mnt", 0755) os.Mkdir(dir+"/orig", 0755) fs := &cacheFs{ pathfs.NewLoopbackFileSystem(dir + "/orig"), } pfs := pathfs.NewPathNodeFs(fs, &pathfs.PathNodeFsOptions{Debug: testutil.VerboseTest()}) opts := nodefs.NewOptions() opts.Debug = testutil.VerboseTest() state, _, err := nodefs.MountRoot(dir+"/mnt", pfs.Root(), opts) if err != nil { t.Fatalf("MountNodeFileSystem failed: %v", err) } go state.Serve() if err := state.WaitMount(); err != nil { t.Fatal("WaitMount", err) } return dir, pfs, func() { err := state.Unmount() if err == nil { os.RemoveAll(dir) } } }
func setupFAttrTest(t *testing.T, fs pathfs.FileSystem) (dir string, clean func()) { dir, err := ioutil.TempDir("", "go-fuse-fsetattr_test") if err != nil { t.Fatalf("TempDir failed: %v", err) } nfs := pathfs.NewPathNodeFs(fs, nil) opts := nodefs.NewOptions() opts.Debug = VerboseTest() state, _, err := nodefs.MountRoot(dir, nfs.Root(), opts) if err != nil { t.Fatalf("MountNodeFileSystem failed: %v", err) } go state.Serve() if err := state.WaitMount(); err != nil { t.Fatal("WaitMount", err) } if state.KernelSettings().Flags&fuse.CAP_FILE_OPS == 0 { t.Skip("Mount does not support file operations") } return dir, func() { if err := state.Unmount(); err != nil { t.Errorf("cleanup: Unmount: %v", err) } else { os.RemoveAll(dir) } } }
func setupFAttrTest(t *testing.T, fs pathfs.FileSystem) (dir string, clean func()) { dir, err := ioutil.TempDir("", "go-fuse-fsetattr_test") if err != nil { t.Fatalf("TempDir failed: %v", err) } nfs := pathfs.NewPathNodeFs(fs, nil) state, _, err := nodefs.MountRoot(dir, nfs.Root(), nil) if err != nil { t.Fatalf("MountNodeFileSystem failed: %v", err) } state.SetDebug(VerboseTest()) go state.Serve() // Trigger INIT. os.Lstat(dir) if state.KernelSettings().Flags&fuse.CAP_FILE_OPS == 0 { t.Log("Mount does not support file operations") } return dir, func() { if state.Unmount() == nil { os.RemoveAll(dir) } } }
func TestOriginalIsSymlink(t *testing.T) { tmpDir := testutil.TempDir() defer os.RemoveAll(tmpDir) orig := tmpDir + "/orig" err := os.Mkdir(orig, 0755) if err != nil { t.Fatalf("Mkdir failed: %v", err) } link := tmpDir + "/link" mnt := tmpDir + "/mnt" if err := os.Mkdir(mnt, 0755); err != nil { t.Fatalf("Mkdir failed: %v", err) } if err := os.Symlink("orig", link); err != nil { t.Fatalf("Symlink failed: %v", err) } fs := pathfs.NewLoopbackFileSystem(link) nfs := pathfs.NewPathNodeFs(fs, nil) state, _, err := nodefs.MountRoot(mnt, nfs.Root(), nil) if err != nil { t.Fatalf("MountNodeFileSystem failed: %v", err) } defer state.Unmount() go state.Serve() if err := state.WaitMount(); err != nil { t.Fatal("WaitMount", err) } if _, err := os.Lstat(mnt); err != nil { t.Fatalf("Lstat failed: %v", err) } }
func main() { debug := flag.Bool("debug", false, "print FUSE debug data") lazy := flag.Bool("lazy", true, "only read contents for reads") disk := flag.Bool("disk", false, "don't use intermediate files") gitRepo := flag.String("git_repo", "", "if set, mount a single repository.") repo := flag.String("repo", "", "if set, mount a single manifest from repo repository.") flag.Parse() if len(flag.Args()) < 1 { log.Fatalf("usage: %s MOUNT", os.Args[0]) } tempDir, err := ioutil.TempDir("", "gitfs") if err != nil { log.Fatalf("TempDir: %v", err) } mntDir := flag.Args()[0] opts := fs.GitFSOptions{ Lazy: *lazy, Disk: *disk, TempDir: tempDir, } var root nodefs.Node if *repo != "" { xml := filepath.Join(*repo, "manifest.xml") m, err := manifest.ParseFile(xml) if err != nil { log.Fatalf("ParseFile(%q): %v", *repo, err) } root, err = fs.NewManifestFS(m, filepath.Join(*repo, "projects"), &opts) if err != nil { log.Fatalf("NewManifestFS: %v", err) } } else if *gitRepo != "" { var err error root, err = fs.NewGitFSRoot(*gitRepo, &opts) if err != nil { log.Fatalf("NewGitFSRoot: %v", err) } } else { root = fs.NewMultiGitFSRoot(&opts) } server, _, err := nodefs.MountRoot(mntDir, root, &nodefs.Options{ EntryTimeout: time.Hour, NegativeTimeout: time.Hour, AttrTimeout: time.Hour, PortableInodes: true, }) if err != nil { log.Fatalf("MountFileSystem: %v", err) } if *debug { server.SetDebug(true) } log.Printf("Started git multi fs FUSE on %s", mntDir) server.Serve() }
// Creates a temporary dir "wd" with 3 directories: // mnt ... overlayed (unionfs) mount // rw .... modifiable data // ro .... read-only data func setupUfs(t *testing.T) (wd string, cleanup func()) { // Make sure system setting does not affect test. syscall.Umask(0) wd = testutil.TempDir() 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 []pathfs.FileSystem fses = append(fses, pathfs.NewLoopbackFileSystem(wd+"/rw")) fses = append(fses, NewCachingFileSystem(pathfs.NewLoopbackFileSystem(wd+"/ro"), 0)) ufs, err := NewUnionFs(fses, testOpts) if err != nil { t.Fatalf("NewUnionFs: %v", err) } // We configure timeouts are smaller, so we can check for // UnionFs's cache consistency. opts := &nodefs.Options{ EntryTimeout: entryTtl / 2, AttrTimeout: entryTtl / 2, NegativeTimeout: entryTtl / 2, PortableInodes: true, Debug: testutil.VerboseTest(), } pathfs := pathfs.NewPathNodeFs(ufs, &pathfs.PathNodeFsOptions{ClientInodes: true, Debug: opts.Debug, }) state, _, err := nodefs.MountRoot(wd+"/mnt", pathfs.Root(), opts) if err != nil { t.Fatalf("MountNodeFileSystem failed: %v", err) } go state.Serve() state.WaitMount() return wd, func() { err := state.Unmount() if err != nil { return } setRecursiveWritable(t, wd, true) os.RemoveAll(wd) } }
func main() { cli.Initialize("adbfs", &config.BaseConfig) if config.DeviceSerial == "" { cli.Log.Fatalln("Device serial must be specified. Run with -h.") } if config.Mountpoint == "" { cli.Log.Fatalln("Mountpoint must be specified. Run with -h.") } absoluteMountpoint, err := filepath.Abs(config.Mountpoint) if err != nil { cli.Log.Fatal(err) } if err = checkValidMountpoint(absoluteMountpoint); err != nil { cli.Log.Fatal(err) } cache := initializeCache(config.CacheTtl) clientConfig := config.ClientConfig() fs := initializeFileSystem(clientConfig, absoluteMountpoint, cache) go watchForDeviceDisconnected(clientConfig, config.DeviceSerial) server, _, err = nodefs.MountRoot(absoluteMountpoint, fs.Root(), nil) if err != nil { cli.Log.Fatal(err) } serverDone, err := startServer(StartTimeout) if err != nil { cli.Log.Fatal(err) } cli.Log.Printf("mounted %s on %s", config.DeviceSerial, absoluteMountpoint) mounted.CompareAndSwap(false, true) defer unmountServer() signals := make(chan os.Signal, 1) signal.Notify(signals, os.Interrupt, os.Kill) for { select { case signal := <-signals: cli.Log.Println("got signal", signal) switch signal { case os.Kill, os.Interrupt: cli.Log.Println("exiting...") return } case <-serverDone: cli.Log.Debugln("server done channel closed.") return } } }
func main() { debug := flag.Bool("debug", false, "debug on") hardlinks := flag.Bool("hardlinks", false, "support hardlinks") delcache_ttl := flag.Float64("deletion_cache_ttl", 5.0, "Deletion cache TTL in seconds.") branchcache_ttl := flag.Float64("branchcache_ttl", 5.0, "Branch cache TTL in seconds.") deldirname := flag.String( "deletion_dirname", "GOUNIONFS_DELETIONS", "Directory name to use for deletions.") hide_readonly_link := flag.Bool("hide_readonly_link", true, "Hides READONLY link from the top mountpoints. "+ "Enabled by default.") portableInodes := flag.Bool("portable-inodes", false, "Use sequential 32-bit inode numbers.") flag.Parse() if len(flag.Args()) < 2 { fmt.Println("Usage:\n main MOUNTPOINT BASEDIR") os.Exit(2) } ufsOptions := unionfs.UnionFsOptions{ DeletionCacheTTL: time.Duration(*delcache_ttl * float64(time.Second)), BranchCacheTTL: time.Duration(*branchcache_ttl * float64(time.Second)), DeletionDirName: *deldirname, } options := unionfs.AutoUnionFsOptions{ UnionFsOptions: ufsOptions, Options: nodefs.Options{ EntryTimeout: time.Second, AttrTimeout: time.Second, NegativeTimeout: time.Second, Owner: fuse.CurrentOwner(), }, UpdateOnMount: true, PathNodeFsOptions: pathfs.PathNodeFsOptions{ ClientInodes: *hardlinks, }, HideReadonly: *hide_readonly_link, } fsOpts := nodefs.Options{ PortableInodes: *portableInodes, } gofs := unionfs.NewAutoUnionFs(flag.Arg(1), options) pathfs := pathfs.NewPathNodeFs(gofs, nil) state, conn, err := nodefs.MountRoot(flag.Arg(0), pathfs.Root(), &fsOpts) if err != nil { fmt.Printf("Mount fail: %v\n", err) os.Exit(1) } pathfs.SetDebug(*debug) conn.SetDebug(*debug) state.SetDebug(*debug) state.Serve() time.Sleep(1 * time.Second) }
func MountFs(path string) { LoadSession() CacheInit() nfs := pathfs.NewPathNodeFs(&DropboxFs{FileSystem: pathfs.NewDefaultFileSystem()}, nil) server, _, err := nodefs.MountRoot(path, 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") } 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 TestDefaultNodeGetAttr(t *testing.T) { dir := testutil.TempDir() defer os.RemoveAll(dir) opts := &nodefs.Options{ // Note: defaultNode.GetAttr() calling file.GetAttr() is only useful if // AttrTimeout is zero. // See https://github.com/JonathonReinhart/gitlab-fuse/issues/2 Owner: fuse.CurrentOwner(), } root := nodefs.NewDefaultNode() s, _, err := nodefs.MountRoot(dir, root, opts) if err != nil { t.Fatalf("MountRoot: %v", err) } go s.Serve() if err := s.WaitMount(); err != nil { t.Fatal("WaitMount", err) } defer s.Unmount() // Attach another custom node type root.Inode().NewChild("foo", false, &myNode{ Node: nodefs.NewDefaultNode(), content: []byte("success"), }) filepath := path.Join(dir, "foo") // NewDefaultNode() should provide for stat that indicates 0-byte regular file fi, err := os.Stat(filepath) if err != nil { t.Fatalf("Stat: %v", err) } if mode := (fi.Mode() & os.ModeType); mode != 0 { // Mode() & ModeType should be zero for regular files t.Fatalf("Unexpected mode: %#o", mode) } if size := fi.Size(); size != 0 { t.Fatalf("Unexpected size: %d", size) } // But when we open the file, we should get the content content, err := ioutil.ReadFile(filepath) if err != nil { t.Fatalf("ReadFile: %v", err) } if string(content) != "success" { t.Fatalf("Unexpected content: %v", content) } }
func main() { flag.Parse() if len(flag.Args()) < 2 { log.Fatal("Usage:\n etcd-fs MOUNTPOINT ETCDENDPOINT") } etcdFs := EtcdFs{FileSystem: pathfs.NewDefaultFileSystem(), EtcdEndpoint: flag.Arg(1)} nfs := pathfs.NewPathNodeFs(&etcdFs, 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() { if len(os.Args) < 3 { log.Fatal("More Args Pls. path username") } gf := &GistFs{FileSystem: pathfs.NewDefaultFileSystem(), user: os.Args[2]} nfs := pathfs.NewPathNodeFs(gf, nil) server, _, err := nodefs.MountRoot(os.Args[1], nfs.Root(), nil) if err != nil { log.Fatal(err) } server.Serve() }
func setupOwnerTest(t *testing.T, opts *nodefs.Options) (workdir string, cleanup func()) { wd, err := ioutil.TempDir("", "go-fuse-owner_test") fs := &ownerFs{NewDefaultFileSystem()} nfs := NewPathNodeFs(fs, nil) state, _, err := nodefs.MountRoot(wd, nfs.Root(), opts) if err != nil { t.Fatalf("MountNodeFileSystem failed: %v", err) } go state.Serve() return wd, func() { state.Unmount() os.RemoveAll(wd) } }