Add compose create

README.md

@@ -331,6 +331,7 @@ It does not necessarily mean that the corresponding features are missing in cont
     - [:whale: nerdctl compose up](#whale-nerdctl-compose-up)
     - [:whale: nerdctl compose logs](#whale-nerdctl-compose-logs)
     - [:whale: nerdctl compose build](#whale-nerdctl-compose-build)
+    - [:whale: nerdctl compose create](#whale-nerdctl-compose-create)
     - [:whale: nerdctl compose exec](#whale-nerdctl-compose-exec)
     - [:whale: nerdctl compose down](#whale-nerdctl-compose-down)
     - [:whale: nerdctl compose images](#whale-nerdctl-compose-images)
@@ -1445,6 +1446,20 @@ Flags:
 
 Unimplemented `docker-compose build` (V1) flags:  `--compress`, `--force-rm`, `--memory`, `--no-rm`, `--parallel`, `--pull`, `--quiet`
 
+### :whale: nerdctl compose create
+
+Creates containers for one or more services.
+
+Usage: `nerdctl compose create [OPTIONS] [SERVICE...]`
+
+Flags:
+
+- :whale: `--build`: Build images before starting containers
+- :whale: `--force-recreate`: Recreate containers even if their configuration and image haven't changed
+- :whale: `--no-build`: Don't build an image even if it's missing, conflict with `--build`
+- :whale: `--no-recreate`: Don't recreate containers if they exist, conflict with `--force-recreate`
+- :whale: `--pull`: Pull images before running. (support always|missing|never) (default "missing")
+
 ### :whale: nerdctl compose exec
 
 Execute a command on a running container of the service.
@@ -1687,7 +1702,7 @@ Registry:
 - `docker search`
 
 Compose:
-- `docker-compose create|events|scale`
+- `docker-compose events|scale`
 
 Others:
 - `docker system df`

cmd/nerdctl/compose.go

@@ -75,6 +75,7 @@ func newComposeCommand() *cobra.Command {
 		newComposePauseCommand(),
 		newComposeUnpauseCommand(),
 		newComposeTopCommand(),
+		newComposeCreateCommand(),
 	)
 
 	return composeCommand

cmd/nerdctl/compose_create.go

@@ -0,0 +1,93 @@
+/*
+   Copyright The containerd Authors.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+package main
+
+import (
+	"errors"
+
+	"github.com/containerd/nerdctl/pkg/composer"
+	"github.com/spf13/cobra"
+)
+
+func newComposeCreateCommand() *cobra.Command {
+	var composeCreateCommand = &cobra.Command{
+		Use:           "create [flags] [SERVICE...]",
+		Short:         "Creates containers for one or more services",
+		RunE:          composeCreateAction,
+		SilenceUsage:  true,
+		SilenceErrors: true,
+	}
+	composeCreateCommand.Flags().Bool("build", false, "Build images before starting containers.")
+	composeCreateCommand.Flags().Bool("no-build", false, "Don't build an image even if it's missing, conflict with --build.")
+	composeCreateCommand.Flags().Bool("force-recreate", false, "Recreate containers even if their configuration and image haven't changed.")
+	composeCreateCommand.Flags().Bool("no-recreate", false, "Don't recreate containers if they exist, conflict with --force-recreate.")
+	composeCreateCommand.Flags().String("pull", "missing", "Pull images before running. (support always|missing|never)")
+	return composeCreateCommand
+}
+
+func composeCreateAction(cmd *cobra.Command, args []string) error {
+	build, err := cmd.Flags().GetBool("build")
+	if err != nil {
+		return err
+	}
+	noBuild, err := cmd.Flags().GetBool("no-build")
+	if err != nil {
+		return err
+	}
+	if build && noBuild {
+		return errors.New("flag --build and --no-build cannot be specified together")
+	}
+	forceRecreate, err := cmd.Flags().GetBool("force-recreate")
+	if err != nil {
+		return err
+	}
+	noRecreate, err := cmd.Flags().GetBool("no-recreate")
+	if err != nil {
+		return nil
+	}
+	if forceRecreate && noRecreate {
+		return errors.New("flag --force-recreate and --no-recreate cannot be specified together")
+	}
+
+	client, ctx, cancel, err := newClient(cmd)
+	if err != nil {
+		return err
+	}
+	defer cancel()
+
+	c, err := getComposer(cmd, client)
+	if err != nil {
+		return err
+	}
+
+	opt := composer.CreateOptions{
+		Build:         build,
+		NoBuild:       noBuild,
+		ForceRecreate: forceRecreate,
+		NoRecreate:    noRecreate,
+	}
+
+	if cmd.Flags().Changed("pull") {
+		pull, err := cmd.Flags().GetString("pull")
+		if err != nil {
+			return err
+		}
+		opt.Pull = &pull
+	}
+
+	return c.Create(ctx, opt, args)
+}

cmd/nerdctl/compose_create_linux_test.go

@@ -0,0 +1,152 @@
+/*
+   Copyright The containerd Authors.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+package main
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/containerd/nerdctl/pkg/testutil"
+)
+
+func TestComposeCreate(t *testing.T) {
+	// docker-compose v1 depecreated this command
+	// docker-compose v2 reimplemented this command
+	testutil.DockerIncompatible(t)
+
+	base := testutil.NewBase(t)
+	var dockerComposeYAML = fmt.Sprintf(`
+version: '3.1'
+
+services:
+  svc0:
+    image: %s
+`, testutil.AlpineImage)
+
+	comp := testutil.NewComposeDir(t, dockerComposeYAML)
+	defer comp.CleanUp()
+	projectName := comp.ProjectName()
+	t.Logf("projectName=%q", projectName)
+
+	defer base.ComposeCmd("-f", comp.YAMLFullPath(), "down", "-v").AssertOK()
+
+	// 1.1 `compose create` should create service container (in `created` status)
+	base.ComposeCmd("-f", comp.YAMLFullPath(), "create").AssertOK()
+	base.ComposeCmd("-f", comp.YAMLFullPath(), "ps", "svc0").AssertOutContainsAny("Created", "created")
+	// 1.2 created container can be started by `compose start`
+	base.ComposeCmd("-f", comp.YAMLFullPath(), "start").AssertOK()
+}
+
+func TestComposeCreateDependency(t *testing.T) {
+	// docker-compose v1 depecreated this command
+	// docker-compose v2 reimplemented this command
+	testutil.DockerIncompatible(t)
+
+	base := testutil.NewBase(t)
+	var dockerComposeYAML = fmt.Sprintf(`
+version: '3.1'
+
+services:
+  svc0:
+    image: %s
+    depends_on:
+    - "svc1"
+  svc1:
+    image: %s
+`, testutil.CommonImage, testutil.CommonImage)
+
+	comp := testutil.NewComposeDir(t, dockerComposeYAML)
+	defer comp.CleanUp()
+	projectName := comp.ProjectName()
+	t.Logf("projectName=%q", projectName)
+
+	defer base.ComposeCmd("-f", comp.YAMLFullPath(), "down", "-v").AssertOK()
+
+	// `compose create` should create containers for both services and their dependencies
+	base.ComposeCmd("-f", comp.YAMLFullPath(), "create", "svc0").AssertOK()
+	base.ComposeCmd("-f", comp.YAMLFullPath(), "ps", "svc0").AssertOutContainsAny("Created", "created")
+	base.ComposeCmd("-f", comp.YAMLFullPath(), "ps", "svc1").AssertOutContainsAny("Created", "created")
+}
+
+func TestComposeCreatePull(t *testing.T) {
+	// docker-compose v1 depecreated this command
+	// docker-compose v2 reimplemented this command
+	testutil.DockerIncompatible(t)
+
+	base := testutil.NewBase(t)
+	var dockerComposeYAML = fmt.Sprintf(`
+version: '3.1'
+
+services:
+  svc0:
+    image: %s
+`, testutil.AlpineImage)
+
+	comp := testutil.NewComposeDir(t, dockerComposeYAML)
+	defer comp.CleanUp()
+	projectName := comp.ProjectName()
+	t.Logf("projectName=%q", projectName)
+
+	defer base.ComposeCmd("-f", comp.YAMLFullPath(), "down", "-v").AssertOK()
+
+	// `compose create --pull never` should fail: no such image
+	base.Cmd("rmi", "-f", testutil.AlpineImage).Run()
+	base.ComposeCmd("-f", comp.YAMLFullPath(), "create", "--pull", "never").AssertFail()
+	// `compose create --pull missing(default)|always` should succeed: image is pulled and container is created
+	base.Cmd("rmi", "-f", testutil.AlpineImage).Run()
+	base.ComposeCmd("-f", comp.YAMLFullPath(), "create").AssertOK()
+	base.Cmd("rmi", "-f", testutil.AlpineImage).Run()
+	base.ComposeCmd("-f", comp.YAMLFullPath(), "create", "--pull", "always").AssertOK()
+	base.ComposeCmd("-f", comp.YAMLFullPath(), "ps", "svc0").AssertOutContainsAny("Created", "created")
+}
+
+func TestComposeCreateBuild(t *testing.T) {
+	// docker-compose v1 depecreated this command
+	// docker-compose v2 reimplemented this command
+	testutil.DockerIncompatible(t)
+
+	const imageSvc0 = "composebuild_svc0"
+
+	dockerComposeYAML := fmt.Sprintf(`
+services:
+  svc0:
+    build: .
+    image: %s
+`, imageSvc0)
+
+	dockerfile := fmt.Sprintf(`FROM %s`, testutil.AlpineImage)
+
+	testutil.RequiresBuild(t)
+	base := testutil.NewBase(t)
+	defer base.Cmd("builder", "prune").Run()
+
+	comp := testutil.NewComposeDir(t, dockerComposeYAML)
+	defer comp.CleanUp()
+	comp.WriteFile("Dockerfile", dockerfile)
+	projectName := comp.ProjectName()
+	t.Logf("projectName=%q", projectName)
+
+	defer base.Cmd("rmi", imageSvc0).Run()
+	defer base.ComposeCmd("-f", comp.YAMLFullPath(), "down", "-v").AssertOK()
+
+	// `compose create --no-build` should fail if service image needs build
+	base.ComposeCmd("-f", comp.YAMLFullPath(), "create", "--no-build").AssertFail()
+	// `compose create --build` should succeed: image is built and container is created
+	base.ComposeCmd("-f", comp.YAMLFullPath(), "create", "--build").AssertOK()
+	base.ComposeCmd("-f", comp.YAMLFullPath(), "images", "svc0").AssertOutContains(imageSvc0)
+	base.ComposeCmd("-f", comp.YAMLFullPath(), "ps", "svc0").AssertOutContainsAny("Created", "created")
+}

cmd/nerdctl/compose_start.go

@@ -22,6 +22,7 @@ import (
 	"os"
 
 	"github.com/containerd/containerd"
+	"github.com/containerd/containerd/errdefs"
 	"github.com/containerd/nerdctl/pkg/containerutil"
 	"github.com/containerd/nerdctl/pkg/labels"
 	"github.com/spf13/cobra"
@@ -86,7 +87,13 @@ func startContainers(ctx context.Context, client *containerd.Client, containers
 		c := c
 		eg.Go(func() error {
 			if cStatus, err := containerutil.ContainerStatus(ctx, c); err != nil {
-				return err
+				// NOTE: NotFound doesn't mean that container hasn't started.
+				// In docker/CRI-containerd plugin, the task will be deleted
+				// when it exits. So, the status will be "created" for this
+				// case.
+				if !errdefs.IsNotFound(err) {
+					return err
+				}
 			} else if cStatus.Status == containerd.Running {
 				return nil
 			}