// mountOptions configures the options from the command line flags func mountOptions(device string) (options []fuse.MountOption) { options = []fuse.MountOption{ fuse.MaxReadahead(uint32(maxReadAhead)), fuse.Subtype("rclone"), fuse.FSName(device), fuse.VolumeName(device), fuse.NoAppleDouble(), fuse.NoAppleXattr(), // Options from benchmarking in the fuse module //fuse.MaxReadahead(64 * 1024 * 1024), //fuse.AsyncRead(), - FIXME this causes // ReadFileHandle.Read error: read /home/files/ISOs/xubuntu-15.10-desktop-amd64.iso: bad file descriptor // which is probably related to errors people are having //fuse.WritebackCache(), } if allowNonEmpty { options = append(options, fuse.AllowNonEmptyMount()) } if allowOther { options = append(options, fuse.AllowOther()) } if allowRoot { options = append(options, fuse.AllowRoot()) } if defaultPermissions { options = append(options, fuse.DefaultPermissions()) } if readOnly { options = append(options, fuse.ReadOnly()) } if writebackCache { options = append(options, fuse.WritebackCache()) } return options }
func TestMountOptionAllowRootThenAllowOther(t *testing.T) { t.Parallel() mnt, err := fstestutil.MountedT(t, fstestutil.SimpleFS{fstestutil.Dir{}}, fuse.AllowRoot(), fuse.AllowOther(), ) if err == nil { mnt.Close() } if g, e := err, fuse.ErrCannotCombineAllowOtherAndAllowRoot; g != e { t.Fatalf("wrong error: %v != %v", g, e) } }
// mount calls the fuse library to specify // the details of the mounted filesystem. func mount(path, mountpoint string) error { // TODO: Check that there is no folder named mountOptions := []fuse.MountOption{ fuse.FSName("MuLi"), fuse.Subtype("MuLiFS"), fuse.LocalVolume(), fuse.VolumeName("Music Library"), } if config_params.allow_users { mountOptions = append(mountOptions, fuse.AllowOther()) } else { if config_params.allow_root { mountOptions = append(mountOptions, fuse.AllowRoot()) } } // playlist or drop in the path. c, err := fuse.Mount( mountpoint, mountOptions...) if err != nil { return err } defer c.Close() filesys := &FS{ mPoint: path, } if err := fs.Serve(c, filesys); err != nil { return err } // check if the mount process has an error to report <-c.Ready if err := c.MountError; err != nil { return err } return nil }
func mountOptions(device string) (options []fuse.MountOption) { if svfs.AllowOther { options = append(options, fuse.AllowOther()) } if svfs.AllowRoot { options = append(options, fuse.AllowRoot()) } if svfs.DefaultPermissions { options = append(options, fuse.DefaultPermissions()) } if svfs.ReadOnly { options = append(options, fuse.ReadOnly()) } options = append(options, fuse.MaxReadahead(uint32(svfs.ReadAheadSize))) options = append(options, fuse.Subtype("svfs")) options = append(options, fuse.FSName(device)) return options }
func main() { allowOther := flag.Bool("allow-other", false, "allow all users access to the filesystem") allowRoot := flag.Bool("allow-root", false, "allow root to access the filesystem") debug := flag.Bool("debug", false, "enable debug output") gid := flag.Int("gid", os.Getgid(), "set the GID that should own all files") perm := flag.Int("perm", 0, "set the file permission flags for all files") ro := flag.Bool("ro", false, "mount the filesystem read-only") root := flag.String("root", "", "path in Consul to the root of the filesystem") timeout := flag.String("timeout", defaultTimeout, "timeout for Consul requests") uid := flag.Int("uid", os.Getuid(), "set the UID that should own all files") flag.Parse() logger := logrus.New() if *debug { logger.Level = logrus.DebugLevel } consulConfig := &consul.Config{} var mountPoint string switch flag.NArg() { case 1: mountPoint = flag.Arg(0) case 2: consulConfig.Address = flag.Arg(0) mountPoint = flag.Arg(1) default: flag.Usage() } // Initialize a Consul client. TODO: connection parameters client, err := consul.NewClient(consulConfig) if err != nil { logrus.NewEntry(logger).WithError(err).Error("could not initialize consul") os.Exit(1) } // Configure some mount options timeoutDuration, err := time.ParseDuration(*timeout) if err != nil { logrus.NewEntry(logger).WithError(err).Fatal("invalid -timeout value") } mountOptions := []fuse.MountOption{ fuse.DefaultPermissions(), fuse.DaemonTimeout(fmt.Sprint(int64(timeoutDuration.Seconds() + 1))), fuse.NoAppleDouble(), fuse.NoAppleXattr(), } if *allowOther { mountOptions = append(mountOptions, fuse.AllowOther()) } if *allowRoot { mountOptions = append(mountOptions, fuse.AllowRoot()) } if *ro { mountOptions = append(mountOptions, fuse.ReadOnly()) } // Mount the file system to start receiving FS events at the mount point. logger.WithField("location", mountPoint).Info("mounting kvfs") conn, err := fuse.Mount(mountPoint, mountOptions...) if err != nil { logrus.NewEntry(logger).WithError(err).Fatal("error mounting kvfs") } defer conn.Close() // Try to cleanly unmount the FS if SIGINT or SIGTERM is received sigs := make(chan os.Signal, 10) signal.Notify(sigs, os.Interrupt, syscall.SIGTERM) go func() { for sig := range sigs { logger.WithField("signal", sig).Info("attempting to unmount") err := fuse.Unmount(mountPoint) if err != nil { logrus.NewEntry(logger).WithError(err).Error("cannot unmount") } } }() // Create a file system object and start handing its requests server := fs.New(conn, &fs.Config{ Debug: func(m interface{}) { logger.Debug(m) }, WithContext: func(ctx context.Context, req fuse.Request) context.Context { // The returned cancel function doesn't matter: the request handler will // cancel the parent context at the end of the request. newCtx, _ := context.WithTimeout(ctx, timeoutDuration) return newCtx }, }) f := &consulfs.ConsulFS{ Consul: &consulfs.CancelConsulKV{ Client: client, Logger: logger, }, Logger: logger, UID: uint32(*uid), GID: uint32(*gid), Perms: os.FileMode(*perm), RootPath: *root, } err = server.Serve(f) if err != nil { // Not sure what would cause Serve() to exit with an error logrus.NewEntry(logger).WithError(err).Error("error serving filesystem") } // Wait for the FUSE connection to end <-conn.Ready if conn.MountError != nil { logrus.NewEntry(logger).WithError(conn.MountError).Error("unmount error") os.Exit(1) } else { logger.Info("file system exiting normally") } }
func run() error { flag.Usage = usage flag.Parse() if *debug { fuse.Debug = func(v interface{}) { log.Println("[fuse]", v) } } var subdir, mountpoint string switch flag.NArg() { case 1: subdir = "/" mountpoint = flag.Arg(0) case 2: subdir = path.Join("/", flag.Arg(0)) mountpoint = flag.Arg(1) default: usage() os.Exit(1) } var endpoints []string if ep := os.Getenv("ETCD_ENDPOINTS"); ep != "" { endpoints = strings.Split(ep, ",") } else { endpoints = []string{"localhost:4001"} } log.Printf("Using endpoints %v", endpoints) cfg := client.Config{ Endpoints: endpoints, } etcd, err := client.New(cfg) if err != nil { return err } var mountOpts []fuse.MountOption if *allowOther { mountOpts = append(mountOpts, fuse.AllowOther()) } if *allowRoot { mountOpts = append(mountOpts, fuse.AllowRoot()) } mountOpts = append(mountOpts, fuse.DefaultPermissions()) mountOpts = append(mountOpts, fuse.FSName("etcd:"+subdir)) mountOpts = append(mountOpts, fuse.ReadOnly()) mountOpts = append(mountOpts, fuse.Subtype("etcdFS")) log.Printf("Mounting etcd:%s to %s", subdir, mountpoint) c, err := fuse.Mount( mountpoint, mountOpts..., ) if err != nil { return err } defer c.Close() srv := fs.New(c, nil) filesys := &etcdFS{ etcd: client.NewKeysAPI(etcd), base: subdir, } errch := make(chan error) log.Printf("Start serving") go func() { errch <- srv.Serve(filesys) }() <-c.Ready if c.MountError != nil { return c.MountError } sigs := make(chan os.Signal) signal.Notify(sigs, syscall.SIGHUP, syscall.SIGINT, syscall.SIGKILL, syscall.SIGTERM) select { case err := <-errch: return err case s := <-sigs: log.Printf("Caught signal: %v", s) err := c.Close() log.Printf("Error: %v", err) return err } }