Capture container exit code and dump on console

ndeloof · ndeloof · commit 7a7114fb5f35 · 2021-02-09T17:07:24.000+01:00
Signed-off-by: Nicolas De Loof &lt;nicolas.deloof@gmail.com&gt;
diff --git a/aci/compose.go b/aci/compose.go
@@ -60,7 +60,7 @@ func (cs *aciComposeService) Create(ctx context.Context, project *types.Project,
 	return errdefs.ErrNotImplemented
 }
 
-func (cs *aciComposeService) Start(ctx context.Context, project *types.Project, consumer compose.LogConsumer) error {
+func (cs *aciComposeService) Start(ctx context.Context, project *types.Project, options compose.StartOptions) error {
 	return errdefs.ErrNotImplemented
 }
 
diff --git a/api/client/compose.go b/api/client/compose.go
@@ -44,7 +44,7 @@ func (c *composeService) Create(ctx context.Context, project *types.Project, opt
 	return errdefs.ErrNotImplemented
 }
 
-func (c *composeService) Start(ctx context.Context, project *types.Project, consumer compose.LogConsumer) error {
+func (c *composeService) Start(ctx context.Context, project *types.Project, options compose.StartOptions) error {
 	return errdefs.ErrNotImplemented
 }
 
diff --git a/api/compose/api.go b/api/compose/api.go
@@ -34,7 +34,7 @@ type Service interface {
 	// Create executes the equivalent to a `compose create`
 	Create(ctx context.Context, project *types.Project, opts CreateOptions) error
 	// Start executes the equivalent to a `compose start`
-	Start(ctx context.Context, project *types.Project, consumer LogConsumer) error
+	Start(ctx context.Context, project *types.Project, options StartOptions) error
 	// Stop executes the equivalent to a `compose stop`
 	Stop(ctx context.Context, project *types.Project) error
 	// Up executes the equivalent to a `compose up`
@@ -63,6 +63,14 @@ type CreateOptions struct {
 	Recreate string
 }
 
+// StartOptions group options of the Start API
+type StartOptions struct {
+	// Attach will attach to container and pipe stdout/stderr to LogConsumer
+	Attach LogConsumer
+	// CascadeStop will run `Stop` on any container exit
+	CascadeStop bool
+}
+
 // UpOptions group options of the Up API
 type UpOptions struct {
 	// Detach will create services and return immediately
@@ -177,4 +185,5 @@ type Stack struct {
 // LogConsumer is a callback to process log messages from services
 type LogConsumer interface {
 	Log(service, container, message string)
+	Exit(service, container string, exitCode int)
 }
diff --git a/cli/cmd/compose/run.go b/cli/cmd/compose/run.go
@@ -102,7 +102,7 @@ func startDependencies(ctx context.Context, c *client.Client, project *types.Pro
 	if err := c.ComposeService().Create(ctx, project, compose.CreateOptions{}); err != nil {
 		return err
 	}
-	if err := c.ComposeService().Start(ctx, project, nil); err != nil {
+	if err := c.ComposeService().Start(ctx, project, compose.StartOptions{}); err != nil {
 		return err
 	}
 	return nil
diff --git a/cli/cmd/compose/start.go b/cli/cmd/compose/start.go
@@ -18,6 +18,7 @@ package compose
 
 import (
 	"context"
+	"github.com/docker/compose-cli/api/compose"
 	"os"
 
 	"github.com/spf13/cobra"
@@ -61,10 +62,12 @@ func runStart(ctx context.Context, opts startOptions, services []string) error {
 
 	if opts.Detach {
 		_, err = progress.Run(ctx, func(ctx context.Context) (string, error) {
-			return "", c.ComposeService().Start(ctx, project, nil)
+			return "", c.ComposeService().Start(ctx, project, compose.StartOptions{})
 		})
 		return err
 	}
 
-	return c.ComposeService().Start(ctx, project, formatter.NewLogConsumer(ctx, os.Stdout))
+	return c.ComposeService().Start(ctx, project, compose.StartOptions{
+		Attach: formatter.NewLogConsumer(ctx, os.Stdout),
+	})
 }
diff --git a/cli/cmd/compose/up.go b/cli/cmd/compose/up.go
@@ -129,7 +129,7 @@ func runCreateStart(ctx context.Context, opts upOptions, services []string) erro
 			return "", err
 		}
 		if opts.Detach {
-			err = c.ComposeService().Start(ctx, project, nil)
+			err = c.ComposeService().Start(ctx, project, compose.StartOptions{})
 		}
 		return "", err
 	})
@@ -145,7 +145,9 @@ func runCreateStart(ctx context.Context, opts upOptions, services []string) erro
 		return nil
 	}
 
-	err = c.ComposeService().Start(ctx, project, formatter.NewLogConsumer(ctx, os.Stdout))
+	err = c.ComposeService().Start(ctx, project, compose.StartOptions{
+		Attach: formatter.NewLogConsumer(ctx, os.Stdout),
+	})
 	if errors.Is(ctx.Err(), context.Canceled) {
 		fmt.Println("Gracefully stopping...")
 		ctx = context.Background()
diff --git a/cli/formatter/logs.go b/cli/formatter/logs.go
@@ -42,12 +42,7 @@ func (l *logConsumer) Log(service, container, message string) {
 	if l.ctx.Err() != nil {
 		return
 	}
-	cf, ok := l.colors[service]
-	if !ok {
-		cf = <-loop
-		l.colors[service] = cf
-		l.computeWidth()
-	}
+	cf := l.getColorFunc(service)
 	prefix := fmt.Sprintf("%-"+strconv.Itoa(l.width)+"s |", container)
 
 	for _, line := range strings.Split(message, "\n") {
@@ -56,6 +51,21 @@ func (l *logConsumer) Log(service, container, message string) {
 	}
 }
 
+func (l *logConsumer) Exit(service, container string, exitCode int) {
+	msg := fmt.Sprintf("%s exited with code %d\n", container, exitCode)
+	l.writer.Write([]byte(l.getColorFunc(service)(msg)))
+}
+
+func (l *logConsumer) getColorFunc(service string) colorFunc {
+	cf, ok := l.colors[service]
+	if !ok {
+		cf = <-loop
+		l.colors[service] = cf
+		l.computeWidth()
+	}
+	return cf
+}
+
 func (l *logConsumer) computeWidth() {
 	width := 0
 	for n := range l.colors {
diff --git a/ecs/local/compose.go b/ecs/local/compose.go
@@ -53,8 +53,8 @@ func (e ecsLocalSimulation) Create(ctx context.Context, project *types.Project,
 	return e.compose.Create(ctx, enhanced, opts)
 }
 
-func (e ecsLocalSimulation) Start(ctx context.Context, project *types.Project, consumer compose.LogConsumer) error {
-	return e.compose.Start(ctx, project, consumer)
+func (e ecsLocalSimulation) Start(ctx context.Context, project *types.Project, options compose.StartOptions) error {
+	return e.compose.Start(ctx, project, options)
 }
 
 func (e ecsLocalSimulation) Stop(ctx context.Context, project *types.Project) error {
diff --git a/ecs/logs.go b/ecs/logs.go
@@ -54,3 +54,9 @@ func (a *allowListLogConsumer) Log(service, container, message string) {
 		a.delegate.Log(service, container, message)
 	}
 }
+
+func (a *allowListLogConsumer) Exit(service, container string, exitCode int) {
+	if a.allowList[service] {
+		a.delegate.Exit(service, container, exitCode)
+	}
+}
diff --git a/ecs/up.go b/ecs/up.go
@@ -47,7 +47,7 @@ func (b *ecsAPIService) Create(ctx context.Context, project *types.Project, opts
 	return errdefs.ErrNotImplemented
 }
 
-func (b *ecsAPIService) Start(ctx context.Context, project *types.Project, consumer compose.LogConsumer) error {
+func (b *ecsAPIService) Start(ctx context.Context, project *types.Project, options compose.StartOptions) error {
 	return errdefs.ErrNotImplemented
 }
 
diff --git a/kube/compose.go b/kube/compose.go
@@ -144,7 +144,7 @@ func (s *composeService) Create(ctx context.Context, project *types.Project, opt
 }
 
 // Start executes the equivalent to a `compose start`
-func (s *composeService) Start(ctx context.Context, project *types.Project, consumer compose.LogConsumer) error {
+func (s *composeService) Start(ctx context.Context, project *types.Project, options compose.StartOptions) error {
 	return errdefs.ErrNotImplemented
 }
 
diff --git a/local/compose/attach.go b/local/compose/attach.go
@@ -28,42 +28,30 @@ import (
 
 	"github.com/compose-spec/compose-go/types"
 	moby "github.com/docker/docker/api/types"
-	"github.com/docker/docker/api/types/filters"
 	"github.com/docker/docker/pkg/stdcopy"
-	"golang.org/x/sync/errgroup"
 )
 
-func (s *composeService) attach(ctx context.Context, project *types.Project, consumer compose.LogConsumer) (*errgroup.Group, error) {
-	containers, err := s.apiClient.ContainerList(ctx, moby.ContainerListOptions{
-		Filters: filters.NewArgs(
-			projectFilter(project.Name),
-		),
-		All: true,
-	})
+func (s *composeService) attach(ctx context.Context, project *types.Project, consumer compose.LogConsumer) (Containers, error) {
+	containers, err := s.getContainers(ctx, project)
 	if err != nil {
 		return nil, err
 	}
-	containers = Containers(containers).filter(isService(project.ServiceNames()...))
 
 	var names []string
 	for _, c := range containers {
 		names = append(names, getCanonicalContainerName(c))
 	}
 	fmt.Printf("Attaching to %s\n", strings.Join(names, ", "))
 
-	eg, ctx := errgroup.WithContext(ctx)
-	for _, c := range containers {
-		container := c
-		eg.Go(func() error {
-			return s.attachContainer(ctx, container, consumer, project)
-		})
+	for _, container := range containers {
+		s.attachContainer(ctx, container, consumer, project)
 	}
-	return eg, nil
+	return containers, nil
 }
 
 func (s *composeService) attachContainer(ctx context.Context, container moby.Container, consumer compose.LogConsumer, project *types.Project) error {
 	serviceName := container.Labels[serviceLabel]
-	w := utils.GetWriter(serviceName, getCanonicalContainerName(container), consumer)
+	w := getWriter(serviceName, getContainerNameWithoutProject(container), consumer)
 
 	service, err := project.GetService(serviceName)
 	if err != nil {
@@ -94,13 +82,15 @@ func (s *composeService) attachContainerStreams(ctx context.Context, container m
 	}
 
 	if w != nil {
-		if tty {
-			_, err = io.Copy(w, stdout)
-		} else {
-			_, err = stdcopy.StdCopy(w, w, stdout)
-		}
+		go func() {
+			if tty {
+				io.Copy(w, stdout) // nolint:errcheck
+			} else {
+				stdcopy.StdCopy(w, w, stdout) // nolint:errcheck
+			}
+		}()
 	}
-	return err
+	return nil
 }
 
 func (s *composeService) getContainerStreams(ctx context.Context, container moby.Container) (io.WriteCloser, io.ReadCloser, error) {
diff --git a/local/compose/compose.go b/local/compose/compose.go
@@ -55,6 +55,16 @@ func getCanonicalContainerName(c moby.Container) string {
 	return c.Names[0][1:]
 }
 
+func getContainerNameWithoutProject(c moby.Container) string {
+	name := getCanonicalContainerName(c)
+	project := c.Labels[projectLabel]
+	prefix := fmt.Sprintf("%s_%s_", project, c.Labels[serviceLabel])
+	if strings.HasPrefix(name, prefix) {
+		return name[len(project)+1:]
+	}
+	return name
+}
+
 func (s *composeService) Convert(ctx context.Context, project *types.Project, options compose.ConvertOptions) ([]byte, error) {
 	switch options.Format {
 	case "json":
diff --git a/local/compose/containers.go b/local/compose/containers.go
@@ -16,11 +16,31 @@
 
 package compose
 
-import moby "github.com/docker/docker/api/types"
+import (
+	"context"
+	"github.com/compose-spec/compose-go/types"
+	moby "github.com/docker/docker/api/types"
+	"github.com/docker/docker/api/types/filters"
+)
 
 // Containers is a set of moby Container
 type Containers []moby.Container
 
+func (s *composeService) getContainers(ctx context.Context, project *types.Project) (Containers, error) {
+	var containers Containers
+	containers, err := s.apiClient.ContainerList(ctx, moby.ContainerListOptions{
+		Filters: filters.NewArgs(
+			projectFilter(project.Name),
+		),
+		All: true,
+	})
+	if err != nil {
+		return nil, err
+	}
+	containers = containers.filter(isService(project.ServiceNames()...))
+	return containers, nil
+}
+
 // containerPredicate define a predicate we want container to satisfy for filtering operations
 type containerPredicate func(c moby.Container) bool
 
diff --git a/local/compose/start.go b/local/compose/start.go
@@ -18,21 +18,28 @@ package compose
 
 import (
 	"context"
+	"github.com/docker/docker/api/types/container"
 
 	"github.com/docker/compose-cli/api/compose"
 
 	"github.com/compose-spec/compose-go/types"
 	"golang.org/x/sync/errgroup"
 )
 
-func (s *composeService) Start(ctx context.Context, project *types.Project, consumer compose.LogConsumer) error {
-	var group *errgroup.Group
-	if consumer != nil {
-		eg, err := s.attach(ctx, project, consumer)
+func (s *composeService) Start(ctx context.Context, project *types.Project, options compose.StartOptions) error {
+	var containers Containers
+	if options.Attach != nil {
+		c, err := s.attach(ctx, project, options.Attach)
 		if err != nil {
 			return err
 		}
-		group = eg
+		containers = c
+	} else {
+		c, err := s.getContainers(ctx, project)
+		if err != nil {
+			return err
+		}
+		containers = c
 	}
 
 	err := InDependencyOrder(ctx, project, func(c context.Context, service types.ServiceConfig) error {
@@ -41,8 +48,24 @@ func (s *composeService) Start(ctx context.Context, project *types.Project, cons
 	if err != nil {
 		return err
 	}
-	if group != nil {
-		return group.Wait()
+
+	if options.Attach == nil {
+		return nil
+	}
+
+	eg, ctx := errgroup.WithContext(ctx)
+	for _, c := range containers {
+		c := c
+		eg.Go(func() error {
+			statusC, errC := s.apiClient.ContainerWait(ctx, c.ID, container.WaitConditionNotRunning)
+			select {
+			case status := <-statusC:
+				options.Attach.Exit(c.Labels[serviceLabel], getContainerNameWithoutProject(c), int(status.StatusCode))
+				return nil
+			case err := <-errC:
+				return err
+			}
+		})
 	}
-	return nil
+	return eg.Wait()
 }

Original file line number	Diff line number	Diff line change
`@@ -60,7 +60,7 @@ func (cs aciComposeService) Create(ctx context.Context, project types.Project,`
`60`	`60`	`return errdefs.ErrNotImplemented`
`61`	`61`	`}`
`62`	`62`
`63`		`-func (cs aciComposeService) Start(ctx context.Context, project types.Project, consumer compose.LogConsumer) error {`
	`63`	`+func (cs aciComposeService) Start(ctx context.Context, project types.Project, options compose.StartOptions) error {`
`64`	`64`	`return errdefs.ErrNotImplemented`
`65`	`65`	`}`
`66`	`66`
Original file line number	Diff line number	Diff line change
`@@ -44,7 +44,7 @@ func (c composeService) Create(ctx context.Context, project types.Project, opt`
`44`	`44`	`return errdefs.ErrNotImplemented`
`45`	`45`	`}`
`46`	`46`
`47`		`-func (c composeService) Start(ctx context.Context, project types.Project, consumer compose.LogConsumer) error {`
	`47`	`+func (c composeService) Start(ctx context.Context, project types.Project, options compose.StartOptions) error {`
`48`	`48`	`return errdefs.ErrNotImplemented`
`49`	`49`	`}`
`50`	`50`
Original file line number	Diff line number	Diff line change
`@@ -102,7 +102,7 @@ func startDependencies(ctx context.Context, c client.Client, project types.Pro`
`102`	`102`	`if err := c.ComposeService().Create(ctx, project, compose.CreateOptions{}); err != nil {`
`103`	`103`	`return err`
`104`	`104`	`}`
`105`		`- if err := c.ComposeService().Start(ctx, project, nil); err != nil {`
	`105`	`+ if err := c.ComposeService().Start(ctx, project, compose.StartOptions{}); err != nil {`
`106`	`106`	`return err`
`107`	`107`	`}`
`108`	`108`	`return nil`
Original file line number	Diff line number	Diff line change
`@@ -129,7 +129,7 @@ func runCreateStart(ctx context.Context, opts upOptions, services []string) erro`
`129`	`129`	`return "", err`
`130`	`130`	`}`
`131`	`131`	`if opts.Detach {`
`132`		`- err = c.ComposeService().Start(ctx, project, nil)`
	`132`	`+ err = c.ComposeService().Start(ctx, project, compose.StartOptions{})`
`133`	`133`	`}`
`134`	`134`	`return "", err`
`135`	`135`	`})`
`@@ -145,7 +145,9 @@ func runCreateStart(ctx context.Context, opts upOptions, services []string) erro`
`145`	`145`	`return nil`
`146`	`146`	`}`
`147`	`147`
`148`		`- err = c.ComposeService().Start(ctx, project, formatter.NewLogConsumer(ctx, os.Stdout))`
	`148`	`+ err = c.ComposeService().Start(ctx, project, compose.StartOptions{`
	`149`	`+ Attach: formatter.NewLogConsumer(ctx, os.Stdout),`
	`150`	`+ })`
`149`	`151`	`if errors.Is(ctx.Err(), context.Canceled) {`
`150`	`152`	`fmt.Println("Gracefully stopping...")`
`151`	`153`	`ctx = context.Background()`
Original file line number	Diff line number	Diff line change
`@@ -53,8 +53,8 @@ func (e ecsLocalSimulation) Create(ctx context.Context, project *types.Project,`
`53`	`53`	`return e.compose.Create(ctx, enhanced, opts)`
`54`	`54`	`}`
`55`	`55`
`56`		`-func (e ecsLocalSimulation) Start(ctx context.Context, project *types.Project, consumer compose.LogConsumer) error {`
`57`		`- return e.compose.Start(ctx, project, consumer)`
	`56`	`+func (e ecsLocalSimulation) Start(ctx context.Context, project *types.Project, options compose.StartOptions) error {`
	`57`	`+ return e.compose.Start(ctx, project, options)`
`58`	`58`	`}`
`59`	`59`
`60`	`60`	`func (e ecsLocalSimulation) Stop(ctx context.Context, project *types.Project) error {`
Original file line number	Diff line number	Diff line change
`@@ -54,3 +54,9 @@ func (a *allowListLogConsumer) Log(service, container, message string) {`
`54`	`54`	`a.delegate.Log(service, container, message)`
`55`	`55`	`}`
`56`	`56`	`}`
	`57`	`+`
	`58`	`+func (a *allowListLogConsumer) Exit(service, container string, exitCode int) {`
	`59`	`+ if a.allowList[service] {`
	`60`	`+ a.delegate.Exit(service, container, exitCode)`
	`61`	`+ }`
	`62`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -47,7 +47,7 @@ func (b ecsAPIService) Create(ctx context.Context, project types.Project, opts`
`47`	`47`	`return errdefs.ErrNotImplemented`
`48`	`48`	`}`
`49`	`49`
`50`		`-func (b ecsAPIService) Start(ctx context.Context, project types.Project, consumer compose.LogConsumer) error {`
	`50`	`+func (b ecsAPIService) Start(ctx context.Context, project types.Project, options compose.StartOptions) error {`
`51`	`51`	`return errdefs.ErrNotImplemented`
`52`	`52`	`}`
`53`	`53`