chore(orchestrator): startup and remove containers based on dependencies

internal/pkg/cli/interfaces.go

@@ -706,12 +706,13 @@ type templateDiffer interface {
 type dockerEngineRunner interface {
 	CheckDockerEngineRunning() error
 	Run(context.Context, *dockerengine.RunOptions) error
-	DoesContainerExist(context.Context, string) (bool, error)
 	IsContainerRunning(context.Context, string) (bool, error)
 	Stop(context.Context, string) error
-	Rm(string) error
 	Build(context.Context, *dockerengine.BuildArguments, io.Writer) error
 	Exec(ctx context.Context, container string, out io.Writer, cmd string, args ...string) error
+	IsContainerCompleteOrSuccess(ctx context.Context, containerName string) (int, error)
+	IsContainerHealthy(ctx context.Context, containerName string) (bool, error)
+	Rm(context.Context, string) error
 }
 
 type workloadStackGenerator interface {

internal/pkg/cli/run_local.go

@@ -537,8 +537,6 @@ func (o *runLocalOpts) prepareTask(ctx context.Context) (orchestrator.Task, erro
 		task.Containers[name] = ctr
 	}
 
-	// TODO (Adi): Use this dependency order in orchestrator to start and stop containers.
-	// replace container dependencies with the local dependencies from manifest.
 	containerDeps := manifest.ContainerDependencies(mft.Manifest())
 	for name, dep := range containerDeps {
 		ctr, ok := task.Containers[name]

internal/pkg/docker/dockerengine/dockerengine.go

@@ -9,6 +9,7 @@ import (
 	"bytes"
 	"context"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"io"
 	"os"
@@ -263,7 +264,6 @@ func (c DockerCmdClient) Push(ctx context.Context, uri string, w io.Writer, tags
 
 func (in *RunOptions) generateRunArguments() []string {
 	args := []string{"run"}
-	args = append(args, "--rm")
 
 	if in.ContainerName != "" {
 		args = append(args, "--name", in.ContainerName)
@@ -303,6 +303,9 @@ func (in *RunOptions) generateRunArguments() []string {
 
 // Run runs a Docker container with the sepcified options.
 func (c DockerCmdClient) Run(ctx context.Context, options *RunOptions) error {
+	type exitCodeError interface {
+		ExitCode() int
+	}
 	// set default options
 	if options.LogOptions.Color == nil {
 		options.LogOptions.Color = color.New()
@@ -343,6 +346,13 @@ func (c DockerCmdClient) Run(ctx context.Context, options *RunOptions) error {
 			exec.Stdout(stdout),
 			exec.Stderr(stderr),
 			exec.NewProcessGroup()); err != nil {
+			var ec exitCodeError
+			if errors.As(err, &ec) {
+				return &ErrContainerExited{
+					name:     options.ContainerName,
+					exitcode: ec.ExitCode(),
+				}
+			}
 			return fmt.Errorf("running container: %w", err)
 		}
 		return nil
@@ -351,15 +361,6 @@ func (c DockerCmdClient) Run(ctx context.Context, options *RunOptions) error {
 	return g.Wait()
 }
 
-// DoesContainerExist checks if a specific Docker container exists.
-func (c DockerCmdClient) DoesContainerExist(ctx context.Context, name string) (bool, error) {
-	output, err := c.containerID(ctx, name)
-	if err != nil {
-		return false, err
-	}
-	return output != "", nil
-}
-
 // IsContainerRunning checks if a specific Docker container is running.
 func (c DockerCmdClient) IsContainerRunning(ctx context.Context, name string) (bool, error) {
 	state, err := c.containerState(ctx, name)
@@ -459,6 +460,11 @@ type ErrContainerExited struct {
 	exitcode int
 }
 
+// ExitCode returns the OS exit code configured for this error.
+func (e *ErrContainerExited) ExitCode() int {
+	return e.exitcode
+}
+
 // ErrContainerExited represents docker container exited with an exitcode.
 func (e *ErrContainerExited) Error() string {
 	return fmt.Sprintf("container %q exited with code %d", e.name, e.exitcode)
@@ -474,9 +480,9 @@ func (c DockerCmdClient) Stop(ctx context.Context, containerID string) error {
 }
 
 // Rm calls `docker rm` to remove a stopped container.
-func (c DockerCmdClient) Rm(containerID string) error {
+func (c DockerCmdClient) Rm(ctx context.Context, containerID string) error {
 	buf := &bytes.Buffer{}
-	if err := c.runner.Run("docker", []string{"rm", containerID}, exec.Stdout(buf), exec.Stderr(buf)); err != nil {
+	if err := c.runner.RunWithContext(ctx, "docker", []string{"rm", containerID}, exec.Stdout(buf), exec.Stderr(buf)); err != nil {
 		return fmt.Errorf("%s: %w", strings.TrimSpace(buf.String()), err)
 	}
 	return nil

internal/pkg/docker/dockerengine/dockerengine_test.go

@@ -9,6 +9,7 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"os"
 	osexec "os/exec"
 	"path/filepath"
 	"strings"
@@ -680,13 +681,35 @@ func TestDockerCommand_Run(t *testing.T) {
 			setupMocks: func(controller *gomock.Controller) {
 				mockCmd = NewMockCmd(controller)
 				mockCmd.EXPECT().RunWithContext(gomock.Any(), "docker", []string{"run",
-					"--rm",
 					"--name", mockPauseContainer,
 					"mockImageUri",
 					"sleep", "infinity"}, gomock.Any(), gomock.Any(), gomock.Any()).Return(mockError)
 			},
 			wantedError: fmt.Errorf("running container: %w", mockError),
 		},
+
+		"should return error when container exits": {
+			containerName: mockPauseContainer,
+			command:       mockCommand,
+			uri:           mockImageURI,
+			setupMocks: func(controller *gomock.Controller) {
+				mockCmd = NewMockCmd(controller)
+
+				mockCmd.EXPECT().RunWithContext(gomock.Any(), "docker", []string{"run",
+					"--name", mockPauseContainer,
+					"mockImageUri",
+					"sleep", "infinity"}, gomock.Any(), gomock.Any(), gomock.Any()).
+					DoAndReturn(func(ctx context.Context, name string, args []string, opts ...exec.CmdOption) error {
+						// Simulate an zero exit code.
+						return &osexec.ExitError{ProcessState: &os.ProcessState{}}
+					})
+			},
+			wantedError: &ErrContainerExited{
+				name:     mockPauseContainer,
+				exitcode: 0,
+			},
+		},
+
 		"success with run options for pause container": {
 			containerName: mockPauseContainer,
 			ports:         mockContainerPorts,
@@ -695,7 +718,6 @@ func TestDockerCommand_Run(t *testing.T) {
 			setupMocks: func(controller *gomock.Controller) {
 				mockCmd = NewMockCmd(controller)
 				mockCmd.EXPECT().RunWithContext(gomock.Any(), "docker", gomock.InAnyOrder([]string{"run",
-					"--rm",
 					"--name", mockPauseContainer,
 					"--publish", "8080:8080",
 					"--publish", "8081:8081",
@@ -712,7 +734,6 @@ func TestDockerCommand_Run(t *testing.T) {
 			setupMocks: func(controller *gomock.Controller) {
 				mockCmd = NewMockCmd(controller)
 				mockCmd.EXPECT().RunWithContext(gomock.Any(), "docker", gomock.InAnyOrder([]string{"run",
-					"--rm",
 					"--name", mockContainerName,
 					"--network", "container:pauseContainer",
 					"--env", "DB_PASSWORD=mysecretPassword",
@@ -733,7 +754,6 @@ func TestDockerCommand_Run(t *testing.T) {
 			setupMocks: func(controller *gomock.Controller) {
 				mockCmd = NewMockCmd(controller)
 				mockCmd.EXPECT().RunWithContext(gomock.Any(), "docker", gomock.InAnyOrder([]string{"run",
-					"--rm",
 					"--name", mockContainerName,
 					"--network", "container:pauseContainer",
 					"--env", "DB_PASSWORD=mysecretPassword",

internal/pkg/docker/dockerengine/dockerenginetest/dockerenginetest.go

@@ -12,12 +12,14 @@ import (
 
 // Double is a test double for dockerengine.DockerCmdClient
 type Double struct {
-	StopFn               func(context.Context, string) error
-	DoesContainerExistFn func(context.Context, string) (bool, error)
-	IsContainerRunningFn func(context.Context, string) (bool, error)
-	RunFn                func(context.Context, *dockerengine.RunOptions) error
-	BuildFn              func(context.Context, *dockerengine.BuildArguments, io.Writer) error
-	ExecFn               func(context.Context, string, io.Writer, string, ...string) error
+	StopFn                         func(context.Context, string) error
+	IsContainerRunningFn           func(context.Context, string) (bool, error)
+	RunFn                          func(context.Context, *dockerengine.RunOptions) error
+	BuildFn                        func(context.Context, *dockerengine.BuildArguments, io.Writer) error
+	ExecFn                         func(context.Context, string, io.Writer, string, ...string) error
+	IsContainerHealthyFn           func(ctx context.Context, containerName string) (bool, error)
+	IsContainerCompleteOrSuccessFn func(ctx context.Context, containerName string) (int, error)
+	RmFn                           func(context.Context, string) error
 }
 
 // Stop calls the stubbed function.
@@ -28,14 +30,6 @@ func (d *Double) Stop(ctx context.Context, name string) error {
 	return d.StopFn(ctx, name)
 }
 
-// DoesContainerExist calls the stubbed function.
-func (d *Double) DoesContainerExist(ctx context.Context, name string) (bool, error) {
-	if d.IsContainerRunningFn == nil {
-		return false, nil
-	}
-	return d.DoesContainerExistFn(ctx, name)
-}
-
 // IsContainerRunning calls the stubbed function.
 func (d *Double) IsContainerRunning(ctx context.Context, name string) (bool, error) {
 	if d.IsContainerRunningFn == nil {
@@ -67,3 +61,27 @@ func (d *Double) Exec(ctx context.Context, container string, out io.Writer, cmd
 	}
 	return d.ExecFn(ctx, container, out, cmd, args...)
 }
+
+// Rm calls the stubbed function.
+func (d *Double) Rm(ctx context.Context, name string) error {
+	if d.RmFn == nil {
+		return nil
+	}
+	return d.RmFn(ctx, name)
+}
+
+// IsContainerCompleteOrSuccess implements orchestrator.DockerEngine.
+func (d *Double) IsContainerCompleteOrSuccess(ctx context.Context, containerName string) (int, error) {
+	if d.IsContainerCompleteOrSuccessFn == nil {
+		return -1, nil
+	}
+	return d.IsContainerCompleteOrSuccessFn(ctx, containerName)
+}
+
+// IsContainerHealthy implements orchestrator.DockerEngine.
+func (d *Double) IsContainerHealthy(ctx context.Context, containerName string) (bool, error) {
+	if d.IsContainerHealthyFn == nil {
+		return false, nil
+	}
+	return d.IsContainerHealthyFn(ctx, containerName)
+}