func fusetestCommon(t *testing.T, fs *otaru.FileSystem, f func(mountpoint string)) { bfuse.Debug = func(msg interface{}) { log.Printf("fusedbg: %v", msg) } mountpoint := "/tmp/hoge" if err := os.Mkdir(mountpoint, 0777); err != nil && !os.IsExist(err) { log.Fatalf("Failed to create mountpoint: %v", err) } bfuse.Unmount(mountpoint) done := make(chan bool) ready := make(chan bool) go func() { if err := fuse.ServeFUSE("otaru-test", mountpoint, fs, ready); err != nil { t.Errorf("ServeFUSE err: %v", err) close(ready) } close(done) }() <-ready f(mountpoint) time.Sleep(100 * time.Millisecond) if err := bfuse.Unmount(mountpoint); err != nil { t.Errorf("umount failed: %v", err) } <-done }
func runMount(cmd *Command, args []string) bool { fmt.Printf("This is SeaweedFS version %s %s %s\n", util.VERSION, runtime.GOOS, runtime.GOARCH) if *mountOptions.dir == "" { fmt.Printf("Please specify the mount directory via \"-dir\"") return false } c, err := fuse.Mount(*mountOptions.dir) if err != nil { glog.Fatal(err) return false } OnInterrupt(func() { fuse.Unmount(*mountOptions.dir) c.Close() }) err = fs.Serve(c, WFS{}) if err != nil { fuse.Unmount(*mountOptions.dir) } // check if the mount process has an error to report <-c.Ready if err := c.MountError; err != nil { glog.Fatal(err) } return true }
func main() { flag.Usage = Usage flag.Parse() if flag.NArg() != 2 { Usage() os.Exit(2) } mountpoint := flag.Arg(0) c, err := fuse.Mount( mountpoint, fuse.FSName("MomFS"), fuse.Subtype("momfs"), fuse.LocalVolume(), fuse.VolumeName("Mom file system"), ) if err != nil { log.Fatal(err) } defer c.Close() sigintCh := make(chan os.Signal, 1) signal.Notify(sigintCh, os.Interrupt) go func() { <-sigintCh log.Printf("Program interrupted. Trying to unmount file system.\n") err := fuse.Unmount(mountpoint) if err != nil { log.Println(err) log.Println("Failed to unmount file system. Trying again..") for { <-time.Tick(1 * time.Second) fuse.Unmount(mountpoint) } } }() err = fs.Serve(c, NewOrgFS()) if err != nil { log.Fatal(err) } // check if the mount process has an error to report <-c.Ready if err := c.MountError; err != nil { log.Fatal(err) } }
func main() { config := NewConfig() fuse.Unmount(config.Base) os.MkdirAll(config.Base, 0777) conn, err := process(config) if err != nil { logex.Fatal(err) } c := make(chan os.Signal, 1) signal.Notify(c, os.Interrupt, os.Kill, syscall.SIGTERM, syscall.SIGHUP) <-c fuse.Unmount(config.Base) conn.Close() }
func (r *fsRoot) Close() error { r.Lock() if r.dst != nil { // Since newConn only sends on dst while holding a reader lock, holding the // writer lock is sufficient to ensure there are no pending sends on the // channel when it is closed. close(r.dst) // Setting it to nil prevents further sends. r.dst = nil } r.Unlock() log.Printf("unmount %q", r.linkDir) if err := fuse.Unmount(r.linkDir); err != nil { return err } var errs bytes.Buffer r.sockLock.Lock() for _, c := range r.closers { if err := c.Close(); err != nil { fmt.Fprintln(&errs, err) } } r.sockLock.Unlock() if errs.Len() == 0 { return nil } log.Printf("Close %q: %v", r.linkDir, errs.String()) return errors.New(errs.String()) }
// Close will wait until all I/O operations are done and unmount the fuse // mount again. func (m *Mount) Close() error { if m.closed { return nil } m.closed = true log.Info("Umount fuse layer...") for tries := 0; tries < 20; tries++ { if err := fuse.Unmount(m.Dir); err != nil { // log.Printf("unmount error: %v", err) time.Sleep(100 * time.Millisecond) continue } break } // Be sure to drain the error channel: select { case err := <-m.errors: // Serve() had some error after some time: if err != nil { log.Warningf("fuse returned an error: %v", err) } } // Be sure to pull the item from the channel: <-m.done if err := m.Conn.Close(); err != nil { return err } return nil }
func main() { log.SetFlags(log.Ldate | log.Ltime | log.Lshortfile) flag.Usage = Usage flag.Parse() cfg, err := facade.NewConfigFromTomlFile(*flagConfigFile) if err != nil { log.Printf("%v", err) Usage() os.Exit(2) } if flag.NArg() != 1 { Usage() os.Exit(2) } mountpoint := flag.Arg(0) o, err := facade.NewOtaru(cfg, &facade.OneshotConfig{Mkfs: *flagMkfs}) if err != nil { log.Printf("NewOtaru failed: %v", err) os.Exit(1) } var muClose sync.Mutex closeOtaruAndExit := func() { muClose.Lock() defer muClose.Unlock() if err := bfuse.Unmount(mountpoint); err != nil { log.Printf("umount err: %v", err) } if o != nil { if err := o.Close(); err != nil { log.Printf("Otaru.Close() returned errs: %v", err) } o = nil } os.Exit(0) } defer closeOtaruAndExit() sigC := make(chan os.Signal, 1) signal.Notify(sigC, os.Interrupt) signal.Notify(sigC, syscall.SIGTERM) go func() { for s := range sigC { log.Printf("Received signal: %v", s) closeOtaruAndExit() } }() bfuse.Debug = func(msg interface{}) { log.Printf("fusedbg: %v", msg) } if err := fuse.ServeFUSE(mountpoint, o.FS, nil); err != nil { log.Fatalf("ServeFUSE failed: %v", err) } log.Printf("ServeFUSE end!") }
func ccfsUnmount(mountpoint string) { err := fuse.Unmount(mountpoint) if err != nil { log.Printf("Could not unmount: %s", err) } log.Printf("Exit-kill program") os.Exit(0) }
// Unmount tries to unmount normally and then force if unsuccessful func (m ForceMounter) Unmount() (err error) { // Try unmount err = fuse.Unmount(m.dir) if err != nil { // Unmount failed, so let's try and force it. err = m.forceUnmount() } return }
func TestMain(m *testing.M) { // Ensure this directory exists. os.MkdirAll(dir, 0777) // Unmount before the tests start, else they won't work correctly. if err := fuse.Unmount(dir); err != nil { log.Printf("couldn't unmount fuse directory %q: %v", dir, err) } ret := m.Run() // Make sure to unmount at the end, so that we don't leave the system in an // inconsistent state in case something weird happened. if err := fuse.Unmount(dir); err != nil { log.Printf("couldn't unmount fuse directory %q: %v", dir, err) } os.Exit(ret) }
func handleStopSignals(mountPoint string) { s := make(chan os.Signal, 10) signal.Notify(s, os.Interrupt, syscall.SIGTERM, syscall.SIGSTOP) for range s { if err := fuse.Unmount(mountPoint); err != nil { log.Fatalf("Error umounting %s: %s", mountPoint, err) } os.Exit(0) } }
func exitSignalHandlers(fs *torrentfs.TorrentFS) { c := make(chan os.Signal) signal.Notify(c, syscall.SIGINT, syscall.SIGTERM) for { <-c fs.Destroy() err := fuse.Unmount(*mountDir) if err != nil { log.Print(err) } } }
// NewConnSrc returns a source of new connections based on Lookups in the // provided mount directory. If there isn't a directory located at tmpdir one // is created. The second return parameter can be used to shutdown and release // any resources. As a result of this shutdown, or during any other fatal // error, the returned chan will be closed. // // The connset parameter is optional. func NewConnSrc(mountdir, tmpdir string, connset *proxy.ConnSet) (<-chan proxy.Conn, io.Closer, error) { if err := os.MkdirAll(tmpdir, 0777); err != nil { return nil, nil, err } if err := fuse.Unmount(mountdir); err != nil { // The error is too verbose to be useful to print out } log.Printf("Mounting %v...", mountdir) c, err := fuse.Mount(mountdir, fuse.AllowOther()) if err != nil { return nil, nil, fmt.Errorf("cannot mount %q: %v", mountdir, err) } log.Printf("Mounted %v", mountdir) if connset == nil { // Make a dummy one. connset = proxy.NewConnSet() } conns := make(chan proxy.Conn, 1) root := &fsRoot{ tmpDir: tmpdir, linkDir: mountdir, dst: conns, links: make(map[string]symlink), closers: []io.Closer{c}, connset: connset, } server := fs.New(c, &fs.Config{ Debug: func(msg interface{}) { if false { log.Print(msg) } }, }) go func() { if err := server.Serve(root); err != nil { log.Printf("serve %q exited due to error: %v", mountdir, err) } // The server exited but we don't know whether this is because of a // graceful reason (via root.Close) or via an external force unmounting. // Closing the root will ensure the 'dst' chan is closed correctly to // signify that no new connections are possible. if err := root.Close(); err != nil { log.Printf("root.Close() error: %v", err) } log.Printf("FUSE exited") }() return conns, root, nil }
func (v *volumeDriver) Unmount(volumeID api.VolumeID, mountpath string) error { volume, err := v.GetVol(volumeID) if err != nil { return err } if volume.AttachPath == "" { return fmt.Errorf("openstorage: device not mounted: %v", volumeID) } if err := fuse.Unmount(volume.AttachPath); err != nil { return err } volume.AttachPath = "" return v.UpdateVol(volume) }
func (proxy *Proxy) Serve() error { err := fuse.Unmount(proxy.Mountpoint) if err != nil { log.Print(err) } connection, err := fuse.Mount(proxy.Mountpoint) if err != nil { log.Fatal(err) } log.Printf("%+v", connection) result := fs.Serve(connection, proxy) log.Printf("Result %+v", result) return result }
// Close unmounts the filesystem and waits for fs.Serve to return. // // TODO not true: Any returned error will be stored in Err. // // It is safe to call Close multiple times. func (mnt *Mount) Close() { if mnt.closed { return } mnt.closed = true for tries := 0; tries < 1000; tries++ { err := fuse.Unmount(mnt.Dir) if err != nil { // TODO do more than log? // TODO use lazy unmount where available? log.Printf("unmount error: %v", err) time.Sleep(10 * time.Millisecond) continue } break } mnt.app.WaitForUnmount(&mnt.Info.VolumeID) os.Remove(mnt.Dir) }
// Close unmounts the filesystem and waits for fs.Serve to return. Any // returned error will be stored in Err. It is safe to call Close // multiple times. func (mnt *Mount) Close() { if mnt.closed { return } mnt.closed = true for tries := 0; tries < 1000; tries++ { err := fuse.Unmount(mnt.Dir) if err != nil { // TODO do more than log? log.Printf("unmount error: %v", err) time.Sleep(10 * time.Millisecond) continue } break } <-mnt.done mnt.Conn.Close() os.Remove(mnt.Dir) }
func process(c *Config) (conn *fuse.Conn, err error) { if err = fuse.Unmount(c.Base); err == nil { logex.Info("last not unmount") time.Sleep(1000 * time.Millisecond) err = nil } else { err = nil } ops := []fuse.MountOption{ fuse.AllowOther(), fuse.FSName(FsName), fuse.LocalVolume(), } conn, err = fuse.Mount(c.Base, ops...) if err != nil { return nil, logex.Trace(err) } go fs.Serve(conn, NewTree("/", c.Target)) logex.Info("connected.") return conn, nil }
// Unmount tries to unmount normally and then if force if unsuccessful. func Unmount(dir string, force bool, log Log) error { if !force { mounted, err := IsMounted(dir, log) if err != nil { return err } if !mounted { return fmt.Errorf("Not mounted") } } log.Info("Trying to unmount: %s", dir) err := fuse.Unmount(dir) if err != nil { if !force { return err } // Unmount failed and we want to force it. log.Info("Unmount %s failed: %s; We will try to force it", dir, err) err = ForceUnmount(dir, log) } return err }
func main() { mountpoint := "/Users/gtarcea/fuse/nginx" fuse.Unmount(mountpoint) conn, err := fuse.Mount( mountpoint, fuse.FSName("etcfs"), fuse.Subtype("etcfs"), fuse.LocalVolume(), fuse.VolumeName("etcfs"), ) if err != nil { log.Fatal(err) } defer conn.Close() err = fs.Serve(conn, etcfs.FS{}) <-conn.Ready if conn.MountError != nil { log.Fatal(conn.MountError) } }
// Unmount tries to unmount normally and then if force if unsuccessful. func Unmount(g *libkb.GlobalContext, dir string, force bool) error { if !force { mounted, err := IsMounted(g, dir) if err != nil { return err } if !mounted { return fmt.Errorf("Not mounted") } } g.Log.Info("Trying to unmount: %s", dir) err := fuse.Unmount(dir) if err != nil { if !force { return err } // Unmount failed and we want to force it. g.Log.Info("Unmount %s failed: %s; We will try to force it", dir, err) err = ForceUnmount(g, dir) } return err }
// Unmount the FS func (v *VaultFS) Unmount() error { if v.conn == nil { return errors.New("not mounted") } err := fuse.Unmount(v.mountpoint) if err != nil { return err } err = v.conn.Close() if err != nil { return err } logrus.Debug("closed connection, waiting for ready") <-v.conn.Ready if v.conn.MountError != nil { return v.conn.MountError } return nil }
func action(c *cli.Context) { if len(c.Args()) < 1 { cli.ShowAppHelp(c) return } if c.Bool("unmount") { fuse.Unmount(c.Args().First()) return } err := redisfs.Mount(c.Args().First(), &redisfs.MountOptions{ Network: "tcp", Address: c.String("host") + ":" + c.String("port"), MaxIdel: c.Int("max-idel"), Sep: c.String("sep"), DB: c.String("db"), Password: c.String("auth"), }) if err != nil { log.Fatal(err) } }
func main() { flag.Usage = usage flag.Parse() if flag.NArg() != 2 { usage() os.Exit(2) } dbURL, mountPoint := flag.Arg(0), flag.Arg(1) // Open DB connection first. db, err := sql.Open("postgres", dbURL) if err != nil { log.Fatal(err) } defer func() { _ = db.Close() }() if err := initSchema(db); err != nil { log.Fatal(err) } cfs := CFS{db} // Mount filesystem. c, err := fuse.Mount( mountPoint, fuse.FSName("CockroachFS"), fuse.Subtype("CockroachFS"), fuse.LocalVolume(), fuse.VolumeName(""), ) if err != nil { log.Fatal(err) } defer func() { _ = c.Close() }() go func() { sig := make(chan os.Signal, 1) signal.Notify(sig, os.Interrupt) for range sig { if err := fuse.Unmount(mountPoint); err != nil { log.Printf("Signal received, but could not unmount: %s", err) } else { break } } }() // Serve root. err = fs.Serve(c, cfs) if err != nil { log.Fatal(err) } // check if the mount process has an error to report <-c.Ready if err := c.MountError; err != nil { log.Fatal(err) } }
func umount(mountpoint string) error { return systemFuse.Unmount(mountpoint) }
func (m *mounter) Unmount(mountPoint string) error { return fuse.Unmount(mountPoint) }
func main() { log.SetFlags(log.Ldate | log.Ltime | log.Lshortfile) logger.Registry().AddOutput(logger.WriterLogger{os.Stderr}) flag.Usage = Usage flag.Parse() cfg, err := facade.NewConfig(*flagConfigDir) if err != nil { logger.Criticalf(mylog, "%v", err) Usage() os.Exit(2) } if flag.NArg() != 1 { Usage() os.Exit(2) } mountpoint := flag.Arg(0) if err := facade.SetupFluentLogger(cfg); err != nil { logger.Criticalf(mylog, "Failed to setup fluentd logger: %v", err) os.Exit(1) } o, err := facade.NewOtaru(cfg, &facade.OneshotConfig{Mkfs: *flagMkfs}) if err != nil { logger.Criticalf(mylog, "NewOtaru failed: %v", err) os.Exit(1) } var muClose sync.Mutex closeOtaruAndExit := func(exitCode int) { muClose.Lock() defer muClose.Unlock() if err := bfuse.Unmount(mountpoint); err != nil { logger.Warningf(mylog, "umount err: %v", err) } if o != nil { if err := o.Close(); err != nil { logger.Warningf(mylog, "Otaru.Close() returned errs: %v", err) } o = nil } os.Exit(exitCode) } defer closeOtaruAndExit(0) sigC := make(chan os.Signal, 1) signal.Notify(sigC, os.Interrupt) signal.Notify(sigC, syscall.SIGTERM) go func() { for s := range sigC { logger.Warningf(mylog, "Received signal: %v", s) closeOtaruAndExit(1) } }() logger.Registry().AddOutput(logger.HandleCritical(func() { logger.Warningf(mylog, "Starting shutdown due to critical event.") closeOtaruAndExit(1) })) bfuseLogger := logger.Registry().Category("bfuse") bfuse.Debug = func(msg interface{}) { logger.Debugf(bfuseLogger, "%v", msg) } if err := fuse.ServeFUSE(cfg.BucketName, mountpoint, o.FS, nil); err != nil { logger.Warningf(mylog, "ServeFUSE failed: %v", err) closeOtaruAndExit(1) } logger.Infof(mylog, "ServeFUSE end!") }
func main() { flag.Usage = Usage debugPtr := flag.Bool("debug", false, "print lots of stuff") newfsPtr := flag.Bool("newfs", false, "start with an empty file system") mtimePtr := flag.Bool("mtimeArchives", false, "use modify timestamp instead of version timestamp for archives") name := flag.String("name", "auto", "replica name") configFile := flag.String("config", "config.txt", "path to config file") flag.Parse() util.SetDebug(*debugPtr) myfs.UseMtime = *mtimePtr util.P_out("main\n") pid := myfs.GetOurPid(*configFile, *name) replicas := myfs.ReadReplicaInfo(*configFile) thisReplica := replicas[pid] if thisReplica == nil { util.P_err("No applicable replica") os.Exit(1) } if *newfsPtr { os.RemoveAll(thisReplica.DbPath) } if _, err := os.Stat(thisReplica.MntPoint); os.IsNotExist(err) { os.MkdirAll(thisReplica.MntPoint, os.ModeDir) } db, err := myfs.NewLeveldbFsDatabase(thisReplica.DbPath) //db := &myfs.DummyFsDb{} //err := error(nil) if err != nil { util.P_err("Problem loading the database: ", err) os.Exit(-1) } filesystem := myfs.NewFs(db, thisReplica, replicas) go filesystem.PeriodicFlush() //mountpoint := flag.Arg(0) mountpoint := thisReplica.MntPoint fuse.Unmount(mountpoint) //!! c, err := fuse.Mount(mountpoint) if err != nil { log.Fatal(err) } defer c.Close() err = fs.Serve(c, filesystem) if err != nil { log.Fatal(err) } // check if the mount process has an error to report <-c.Ready if err := c.MountError; err != nil { log.Fatal(err) } }
func main() { flag.Parse() if flag.NArg() != 0 { os.Stderr.WriteString("one does not simply pass positional args\n") os.Exit(2) } if *mountDir == "" { os.Stderr.WriteString("y u no specify mountpoint?\n") os.Exit(2) } log.SetFlags(log.LstdFlags | log.Lshortfile) conn, err := fuse.Mount(*mountDir) if err != nil { log.Fatal(err) } defer fuse.Unmount(*mountDir) // TODO: Think about the ramifications of exiting not due to a signal. defer conn.Close() client, err := torrent.NewClient(&torrent.Config{ DataDir: *downloadDir, DisableTrackers: *disableTrackers, ListenAddr: *listenAddr, NoUpload: true, // Ensure that downloads are responsive. }) if err != nil { log.Fatal(err) } // This is naturally exported via GOPPROF=http. http.DefaultServeMux.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) { client.WriteStatus(w) }) dw, err := dirwatch.New(*torrentPath) if err != nil { log.Fatal(err) } go func() { for ev := range dw.Events { switch ev.Change { case dirwatch.Added: if ev.TorrentFilePath != "" { _, err := client.AddTorrentFromFile(ev.TorrentFilePath) if err != nil { log.Printf("error adding torrent to client: %s", err) } } else if ev.MagnetURI != "" { _, err := client.AddMagnet(ev.MagnetURI) if err != nil { log.Printf("error adding magnet: %s", err) } } case dirwatch.Removed: T, ok := client.Torrent(ev.InfoHash) if !ok { break } T.Drop() } } }() resolveTestPeerAddr() fs := torrentfs.New(client) go exitSignalHandlers(fs) go func() { for { addTestPeer(client) time.Sleep(10 * time.Second) } }() if err := fusefs.Serve(conn, fs); err != nil { log.Fatal(err) } <-conn.Ready if err := conn.MountError; err != nil { log.Fatal(err) } }
func (cmd CmdMount) Execute(args []string) error { if len(args) == 0 { return fmt.Errorf("wrong number of parameters, Usage: %s", cmd.Usage()) } repo, err := cmd.global.OpenRepository() if err != nil { return err } err = repo.LoadIndex() if err != nil { return err } mountpoint := args[0] if _, err := os.Stat(mountpoint); os.IsNotExist(err) { cmd.global.Verbosef("Mountpoint %s doesn't exist, creating it\n", mountpoint) err = os.Mkdir(mountpoint, os.ModeDir|0700) if err != nil { return err } } c, err := systemFuse.Mount( mountpoint, systemFuse.ReadOnly(), systemFuse.FSName("restic"), ) if err != nil { return err } root := fs.Tree{} root.Add("snapshots", fuse.NewSnapshotsDir(repo, cmd.Root)) cmd.global.Printf("Now serving %s at %s\n", repo.Backend().Location(), mountpoint) cmd.global.Printf("Don't forget to umount after quitting!\n") AddCleanupHandler(func() error { return systemFuse.Unmount(mountpoint) }) cmd.ready <- struct{}{} errServe := make(chan error) go func() { err = fs.Serve(c, &root) if err != nil { errServe <- err } <-c.Ready errServe <- c.MountError }() select { case err := <-errServe: return err case <-cmd.done: err := c.Close() if err != nil { cmd.global.Printf("Error closing fuse connection: %s\n", err) } return systemFuse.Unmount(mountpoint) } }