X-Git-Url: https://git.arvados.org/arvados.git/blobdiff_plain/927524f1be454de021180b74999d682780b8cb6b..607033c33f2001c194fe8c68d0dc17e4bde849da:/sdk/go/arvados/fs_base.go

diff --git a/sdk/go/arvados/fs_base.go b/sdk/go/arvados/fs_base.go
index 5f2747ac9a..2ad4d1f859 100644
--- a/sdk/go/arvados/fs_base.go
+++ b/sdk/go/arvados/fs_base.go
@@ -8,6 +8,7 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"io/fs"
 	"log"
 	"net/http"
 	"os"
@@ -77,6 +78,24 @@ type File interface {
 	Stat() (os.FileInfo, error)
 	Truncate(int64) error
 	Sync() error
+	// Create a snapshot of a file or directory tree, which can
+	// then be spliced onto a different path or a different
+	// collection.
+	Snapshot() (*Subtree, error)
+	// Replace this file or directory with the given snapshot.
+	// The target must be inside a collection: Splice returns an
+	// error if the File is a virtual file or directory like
+	// by_id, a project directory, .arvados#collection,
+	// etc. Splice can replace directories with regular files and
+	// vice versa, except it cannot replace the root directory of
+	// a collection with a regular file.
+	Splice(snapshot *Subtree) error
+}
+
+// A Subtree is a detached part of a filesystem tree that can be
+// spliced into a filesystem via (File)Splice().
+type Subtree struct {
+	inode inode
 }
 
 // A FileSystem is an http.Filesystem plus Stat() and support for
@@ -141,6 +160,18 @@ type FileSystem interface {
 	MemorySize() int64
 }
 
+type fsFS struct {
+	FileSystem
+}
+
+// FS returns an fs.FS interface to the given FileSystem, to enable
+// the use of fs.WalkDir, etc.
+func FS(fs FileSystem) fs.FS { return fsFS{fs} }
+func (fs fsFS) Open(path string) (fs.File, error) {
+	f, err := fs.FileSystem.Open(path)
+	return f, err
+}
+
 type inode interface {
 	SetParent(parent inode, name string)
 	Parent() inode
@@ -152,6 +183,12 @@ type inode interface {
 	Readdir() ([]os.FileInfo, error)
 	Size() int64
 	FileInfo() os.FileInfo
+	// Create a snapshot of this node and its descendants.
+	Snapshot() (inode, error)
+	// Replace this node with a copy of the provided snapshot.
+	// Caller may provide the same snapshot to multiple Splice
+	// calls, but must not modify the snapshot concurrently.
+	Splice(inode) error
 
 	// Child() performs lookups and updates of named child nodes.
 	//
@@ -197,6 +234,14 @@ type fileinfo struct {
 	mode    os.FileMode
 	size    int64
 	modTime time.Time
+	// If not nil, sys() returns the source data structure, which
+	// can be a *Collection, *Group, or nil. Currently populated
+	// only for project dirs and top-level collection dirs. Does
+	// not stay up to date with upstream changes.
+	//
+	// Intended to support keep-web's properties-as-s3-metadata
+	// feature (https://dev.arvados.org/issues/19088).
+	sys func() interface{}
 }
 
 // Name implements os.FileInfo.
@@ -224,9 +269,12 @@ func (fi fileinfo) Size() int64 {
 	return fi.size
 }
 
-// Sys implements os.FileInfo.
+// Sys implements os.FileInfo. See comment in fileinfo struct.
 func (fi fileinfo) Sys() interface{} {
-	return nil
+	if fi.sys == nil {
+		return nil
+	}
+	return fi.sys()
 }
 
 type nullnode struct{}
@@ -270,6 +318,14 @@ func (*nullnode) MemorySize() int64 {
 	return 64
 }
 
+func (*nullnode) Snapshot() (inode, error) {
+	return nil, ErrInvalidOperation
+}
+
+func (*nullnode) Splice(inode) error {
+	return ErrInvalidOperation
+}
+
 type treenode struct {
 	fs       FileSystem
 	parent   inode
@@ -370,7 +426,7 @@ func (n *treenode) MemorySize() (size int64) {
 	for _, inode := range n.inodes {
 		size += inode.MemorySize()
 	}
-	return
+	return 64 + size
 }
 
 type fileSystem struct {
@@ -418,14 +474,14 @@ func (fs *fileSystem) openFile(name string, flag int, perm os.FileMode) (*fileha
 	default:
 		return nil, fmt.Errorf("invalid flags 0x%x", flag)
 	}
-	if !writable && parent.IsDir() {
+	if parent.IsDir() {
 		// A directory can be opened via "foo/", "foo/.", or
 		// "foo/..".
 		switch name {
 		case ".", "":
-			return &filehandle{inode: parent}, nil
+			return &filehandle{inode: parent, readable: readable, writable: writable}, nil
 		case "..":
-			return &filehandle{inode: parent.Parent()}, nil
+			return &filehandle{inode: parent.Parent(), readable: readable, writable: writable}, nil
 		}
 	}
 	createMode := flag&os.O_CREATE != 0
@@ -559,7 +615,7 @@ func (fs *fileSystem) Rename(oldname, newname string) error {
 		// supported. Locking inodes from different
 		// filesystems could deadlock, so we must error out
 		// now.
-		return ErrInvalidArgument
+		return ErrInvalidOperation
 	}
 
 	// To ensure we can test reliably whether we're about to move
@@ -697,3 +753,32 @@ func rlookup(start inode, path string) (node inode, err error) {
 func permittedName(name string) bool {
 	return name != "" && name != "." && name != ".." && !strings.Contains(name, "/")
 }
+
+// Snapshot returns a Subtree that's a copy of the given path. It
+// returns an error if the path is not inside a collection.
+func Snapshot(fs FileSystem, path string) (*Subtree, error) {
+	f, err := fs.OpenFile(path, os.O_RDONLY, 0)
+	if err != nil {
+		return nil, err
+	}
+	defer f.Close()
+	return f.Snapshot()
+}
+
+// Splice inserts newsubtree at the indicated target path.
+//
+// Splice returns an error if target is not inside a collection.
+//
+// Splice returns an error if target is the root of a collection and
+// newsubtree is a snapshot of a file.
+func Splice(fs FileSystem, target string, newsubtree *Subtree) error {
+	f, err := fs.OpenFile(target, os.O_WRONLY, 0)
+	if os.IsNotExist(err) {
+		f, err = fs.OpenFile(target, os.O_CREATE|os.O_WRONLY, 0700)
+	}
+	if err != nil {
+		return fmt.Errorf("open %s: %w", target, err)
+	}
+	defer f.Close()
+	return f.Splice(newsubtree)
+}