2017-10-28 19:01:34 +00:00
|
|
|
package vfs
|
2017-05-02 21:35:07 +00:00
|
|
|
|
|
|
|
import (
|
2019-06-17 08:34:30 +00:00
|
|
|
"context"
|
2017-10-25 09:00:26 +00:00
|
|
|
"os"
|
2017-05-09 10:29:02 +00:00
|
|
|
"path"
|
2017-05-02 21:35:07 +00:00
|
|
|
"sync"
|
|
|
|
"sync/atomic"
|
|
|
|
"time"
|
|
|
|
|
|
|
|
"github.com/pkg/errors"
|
2019-07-28 17:47:38 +00:00
|
|
|
"github.com/rclone/rclone/fs"
|
|
|
|
"github.com/rclone/rclone/fs/log"
|
|
|
|
"github.com/rclone/rclone/fs/operations"
|
2020-02-28 14:44:15 +00:00
|
|
|
"github.com/rclone/rclone/vfs/vfscommon"
|
2017-05-02 21:35:07 +00:00
|
|
|
)
|
|
|
|
|
2020-04-14 16:55:18 +00:00
|
|
|
// The File object is tightly coupled to the Dir object. Since they
|
|
|
|
// both have locks there is plenty of potential for deadlocks. In
|
|
|
|
// order to mitigate this, we use the following conventions
|
|
|
|
//
|
2020-04-14 17:14:24 +00:00
|
|
|
// File may **only** call these methods from Dir with the File lock
|
|
|
|
// held.
|
2020-04-14 16:55:18 +00:00
|
|
|
//
|
2020-04-14 17:14:24 +00:00
|
|
|
// Dir.Fs
|
|
|
|
// Dir.VFS
|
|
|
|
//
|
|
|
|
// (As these are read only and do not need to take the Dir mutex.)
|
|
|
|
//
|
|
|
|
// File may **not** call any other Dir methods with the File lock
|
|
|
|
// held. This preserves total lock ordering and makes File subordinate
|
|
|
|
// to Dir as far as locking is concerned, preventing deadlocks.
|
|
|
|
//
|
|
|
|
// File may **not** read any members of Dir directly.
|
2020-04-14 16:55:18 +00:00
|
|
|
|
2017-05-02 21:35:07 +00:00
|
|
|
// File represents a file
|
|
|
|
type File struct {
|
2019-11-06 21:48:43 +00:00
|
|
|
inode uint64 // inode number - read only
|
2018-02-18 13:12:26 +00:00
|
|
|
size int64 // size of file - read and written with atomic int64 - must be 64 bit aligned
|
|
|
|
|
2020-02-29 18:08:22 +00:00
|
|
|
mu sync.RWMutex // protects the following
|
|
|
|
d *Dir // parent directory
|
|
|
|
dPath string // path of parent directory. NB dir rename means all Files are flushed
|
|
|
|
o fs.Object // NB o may be nil if file is being written
|
|
|
|
leaf string // leaf name of the object
|
|
|
|
writers []Handle // writers for this file
|
|
|
|
nwriters int32 // len(writers) which is read/updated with atomic
|
|
|
|
pendingModTime time.Time // will be applied once o becomes available, i.e. after file was written
|
|
|
|
pendingRenameFun func(ctx context.Context) error // will be run/renamed after all writers close
|
|
|
|
appendMode bool // file was opened with O_APPEND
|
2020-07-08 09:27:26 +00:00
|
|
|
sys atomic.Value // user defined info to be attached here
|
2018-02-18 13:12:26 +00:00
|
|
|
|
2020-05-20 10:39:20 +00:00
|
|
|
muRW sync.Mutex // synchronize RWFileHandle.openPending(), RWFileHandle.close() and File.Remove
|
2017-05-02 21:35:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// newFile creates a new File
|
2019-11-25 11:31:44 +00:00
|
|
|
//
|
|
|
|
// o may be nil
|
2020-04-14 16:55:18 +00:00
|
|
|
func newFile(d *Dir, dPath string, o fs.Object, leaf string) *File {
|
2019-11-25 11:31:44 +00:00
|
|
|
f := &File{
|
2017-05-02 21:35:07 +00:00
|
|
|
d: d,
|
2020-04-14 16:55:18 +00:00
|
|
|
dPath: dPath,
|
2017-05-02 21:35:07 +00:00
|
|
|
o: o,
|
2017-05-09 10:29:02 +00:00
|
|
|
leaf: leaf,
|
2017-10-29 17:37:54 +00:00
|
|
|
inode: newInode(),
|
2017-05-02 21:35:07 +00:00
|
|
|
}
|
2019-11-25 11:31:44 +00:00
|
|
|
if o != nil {
|
|
|
|
f.size = o.Size()
|
|
|
|
}
|
|
|
|
return f
|
2017-05-02 21:35:07 +00:00
|
|
|
}
|
|
|
|
|
2017-05-09 10:29:02 +00:00
|
|
|
// String converts it to printable
|
|
|
|
func (f *File) String() string {
|
|
|
|
if f == nil {
|
|
|
|
return "<nil *File>"
|
|
|
|
}
|
2017-11-18 11:47:21 +00:00
|
|
|
return f.Path()
|
2017-05-09 10:29:02 +00:00
|
|
|
}
|
|
|
|
|
2017-05-02 21:35:07 +00:00
|
|
|
// IsFile returns true for File - satisfies Node interface
|
|
|
|
func (f *File) IsFile() bool {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
|
2017-10-25 09:00:26 +00:00
|
|
|
// IsDir returns false for File - satisfies Node interface
|
|
|
|
func (f *File) IsDir() bool {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
// Mode bits of the file or directory - satisfies Node interface
|
|
|
|
func (f *File) Mode() (mode os.FileMode) {
|
2019-11-06 21:48:43 +00:00
|
|
|
f.mu.RLock()
|
|
|
|
defer f.mu.RUnlock()
|
2019-10-15 00:57:15 +00:00
|
|
|
mode = f.d.vfs.Opt.FilePerms
|
|
|
|
if f.appendMode {
|
|
|
|
mode |= os.ModeAppend
|
|
|
|
}
|
|
|
|
return mode
|
2017-10-25 09:00:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Name (base) of the directory - satisfies Node interface
|
|
|
|
func (f *File) Name() (name string) {
|
2019-11-06 21:48:43 +00:00
|
|
|
f.mu.RLock()
|
|
|
|
defer f.mu.RUnlock()
|
2017-10-29 21:14:05 +00:00
|
|
|
return f.leaf
|
2017-10-25 09:00:26 +00:00
|
|
|
}
|
|
|
|
|
2020-01-19 12:52:48 +00:00
|
|
|
// _path returns the full path of the file
|
|
|
|
// use when lock is held
|
|
|
|
func (f *File) _path() string {
|
2020-04-14 16:55:18 +00:00
|
|
|
return path.Join(f.dPath, f.leaf)
|
2020-01-19 12:52:48 +00:00
|
|
|
}
|
|
|
|
|
2017-11-18 11:47:21 +00:00
|
|
|
// Path returns the full path of the file
|
|
|
|
func (f *File) Path() string {
|
2019-11-06 21:48:43 +00:00
|
|
|
f.mu.RLock()
|
2020-04-14 16:55:18 +00:00
|
|
|
dPath, leaf := f.dPath, f.leaf
|
2020-04-02 20:14:45 +00:00
|
|
|
f.mu.RUnlock()
|
2020-04-14 16:55:18 +00:00
|
|
|
return path.Join(dPath, leaf)
|
2017-11-18 11:47:21 +00:00
|
|
|
}
|
|
|
|
|
2017-10-25 09:00:26 +00:00
|
|
|
// Sys returns underlying data source (can be nil) - satisfies Node interface
|
|
|
|
func (f *File) Sys() interface{} {
|
2020-07-08 09:27:26 +00:00
|
|
|
return f.sys.Load()
|
2020-05-01 17:30:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// SetSys sets the underlying data source (can be nil) - satisfies Node interface
|
|
|
|
func (f *File) SetSys(x interface{}) {
|
2020-07-08 09:27:26 +00:00
|
|
|
f.sys.Store(x)
|
2017-10-25 09:00:26 +00:00
|
|
|
}
|
|
|
|
|
2017-05-02 21:35:07 +00:00
|
|
|
// Inode returns the inode number - satisfies Node interface
|
|
|
|
func (f *File) Inode() uint64 {
|
|
|
|
return f.inode
|
|
|
|
}
|
|
|
|
|
Spelling fixes
Fix spelling of: above, already, anonymous, associated,
authentication, bandwidth, because, between, blocks, calculate,
candidates, cautious, changelog, cleaner, clipboard, command,
completely, concurrently, considered, constructs, corrupt, current,
daemon, dependencies, deprecated, directory, dispatcher, download,
eligible, ellipsis, encrypter, endpoint, entrieslist, essentially,
existing writers, existing, expires, filesystem, flushing, frequently,
hierarchy, however, implementation, implements, inaccurate,
individually, insensitive, longer, maximum, metadata, modified,
multipart, namedirfirst, nextcloud, obscured, opened, optional,
owncloud, pacific, passphrase, password, permanently, persimmon,
positive, potato, protocol, quota, receiving, recommends, referring,
requires, revisited, satisfied, satisfies, satisfy, semver,
serialized, session, storage, strategies, stringlist, successful,
supported, surprise, temporarily, temporary, transactions, unneeded,
update, uploads, wrapped
Signed-off-by: Josh Soref <jsoref@users.noreply.github.com>
2020-10-09 00:17:24 +00:00
|
|
|
// Node returns the Node associated with this - satisfies Noder interface
|
2017-05-02 21:35:07 +00:00
|
|
|
func (f *File) Node() Node {
|
|
|
|
return f
|
|
|
|
}
|
|
|
|
|
2018-05-24 18:45:11 +00:00
|
|
|
// applyPendingRename runs a previously set rename operation if there are no
|
|
|
|
// more remaining writers. Call without lock held.
|
|
|
|
func (f *File) applyPendingRename() {
|
2019-11-06 21:48:43 +00:00
|
|
|
f.mu.RLock()
|
2018-05-24 18:45:11 +00:00
|
|
|
fun := f.pendingRenameFun
|
2019-11-06 21:48:43 +00:00
|
|
|
writing := f._writingInProgress()
|
|
|
|
f.mu.RUnlock()
|
|
|
|
if fun == nil || writing {
|
2018-05-24 18:45:11 +00:00
|
|
|
return
|
|
|
|
}
|
2020-04-15 11:17:28 +00:00
|
|
|
fs.Debugf(f.Path(), "Running delayed rename now")
|
2019-06-17 08:34:30 +00:00
|
|
|
if err := fun(context.TODO()); err != nil {
|
2018-05-29 17:19:17 +00:00
|
|
|
fs.Errorf(f.Path(), "delayed File.Rename error: %v", err)
|
|
|
|
}
|
2018-05-24 18:45:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// rename attempts to immediately rename a file if there are no open writers.
|
|
|
|
// Otherwise it will queue the rename operation on the remote until no writers
|
|
|
|
// remain.
|
2019-06-17 08:34:30 +00:00
|
|
|
func (f *File) rename(ctx context.Context, destDir *Dir, newName string) error {
|
2019-11-06 21:48:43 +00:00
|
|
|
f.mu.RLock()
|
|
|
|
d := f.d
|
2019-12-05 12:58:24 +00:00
|
|
|
oldPendingRenameFun := f.pendingRenameFun
|
2019-11-06 21:48:43 +00:00
|
|
|
f.mu.RUnlock()
|
2019-12-05 12:58:24 +00:00
|
|
|
|
2020-04-14 17:14:24 +00:00
|
|
|
if features := d.Fs().Features(); features.Move == nil && features.Copy == nil {
|
2020-10-13 21:43:40 +00:00
|
|
|
err := errors.Errorf("Fs %q can't rename files (no server-side Move or Copy)", d.Fs())
|
2018-05-24 18:45:11 +00:00
|
|
|
fs.Errorf(f.Path(), "Dir.Rename error: %v", err)
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2020-02-29 18:08:22 +00:00
|
|
|
oldPath := f.Path()
|
2020-04-14 16:55:18 +00:00
|
|
|
// File.mu is unlocked here to call Dir.Path()
|
|
|
|
newPath := path.Join(destDir.Path(), newName)
|
2019-12-05 12:58:24 +00:00
|
|
|
|
2020-02-29 18:08:22 +00:00
|
|
|
renameCall := func(ctx context.Context) (err error) {
|
2019-12-05 12:58:24 +00:00
|
|
|
// chain rename calls if any
|
|
|
|
if oldPendingRenameFun != nil {
|
|
|
|
err := oldPendingRenameFun(ctx)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-01-13 17:37:54 +00:00
|
|
|
f.mu.RLock()
|
|
|
|
o := f.o
|
2020-08-19 15:55:30 +00:00
|
|
|
d := f.d
|
2020-01-13 17:37:54 +00:00
|
|
|
f.mu.RUnlock()
|
2020-02-29 18:08:22 +00:00
|
|
|
var newObject fs.Object
|
|
|
|
// if o is nil then are writing the file so no need to rename the object
|
|
|
|
if o != nil {
|
|
|
|
if o.Remote() == newPath {
|
|
|
|
return nil // no need to rename
|
|
|
|
}
|
2020-01-13 17:37:54 +00:00
|
|
|
|
2020-02-29 18:08:22 +00:00
|
|
|
// do the move of the remote object
|
|
|
|
dstOverwritten, _ := d.Fs().NewObject(ctx, newPath)
|
|
|
|
newObject, err = operations.Move(ctx, d.Fs(), dstOverwritten, newPath, o)
|
|
|
|
if err != nil {
|
|
|
|
fs.Errorf(f.Path(), "File.Rename error: %v", err)
|
|
|
|
return err
|
|
|
|
}
|
2019-08-26 12:43:11 +00:00
|
|
|
|
2020-02-29 18:08:22 +00:00
|
|
|
// newObject can be nil here for example if --dry-run
|
|
|
|
if newObject == nil {
|
|
|
|
err = errors.New("rename failed: nil object returned")
|
|
|
|
fs.Errorf(f.Path(), "File.Rename %v", err)
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// Rename in the cache
|
2020-08-19 15:56:22 +00:00
|
|
|
if d.vfs.cache != nil && d.vfs.cache.Exists(oldPath) {
|
2020-08-19 15:55:30 +00:00
|
|
|
if err := d.vfs.cache.Rename(oldPath, newPath, newObject); err != nil {
|
2020-02-29 18:08:22 +00:00
|
|
|
fs.Infof(f.Path(), "File.Rename failed in Cache: %v", err)
|
|
|
|
}
|
2019-01-14 12:07:25 +00:00
|
|
|
}
|
2018-05-24 18:45:11 +00:00
|
|
|
// Update the node with the new details
|
2020-04-15 11:17:28 +00:00
|
|
|
fs.Debugf(f.Path(), "Updating file with %v %p", newObject, f)
|
2018-05-24 18:45:11 +00:00
|
|
|
// f.rename(destDir, newObject)
|
|
|
|
f.mu.Lock()
|
2020-02-29 18:08:22 +00:00
|
|
|
if newObject != nil {
|
|
|
|
f.o = newObject
|
|
|
|
}
|
2018-05-24 18:45:11 +00:00
|
|
|
f.pendingRenameFun = nil
|
|
|
|
f.mu.Unlock()
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-12-05 12:58:24 +00:00
|
|
|
// rename the file object
|
2020-04-14 16:55:18 +00:00
|
|
|
dPath := destDir.Path()
|
2019-12-05 12:58:24 +00:00
|
|
|
f.mu.Lock()
|
|
|
|
f.d = destDir
|
2020-04-14 16:55:18 +00:00
|
|
|
f.dPath = dPath
|
2019-12-05 12:58:24 +00:00
|
|
|
f.leaf = newName
|
2019-11-06 21:48:43 +00:00
|
|
|
writing := f._writingInProgress()
|
2019-12-05 12:58:24 +00:00
|
|
|
f.mu.Unlock()
|
|
|
|
|
2020-02-29 18:08:22 +00:00
|
|
|
// Delay the rename if not using RW caching. For the minimal case we
|
|
|
|
// need to look in the cache to see if caching is in use.
|
|
|
|
CacheMode := d.vfs.Opt.CacheMode
|
|
|
|
if writing &&
|
|
|
|
(CacheMode < vfscommon.CacheModeMinimal ||
|
2020-08-19 15:55:30 +00:00
|
|
|
(CacheMode == vfscommon.CacheModeMinimal && !destDir.vfs.cache.Exists(oldPath))) {
|
2020-07-08 10:40:41 +00:00
|
|
|
fs.Debugf(oldPath, "File is currently open, delaying rename %p", f)
|
2018-05-24 18:45:11 +00:00
|
|
|
f.mu.Lock()
|
|
|
|
f.pendingRenameFun = renameCall
|
|
|
|
f.mu.Unlock()
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-06-17 08:34:30 +00:00
|
|
|
return renameCall(ctx)
|
2017-05-02 21:35:07 +00:00
|
|
|
}
|
|
|
|
|
2017-11-16 09:31:33 +00:00
|
|
|
// addWriter adds a write handle to the file
|
|
|
|
func (f *File) addWriter(h Handle) {
|
2017-05-02 21:35:07 +00:00
|
|
|
f.mu.Lock()
|
2017-11-16 09:31:33 +00:00
|
|
|
f.writers = append(f.writers, h)
|
2018-03-09 09:49:41 +00:00
|
|
|
atomic.AddInt32(&f.nwriters, 1)
|
2017-11-16 09:31:33 +00:00
|
|
|
f.mu.Unlock()
|
|
|
|
}
|
|
|
|
|
|
|
|
// delWriter removes a write handle from the file
|
2020-02-29 18:08:22 +00:00
|
|
|
func (f *File) delWriter(h Handle) {
|
2017-11-16 09:31:33 +00:00
|
|
|
f.mu.Lock()
|
2019-11-06 21:48:43 +00:00
|
|
|
defer f.applyPendingRename()
|
2018-02-18 13:12:26 +00:00
|
|
|
defer f.mu.Unlock()
|
2017-11-16 09:31:33 +00:00
|
|
|
var found = -1
|
|
|
|
for i := range f.writers {
|
|
|
|
if f.writers[i] == h {
|
|
|
|
found = i
|
|
|
|
break
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if found >= 0 {
|
|
|
|
f.writers = append(f.writers[:found], f.writers[found+1:]...)
|
2018-03-09 09:49:41 +00:00
|
|
|
atomic.AddInt32(&f.nwriters, -1)
|
2017-11-16 09:31:33 +00:00
|
|
|
} else {
|
2020-04-15 11:17:28 +00:00
|
|
|
fs.Debugf(f._path(), "File.delWriter couldn't find handle")
|
2017-11-16 09:31:33 +00:00
|
|
|
}
|
2017-05-02 21:35:07 +00:00
|
|
|
}
|
|
|
|
|
2017-11-18 11:57:40 +00:00
|
|
|
// activeWriters returns the number of writers on the file
|
2018-03-09 09:49:41 +00:00
|
|
|
//
|
|
|
|
// Note that we don't take the mutex here. If we do then we can get a
|
|
|
|
// deadlock.
|
2017-11-18 11:57:40 +00:00
|
|
|
func (f *File) activeWriters() int {
|
2018-03-09 09:49:41 +00:00
|
|
|
return int(atomic.LoadInt32(&f.nwriters))
|
2017-11-18 11:57:40 +00:00
|
|
|
}
|
|
|
|
|
2017-10-25 09:00:26 +00:00
|
|
|
// ModTime returns the modified time of the file
|
|
|
|
//
|
|
|
|
// if NoModTime is set then it returns the mod time of the directory
|
|
|
|
func (f *File) ModTime() (modTime time.Time) {
|
2019-11-06 21:48:43 +00:00
|
|
|
f.mu.RLock()
|
2020-04-14 16:55:18 +00:00
|
|
|
d, o, pendingModTime := f.d, f.o, f.pendingModTime
|
|
|
|
f.mu.RUnlock()
|
2017-10-25 09:00:26 +00:00
|
|
|
|
2020-04-14 16:55:18 +00:00
|
|
|
if d.vfs.Opt.NoModTime {
|
|
|
|
return d.ModTime()
|
2017-10-25 09:00:26 +00:00
|
|
|
}
|
2020-04-14 16:55:18 +00:00
|
|
|
if !pendingModTime.IsZero() {
|
|
|
|
return pendingModTime
|
2019-11-11 15:56:59 +00:00
|
|
|
}
|
2020-04-14 16:55:18 +00:00
|
|
|
if o == nil {
|
2020-06-09 14:07:28 +00:00
|
|
|
return time.Now()
|
2019-11-11 15:56:59 +00:00
|
|
|
}
|
2020-04-14 16:55:18 +00:00
|
|
|
return o.ModTime(context.TODO())
|
2017-10-25 09:00:26 +00:00
|
|
|
}
|
|
|
|
|
2018-01-31 15:23:01 +00:00
|
|
|
// nonNegative returns 0 if i is -ve, i otherwise
|
|
|
|
func nonNegative(i int64) int64 {
|
|
|
|
if i >= 0 {
|
|
|
|
return i
|
|
|
|
}
|
|
|
|
return 0
|
|
|
|
}
|
|
|
|
|
2017-10-25 09:00:26 +00:00
|
|
|
// Size of the file
|
|
|
|
func (f *File) Size() int64 {
|
2019-11-06 21:48:43 +00:00
|
|
|
f.mu.RLock()
|
|
|
|
defer f.mu.RUnlock()
|
2017-10-25 09:00:26 +00:00
|
|
|
|
2020-04-17 10:18:58 +00:00
|
|
|
// Read the size from a dirty item if it exists
|
|
|
|
if f.d.vfs.Opt.CacheMode >= vfscommon.CacheModeMinimal {
|
|
|
|
if item := f.d.vfs.cache.DirtyItem(f._path()); item != nil {
|
|
|
|
size, err := item.GetSize()
|
|
|
|
if err != nil {
|
|
|
|
fs.Errorf(f._path(), "Size: Item GetSize failed: %v", err)
|
|
|
|
} else {
|
|
|
|
return size
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-05-02 21:35:07 +00:00
|
|
|
// if o is nil it isn't valid yet or there are writers, so return the size so far
|
2019-11-06 21:48:43 +00:00
|
|
|
if f._writingInProgress() {
|
2017-10-25 09:00:26 +00:00
|
|
|
return atomic.LoadInt64(&f.size)
|
2017-05-02 21:35:07 +00:00
|
|
|
}
|
2018-01-31 15:23:01 +00:00
|
|
|
return nonNegative(f.o.Size())
|
2017-05-02 21:35:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// SetModTime sets the modtime for the file
|
2020-09-30 15:06:57 +00:00
|
|
|
//
|
|
|
|
// if NoModTime is set then it does nothing
|
2017-05-02 21:35:07 +00:00
|
|
|
func (f *File) SetModTime(modTime time.Time) error {
|
2020-08-19 15:55:30 +00:00
|
|
|
f.mu.Lock()
|
|
|
|
defer f.mu.Unlock()
|
2020-09-30 15:06:57 +00:00
|
|
|
if f.d.vfs.Opt.NoModTime {
|
|
|
|
return nil
|
|
|
|
}
|
2017-10-29 11:00:56 +00:00
|
|
|
if f.d.vfs.Opt.ReadOnly {
|
2017-05-11 12:15:51 +00:00
|
|
|
return EROFS
|
|
|
|
}
|
2017-05-02 21:35:07 +00:00
|
|
|
|
|
|
|
f.pendingModTime = modTime
|
|
|
|
|
2020-08-20 15:01:55 +00:00
|
|
|
// set the time of the file in the cache
|
|
|
|
if f.d.vfs.cache != nil && f.d.vfs.cache.Exists(f._path()) {
|
|
|
|
f.d.vfs.cache.SetModTime(f._path(), f.pendingModTime)
|
|
|
|
}
|
|
|
|
|
2018-02-18 13:12:26 +00:00
|
|
|
// Only update the ModTime when there are no writers, setObject will do it
|
2019-11-06 21:48:43 +00:00
|
|
|
if !f._writingInProgress() {
|
|
|
|
return f._applyPendingModTime()
|
2017-05-02 21:35:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// queue up for later, hoping f.o becomes available
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-11-06 21:48:43 +00:00
|
|
|
// Apply a pending mod time
|
2020-04-15 11:17:28 +00:00
|
|
|
// Call with the mutex held
|
2019-11-06 21:48:43 +00:00
|
|
|
func (f *File) _applyPendingModTime() error {
|
2017-05-02 21:35:07 +00:00
|
|
|
if f.pendingModTime.IsZero() {
|
|
|
|
return nil
|
|
|
|
}
|
2019-11-06 21:48:43 +00:00
|
|
|
defer func() { f.pendingModTime = time.Time{} }()
|
|
|
|
|
2017-05-02 21:35:07 +00:00
|
|
|
if f.o == nil {
|
|
|
|
return errors.New("Cannot apply ModTime, file object is not available")
|
|
|
|
}
|
|
|
|
|
2020-01-19 12:52:48 +00:00
|
|
|
// set the time of the object
|
2019-06-17 08:34:30 +00:00
|
|
|
err := f.o.SetModTime(context.TODO(), f.pendingModTime)
|
2017-05-02 21:35:07 +00:00
|
|
|
switch err {
|
|
|
|
case nil:
|
2020-08-19 15:56:22 +00:00
|
|
|
fs.Debugf(f.o, "Applied pending mod time %v OK", f.pendingModTime)
|
2017-06-13 12:58:39 +00:00
|
|
|
case fs.ErrorCantSetModTime, fs.ErrorCantSetModTimeWithoutDelete:
|
2017-05-02 21:35:07 +00:00
|
|
|
// do nothing, in order to not break "touch somefile" if it exists already
|
|
|
|
default:
|
2020-08-19 15:56:22 +00:00
|
|
|
fs.Errorf(f.o, "Failed to apply pending mod time %v: %v", f.pendingModTime, err)
|
2017-05-02 21:35:07 +00:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-11-06 21:48:43 +00:00
|
|
|
// _writingInProgress returns true of there are any open writers
|
|
|
|
// Call with read lock held
|
|
|
|
func (f *File) _writingInProgress() bool {
|
2020-02-29 18:08:22 +00:00
|
|
|
return f.o == nil || len(f.writers) != 0
|
2018-05-24 18:45:11 +00:00
|
|
|
}
|
|
|
|
|
2020-11-10 12:58:03 +00:00
|
|
|
// writingInProgress returns true of there are any open writers
|
|
|
|
func (f *File) writingInProgress() bool {
|
|
|
|
f.mu.RLock()
|
|
|
|
defer f.mu.RUnlock()
|
|
|
|
return f.o == nil || len(f.writers) != 0
|
|
|
|
}
|
|
|
|
|
2017-05-02 21:35:07 +00:00
|
|
|
// Update the size while writing
|
|
|
|
func (f *File) setSize(n int64) {
|
|
|
|
atomic.StoreInt64(&f.size, n)
|
|
|
|
}
|
|
|
|
|
2017-11-18 11:47:21 +00:00
|
|
|
// Update the object when written and add it to the directory
|
2017-05-02 21:35:07 +00:00
|
|
|
func (f *File) setObject(o fs.Object) {
|
|
|
|
f.mu.Lock()
|
|
|
|
f.o = o
|
2019-11-06 21:48:43 +00:00
|
|
|
_ = f._applyPendingModTime()
|
2020-08-19 15:55:30 +00:00
|
|
|
d := f.d
|
2018-12-03 21:51:39 +00:00
|
|
|
f.mu.Unlock()
|
|
|
|
|
2020-04-14 16:55:18 +00:00
|
|
|
// Release File.mu before calling Dir method
|
2020-08-19 15:55:30 +00:00
|
|
|
d.addObject(f)
|
2017-05-02 21:35:07 +00:00
|
|
|
}
|
|
|
|
|
2018-03-01 15:51:05 +00:00
|
|
|
// Update the object but don't update the directory cache - for use by
|
|
|
|
// the directory cache
|
|
|
|
func (f *File) setObjectNoUpdate(o fs.Object) {
|
|
|
|
f.mu.Lock()
|
|
|
|
f.o = o
|
2019-11-06 21:48:43 +00:00
|
|
|
f.mu.Unlock()
|
2018-03-01 15:51:05 +00:00
|
|
|
}
|
|
|
|
|
2018-03-01 15:50:23 +00:00
|
|
|
// Get the current fs.Object - may be nil
|
|
|
|
func (f *File) getObject() fs.Object {
|
2019-11-06 21:48:43 +00:00
|
|
|
f.mu.RLock()
|
|
|
|
defer f.mu.RUnlock()
|
2018-03-01 15:50:23 +00:00
|
|
|
return f.o
|
|
|
|
}
|
|
|
|
|
2017-11-16 09:31:33 +00:00
|
|
|
// exists returns whether the file exists already
|
|
|
|
func (f *File) exists() bool {
|
2019-11-06 21:48:43 +00:00
|
|
|
f.mu.RLock()
|
|
|
|
defer f.mu.RUnlock()
|
2017-11-16 09:31:33 +00:00
|
|
|
return f.o != nil
|
|
|
|
}
|
|
|
|
|
2017-05-02 21:35:07 +00:00
|
|
|
// Wait for f.o to become non nil for a short time returning it or an
|
2017-11-06 21:38:52 +00:00
|
|
|
// error. Use when opening a read handle.
|
2017-05-02 21:35:07 +00:00
|
|
|
//
|
|
|
|
// Call without the mutex held
|
|
|
|
func (f *File) waitForValidObject() (o fs.Object, err error) {
|
|
|
|
for i := 0; i < 50; i++ {
|
2019-11-06 21:48:43 +00:00
|
|
|
f.mu.RLock()
|
2017-05-02 21:35:07 +00:00
|
|
|
o = f.o
|
2017-11-16 09:31:33 +00:00
|
|
|
nwriters := len(f.writers)
|
2019-11-06 21:48:43 +00:00
|
|
|
f.mu.RUnlock()
|
2017-05-02 21:35:07 +00:00
|
|
|
if o != nil {
|
|
|
|
return o, nil
|
|
|
|
}
|
2020-02-29 18:08:22 +00:00
|
|
|
if nwriters == 0 {
|
2017-05-02 21:35:07 +00:00
|
|
|
return nil, errors.New("can't open file - writer failed")
|
|
|
|
}
|
|
|
|
time.Sleep(100 * time.Millisecond)
|
|
|
|
}
|
|
|
|
return nil, ENOENT
|
|
|
|
}
|
|
|
|
|
2017-12-06 16:38:19 +00:00
|
|
|
// openRead open the file for read
|
|
|
|
func (f *File) openRead() (fh *ReadFileHandle, err error) {
|
2017-05-02 21:35:07 +00:00
|
|
|
// if o is nil it isn't valid yet
|
2018-03-01 15:50:23 +00:00
|
|
|
_, err = f.waitForValidObject()
|
2017-05-02 21:35:07 +00:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
2020-04-15 11:17:28 +00:00
|
|
|
// fs.Debugf(f.Path(), "File.openRead")
|
2017-05-02 21:35:07 +00:00
|
|
|
|
2018-03-01 15:50:23 +00:00
|
|
|
fh, err = newReadFileHandle(f)
|
2017-05-02 21:35:07 +00:00
|
|
|
if err != nil {
|
2020-04-15 11:17:28 +00:00
|
|
|
fs.Debugf(f.Path(), "File.openRead failed: %v", err)
|
2017-05-02 21:35:07 +00:00
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
return fh, nil
|
|
|
|
}
|
|
|
|
|
2017-12-06 16:38:19 +00:00
|
|
|
// openWrite open the file for write
|
|
|
|
func (f *File) openWrite(flags int) (fh *WriteFileHandle, err error) {
|
2019-11-06 21:48:43 +00:00
|
|
|
f.mu.RLock()
|
|
|
|
d := f.d
|
|
|
|
f.mu.RUnlock()
|
|
|
|
|
|
|
|
if d.vfs.Opt.ReadOnly {
|
2017-05-11 12:15:51 +00:00
|
|
|
return nil, EROFS
|
|
|
|
}
|
2020-04-15 11:17:28 +00:00
|
|
|
// fs.Debugf(f.Path(), "File.openWrite")
|
2017-05-02 21:35:07 +00:00
|
|
|
|
2019-11-06 21:48:43 +00:00
|
|
|
fh, err = newWriteFileHandle(d, f, f.Path(), flags)
|
2017-05-02 21:35:07 +00:00
|
|
|
if err != nil {
|
2020-04-15 11:17:28 +00:00
|
|
|
fs.Debugf(f.Path(), "File.openWrite failed: %v", err)
|
2017-05-02 21:35:07 +00:00
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
return fh, nil
|
|
|
|
}
|
|
|
|
|
Spelling fixes
Fix spelling of: above, already, anonymous, associated,
authentication, bandwidth, because, between, blocks, calculate,
candidates, cautious, changelog, cleaner, clipboard, command,
completely, concurrently, considered, constructs, corrupt, current,
daemon, dependencies, deprecated, directory, dispatcher, download,
eligible, ellipsis, encrypter, endpoint, entrieslist, essentially,
existing writers, existing, expires, filesystem, flushing, frequently,
hierarchy, however, implementation, implements, inaccurate,
individually, insensitive, longer, maximum, metadata, modified,
multipart, namedirfirst, nextcloud, obscured, opened, optional,
owncloud, pacific, passphrase, password, permanently, persimmon,
positive, potato, protocol, quota, receiving, recommends, referring,
requires, revisited, satisfied, satisfies, satisfy, semver,
serialized, session, storage, strategies, stringlist, successful,
supported, surprise, temporarily, temporary, transactions, unneeded,
update, uploads, wrapped
Signed-off-by: Josh Soref <jsoref@users.noreply.github.com>
2020-10-09 00:17:24 +00:00
|
|
|
// openRW open the file for read and write using a temporary file
|
2017-11-06 21:38:52 +00:00
|
|
|
//
|
|
|
|
// It uses the open flags passed in.
|
2017-12-06 16:38:19 +00:00
|
|
|
func (f *File) openRW(flags int) (fh *RWFileHandle, err error) {
|
2019-11-06 21:48:43 +00:00
|
|
|
f.mu.RLock()
|
|
|
|
d := f.d
|
|
|
|
f.mu.RUnlock()
|
|
|
|
|
2017-12-06 16:38:19 +00:00
|
|
|
// FIXME chunked
|
2019-11-06 21:48:43 +00:00
|
|
|
if flags&accessModeMask != os.O_RDONLY && d.vfs.Opt.ReadOnly {
|
2017-11-06 21:38:52 +00:00
|
|
|
return nil, EROFS
|
|
|
|
}
|
2020-04-15 11:17:28 +00:00
|
|
|
// fs.Debugf(f.Path(), "File.openRW")
|
2017-11-06 21:38:52 +00:00
|
|
|
|
2019-12-09 14:25:54 +00:00
|
|
|
fh, err = newRWFileHandle(d, f, flags)
|
2017-11-06 21:38:52 +00:00
|
|
|
if err != nil {
|
2020-04-15 11:17:28 +00:00
|
|
|
fs.Debugf(f.Path(), "File.openRW failed: %v", err)
|
2017-11-06 21:38:52 +00:00
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
return fh, nil
|
|
|
|
}
|
|
|
|
|
2017-11-18 15:48:49 +00:00
|
|
|
// Sync the file
|
2017-05-02 21:35:07 +00:00
|
|
|
//
|
|
|
|
// Note that we don't do anything except return OK
|
2017-11-18 15:48:49 +00:00
|
|
|
func (f *File) Sync() error {
|
2017-05-02 21:35:07 +00:00
|
|
|
return nil
|
|
|
|
}
|
2017-10-26 15:55:40 +00:00
|
|
|
|
|
|
|
// Remove the file
|
2020-06-03 14:49:41 +00:00
|
|
|
func (f *File) Remove() (err error) {
|
|
|
|
defer log.Trace(f.Path(), "")("err=%v", &err)
|
2019-11-06 21:48:43 +00:00
|
|
|
f.mu.RLock()
|
|
|
|
d := f.d
|
|
|
|
f.mu.RUnlock()
|
|
|
|
|
|
|
|
if d.vfs.Opt.ReadOnly {
|
2017-10-26 15:55:40 +00:00
|
|
|
return EROFS
|
|
|
|
}
|
2020-06-03 14:49:41 +00:00
|
|
|
|
|
|
|
// Remove the object from the cache
|
|
|
|
wasWriting := false
|
2020-08-19 15:56:22 +00:00
|
|
|
if d.vfs.cache != nil && d.vfs.cache.Exists(f.Path()) {
|
2020-06-03 14:49:41 +00:00
|
|
|
wasWriting = d.vfs.cache.Remove(f.Path())
|
|
|
|
}
|
|
|
|
|
|
|
|
// Remove the item from the directory listing
|
|
|
|
// called with File.mu released
|
|
|
|
d.delObject(f.Name())
|
|
|
|
|
2018-12-21 13:55:06 +00:00
|
|
|
f.muRW.Lock() // muRW must be locked before mu to avoid
|
|
|
|
f.mu.Lock() // deadlock in RWFileHandle.openPending and .close
|
2017-10-29 21:14:05 +00:00
|
|
|
if f.o != nil {
|
2020-06-03 14:49:41 +00:00
|
|
|
err = f.o.Remove(context.TODO())
|
2017-10-26 15:55:40 +00:00
|
|
|
}
|
2018-12-03 21:51:39 +00:00
|
|
|
f.mu.Unlock()
|
2018-12-21 13:55:06 +00:00
|
|
|
f.muRW.Unlock()
|
2020-06-03 14:49:41 +00:00
|
|
|
if err != nil {
|
|
|
|
if wasWriting {
|
|
|
|
// Ignore error deleting file if was writing it as it may not be uploaded yet
|
|
|
|
err = nil
|
2020-06-15 14:09:33 +00:00
|
|
|
fs.Debugf(f._path(), "Ignoring File.Remove file error as uploading: %v", err)
|
2020-06-03 14:49:41 +00:00
|
|
|
} else {
|
|
|
|
fs.Debugf(f._path(), "File.Remove file error: %v", err)
|
|
|
|
}
|
2017-11-27 19:48:25 +00:00
|
|
|
}
|
2020-06-03 14:49:41 +00:00
|
|
|
return err
|
2017-10-26 15:55:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// RemoveAll the file - same as remove for files
|
|
|
|
func (f *File) RemoveAll() error {
|
|
|
|
return f.Remove()
|
|
|
|
}
|
2017-10-26 16:02:48 +00:00
|
|
|
|
2017-10-29 21:14:05 +00:00
|
|
|
// DirEntry returns the underlying fs.DirEntry - may be nil
|
2017-10-26 16:02:48 +00:00
|
|
|
func (f *File) DirEntry() (entry fs.DirEntry) {
|
2019-11-06 21:48:43 +00:00
|
|
|
f.mu.RLock()
|
|
|
|
defer f.mu.RUnlock()
|
2017-10-26 16:02:48 +00:00
|
|
|
return f.o
|
|
|
|
}
|
2017-10-29 11:00:56 +00:00
|
|
|
|
|
|
|
// Dir returns the directory this file is in
|
|
|
|
func (f *File) Dir() *Dir {
|
2019-11-06 21:48:43 +00:00
|
|
|
f.mu.RLock()
|
|
|
|
defer f.mu.RUnlock()
|
2017-10-29 11:00:56 +00:00
|
|
|
return f.d
|
|
|
|
}
|
|
|
|
|
|
|
|
// VFS returns the instance of the VFS
|
|
|
|
func (f *File) VFS() *VFS {
|
2019-11-06 21:48:43 +00:00
|
|
|
f.mu.RLock()
|
|
|
|
defer f.mu.RUnlock()
|
2017-10-29 11:00:56 +00:00
|
|
|
return f.d.vfs
|
|
|
|
}
|
2017-10-30 10:14:39 +00:00
|
|
|
|
2020-04-14 17:03:45 +00:00
|
|
|
// Fs returns the underlying Fs for the file
|
|
|
|
func (f *File) Fs() fs.Fs {
|
|
|
|
f.mu.RLock()
|
|
|
|
defer f.mu.RUnlock()
|
2020-04-14 17:14:24 +00:00
|
|
|
return f.d.Fs()
|
2020-04-14 17:03:45 +00:00
|
|
|
}
|
|
|
|
|
2017-10-30 10:14:39 +00:00
|
|
|
// Open a file according to the flags provided
|
2017-11-06 21:38:52 +00:00
|
|
|
//
|
|
|
|
// O_RDONLY open the file read-only.
|
|
|
|
// O_WRONLY open the file write-only.
|
|
|
|
// O_RDWR open the file read-write.
|
|
|
|
//
|
|
|
|
// O_APPEND append data to the file when writing.
|
|
|
|
// O_CREATE create a new file if none exists.
|
|
|
|
// O_EXCL used with O_CREATE, file must not exist
|
|
|
|
// O_SYNC open for synchronous I/O.
|
Spelling fixes
Fix spelling of: above, already, anonymous, associated,
authentication, bandwidth, because, between, blocks, calculate,
candidates, cautious, changelog, cleaner, clipboard, command,
completely, concurrently, considered, constructs, corrupt, current,
daemon, dependencies, deprecated, directory, dispatcher, download,
eligible, ellipsis, encrypter, endpoint, entrieslist, essentially,
existing writers, existing, expires, filesystem, flushing, frequently,
hierarchy, however, implementation, implements, inaccurate,
individually, insensitive, longer, maximum, metadata, modified,
multipart, namedirfirst, nextcloud, obscured, opened, optional,
owncloud, pacific, passphrase, password, permanently, persimmon,
positive, potato, protocol, quota, receiving, recommends, referring,
requires, revisited, satisfied, satisfies, satisfy, semver,
serialized, session, storage, strategies, stringlist, successful,
supported, surprise, temporarily, temporary, transactions, unneeded,
update, uploads, wrapped
Signed-off-by: Josh Soref <jsoref@users.noreply.github.com>
2020-10-09 00:17:24 +00:00
|
|
|
// O_TRUNC if possible, truncate file when opened
|
2017-11-06 21:38:52 +00:00
|
|
|
//
|
|
|
|
// We ignore O_SYNC and O_EXCL
|
2017-10-30 10:14:39 +00:00
|
|
|
func (f *File) Open(flags int) (fd Handle, err error) {
|
2020-04-15 11:17:28 +00:00
|
|
|
defer log.Trace(f.Path(), "flags=%s", decodeOpenFlags(flags))("fd=%v, err=%v", &fd, &err)
|
2017-11-06 21:38:52 +00:00
|
|
|
var (
|
|
|
|
write bool // if set need write support
|
|
|
|
read bool // if set need read support
|
2018-02-23 22:39:28 +00:00
|
|
|
rdwrMode = flags & accessModeMask
|
2017-11-06 21:38:52 +00:00
|
|
|
)
|
|
|
|
|
2018-02-23 22:39:28 +00:00
|
|
|
// http://pubs.opengroup.org/onlinepubs/7908799/xsh/open.html
|
|
|
|
// The result of using O_TRUNC with O_RDONLY is undefined.
|
|
|
|
// Linux seems to truncate the file, but we prefer to return EINVAL
|
|
|
|
if rdwrMode == os.O_RDONLY && flags&os.O_TRUNC != 0 {
|
|
|
|
return nil, EINVAL
|
|
|
|
}
|
|
|
|
|
2017-11-06 21:38:52 +00:00
|
|
|
// Figure out the read/write intents
|
2017-10-30 10:14:39 +00:00
|
|
|
switch {
|
|
|
|
case rdwrMode == os.O_RDONLY:
|
|
|
|
read = true
|
2017-11-06 21:38:52 +00:00
|
|
|
case rdwrMode == os.O_WRONLY:
|
|
|
|
write = true
|
2017-10-30 10:14:39 +00:00
|
|
|
case rdwrMode == os.O_RDWR:
|
2017-11-06 21:38:52 +00:00
|
|
|
read = true
|
|
|
|
write = true
|
2017-10-30 10:14:39 +00:00
|
|
|
default:
|
2020-04-15 11:17:28 +00:00
|
|
|
fs.Debugf(f.Path(), "Can't figure out how to open with flags: 0x%X", flags)
|
2017-10-31 15:33:08 +00:00
|
|
|
return nil, EPERM
|
2017-10-30 10:14:39 +00:00
|
|
|
}
|
2017-11-06 21:38:52 +00:00
|
|
|
|
2017-12-06 16:38:19 +00:00
|
|
|
// If append is set then set read to force openRW
|
2017-11-06 21:38:52 +00:00
|
|
|
if flags&os.O_APPEND != 0 {
|
|
|
|
read = true
|
2019-11-06 21:48:43 +00:00
|
|
|
f.mu.Lock()
|
2019-10-15 00:57:15 +00:00
|
|
|
f.appendMode = true
|
2019-11-06 21:48:43 +00:00
|
|
|
f.mu.Unlock()
|
2017-11-06 21:38:52 +00:00
|
|
|
}
|
|
|
|
|
2017-12-06 16:38:19 +00:00
|
|
|
// If truncate is set then set write to force openRW
|
2017-11-06 21:38:52 +00:00
|
|
|
if flags&os.O_TRUNC != 0 {
|
|
|
|
write = true
|
|
|
|
}
|
|
|
|
|
|
|
|
// Open the correct sort of handle
|
2019-11-06 21:48:43 +00:00
|
|
|
f.mu.RLock()
|
|
|
|
d := f.d
|
|
|
|
f.mu.RUnlock()
|
|
|
|
CacheMode := d.vfs.Opt.CacheMode
|
2020-02-29 18:08:22 +00:00
|
|
|
if CacheMode >= vfscommon.CacheModeMinimal && (d.vfs.cache.InUse(f.Path()) || d.vfs.cache.Exists(f.Path())) {
|
2018-02-18 13:12:26 +00:00
|
|
|
fd, err = f.openRW(flags)
|
|
|
|
} else if read && write {
|
2020-02-28 14:44:15 +00:00
|
|
|
if CacheMode >= vfscommon.CacheModeMinimal {
|
2017-12-06 16:38:19 +00:00
|
|
|
fd, err = f.openRW(flags)
|
2017-11-06 21:38:52 +00:00
|
|
|
} else {
|
2017-11-16 10:55:24 +00:00
|
|
|
// Open write only and hope the user doesn't
|
|
|
|
// want to read. If they do they will get an
|
|
|
|
// EPERM plus an Error log.
|
2017-12-06 16:38:19 +00:00
|
|
|
fd, err = f.openWrite(flags)
|
2017-11-06 21:38:52 +00:00
|
|
|
}
|
|
|
|
} else if write {
|
2020-02-28 14:44:15 +00:00
|
|
|
if CacheMode >= vfscommon.CacheModeWrites {
|
2017-12-06 16:38:19 +00:00
|
|
|
fd, err = f.openRW(flags)
|
2017-11-06 21:38:52 +00:00
|
|
|
} else {
|
2017-12-06 16:38:19 +00:00
|
|
|
fd, err = f.openWrite(flags)
|
2017-11-06 21:38:52 +00:00
|
|
|
}
|
|
|
|
} else if read {
|
2020-02-28 14:44:15 +00:00
|
|
|
if CacheMode >= vfscommon.CacheModeFull {
|
2017-12-06 16:38:19 +00:00
|
|
|
fd, err = f.openRW(flags)
|
2017-11-06 21:38:52 +00:00
|
|
|
} else {
|
2017-12-06 16:38:19 +00:00
|
|
|
fd, err = f.openRead()
|
2017-11-06 21:38:52 +00:00
|
|
|
}
|
2017-10-30 10:14:39 +00:00
|
|
|
} else {
|
2020-04-15 11:17:28 +00:00
|
|
|
fs.Debugf(f.Path(), "Can't figure out how to open with flags: 0x%X", flags)
|
2017-11-06 21:38:52 +00:00
|
|
|
return nil, EPERM
|
2017-10-30 10:14:39 +00:00
|
|
|
}
|
2019-11-03 12:23:58 +00:00
|
|
|
// if creating a file, add the file to the directory
|
|
|
|
if err == nil && flags&os.O_CREATE != 0 {
|
2020-04-14 16:55:18 +00:00
|
|
|
// called without File.mu held
|
2019-11-06 21:48:43 +00:00
|
|
|
d.addObject(f)
|
2019-11-03 12:23:58 +00:00
|
|
|
}
|
2017-10-30 10:14:39 +00:00
|
|
|
return fd, err
|
|
|
|
}
|
2017-11-06 21:38:52 +00:00
|
|
|
|
|
|
|
// Truncate changes the size of the named file.
|
2017-11-16 09:31:33 +00:00
|
|
|
func (f *File) Truncate(size int64) (err error) {
|
|
|
|
// make a copy of fh.writers with the lock held then unlock so
|
|
|
|
// we can call other file methods.
|
|
|
|
f.mu.Lock()
|
|
|
|
writers := make([]Handle, len(f.writers))
|
|
|
|
copy(writers, f.writers)
|
2019-11-06 21:48:43 +00:00
|
|
|
o := f.o
|
2017-11-16 09:31:33 +00:00
|
|
|
f.mu.Unlock()
|
|
|
|
|
2018-02-18 13:12:26 +00:00
|
|
|
// FIXME: handle closing writer
|
|
|
|
|
2017-11-16 09:31:33 +00:00
|
|
|
// If have writers then call truncate for each writer
|
|
|
|
if len(writers) != 0 {
|
2020-04-15 11:17:28 +00:00
|
|
|
fs.Debugf(f.Path(), "Truncating %d file handles", len(writers))
|
2017-11-16 09:31:33 +00:00
|
|
|
for _, h := range writers {
|
|
|
|
truncateErr := h.Truncate(size)
|
|
|
|
if truncateErr != nil {
|
|
|
|
err = truncateErr
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return err
|
|
|
|
}
|
2019-02-12 17:27:04 +00:00
|
|
|
|
|
|
|
// If no writers, and size is already correct then all done
|
2019-11-06 21:48:43 +00:00
|
|
|
if o.Size() == size {
|
2019-02-12 17:27:04 +00:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2020-04-15 11:17:28 +00:00
|
|
|
fs.Debugf(f.Path(), "Truncating file")
|
2017-11-16 09:31:33 +00:00
|
|
|
|
|
|
|
// Otherwise if no writers then truncate the file by opening
|
|
|
|
// the file and truncating it.
|
|
|
|
flags := os.O_WRONLY
|
|
|
|
if size == 0 {
|
|
|
|
flags |= os.O_TRUNC
|
|
|
|
}
|
|
|
|
fh, err := f.Open(flags)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
defer fs.CheckClose(fh, &err)
|
|
|
|
if size != 0 {
|
|
|
|
return fh.Truncate(size)
|
2017-11-06 21:38:52 +00:00
|
|
|
}
|
2017-11-16 09:31:33 +00:00
|
|
|
return nil
|
2017-11-06 21:38:52 +00:00
|
|
|
}
|