github.com/mgoltzsche/ctnr@v0.7.1-alpha/pkg/fs/writer/fsnodewriter.go (about)

     1  package writer
     2  
     3  import (
     4  	"github.com/mgoltzsche/ctnr/pkg/fs"
     5  	"github.com/mgoltzsche/ctnr/pkg/fs/source"
     6  	"github.com/pkg/errors"
     7  )
     8  
     9  // Writer that builds a node tree and delegates operations to wrapped writer
    10  // using the inserted node's path.
    11  type FsNodeWriter struct {
    12  	node fs.FsNode
    13  	//writtenLower map[types.Source]string
    14  	delegate fs.Writer
    15  }
    16  
    17  func NewFsNodeWriter(root fs.FsNode, delegate fs.Writer) (w fs.Writer) {
    18  	return &FsNodeWriter{root /*map[types.Source]string{},*/, delegate}
    19  }
    20  
    21  func (w *FsNodeWriter) FS() fs.FsNode {
    22  	return w.node
    23  }
    24  
    25  func (w *FsNodeWriter) Parent() error {
    26  	return w.delegate.Parent()
    27  }
    28  
    29  func (w *FsNodeWriter) Mkdir(dir string) (err error) {
    30  	return w.delegate.Mkdir(dir)
    31  }
    32  
    33  func (w *FsNodeWriter) LowerNode(path, name string, a *fs.NodeAttrs) (err error) {
    34  	node, err := w.node.AddLower(path, a)
    35  	if err == nil {
    36  		return
    37  	}
    38  	//w.writtenLower[node.source] = path
    39  	return w.delegate.LowerNode(node.Path(), node.Name(), a)
    40  }
    41  
    42  func (w *FsNodeWriter) Lazy(path, name string, src fs.LazySource, written map[fs.Source]string) (err error) {
    43  	node, err := w.node.AddUpper(path, src)
    44  	if err == nil {
    45  		return
    46  	}
    47  	return w.delegate.Lazy(node.Path(), node.Name(), src, written)
    48  }
    49  
    50  func (w *FsNodeWriter) File(file string, src fs.FileSource) (r fs.Source, err error) {
    51  	node, err := w.node.AddUpper(file, src)
    52  	if err != nil {
    53  		return
    54  	}
    55  	r, err = w.delegate.File(node.Path(), src)
    56  	node.SetSource(r)
    57  	return
    58  }
    59  
    60  func (w *FsNodeWriter) Link(path, target string) error {
    61  	linkedNode, targetNode, err := w.node.Link(path, target)
    62  	if err != nil {
    63  		return errors.WithMessage(err, "link")
    64  	}
    65  	return w.delegate.Link(linkedNode.Path(), targetNode.Path())
    66  }
    67  
    68  func (w *FsNodeWriter) LowerLink(path, target string, a *fs.NodeAttrs) error {
    69  	node, err := w.node.AddLower(path, a)
    70  	if err == nil {
    71  		return errors.WithMessage(err, "lower link")
    72  	}
    73  	return w.delegate.LowerLink(node.Path(), target, a)
    74  }
    75  
    76  func (w *FsNodeWriter) Symlink(path string, a fs.FileAttrs) (err error) {
    77  	node, err := w.node.AddUpper(path, source.NewSourceSymlink(a))
    78  	if err != nil {
    79  		return
    80  	}
    81  	return w.delegate.Symlink(node.Path(), a)
    82  }
    83  
    84  func (w *FsNodeWriter) Fifo(file string, a fs.DeviceAttrs) (err error) {
    85  	node, err := w.node.AddUpper(file, source.NewSourceFifo(a))
    86  	if err != nil {
    87  		return
    88  	}
    89  	return w.delegate.Fifo(node.Path(), a)
    90  }
    91  
    92  func (w *FsNodeWriter) Device(path string, a fs.DeviceAttrs) (err error) {
    93  	node, err := w.node.AddUpper(path, source.NewSourceDevice(a))
    94  	if err != nil {
    95  		return
    96  	}
    97  	return w.delegate.Device(node.Path(), a)
    98  }
    99  
   100  func (w *FsNodeWriter) Dir(dir, base string, a fs.FileAttrs) (err error) {
   101  	node, err := w.node.AddUpper(dir, source.NewSourceDir(a))
   102  	if err != nil {
   103  		return
   104  	}
   105  	return w.delegate.Dir(node.Path(), node.Name(), a)
   106  }
   107  
   108  func (w *FsNodeWriter) Remove(file string) (err error) {
   109  	node, err := w.node.AddWhiteout(file)
   110  	if err != nil {
   111  		return
   112  	}
   113  	return w.delegate.Remove(node.Path())
   114  }