Skip to content

Modern Docker Management, Designed for Everyone

fix: incorrect ipv6 parsing on api responses (#2040)

Kyle Mendelld54cc6fed7ce
diff --git a/backend/cli/upgrade/upgrade.go b/backend/cli/upgrade/upgrade.go
index 2fdb9373b..483f333d8 100644
--- a/backend/cli/upgrade/upgrade.go
+++ b/backend/cli/upgrade/upgrade.go
@@ -83,7 +83,7 @@ func runUpgrade(cmd *cobra.Command, args []string) error {
containerName = strings.TrimPrefix(targetContainer.Name, "/")
slog.Info("Found Arcane container", "name", containerName, "id", targetContainer.ID[:12])
} else {
- inspectResult, inspectErr := dockerClient.ContainerInspect(ctx, containerName, client.ContainerInspectOptions{})
+ inspectResult, inspectErr := libarcane.ContainerInspectWithCompatibility(ctx, dockerClient, containerName, client.ContainerInspectOptions{})
targetContainer = inspectResult.Container
err = inspectErr
if err != nil {
@@ -134,7 +134,7 @@ func findArcaneContainer(ctx context.Context, dockerClient *client.Client) (cont
continue
}
- inspectResult, err := dockerClient.ContainerInspect(ctx, c.ID, client.ContainerInspectOptions{})
+ inspectResult, err := libarcane.ContainerInspectWithCompatibility(ctx, dockerClient, c.ID, client.ContainerInspectOptions{})
if err != nil {
continue
}
diff --git a/backend/internal/services/container_service.go b/backend/internal/services/container_service.go
index 58d5b5668..e6e0d87c3 100644
--- a/backend/internal/services/container_service.go
+++ b/backend/internal/services/container_service.go
@@ -124,7 +124,7 @@ func (s *ContainerService) GetContainerByID(ctx context.Context, id string) (*co
return nil, fmt.Errorf("failed to connect to Docker: %w", err)
}
- containerInspect, err := dockerClient.ContainerInspect(ctx, id, client.ContainerInspectOptions{})
+ containerInspect, err := libarcane.ContainerInspectWithCompatibility(ctx, dockerClient, id, client.ContainerInspectOptions{})
if err != nil {
return nil, fmt.Errorf("container not found: %w", err)
}
@@ -143,7 +143,7 @@ func (s *ContainerService) DeleteContainer(ctx context.Context, containerID stri
// Get container mounts before deletion if we need to remove volumes
var volumesToRemove []string
if removeVolumes {
- containerJSON, inspectErr := dockerClient.ContainerInspect(ctx, containerID, client.ContainerInspectOptions{})
+ containerJSON, inspectErr := libarcane.ContainerInspectWithCompatibility(ctx, dockerClient, containerID, client.ContainerInspectOptions{})
if inspectErr == nil {
for _, mount := range containerJSON.Container.Mounts {
// Only collect named volumes (not bind mounts or tmpfs)
@@ -253,7 +253,7 @@ func (s *ContainerService) CreateContainer(ctx context.Context, config *containe
return nil, fmt.Errorf("failed to start container: %w", err)
}
- containerJSON, err := dockerClient.ContainerInspect(ctx, resp.ID, client.ContainerInspectOptions{})
+ containerJSON, err := libarcane.ContainerInspectWithCompatibility(ctx, dockerClient, resp.ID, client.ContainerInspectOptions{})
if err != nil {
s.eventService.LogErrorEvent(ctx, models.EventTypeContainerError, "container", resp.ID, containerName, user.ID, user.Username, "0", err, models.JSON{"action": "create", "image": config.Image, "step": "inspect"})
return nil, fmt.Errorf("failed to inspect created container: %w", err)
diff --git a/backend/internal/services/network_service.go b/backend/internal/services/network_service.go
index 0780a2088..a5c3ea265 100644
--- a/backend/internal/services/network_service.go
+++ b/backend/internal/services/network_service.go
@@ -9,6 +9,7 @@ import (
"github.com/getarcaneapp/arcane/backend/internal/models"
dockerutil "github.com/getarcaneapp/arcane/backend/internal/utils/docker"
"github.com/getarcaneapp/arcane/backend/internal/utils/pagination"
+ "github.com/getarcaneapp/arcane/backend/pkg/libarcane"
networktypes "github.com/getarcaneapp/arcane/types/network"
"github.com/moby/moby/api/types/container"
"github.com/moby/moby/api/types/network"
@@ -35,7 +36,7 @@ func (s *NetworkService) GetNetworkByID(ctx context.Context, id string) (*networ
return nil, fmt.Errorf("failed to connect to Docker: %w", err)
}
- networkInspect, err := dockerClient.NetworkInspect(ctx, id, client.NetworkInspectOptions{})
+ networkInspect, err := libarcane.NetworkInspectWithCompatibility(ctx, dockerClient, id, client.NetworkInspectOptions{})
if err != nil {
return nil, fmt.Errorf("network not found: %w", err)
}
@@ -86,7 +87,7 @@ func (s *NetworkService) RemoveNetwork(ctx context.Context, id string, user mode
return fmt.Errorf("failed to connect to Docker: %w", err)
}
- networkInfo, err := dockerClient.NetworkInspect(ctx, id, client.NetworkInspectOptions{})
+ networkInfo, err := libarcane.NetworkInspectWithCompatibility(ctx, dockerClient, id, client.NetworkInspectOptions{})
var networkName string
if err == nil {
networkName = networkInfo.Network.Name
diff --git a/backend/internal/services/system_upgrade_service.go b/backend/internal/services/system_upgrade_service.go
index 4013e28e7..f1372e26c 100644
--- a/backend/internal/services/system_upgrade_service.go
+++ b/backend/internal/services/system_upgrade_service.go
@@ -13,6 +13,7 @@ import (
"github.com/getarcaneapp/arcane/backend/internal/models"
dockerutils "github.com/getarcaneapp/arcane/backend/internal/utils/docker"
"github.com/getarcaneapp/arcane/backend/internal/utils/timeouts"
+ "github.com/getarcaneapp/arcane/backend/pkg/libarcane"
containertypes "github.com/moby/moby/api/types/container"
mounttypes "github.com/moby/moby/api/types/mount"
"github.com/moby/moby/client"
@@ -227,7 +228,7 @@ func (s *SystemUpgradeService) findArcaneContainer(ctx context.Context, containe
}
// Try to inspect the container directly
- container, err := dockerClient.ContainerInspect(ctx, containerId, client.ContainerInspectOptions{})
+ container, err := libarcane.ContainerInspectWithCompatibility(ctx, dockerClient, containerId, client.ContainerInspectOptions{})
if err == nil {
return container.Container, nil
}
@@ -246,7 +247,7 @@ func (s *SystemUpgradeService) findArcaneContainer(ctx context.Context, containe
for _, c := range containers.Items {
if strings.HasPrefix(c.ID, containerId) {
- inspect, inspectErr := dockerClient.ContainerInspect(ctx, c.ID, client.ContainerInspectOptions{})
+ inspect, inspectErr := libarcane.ContainerInspectWithCompatibility(ctx, dockerClient, c.ID, client.ContainerInspectOptions{})
if inspectErr != nil {
return containertypes.InspectResponse{}, inspectErr
}
@@ -262,7 +263,7 @@ func (s *SystemUpgradeService) findArcaneContainer(ctx context.Context, containe
for _, c := range allContainers.Items {
if strings.HasPrefix(c.ID, containerId) || c.ID == containerId {
- inspect, inspectErr := dockerClient.ContainerInspect(ctx, c.ID, client.ContainerInspectOptions{})
+ inspect, inspectErr := libarcane.ContainerInspectWithCompatibility(ctx, dockerClient, c.ID, client.ContainerInspectOptions{})
if inspectErr != nil {
return containertypes.InspectResponse{}, inspectErr
}
diff --git a/backend/internal/services/updater_service.go b/backend/internal/services/updater_service.go
index 1d06966ee..0973b78bd 100644
--- a/backend/internal/services/updater_service.go
+++ b/backend/internal/services/updater_service.go
@@ -428,7 +428,7 @@ func (s *UpdaterService) UpdateSingleContainer(ctx context.Context, containerID
slog.InfoContext(ctx, "UpdateSingleContainer: found container", "containerID", containerID, "name", containerName, "image", targetContainer.Image)
// Inspect container to get full config (needed for label-based controls)
- inspectBeforeResult, err := dcli.ContainerInspect(ctx, targetContainer.ID, client.ContainerInspectOptions{})
+ inspectBeforeResult, err := libarcane.ContainerInspectWithCompatibility(ctx, dcli, targetContainer.ID, client.ContainerInspectOptions{})
if err != nil {
out.Items = append(out.Items, updater.ResourceResult{
ResourceID: targetContainer.ID,
@@ -923,7 +923,7 @@ func (s *UpdaterService) collectUsedImagesFromContainersInternal(ctx context.Con
continue
}
- inspectResult, err := dcli.ContainerInspect(ctx, c.ID, client.ContainerInspectOptions{})
+ inspectResult, err := libarcane.ContainerInspectWithCompatibility(ctx, dcli, c.ID, client.ContainerInspectOptions{})
if err != nil {
slog.DebugContext(ctx, "collectUsedImagesFromContainersInternal: container inspect failed", "containerId", c.ID, "err", err)
continue
@@ -1255,7 +1255,7 @@ func (s *UpdaterService) restartContainersUsingOldIDs(ctx context.Context, oldID
if len(markedForRestart) > 0 {
for i := range containersWithDeps {
cwd := containersWithDeps[i]
- inspectResult, ierr := dcli.ContainerInspect(ctx, cwd.Container.ID, client.ContainerInspectOptions{})
+ inspectResult, ierr := libarcane.ContainerInspectWithCompatibility(ctx, dcli, cwd.Container.ID, client.ContainerInspectOptions{})
if ierr != nil {
continue
}
@@ -1317,7 +1317,7 @@ func (s *UpdaterService) restartContainersUsingOldIDs(ctx context.Context, oldID
name := cd.Name
labels := map[string]string{}
if p.inspect == nil {
- inspectResult, ierr := dcli.ContainerInspect(ctx, p.cnt.ID, client.ContainerInspectOptions{})
+ inspectResult, ierr := libarcane.ContainerInspectWithCompatibility(ctx, dcli, p.cnt.ID, client.ContainerInspectOptions{})
if ierr != nil {
res := updater.ResourceResult{
ResourceID: p.cnt.ID,
@@ -1614,7 +1614,7 @@ func (s *UpdaterService) anyImageIDsStillInUse(ctx context.Context, ids []string
}
list := listResult.Items
for _, c := range list {
- inspectResult, ierr := dcli.ContainerInspect(ctx, c.ID, client.ContainerInspectOptions{})
+ inspectResult, ierr := libarcane.ContainerInspectWithCompatibility(ctx, dcli, c.ID, client.ContainerInspectOptions{})
if ierr != nil {
continue
}
@@ -1670,7 +1670,7 @@ func (s *UpdaterService) buildRunningImageIDSetInternal(ctx context.Context) (ma
continue
}
- inspectResult, ierr := dcli.ContainerInspect(ctx, c.ID, client.ContainerInspectOptions{})
+ inspectResult, ierr := libarcane.ContainerInspectWithCompatibility(ctx, dcli, c.ID, client.ContainerInspectOptions{})
inspect := inspectResult.Container
if ierr == nil && inspect.Image != "" {
inUseSet[inspect.Image] = struct{}{}
diff --git a/backend/internal/services/version_service.go b/backend/internal/services/version_service.go
index 0f53572e3..ed0a11cbd 100644
--- a/backend/internal/services/version_service.go
+++ b/backend/internal/services/version_service.go
@@ -15,6 +15,7 @@ import (
"github.com/getarcaneapp/arcane/backend/internal/utils/arcaneupdater"
"github.com/getarcaneapp/arcane/backend/internal/utils/cache"
"github.com/getarcaneapp/arcane/backend/internal/utils/docker"
+ "github.com/getarcaneapp/arcane/backend/pkg/libarcane"
"github.com/getarcaneapp/arcane/types/version"
containertypes "github.com/moby/moby/api/types/container"
"github.com/moby/moby/client"
@@ -293,7 +294,7 @@ func (s *VersionService) detectCurrentImageInfo(ctx context.Context) (tag string
}
slog.Debug("detectCurrentImageInfo: detected container", "containerId", containerId)
- inspectResult, err := dockerClient.ContainerInspect(ctx, containerId, client.ContainerInspectOptions{})
+ inspectResult, err := libarcane.ContainerInspectWithCompatibility(ctx, dockerClient, containerId, client.ContainerInspectOptions{})
if err != nil {
slog.Debug("detectCurrentImageInfo: failed to inspect container", "containerId", containerId, "error", err)
return "", "", ""
diff --git a/backend/internal/services/volume_service.go b/backend/internal/services/volume_service.go
index 5500d7465..5f51fabf5 100644
--- a/backend/internal/services/volume_service.go
+++ b/backend/internal/services/volume_service.go
@@ -404,7 +404,7 @@ func (s *VolumeService) getHelperImageInternal(ctx context.Context, dockerClient
func (s *VolumeService) resolveArcaneHelperImageInternal(ctx context.Context, dockerClient *client.Client) (string, string, bool) {
hostname, _ := os.Hostname()
if hostname != "" {
- if inspect, err := dockerClient.ContainerInspect(ctx, hostname, client.ContainerInspectOptions{}); err == nil && inspect.Container.Config != nil && strings.TrimSpace(inspect.Container.Config.Image) != "" {
+ if inspect, err := libarcane.ContainerInspectWithCompatibility(ctx, dockerClient, hostname, client.ContainerInspectOptions{}); err == nil && inspect.Container.Config != nil && strings.TrimSpace(inspect.Container.Config.Image) != "" {
return inspect.Container.Config.Image, "hostname", true
}
}
@@ -440,7 +440,7 @@ func (s *VolumeService) resolveBackupStorageMountInternal(ctx context.Context, d
if dockerClient != nil {
containerID := s.getArcaneContainerIDInternal(ctx, dockerClient)
if containerID != "" {
- inspect, err := dockerClient.ContainerInspect(ctx, containerID, client.ContainerInspectOptions{})
+ inspect, err := libarcane.ContainerInspectWithCompatibility(ctx, dockerClient, containerID, client.ContainerInspectOptions{})
if err != nil {
slog.WarnContext(ctx, "volume service: failed to inspect arcane container for backup mount resolution, falling back to named volume", "container_id", containerID, "error", err.Error())
} else if resolved, ok := resolveBackupStorageMountFromMountsInternal(inspect.Container.Mounts, target, readOnly); ok {
@@ -510,7 +510,7 @@ func (s *VolumeService) BackupMountWarning(ctx context.Context) string {
return ""
}
- inspect, err := dockerClient.ContainerInspect(ctx, containerID, client.ContainerInspectOptions{})
+ inspect, err := libarcane.ContainerInspectWithCompatibility(ctx, dockerClient, containerID, client.ContainerInspectOptions{})
if err != nil {
return ""
}
@@ -521,7 +521,7 @@ func (s *VolumeService) BackupMountWarning(ctx context.Context) string {
func (s *VolumeService) getArcaneContainerIDInternal(ctx context.Context, dockerClient *client.Client) string {
hostname, _ := os.Hostname()
if hostname != "" {
- if inspect, err := dockerClient.ContainerInspect(ctx, hostname, client.ContainerInspectOptions{}); err == nil {
+ if inspect, err := libarcane.ContainerInspectWithCompatibility(ctx, dockerClient, hostname, client.ContainerInspectOptions{}); err == nil {
return inspect.Container.ID
}
}
@@ -737,7 +737,7 @@ func (s *VolumeService) getReusableReadOnlyContainerInternal(ctx context.Context
return "", false
}
- inspect, err := dockerClient.ContainerInspect(ctx, containerID, client.ContainerInspectOptions{})
+ inspect, err := libarcane.ContainerInspectWithCompatibility(ctx, dockerClient, containerID, client.ContainerInspectOptions{})
if err != nil || inspect.Container.State == nil || !inspect.Container.State.Running {
s.helperMu.Lock()
delete(s.helperByVolume, volumeName)
diff --git a/backend/internal/utils/arcaneupdater/sorter.go b/backend/internal/utils/arcaneupdater/sorter.go
index d61de3174..cb19f34be 100644
--- a/backend/internal/utils/arcaneupdater/sorter.go
+++ b/backend/internal/utils/arcaneupdater/sorter.go
@@ -185,28 +185,34 @@ func UpdateImplicitRestart(containers []ContainerWithDeps, markedForRestart map[
}
// Check if any dependency is marked for restart
- allDeps := make([]string, 0, len(c.Links)+len(c.DependsOn)+len(c.NetworkDeps))
- allDeps = append(allDeps, c.Links...)
- allDeps = append(allDeps, c.DependsOn...)
- allDeps = append(allDeps, c.NetworkDeps...)
-
- for _, dep := range allDeps {
- if markedForRestart[dep] {
- // This container's dependency is restarting, so it needs to restart too
- markedForRestart[c.Name] = true
- if containers[i].Container.Labels == nil {
- containers[i].Container.Labels = map[string]string{}
- }
- containers[i].Container.Labels["_arcane_implicit_restart"] = "true"
- implicitRestarts = append(implicitRestarts, c.Name)
- break
- }
+ if !hasMarkedDependencyInternal(markedForRestart, c.Links) &&
+ !hasMarkedDependencyInternal(markedForRestart, c.DependsOn) &&
+ !hasMarkedDependencyInternal(markedForRestart, c.NetworkDeps) {
+ continue
}
+
+ // This container's dependency is restarting, so it needs to restart too
+ markedForRestart[c.Name] = true
+ if containers[i].Container.Labels == nil {
+ containers[i].Container.Labels = map[string]string{}
+ }
+ containers[i].Container.Labels["_arcane_implicit_restart"] = "true"
+ implicitRestarts = append(implicitRestarts, c.Name)
}
return implicitRestarts
}
+func hasMarkedDependencyInternal(markedForRestart map[string]bool, deps []string) bool {
+ for _, dep := range deps {
+ if markedForRestart[dep] {
+ return true
+ }
+ }
+
+ return false
+}
+
// ExtractContainerName extracts a clean container name from the summary
func ExtractContainerName(cnt container.Summary) string {
if len(cnt.Names) > 0 {
diff --git a/backend/internal/utils/docker/mount_utils.go b/backend/internal/utils/docker/mount_utils.go
index 1e5a5aedd..8aecda7c4 100644
--- a/backend/internal/utils/docker/mount_utils.go
+++ b/backend/internal/utils/docker/mount_utils.go
@@ -6,6 +6,7 @@ import (
"strings"
"github.com/getarcaneapp/arcane/backend/internal/utils/pathmapper"
+ "github.com/getarcaneapp/arcane/backend/pkg/libarcane"
containertypes "github.com/moby/moby/api/types/container"
mounttypes "github.com/moby/moby/api/types/mount"
"github.com/moby/moby/client"
@@ -26,7 +27,7 @@ func GetHostPathForContainerPath(ctx context.Context, dockerCli *client.Client,
}
// 2. Inspect self
- inspect, err := dockerCli.ContainerInspect(ctx, hostname, client.ContainerInspectOptions{})
+ inspect, err := libarcane.ContainerInspectWithCompatibility(ctx, dockerCli, hostname, client.ContainerInspectOptions{})
if err != nil {
// Not running in a container or can't reach docker daemon
return "", err
diff --git a/backend/pkg/libarcane/inspect_compat.go b/backend/pkg/libarcane/inspect_compat.go
new file mode 100644
index 000000000..6eb64252e
--- /dev/null
+++ b/backend/pkg/libarcane/inspect_compat.go
@@ -0,0 +1,460 @@
+package libarcane
+
+import (
+ "bufio"
+ "context"
+ "encoding/json"
+ "fmt"
+ "io"
+ "net/http"
+ "net/netip"
+ "net/url"
+ "path"
+ "strconv"
+ "strings"
+
+ containertypes "github.com/moby/moby/api/types/container"
+ networktypes "github.com/moby/moby/api/types/network"
+ "github.com/moby/moby/client"
+)
+
+// WrapDockerAPIClientForInspectCompatibility wraps a Docker API client so
+// inspect calls can recover from daemon responses that encode address fields
+// with CIDR suffixes that newer typed Moby structs reject.
+func WrapDockerAPIClientForInspectCompatibility(apiClient client.APIClient) client.APIClient {
+ if apiClient == nil {
+ return nil
+ }
+ if _, ok := apiClient.(*inspectCompatibilityClient); ok {
+ return apiClient
+ }
+ return &inspectCompatibilityClient{APIClient: apiClient}
+}
+
+type inspectCompatibilityClient struct {
+ client.APIClient
+}
+
+func (c *inspectCompatibilityClient) ContainerInspect(ctx context.Context, containerID string, options client.ContainerInspectOptions) (client.ContainerInspectResult, error) {
+ return ContainerInspectWithCompatibility(ctx, c.APIClient, containerID, options)
+}
+
+func (c *inspectCompatibilityClient) NetworkInspect(ctx context.Context, networkID string, options client.NetworkInspectOptions) (client.NetworkInspectResult, error) {
+ return NetworkInspectWithCompatibility(ctx, c.APIClient, networkID, options)
+}
+
+// ContainerInspectWithCompatibility retries inspect decoding against raw daemon
+// JSON when the primary typed decode fails on a ParseAddr-style CIDR issue.
+func ContainerInspectWithCompatibility(ctx context.Context, apiClient client.APIClient, containerID string, options client.ContainerInspectOptions) (client.ContainerInspectResult, error) {
+ if apiClient == nil {
+ return client.ContainerInspectResult{}, fmt.Errorf("docker api client is nil")
+ }
+
+ result, err := apiClient.ContainerInspect(ctx, containerID, options)
+ if err == nil || !isInspectAddressParseErrorInternal(err) {
+ return result, err
+ }
+
+ query := url.Values{}
+ if options.Size {
+ query.Set("size", "1")
+ }
+
+ raw, fetchErr := fetchDockerAPIJSONInternal(ctx, apiClient, "/containers/"+strings.TrimSpace(containerID)+"/json", query)
+ if fetchErr != nil {
+ return client.ContainerInspectResult{}, err
+ }
+
+ normalized, changed, normalizeContainerInspectRawJSONInternalErr := normalizeContainerInspectRawJSONInternal(raw)
+ if normalizeContainerInspectRawJSONInternalErr != nil || !changed {
+ return client.ContainerInspectResult{}, err
+ }
+
+ var repaired containertypes.InspectResponse
+ if unmarshalErr := json.Unmarshal(normalized, &repaired); unmarshalErr != nil {
+ return client.ContainerInspectResult{}, err
+ }
+
+ return client.ContainerInspectResult{
+ Container: repaired,
+ Raw: normalized,
+ }, nil
+}
+
+// NetworkInspectWithCompatibility retries inspect decoding against raw daemon
+// JSON when the primary typed decode fails on a ParseAddr-style CIDR issue.
+func NetworkInspectWithCompatibility(ctx context.Context, apiClient client.APIClient, networkID string, options client.NetworkInspectOptions) (client.NetworkInspectResult, error) {
+ if apiClient == nil {
+ return client.NetworkInspectResult{}, fmt.Errorf("docker api client is nil")
+ }
+
+ result, err := apiClient.NetworkInspect(ctx, networkID, options)
+ if err == nil || !isInspectAddressParseErrorInternal(err) {
+ return result, err
+ }
+
+ query := url.Values{}
+ if options.Verbose {
+ query.Set("verbose", "true")
+ }
+ if scope := strings.TrimSpace(options.Scope); scope != "" {
+ query.Set("scope", scope)
+ }
+
+ raw, fetchErr := fetchDockerAPIJSONInternal(ctx, apiClient, "/networks/"+strings.TrimSpace(networkID), query)
+ if fetchErr != nil {
+ return client.NetworkInspectResult{}, err
+ }
+
+ normalized, changed, normalizeNetworkInspectRawJSONInternalErr := normalizeNetworkInspectRawJSONInternal(raw)
+ if normalizeNetworkInspectRawJSONInternalErr != nil || !changed {
+ return client.NetworkInspectResult{}, err
+ }
+
+ var repaired networktypes.Inspect
+ if unmarshalErr := json.Unmarshal(normalized, &repaired); unmarshalErr != nil {
+ return client.NetworkInspectResult{}, err
+ }
+
+ return client.NetworkInspectResult{
+ Network: repaired,
+ Raw: normalized,
+ }, nil
+}
+
+func fetchDockerAPIJSONInternal(ctx context.Context, apiClient client.APIClient, resourcePath string, query url.Values) ([]byte, error) {
+ dialer := apiClient.Dialer()
+ if dialer == nil {
+ return nil, fmt.Errorf("docker api client does not expose a dialer")
+ }
+
+ reqURL := &url.URL{
+ Scheme: "http",
+ Host: client.DummyHost,
+ Path: buildDockerAPIPathInternal(apiClient.ClientVersion(), resourcePath),
+ RawQuery: query.Encode(),
+ }
+ req, err := http.NewRequestWithContext(ctx, http.MethodGet, reqURL.String(), http.NoBody)
+ if err != nil {
+ return nil, err
+ }
+
+ // The official Moby client uses a TLS-aware dialer here when the daemon is
+ // configured with client certificates, so this fallback continues to work
+ // for remote tcp+TLS and local socket transports without reimplementing the
+ // client's private request machinery.
+ conn, err := dialer(ctx)
+ if err != nil {
+ return nil, err
+ }
+ defer func() { _ = conn.Close() }()
+
+ if err := req.Write(conn); err != nil {
+ return nil, err
+ }
+
+ resp, err := http.ReadResponse(bufio.NewReader(conn), req)
+ if err != nil {
+ return nil, err
+ }
+ defer func() { _ = resp.Body.Close() }()
+
+ body, err := io.ReadAll(resp.Body)
+ if err != nil {
+ return nil, err
+ }
+ if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+ return nil, fmt.Errorf("docker api GET %s failed with %s: %s", resourcePath, resp.Status, strings.TrimSpace(string(body)))
+ }
+
+ return body, nil
+}
+
+func buildDockerAPIPathInternal(version, resourcePath string) string {
+ if trimmedVersion := strings.TrimSpace(strings.TrimPrefix(version, "v")); trimmedVersion != "" {
+ return path.Join("/v"+trimmedVersion, resourcePath)
+ }
+ return path.Join("/", resourcePath)
+}
+
+func normalizeContainerInspectRawJSONInternal(raw []byte) ([]byte, bool, error) {
+ payload := map[string]any{}
+ if err := json.Unmarshal(raw, &payload); err != nil {
+ return nil, false, err
+ }
+
+ changed := false
+
+ networkSettings, ok := asMapInternal(payload["NetworkSettings"])
+ if ok {
+ changed = normalizeAddressStringFieldInternal(networkSettings, "Gateway") || changed
+ changed = normalizeAddressStringFieldInternal(networkSettings, "IPv6Gateway") || changed
+ changed = normalizeAddressWithPrefixFieldInternal(networkSettings, "IPAddress", "IPPrefixLen") || changed
+ changed = normalizeAddressWithPrefixFieldInternal(networkSettings, "GlobalIPv6Address", "GlobalIPv6PrefixLen") || changed
+
+ if networks, ok := asMapInternal(networkSettings["Networks"]); ok {
+ for _, endpointAny := range networks {
+ endpoint, ok := asMapInternal(endpointAny)
+ if !ok {
+ continue
+ }
+
+ changed = normalizeAddressStringFieldInternal(endpoint, "Gateway") || changed
+ changed = normalizeAddressStringFieldInternal(endpoint, "IPv6Gateway") || changed
+ changed = normalizeAddressWithPrefixFieldInternal(endpoint, "IPAddress", "IPPrefixLen") || changed
+ changed = normalizeAddressWithPrefixFieldInternal(endpoint, "GlobalIPv6Address", "GlobalIPv6PrefixLen") || changed
+
+ if ipam, ok := asMapInternal(endpoint["IPAMConfig"]); ok {
+ changed = normalizeAddressStringFieldInternal(ipam, "IPv4Address") || changed
+ changed = normalizeAddressStringFieldInternal(ipam, "IPv6Address") || changed
+ changed = normalizeAddressStringSliceFieldInternal(ipam, "LinkLocalIPs") || changed
+ }
+ }
+ }
+ }
+
+ if !changed {
+ return raw, false, nil
+ }
+
+ normalized, err := json.Marshal(payload)
+ if err != nil {
+ return nil, false, err
+ }
+ return normalized, true, nil
+}
+
+func normalizeNetworkInspectRawJSONInternal(raw []byte) ([]byte, bool, error) {
+ payload := map[string]any{}
+ if err := json.Unmarshal(raw, &payload); err != nil {
+ return nil, false, err
+ }
+
+ changed := false
+ if ipam, ok := asMapInternal(payload["IPAM"]); ok {
+ if configs, ok := asSliceInternal(ipam["Config"]); ok {
+ for _, configAny := range configs {
+ config, ok := asMapInternal(configAny)
+ if !ok {
+ continue
+ }
+
+ changed = normalizeAddressStringFieldInternal(config, "Gateway") || changed
+ changed = normalizeAuxiliaryAddressesInternal(config, "AuxiliaryAddresses") || changed
+ changed = normalizeAuxiliaryAddressesInternal(config, "AuxAddress") || changed
+ }
+ }
+ }
+ if containers, ok := asMapInternal(payload["Containers"]); ok {
+ for _, endpointAny := range containers {
+ endpoint, ok := asMapInternal(endpointAny)
+ if !ok {
+ continue
+ }
+
+ changed = normalizePrefixStringFieldInternal(endpoint, "IPv4Address") || changed
+ changed = normalizePrefixStringFieldInternal(endpoint, "IPv6Address") || changed
+ }
+ }
+
+ if !changed {
+ return raw, false, nil
+ }
+
+ normalized, err := json.Marshal(payload)
+ if err != nil {
+ return nil, false, err
+ }
+ return normalized, true, nil
+}
+
+func normalizeAddressStringFieldInternal(obj map[string]any, key string) bool {
+ raw, ok := obj[key].(string)
+ if !ok {
+ return false
+ }
+
+ normalized, changed := normalizeAddressStringInternal(raw)
+ if !changed {
+ return false
+ }
+
+ obj[key] = normalized
+ return true
+}
+
+func normalizeAddressWithPrefixFieldInternal(obj map[string]any, addrKey, prefixLenKey string) bool {
+ raw, ok := obj[addrKey].(string)
+ if !ok {
+ return false
+ }
+
+ trimmed := strings.TrimSpace(raw)
+ if trimmed == "" {
+ return false
+ }
+ if _, err := netip.ParseAddr(trimmed); err == nil {
+ if raw == trimmed {
+ return false
+ }
+ obj[addrKey] = trimmed
+ return true
+ }
+
+ prefix, err := netip.ParsePrefix(trimmed)
+ if err != nil {
+ return false
+ }
+
+ changed := false
+ addrValue := prefix.Addr().String()
+ if raw != addrValue {
+ obj[addrKey] = addrValue
+ changed = true
+ }
+
+ if prefixLenMissingInternal(obj[prefixLenKey]) {
+ obj[prefixLenKey] = prefix.Bits()
+ changed = true
+ }
+
+ return changed
+}
+
+func normalizeAddressStringSliceFieldInternal(obj map[string]any, key string) bool {
+ values, ok := asSliceInternal(obj[key])
+ if !ok {
+ return false
+ }
+
+ changed := false
+ for i, value := range values {
+ raw, ok := value.(string)
+ if !ok {
+ continue
+ }
+ normalized, fieldChanged := normalizeAddressStringInternal(raw)
+ if !fieldChanged {
+ continue
+ }
+ values[i] = normalized
+ changed = true
+ }
+
+ if changed {
+ obj[key] = values
+ }
+ return changed
+}
+
+func normalizeAuxiliaryAddressesInternal(obj map[string]any, key string) bool {
+ auxMap, ok := asMapInternal(obj[key])
+ if !ok {
+ return false
+ }
+
+ changed := false
+ for auxKey, auxValue := range auxMap {
+ raw, ok := auxValue.(string)
+ if !ok {
+ continue
+ }
+ normalized, fieldChanged := normalizeAddressStringInternal(raw)
+ if !fieldChanged {
+ continue
+ }
+ auxMap[auxKey] = normalized
+ changed = true
+ }
+
+ if changed {
+ obj[key] = auxMap
+ }
+ return changed
+}
+
+func normalizePrefixStringFieldInternal(obj map[string]any, key string) bool {
+ raw, ok := obj[key].(string)
+ if !ok {
+ return false
+ }
+
+ trimmed := strings.TrimSpace(raw)
+ if trimmed == "" {
+ return false
+ }
+
+ prefix, err := netip.ParsePrefix(trimmed)
+ if err != nil {
+ return false
+ }
+
+ normalized := prefix.String()
+ if normalized == raw {
+ return false
+ }
+
+ obj[key] = normalized
+ return true
+}
+
+func normalizeAddressStringInternal(raw string) (string, bool) {
+ trimmed := strings.TrimSpace(raw)
+ if trimmed == "" {
+ return raw, false
+ }
+ if _, err := netip.ParseAddr(trimmed); err == nil {
+ return trimmed, trimmed != raw
+ }
+
+ prefix, err := netip.ParsePrefix(trimmed)
+ if err != nil {
+ return raw, false
+ }
+
+ normalized := prefix.Addr().String()
+ return normalized, normalized != raw
+}
+
+func prefixLenMissingInternal(value any) bool {
+ switch v := value.(type) {
+ case nil:
+ return true
+ case float64:
+ return v == 0
+ case int:
+ return v == 0
+ case int32:
+ return v == 0
+ case int64:
+ return v == 0
+ case string:
+ trimmed := strings.TrimSpace(v)
+ if trimmed == "" {
+ return true
+ }
+ parsed, err := strconv.Atoi(trimmed)
+ return err != nil || parsed == 0
+ default:
+ return false
+ }
+}
+
+func asMapInternal(value any) (map[string]any, bool) {
+ out, ok := value.(map[string]any)
+ return out, ok
+}
+
+func asSliceInternal(value any) ([]any, bool) {
+ out, ok := value.([]any)
+ return out, ok
+}
+
+func isInspectAddressParseErrorInternal(err error) bool {
+ if err == nil {
+ return false
+ }
+
+ msg := err.Error()
+ return strings.Contains(msg, "ParseAddr(") || strings.Contains(msg, "ParsePrefix(")
+}
diff --git a/backend/pkg/libarcane/inspect_compat_test.go b/backend/pkg/libarcane/inspect_compat_test.go
new file mode 100644
index 000000000..ac781e0e5
--- /dev/null
+++ b/backend/pkg/libarcane/inspect_compat_test.go
@@ -0,0 +1,340 @@
+package libarcane
+
+import (
+ "context"
+ "encoding/json"
+ "net/http"
+ "net/http/httptest"
+ "net/netip"
+ "strings"
+ "testing"
+
+ containertypes "github.com/moby/moby/api/types/container"
+ networktypes "github.com/moby/moby/api/types/network"
+ "github.com/moby/moby/client"
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
+)
+
+func TestNormalizeContainerInspectRawJSONInternal(t *testing.T) {
+ raw := []byte(`{
+ "Id":"abc123",
+ "Name":"/app",
+ "Config":{"Image":"test:latest"},
+ "HostConfig":{"NetworkMode":"bridge"},
+ "NetworkSettings":{
+ "Networks":{
+ "bridge":{
+ "IPAMConfig":{
+ "IPv4Address":"172.18.0.50/16",
+ "IPv6Address":"fdd0:0:0:c::10/64",
+ "LinkLocalIPs":["169.254.10.10/16","fe80::10/64"]
+ },
+ "Gateway":"172.18.0.1/16",
+ "IPAddress":"172.18.0.20/16",
+ "IPPrefixLen":0,
+ "IPv6Gateway":"fdd0:0:0:c::1/64",
+ "GlobalIPv6Address":"fdd0:0:0:c::10/64",
+ "GlobalIPv6PrefixLen":0
+ }
+ }
+ }
+ }`)
+
+ normalized, changed, err := normalizeContainerInspectRawJSONInternal(raw)
+ require.NoError(t, err)
+ require.True(t, changed)
+
+ var inspect containertypes.InspectResponse
+ require.NoError(t, json.Unmarshal(normalized, &inspect))
+
+ endpoint := inspect.NetworkSettings.Networks["bridge"]
+ require.NotNil(t, endpoint)
+ require.NotNil(t, endpoint.IPAMConfig)
+ assert.Equal(t, netip.MustParseAddr("172.18.0.1"), endpoint.Gateway)
+ assert.Equal(t, netip.MustParseAddr("172.18.0.20"), endpoint.IPAddress)
+ assert.Equal(t, 16, endpoint.IPPrefixLen)
+ assert.Equal(t, netip.MustParseAddr("fdd0:0:0:c::1"), endpoint.IPv6Gateway)
+ assert.Equal(t, netip.MustParseAddr("fdd0:0:0:c::10"), endpoint.GlobalIPv6Address)
+ assert.Equal(t, 64, endpoint.GlobalIPv6PrefixLen)
+ assert.Equal(t, netip.MustParseAddr("172.18.0.50"), endpoint.IPAMConfig.IPv4Address)
+ assert.Equal(t, netip.MustParseAddr("fdd0:0:0:c::10"), endpoint.IPAMConfig.IPv6Address)
+ assert.Equal(t, []netip.Addr{
+ netip.MustParseAddr("169.254.10.10"),
+ netip.MustParseAddr("fe80::10"),
+ }, endpoint.IPAMConfig.LinkLocalIPs)
+}
+
+func TestNormalizeContainerInspectRawJSONInternal_NormalizesTopLevelNetworkSettings(t *testing.T) {
+ raw := []byte(`{
+ "Id":"abc123",
+ "Name":"/app",
+ "Config":{"Image":"test:latest"},
+ "HostConfig":{"NetworkMode":"bridge"},
+ "NetworkSettings":{
+ "Gateway":"172.18.0.1/16",
+ "IPAddress":"172.18.0.20/16",
+ "IPPrefixLen":0,
+ "IPv6Gateway":"fdd0:0:0:c::1/64",
+ "GlobalIPv6Address":"fdd0:0:0:c::10/64",
+ "GlobalIPv6PrefixLen":0,
+ "Networks":{}
+ }
+ }`)
+
+ normalized, changed, err := normalizeContainerInspectRawJSONInternal(raw)
+ require.NoError(t, err)
+ require.True(t, changed)
+
+ payload := map[string]any{}
+ require.NoError(t, json.Unmarshal(normalized, &payload))
+
+ networkSettings, ok := asMapInternal(payload["NetworkSettings"])
+ require.True(t, ok)
+ assert.Equal(t, "172.18.0.1", networkSettings["Gateway"])
+ assert.Equal(t, "172.18.0.20", networkSettings["IPAddress"])
+ assert.Equal(t, float64(16), networkSettings["IPPrefixLen"])
+ assert.Equal(t, "fdd0:0:0:c::1", networkSettings["IPv6Gateway"])
+ assert.Equal(t, "fdd0:0:0:c::10", networkSettings["GlobalIPv6Address"])
+ assert.Equal(t, float64(64), networkSettings["GlobalIPv6PrefixLen"])
+}
+
+func TestNormalizeNetworkInspectRawJSONInternal(t *testing.T) {
+ raw := []byte(`{
+ "Name":"test-net",
+ "Id":"net123",
+ "Created":"2026-03-11T00:00:00Z",
+ "Scope":"local",
+ "Driver":"bridge",
+ "EnableIPv6":true,
+ "IPAM":{
+ "Driver":"default",
+ "Config":[
+ {
+ "Subnet":"fdd0:0:0:c::/64",
+ "Gateway":"fdd0:0:0:c::1/64",
+ "AuxiliaryAddresses":{
+ "router":"fdd0:0:0:c::2/64"
+ }
+ }
+ ]
+ },
+ "Containers":{}
+ }`)
+
+ normalized, changed, err := normalizeNetworkInspectRawJSONInternal(raw)
+ require.NoError(t, err)
+ require.True(t, changed)
+
+ var inspect networktypes.Inspect
+ require.NoError(t, json.Unmarshal(normalized, &inspect))
+ require.Len(t, inspect.IPAM.Config, 1)
+ assert.Equal(t, netip.MustParsePrefix("fdd0:0:0:c::/64"), inspect.IPAM.Config[0].Subnet)
+ assert.Equal(t, netip.MustParseAddr("fdd0:0:0:c::1"), inspect.IPAM.Config[0].Gateway)
+ assert.Equal(t, netip.MustParseAddr("fdd0:0:0:c::2"), inspect.IPAM.Config[0].AuxAddress["router"])
+}
+
+func TestNormalizeNetworkInspectRawJSONInternal_NormalizesContainerEndpoints(t *testing.T) {
+ raw := []byte(`{
+ "Name":"test-net",
+ "Id":"net123",
+ "Created":"2026-03-11T00:00:00Z",
+ "Scope":"local",
+ "Driver":"bridge",
+ "IPAM":{"Driver":"default","Config":[]},
+ "Containers":{
+ "abc123":{
+ "Name":"app",
+ "EndpointID":"ep1",
+ "IPv4Address":" 172.18.0.20/16 ",
+ "IPv6Address":" fdd0:0:0:c::10/64 "
+ }
+ }
+ }`)
+
+ normalized, changed, err := normalizeNetworkInspectRawJSONInternal(raw)
+ require.NoError(t, err)
+ require.True(t, changed)
+
+ var inspect networktypes.Inspect
+ require.NoError(t, json.Unmarshal(normalized, &inspect))
+ endpoint := inspect.Containers["abc123"]
+ assert.Equal(t, netip.MustParsePrefix("172.18.0.20/16"), endpoint.IPv4Address)
+ assert.Equal(t, netip.MustParsePrefix("fdd0:0:0:c::10/64"), endpoint.IPv6Address)
+}
+
+func TestNormalizeAddressStringInternal_TrimsWhitespaceAroundValidAddress(t *testing.T) {
+ normalized, changed := normalizeAddressStringInternal(" 172.18.0.1 ")
+ assert.True(t, changed)
+ assert.Equal(t, "172.18.0.1", normalized)
+}
+
+func TestNormalizeAddressWithPrefixFieldInternal_TrimsWhitespaceAroundValidAddress(t *testing.T) {
+ obj := map[string]any{
+ "IPAddress": " 172.18.0.20 ",
+ "IPPrefixLen": 24,
+ }
+
+ changed := normalizeAddressWithPrefixFieldInternal(obj, "IPAddress", "IPPrefixLen")
+ assert.True(t, changed)
+ assert.Equal(t, "172.18.0.20", obj["IPAddress"])
+ assert.Equal(t, 24, obj["IPPrefixLen"])
+}
+
+func TestIsInspectAddressParseErrorInternal_MatchesPrefixErrors(t *testing.T) {
+ _, err := netip.ParsePrefix(" 172.18.0.20/16 ")
+ assert.True(t, isInspectAddressParseErrorInternal(err))
+}
+
+func TestContainerInspectWithCompatibility(t *testing.T) {
+ containerJSON := `{
+ "Id":"abc123",
+ "Name":"/app",
+ "Config":{"Image":"test:latest"},
+ "HostConfig":{"NetworkMode":"bridge"},
+ "NetworkSettings":{
+ "Networks":{
+ "bridge":{
+ "IPAMConfig":{"IPv6Address":"fdd0:0:0:c::10/64"},
+ "IPv6Gateway":"fdd0:0:0:c::1/64",
+ "GlobalIPv6Address":"fdd0:0:0:c::10/64",
+ "GlobalIPv6PrefixLen":0
+ }
+ }
+ }
+ }`
+
+ dockerClient := newTestDockerClient(t, func(w http.ResponseWriter, r *http.Request) {
+ assert.Equal(t, "/v1.41/containers/test-container/json", r.URL.Path)
+ _, _ = w.Write([]byte(containerJSON))
+ })
+
+ result, err := ContainerInspectWithCompatibility(context.Background(), dockerClient, "test-container", client.ContainerInspectOptions{})
+ require.NoError(t, err)
+ assert.Equal(t, "abc123", result.Container.ID)
+ endpoint := result.Container.NetworkSettings.Networks["bridge"]
+ require.NotNil(t, endpoint)
+ assert.Equal(t, netip.MustParseAddr("fdd0:0:0:c::1"), endpoint.IPv6Gateway)
+ assert.Equal(t, netip.MustParseAddr("fdd0:0:0:c::10"), endpoint.GlobalIPv6Address)
+ assert.Equal(t, 64, endpoint.GlobalIPv6PrefixLen)
+}
+
+func TestNetworkInspectWithCompatibility(t *testing.T) {
+ networkJSON := `{
+ "Name":"test-net",
+ "Id":"net123",
+ "Created":"2026-03-11T00:00:00Z",
+ "Scope":"local",
+ "Driver":"bridge",
+ "IPAM":{
+ "Driver":"default",
+ "Config":[
+ {
+ "Subnet":"fdd0:0:0:c::/64",
+ "Gateway":"fdd0:0:0:c::1/64"
+ }
+ ]
+ },
+ "Containers":{}
+ }`
+
+ dockerClient := newTestDockerClient(t, func(w http.ResponseWriter, r *http.Request) {
+ assert.Equal(t, "/v1.41/networks/test-net", r.URL.Path)
+ _, _ = w.Write([]byte(networkJSON))
+ })
+
+ result, err := NetworkInspectWithCompatibility(context.Background(), dockerClient, "test-net", client.NetworkInspectOptions{})
+ require.NoError(t, err)
+ require.Len(t, result.Network.IPAM.Config, 1)
+ assert.Equal(t, netip.MustParseAddr("fdd0:0:0:c::1"), result.Network.IPAM.Config[0].Gateway)
+}
+
+func TestContainerInspectWithCompatibility_TLSRemote(t *testing.T) {
+ containerJSON := `{
+ "Id":"abc123",
+ "Name":"/app",
+ "Config":{"Image":"test:latest"},
+ "HostConfig":{"NetworkMode":"bridge"},
+ "NetworkSettings":{
+ "Networks":{
+ "bridge":{
+ "IPv6Gateway":"fdd0:0:0:c::1/64"
+ }
+ }
+ }
+ }`
+
+ server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ assert.Equal(t, "/v1.41/containers/test-container/json", r.URL.Path)
+ _, _ = w.Write([]byte(containerJSON))
+ }))
+ defer server.Close()
+
+ dockerClient, err := client.New(
+ client.WithHTTPClient(server.Client()),
+ client.WithHost("tcp://"+strings.TrimPrefix(server.URL, "https://")),
+ client.WithScheme("https"),
+ client.WithAPIVersion("1.41"),
+ )
+ require.NoError(t, err)
+ defer func() {
+ _ = dockerClient.Close()
+ }()
+
+ result, err := ContainerInspectWithCompatibility(context.Background(), dockerClient, "test-container", client.ContainerInspectOptions{})
+ require.NoError(t, err)
+ assert.Equal(t, netip.MustParseAddr("fdd0:0:0:c::1"), result.Container.NetworkSettings.Networks["bridge"].IPv6Gateway)
+}
+
+func TestInspectCompatibilityLeavesInvalidValuesFailing(t *testing.T) {
+ dockerClient := newTestDockerClient(t, func(w http.ResponseWriter, r *http.Request) {
+ _, _ = w.Write([]byte(`{
+ "Name":"test-net",
+ "Id":"net123",
+ "Created":"2026-03-11T00:00:00Z",
+ "Scope":"local",
+ "Driver":"bridge",
+ "IPAM":{"Driver":"default","Config":[{"Subnet":"fdd0:0:0:c::/64","Gateway":"definitely-not-an-ip"}]},
+ "Containers":{}
+ }`))
+ })
+
+ _, err := NetworkInspectWithCompatibility(context.Background(), dockerClient, "test-net", client.NetworkInspectOptions{})
+ require.Error(t, err)
+ assert.True(t, strings.Contains(err.Error(), `ParseAddr("definitely-not-an-ip")`))
+}
+
+func TestWrapDockerAPIClientForInspectCompatibility(t *testing.T) {
+ dockerClient := newTestDockerClient(t, func(w http.ResponseWriter, r *http.Request) {
+ _, _ = w.Write([]byte(`{
+ "Id":"abc123",
+ "Name":"/app",
+ "Config":{"Image":"test:latest"},
+ "HostConfig":{"NetworkMode":"bridge"},
+ "NetworkSettings":{"Networks":{"bridge":{"IPv6Gateway":"fdd0:0:0:c::1/64"}}}
+ }`))
+ })
+
+ wrapped := WrapDockerAPIClientForInspectCompatibility(dockerClient)
+ result, err := wrapped.ContainerInspect(context.Background(), "test-container", client.ContainerInspectOptions{})
+ require.NoError(t, err)
+ assert.Equal(t, netip.MustParseAddr("fdd0:0:0:c::1"), result.Container.NetworkSettings.Networks["bridge"].IPv6Gateway)
+}
+
+func newTestDockerClient(t *testing.T, handler http.HandlerFunc) *client.Client {
+ t.Helper()
+
+ server := httptest.NewServer(handler)
+ t.Cleanup(server.Close)
+
+ dockerClient, err := client.New(
+ client.WithHost("tcp://"+strings.TrimPrefix(server.URL, "http://")),
+ client.WithAPIVersion("1.41"),
+ )
+ require.NoError(t, err)
+ t.Cleanup(func() {
+ _ = dockerClient.Close()
+ })
+
+ return dockerClient
+}
diff --git a/backend/pkg/projects/compose.go b/backend/pkg/projects/compose.go
index af1ecff06..2c915d7f1 100644
--- a/backend/pkg/projects/compose.go
+++ b/backend/pkg/projects/compose.go
@@ -9,6 +9,8 @@ import (
"github.com/docker/cli/cli/flags"
"github.com/docker/compose/v5/pkg/api"
composev2 "github.com/docker/compose/v5/pkg/compose"
+ "github.com/getarcaneapp/arcane/backend/pkg/libarcane"
+ "github.com/moby/moby/client"
)
type Client struct {
@@ -25,14 +27,36 @@ func NewClient(ctx context.Context) (*Client, error) {
if err := cli.Initialize(opts); err != nil {
return nil, err
}
- svc, err := composev2.NewComposeService(cli,
+
+ composeCLI := wrapDockerCLIWithInspectCompatibilityInternal(cli)
+ svc, err := composev2.NewComposeService(composeCLI,
composev2.WithPrompt(composev2.AlwaysOkPrompt()),
)
if err != nil {
return nil, err
}
- return &Client{svc: svc, dockerCli: cli}, nil
+ return &Client{svc: svc, dockerCli: composeCLI}, nil
+}
+
+type inspectCompatibleDockerCli struct {
+ command.Cli
+ apiClient client.APIClient
+}
+
+func (c *inspectCompatibleDockerCli) Client() client.APIClient {
+ return c.apiClient
+}
+
+func wrapDockerCLIWithInspectCompatibilityInternal(cli command.Cli) command.Cli {
+ if cli == nil {
+ return nil
+ }
+
+ return &inspectCompatibleDockerCli{
+ Cli: cli,
+ apiClient: libarcane.WrapDockerAPIClientForInspectCompatibility(cli.Client()),
+ }
}
func (c *Client) Close() error {
diff --git a/backend/pkg/projects/compose_test.go b/backend/pkg/projects/compose_test.go
new file mode 100644
index 000000000..09a860f80
--- /dev/null
+++ b/backend/pkg/projects/compose_test.go
@@ -0,0 +1,30 @@
+package projects
+
+import (
+ "reflect"
+ "testing"
+
+ "github.com/docker/cli/cli/command"
+ "github.com/docker/cli/cli/flags"
+ mobyclient "github.com/moby/moby/client"
+ "github.com/stretchr/testify/require"
+)
+
+func TestWrapDockerCLIWithInspectCompatibility(t *testing.T) {
+ t.Setenv("DOCKER_HOST", "tcp://example.com:2375")
+
+ apiClient, err := mobyclient.New(mobyclient.WithHost("tcp://example.com:2375"))
+ require.NoError(t, err)
+ t.Cleanup(func() {
+ _ = apiClient.Close()
+ })
+
+ baseCLI, err := command.NewDockerCli(command.WithAPIClient(apiClient))
+ require.NoError(t, err)
+ require.NoError(t, baseCLI.Initialize(flags.NewClientOptions()))
+
+ wrapped := wrapDockerCLIWithInspectCompatibilityInternal(baseCLI)
+ require.NotNil(t, wrapped)
+ require.NotSame(t, baseCLI, wrapped)
+ require.NotEqual(t, reflect.TypeOf(apiClient), reflect.TypeOf(wrapped.Client()))
+}
diff --git a/backend/pkg/scheduler/auto_heal_job.go b/backend/pkg/scheduler/auto_heal_job.go
index f2f399f32..05433384c 100644
--- a/backend/pkg/scheduler/auto_heal_job.go
+++ b/backend/pkg/scheduler/auto_heal_job.go
@@ -105,7 +105,7 @@ func (j *AutoHealJob) Run(ctx context.Context) {
}
// Inspect to get health status
- inspect, err := dockerClient.ContainerInspect(ctx, c.ID, client.ContainerInspectOptions{})
+ inspect, err := libarcane.ContainerInspectWithCompatibility(ctx, dockerClient, c.ID, client.ContainerInspectOptions{})
if err != nil {
slog.WarnContext(ctx, "auto-heal failed to inspect container", "container", containerName, "error", err)
continue