157 lines
3.2 KiB
Go
157 lines
3.2 KiB
Go
package snapshot
|
|
|
|
import (
|
|
"crypto/md5"
|
|
"encoding/hex"
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
|
|
"github.com/docker/containerd"
|
|
)
|
|
|
|
func NewOverlayfs(root string) (*Overlayfs, error) {
|
|
if err := os.MkdirAll(root, 0700); err != nil {
|
|
return nil, err
|
|
}
|
|
for _, p := range []string{
|
|
"snapshots",
|
|
"active",
|
|
} {
|
|
if err := os.MkdirAll(filepath.Join(root, p), 0700); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
return &Overlayfs{
|
|
root: root,
|
|
}, nil
|
|
}
|
|
|
|
type Overlayfs struct {
|
|
root string
|
|
}
|
|
|
|
func (o *Overlayfs) Prepare(key string, parentName string) ([]containerd.Mount, error) {
|
|
if err := validKey(key); err != nil {
|
|
return nil, err
|
|
}
|
|
active, err := o.newActiveDir(key)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if parentName != "" {
|
|
if err := active.setParent(parentName); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
return active.mounts()
|
|
}
|
|
|
|
func (o *Overlayfs) Commit(key string, name string) error {
|
|
active := o.getActive(key)
|
|
return active.commit(name)
|
|
}
|
|
|
|
func (o *Overlayfs) newActiveDir(key string) (*activeDir, error) {
|
|
var (
|
|
hash = hash(key)
|
|
path = filepath.Join(o.root, "active", hash)
|
|
)
|
|
a := &activeDir{
|
|
path: path,
|
|
snapshotsDir: filepath.Join(o.root, "snapshots"),
|
|
}
|
|
for _, p := range []string{
|
|
"work",
|
|
"fs",
|
|
} {
|
|
if err := os.MkdirAll(filepath.Join(path, p), 0700); err != nil {
|
|
a.delete()
|
|
return nil, err
|
|
}
|
|
}
|
|
return a, nil
|
|
}
|
|
|
|
func (o *Overlayfs) getActive(key string) *activeDir {
|
|
return &activeDir{
|
|
path: filepath.Join(o.root, "active", hash(key)),
|
|
snapshotsDir: filepath.Join(o.root, "snapshots"),
|
|
}
|
|
}
|
|
|
|
func validKey(key string) error {
|
|
_, err := filepath.Abs(key)
|
|
return err
|
|
}
|
|
|
|
func hash(k string) string {
|
|
h := md5.New()
|
|
h.Write([]byte(k))
|
|
return hex.EncodeToString(h.Sum(nil))
|
|
}
|
|
|
|
type activeDir struct {
|
|
snapshotsDir string
|
|
path string
|
|
}
|
|
|
|
func (a *activeDir) delete() error {
|
|
return os.RemoveAll(a.path)
|
|
}
|
|
|
|
func (a *activeDir) setParent(name string) error {
|
|
return os.Symlink(filepath.Join(a.snapshotsDir, name), filepath.Join(a.path, "parent"))
|
|
}
|
|
|
|
func (a *activeDir) commit(name string) error {
|
|
if err := os.RemoveAll(filepath.Join(a.path, "work")); err != nil {
|
|
return err
|
|
}
|
|
return os.Rename(a.path, filepath.Join(a.snapshotsDir, name))
|
|
}
|
|
|
|
func (a *activeDir) mounts() ([]containerd.Mount, error) {
|
|
var (
|
|
parentLink = filepath.Join(a.path, "parent")
|
|
parents []string
|
|
)
|
|
for {
|
|
snapshot, err := os.Readlink(parentLink)
|
|
if err != nil {
|
|
if os.IsNotExist(err) {
|
|
break
|
|
}
|
|
return nil, err
|
|
}
|
|
parents = append(parents, filepath.Join(snapshot, "fs"))
|
|
parentLink = filepath.Join(snapshot, "parent")
|
|
}
|
|
if len(parents) == 0 {
|
|
// if we only have one layer/no parents then just return a bind mount as overlay
|
|
// will not work
|
|
return []containerd.Mount{
|
|
{
|
|
Source: filepath.Join(a.path, "fs"),
|
|
Type: "bind",
|
|
Options: []string{
|
|
"rw",
|
|
"rbind",
|
|
},
|
|
},
|
|
}, nil
|
|
}
|
|
options := []string{
|
|
fmt.Sprintf("workdir=%s", filepath.Join(a.path, "work")),
|
|
fmt.Sprintf("upperdir=%s", filepath.Join(a.path, "fs")),
|
|
fmt.Sprintf("lowerdir=%s", strings.Join(parents, ":")),
|
|
}
|
|
return []containerd.Mount{
|
|
{
|
|
Type: "overlay",
|
|
Source: "overlay",
|
|
Options: options,
|
|
},
|
|
}, nil
|
|
}
|