Add ENGINE column driven by com.docker.compose.engine label

cmd/compose/ps.go

@@ -30,6 +30,7 @@ import (
 	"github.com/spf13/cobra"
 
 	"github.com/docker/compose/v5/cmd/formatter"
+	"github.com/docker/compose/v5/internal/coordinator"
 	"github.com/docker/compose/v5/pkg/api"
 	"github.com/docker/compose/v5/pkg/compose"
 )
@@ -156,9 +157,14 @@ func runPs(ctx context.Context, dockerCli command.Cli, backendOptions *BackendOp
 		opts.Format = dockerCli.ConfigFile().PsFormat
 	}
 
+	// Show the ENGINE column when the current Docker context is coordinator-
+	// enabled, so the column's presence is stable across `ps` and `ps <subset>`
+	// rather than gated on which containers happen to carry the engine label.
+	showEngine := coordinator.PushEnabled(dockerCli)
+
 	containerCtx := cliformatter.Context{
 		Output: dockerCli.Out(),
-		Format: formatter.NewContainerFormat(opts.Format, opts.Quiet, false),
+		Format: formatter.NewContainerFormat(opts.Format, opts.Quiet, false, showEngine),
 		Trunc:  !opts.noTrunc,
 	}
 	return formatter.ContainerWrite(containerCtx, containers)

cmd/formatter/container.go

@@ -42,16 +42,20 @@ const (
 	mountsHeader     = "MOUNTS"
 	localVolumes     = "LOCAL VOLUMES"
 	networksHeader   = "NETWORKS"
+	engineHeader     = "ENGINE"
 )
 
 // NewContainerFormat returns a Format for rendering using a Context
-func NewContainerFormat(source string, quiet bool, size bool) formatter.Format {
+func NewContainerFormat(source string, quiet bool, size bool, engine bool) formatter.Format {
 	switch source {
 	case formatter.TableFormatKey, "": // table formatting is the default if none is set.
 		if quiet {
 			return formatter.DefaultQuietFormat
 		}
 		format := defaultContainerTableFormat
+		if engine {
+			format += `\t{{.Engine}}`
+		}
 		if size {
 			format += `\t{{.Size}}`
 		}
@@ -126,6 +130,7 @@ func NewContainerContext() *ContainerContext {
 		"Status":     formatter.StatusHeader,
 		"Size":       formatter.SizeHeader,
 		"Labels":     formatter.LabelsHeader,
+		"Engine":     engineHeader,
 	}
 	return &containerCtx
 }
@@ -245,6 +250,15 @@ func (c *ContainerContext) Labels() string {
 	return strings.Join(joinLabels, ",")
 }
 
+// Engine returns the name of the engine that runs the container, as stored in
+// the com.docker.compose.engine label, or an empty string if unset.
+func (c *ContainerContext) Engine() string {
+	if c.c.Labels == nil {
+		return ""
+	}
+	return c.c.Labels[api.ContainerEngineLabel]
+}
+
 // Label returns the value of the label with the given name or an empty string
 // if the given label does not exist.
 func (c *ContainerContext) Label(name string) string {

cmd/formatter/container_test.go

@@ -0,0 +1,78 @@
+/*
+   Copyright 2020 Docker Compose CLI 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 formatter
+
+import (
+	"bytes"
+	"strings"
+	"testing"
+
+	"github.com/docker/cli/cli/command/formatter"
+	"gotest.tools/v3/assert"
+
+	"github.com/docker/compose/v5/pkg/api"
+)
+
+func TestContainerContextEngine(t *testing.T) {
+	withLabel := ContainerContext{c: api.ContainerSummary{
+		Labels: map[string]string{api.ContainerEngineLabel: "moby"},
+	}}
+	assert.Equal(t, withLabel.Engine(), "moby")
+
+	noLabels := ContainerContext{c: api.ContainerSummary{}}
+	assert.Equal(t, noLabels.Engine(), "")
+
+	otherLabel := ContainerContext{c: api.ContainerSummary{
+		Labels: map[string]string{api.ProjectLabel: "test"},
+	}}
+	assert.Equal(t, otherLabel.Engine(), "")
+}
+
+func TestContainerWriteEngineColumn(t *testing.T) {
+	containers := []api.ContainerSummary{
+		{
+			Name:    "with-engine",
+			Service: "svc1",
+			Labels:  map[string]string{api.ContainerEngineLabel: "moby"},
+		},
+		{
+			Name:    "without-engine",
+			Service: "svc2",
+		},
+	}
+
+	t.Run("engine column shown when label present", func(t *testing.T) {
+		var out bytes.Buffer
+		ctx := formatter.Context{
+			Output: &out,
+			Format: NewContainerFormat("table", false, false, true),
+		}
+		assert.NilError(t, ContainerWrite(ctx, containers))
+		assert.Assert(t, strings.Contains(out.String(), engineHeader), out.String())
+		assert.Assert(t, strings.Contains(out.String(), "moby"), out.String())
+	})
+
+	t.Run("engine column hidden when no label present", func(t *testing.T) {
+		var out bytes.Buffer
+		ctx := formatter.Context{
+			Output: &out,
+			Format: NewContainerFormat("table", false, false, false),
+		}
+		assert.NilError(t, ContainerWrite(ctx, containers))
+		assert.Assert(t, !strings.Contains(out.String(), engineHeader), out.String())
+	})
+}

internal/coordinator/coordinator.go

@@ -0,0 +1,161 @@
+/*
+   Copyright 2020 Docker Compose CLI 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 coordinator holds the coordinator-specific integration used by
+// Compose: detecting a coordinator-enabled Docker context and pushing the
+// project configuration to it over the engine socket. It mirrors the
+// self-contained layout of internal/desktop (detection, HTTP client, versioned
+// URL and outcome handling) so that pkg/compose keeps only a thin call-site.
+package coordinator
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"io"
+	"net"
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/compose-spec/compose-go/v2/types"
+	"github.com/docker/cli/cli/command"
+	"github.com/moby/moby/client/pkg/versions"
+)
+
+// MetadataKey is the Docker context metadata key that opts a socket into the
+// Compose project-config push. When the current context's metadata carries
+// this key set to a truthy value, the socket is assumed to accept
+// POST /v{version}/compose/project (see MinAPIVersion), and Compose sends the
+// project configuration to the coordinator at the start of "compose up" before
+// any other Docker API call.
+const MetadataKey = "com.docker.compose.project.config"
+
+// MinAPIVersion is the Engine/coordinator API version that introduced
+// POST /v{version}/compose/project for the Compose project-config push. It
+// documents the minimum coordinator version and is the single place the push
+// gates on.
+const MinAPIVersion = "1.51"
+
+// defaultTimeout bounds a single project-config push. The push runs before any
+// other Docker API call in "compose up", so without a deadline a coordinator
+// that accepts the connection but never responds would hang "up" indefinitely,
+// defeating the non-fatal "warn and continue" guarantee.
+const defaultTimeout = 30 * time.Second
+
+// responseBodyLimit bounds how much of an error response body is read back
+// into the returned error message.
+const responseBodyLimit = 2048
+
+// PushEnabled reports whether the current Docker context opts into the
+// project-config push via the MetadataKey metadata key. A metadata read
+// failure is treated as "not enabled" so that "compose up" is never blocked on
+// context inspection. The value is accepted as either a JSON boolean true or
+// the string "true" (case-insensitive), mirroring how custom context metadata
+// may be decoded (see ConfigFromDockerContext in
+// internal/tracing/docker_context.go).
+func PushEnabled(dockerCli command.Cli) bool {
+	meta, err := dockerCli.ContextStore().GetMetadata(dockerCli.CurrentContext())
+	if err != nil {
+		return false
+	}
+
+	var value any
+	switch m := meta.Metadata.(type) {
+	case command.DockerContext:
+		value = m.AdditionalFields[MetadataKey]
+	case map[string]any:
+		value = m[MetadataKey]
+	}
+
+	switch v := value.(type) {
+	case bool:
+		return v
+	case string:
+		return strings.EqualFold(v, "true")
+	default:
+		return false
+	}
+}
+
+// Client pushes the Compose project configuration to a coordinator over the
+// Docker engine socket, using the engine dialer for transport (mirroring
+// internal/desktop/client.go).
+type Client struct {
+	dialer  func(ctx context.Context) (net.Conn, error)
+	timeout time.Duration
+}
+
+// NewClient builds a coordinator client that reaches the engine over the given
+// dialer (typically apiClient.Dialer()).
+func NewClient(dialer func(ctx context.Context) (net.Conn, error)) *Client {
+	return &Client{dialer: dialer, timeout: defaultTimeout}
+}
+
+// PushProjectConfig sends the full project configuration to the coordinator's
+// version-negotiated POST /v{version}/compose/project endpoint. apiVersion is
+// the negotiated engine API version; the push is rejected before any network
+// call when it predates MinAPIVersion. A non-2xx response is returned as an
+// error; callers warn and continue. The request is bounded by a timeout so a
+// coordinator that never responds cannot hang "compose up".
+func (c *Client) PushProjectConfig(ctx context.Context, apiVersion string, project *types.Project) error {
+	if versions.LessThan(apiVersion, MinAPIVersion) {
+		return fmt.Errorf("coordinator API version %s does not support the project-config push (requires %s or later)",
+			apiVersion, MinAPIVersion)
+	}
+
+	payload, err := project.MarshalJSON()
+	if err != nil {
+		return fmt.Errorf("marshaling project config: %w", err)
+	}
+
+	httpClient := &http.Client{
+		Timeout: c.timeout,
+		Transport: &http.Transport{
+			DialContext: func(ctx context.Context, _, _ string) (net.Conn, error) {
+				return c.dialer(ctx)
+			},
+		},
+	}
+
+	// The host is cosmetic: the custom dialer handles routing to the engine
+	// socket. It exists only to form a valid URL (see desktop.backendURL).
+	url := fmt.Sprintf("http://docker/v%s/compose/project", apiVersion)
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewReader(payload))
+	if err != nil {
+		return err
+	}
+	req.Header.Set("Content-Type", "application/json")
+
+	resp, err := httpClient.Do(req)
+	if err != nil {
+		return err
+	}
+	defer func() {
+		_ = resp.Body.Close()
+	}()
+
+	if resp.StatusCode >= http.StatusBadRequest {
+		body, _ := io.ReadAll(io.LimitReader(resp.Body, responseBodyLimit))
+		msg := strings.TrimSpace(string(body))
+		if msg == "" {
+			return fmt.Errorf("coordinator returned status %d", resp.StatusCode)
+		}
+		return fmt.Errorf("coordinator returned status %d: %s", resp.StatusCode, msg)
+	}
+
+	return nil
+}