Skip to content

Modern Docker Management, Designed for Everyone

fix: docker container creation on api 1.44 attach primary network then remaining networks (#2053)

Kyle Mendell87b1df16b575
diff --git a/backend/cli/upgrade/upgrade.go b/backend/cli/upgrade/upgrade.go
index 483f333d8..37eef6b44 100644
--- a/backend/cli/upgrade/upgrade.go
+++ b/backend/cli/upgrade/upgrade.go
@@ -383,9 +383,12 @@ func upgradeContainer(ctx context.Context, dockerClient *client.Client, oldConta
}
// Build network config - preserve all network settings including IP addresses
- var networkConfig *network.NetworkingConfig
+ var (
+ apiVersion string
+ networkConfig *network.NetworkingConfig
+ )
if !nm.IsContainer() {
- apiVersion := libarcane.DetectDockerAPIVersion(ctx, dockerClient)
+ apiVersion = libarcane.DetectDockerAPIVersion(ctx, dockerClient)
if apiVersion != "" && !libarcane.SupportsDockerCreatePerNetworkMACAddress(apiVersion) {
slog.Info("daemon API does not support per-network mac-address on create; stripping endpoint mac addresses",
"dockerAPIVersion", apiVersion,
@@ -419,12 +422,12 @@ func upgradeContainer(ctx context.Context, dockerClient *client.Client, oldConta
fmt.Println("PROGRESS:75:Creating new container")
slog.Info("Creating new container", "name", originalName)
- resp, err := dockerClient.ContainerCreate(ctx, client.ContainerCreateOptions{
+ resp, err := libarcane.ContainerCreateWithCompatibilityForAPIVersion(ctx, dockerClient, client.ContainerCreateOptions{
Config: &config,
HostConfig: hostConfig,
NetworkingConfig: networkConfig,
Name: originalName,
- })
+ }, apiVersion)
if err != nil {
// Try to restart and restore old container on failure
_, _ = dockerClient.ContainerStart(ctx, oldContainer.ID, client.ContainerStartOptions{})
diff --git a/backend/internal/services/container_service.go b/backend/internal/services/container_service.go
index 08f9ad137..54097e7ea 100644
--- a/backend/internal/services/container_service.go
+++ b/backend/internal/services/container_service.go
@@ -239,7 +239,7 @@ func (s *ContainerService) CreateContainer(ctx context.Context, config *containe
}
}
- resp, err := dockerClient.ContainerCreate(ctx, client.ContainerCreateOptions{
+ resp, err := libarcane.ContainerCreateWithCompatibility(ctx, dockerClient, client.ContainerCreateOptions{
Config: config,
HostConfig: hostConfig,
NetworkingConfig: networkingConfig,
diff --git a/backend/internal/services/updater_service.go b/backend/internal/services/updater_service.go
index 73a495cc2..647829574 100644
--- a/backend/internal/services/updater_service.go
+++ b/backend/internal/services/updater_service.go
@@ -797,12 +797,12 @@ func (s *UpdaterService) updateContainer(ctx context.Context, cnt container.Summ
// Use original name for new container
containerName := strings.TrimPrefix(originalName, "/")
- resp, err := dcli.ContainerCreate(ctx, client.ContainerCreateOptions{
+ resp, err := libarcane.ContainerCreateWithCompatibilityForAPIVersion(ctx, dcli, client.ContainerCreateOptions{
Config: cfg,
HostConfig: hostConfig,
NetworkingConfig: networkingConfig,
Name: containerName,
- })
+ }, apiVersion)
if err != nil {
slog.DebugContext(ctx, "updateContainer: create failed", "containerName", containerName, "err", err)
return fmt.Errorf("create: %w", err)
diff --git a/backend/pkg/libarcane/docker_compat.go b/backend/pkg/libarcane/docker_compat.go
index afecb779e..0900aa8e4 100644
--- a/backend/pkg/libarcane/docker_compat.go
+++ b/backend/pkg/libarcane/docker_compat.go
@@ -2,19 +2,40 @@ package libarcane
import (
"context"
+ "fmt"
+ "slices"
"strconv"
"strings"
+ "github.com/moby/moby/api/types/container"
"github.com/moby/moby/api/types/network"
"github.com/moby/moby/client"
)
const NetworkScopedMacAddressMinAPIVersion = "1.44"
+// MultiEndpointContainerCreateMinAPIVersion is the first Docker API version
+// that reliably accepts multiple entries in NetworkingConfig.EndpointsConfig on
+// ContainerCreate.
+//
+// This matters because Arcane has several in-process container creation paths
+// (auto-update recreate, manual create, self-upgrade recreate, embedded Compose
+// library usage). Those paths all speak to the daemon through the Moby API
+// client, so Arcane must handle daemon API compatibility itself.
+//
+// A host-side `docker compose up` command can still succeed against the same
+// daemon because the installed Compose CLI/plugin may implement its own
+// fallback strategy for older daemon APIs, such as creating the container on
+// the primary network and then attaching the remaining networks with
+// NetworkConnect. Arcane cannot assume the host CLI's fallback behavior exists
+// in its own code paths, so the compatibility shim below applies that fallback
+// explicitly.
+const MultiEndpointContainerCreateMinAPIVersion = "1.44"
+
// DetectDockerAPIVersion returns the configured client API version when
// available, and falls back to the daemon-reported version only when the
// client version is not yet set.
-func DetectDockerAPIVersion(ctx context.Context, dockerClient *client.Client) string {
+func DetectDockerAPIVersion(ctx context.Context, dockerClient client.APIClient) string {
if dockerClient == nil {
return ""
}
@@ -31,6 +52,16 @@ func DetectDockerAPIVersion(ctx context.Context, dockerClient *client.Client) st
return strings.TrimSpace(serverVersion.APIVersion)
}
+// SupportsDockerCreateMultiEndpointNetworking reports whether the connected
+// daemon API supports attaching multiple endpoints during ContainerCreate.
+//
+// On older daemon APIs, sending multiple EndpointsConfig entries can fail with
+// daemon-side networking errors even though newer Compose CLIs may appear to
+// "work" by using a different fallback sequence under the hood.
+func SupportsDockerCreateMultiEndpointNetworking(apiVersion string) bool {
+ return IsDockerAPIVersionAtLeast(apiVersion, MultiEndpointContainerCreateMinAPIVersion)
+}
+
// SupportsDockerCreatePerNetworkMACAddress reports whether the daemon API
// supports per-network mac-address on container create (Docker API >= 1.44).
func SupportsDockerCreatePerNetworkMACAddress(apiVersion string) bool {
@@ -91,6 +122,134 @@ func SanitizeContainerCreateEndpointSettingsForDockerAPI(endpoints map[string]*n
return cloned
}
+// PrepareContainerCreateOptionsForDockerAPI rewrites a container create request
+// for older daemon APIs that cannot accept multiple endpoint attachments in the
+// initial ContainerCreate call.
+//
+// For API versions below MultiEndpointContainerCreateMinAPIVersion, Arcane
+// keeps only the primary network in NetworkingConfig.EndpointsConfig and
+// returns the remaining endpoints so the caller can attach them with
+// NetworkConnect after create but before start. This mirrors the compatibility
+// behavior that a newer host-side Compose CLI may apply internally, which
+// explains why a shell `docker compose up` can succeed while Arcane's embedded
+// or manual create paths fail unless we perform the split ourselves.
+func PrepareContainerCreateOptionsForDockerAPI(options client.ContainerCreateOptions, apiVersion string) (client.ContainerCreateOptions, map[string]*network.EndpointSettings) {
+ if SupportsDockerCreateMultiEndpointNetworking(apiVersion) || options.NetworkingConfig == nil || len(options.NetworkingConfig.EndpointsConfig) <= 1 {
+ return options, nil
+ }
+
+ primaryNetwork := resolvePrimaryContainerCreateNetworkInternal(options.HostConfig, options.NetworkingConfig.EndpointsConfig)
+ if primaryNetwork == "" {
+ return options, nil
+ }
+
+ adjusted := options
+ if options.HostConfig != nil {
+ hostConfigCopy := *options.HostConfig
+ adjusted.HostConfig = &hostConfigCopy
+ }
+ if adjusted.HostConfig == nil {
+ adjusted.HostConfig = &container.HostConfig{}
+ }
+ if strings.TrimSpace(string(adjusted.HostConfig.NetworkMode)) == "" {
+ adjusted.HostConfig.NetworkMode = container.NetworkMode(primaryNetwork)
+ }
+
+ primaryEndpoint := copyEndpointSettingsInternal(options.NetworkingConfig.EndpointsConfig[primaryNetwork])
+ adjusted.NetworkingConfig = &network.NetworkingConfig{
+ EndpointsConfig: map[string]*network.EndpointSettings{
+ primaryNetwork: primaryEndpoint,
+ },
+ }
+
+ extraEndpoints := make(map[string]*network.EndpointSettings, len(options.NetworkingConfig.EndpointsConfig)-1)
+ for networkName, endpoint := range options.NetworkingConfig.EndpointsConfig {
+ if networkName == primaryNetwork {
+ continue
+ }
+ extraEndpoints[networkName] = copyEndpointSettingsInternal(endpoint)
+ }
+ if len(extraEndpoints) == 0 {
+ return adjusted, nil
+ }
+
+ return adjusted, extraEndpoints
+}
+
+// ConnectContainerExtraNetworksForDockerAPI attaches endpoints that were
+// intentionally withheld from ContainerCreate for legacy daemon API
+// compatibility.
+//
+// The intended call order is:
+// 1. create the container on the primary network
+// 2. connect each additional user-defined network
+// 3. start the container
+//
+// Doing the attachment before start preserves the expected network topology
+// while avoiding the legacy daemon limitation on multi-endpoint create.
+func ConnectContainerExtraNetworksForDockerAPI(ctx context.Context, dockerClient client.APIClient, containerID string, endpoints map[string]*network.EndpointSettings) error {
+ if dockerClient == nil || strings.TrimSpace(containerID) == "" || len(endpoints) == 0 {
+ return nil
+ }
+
+ networkNames := make([]string, 0, len(endpoints))
+ for networkName := range endpoints {
+ networkNames = append(networkNames, networkName)
+ }
+ slices.Sort(networkNames)
+
+ for _, networkName := range networkNames {
+ _, err := dockerClient.NetworkConnect(ctx, networkName, client.NetworkConnectOptions{
+ Container: containerID,
+ EndpointConfig: copyEndpointSettingsInternal(endpoints[networkName]),
+ })
+ if err != nil {
+ return fmt.Errorf("connect network %s: %w", networkName, err)
+ }
+ }
+
+ return nil
+}
+
+// ContainerCreateWithCompatibility applies Arcane's Docker API compatibility
+// shims before calling ContainerCreate.
+//
+// This helper exists so every in-process Arcane create/recreate path can share
+// the same daemon-compatibility behavior instead of relying on whichever
+// fallback logic a separate host CLI binary might have. In practice this is the
+// guardrail that keeps Arcane aligned with older daemons such as Docker 24.x
+// advertising API 1.43 when a container needs multiple user-defined networks.
+func ContainerCreateWithCompatibility(ctx context.Context, dockerClient client.APIClient, options client.ContainerCreateOptions) (client.ContainerCreateResult, error) {
+ return ContainerCreateWithCompatibilityForAPIVersion(ctx, dockerClient, options, DetectDockerAPIVersion(ctx, dockerClient))
+}
+
+// ContainerCreateWithCompatibilityForAPIVersion applies Arcane's Docker API
+// compatibility shims before calling ContainerCreate when the caller has
+// already resolved the daemon API version.
+func ContainerCreateWithCompatibilityForAPIVersion(ctx context.Context, dockerClient client.APIClient, options client.ContainerCreateOptions, apiVersion string) (client.ContainerCreateResult, error) {
+ if dockerClient == nil {
+ return client.ContainerCreateResult{}, fmt.Errorf("docker api client is nil")
+ }
+
+ adjustedOptions, extraEndpoints := PrepareContainerCreateOptionsForDockerAPI(options, apiVersion)
+
+ result, err := dockerClient.ContainerCreate(ctx, adjustedOptions)
+ if err != nil {
+ return client.ContainerCreateResult{}, err
+ }
+
+ if len(extraEndpoints) == 0 {
+ return result, nil
+ }
+
+ if err := ConnectContainerExtraNetworksForDockerAPI(ctx, dockerClient, result.ID, extraEndpoints); err != nil {
+ _, _ = dockerClient.ContainerRemove(ctx, result.ID, client.ContainerRemoveOptions{Force: true})
+ return client.ContainerCreateResult{}, err
+ }
+
+ return result, nil
+}
+
func parseAPIVersionInternal(version string) ([3]int, bool) {
parsed := [3]int{}
@@ -119,3 +278,43 @@ func parseAPIVersionInternal(version string) ([3]int, bool) {
return parsed, true
}
+
+func resolvePrimaryContainerCreateNetworkInternal(hostConfig *container.HostConfig, endpoints map[string]*network.EndpointSettings) string {
+ if len(endpoints) == 0 {
+ return ""
+ }
+
+ if hostConfig != nil {
+ networkMode := strings.TrimSpace(string(hostConfig.NetworkMode))
+ switch {
+ case networkMode == "":
+ case container.NetworkMode(networkMode).IsHost(),
+ container.NetworkMode(networkMode).IsNone(),
+ container.NetworkMode(networkMode).IsContainer():
+ return ""
+ default:
+ if _, ok := endpoints[networkMode]; ok {
+ return networkMode
+ }
+ // Named network set in NetworkMode is not represented in endpoint
+ // config, so avoid splitting the request and let the daemon handle
+ // the original create options as-is.
+ return ""
+ }
+ }
+
+ networkNames := make([]string, 0, len(endpoints))
+ for networkName := range endpoints {
+ networkNames = append(networkNames, networkName)
+ }
+ slices.Sort(networkNames)
+ return networkNames[0]
+}
+
+func copyEndpointSettingsInternal(endpoint *network.EndpointSettings) *network.EndpointSettings {
+ if endpoint == nil {
+ return nil
+ }
+
+ return endpoint.Copy()
+}
diff --git a/backend/pkg/libarcane/docker_compat_test.go b/backend/pkg/libarcane/docker_compat_test.go
index dfd5a01bf..21a324a0d 100644
--- a/backend/pkg/libarcane/docker_compat_test.go
+++ b/backend/pkg/libarcane/docker_compat_test.go
@@ -1,14 +1,75 @@
package libarcane
import (
+ "context"
+ "errors"
"net"
"net/netip"
"testing"
+ "github.com/moby/moby/api/types/container"
"github.com/moby/moby/api/types/network"
+ "github.com/moby/moby/client"
"github.com/stretchr/testify/require"
)
+type fakeContainerCreateCompatibilityClient struct {
+ client.APIClient
+ containerCreateResult client.ContainerCreateResult
+ containerCreateErr error
+ networkConnectErrs map[string]error
+ containerRemoveErr error
+ containerCreateCalls []client.ContainerCreateOptions
+ networkConnectCalls []fakeNetworkConnectCall
+ containerRemoveCalls []fakeContainerRemoveCall
+ clientVersionCalls int
+ serverVersionCalls int
+}
+
+type fakeNetworkConnectCall struct {
+ network string
+ options client.NetworkConnectOptions
+}
+
+type fakeContainerRemoveCall struct {
+ containerID string
+ options client.ContainerRemoveOptions
+}
+
+func (f *fakeContainerCreateCompatibilityClient) ClientVersion() string {
+ f.clientVersionCalls++
+ return ""
+}
+
+func (f *fakeContainerCreateCompatibilityClient) ServerVersion(context.Context, client.ServerVersionOptions) (client.ServerVersionResult, error) {
+ f.serverVersionCalls++
+ return client.ServerVersionResult{}, nil
+}
+
+func (f *fakeContainerCreateCompatibilityClient) ContainerCreate(_ context.Context, options client.ContainerCreateOptions) (client.ContainerCreateResult, error) {
+ f.containerCreateCalls = append(f.containerCreateCalls, options)
+ if f.containerCreateErr != nil {
+ return client.ContainerCreateResult{}, f.containerCreateErr
+ }
+ return f.containerCreateResult, nil
+}
+
+func (f *fakeContainerCreateCompatibilityClient) NetworkConnect(_ context.Context, networkName string, options client.NetworkConnectOptions) (client.NetworkConnectResult, error) {
+ f.networkConnectCalls = append(f.networkConnectCalls, fakeNetworkConnectCall{network: networkName, options: options})
+ if err := f.networkConnectErrs[networkName]; err != nil {
+ return client.NetworkConnectResult{}, err
+ }
+ return client.NetworkConnectResult{}, nil
+}
+
+func (f *fakeContainerCreateCompatibilityClient) ContainerRemove(_ context.Context, containerID string, options client.ContainerRemoveOptions) (client.ContainerRemoveResult, error) {
+ f.containerRemoveCalls = append(f.containerRemoveCalls, fakeContainerRemoveCall{containerID: containerID, options: options})
+ if f.containerRemoveErr != nil {
+ return client.ContainerRemoveResult{}, f.containerRemoveErr
+ }
+ return client.ContainerRemoveResult{}, nil
+}
+
func mustHardwareAddr(t *testing.T, addr string) network.HardwareAddr {
t.Helper()
parsed, err := net.ParseMAC(addr)
@@ -47,6 +108,13 @@ func TestSupportsDockerCreatePerNetworkMACAddress(t *testing.T) {
require.False(t, SupportsDockerCreatePerNetworkMACAddress("1.41"))
}
+func TestSupportsDockerCreateMultiEndpointNetworking(t *testing.T) {
+ require.True(t, SupportsDockerCreateMultiEndpointNetworking("1.44"))
+ require.True(t, SupportsDockerCreateMultiEndpointNetworking("1.46"))
+ require.False(t, SupportsDockerCreateMultiEndpointNetworking("1.43"))
+ require.False(t, SupportsDockerCreateMultiEndpointNetworking("1.41"))
+}
+
func TestSanitizeContainerCreateEndpointSettingsForDockerAPI(t *testing.T) {
input := map[string]*network.EndpointSettings{
"bridge": {
@@ -86,3 +154,165 @@ func TestSanitizeContainerCreateEndpointSettingsForDockerAPI(t *testing.T) {
require.Nil(t, SanitizeContainerCreateEndpointSettingsForDockerAPI(map[string]*network.EndpointSettings{}, "1.44"))
})
}
+
+func TestPrepareContainerCreateOptionsForDockerAPI(t *testing.T) {
+ options := client.ContainerCreateOptions{
+ HostConfig: &container.HostConfig{
+ NetworkMode: container.NetworkMode("synobridge"),
+ },
+ NetworkingConfig: &network.NetworkingConfig{
+ EndpointsConfig: map[string]*network.EndpointSettings{
+ "synobridge": {
+ Aliases: []string{"app"},
+ },
+ "nginx-proxy-manager_zbridge": {
+ Aliases: []string{"proxy"},
+ },
+ },
+ },
+ }
+
+ t.Run("splits legacy multi-network create into primary plus extras", func(t *testing.T) {
+ adjusted, extras := PrepareContainerCreateOptionsForDockerAPI(options, "1.43")
+ require.NotNil(t, adjusted.NetworkingConfig)
+ require.Len(t, adjusted.NetworkingConfig.EndpointsConfig, 1)
+ require.Contains(t, adjusted.NetworkingConfig.EndpointsConfig, "synobridge")
+ require.Equal(t, []string{"app"}, adjusted.NetworkingConfig.EndpointsConfig["synobridge"].Aliases)
+
+ require.Len(t, extras, 1)
+ require.Contains(t, extras, "nginx-proxy-manager_zbridge")
+ require.Equal(t, []string{"proxy"}, extras["nginx-proxy-manager_zbridge"].Aliases)
+
+ adjusted.NetworkingConfig.EndpointsConfig["synobridge"].Aliases[0] = "changed"
+ extras["nginx-proxy-manager_zbridge"].Aliases[0] = "changed-too"
+
+ require.Equal(t, []string{"app"}, options.NetworkingConfig.EndpointsConfig["synobridge"].Aliases)
+ require.Equal(t, []string{"proxy"}, options.NetworkingConfig.EndpointsConfig["nginx-proxy-manager_zbridge"].Aliases)
+ })
+
+ t.Run("leaves create options unchanged on newer daemon apis", func(t *testing.T) {
+ adjusted, extras := PrepareContainerCreateOptionsForDockerAPI(options, "1.44")
+ require.Len(t, adjusted.NetworkingConfig.EndpointsConfig, 2)
+ require.Nil(t, extras)
+ })
+
+ t.Run("uses deterministic fallback primary network when mode is unset", func(t *testing.T) {
+ adjusted, extras := PrepareContainerCreateOptionsForDockerAPI(client.ContainerCreateOptions{
+ NetworkingConfig: &network.NetworkingConfig{
+ EndpointsConfig: map[string]*network.EndpointSettings{
+ "znet": {Aliases: []string{"z"}},
+ "anet": {Aliases: []string{"a"}},
+ },
+ },
+ }, "1.43")
+
+ require.NotNil(t, adjusted.HostConfig)
+ require.Equal(t, container.NetworkMode("anet"), adjusted.HostConfig.NetworkMode)
+ require.Len(t, adjusted.NetworkingConfig.EndpointsConfig, 1)
+ require.Contains(t, adjusted.NetworkingConfig.EndpointsConfig, "anet")
+ require.Len(t, extras, 1)
+ require.Contains(t, extras, "znet")
+ })
+
+ t.Run("leaves create options unchanged when named network mode is missing from endpoints", func(t *testing.T) {
+ options := client.ContainerCreateOptions{
+ HostConfig: &container.HostConfig{
+ NetworkMode: container.NetworkMode("mynetwork"),
+ },
+ NetworkingConfig: &network.NetworkingConfig{
+ EndpointsConfig: map[string]*network.EndpointSettings{
+ "anet": {Aliases: []string{"a"}},
+ "znet": {Aliases: []string{"z"}},
+ },
+ },
+ }
+
+ adjusted, extras := PrepareContainerCreateOptionsForDockerAPI(options, "1.43")
+
+ require.Equal(t, options.HostConfig.NetworkMode, adjusted.HostConfig.NetworkMode)
+ require.Len(t, adjusted.NetworkingConfig.EndpointsConfig, 2)
+ require.Contains(t, adjusted.NetworkingConfig.EndpointsConfig, "anet")
+ require.Contains(t, adjusted.NetworkingConfig.EndpointsConfig, "znet")
+ require.Nil(t, extras)
+ })
+}
+
+func TestContainerCreateWithCompatibilityForAPIVersion(t *testing.T) {
+ t.Run("uses provided api version without re-detecting it", func(t *testing.T) {
+ fakeClient := &fakeContainerCreateCompatibilityClient{
+ containerCreateResult: client.ContainerCreateResult{ID: "created"},
+ }
+
+ result, err := ContainerCreateWithCompatibilityForAPIVersion(t.Context(), fakeClient, client.ContainerCreateOptions{
+ Config: &container.Config{Image: "nginx:latest"},
+ }, "1.44")
+
+ require.NoError(t, err)
+ require.Equal(t, "created", result.ID)
+ require.Zero(t, fakeClient.clientVersionCalls)
+ require.Zero(t, fakeClient.serverVersionCalls)
+ require.Len(t, fakeClient.containerCreateCalls, 1)
+ })
+
+ t.Run("removes created container when a later network attach fails", func(t *testing.T) {
+ fakeClient := &fakeContainerCreateCompatibilityClient{
+ containerCreateResult: client.ContainerCreateResult{ID: "created-container"},
+ networkConnectErrs: map[string]error{
+ "cnet": errors.New("boom"),
+ },
+ }
+
+ _, err := ContainerCreateWithCompatibilityForAPIVersion(t.Context(), fakeClient, client.ContainerCreateOptions{
+ Config: &container.Config{Image: "nginx:latest"},
+ HostConfig: &container.HostConfig{
+ NetworkMode: container.NetworkMode("anet"),
+ },
+ NetworkingConfig: &network.NetworkingConfig{
+ EndpointsConfig: map[string]*network.EndpointSettings{
+ "anet": {Aliases: []string{"a"}},
+ "bnet": {Aliases: []string{"b"}},
+ "cnet": {Aliases: []string{"c"}},
+ "dnet": {Aliases: []string{"d"}},
+ },
+ },
+ }, "1.43")
+
+ require.ErrorContains(t, err, "connect network cnet")
+ require.Len(t, fakeClient.containerCreateCalls, 1)
+ require.Len(t, fakeClient.networkConnectCalls, 2)
+ require.Equal(t, "bnet", fakeClient.networkConnectCalls[0].network)
+ require.Equal(t, "cnet", fakeClient.networkConnectCalls[1].network)
+ require.Len(t, fakeClient.containerRemoveCalls, 1)
+ require.Equal(t, "created-container", fakeClient.containerRemoveCalls[0].containerID)
+ require.True(t, fakeClient.containerRemoveCalls[0].options.Force)
+ })
+
+ t.Run("propagates network attach error when rollback remove also fails", func(t *testing.T) {
+ connectErr := errors.New("connect-boom")
+ removeErr := errors.New("remove-boom")
+ fakeClient := &fakeContainerCreateCompatibilityClient{
+ containerCreateResult: client.ContainerCreateResult{ID: "created-container"},
+ networkConnectErrs: map[string]error{
+ "bnet": connectErr,
+ },
+ containerRemoveErr: removeErr,
+ }
+
+ _, err := ContainerCreateWithCompatibilityForAPIVersion(t.Context(), fakeClient, client.ContainerCreateOptions{
+ HostConfig: &container.HostConfig{
+ NetworkMode: container.NetworkMode("anet"),
+ },
+ NetworkingConfig: &network.NetworkingConfig{
+ EndpointsConfig: map[string]*network.EndpointSettings{
+ "anet": {},
+ "bnet": {},
+ },
+ },
+ }, "1.43")
+
+ require.ErrorContains(t, err, "connect network bnet")
+ require.ErrorIs(t, err, connectErr)
+ require.NotErrorIs(t, err, removeErr)
+ require.Len(t, fakeClient.containerRemoveCalls, 1)
+ })
+}
diff --git a/backend/pkg/libarcane/inspect_compat.go b/backend/pkg/libarcane/inspect_compat.go
index 6eb64252e..e8553b106 100644
--- a/backend/pkg/libarcane/inspect_compat.go
+++ b/backend/pkg/libarcane/inspect_compat.go
@@ -35,6 +35,10 @@ type inspectCompatibilityClient struct {
client.APIClient
}
+func (c *inspectCompatibilityClient) ContainerCreate(ctx context.Context, options client.ContainerCreateOptions) (client.ContainerCreateResult, error) {
+ return ContainerCreateWithCompatibility(ctx, c.APIClient, options)
+}
+
func (c *inspectCompatibilityClient) ContainerInspect(ctx context.Context, containerID string, options client.ContainerInspectOptions) (client.ContainerInspectResult, error) {
return ContainerInspectWithCompatibility(ctx, c.APIClient, containerID, options)
}
diff --git a/backend/pkg/libarcane/inspect_compat_test.go b/backend/pkg/libarcane/inspect_compat_test.go
index ac781e0e5..390ae3ff5 100644
--- a/backend/pkg/libarcane/inspect_compat_test.go
+++ b/backend/pkg/libarcane/inspect_compat_test.go
@@ -3,6 +3,7 @@ package libarcane
import (
"context"
"encoding/json"
+ "io"
"net/http"
"net/http/httptest"
"net/netip"
@@ -321,6 +322,76 @@ func TestWrapDockerAPIClientForInspectCompatibility(t *testing.T) {
assert.Equal(t, netip.MustParseAddr("fdd0:0:0:c::1"), result.Container.NetworkSettings.Networks["bridge"].IPv6Gateway)
}
+func TestWrapDockerAPIClientForInspectCompatibility_ContainerCreateLegacyNetworks(t *testing.T) {
+ type createRequest struct {
+ NetworkingConfig networktypes.NetworkingConfig `json:"NetworkingConfig"`
+ }
+ type connectRequest struct {
+ Container string `json:"Container"`
+ EndpointConfig *networktypes.EndpointSettings `json:"EndpointConfig"`
+ }
+
+ var createPayload createRequest
+ connectPayloads := map[string]connectRequest{}
+
+ dockerClient := newTestDockerClient(t, func(w http.ResponseWriter, r *http.Request) {
+ switch {
+ case r.Method == http.MethodPost && strings.HasSuffix(r.URL.Path, "/containers/create"):
+ body, err := io.ReadAll(r.Body)
+ require.NoError(t, err)
+ require.NoError(t, json.Unmarshal(body, &createPayload))
+ w.Header().Set("Content-Type", "application/json")
+ _, _ = w.Write([]byte(`{"Id":"new-container-id","Warnings":[]}`))
+ case r.Method == http.MethodPost && strings.Contains(r.URL.Path, "/networks/") && strings.HasSuffix(r.URL.Path, "/connect"):
+ networkName := r.URL.Path
+ networkName = strings.TrimSuffix(networkName, "/connect")
+ networkName = networkName[strings.LastIndex(networkName, "/networks/")+len("/networks/"):]
+ body, err := io.ReadAll(r.Body)
+ require.NoError(t, err)
+
+ var payload connectRequest
+ require.NoError(t, json.Unmarshal(body, &payload))
+ connectPayloads[networkName] = payload
+ w.WriteHeader(http.StatusOK)
+ default:
+ t.Fatalf("unexpected request: %s %s", r.Method, r.URL.Path)
+ }
+ })
+
+ wrapped := WrapDockerAPIClientForInspectCompatibility(dockerClient)
+ result, err := wrapped.ContainerCreate(context.Background(), client.ContainerCreateOptions{
+ Config: &containertypes.Config{
+ Image: "nginx:alpine",
+ },
+ HostConfig: &containertypes.HostConfig{
+ NetworkMode: containertypes.NetworkMode("synobridge"),
+ },
+ NetworkingConfig: &networktypes.NetworkingConfig{
+ EndpointsConfig: map[string]*networktypes.EndpointSettings{
+ "synobridge": {
+ Aliases: []string{"app"},
+ },
+ "nginx-proxy-manager_zbridge": {
+ Aliases: []string{"proxy"},
+ },
+ },
+ },
+ Name: "test-app",
+ })
+ require.NoError(t, err)
+ assert.Equal(t, "new-container-id", result.ID)
+
+ require.Len(t, createPayload.NetworkingConfig.EndpointsConfig, 1)
+ require.Contains(t, createPayload.NetworkingConfig.EndpointsConfig, "synobridge")
+ assert.Equal(t, []string{"app"}, createPayload.NetworkingConfig.EndpointsConfig["synobridge"].Aliases)
+
+ require.Len(t, connectPayloads, 1)
+ require.Contains(t, connectPayloads, "nginx-proxy-manager_zbridge")
+ assert.Equal(t, "new-container-id", connectPayloads["nginx-proxy-manager_zbridge"].Container)
+ require.NotNil(t, connectPayloads["nginx-proxy-manager_zbridge"].EndpointConfig)
+ assert.Equal(t, []string{"proxy"}, connectPayloads["nginx-proxy-manager_zbridge"].EndpointConfig.Aliases)
+}
+
func newTestDockerClient(t *testing.T, handler http.HandlerFunc) *client.Client {
t.Helper()
diff --git a/types/project/marshal_utils.go b/types/project/marshal_utils.go
index b55f6a7ff..69fb8cedd 100644
--- a/types/project/marshal_utils.go
+++ b/types/project/marshal_utils.go
@@ -4,6 +4,7 @@ import (
"bytes"
"encoding/json"
"fmt"
+ "maps"
"reflect"
"strconv"
"strings"
@@ -14,7 +15,7 @@ import (
// unitBytesType is used to detect compose-go fields that need string-or-number
// normalization before they can be decoded by encoding/json.
-var unitBytesType = reflect.TypeOf(composetypes.UnitBytes(0))
+var unitBytesType = reflect.TypeFor[composetypes.UnitBytes]()
// runtimeServiceJSON is an internal decode shape that lets RuntimeService
// handle serviceConfig separately from the rest of the payload.
@@ -112,7 +113,7 @@ func unmarshalComposeServiceConfigJSONInternal(data []byte) (*composetypes.Servi
return nil, err
}
- normalized, err := normalizeJSONValueForTypeInternal(raw, reflect.TypeOf(composetypes.ServiceConfig{}))
+ normalized, err := normalizeJSONValueForTypeInternal(raw, reflect.TypeFor[composetypes.ServiceConfig]())
if err != nil {
return nil, err
}
@@ -188,12 +189,9 @@ func normalizeJSONObjectForTypeInternal(value any, destType reflect.Type) (any,
}
normalized := make(map[string]any, len(object))
- for key, item := range object {
- normalized[key] = item
- }
+ maps.Copy(normalized, object)
- for i := 0; i < destType.NumField(); i++ {
- field := destType.Field(i)
+ for field := range destType.Fields() {
if field.PkgPath != "" {
continue
}