sdk/go/arvados/fs_deferred.go

   1 // Copyright (C) The Arvados Authors. All rights reserved.
   2 //
   3 // SPDX-License-Identifier: Apache-2.0
   4
   5 package arvados
   6
   7 import (
   8         "log"
   9         "os"
  10         "sync"
  11         "time"
  12 )
  13
  14 func deferredCollectionFS(fs FileSystem, parent inode, coll Collection) inode {
  15         modTime := coll.ModifiedAt
  16         if modTime.IsZero() {
  17                 modTime = time.Now()
  18         }
  19         placeholder := &treenode{
  20                 fs:     fs,
  21                 parent: parent,
  22                 inodes: nil,
  23                 fileinfo: fileinfo{
  24                         name:    coll.Name,
  25                         modTime: modTime,
  26                         mode:    0755 | os.ModeDir,
  27                 },
  28         }
  29         return &deferrednode{wrapped: placeholder, create: func() inode {
  30                 err := fs.RequestAndDecode(&coll, "GET", "arvados/v1/collections/"+coll.UUID, nil, nil)
  31                 if err != nil {
  32                         log.Printf("BUG: unhandled error: %s", err)
  33                         return placeholder
  34                 }
  35                 newfs, err := coll.FileSystem(fs, fs)
  36                 if err != nil {
  37                         log.Printf("BUG: unhandled error: %s", err)
  38                         return placeholder
  39                 }
  40                 cfs := newfs.(*collectionFileSystem)
  41                 cfs.SetParent(parent, coll.Name)
  42                 return cfs
  43         }}
  44 }
  45
  46 // A deferrednode wraps an inode that's expensive to build. Initially,
  47 // it responds to basic directory functions by proxying to the given
  48 // placeholder. If a caller uses a read/write/lock operation,
  49 // deferrednode calls the create() func to create the real inode, and
  50 // proxies to the real inode from then on.
  51 //
  52 // In practice, this means a deferrednode's parent's directory listing
  53 // can be generated using only the placeholder, instead of waiting for
  54 // create().
  55 type deferrednode struct {
  56         wrapped inode
  57         create  func() inode
  58         mtx     sync.Mutex
  59         created bool
  60 }
  61
  62 func (dn *deferrednode) realinode() inode {
  63         dn.mtx.Lock()
  64         defer dn.mtx.Unlock()
  65         if !dn.created {
  66                 dn.wrapped = dn.create()
  67                 dn.created = true
  68         }
  69         return dn.wrapped
  70 }
  71
  72 func (dn *deferrednode) currentinode() inode {
  73         dn.mtx.Lock()
  74         defer dn.mtx.Unlock()
  75         return dn.wrapped
  76 }
  77
  78 func (dn *deferrednode) Read(p []byte, pos filenodePtr) (int, filenodePtr, error) {
  79         return dn.realinode().Read(p, pos)
  80 }
  81
  82 func (dn *deferrednode) Write(p []byte, pos filenodePtr) (int, filenodePtr, error) {
  83         return dn.realinode().Write(p, pos)
  84 }
  85
  86 func (dn *deferrednode) Child(name string, replace func(inode) (inode, error)) (inode, error) {
  87         return dn.realinode().Child(name, replace)
  88 }
  89
  90 // Sync is a no-op if the real inode hasn't even been created yet.
  91 func (dn *deferrednode) Sync() error {
  92         dn.mtx.Lock()
  93         defer dn.mtx.Unlock()
  94         if !dn.created {
  95                 return nil
  96         } else if syncer, ok := dn.wrapped.(syncer); ok {
  97                 return syncer.Sync()
  98         } else {
  99                 return ErrInvalidOperation
 100         }
 101 }
 102
 103 func (dn *deferrednode) Truncate(size int64) error       { return dn.realinode().Truncate(size) }
 104 func (dn *deferrednode) SetParent(p inode, name string)  { dn.realinode().SetParent(p, name) }
 105 func (dn *deferrednode) IsDir() bool                     { return dn.currentinode().IsDir() }
 106 func (dn *deferrednode) Readdir() ([]os.FileInfo, error) { return dn.realinode().Readdir() }
 107 func (dn *deferrednode) Size() int64                     { return dn.currentinode().Size() }
 108 func (dn *deferrednode) FileInfo() os.FileInfo           { return dn.currentinode().FileInfo() }
 109 func (dn *deferrednode) Lock()                           { dn.realinode().Lock() }
 110 func (dn *deferrednode) Unlock()                         { dn.realinode().Unlock() }
 111 func (dn *deferrednode) RLock()                          { dn.realinode().RLock() }
 112 func (dn *deferrednode) RUnlock()                        { dn.realinode().RUnlock() }
 113 func (dn *deferrednode) FS() FileSystem                  { return dn.currentinode().FS() }
 114 func (dn *deferrednode) Parent() inode                   { return dn.currentinode().Parent() }
 115 func (dn *deferrednode) MemorySize() int64               { return dn.currentinode().MemorySize() }
 116 func (dn *deferrednode) Snapshot() (inode, error)        { return dn.realinode().Snapshot() }
 117 func (dn *deferrednode) Splice(repl inode) error         { return dn.realinode().Splice(repl) }