prime8dev

overlay.go (6831B)

---

 package vfs
 
 import (
 	"errors"
 	"path"
 	"sort"
 	"strings"
 )
 
 // Writable layer for the shell. The generated tree (Build) stays read-only and
 // shared; each shell session keeps an Overlay of what it created, changed or
 // deleted, and FS replays it over a private clone of the base on every
 // command. The overlay lives in memory only (an SSH session loses it on
 // disconnect) and is capped so a public session cannot grow without bound.
 
 const (
 	// OverlayQuota caps the bytes (paths + contents) one session may write.
 	OverlayQuota = 1 << 20
 	// OverlayMaxEntries caps how many paths one session may touch.
 	OverlayMaxEntries = 4096
 )
 
 // Errors carry the text a shell prints after "cmd: 'path': ".
 var (
 	ErrNotExist   = errors.New("No such file or directory")
 	ErrNotDir     = errors.New("Not a directory")
 	ErrIsDir      = errors.New("Is a directory")
 	ErrExist      = errors.New("File exists")
 	ErrNotEmpty   = errors.New("Directory not empty")
 	ErrPermission = errors.New("Permission denied")
 	ErrNoSpace    = errors.New("No space left on device")
 )
 
 // overlayEntry is one changed path. A nil *overlayEntry in the map is a
 // whiteout (deleted base node). fresh marks a directory that replaces the
 // base directory at the same path instead of merging with it.
 type overlayEntry struct {
 	dir     bool
 	fresh   bool
 	content string
 }
 
 func (e *overlayEntry) size(p string) int {
 	if e == nil {
 		return len(p)
 	}
 	return len(p) + len(e.content)
 }
 
 // Overlay is a session's set of changes, keyed by absolute path.
 type Overlay struct {
 	entries map[string]*overlayEntry
 	used    int
 }
 
 // NewOverlay returns an empty overlay.
 func NewOverlay() *Overlay {
 	return &Overlay{entries: map[string]*overlayEntry{}}
 }
 
 // Changes is the number of paths the overlay touches.
 func (o *Overlay) Changes() int { return len(o.entries) }
 
 // Used is the bytes counted against OverlayQuota.
 func (o *Overlay) Used() int { return o.used }
 
 // Reset drops every change.
 func (o *Overlay) Reset() {
 	o.entries = map[string]*overlayEntry{}
 	o.used = 0
 }
 
 func (o *Overlay) set(p string, e *overlayEntry) error {
 	old, had := o.entries[p]
 	next := o.used + e.size(p)
 	if had {
 		next -= old.size(p)
 	}
 	if next > OverlayQuota || (!had && len(o.entries) >= OverlayMaxEntries) {
 		return ErrNoSpace
 	}
 	o.entries[p] = e
 	o.used = next
 	return nil
 }
 
 func (o *Overlay) drop(p string) {
 	if e, ok := o.entries[p]; ok {
 		o.used -= e.size(p)
 		delete(o.entries, p)
 	}
 }
 
 // Clone deep-copies a node.
 func (n *Node) Clone() *Node {
 	c := &Node{Name: n.Name, Dir: n.Dir, Content: n.Content}
 	if n.Dir {
 		c.Children = make(map[string]*Node, len(n.Children))
 		for k, v := range n.Children {
 			c.Children[k] = v.Clone()
 		}
 	}
 	return c
 }
 
 // FS is a writable view: a private clone of base with the overlay applied.
 // Mutations update both the view and the overlay; base is never touched.
 type FS struct {
 	base *Node
 	root *Node
 	home string
 	ov   *Overlay
 }
 
 // NewFS clones base and replays ov over it. home (and /tmp) are writable.
 func NewFS(base *Node, home string, ov *Overlay) *FS {
 	if ov == nil {
 		ov = NewOverlay()
 	}
 	f := &FS{base: base, root: base.Clone(), home: home, ov: ov}
 	f.apply()
 	return f
 }
 
 func depth(p string) int { return strings.Count(p, "/") }
 
 func (f *FS) apply() {
 	keys := make([]string, 0, len(f.ov.entries))
 	for k := range f.ov.entries {
 		keys = append(keys, k)
 	}
 	sort.Slice(keys, func(i, j int) bool {
 		if di, dj := depth(keys[i]), depth(keys[j]); di != dj {
 			return di < dj
 		}
 		return keys[i] < keys[j]
 	})
 	for _, k := range keys {
 		parent := f.root.Lookup(path.Dir(k))
 		if parent == nil || !parent.Dir {
 			continue
 		}
 		name := path.Base(k)
 		e := f.ov.entries[k]
 		switch {
 		case e == nil:
 			delete(parent.Children, name)
 		case e.dir:
 			if cur, ok := parent.Children[name]; e.fresh || !ok || !cur.Dir {
 				parent.Children[name] = NewDir(name)
 			}
 		default:
 			parent.AddFile(name, e.content)
 		}
 	}
 }
 
 // Root is the merged tree. Treat it as read-only; mutate through FS.
 func (f *FS) Root() *Node { return f.root }
 
 // Get looks up an absolute path in the merged tree.
 func (f *FS) Get(abs string) *Node { return f.root.Lookup(abs) }
 
 func inside(abs, base string) bool {
 	return abs == base || strings.HasPrefix(abs, strings.TrimSuffix(base, "/")+"/")
 }
 
 // Writable: the session owns its home and /tmp; the rest belongs to root.
 func (f *FS) Writable(abs string) bool {
 	return inside(abs, f.home) || inside(abs, "/tmp")
 }
 
 // CheckCreate reports why abs cannot be created, replaced or removed.
 func (f *FS) CheckCreate(abs string) error {
 	if abs == "/" {
 		return ErrPermission
 	}
 	parent := f.Get(path.Dir(abs))
 	switch {
 	case parent == nil:
 		return ErrNotExist
 	case !parent.Dir:
 		return ErrNotDir
 	case !f.Writable(path.Dir(abs)) || !f.Writable(abs):
 		return ErrPermission
 	}
 	return nil
 }
 
 func (f *FS) inBase(abs string) bool { return f.base.Lookup(abs) != nil }
 
 // Mkdir creates (or replaces) a directory at abs. Call CheckCreate first.
 func (f *FS) Mkdir(abs string) error {
 	parent := f.Get(path.Dir(abs))
 	if parent == nil || !parent.Dir {
 		return ErrNotExist
 	}
 	if err := f.ov.set(abs, &overlayEntry{dir: true, fresh: f.inBase(abs)}); err != nil {
 		return err
 	}
 	name := path.Base(abs)
 	parent.Children[name] = NewDir(name)
 	return nil
 }
 
 // Write creates or replaces the file at abs. Call CheckCreate first.
 func (f *FS) Write(abs, content string) error {
 	parent := f.Get(path.Dir(abs))
 	if parent == nil || !parent.Dir {
 		return ErrNotExist
 	}
 	if err := f.ov.set(abs, &overlayEntry{content: content}); err != nil {
 		return err
 	}
 	parent.AddFile(path.Base(abs), content)
 	return nil
 }
 
 // Remove deletes abs and everything under it. Call CheckCreate first.
 func (f *FS) Remove(abs string) error {
 	parent := f.Get(path.Dir(abs))
 	if parent == nil || !parent.Dir {
 		return ErrNotExist
 	}
 	prefix := abs + "/"
 	for k := range f.ov.entries {
 		if strings.HasPrefix(k, prefix) {
 			f.ov.drop(k)
 		}
 	}
 	if f.inBase(abs) {
 		if err := f.ov.set(abs, nil); err != nil {
 			return err
 		}
 	} else {
 		f.ov.drop(abs)
 	}
 	delete(parent.Children, path.Base(abs))
 	return nil
 }
 
 // Copy materializes n (a whole subtree for a directory) at abs.
 func (f *FS) Copy(n *Node, abs string) error {
 	n = n.Clone() // n may live under abs's old subtree
 	if f.Get(abs) != nil {
 		if err := f.Remove(abs); err != nil {
 			return err
 		}
 	}
 	if !n.Dir {
 		return f.Write(abs, n.Content)
 	}
 	if err := f.Mkdir(abs); err != nil {
 		return err
 	}
 	for _, c := range n.SortedChildren() {
 		if err := f.Copy(c, path.Join(abs, c.Name)); err != nil {
 			return err
 		}
 	}
 	return nil
 }
 
 // Count is the number of nodes in n's subtree, n included.
 func Count(n *Node) int {
 	if !n.Dir {
 		return 1
 	}
 	total := 1
 	for _, c := range n.Children {
 		total += Count(c)
 	}
 	return total
 }