Merge pull request #271 from nalind/template-layers

rhatdan · web-flow · commit 891018027efc · 2019-01-18T10:56:56.000-05:00
drivers: add CreateFromTemplate()
diff --git a/.travis.yml b/.travis.yml
@@ -76,6 +76,5 @@ script:
                          -e TRAVIS_JOB_ID=$TRAVIS_JOB_ID
                          -e TRAVIS_BUILD_DIR=$TRAVIS_BUILD_DIR"
     - env
-    - echo
     - echo "Running tests in SPC using ./hack/run_ci_tests.sh"
     - ./hack/run_ci_tests.sh
diff --git a/containers_ffjson.go b/containers_ffjson.go
diff --git a/drivers/aufs/aufs.go b/drivers/aufs/aufs.go
@@ -253,6 +253,11 @@ func (a *Driver) AdditionalImageStores() []string {
 	return nil
 }
 
+// CreateFromTemplate creates a layer with the same contents and parent as another layer.
+func (a *Driver) CreateFromTemplate(id, template string, templateIDMappings *idtools.IDMappings, parent string, parentIDMappings *idtools.IDMappings, opts *graphdriver.CreateOpts, readWrite bool) error {
+	return graphdriver.NaiveCreateFromTemplate(a, id, template, templateIDMappings, parent, parentIDMappings, opts, readWrite)
+}
+
 // CreateReadWrite creates a layer that is writable for use as a container
 // file system.
 func (a *Driver) CreateReadWrite(id, parent string, opts *graphdriver.CreateOpts) error {
diff --git a/drivers/aufs/aufs_test.go b/drivers/aufs/aufs_test.go
@@ -14,6 +14,7 @@ import (
 	"testing"
 
 	"github.com/containers/storage/drivers"
+	"github.com/containers/storage/drivers/graphtest"
 	"github.com/containers/storage/pkg/archive"
 	"github.com/containers/storage/pkg/reexec"
 	"github.com/containers/storage/pkg/stringid"
@@ -803,3 +804,23 @@ func TestInitStaleCleanup(t *testing.T) {
 		}
 	}
 }
+
+func TestAufsCreateEmpty(t *testing.T) {
+	graphtest.DriverTestCreateEmpty(t, "aufs")
+}
+
+func TestAufsCreateBase(t *testing.T) {
+	graphtest.DriverTestCreateBase(t, "aufs")
+}
+
+func TestAufsCreateSnap(t *testing.T) {
+	graphtest.DriverTestCreateSnap(t, "aufs")
+}
+
+func TestAufsCreateFromTemplate(t *testing.T) {
+	graphtest.DriverTestCreateFromTemplate(t, "aufs")
+}
+
+func TestAufsEcho(t *testing.T) {
+	graphtest.DriverTestEcho(t, "aufs")
+}
diff --git a/drivers/btrfs/btrfs.go b/drivers/btrfs/btrfs.go
@@ -490,6 +490,11 @@ func (d *Driver) quotasDirID(id string) string {
 	return path.Join(d.quotasDir(), id)
 }
 
+// CreateFromTemplate creates a layer with the same contents and parent as another layer.
+func (d *Driver) CreateFromTemplate(id, template string, templateIDMappings *idtools.IDMappings, parent string, parentIDMappings *idtools.IDMappings, opts *graphdriver.CreateOpts, readWrite bool) error {
+	return d.Create(id, template, opts)
+}
+
 // CreateReadWrite creates a layer that is writable for use as a container
 // file system.
 func (d *Driver) CreateReadWrite(id, parent string, opts *graphdriver.CreateOpts) error {
diff --git a/drivers/btrfs/btrfs_test.go b/drivers/btrfs/btrfs_test.go
@@ -29,6 +29,10 @@ func TestBtrfsCreateSnap(t *testing.T) {
 	graphtest.DriverTestCreateSnap(t, "btrfs")
 }
 
+func TestBtrfsCreateFromTemplate(t *testing.T) {
+	graphtest.DriverTestCreateFromTemplate(t, "btrfs")
+}
+
 func TestBtrfsSubvolDelete(t *testing.T) {
 	d := graphtest.GetDriver(t, "btrfs")
 	if err := d.CreateReadWrite("test", "", nil); err != nil {
diff --git a/drivers/devmapper/devmapper_test.go b/drivers/devmapper/devmapper_test.go
@@ -82,6 +82,10 @@ func TestDevmapperCreateSnap(t *testing.T) {
 	graphtest.DriverTestCreateSnap(t, "devicemapper", "test=1")
 }
 
+func TestDevmapperCreateFromTemplate(t *testing.T) {
+	graphtest.DriverTestCreateFromTemplate(t, "devicemapper", "test=1")
+}
+
 func TestDevmapperTeardown(t *testing.T) {
 	graphtest.PutDriver(t)
 }
diff --git a/drivers/devmapper/driver.go b/drivers/devmapper/driver.go
@@ -123,6 +123,11 @@ func (d *Driver) Cleanup() error {
 	return err
 }
 
+// CreateFromTemplate creates a layer with the same contents and parent as another layer.
+func (d *Driver) CreateFromTemplate(id, template string, templateIDMappings *idtools.IDMappings, parent string, parentIDMappings *idtools.IDMappings, opts *graphdriver.CreateOpts, readWrite bool) error {
+	return d.Create(id, template, opts)
+}
+
 // CreateReadWrite creates a layer that is writable for use as a container
 // file system.
 func (d *Driver) CreateReadWrite(id, parent string, opts *graphdriver.CreateOpts) error {
diff --git a/drivers/driver.go b/drivers/driver.go
@@ -72,6 +72,9 @@ type ProtoDriver interface {
 	// specified id and parent and options passed in opts. Parent
 	// may be "" and opts may be nil.
 	Create(id, parent string, opts *CreateOpts) error
+	// CreateFromTemplate creates a new filesystem layer with the specified id
+	// and parent, with contents identical to the specified template layer.
+	CreateFromTemplate(id, template string, templateIDMappings *idtools.IDMappings, parent string, parentIDMappings *idtools.IDMappings, opts *CreateOpts, readWrite bool) error
 	// Remove attempts to remove the filesystem layer with this id.
 	Remove(id string) error
 	// Get returns the mountpoint for the layered filesystem referred
diff --git a/drivers/graphtest/graphtest_unix.go b/drivers/graphtest/graphtest_unix.go
@@ -143,6 +143,100 @@ func DriverTestCreateSnap(t testing.TB, drivername string, driverOptions ...stri
 	verifyBase(t, driver, "Snap")
 }
 
+// DriverTestCreateFromTemplate Create a driver and template of a snap and verifies its
+// contents.
+func DriverTestCreateFromTemplate(t testing.TB, drivername string, driverOptions ...string) {
+	driver := GetDriver(t, drivername, driverOptions...)
+	defer PutDriver(t)
+
+	createBase(t, driver, "Base")
+	defer func() {
+		require.NoError(t, driver.Remove("Base"))
+	}()
+
+	err := driver.Create("Snap", "Base", nil)
+	require.NoError(t, err)
+	defer func() {
+		require.NoError(t, driver.Remove("Snap"))
+	}()
+
+	content := []byte("test content")
+	if err := addFile(driver, "Snap", "testfile.txt", content); err != nil {
+		t.Fatal(err)
+	}
+
+	err = driver.CreateFromTemplate("FromTemplate", "Snap", nil, "Base", nil, nil, true)
+	require.NoError(t, err)
+	defer func() {
+		require.NoError(t, driver.Remove("FromTemplate"))
+	}()
+
+	err = driver.CreateFromTemplate("ROFromTemplate", "Snap", nil, "Base", nil, nil, false)
+	require.NoError(t, err)
+	defer func() {
+		require.NoError(t, driver.Remove("ROFromTemplate"))
+	}()
+
+	noChanges := []archive.Change{}
+
+	changes, err := driver.Changes("FromTemplate", nil, "Snap", nil, "")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err = checkChanges(noChanges, changes); err != nil {
+		t.Fatal(err)
+	}
+
+	changes, err = driver.Changes("ROFromTemplate", nil, "Snap", nil, "")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err = checkChanges(noChanges, changes); err != nil {
+		t.Fatal(err)
+	}
+
+	if err := checkFile(driver, "FromTemplate", "testfile.txt", content); err != nil {
+		t.Fatal(err)
+	}
+	if err := checkFile(driver, "ROFromTemplate", "testfile.txt", content); err != nil {
+		t.Fatal(err)
+	}
+	if err := checkFile(driver, "Snap", "testfile.txt", content); err != nil {
+		t.Fatal(err)
+	}
+
+	expectedChanges := []archive.Change{{
+		Path: "/testfile.txt",
+		Kind: archive.ChangeAdd,
+	}}
+
+	changes, err = driver.Changes("Snap", nil, "Base", nil, "")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err = checkChanges(expectedChanges, changes); err != nil {
+		t.Fatal(err)
+	}
+
+	changes, err = driver.Changes("FromTemplate", nil, "Base", nil, "")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err = checkChanges(expectedChanges, changes); err != nil {
+		t.Fatal(err)
+	}
+
+	changes, err = driver.Changes("ROFromTemplate", nil, "Base", nil, "")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err = checkChanges(expectedChanges, changes); err != nil {
+		t.Fatal(err)
+	}
+
+	verifyBase(t, driver, "Base")
+}
+
 // DriverTestDeepLayerRead reads a file from a lower layer under a given number of layers
 func DriverTestDeepLayerRead(t testing.TB, layerCount int, drivername string, driverOptions ...string) {
 	driver := GetDriver(t, drivername, driverOptions...)
diff --git a/drivers/overlay/overlay.go b/drivers/overlay/overlay.go
@@ -418,6 +418,14 @@ func (d *Driver) Cleanup() error {
 	return mount.Unmount(d.home)
 }
 
+// CreateFromTemplate creates a layer with the same contents and parent as another layer.
+func (d *Driver) CreateFromTemplate(id, template string, templateIDMappings *idtools.IDMappings, parent string, parentIDMappings *idtools.IDMappings, opts *graphdriver.CreateOpts, readWrite bool) error {
+	if readWrite {
+		return d.CreateReadWrite(id, template, opts)
+	}
+	return d.Create(id, template, opts)
+}
+
 // CreateReadWrite creates a layer that is writable for use as a container
 // file system.
 func (d *Driver) CreateReadWrite(id, parent string, opts *graphdriver.CreateOpts) error {
diff --git a/drivers/overlay/overlay_test.go b/drivers/overlay/overlay_test.go
@@ -66,6 +66,10 @@ func TestOverlayCreateSnap(t *testing.T) {
 	graphtest.DriverTestCreateSnap(t, driverName)
 }
 
+func TestOverlayCreateFromTemplate(t *testing.T) {
+	graphtest.DriverTestCreateFromTemplate(t, driverName)
+}
+
 func TestOverlay128LayerRead(t *testing.T) {
 	graphtest.DriverTestDeepLayerRead(t, 128, driverName)
 }
diff --git a/drivers/template.go b/drivers/template.go
@@ -0,0 +1,45 @@
+package graphdriver
+
+import (
+	"github.com/sirupsen/logrus"
+
+	"github.com/containers/storage/pkg/idtools"
+)
+
+// TemplateDriver is just barely enough of a driver that we can implement a
+// naive version of CreateFromTemplate on top of it.
+type TemplateDriver interface {
+	DiffDriver
+	CreateReadWrite(id, parent string, opts *CreateOpts) error
+	Create(id, parent string, opts *CreateOpts) error
+	Remove(id string) error
+}
+
+// CreateFromTemplate creates a layer with the same contents and parent as
+// another layer.  Internally, it may even depend on that other layer
+// continuing to exist, as if it were actually a child of the child layer.
+func NaiveCreateFromTemplate(d TemplateDriver, id, template string, templateIDMappings *idtools.IDMappings, parent string, parentIDMappings *idtools.IDMappings, opts *CreateOpts, readWrite bool) error {
+	var err error
+	if readWrite {
+		err = d.CreateReadWrite(id, parent, opts)
+	} else {
+		err = d.Create(id, parent, opts)
+	}
+	if err != nil {
+		return err
+	}
+	diff, err := d.Diff(template, templateIDMappings, parent, parentIDMappings, opts.MountLabel)
+	if err != nil {
+		if err2 := d.Remove(id); err2 != nil {
+			logrus.Errorf("error removing layer %q: %v", id, err2)
+		}
+		return err
+	}
+	if _, err = d.ApplyDiff(id, templateIDMappings, parent, opts.MountLabel, diff); err != nil {
+		if err2 := d.Remove(id); err2 != nil {
+			logrus.Errorf("error removing layer %q: %v", id, err2)
+		}
+		return err
+	}
+	return nil
+}
diff --git a/drivers/vfs/driver.go b/drivers/vfs/driver.go
@@ -99,6 +99,14 @@ func (d *Driver) Cleanup() error {
 	return nil
 }
 
+// CreateFromTemplate creates a layer with the same contents and parent as another layer.
+func (d *Driver) CreateFromTemplate(id, template string, templateIDMappings *idtools.IDMappings, parent string, parentIDMappings *idtools.IDMappings, opts *graphdriver.CreateOpts, readWrite bool) error {
+	if readWrite {
+		return d.CreateReadWrite(id, template, opts)
+	}
+	return d.Create(id, template, opts)
+}
+
 // CreateReadWrite creates a layer that is writable for use as a container
 // file system.
 func (d *Driver) CreateReadWrite(id, parent string, opts *graphdriver.CreateOpts) error {
diff --git a/drivers/vfs/vfs_test.go b/drivers/vfs/vfs_test.go
@@ -32,6 +32,10 @@ func TestVfsCreateSnap(t *testing.T) {
 	graphtest.DriverTestCreateSnap(t, "vfs")
 }
 
+func TestVfsCreateFromTemplate(t *testing.T) {
+	graphtest.DriverTestCreateFromTemplate(t, "vfs")
+}
+
 func TestVfsTeardown(t *testing.T) {
 	graphtest.PutDriver(t)
 }
diff --git a/drivers/windows/windows.go b/drivers/windows/windows.go
@@ -185,6 +185,11 @@ func (d *Driver) Exists(id string) bool {
 	return result
 }
 
+// CreateFromTemplate creates a layer with the same contents and parent as another layer.
+func (d *Driver) CreateFromTemplate(id, template string, templateIDMappings *idtools.IDMappings, parent string, parentIDMappings *idtools.IDMappings, opts *graphdriver.CreateOpts, readWrite bool) error {
+	return graphdriver.NaiveCreateFromTemplate(d, id, template, templateIDMappings, parent, parentIDMappings, opts, readWrite)
+}
+
 // CreateReadWrite creates a layer that is writable for use as a container
 // file system.
 func (d *Driver) CreateReadWrite(id, parent string, opts *graphdriver.CreateOpts) error {
diff --git a/drivers/zfs/zfs.go b/drivers/zfs/zfs.go
@@ -259,6 +259,11 @@ func (d *Driver) mountPath(id string) string {
 	return path.Join(d.options.mountPath, "graph", getMountpoint(id))
 }
 
+// CreateFromTemplate creates a layer with the same contents and parent as another layer.
+func (d *Driver) CreateFromTemplate(id, template string, templateIDMappings *idtools.IDMappings, parent string, parentIDMappings *idtools.IDMappings, opts *graphdriver.CreateOpts, readWrite bool) error {
+	return d.Create(id, template, opts)
+}
+
 // CreateReadWrite creates a layer that is writable for use as a container
 // file system.
 func (d *Driver) CreateReadWrite(id, parent string, opts *graphdriver.CreateOpts) error {
diff --git a/drivers/zfs/zfs_test.go b/drivers/zfs/zfs_test.go
@@ -26,6 +26,10 @@ func TestZfsCreateSnap(t *testing.T) {
 	graphtest.DriverTestCreateSnap(t, "zfs")
 }
 
+func TestZfsCreateFromTemplate(t *testing.T) {
+	graphtest.DriverTestCreateFromTemplate(t, "zfs")
+}
+
 func TestZfsSetQuota(t *testing.T) {
 	graphtest.DriverTestSetQuota(t, "zfs")
 }
diff --git a/images.go b/images.go
@@ -42,7 +42,9 @@ type Image struct {
 
 	// MappedTopLayers are the IDs of alternate versions of the top layer
 	// which have the same contents and parent, and which differ from
-	// TopLayer only in which ID mappings they use.
+	// TopLayer only in which ID mappings they use.  When the image is
+	// to be removed, they should be removed before the TopLayer, as the
+	// graph driver may depend on that.
 	MappedTopLayers []string `json:"mapped-layers,omitempty"`
 
 	// Metadata is data we keep for the convenience of the caller.  It is not
diff --git a/images_ffjson.go b/images_ffjson.go
diff --git a/layers.go b/layers.go
diff --git a/layers_ffjson.go b/layers_ffjson.go
diff --git a/store.go b/store.go

Original file line number	Diff line number	Diff line change
`@@ -82,6 +82,10 @@ func TestDevmapperCreateSnap(t *testing.T) {`
`82`	`82`	`graphtest.DriverTestCreateSnap(t, "devicemapper", "test=1")`
`83`	`83`	`}`
`84`	`84`
	`85`	`+func TestDevmapperCreateFromTemplate(t *testing.T) {`
	`86`	`+ graphtest.DriverTestCreateFromTemplate(t, "devicemapper", "test=1")`
	`87`	`+}`
	`88`	`+`
`85`	`89`	`func TestDevmapperTeardown(t *testing.T) {`
`86`	`90`	`graphtest.PutDriver(t)`
`87`	`91`	`}`