feature: support creating container by just specifying rootfs

Signed-off-by: Michael Wan <[email protected]>

Author: HusterWan

ctrd/container.go

@@ -345,35 +345,45 @@ func (c *Client) createContainer(ctx context.Context, ref, id string, container
 		return fmt.Errorf("failed to get a containerd grpc client: %v", err)
 	}
 
-	// get image
-	img, err := wrapperCli.client.GetImage(ctx, ref)
-	if err != nil {
-		if errdefs.IsNotFound(err) {
-			return errors.Wrapf(errtypes.ErrNotfound, "image %s", ref)
+	// if creating the container by specify rootfs, we no need use the image
+	if !container.RootFSProvided {
+		// get image
+		img, err := wrapperCli.client.GetImage(ctx, ref)
+		if err != nil {
+			if errdefs.IsNotFound(err) {
+				return errors.Wrapf(errtypes.ErrNotfound, "image %s", ref)
+			}
+			return errors.Wrapf(err, "failed to get image %s", ref)
 		}
-		return errors.Wrapf(err, "failed to get image %s", ref)
-	}
 
-	logrus.Infof("success to get image %s, container id %s", img.Name(), id)
-
-	// create container
-	specOptions := []oci.SpecOpts{
-		oci.WithRootFSPath("rootfs"),
+		logrus.Infof("success to get image %s, container id %s", img.Name(), id)
 	}
 
+	// create container
 	options := []containerd.NewContainerOpts{
-		containerd.WithSpec(container.Spec, specOptions...),
 		containerd.WithRuntime(fmt.Sprintf("io.containerd.runtime.v1.%s", runtime.GOOS), &runctypes.RuncOptions{
 			Runtime:     container.Runtime,
 			RuntimeRoot: runtimeRoot,
 		}),
 	}
 
-	// check snapshot exist or not.
-	if _, err := c.GetSnapshot(ctx, id); err != nil {
-		return errors.Wrapf(err, "failed to create container %s", id)
+	rootFSPath := "rootfs"
+	// if container is taken over by pouch, not created by pouch
+	if container.RootFSProvided {
+		rootFSPath = container.BaseFS
+	} else { // containers created by pouch must first create snapshot
+		// check snapshot exist or not.
+		if _, err := c.GetSnapshot(ctx, id); err != nil {
+			return errors.Wrapf(err, "failed to create container %s", id)
+		}
+		options = append(options, containerd.WithSnapshot(id))
+	}
+
+	// specify Spec for new container
+	specOptions := []oci.SpecOpts{
+		oci.WithRootFSPath(rootFSPath),
 	}
-	options = append(options, containerd.WithSnapshot(id))
+	options = append(options, containerd.WithSpec(container.Spec, specOptions...))
 
 	nc, err := wrapperCli.client.NewContainer(ctx, id, options...)
 	if err != nil {

ctrd/container_types.go

@@ -6,13 +6,22 @@ import (
 	specs "github.com/opencontainers/runtime-spec/specs-go"
 )
 
-// Container wraps container's info.
+// Container wraps container's info. there have two kind of containers now:
+// One is created by pouch: first using image to create snapshot,
+// then create container by specifying the snapshot;
+// The other is create container by specify container rootfs, we use `RootFSProvided` flag to mark it,
 type Container struct {
 	ID      string
 	Image   string
 	Runtime string
 	IO      *containerio.IO
 	Spec    *specs.Spec
+
+	// BaseFS is rootfs used by containerd container
+	BaseFS string
+
+	// RootFSProvided is a flag to point the container is created by specifying rootfs
+	RootFSProvided bool
 }
 
 // Process wraps exec process's info.

daemon/mgr/container.go

@@ -25,12 +25,14 @@ import (
 	"github.com/alibaba/pouch/pkg/collect"
 	"github.com/alibaba/pouch/pkg/errtypes"
 	"github.com/alibaba/pouch/pkg/meta"
+	mountutils "github.com/alibaba/pouch/pkg/mount"
 	"github.com/alibaba/pouch/pkg/randomid"
 	"github.com/alibaba/pouch/pkg/utils"
 	"github.com/alibaba/pouch/storage/quota"
 	volumetypes "github.com/alibaba/pouch/storage/volume/types"
 
 	"github.com/containerd/containerd/errdefs"
+	"github.com/containerd/containerd/mount"
 	"github.com/containerd/containerd/namespaces"
 	"github.com/docker/libnetwork"
 	"github.com/go-openapi/strfmt"
@@ -597,14 +599,24 @@ func (mgr *ContainerManager) createContainerdContainer(ctx context.Context, c *C
 
 	c.Lock()
 	ctrdContainer := &ctrd.Container{
-		ID:      c.ID,
-		Image:   c.Config.Image,
-		Runtime: c.HostConfig.Runtime,
-		Spec:    sw.s,
-		IO:      io,
+		ID:             c.ID,
+		Image:          c.Config.Image,
+		Runtime:        c.HostConfig.Runtime,
+		Spec:           sw.s,
+		IO:             io,
+		RootFSProvided: c.RootFSProvided,
+		BaseFS:         c.BaseFS,
 	}
 	c.Unlock()
 
+	// if creating the container by specified the rootfs, we must check
+	// whether the rootfs is mounted before creation
+	if c.RootFSProvided {
+		if err := mgr.ensureRootFSMounted(c.BaseFS, c.Snapshotter.Data); err != nil {
+			return fmt.Errorf("failed to mount container rootfs: %v", err)
+		}
+	}
+
 	if err := mgr.Client.CreateContainer(ctx, ctrdContainer); err != nil {
 		logrus.Errorf("failed to create new containerd container: %v", err)
 
@@ -631,6 +643,53 @@ func (mgr *ContainerManager) createContainerdContainer(ctx context.Context, c *C
 	return c.Write(mgr.Store)
 }
 
+func (mgr *ContainerManager) ensureRootFSMounted(rootfs string, snapData map[string]string) error {
+	if rootfs == "" || len(snapData) == 0 {
+		return fmt.Errorf("container rootfs or snapshotter data is empty")
+	}
+
+	// check if rootfs already mounted
+	notMounted, err := mountutils.IsLikelyNotMountPoint(rootfs)
+	if err != nil {
+		return err
+	}
+	// rootfs already mounted
+	if !notMounted {
+		return nil
+	}
+
+	var workDir, upperDir, lowerDir string
+	for _, dir := range []string{"WorkDir", "UpperDir", "LowerDir"} {
+		if v, ok := snapData[dir]; ok {
+			switch dir {
+			case "WorkDir":
+				workDir = v
+			case "UpperDir":
+				upperDir = v
+			case "LowerDir":
+				lowerDir = v
+			}
+		}
+	}
+
+	if workDir == "" || upperDir == "" || lowerDir == "" {
+		return fmt.Errorf("faile to mount overlay: one or more dirs in WorkDir, UpperDir and LowerDir are empty")
+	}
+
+	options := []string{
+		fmt.Sprintf("workdir=%s", snapData["WorkDir"]),
+		fmt.Sprintf("upperdir=%s", snapData["UpperDir"]),
+		fmt.Sprintf("lowerdir=%s", snapData["LowerDir"]),
+	}
+	mount := mount.Mount{
+		Type:    "overlay",
+		Source:  "overlay",
+		Options: options,
+	}
+
+	return mount.Mount(rootfs)
+}
+
 // Stop stops a running container.
 func (mgr *ContainerManager) Stop(ctx context.Context, name string, timeout int64) error {
 	c, err := mgr.container(name)
@@ -949,9 +1008,13 @@ func (mgr *ContainerManager) Remove(ctx context.Context, name string, options *t
 		logrus.Errorf("failed to detach volume: %v", err)
 	}
 
-	// remove snapshot
-	if err := mgr.Client.RemoveSnapshot(ctx, c.ID); err != nil {
-		logrus.Errorf("failed to remove snapshot of container %s: %v", c.ID, err)
+	// if creating the container by specify rootfs,
+	// there is no snapshot for this container.
+	if !c.RootFSProvided {
+		// remove snapshot
+		if err := mgr.Client.RemoveSnapshot(ctx, c.ID); err != nil {
+			logrus.Errorf("failed to remove snapshot of container %s: %v", c.ID, err)
+		}
 	}
 
 	// When removing a container, we have set up such rule for object removing sequences:
@@ -967,7 +1030,6 @@ func (mgr *ContainerManager) Remove(ctx context.Context, name string, options *t
 	if err := mgr.Store.Remove(c.Key()); err != nil {
 		logrus.Errorf("failed to remove container %s from meta store: %v", c.ID, err)
 	}
-
 	return nil
 }
 

daemon/mgr/container_types.go

@@ -180,6 +180,9 @@ type Container struct {
 
 	// Escape keys for detach
 	DetachKeys string
+
+	// RootFSProvided is a flag to point the container is created by specify rootfs
+	RootFSProvided bool
 }
 
 // Key returns container's id.

pkg/mount/mount.go

@@ -0,0 +1,31 @@
+package mount
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"syscall"
+)
+
+// IsLikelyNotMountPoint determines if a directory is not a mountpoint.
+// It is fast but not necessarily ALWAYS correct. If the path is in fact
+// a bind mount from one part of a mount to another it will not be detected.
+// mkdir /tmp/a /tmp/b; mount --bin /tmp/a /tmp/b; IsLikelyNotMountPoint("/tmp/b")
+// will return true. When in fact /tmp/b is a mount point. If this situation
+// if of interest to you, don't use this function...
+func IsLikelyNotMountPoint(file string) (bool, error) {
+	stat, err := os.Stat(file)
+	if err != nil {
+		return true, err
+	}
+	rootStat, err := os.Lstat(filepath.Dir(strings.TrimSuffix(file, "/")))
+	if err != nil {
+		return true, err
+	}
+	// If the directory has a different device as parent, then it is a mountpoint.
+	if stat.Sys().(*syscall.Stat_t).Dev != rootStat.Sys().(*syscall.Stat_t).Dev {
+		return false, nil
+	}
+
+	return true, nil
+}

pkg/mount/mount_test.go

@@ -0,0 +1,29 @@
+package mount
+
+import "testing"
+
+func TestIsLikelyNotMountPoint(t *testing.T) {
+	type args struct {
+		file string
+	}
+	tests := []struct {
+		name    string
+		args    args
+		want    bool
+		wantErr bool
+	}{
+	// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := IsLikelyNotMountPoint(tt.args.file)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("IsLikelyNotMountPoint() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if got != tt.want {
+				t.Errorf("IsLikelyNotMountPoint() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}