From 190367d917763b55636cc602c2c8be0e2caed0ee Mon Sep 17 00:00:00 2001 From: Nick Craig-Wood Date: Mon, 30 Oct 2017 10:14:39 +0000 Subject: [PATCH] vfs: factor duplicated Open code into vfs from mount/cmount --- cmd/cmount/fs.go | 36 ++++++++++++++--------------------- cmd/mount/file.go | 48 +++++++++++++++++------------------------------ cmd/mount/fs.go | 2 ++ vfs/dir.go | 30 ++++++++++++++++++----------- vfs/dir_handle.go | 16 ++++++++++++++++ vfs/file.go | 32 +++++++++++++++++++++++++++---- vfs/vfs.go | 46 ++++++++++----------------------------------- 7 files changed, 106 insertions(+), 104 deletions(-) diff --git a/cmd/cmount/fs.go b/cmd/cmount/fs.go index feff7d5cc..59d8bcd2b 100644 --- a/cmd/cmount/fs.go +++ b/cmd/cmount/fs.go @@ -337,31 +337,21 @@ func (fsys *FS) Statfs(path string, stat *fuse.Statfs_t) (errc int) { // Open opens a file func (fsys *FS) Open(path string, flags int) (errc int, fh uint64) { defer fs.Trace(path, "flags=0x%X", flags)("errc=%d, fh=0x%X", &errc, &fh) - file, errc := fsys.lookupFile(path) + + // fuse flags are based off syscall flags as are os flags, so + // should be compatible + handle, err := fsys.VFS.OpenFile(path, flags, 0777) if errc != 0 { - return errc, fhUnset + return translateError(err), fhUnset } - rdwrMode := flags & fuse.O_ACCMODE - var err error - var handle vfs.Noder - switch { - case rdwrMode == fuse.O_RDONLY: - handle, err = file.OpenRead() - if err != nil { - return translateError(err), fhUnset - } - return 0, fsys.openFilesRd.Open(handle) - case rdwrMode == fuse.O_WRONLY || (rdwrMode == fuse.O_RDWR && (flags&fuse.O_TRUNC) != 0): - handle, err = file.OpenWrite() - if err != nil { - return translateError(err), fhUnset - } - return 0, fsys.openFilesWr.Open(handle) - case rdwrMode == fuse.O_RDWR: - fs.Errorf(path, "Can't open for Read and Write") - return -fuse.EPERM, fhUnset + + switch fh := handle.(type) { + case *vfs.WriteFileHandle: + return 0, fsys.openFilesWr.Open(fh) + case *vfs.ReadFileHandle: + return 0, fsys.openFilesRd.Open(fh) } - fs.Errorf(path, "Can't figure out how to open with flags: 0x%X", flags) + return -fuse.EPERM, fhUnset } @@ -648,6 +638,8 @@ func translateError(err error) (errc int) { return -fuse.EBADF case vfs.EROFS: return -fuse.EROFS + case vfs.ENOSYS: + return -fuse.ENOSYS } fs.Errorf(nil, "IO error: %v", err) return -fuse.EIO diff --git a/cmd/mount/file.go b/cmd/mount/file.go index 024acc2ee..35a4f76ca 100644 --- a/cmd/mount/file.go +++ b/cmd/mount/file.go @@ -9,7 +9,6 @@ import ( fusefs "bazil.org/fuse/fs" "github.com/ncw/rclone/fs" "github.com/ncw/rclone/vfs" - "github.com/pkg/errors" "golang.org/x/net/context" ) @@ -62,40 +61,27 @@ var _ fusefs.NodeOpener = (*File)(nil) // Open the file for read or write func (f *File) Open(ctx context.Context, req *fuse.OpenRequest, resp *fuse.OpenResponse) (fh fusefs.Handle, err error) { defer fs.Trace(f, "flags=%v", req.Flags)("fh=%v, err=%v", &fh, &err) - switch { - case req.Flags.IsReadOnly(): - if f.VFS().Opt.NoSeek { - resp.Flags |= fuse.OpenNonSeekable - } - var rfh *vfs.ReadFileHandle - rfh, err = f.File.OpenRead() - fh = &ReadFileHandle{rfh} - case req.Flags.IsWriteOnly() || (req.Flags.IsReadWrite() && (req.Flags&fuse.OpenTruncate) != 0): - resp.Flags |= fuse.OpenNonSeekable - var wfh *vfs.WriteFileHandle - wfh, err = f.File.OpenWrite() - fh = &WriteFileHandle{wfh} - case req.Flags.IsReadWrite(): - err = errors.New("can't open for read and write simultaneously") - default: - err = errors.Errorf("can't figure out how to open with flags %v", req.Flags) - } - - /* - // File was opened in append-only mode, all writes will go to end - // of file. OS X does not provide this information. - OpenAppend OpenFlags = syscall.O_APPEND - OpenCreate OpenFlags = syscall.O_CREAT - OpenDirectory OpenFlags = syscall.O_DIRECTORY - OpenExclusive OpenFlags = syscall.O_EXCL - OpenNonblock OpenFlags = syscall.O_NONBLOCK - OpenSync OpenFlags = syscall.O_SYNC - OpenTruncate OpenFlags = syscall.O_TRUNC - */ + // fuse flags are based off syscall flags as are os flags, so + // should be compatible + handle, err := f.File.Open(int(resp.Flags)) if err != nil { return nil, translateError(err) } + + switch h := handle.(type) { + case *vfs.ReadFileHandle: + if f.VFS().Opt.NoSeek { + resp.Flags |= fuse.OpenNonSeekable + } + fh = &ReadFileHandle{h} + case *vfs.WriteFileHandle: + resp.Flags |= fuse.OpenNonSeekable + fh = &WriteFileHandle{h} + default: + panic("unknown file handle type") + } + return fh, nil } diff --git a/cmd/mount/fs.go b/cmd/mount/fs.go index 8327d0e90..99bb55b5a 100644 --- a/cmd/mount/fs.go +++ b/cmd/mount/fs.go @@ -84,6 +84,8 @@ func translateError(err error) error { return fuse.Errno(syscall.EBADF) case vfs.EROFS: return fuse.Errno(syscall.EROFS) + case vfs.ENOSYS: + return fuse.Errno(syscall.ENOSYS) } return err } diff --git a/vfs/dir.go b/vfs/dir.go index 7ba6a96a3..b2f71eb77 100644 --- a/vfs/dir.go +++ b/vfs/dir.go @@ -211,7 +211,7 @@ func (d *Dir) _readDir() error { d.items[name] = newDir(d.vfs, d.f, d, dir) default: err = errors.Errorf("unknown type %T", item) - fs.Errorf(d.path, "readDir error: %v", err) + fs.Errorf(d, "readDir error: %v", err) return err } } @@ -276,12 +276,11 @@ func (d *Dir) SetModTime(modTime time.Time) error { // // Stat need not to handle the names "." and "..". func (d *Dir) Stat(name string) (node Node, err error) { - path := path.Join(d.path, name) // fs.Debugf(path, "Dir.Stat") node, err = d.stat(name) if err != nil { if err != ENOENT { - fs.Errorf(path, "Dir.Stat error: %v", err) + fs.Errorf(d, "Dir.Stat error: %v", err) } return nil, err } @@ -307,6 +306,16 @@ func (d *Dir) ReadDirAll() (items Nodes, err error) { return items, nil } +// Open the directory according to the flags provided +func (d *Dir) Open(flags int) (fd Handle, err error) { + rdwrMode := flags & (os.O_RDONLY | os.O_WRONLY | os.O_RDWR) + if rdwrMode != os.O_RDONLY { + fs.Errorf(d, "Can only open directories read only") + return nil, os.ErrPermission + } + return newDirHandle(d), nil +} + // Create makes a new file func (d *Dir) Create(name string) (*File, *WriteFileHandle, error) { if d.vfs.Opt.ReadOnly { @@ -319,7 +328,7 @@ func (d *Dir) Create(name string) (*File, *WriteFileHandle, error) { file := newFile(d, nil, name) fh, err := newWriteFileHandle(d, file, src) if err != nil { - fs.Errorf(path, "Dir.Create error: %v", err) + fs.Errorf(d, "Dir.Create error: %v", err) return nil, nil, err } // fs.Debugf(path, "Dir.Create OK") @@ -335,7 +344,7 @@ func (d *Dir) Mkdir(name string) (*Dir, error) { // fs.Debugf(path, "Dir.Mkdir") err := d.f.Mkdir(path) if err != nil { - fs.Errorf(path, "Dir.Mkdir failed to create directory: %v", err) + fs.Errorf(d, "Dir.Mkdir failed to create directory: %v", err) return nil, err } fsDir := fs.NewDir(path, time.Now()) @@ -353,17 +362,17 @@ func (d *Dir) Remove() error { // Check directory is empty first empty, err := d.isEmpty() if err != nil { - fs.Errorf(d.path, "Dir.Remove dir error: %v", err) + fs.Errorf(d, "Dir.Remove dir error: %v", err) return err } if !empty { - fs.Errorf(d.path, "Dir.Remove not empty") + fs.Errorf(d, "Dir.Remove not empty") return ENOTEMPTY } // remove directory err = d.f.Rmdir(d.path) if err != nil { - fs.Errorf(d.path, "Dir.Remove failed to remove directory: %v", err) + fs.Errorf(d, "Dir.Remove failed to remove directory: %v", err) return err } // Remove the item from the parent directory listing @@ -381,7 +390,7 @@ func (d *Dir) RemoveAll() error { // Remove contents of the directory nodes, err := d.ReadDirAll() if err != nil { - fs.Errorf(d.path, "Dir.RemoveAll failed to read directory: %v", err) + fs.Errorf(d, "Dir.RemoveAll failed to read directory: %v", err) return err } for _, node := range nodes { @@ -406,11 +415,10 @@ func (d *Dir) RemoveName(name string) error { if d.vfs.Opt.ReadOnly { return EROFS } - path := path.Join(d.path, name) // fs.Debugf(path, "Dir.Remove") node, err := d.stat(name) if err != nil { - fs.Errorf(path, "Dir.Remove error: %v", err) + fs.Errorf(d, "Dir.Remove error: %v", err) return err } return node.Remove() diff --git a/vfs/dir_handle.go b/vfs/dir_handle.go index 2a1e84286..b60065b2b 100644 --- a/vfs/dir_handle.go +++ b/vfs/dir_handle.go @@ -19,11 +19,27 @@ func newDirHandle(d *Dir) *DirHandle { } } +// String converts it to printable +func (fh *DirHandle) String() string { + if fh == nil { + return "" + } + if fh.d == nil { + return "" + } + return fh.d.String() + " (r)" +} + // Stat returns info about the current directory func (fh *DirHandle) Stat() (fi os.FileInfo, err error) { return fh.d, nil } +// Node returns the Node assocuated with this - satisfies Noder interface +func (fh *DirHandle) Node() Node { + return fh.d +} + // Readdir reads the contents of the directory associated with file and returns // a slice of up to n FileInfo values, as would be returned by Lstat, in // directory order. Subsequent calls on the same file will yield further diff --git a/vfs/file.go b/vfs/file.go index 0dc9e711c..d7043428e 100644 --- a/vfs/file.go +++ b/vfs/file.go @@ -161,7 +161,7 @@ func (f *File) applyPendingModTime() error { case fs.ErrorCantSetModTime, fs.ErrorCantSetModTimeWithoutDelete: // do nothing, in order to not break "touch somefile" if it exists already default: - fs.Errorf(f.o, "File.applyPendingModTime error: %v", err) + fs.Errorf(f, "File.applyPendingModTime error: %v", err) return err } @@ -216,7 +216,7 @@ func (f *File) OpenRead() (fh *ReadFileHandle, err error) { err = errors.Wrap(err, "open for read") if err != nil { - fs.Errorf(o, "File.OpenRead failed: %v", err) + fs.Errorf(f, "File.OpenRead failed: %v", err) return nil, err } return fh, nil @@ -239,7 +239,7 @@ func (f *File) OpenWrite() (fh *WriteFileHandle, err error) { err = errors.Wrap(err, "open for write") if err != nil { - fs.Errorf(o, "File.OpenWrite failed: %v", err) + fs.Errorf(f, "File.OpenWrite failed: %v", err) return nil, err } return fh, nil @@ -259,7 +259,7 @@ func (f *File) Remove() error { } err := f.o.Remove() if err != nil { - fs.Errorf(f.o, "File.Remove file error: %v", err) + fs.Errorf(f, "File.Remove file error: %v", err) return err } // Remove the item from the directory listing @@ -286,3 +286,27 @@ func (f *File) Dir() *Dir { func (f *File) VFS() *VFS { return f.d.vfs } + +// Open a file according to the flags provided +func (f *File) Open(flags int) (fd Handle, err error) { + rdwrMode := flags & (os.O_RDONLY | os.O_WRONLY | os.O_RDWR) + var read bool + switch { + case rdwrMode == os.O_RDONLY: + read = true + case rdwrMode == os.O_WRONLY || (rdwrMode == os.O_RDWR && (flags&os.O_TRUNC) != 0): + read = false + case rdwrMode == os.O_RDWR: + fs.Errorf(f, "Can't open for Read and Write") + return nil, os.ErrPermission + default: + fs.Errorf(f, "Can't figure out how to open with flags: 0x%X", flags) + return nil, os.ErrPermission + } + if read { + fd, err = f.OpenRead() + } else { + fd, err = f.OpenWrite() + } + return fd, err +} diff --git a/vfs/vfs.go b/vfs/vfs.go index 5329eeac9..8c5a1e723 100644 --- a/vfs/vfs.go +++ b/vfs/vfs.go @@ -50,6 +50,7 @@ type Node interface { RemoveAll() error DirEntry() fs.DirEntry VFS() *VFS + Open(flags int) (Handle, error) } // Check interfaces @@ -78,6 +79,7 @@ var ( _ Noder = (*Dir)(nil) _ Noder = (*ReadFileHandle)(nil) _ Noder = (*WriteFileHandle)(nil) + _ Noder = (*DirHandle)(nil) ) // Handle is the interface statisified by open files or directories. @@ -246,47 +248,19 @@ func (vfs *VFS) StatParent(name string) (dir *Dir, leaf string, err error) { // OpenFile a file according to the flags and perm provided func (vfs *VFS) OpenFile(name string, flags int, perm os.FileMode) (fd Handle, err error) { - rdwrMode := flags & (os.O_RDONLY | os.O_WRONLY | os.O_RDWR) - var read bool - switch { - case rdwrMode == os.O_RDONLY: - read = true - case rdwrMode == os.O_WRONLY || (rdwrMode == os.O_RDWR && (flags&os.O_TRUNC) != 0): - read = false - case rdwrMode == os.O_RDWR: - fs.Errorf(name, "Can't open for Read and Write") - return nil, os.ErrPermission - default: - fs.Errorf(name, "Can't figure out how to open with flags: 0x%X", flags) - return nil, os.ErrPermission - } node, err := vfs.Stat(name) if err != nil { - if err == os.ErrNotExist && !read { - return vfs.createFile(name, flags, perm) + if err == ENOENT && flags&os.O_CREATE != 0 { + dir, leaf, err := vfs.StatParent(name) + if err != nil { + return nil, err + } + _, fd, err = dir.Create(leaf) + return fd, err } return nil, err } - if node.IsFile() { - file := node.(*File) - if read { - fd, err = file.OpenRead() - } else { - fd, err = file.OpenWrite() - } - } else { - fd, err = newDirHandle(node.(*Dir)), nil - } - return fd, err -} - -func (vfs *VFS) createFile(name string, flags int, perm os.FileMode) (fd Handle, err error) { - dir, leaf, err := vfs.StatParent(name) - if err != nil { - return nil, err - } - _, fd, err = dir.Create(leaf) - return fd, err + return node.Open(flags) } // Rename oldName to newName