Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
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.goindex 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, oldContafmt.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.goindex 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.goindex 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 containercontainerName := 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.goindex afecb779e..0900aa8e4 100644--- a/backend/pkg/libarcane/docker_compat.go+++ b/backend/pkg/libarcane/docker_compat.go@@ -2,19 +2,40 @@ package libarcaneimport ("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) streturn 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]*nreturn 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.goindex dfd5a01bf..21a324a0d 100644--- a/backend/pkg/libarcane/docker_compat_test.go+++ b/backend/pkg/libarcane/docker_compat_test.go@@ -1,14 +1,75 @@package libarcaneimport (+ "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.goindex 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.goindex ac781e0e5..390ae3ff5 100644--- a/backend/pkg/libarcane/inspect_compat_test.go+++ b/backend/pkg/libarcane/inspect_compat_test.go@@ -3,6 +3,7 @@ package libarcaneimport ("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.goindex 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.Servireturn 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}