13111: Merge branch 'master' into 12308-go-fuse

[arvados.git] / sdk / go / arvados / fs_collection.go

diff --git a/sdk/go/arvados/fs_collection.go b/sdk/go/arvados/fs_collection.go
index a64ce8c7a0a0a24a6dafe4e75108f105a048c779..fbd9775b0cde0876e68328fd63a019485eeac4a9 100644 (file)
--- a/sdk/go/arvados/fs_collection.go
+++ b/sdk/go/arvados/fs_collection.go
@@ -21,28 +21,6 @@ import (
 
 var maxBlockSize = 1 << 26
 
-type fsBackend interface {
-       keepClient
-       apiClient
-}
-
-// Ideally *Client would do everything; meanwhile keepBackend
-// implements fsBackend by merging the two kinds of arvados client.
-type keepBackend struct {
-       keepClient
-       apiClient
-}
-
-type keepClient interface {
-       ReadAt(locator string, p []byte, off int) (int, error)
-       PutB(p []byte) (string, int, error)
-}
-
-type apiClient interface {
-       RequestAndDecode(dst interface{}, method, path string, body io.Reader, params interface{}) error
-       UpdateBody(rsc resource) io.Reader
-}
-
 // A CollectionFileSystem is a FileSystem that can be serialized as a
 // manifest and stored as a collection.
 type CollectionFileSystem interface {
@@ -55,6 +33,11 @@ type CollectionFileSystem interface {
        MarshalManifest(prefix string) (string, error)
 }
 
+type collectionFileSystem struct {
+       fileSystem
+       uuid string
+}
+
 // FileSystem returns a CollectionFileSystem for the collection.
 func (c *Collection) FileSystem(client apiClient, kc keepClient) (CollectionFileSystem, error) {
        var modTime time.Time
@@ -80,17 +63,25 @@ func (c *Collection) FileSystem(client apiClient, kc keepClient) (CollectionFile
                        inodes: make(map[string]inode),
                },
        }
-       root.SetParent(root)
+       root.SetParent(root, ".")
        if err := root.loadManifest(c.ManifestText); err != nil {
                return nil, err
        }
+       backdateTree(root, modTime)
        fs.root = root
        return fs, nil
 }
 
-type collectionFileSystem struct {
-       fileSystem
-       uuid string
+func backdateTree(n inode, modTime time.Time) {
+       switch n := n.(type) {
+       case *filenode:
+               n.fileinfo.modTime = modTime
+       case *dirnode:
+               n.fileinfo.modTime = modTime
+               for _, n := range n.inodes {
+                       backdateTree(n, modTime)
+               }
+       }
 }
 
 func (fs *collectionFileSystem) newNode(name string, perm os.FileMode, modTime time.Time) (node inode, err error) {
@@ -142,27 +133,6 @@ func (fs *collectionFileSystem) Sync() error {
        return err
 }
 
-func (dn *dirnode) Child(name string, replace func(inode) inode) inode {
-       if dn == dn.fs.rootnode() && name == ".arvados#collection" {
-               gn := &getternode{Getter: func() ([]byte, error) {
-                       var coll Collection
-                       var err error
-                       coll.ManifestText, err = dn.fs.MarshalManifest(".")
-                       if err != nil {
-                               return nil, err
-                       }
-                       data, err := json.Marshal(&coll)
-                       if err == nil {
-                               data = append(data, 10)
-                       }
-                       return data, err
-               }}
-               gn.SetParent(dn)
-               return gn
-       }
-       return dn.treenode.Child(name, replace)
-}
-
 func (fs *collectionFileSystem) MarshalManifest(prefix string) (string, error) {
        fs.fileSystem.root.Lock()
        defer fs.fileSystem.root.Unlock()
@@ -262,10 +232,11 @@ func (fn *filenode) appendSegment(e segment) {
        fn.fileinfo.size += int64(e.Len())
 }
 
-func (fn *filenode) SetParent(p inode) {
-       fn.RLock()
-       defer fn.RUnlock()
+func (fn *filenode) SetParent(p inode, name string) {
+       fn.Lock()
+       defer fn.Unlock()
        fn.parent = p
+       fn.fileinfo.name = name
 }
 
 func (fn *filenode) Parent() inode {
@@ -523,7 +494,7 @@ func (fn *filenode) pruneMemSegments() {
                if !ok || seg.Len() < maxBlockSize {
                        continue
                }
-               locator, _, err := fn.parent.(fsBackend).PutB(seg.buf)
+               locator, _, err := fn.FS().PutB(seg.buf)
                if err != nil {
                        // TODO: stall (or return errors from)
                        // subsequent writes until flushing
@@ -532,7 +503,7 @@ func (fn *filenode) pruneMemSegments() {
                }
                fn.memsize -= int64(seg.Len())
                fn.segments[idx] = storedSegment{
-                       kc:      fn.parent.FS(),
+                       kc:      fn.FS(),
                        locator: locator,
                        size:    seg.Len(),
                        offset:  0,
@@ -550,6 +521,27 @@ func (dn *dirnode) FS() FileSystem {
        return dn.fs
 }
 
+func (dn *dirnode) Child(name string, replace func(inode) inode) inode {
+       if dn == dn.fs.rootnode() && name == ".arvados#collection" {
+               gn := &getternode{Getter: func() ([]byte, error) {
+                       var coll Collection
+                       var err error
+                       coll.ManifestText, err = dn.fs.MarshalManifest(".")
+                       if err != nil {
+                               return nil, err
+                       }
+                       data, err := json.Marshal(&coll)
+                       if err == nil {
+                               data = append(data, '\n')
+                       }
+                       return data, err
+               }}
+               gn.SetParent(dn, name)
+               return gn
+       }
+       return dn.treenode.Child(name, replace)
+}
+
 // sync flushes in-memory data (for all files in the tree rooted at
 // dn) to persistent storage. Caller must hold dn.Lock().
 func (dn *dirnode) sync() error {
@@ -847,8 +839,9 @@ func (dn *dirnode) createFileAndParents(path string) (fn *filenode, err error) {
                }
                node.Child(name, func(child inode) inode {
                        if child == nil {
-                               node, err = node.FS().newNode(name, 0755|os.ModeDir, node.Parent().FileInfo().ModTime())
-                               child = node
+                               child, err = node.FS().newNode(name, 0755|os.ModeDir, node.Parent().FileInfo().ModTime())
+                               child.SetParent(node, name)
+                               node = child
                        } else if !child.IsDir() {
                                err = ErrFileExists
                        } else {
@@ -864,6 +857,7 @@ func (dn *dirnode) createFileAndParents(path string) (fn *filenode, err error) {
                switch child := child.(type) {
                case nil:
                        child, err = node.FS().newNode(basename, 0755, node.FileInfo().ModTime())
+                       child.SetParent(node, basename)
                        fn = child.(*filenode)
                        return child
                case *filenode: