"rsync for cloud storage" - Google Drive, S3, Dropbox, Backblaze B2, One Drive, Swift, Hubic, Wasabi, Google Cloud Storage, Azure Blob, Azure Files, Yandex Files
Go azure-blobazure-blob-storageazure-filesbackblaze-b2cloud-storagedropboxencryptionftpfuse-filesystemgogolanggoogle-cloud-storagegoogle-driveonedriveopenstack-swiftrclones3sftpsyncwebdav
vfs: convert vfs options to new style
Nick Craig-Wooda28287e96d2d
diff --git a/backend/cache/cache_internal_test.go b/backend/cache/cache_internal_test.goindex 92b2abeb1..6467e4cd9 100644--- a/backend/cache/cache_internal_test.go+++ b/backend/cache/cache_internal_test.go@@ -33,7 +33,7 @@ import ("github.com/rclone/rclone/fstest""github.com/rclone/rclone/fstest/testy""github.com/rclone/rclone/lib/random"- "github.com/rclone/rclone/vfs/vfsflags"+ "github.com/rclone/rclone/vfs/vfscommon""github.com/stretchr/testify/require")@@ -123,10 +123,10 @@ func TestInternalListRootAndInnerRemotes(t *testing.T) {/* TODO: is this testing something?func TestInternalVfsCache(t *testing.T) {- vfsflags.Opt.DirCacheTime = time.Second * 30+ vfscommon.Opt.DirCacheTime = time.Second * 30testSize := int64(524288000)- vfsflags.Opt.CacheMode = vfs.CacheModeWrites+ vfscommon.Opt.CacheMode = vfs.CacheModeWritesid := "tiuufo"rootFs, boltDb := runInstance.newCacheFs(t, remoteName, id, true, true, nil, map[string]string{"writes": "true", "info_age": "1h"})defer runInstance.cleanupFs(t, rootFs, boltDb)@@ -338,7 +338,7 @@ func TestInternalCachedUpdatedContentMatches(t *testing.T) {func TestInternalWrappedWrittenContentMatches(t *testing.T) {id := fmt.Sprintf("tiwwcm%v", time.Now().Unix())- vfsflags.Opt.DirCacheTime = fs.Duration(time.Second)+ vfscommon.Opt.DirCacheTime = fs.Duration(time.Second)rootFs, _ := runInstance.newCacheFs(t, remoteName, id, true, true, nil)if runInstance.rootIsCrypt {t.Skip("test skipped with crypt remote")@@ -368,7 +368,7 @@ func TestInternalWrappedWrittenContentMatches(t *testing.T) {func TestInternalLargeWrittenContentMatches(t *testing.T) {id := fmt.Sprintf("tilwcm%v", time.Now().Unix())- vfsflags.Opt.DirCacheTime = fs.Duration(time.Second)+ vfscommon.Opt.DirCacheTime = fs.Duration(time.Second)rootFs, _ := runInstance.newCacheFs(t, remoteName, id, true, true, nil)if runInstance.rootIsCrypt {t.Skip("test skipped with crypt remote")@@ -708,7 +708,7 @@ func TestInternalMaxChunkSizeRespected(t *testing.T) {func TestInternalExpiredEntriesRemoved(t *testing.T) {id := fmt.Sprintf("tieer%v", time.Now().Unix())- vfsflags.Opt.DirCacheTime = fs.Duration(time.Second * 4) // needs to be lower than the defined+ vfscommon.Opt.DirCacheTime = fs.Duration(time.Second * 4) // needs to be lower than the definedrootFs, _ := runInstance.newCacheFs(t, remoteName, id, true, true, nil)cfs, err := runInstance.getCacheFs(rootFs)require.NoError(t, err)@@ -743,7 +743,7 @@ func TestInternalExpiredEntriesRemoved(t *testing.T) {}func TestInternalBug2117(t *testing.T) {- vfsflags.Opt.DirCacheTime = fs.Duration(time.Second * 10)+ vfscommon.Opt.DirCacheTime = fs.Duration(time.Second * 10)id := fmt.Sprintf("tib2117%v", time.Now().Unix())rootFs, _ := runInstance.newCacheFs(t, remoteName, id, false, true, map[string]string{"info_age": "72h", "chunk_clean_interval": "15m"})diff --git a/cmd/mount/dir.go b/cmd/mount/dir.goindex 7cf1c75e6..1252177b9 100644--- a/cmd/mount/dir.go+++ b/cmd/mount/dir.go@@ -33,7 +33,7 @@ func (d *Dir) Attr(ctx context.Context, a *fuse.Attr) (err error) {a.Valid = time.Duration(d.fsys.opt.AttrTimeout)a.Gid = d.VFS().Opt.GIDa.Uid = d.VFS().Opt.UID- a.Mode = os.ModeDir | d.VFS().Opt.DirPerms+ a.Mode = os.ModeDir | os.FileMode(d.VFS().Opt.DirPerms)modTime := d.ModTime()a.Atime = modTimea.Mtime = modTimediff --git a/cmd/mount/file.go b/cmd/mount/file.goindex 6e7b67355..bc9883443 100644--- a/cmd/mount/file.go+++ b/cmd/mount/file.go@@ -4,6 +4,7 @@ package mountimport ("context"+ "os""syscall""time"@@ -31,7 +32,7 @@ func (f *File) Attr(ctx context.Context, a *fuse.Attr) (err error) {Blocks := (Size + 511) / 512a.Gid = f.VFS().Opt.GIDa.Uid = f.VFS().Opt.UID- a.Mode = f.VFS().Opt.FilePerms+ a.Mode = os.FileMode(f.VFS().Opt.FilePerms)a.Size = Sizea.Atime = modTimea.Mtime = modTimediff --git a/cmd/mountlib/mount.go b/cmd/mountlib/mount.goindex 5fdf991ac..35d50525a 100644--- a/cmd/mountlib/mount.go+++ b/cmd/mountlib/mount.go@@ -228,7 +228,7 @@ func NewMountCommand(commandName string, hidden bool, mount MountFn) *cobra.Commdefer cmd.StartStats()()}- mnt := NewMountPoint(mount, args[1], cmd.NewFsDir(args), &Opt, &vfsflags.Opt)+ mnt := NewMountPoint(mount, args[1], cmd.NewFsDir(args), &Opt, &vfscommon.Opt)mountDaemon, err := mnt.Mount()// Wait for foreground mount, if any...diff --git a/cmd/mountlib/rc.go b/cmd/mountlib/rc.goindex df13ca97c..a896e8c5f 100644--- a/cmd/mountlib/rc.go+++ b/cmd/mountlib/rc.go@@ -10,7 +10,7 @@ import ("github.com/rclone/rclone/fs""github.com/rclone/rclone/fs/rc"- "github.com/rclone/rclone/vfs/vfsflags"+ "github.com/rclone/rclone/vfs/vfscommon")var (@@ -85,7 +85,7 @@ func mountRc(ctx context.Context, in rc.Params) (out rc.Params, err error) {return nil, err}- vfsOpt := vfsflags.Opt+ vfsOpt := vfscommon.Opterr = in.GetStructMissingOK("vfsOpt", &vfsOpt)if err != nil {return nil, errdiff --git a/cmd/serve/dlna/dlna.go b/cmd/serve/dlna/dlna.goindex 86251508d..29bdd485f 100644--- a/cmd/serve/dlna/dlna.go+++ b/cmd/serve/dlna/dlna.go@@ -26,6 +26,7 @@ import ("github.com/rclone/rclone/fs""github.com/rclone/rclone/lib/systemd""github.com/rclone/rclone/vfs"+ "github.com/rclone/rclone/vfs/vfscommon""github.com/rclone/rclone/vfs/vfsflags""github.com/spf13/cobra")@@ -134,7 +135,7 @@ func newServer(f fs.Fs, opt *dlnaflags.Options) (*server, error) {waitChan: make(chan struct{}),httpListenAddr: opt.ListenAddr,f: f,- vfs: vfs.New(f, &vfsflags.Opt),+ vfs: vfs.New(f, &vfscommon.Opt),}s.services = map[string]UPnPService{diff --git a/cmd/serve/docker/driver.go b/cmd/serve/docker/driver.goindex 278a24e31..86885d336 100644--- a/cmd/serve/docker/driver.go+++ b/cmd/serve/docker/driver.go@@ -19,7 +19,6 @@ import ("github.com/rclone/rclone/lib/atexit""github.com/rclone/rclone/lib/file""github.com/rclone/rclone/vfs/vfscommon"- "github.com/rclone/rclone/vfs/vfsflags")// Driver implements docker driver api@@ -55,7 +54,7 @@ func NewDriver(ctx context.Context, root string, mntOpt *mountlib.Options, vfsOpmntOpt = &mountlib.Opt}if vfsOpt == nil {- vfsOpt = &vfsflags.Opt+ vfsOpt = &vfscommon.Opt}drv := &Driver{root: root,diff --git a/cmd/serve/docker/options.go b/cmd/serve/docker/options.goindex b8e64552e..ef598ebb0 100644--- a/cmd/serve/docker/options.go+++ b/cmd/serve/docker/options.go@@ -2,7 +2,6 @@ package dockerimport ("fmt"- "strconv""strings""github.com/rclone/rclone/cmd/mountlib"@@ -11,7 +10,6 @@ import ("github.com/rclone/rclone/fs/fspath""github.com/rclone/rclone/fs/rc""github.com/rclone/rclone/vfs/vfscommon"- "github.com/rclone/rclone/vfs/vfsflags""github.com/spf13/pflag")@@ -265,22 +263,13 @@ func getVFSOption(vfsOpt *vfscommon.Options, opt rc.Params, key string) (ok boolcase "read-only":vfsOpt.ReadOnly, err = opt.GetBool(key)case "dir-perms":- perms := &vfsflags.FileMode{Mode: &vfsOpt.DirPerms}- err = getFVarP(perms, opt, key)+ err = getFVarP(&vfsOpt.DirPerms, opt, key)case "file-perms":- perms := &vfsflags.FileMode{Mode: &vfsOpt.FilePerms}- err = getFVarP(perms, opt, key)+ err = getFVarP(&vfsOpt.FilePerms, opt, key)// unprefixed unix-only vfs optionscase "umask":- // GetInt64 doesn't support the `0octal` umask syntax - parse locally- var strVal string- if strVal, err = opt.GetString(key); err == nil {- var longVal int64- if longVal, err = strconv.ParseInt(strVal, 0, 0); err == nil {- vfsOpt.Umask = int(longVal)- }- }+ err = getFVarP(&vfsOpt.Umask, opt, key)case "uid":intVal, err = opt.GetInt64(key)vfsOpt.UID = uint32(intVal)diff --git a/cmd/serve/ftp/ftp.go b/cmd/serve/ftp/ftp.goindex d9b2ea607..9aecfea24 100644--- a/cmd/serve/ftp/ftp.go+++ b/cmd/serve/ftp/ftp.go@@ -27,6 +27,7 @@ import ("github.com/rclone/rclone/fs/log""github.com/rclone/rclone/fs/rc""github.com/rclone/rclone/vfs"+ "github.com/rclone/rclone/vfs/vfscommon""github.com/rclone/rclone/vfs/vfsflags""github.com/spf13/cobra""github.com/spf13/pflag"@@ -157,7 +158,7 @@ func newServer(ctx context.Context, f fs.Fs, opt *Options) (*driver, error) {d.proxy = proxy.New(ctx, &proxyflags.Opt)d.userPass = make(map[string]string, 16)} else {- d.globalVFS = vfs.New(f, &vfsflags.Opt)+ d.globalVFS = vfs.New(f, &vfscommon.Opt)}d.useTLS = d.opt.TLSKey != ""diff --git a/cmd/serve/http/http.go b/cmd/serve/http/http.goindex 5df63d17a..5ffa2d0a3 100644--- a/cmd/serve/http/http.go+++ b/cmd/serve/http/http.go@@ -24,6 +24,7 @@ import ("github.com/rclone/rclone/lib/http/serve""github.com/rclone/rclone/lib/systemd""github.com/rclone/rclone/vfs"+ "github.com/rclone/rclone/vfs/vfscommon""github.com/rclone/rclone/vfs/vfsflags""github.com/spf13/cobra")@@ -148,7 +149,7 @@ func run(ctx context.Context, f fs.Fs, opt Options) (s *HTTP, err error) {// override auths.opt.Auth.CustomAuthFn = s.auth} else {- s._vfs = vfs.New(f, &vfsflags.Opt)+ s._vfs = vfs.New(f, &vfscommon.Opt)}s.server, err = libhttp.NewServer(ctx,@@ -215,7 +216,7 @@ func (s *HTTP) serveDir(w http.ResponseWriter, r *http.Request, dirRemote string// Make the entries for displaydirectory := serve.NewDirectory(dirRemote, s.server.HTMLTemplate())for _, node := range dirEntries {- if vfsflags.Opt.NoModTime {+ if vfscommon.Opt.NoModTime {directory.AddHTMLEntry(node.Path(), node.IsDir(), node.Size(), time.Time{})} else {directory.AddHTMLEntry(node.Path(), node.IsDir(), node.Size(), node.ModTime().UTC())diff --git a/cmd/serve/nfs/nfs.go b/cmd/serve/nfs/nfs.goindex 69b571751..22b263308 100644--- a/cmd/serve/nfs/nfs.go+++ b/cmd/serve/nfs/nfs.go@@ -17,6 +17,7 @@ import ("github.com/rclone/rclone/fs/config/flags""github.com/rclone/rclone/fs/rc""github.com/rclone/rclone/vfs"+ "github.com/rclone/rclone/vfs/vfscommon""github.com/rclone/rclone/vfs/vfsflags""github.com/spf13/cobra""github.com/spf13/pflag"@@ -48,7 +49,7 @@ func Run(command *cobra.Command, args []string) {cmd.CheckArgs(1, 1, command, args)f = cmd.NewFsSrc(args)cmd.Run(false, true, command, func() error {- s, err := NewServer(context.Background(), vfs.New(f, &vfsflags.Opt), &opt)+ s, err := NewServer(context.Background(), vfs.New(f, &vfscommon.Opt), &opt)if err != nil {return err}diff --git a/cmd/serve/proxy/proxy.go b/cmd/serve/proxy/proxy.goindex 578250f9f..3ad607d89 100644--- a/cmd/serve/proxy/proxy.go+++ b/cmd/serve/proxy/proxy.go@@ -19,7 +19,7 @@ import ("github.com/rclone/rclone/fs/config/obscure"libcache "github.com/rclone/rclone/lib/cache""github.com/rclone/rclone/vfs"- "github.com/rclone/rclone/vfs/vfsflags"+ "github.com/rclone/rclone/vfs/vfscommon")// Help contains text describing how to use the proxy@@ -242,7 +242,7 @@ func (p *Proxy) call(user, auth string, isPublicKey bool) (value interface{}, er// need to in memory. An attacker would find it easier to go// after the unencrypted password in memory most likely.entry := cacheEntry{- vfs: vfs.New(f, &vfsflags.Opt),+ vfs: vfs.New(f, &vfscommon.Opt),pwHash: sha256.Sum256([]byte(auth)),}return entry, true, nildiff --git a/cmd/serve/s3/server.go b/cmd/serve/s3/server.goindex a1ef38262..470238644 100644--- a/cmd/serve/s3/server.go+++ b/cmd/serve/s3/server.go@@ -13,7 +13,7 @@ import ("github.com/rclone/rclone/fs/hash"httplib "github.com/rclone/rclone/lib/http""github.com/rclone/rclone/vfs"- "github.com/rclone/rclone/vfs/vfsflags"+ "github.com/rclone/rclone/vfs/vfscommon")// Options contains options for the http Server@@ -42,7 +42,7 @@ func newServer(ctx context.Context, f fs.Fs, opt *Options) (s *Server, err errorw := &Server{f: f,ctx: ctx,- vfs: vfs.New(f, &vfsflags.Opt),+ vfs: vfs.New(f, &vfscommon.Opt),}if len(opt.authPair) == 0 {diff --git a/cmd/serve/sftp/connection.go b/cmd/serve/sftp/connection.goindex ae52ccfbd..fb6d524cb 100644--- a/cmd/serve/sftp/connection.go+++ b/cmd/serve/sftp/connection.go@@ -17,7 +17,7 @@ import ("github.com/rclone/rclone/fs/hash""github.com/rclone/rclone/lib/terminal""github.com/rclone/rclone/vfs"- "github.com/rclone/rclone/vfs/vfsflags"+ "github.com/rclone/rclone/vfs/vfscommon""golang.org/x/crypto/ssh")@@ -307,7 +307,7 @@ func serveStdio(f fs.Fs) error {stdin: os.Stdin,stdout: os.Stdout,}- handlers := newVFSHandler(vfs.New(f, &vfsflags.Opt))+ handlers := newVFSHandler(vfs.New(f, &vfscommon.Opt))return serveChannel(sshChannel, handlers, "stdio")}diff --git a/cmd/serve/sftp/server.go b/cmd/serve/sftp/server.goindex 43944d4a0..1afc7e288 100644--- a/cmd/serve/sftp/server.go+++ b/cmd/serve/sftp/server.go@@ -28,7 +28,7 @@ import ("github.com/rclone/rclone/lib/env""github.com/rclone/rclone/lib/file""github.com/rclone/rclone/vfs"- "github.com/rclone/rclone/vfs/vfsflags"+ "github.com/rclone/rclone/vfs/vfscommon""golang.org/x/crypto/ssh")@@ -54,7 +54,7 @@ func newServer(ctx context.Context, f fs.Fs, opt *Options) *server {if proxyflags.Opt.AuthProxy != "" {s.proxy = proxy.New(ctx, &proxyflags.Opt)} else {- s.vfs = vfs.New(f, &vfsflags.Opt)+ s.vfs = vfs.New(f, &vfscommon.Opt)}return s}diff --git a/cmd/serve/webdav/webdav.go b/cmd/serve/webdav/webdav.goindex b91a80253..c28b13e69 100644--- a/cmd/serve/webdav/webdav.go+++ b/cmd/serve/webdav/webdav.go@@ -26,6 +26,7 @@ import ("github.com/rclone/rclone/lib/http/serve""github.com/rclone/rclone/lib/systemd""github.com/rclone/rclone/vfs"+ "github.com/rclone/rclone/vfs/vfscommon""github.com/rclone/rclone/vfs/vfsflags""github.com/spf13/cobra""golang.org/x/net/webdav"@@ -193,7 +194,7 @@ func newWebDAV(ctx context.Context, f fs.Fs, opt *Options) (w *WebDAV, err error// override authw.opt.Auth.CustomAuthFn = w.auth} else {- w._vfs = vfs.New(f, &vfsflags.Opt)+ w._vfs = vfs.New(f, &vfscommon.Opt)}w.Server, err = libhttp.NewServer(ctx,@@ -365,7 +366,7 @@ func (w *WebDAV) serveDir(rw http.ResponseWriter, r *http.Request, dirRemote str// Make the entries for displaydirectory := serve.NewDirectory(dirRemote, w.Server.HTMLTemplate())for _, node := range dirEntries {- if vfsflags.Opt.NoModTime {+ if vfscommon.Opt.NoModTime {directory.AddHTMLEntry(node.Path(), node.IsDir(), node.Size(), time.Time{})} else {directory.AddHTMLEntry(node.Path(), node.IsDir(), node.Size(), node.ModTime().UTC())diff --git a/vfs/dir.go b/vfs/dir.goindex 9bf033374..26b706b62 100644--- a/vfs/dir.go+++ b/vfs/dir.go@@ -157,7 +157,7 @@ func (d *Dir) IsDir() bool {// Mode bits of the directory - satisfies Node interfacefunc (d *Dir) Mode() (mode os.FileMode) {- return d.vfs.Opt.DirPerms+ return os.FileMode(d.vfs.Opt.DirPerms)}// Name (base) of the directory - satisfies Node interfacediff --git a/vfs/dir_test.go b/vfs/dir_test.goindex 754a5bf3c..190ba53d0 100644--- a/vfs/dir_test.go+++ b/vfs/dir_test.go@@ -43,7 +43,7 @@ func TestDirMethods(t *testing.T) {assert.Equal(t, false, dir.IsFile())// Mode- assert.Equal(t, vfs.Opt.DirPerms, dir.Mode())+ assert.Equal(t, os.FileMode(vfs.Opt.DirPerms), dir.Mode())// Nameassert.Equal(t, "dir", dir.Name())diff --git a/vfs/file.go b/vfs/file.goindex 4b970f21b..1c599ef01 100644--- a/vfs/file.go+++ b/vfs/file.go@@ -94,7 +94,7 @@ func (f *File) IsDir() bool {func (f *File) Mode() (mode os.FileMode) {f.mu.RLock()defer f.mu.RUnlock()- mode = f.d.vfs.Opt.FilePerms+ mode = os.FileMode(f.d.vfs.Opt.FilePerms)if f.appendMode {mode |= os.ModeAppend}diff --git a/vfs/file_test.go b/vfs/file_test.goindex 6688749d2..2a4b5fd47 100644--- a/vfs/file_test.go+++ b/vfs/file_test.go@@ -19,7 +19,7 @@ import ()func fileCreate(t *testing.T, mode vfscommon.CacheMode) (r *fstest.Run, vfs *VFS, fh *File, item fstest.Item) {- opt := vfscommon.DefaultOpt+ opt := vfscommon.Optopt.CacheMode = modeopt.WriteBack = writeBackDelayr, vfs = newTestVFSOpt(t, &opt)@@ -48,7 +48,7 @@ func TestFileMethods(t *testing.T) {assert.Equal(t, true, file.IsFile())// Mode- assert.Equal(t, vfs.Opt.FilePerms, file.Mode())+ assert.Equal(t, os.FileMode(vfs.Opt.FilePerms), file.Mode())// Nameassert.Equal(t, "file1", file.Name())diff --git a/vfs/rc_test.go b/vfs/rc_test.goindex 01aa3921e..9c70d526a 100644--- a/vfs/rc_test.go+++ b/vfs/rc_test.go@@ -46,7 +46,7 @@ func TestRcGetVFS(t *testing.T) {assert.Contains(t, err.Error(), "no VFS found with name")assert.Nil(t, vfs)- opt := vfscommon.DefaultOpt+ opt := vfscommon.Optopt.NoModTime = truevfs3 := New(r.Fremote, &opt)defer vfs3.Shutdown()diff --git a/vfs/read_write_test.go b/vfs/read_write_test.goindex b5d3c9982..e89e9a5e2 100644--- a/vfs/read_write_test.go+++ b/vfs/read_write_test.go@@ -30,7 +30,7 @@ var (// Create a file and open it with the flags passed infunc rwHandleCreateFlags(t *testing.T, create bool, filename string, flags int) (r *fstest.Run, vfs *VFS, fh *RWFileHandle) {- opt := vfscommon.DefaultOpt+ opt := vfscommon.Optopt.CacheMode = vfscommon.CacheModeFullopt.WriteBack = writeBackDelayr, vfs = newTestVFSOpt(t, &opt)@@ -634,7 +634,7 @@ func testRWFileHandleOpenTest(t *testing.T, vfs *VFS, test *openTest) {func TestRWFileHandleOpenTests(t *testing.T) {for _, cacheMode := range []vfscommon.CacheMode{vfscommon.CacheModeWrites, vfscommon.CacheModeFull} {t.Run(cacheMode.String(), func(t *testing.T) {- opt := vfscommon.DefaultOpt+ opt := vfscommon.Optopt.CacheMode = cacheModeopt.WriteBack = writeBackDelay_, vfs := newTestVFSOpt(t, &opt)@@ -685,7 +685,7 @@ func TestRWFileModTimeWithOpenWriters(t *testing.T) {}func TestRWCacheRename(t *testing.T) {- opt := vfscommon.DefaultOpt+ opt := vfscommon.Optopt.CacheMode = vfscommon.CacheModeFullopt.WriteBack = writeBackDelayr, vfs := newTestVFSOpt(t, &opt)@@ -719,7 +719,7 @@ func TestRWCacheRename(t *testing.T) {//// See: https://github.com/rclone/rclone/issues/6053func TestRWCacheUpdate(t *testing.T) {- opt := vfscommon.DefaultOpt+ opt := vfscommon.Optopt.CacheMode = vfscommon.CacheModeFullopt.WriteBack = writeBackDelayopt.DirCacheTime = fs.Duration(100 * time.Millisecond)diff --git a/vfs/vfs.go b/vfs/vfs.goindex b35d8d0a1..9f0fc1f14 100644--- a/vfs/vfs.go+++ b/vfs/vfs.go@@ -204,7 +204,7 @@ func New(f fs.Fs, opt *vfscommon.Options) *VFS {if opt != nil {vfs.Opt = *opt} else {- vfs.Opt = vfscommon.DefaultOpt+ vfs.Opt = vfscommon.Opt}// Fill out anything else@@ -776,7 +776,7 @@ func (vfs *VFS) AddVirtual(remote string, size int64, isDir bool) (err error) {} else {// Create parent of virtual directory since backend can't have empty directoriesparent, leaf = path.Split(remote)- dir, err = vfs.mkdirAll(parent, vfs.Opt.DirPerms)+ dir, err = vfs.mkdirAll(parent, os.FileMode(vfs.Opt.DirPerms))}if err != nil {return errdiff --git a/vfs/vfs_case_test.go b/vfs/vfs_case_test.goindex 7641cf89f..26acd2210 100644--- a/vfs/vfs_case_test.go+++ b/vfs/vfs_case_test.go@@ -34,12 +34,12 @@ func TestCaseSensitivity(t *testing.T) {file3 := r.WriteObject(ctx, "FilEb", "data3", t3)// Create a case-Sensitive and case-INsensitive VFS- optCS := vfscommon.DefaultOpt+ optCS := vfscommon.OptoptCS.CaseInsensitive = falsevfsCS := New(r.Fremote, &optCS)defer cleanupVFS(t, vfsCS)- optCI := vfscommon.DefaultOpt+ optCI := vfscommon.OptoptCI.CaseInsensitive = truevfsCI := New(r.Fremote, &optCI)defer cleanupVFS(t, vfsCI)@@ -179,7 +179,7 @@ func TestUnicodeNormalization(t *testing.T) {r.CheckRemoteItems(t, file1, file2)// Create VFS- opt := vfscommon.DefaultOpt+ opt := vfscommon.Optvfs := New(r.Fremote, &opt)defer cleanupVFS(t, vfs)diff --git a/vfs/vfs_test.go b/vfs/vfs_test.goindex 1e8fb6486..2bd35ee1d 100644--- a/vfs/vfs_test.go+++ b/vfs/vfs_test.go@@ -138,10 +138,8 @@ func TestVFSNew(t *testing.T) {r, vfs := newTestVFS(t)// Check making a VFS with nil options- var defaultOpt = vfscommon.DefaultOpt- defaultOpt.DirPerms |= os.ModeDir- assert.Equal(t, vfs.Opt, defaultOpt)- assert.Equal(t, vfs.f, r.Fremote)+ var defaultOpt = vfscommon.Opt+ defaultOpt.Init()checkActiveCacheEntries(1)@@ -164,14 +162,14 @@ func TestVFSNew(t *testing.T) {// TestVFSNewWithOpts sees if the New command works properlyfunc TestVFSNewWithOpts(t *testing.T) {- var opt = vfscommon.DefaultOpt+ var opt = vfscommon.Optopt.DirPerms = 0777opt.FilePerms = 0666opt.Umask = 0002_, vfs := newTestVFSOpt(t, &opt)- assert.Equal(t, os.FileMode(0775)|os.ModeDir, vfs.Opt.DirPerms)- assert.Equal(t, os.FileMode(0664), vfs.Opt.FilePerms)+ assert.Equal(t, vfscommon.FileMode(0775)|vfscommon.FileMode(os.ModeDir), vfs.Opt.DirPerms)+ assert.Equal(t, vfscommon.FileMode(0664), vfs.Opt.FilePerms)}// TestVFSRoot checks root directory is present and correct@@ -182,7 +180,7 @@ func TestVFSRoot(t *testing.T) {require.NoError(t, err)assert.Equal(t, vfs.root, root)assert.True(t, root.IsDir())- assert.Equal(t, vfs.Opt.DirPerms.Perm(), root.Mode().Perm())+ assert.Equal(t, os.FileMode(vfs.Opt.DirPerms).Perm(), root.Mode().Perm())}func TestVFSStat(t *testing.T) {diff --git a/vfs/vfscache/cache_test.go b/vfs/vfscache/cache_test.goindex 684fcb61b..61357c2f9 100644--- a/vfs/vfscache/cache_test.go+++ b/vfs/vfscache/cache_test.go@@ -104,7 +104,7 @@ func newTestCacheOpt(t *testing.T, opt vfscommon.Options) (r *fstest.Run, c *Cac}func newTestCache(t *testing.T) (r *fstest.Run, c *Cache) {- opt := vfscommon.DefaultOpt+ opt := vfscommon.Opt// Disable the cache cleaner as it interferes with these testsopt.CachePollInterval = 0@@ -627,7 +627,7 @@ func TestCacheRename(t *testing.T) {}func TestCacheCleaner(t *testing.T) {- opt := vfscommon.DefaultOpt+ opt := vfscommon.Optopt.CachePollInterval = fs.Duration(10 * time.Millisecond)opt.CacheMaxAge = fs.Duration(20 * time.Millisecond)_, c := newTestCacheOpt(t, opt)diff --git a/vfs/vfscache/downloaders/downloaders_test.go b/vfs/vfscache/downloaders/downloaders_test.goindex bc31848c9..8d82c3f99 100644--- a/vfs/vfscache/downloaders/downloaders_test.go+++ b/vfs/vfscache/downloaders/downloaders_test.go@@ -93,7 +93,7 @@ func TestDownloaders(t *testing.T) {t: t,size: size,}- opt := vfscommon.DefaultOpt+ opt := vfscommon.Optdls := New(item, &opt, remote, src)return item, dls}diff --git a/vfs/vfscache/item_test.go b/vfs/vfscache/item_test.goindex fc3eeddad..9fa2f3dbe 100644--- a/vfs/vfscache/item_test.go+++ b/vfs/vfscache/item_test.go@@ -24,7 +24,7 @@ import (var zeroes = string(make([]byte, 100))func newItemTestCache(t *testing.T) (r *fstest.Run, c *Cache) {- opt := vfscommon.DefaultOpt+ opt := vfscommon.Opt// Disable the cache cleaner as it interferes with these testsopt.CachePollInterval = 0diff --git a/vfs/vfscache/writeback/writeback_test.go b/vfs/vfscache/writeback/writeback_test.goindex 650be9a81..64645eccf 100644--- a/vfs/vfscache/writeback/writeback_test.go+++ b/vfs/vfscache/writeback/writeback_test.go@@ -17,7 +17,7 @@ import (func newTestWriteBack(t *testing.T) (wb *WriteBack, cancel func()) {ctx, cancel := context.WithCancel(context.Background())- opt := vfscommon.DefaultOpt+ opt := vfscommon.Optopt.WriteBack = fs.Duration(100 * time.Millisecond)wb = New(ctx, &opt)return wb, canceldiff --git a/vfs/vfscommon/filemode.go b/vfs/vfscommon/filemode.gonew file mode 100644index 000000000..109db6c18--- /dev/null+++ b/vfs/vfscommon/filemode.go@@ -0,0 +1,40 @@+package vfscommon++import (+ "fmt"+ "os"+ "strconv"++ "github.com/rclone/rclone/fs"+)++// FileMode is a command line friendly os.FileMode+type FileMode os.FileMode++// String turns FileMode into a string+func (x FileMode) String() string {+ return fmt.Sprintf("%03o", x)+}++// Set a FileMode+func (x *FileMode) Set(s string) error {+ i, err := strconv.ParseInt(s, 8, 32)+ if err != nil {+ return fmt.Errorf("bad FileMode - must be octal digits: %w", err)+ }+ *x = (FileMode)(i)+ return nil+}++// Type of the value+func (x FileMode) Type() string {+ return "FileMode"+}++// UnmarshalJSON makes sure the value can be parsed as a string or integer in JSON+func (x *FileMode) UnmarshalJSON(in []byte) error {+ return fs.UnmarshalJSONFlag(in, x, func(i int64) error {+ *x = FileMode(i)+ return nil+ })+}diff --git a/vfs/vfscommon/filemode_test.go b/vfs/vfscommon/filemode_test.gonew file mode 100644index 000000000..310194ca4--- /dev/null+++ b/vfs/vfscommon/filemode_test.go@@ -0,0 +1,77 @@+package vfscommon++import (+ "encoding/json"+ "testing"++ "github.com/rclone/rclone/fs"+ "github.com/stretchr/testify/assert"+ "github.com/stretchr/testify/require"+)++// Check it satisfies the interfaces+var (+ _ fs.Flagger = (*FileMode)(nil)+ _ fs.FlaggerNP = FileMode(0)+)++func TestFileModeString(t *testing.T) {+ for _, test := range []struct {+ in FileMode+ want string+ }{+ {0, "000"},+ {0666, "666"},+ {02666, "2666"},+ } {+ got := test.in.String()+ assert.Equal(t, test.want, got)+ }+}++func TestFileModeSet(t *testing.T) {+ for _, test := range []struct {+ in string+ want FileMode+ err bool+ }{+ {"0", 0, false},+ {"0666", 0666, false},+ {"666", 0666, false},+ {"2666", 02666, false},+ {"999", 0, true},+ } {+ got := FileMode(0)+ err := got.Set(test.in)+ if test.err {+ require.Error(t, err, test.in)+ } else {+ require.NoError(t, err, test.in)+ }+ assert.Equal(t, test.want, got)+ }+}++func TestFileModeUnmarshalJSON(t *testing.T) {+ for _, test := range []struct {+ in string+ want FileMode+ err bool+ }{+ {`"0"`, 0, false},+ {`"666"`, 0666, false},+ {`"02666"`, 02666, false},+ {`"999"`, 0, true},+ {`438`, 0666, false},+ {`"999"`, 0, true},+ } {+ var ss FileMode+ err := json.Unmarshal([]byte(test.in), &ss)+ if test.err {+ require.Error(t, err, test.in)+ } else {+ require.NoError(t, err, test.in)+ }+ assert.Equal(t, test.want, ss, test.in)+ }+}diff --git a/vfs/vfscommon/options.go b/vfs/vfscommon/options.goindex 754e53218..12ccd8664 100644--- a/vfs/vfscommon/options.go+++ b/vfs/vfscommon/options.go@@ -8,75 +8,194 @@ import ("github.com/rclone/rclone/fs")+// OptionsInfo describes the Options in use+var OptionsInfo = fs.Options{{+ Name: "no_modtime",+ Default: false,+ Help: "Don't read/write the modification time (can speed things up)",+ Groups: "VFS",+}, {+ Name: "no_checksum",+ Default: false,+ Help: "Don't compare checksums on up/download",+ Groups: "VFS",+}, {+ Name: "no_seek",+ Default: false,+ Help: "Don't allow seeking in files",+ Groups: "VFS",+}, {+ Name: "dir_cache_time",+ Default: fs.Duration(5 * 60 * time.Second),+ Help: "Time to cache directory entries for",+ Groups: "VFS",+}, {+ Name: "vfs_refresh",+ Default: false,+ Help: "Refreshes the directory cache recursively in the background on start",+ Groups: "VFS",+}, {+ Name: "poll_interval",+ Default: fs.Duration(time.Minute),+ Help: "Time to wait between polling for changes, must be smaller than dir-cache-time and only on supported remotes (set 0 to disable)",+ Groups: "VFS",+}, {+ Name: "read_only",+ Default: false,+ Help: "Only allow read-only access",+ Groups: "VFS",+}, {+ Name: "vfs_cache_mode",+ Default: CacheModeOff,+ Help: "Cache mode off|minimal|writes|full",+ Groups: "VFS",+}, {+ Name: "vfs_cache_poll_interval",+ Default: fs.Duration(60 * time.Second),+ Help: "Interval to poll the cache for stale objects",+ Groups: "VFS",+}, {+ Name: "vfs_cache_max_age",+ Default: fs.Duration(3600 * time.Second),+ Help: "Max time since last access of objects in the cache",+ Groups: "VFS",+}, {+ Name: "vfs_cache_max_size",+ Default: fs.SizeSuffix(-1),+ Help: "Max total size of objects in the cache",+ Groups: "VFS",+}, {+ Name: "vfs_cache_min_free_space",+ Default: fs.SizeSuffix(-1),+ Help: "Target minimum free space on the disk containing the cache",+ Groups: "VFS",+}, {+ Name: "vfs_read_chunk_size",+ Default: 128 * fs.Mebi,+ Help: "Read the source objects in chunks",+ Groups: "VFS",+}, {+ Name: "vfs_read_chunk_size_limit",+ Default: fs.SizeSuffix(-1),+ Help: "If greater than --vfs-read-chunk-size, double the chunk size after each chunk read, until the limit is reached ('off' is unlimited)",+ Groups: "VFS",+}, {+ Name: "dir_perms",+ Default: FileMode(0777),+ Help: "Directory permissions",+ Groups: "VFS",+}, {+ Name: "file_perms",+ Default: FileMode(0666),+ Help: "File permissions",+ Groups: "VFS",+}, {+ Name: "vfs_case_insensitive",+ Default: runtime.GOOS == "windows" || runtime.GOOS == "darwin", // default to true on Windows and Mac, false otherwise,+ Help: "If a file name not found, find a case insensitive match",+ Groups: "VFS",+}, {+ Name: "vfs_block_norm_dupes",+ Default: false,+ Help: "If duplicate filenames exist in the same directory (after normalization), log an error and hide the duplicates (may have a performance cost)",+ Groups: "VFS",+}, {+ Name: "vfs_write_wait",+ Default: fs.Duration(1000 * time.Millisecond),+ Help: "Time to wait for in-sequence write before giving error",+ Groups: "VFS",+}, {+ Name: "vfs_read_wait",+ Default: fs.Duration(20 * time.Millisecond),+ Help: "Time to wait for in-sequence read before seeking",+ Groups: "VFS",+}, {+ Name: "vfs_write_back",+ Default: fs.Duration(5 * time.Second),+ Help: "Time to writeback files after last use when using cache",+ Groups: "VFS",+}, {+ Name: "vfs_read_ahead",+ Default: 0 * fs.Mebi,+ Help: "Extra read ahead over --buffer-size when using cache-mode full",+ Groups: "VFS",+}, {+ Name: "vfs_used_is_size",+ Default: false,+ Help: "Use the `rclone size` algorithm for Used size",+ Groups: "VFS",+}, {+ Name: "vfs_fast_fingerprint",+ Default: false,+ Help: "Use fast (less accurate) fingerprints for change detection",+ Groups: "VFS",+}, {+ Name: "vfs_disk_space_total_size",+ Default: fs.SizeSuffix(-1),+ Help: "Specify the total space of disk",+ Groups: "VFS",+}, {+ Name: "umask",+ Default: FileMode(getUmask()),+ Help: "Override the permission bits set by the filesystem (not supported on Windows)",+ Groups: "VFS",+}, {+ Name: "uid",+ Default: getUID(),+ Help: "Override the uid field set by the filesystem (not supported on Windows)",+ Groups: "VFS",+}, {+ Name: "gid",+ Default: getGID(),+ Help: "Override the gid field set by the filesystem (not supported on Windows)",+ Groups: "VFS",+}}++func init() {+ fs.RegisterGlobalOptions(fs.OptionsInfo{Name: "vfs", Opt: &Opt, Options: OptionsInfo})+}+// Options is options for creating the vfstype Options struct {- NoSeek bool // don't allow seeking if set- NoChecksum bool // don't check checksums if set- ReadOnly bool // if set VFS is read only- NoModTime bool // don't read mod times for files- DirCacheTime fs.Duration // how long to consider directory listing cache valid- Refresh bool // refreshes the directory listing recursively on start- PollInterval fs.Duration- Umask int- UID uint32- GID uint32- DirPerms os.FileMode- FilePerms os.FileMode- ChunkSize fs.SizeSuffix // if > 0 read files in chunks- ChunkSizeLimit fs.SizeSuffix // if > ChunkSize double the chunk size after each chunk until reached- CacheMode CacheMode- CacheMaxAge fs.Duration- CacheMaxSize fs.SizeSuffix- CacheMinFreeSpace fs.SizeSuffix- CachePollInterval fs.Duration- CaseInsensitive bool- BlockNormDupes bool- WriteWait fs.Duration // time to wait for in-sequence write- ReadWait fs.Duration // time to wait for in-sequence read- WriteBack fs.Duration // time to wait before writing back dirty files- ReadAhead fs.SizeSuffix // bytes to read ahead in cache mode "full"- UsedIsSize bool // if true, use the `rclone size` algorithm for Used size- FastFingerprint bool // if set use fast fingerprints- DiskSpaceTotalSize fs.SizeSuffix+ NoSeek bool `config:"no_seek"` // don't allow seeking if set+ NoChecksum bool `config:"no_checksum"` // don't check checksums if set+ ReadOnly bool `config:"read_only"` // if set VFS is read only+ NoModTime bool `config:"no_modtime"` // don't read mod times for files+ DirCacheTime fs.Duration `config:"dir_cache_time"` // how long to consider directory listing cache valid+ Refresh bool `config:"vfs_refresh"` // refreshes the directory listing recursively on start+ PollInterval fs.Duration `config:"poll_interval"`+ Umask FileMode `config:"umask"`+ UID uint32 `config:"uid"`+ GID uint32 `config:"gid"`+ DirPerms FileMode `config:"dir_perms"`+ FilePerms FileMode `config:"file_perms"`+ ChunkSize fs.SizeSuffix `config:"vfs_read_chunk_size"` // if > 0 read files in chunks+ ChunkSizeLimit fs.SizeSuffix `config:"vfs_read_chunk_size_limit"` // if > ChunkSize double the chunk size after each chunk until reached+ CacheMode CacheMode `config:"vfs_cache_mode"`+ CacheMaxAge fs.Duration `config:"vfs_cache_max_age"`+ CacheMaxSize fs.SizeSuffix `config:"vfs_cache_max_size"`+ CacheMinFreeSpace fs.SizeSuffix `config:"vfs_cache_min_free_space"`+ CachePollInterval fs.Duration `config:"vfs_cache_poll_interval"`+ CaseInsensitive bool `config:"vfs_case_insensitive"`+ BlockNormDupes bool `config:"vfs_block_norm_dupes"`+ WriteWait fs.Duration `config:"vfs_write_wait"` // time to wait for in-sequence write+ ReadWait fs.Duration `config:"vfs_read_wait"` // time to wait for in-sequence read+ WriteBack fs.Duration `config:"vfs_write_back"` // time to wait before writing back dirty files+ ReadAhead fs.SizeSuffix `config:"vfs_read_ahead"` // bytes to read ahead in cache mode "full"+ UsedIsSize bool `config:"vfs_used_is_size"` // if true, use the `rclone size` algorithm for Used size+ FastFingerprint bool `config:"vfs_fast_fingerprint"` // if set use fast fingerprints+ DiskSpaceTotalSize fs.SizeSuffix `config:"vfs_disk_space_total_size"`}-// DefaultOpt is the default values uses for Opt-var DefaultOpt = Options{- NoModTime: false,- NoChecksum: false,- NoSeek: false,- DirCacheTime: fs.Duration(5 * 60 * time.Second),- Refresh: false,- PollInterval: fs.Duration(time.Minute),- ReadOnly: false,- Umask: 0,- UID: ^uint32(0), // these values instruct WinFSP-FUSE to use the current user- GID: ^uint32(0), // overridden for non windows in mount_unix.go- DirPerms: os.FileMode(0777),- FilePerms: os.FileMode(0666),- CacheMode: CacheModeOff,- CacheMaxAge: fs.Duration(3600 * time.Second),- CachePollInterval: fs.Duration(60 * time.Second),- ChunkSize: 128 * fs.Mebi,- ChunkSizeLimit: -1,- CacheMaxSize: -1,- CacheMinFreeSpace: -1,- CaseInsensitive: runtime.GOOS == "windows" || runtime.GOOS == "darwin", // default to true on Windows and Mac, false otherwise- WriteWait: fs.Duration(1000 * time.Millisecond),- ReadWait: fs.Duration(20 * time.Millisecond),- WriteBack: fs.Duration(5 * time.Second),- ReadAhead: 0 * fs.Mebi,- UsedIsSize: false,- DiskSpaceTotalSize: -1,-}+// Opt is the default options modified by the environment variables and command line flags+var Opt Options// Init the options, making sure everything is within rangefunc (opt *Options) Init() {// Mask the permissions with the umask- opt.DirPerms &= ^os.FileMode(opt.Umask)- opt.FilePerms &= ^os.FileMode(opt.Umask)+ opt.DirPerms &= ^opt.Umask+ opt.FilePerms &= ^opt.Umask// Make sure directories are returned as directories- opt.DirPerms |= os.ModeDir-+ opt.DirPerms |= FileMode(os.ModeDir)}diff --git a/vfs/vfscommon/vfsflags_non_unix.go b/vfs/vfscommon/vfsflags_non_unix.gonew file mode 100644index 000000000..0cf18a200--- /dev/null+++ b/vfs/vfscommon/vfsflags_non_unix.go@@ -0,0 +1,18 @@+//go:build !linux && !darwin && !freebsd++package vfscommon++// get the current umask+func getUmask() int {+ return 0000+}++// get the current uid+func getUID() uint32 {+ return ^uint32(0) // these values instruct WinFSP-FUSE to use the current user+}++// get the current gid+func getGID() uint32 {+ return ^uint32(0) // these values instruct WinFSP-FUSE to use the current user+}diff --git a/vfs/vfscommon/vfsflags_unix.go b/vfs/vfscommon/vfsflags_unix.gonew file mode 100644index 000000000..48ea7ef2e--- /dev/null+++ b/vfs/vfscommon/vfsflags_unix.go@@ -0,0 +1,24 @@+//go:build linux || darwin || freebsd++package vfscommon++import (+ "golang.org/x/sys/unix"+)++// get the current umask+func getUmask() int {+ umask := unix.Umask(0) // read the umask+ unix.Umask(umask) // set it back to what it was+ return umask+}++// get the current uid+func getUID() uint32 {+ return uint32(unix.Geteuid())+}++// get the current gid+func getGID() uint32 {+ return uint32(unix.Getegid())+}diff --git a/vfs/vfsflags/filemode.go b/vfs/vfsflags/filemode.godeleted file mode 100644index a6a69f610..000000000--- a/vfs/vfsflags/filemode.go+++ /dev/null@@ -1,32 +0,0 @@-package vfsflags--import (- "fmt"- "os"- "strconv"-)--// FileMode is a command line friendly os.FileMode-type FileMode struct {- Mode *os.FileMode-}--// String turns FileMode into a string-func (x *FileMode) String() string {- return fmt.Sprintf("0%3o", *x.Mode)-}--// Set a FileMode-func (x *FileMode) Set(s string) error {- i, err := strconv.ParseInt(s, 8, 32)- if err != nil {- return fmt.Errorf("bad FileMode - must be octal digits: %w", err)- }- *x.Mode = (os.FileMode)(i)- return nil-}--// Type of the value-func (x *FileMode) Type() string {- return "FileMode"-}diff --git a/vfs/vfsflags/vfsflags.go b/vfs/vfsflags/vfsflags.goindex 62090f490..f5709d7a8 100644--- a/vfs/vfsflags/vfsflags.go+++ b/vfs/vfsflags/vfsflags.go@@ -3,45 +3,11 @@ package vfsflagsimport ("github.com/rclone/rclone/fs/config/flags"- "github.com/rclone/rclone/fs/rc""github.com/rclone/rclone/vfs/vfscommon""github.com/spf13/pflag")-// Options set by command line flags-var (- Opt = vfscommon.DefaultOpt- DirPerms = &FileMode{Mode: &Opt.DirPerms}- FilePerms = &FileMode{Mode: &Opt.FilePerms}-)-// AddFlags adds the non filing system specific flags to the commandfunc AddFlags(flagSet *pflag.FlagSet) {- rc.AddOption("vfs", &Opt)- flags.BoolVarP(flagSet, &Opt.NoModTime, "no-modtime", "", Opt.NoModTime, "Don't read/write the modification time (can speed things up)", "VFS")- flags.BoolVarP(flagSet, &Opt.NoChecksum, "no-checksum", "", Opt.NoChecksum, "Don't compare checksums on up/download", "VFS")- flags.BoolVarP(flagSet, &Opt.NoSeek, "no-seek", "", Opt.NoSeek, "Don't allow seeking in files", "VFS")- flags.FVarP(flagSet, &Opt.DirCacheTime, "dir-cache-time", "", "Time to cache directory entries for", "VFS")- flags.BoolVarP(flagSet, &Opt.Refresh, "vfs-refresh", "", Opt.Refresh, "Refreshes the directory cache recursively in the background on start", "VFS")- flags.FVarP(flagSet, &Opt.PollInterval, "poll-interval", "", "Time to wait between polling for changes, must be smaller than dir-cache-time and only on supported remotes (set 0 to disable)", "VFS")- flags.BoolVarP(flagSet, &Opt.ReadOnly, "read-only", "", Opt.ReadOnly, "Only allow read-only access", "VFS")- flags.FVarP(flagSet, &Opt.CacheMode, "vfs-cache-mode", "", "Cache mode off|minimal|writes|full", "VFS")- flags.FVarP(flagSet, &Opt.CachePollInterval, "vfs-cache-poll-interval", "", "Interval to poll the cache for stale objects", "VFS")- flags.FVarP(flagSet, &Opt.CacheMaxAge, "vfs-cache-max-age", "", "Max time since last access of objects in the cache", "VFS")- flags.FVarP(flagSet, &Opt.CacheMaxSize, "vfs-cache-max-size", "", "Max total size of objects in the cache", "VFS")- flags.FVarP(flagSet, &Opt.CacheMinFreeSpace, "vfs-cache-min-free-space", "", "Target minimum free space on the disk containing the cache", "VFS")- flags.FVarP(flagSet, &Opt.ChunkSize, "vfs-read-chunk-size", "", "Read the source objects in chunks", "VFS")- flags.FVarP(flagSet, &Opt.ChunkSizeLimit, "vfs-read-chunk-size-limit", "", "If greater than --vfs-read-chunk-size, double the chunk size after each chunk read, until the limit is reached ('off' is unlimited)", "VFS")- flags.FVarP(flagSet, DirPerms, "dir-perms", "", "Directory permissions", "VFS")- flags.FVarP(flagSet, FilePerms, "file-perms", "", "File permissions", "VFS")- flags.BoolVarP(flagSet, &Opt.CaseInsensitive, "vfs-case-insensitive", "", Opt.CaseInsensitive, "If a file name not found, find a case insensitive match", "VFS")- flags.BoolVarP(flagSet, &Opt.BlockNormDupes, "vfs-block-norm-dupes", "", Opt.BlockNormDupes, "If duplicate filenames exist in the same directory (after normalization), log an error and hide the duplicates (may have a performance cost)", "VFS")- flags.FVarP(flagSet, &Opt.WriteWait, "vfs-write-wait", "", "Time to wait for in-sequence write before giving error", "VFS")- flags.FVarP(flagSet, &Opt.ReadWait, "vfs-read-wait", "", "Time to wait for in-sequence read before seeking", "VFS")- flags.FVarP(flagSet, &Opt.WriteBack, "vfs-write-back", "", "Time to writeback files after last use when using cache", "VFS")- flags.FVarP(flagSet, &Opt.ReadAhead, "vfs-read-ahead", "", "Extra read ahead over --buffer-size when using cache-mode full", "VFS")- flags.BoolVarP(flagSet, &Opt.UsedIsSize, "vfs-used-is-size", "", Opt.UsedIsSize, "Use the `rclone size` algorithm for Used size", "VFS")- flags.BoolVarP(flagSet, &Opt.FastFingerprint, "vfs-fast-fingerprint", "", Opt.FastFingerprint, "Use fast (less accurate) fingerprints for change detection", "VFS")- flags.FVarP(flagSet, &Opt.DiskSpaceTotalSize, "vfs-disk-space-total-size", "", "Specify the total space of disk", "VFS")- platformFlags(flagSet)+ flags.AddFlagsFromOptions(flagSet, "", vfscommon.OptionsInfo)}diff --git a/vfs/vfsflags/vfsflags_non_unix.go b/vfs/vfsflags/vfsflags_non_unix.godeleted file mode 100644index 68c2af5ac..000000000--- a/vfs/vfsflags/vfsflags_non_unix.go+++ /dev/null@@ -1,11 +0,0 @@-//go:build !linux && !darwin && !freebsd--package vfsflags--import (- "github.com/spf13/pflag"-)--// add any extra platform specific flags-func platformFlags(flags *pflag.FlagSet) {-}diff --git a/vfs/vfsflags/vfsflags_unix.go b/vfs/vfsflags/vfsflags_unix.godeleted file mode 100644index 83af3f2a8..000000000--- a/vfs/vfsflags/vfsflags_unix.go+++ /dev/null@@ -1,20 +0,0 @@-//go:build linux || darwin || freebsd--package vfsflags--import (- "github.com/rclone/rclone/fs/config/flags"- "github.com/spf13/pflag"- "golang.org/x/sys/unix"-)--// add any extra platform specific flags-func platformFlags(flagSet *pflag.FlagSet) {- Opt.Umask = unix.Umask(0) // read the umask- unix.Umask(Opt.Umask) // set it back to what it was- flags.IntVarP(flagSet, &Opt.Umask, "umask", "", Opt.Umask, "Override the permission bits set by the filesystem (not supported on Windows)", "VFS")- Opt.UID = uint32(unix.Geteuid())- Opt.GID = uint32(unix.Getegid())- flags.Uint32VarP(flagSet, &Opt.UID, "uid", "", Opt.UID, "Override the uid field set by the filesystem (not supported on Windows)", "VFS")- flags.Uint32VarP(flagSet, &Opt.GID, "gid", "", Opt.GID, "Override the gid field set by the filesystem (not supported on Windows)", "VFS")-}diff --git a/vfs/vfstest/fs.go b/vfs/vfstest/fs.goindex 011f02985..97436d38e 100644--- a/vfs/vfstest/fs.go+++ b/vfs/vfstest/fs.go@@ -26,7 +26,6 @@ import ("github.com/rclone/rclone/fs/walk""github.com/rclone/rclone/fstest""github.com/rclone/rclone/vfs/vfscommon"- "github.com/rclone/rclone/vfs/vfsflags""github.com/stretchr/testify/assert""github.com/stretchr/testify/require")@@ -62,7 +61,7 @@ func RunTests(t *testing.T, useVFS bool, minimumRequiredCacheMode vfscommon.Cachif test.cacheMode < minimumRequiredCacheMode {continue}- vfsOpt := vfsflags.Opt+ vfsOpt := vfscommon.OptvfsOpt.CacheMode = test.cacheModevfsOpt.WriteBack = test.writeBackrun = newRun(useVFS, &vfsOpt, mountFn)@@ -235,10 +234,10 @@ func (r *Run) readLocal(t *testing.T, dir dirMap, filePath string) {if fi.IsDir() {dir[name+"/"] = struct{}{}r.readLocal(t, dir, name)- assert.Equal(t, r.vfsOpt.DirPerms&os.ModePerm, fi.Mode().Perm())+ assert.Equal(t, os.FileMode(r.vfsOpt.DirPerms)&os.ModePerm, fi.Mode().Perm())} else {dir[fmt.Sprintf("%s %d", name, fi.Size())] = struct{}{}- assert.Equal(t, r.vfsOpt.FilePerms&os.ModePerm, fi.Mode().Perm())+ assert.Equal(t, os.FileMode(r.vfsOpt.FilePerms)&os.ModePerm, fi.Mode().Perm())}}}@@ -377,5 +376,5 @@ func TestRoot(t *testing.T) {fi, err := os.Lstat(run.mountPath)require.NoError(t, err)assert.True(t, fi.IsDir())- assert.Equal(t, run.vfsOpt.DirPerms&os.ModePerm, fi.Mode().Perm())+ assert.Equal(t, os.FileMode(run.vfsOpt.DirPerms)&os.ModePerm, fi.Mode().Perm())}