Skip to content

Modern Docker Management, Designed for Everyone

fix: pick a DOCKER_HOST-reachable network for the self-update upgrader (#3566)

Kyle Mendell4047c00f6326
diff --git a/backend/internal/system/upgrade_service.go b/backend/internal/system/upgrade_service.go
index 30c88e1ed..18b770547 100644
--- a/backend/internal/system/upgrade_service.go
+++ b/backend/internal/system/upgrade_service.go
@@ -223,6 +223,9 @@ func (s *SystemUpgradeService) TriggerUpgradeViaCLI(ctx context.Context, user mo
_, err := cgroup.CurrentContainerID()
return err == nil
},
+ func(ctx context.Context, inspect *container.InspectResponse, dockerHost string) string {
+ return dockerutils.SelectDockerHostReachableNetworkMode(ctx, dockerClient, inspect, dockerHost)
+ },
)
if err != nil {
return "", errors.WrapIf(err, "resolve upgrader docker runtime")
@@ -332,6 +335,7 @@ func resolveSystemUpgraderRuntimeOptionsInternal(
currentContainer *container.InspectResponse,
discoverHostPath func(context.Context, string) (string, error),
isRunningInDocker func() bool,
+ selectReachableNetwork func(context.Context, *container.InspectResponse, string) string,
) (upgraderRuntimeOptionsInternal, error) {
options := upgraderRuntimeOptionsInternal{
ContainerEnv: vuln.BuildDockerHostEnv(dockerHost),
@@ -343,7 +347,13 @@ func resolveSystemUpgraderRuntimeOptionsInternal(
}
if scheme != "unix" {
- options.NetworkMode = container.NetworkMode(vuln.SelectAutoNetworkMode(currentContainer))
+ // The upgrader must reach the tcp DOCKER_HOST, so prefer a network the
+ // daemon proxy is actually on over the plain auto heuristic (#3533).
+ if selectReachableNetwork != nil {
+ options.NetworkMode = container.NetworkMode(selectReachableNetwork(ctx, currentContainer, dockerHost))
+ } else {
+ options.NetworkMode = container.NetworkMode(dockerutils.SelectAutoNetworkMode(currentContainer))
+ }
return options, nil
}
diff --git a/backend/internal/system/upgrade_service_test.go b/backend/internal/system/upgrade_service_test.go
index eda6b3538..549476e57 100644
--- a/backend/internal/system/upgrade_service_test.go
+++ b/backend/internal/system/upgrade_service_test.go
@@ -212,6 +212,7 @@ func TestResolveSystemUpgraderRuntimeOptionsInternal_TCPDockerHost(t *testing.T)
currentContainer,
nil,
func() bool { return true },
+ nil,
)
require.NoError(t, err)
require.Equal(t, []string{"DOCKER_HOST=tcp://docker-socket-proxy:2375"}, options.ContainerEnv)
@@ -228,6 +229,7 @@ func TestResolveSystemUpgraderRuntimeOptionsInternal_UnixDockerHost(t *testing.T
return "/host/run/docker.sock", nil
},
func() bool { return true },
+ nil,
)
require.NoError(t, err)
require.Equal(t, []string{"DOCKER_HOST=unix:///var/run/docker.sock"}, options.ContainerEnv)
@@ -250,6 +252,7 @@ func TestResolveSystemUpgraderRuntimeOptionsInternal_DefaultDockerHost(t *testin
return "/var/run/docker.sock", nil
},
func() bool { return true },
+ nil,
)
require.NoError(t, err)
require.Nil(t, options.ContainerEnv)
@@ -271,6 +274,7 @@ func TestResolveSystemUpgraderRuntimeOptionsInternal_UnixDockerHostResolutionErr
return "", errors.New("inspect failed")
},
func() bool { return true },
+ nil,
)
require.Error(t, err)
require.Contains(t, err.Error(), "resolve unix socket source")
diff --git a/backend/internal/vulnerability/vulnerability_trivy.go b/backend/internal/vulnerability/vulnerability_trivy.go
index e12bef823..251ab531c 100644
--- a/backend/internal/vulnerability/vulnerability_trivy.go
+++ b/backend/internal/vulnerability/vulnerability_trivy.go
@@ -501,7 +501,7 @@ func (s *VulnerabilityService) resolveTrivyNetworkModeInternal(ctx context.Conte
inspect, err := libarcane.InspectCurrentArcaneContainer(ctx, dockerClient)
if err == nil {
- return vuln.SelectAutoNetworkMode(inspect)
+ return dockerutils.SelectAutoNetworkMode(inspect)
}
slog.DebugContext(ctx, "failed to auto-detect Trivy network; falling back to bridge", "error", err)
diff --git a/backend/pkg/dockerutil/network_utils.go b/backend/pkg/dockerutil/network_utils.go
index f7fd9dbc5..df3c82ada 100644
--- a/backend/pkg/dockerutil/network_utils.go
+++ b/backend/pkg/dockerutil/network_utils.go
@@ -1,5 +1,19 @@
package docker
+import (
+ "context"
+ "log/slog"
+ "net/url"
+ "slices"
+ "sort"
+ "strings"
+
+ "github.com/moby/moby/api/types/container"
+ "github.com/moby/moby/client"
+)
+
+const defaultNetworkModeInternal = "bridge"
+
func IsDefaultNetwork(name string) bool {
switch name {
case "bridge", "host", "none", "ingress":
@@ -8,3 +22,117 @@ func IsDefaultNetwork(name string) bool {
return false
}
}
+
+func SelectAutoNetworkMode(inspect *container.InspectResponse) string {
+ if inspect == nil {
+ return defaultNetworkModeInternal
+ }
+
+ if inspect.HostConfig != nil {
+ networkMode := strings.TrimSpace(string(inspect.HostConfig.NetworkMode))
+ if networkMode != "" && networkMode != "default" && networkMode != defaultNetworkModeInternal &&
+ !container.NetworkMode(networkMode).IsContainer() {
+ return networkMode
+ }
+ }
+
+ if inspect.NetworkSettings != nil && len(inspect.NetworkSettings.Networks) > 0 {
+ networkNames := make([]string, 0, len(inspect.NetworkSettings.Networks))
+ for networkName := range inspect.NetworkSettings.Networks {
+ networkName = strings.TrimSpace(networkName)
+ if networkName != "" {
+ networkNames = append(networkNames, networkName)
+ }
+ }
+ sort.Strings(networkNames)
+
+ for _, networkName := range networkNames {
+ if !IsDefaultNetwork(networkName) {
+ return networkName
+ }
+ }
+
+ for _, networkName := range networkNames {
+ if container.NetworkMode(networkName).IsContainer() {
+ continue
+ }
+ if networkName == "host" || networkName == "none" || networkName == defaultNetworkModeInternal {
+ return networkName
+ }
+ }
+ }
+
+ if inspect.HostConfig != nil {
+ networkMode := strings.TrimSpace(string(inspect.HostConfig.NetworkMode))
+ if networkMode != "" && networkMode != "default" && !container.NetworkMode(networkMode).IsContainer() {
+ return networkMode
+ }
+ }
+
+ return defaultNetworkModeInternal
+}
+
+// SelectDockerHostReachableNetworkMode picks the network for a helper container
+// that must reach a tcp DOCKER_HOST (e.g. a docker-socket-proxy). When the
+// DOCKER_HOST hostname matches a running container — by name, compose service,
+// or DNS alias — that shares a network with the current container, that shared
+// network wins. SelectAutoNetworkMode's alphabetical heuristic routinely lands
+// on an unrelated external network on multi-network setups, leaving the helper
+// unable to reach the daemon (#3533).
+func SelectDockerHostReachableNetworkMode(ctx context.Context, dockerClient *client.Client, inspect *container.InspectResponse, dockerHost string) string {
+ fallback := SelectAutoNetworkMode(inspect)
+
+ host := ""
+ if parsed, err := url.Parse(strings.TrimSpace(dockerHost)); err == nil {
+ host = parsed.Hostname()
+ }
+ if host == "" || dockerClient == nil || inspect == nil || inspect.NetworkSettings == nil || len(inspect.NetworkSettings.Networks) == 0 {
+ return fallback
+ }
+
+ list, err := dockerClient.ContainerList(ctx, client.ContainerListOptions{})
+ if err != nil {
+ slog.DebugContext(ctx, "select docker-host network: list failed", "error", err)
+ return fallback
+ }
+
+ shared := make([]string, 0, 2)
+ for _, c := range list.Items {
+ if c.NetworkSettings == nil || !containerAnswersToHostnameInternal(&c, host) {
+ continue
+ }
+ for networkName := range c.NetworkSettings.Networks {
+ if _, ok := inspect.NetworkSettings.Networks[networkName]; ok {
+ shared = append(shared, networkName)
+ }
+ }
+ }
+ if len(shared) == 0 {
+ return fallback
+ }
+ sort.Strings(shared)
+ return shared[0]
+}
+
+// containerAnswersToHostnameInternal reports whether the container is
+// addressable as host on some network: by container name, compose service
+// name, or an endpoint DNS name/alias.
+func containerAnswersToHostnameInternal(c *container.Summary, host string) bool {
+ for _, name := range c.Names {
+ if strings.TrimPrefix(name, "/") == host {
+ return true
+ }
+ }
+ if c.Labels["com.docker.compose.service"] == host {
+ return true
+ }
+ for _, endpoint := range c.NetworkSettings.Networks {
+ if endpoint == nil {
+ continue
+ }
+ if slices.Contains(endpoint.DNSNames, host) || slices.Contains(endpoint.Aliases, host) {
+ return true
+ }
+ }
+ return false
+}
diff --git a/backend/pkg/dockerutil/network_utils_test.go b/backend/pkg/dockerutil/network_utils_test.go
new file mode 100644
index 000000000..620b9b74b
--- /dev/null
+++ b/backend/pkg/dockerutil/network_utils_test.go
@@ -0,0 +1,90 @@
+package docker
+
+import (
+ "context"
+ "net/http"
+ "net/http/httptest"
+ "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/require"
+)
+
+func TestSelectAutoNetworkMode(t *testing.T) {
+ t.Run("prefers explicit host network mode", func(t *testing.T) {
+ mode := SelectAutoNetworkMode(&containertypes.InspectResponse{
+ HostConfig: &containertypes.HostConfig{NetworkMode: "host"},
+ })
+
+ require.Equal(t, "host", mode)
+ })
+
+ t.Run("prefers attached custom network over bridge", func(t *testing.T) {
+ mode := SelectAutoNetworkMode(&containertypes.InspectResponse{
+ HostConfig: &containertypes.HostConfig{NetworkMode: "bridge"},
+ NetworkSettings: &containertypes.NetworkSettings{
+ Networks: map[string]*networktypes.EndpointSettings{
+ "bridge": {},
+ "arcane-internal": {},
+ },
+ },
+ })
+
+ require.Equal(t, "arcane-internal", mode)
+ })
+
+ t.Run("falls back to bridge when no custom network is attached", func(t *testing.T) {
+ mode := SelectAutoNetworkMode(&containertypes.InspectResponse{
+ HostConfig: &containertypes.HostConfig{NetworkMode: "bridge"},
+ NetworkSettings: &containertypes.NetworkSettings{
+ Networks: map[string]*networktypes.EndpointSettings{
+ "bridge": {},
+ },
+ },
+ })
+
+ require.Equal(t, "bridge", mode)
+ })
+}
+
+func TestSelectDockerHostReachableNetworkMode(t *testing.T) {
+ // Server container on an external tunnel network plus a compose-prefixed
+ // socket-proxy network. Plain alphabetical selection picks the tunnel (#3533).
+ inspect := &containertypes.InspectResponse{
+ NetworkSettings: &containertypes.NetworkSettings{
+ Networks: map[string]*networktypes.EndpointSettings{
+ "cloudflare-tunnel": {},
+ "myproj_socket-proxy-net": {},
+ },
+ },
+ }
+
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ w.Header().Set("Content-Type", "application/json")
+ if strings.HasSuffix(r.URL.Path, "/containers/json") {
+ _, _ = w.Write([]byte(`[{"Id":"proxy1","Names":["/myproj-socket-proxy-1"],"Labels":{"com.docker.compose.service":"socket-proxy"},"State":"running","NetworkSettings":{"Networks":{"myproj_socket-proxy-net":{"Aliases":["socket-proxy"]}}}}]`))
+ return
+ }
+ w.WriteHeader(http.StatusOK)
+ }))
+ defer server.Close()
+ dockerClient, err := client.New(
+ client.WithHost("tcp://"+strings.TrimPrefix(server.URL, "http://")),
+ client.WithAPIVersion("1.41"),
+ )
+ require.NoError(t, err)
+ defer func() { _ = dockerClient.Close() }()
+
+ t.Run("prefers shared network with the DOCKER_HOST container", func(t *testing.T) {
+ got := SelectDockerHostReachableNetworkMode(context.Background(), dockerClient, inspect, "tcp://socket-proxy:2375")
+ require.Equal(t, "myproj_socket-proxy-net", got)
+ })
+
+ t.Run("falls back to auto heuristic when nothing matches", func(t *testing.T) {
+ got := SelectDockerHostReachableNetworkMode(context.Background(), dockerClient, inspect, "tcp://unknown-host:2375")
+ require.Equal(t, "cloudflare-tunnel", got)
+ })
+}
diff --git a/backend/pkg/libarcane/vuln/driver.go b/backend/pkg/libarcane/vuln/driver.go
index 84e304d6c..772770e00 100644
--- a/backend/pkg/libarcane/vuln/driver.go
+++ b/backend/pkg/libarcane/vuln/driver.go
@@ -12,7 +12,6 @@ import (
"math"
"os"
"path/filepath"
- "sort"
"strconv"
"strings"
"time"
@@ -84,55 +83,6 @@ func ResolveUnixSocketSource(
return socketPath, nil
}
-func SelectAutoNetworkMode(inspect *containertypes.InspectResponse) string {
- if inspect == nil {
- return DefaultNetworkMode
- }
-
- if inspect.HostConfig != nil {
- networkMode := strings.TrimSpace(string(inspect.HostConfig.NetworkMode))
- if networkMode != "" && networkMode != "default" && networkMode != DefaultNetworkMode &&
- !containertypes.NetworkMode(networkMode).IsContainer() {
- return networkMode
- }
- }
-
- if inspect.NetworkSettings != nil && len(inspect.NetworkSettings.Networks) > 0 {
- networkNames := make([]string, 0, len(inspect.NetworkSettings.Networks))
- for networkName := range inspect.NetworkSettings.Networks {
- networkName = strings.TrimSpace(networkName)
- if networkName != "" {
- networkNames = append(networkNames, networkName)
- }
- }
- sort.Strings(networkNames)
-
- for _, networkName := range networkNames {
- if !dockerutils.IsDefaultNetwork(networkName) {
- return networkName
- }
- }
-
- for _, networkName := range networkNames {
- if containertypes.NetworkMode(networkName).IsContainer() {
- continue
- }
- if networkName == "host" || networkName == "none" || networkName == DefaultNetworkMode {
- return networkName
- }
- }
- }
-
- if inspect.HostConfig != nil {
- networkMode := strings.TrimSpace(string(inspect.HostConfig.NetworkMode))
- if networkMode != "" && networkMode != "default" && !containertypes.NetworkMode(networkMode).IsContainer() {
- return networkMode
- }
- }
-
- return DefaultNetworkMode
-}
-
func NewOutputPath() string {
return outputPathPrefixInternal + strconv.FormatInt(time.Now().UnixNano(), 10) + ".json"
}
diff --git a/backend/pkg/libarcane/vuln/driver_test.go b/backend/pkg/libarcane/vuln/driver_test.go
index 863c1e420..f98ef14a7 100644
--- a/backend/pkg/libarcane/vuln/driver_test.go
+++ b/backend/pkg/libarcane/vuln/driver_test.go
@@ -12,7 +12,6 @@ import (
"emperror.dev/errors"
containertypes "github.com/moby/moby/api/types/container"
mounttypes "github.com/moby/moby/api/types/mount"
- networktypes "github.com/moby/moby/api/types/network"
"github.com/stretchr/testify/require"
"github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane/timeouts"
@@ -432,43 +431,6 @@ func TestResolveTrivyUnixSocketSourceInternal(t *testing.T) {
})
}
-func TestSelectTrivyAutoNetworkModeInternal(t *testing.T) {
- t.Run("prefers explicit host network mode", func(t *testing.T) {
- mode := SelectAutoNetworkMode(&containertypes.InspectResponse{
- HostConfig: &containertypes.HostConfig{NetworkMode: "host"},
- })
-
- require.Equal(t, "host", mode)
- })
-
- t.Run("prefers attached custom network over bridge", func(t *testing.T) {
- mode := SelectAutoNetworkMode(&containertypes.InspectResponse{
- HostConfig: &containertypes.HostConfig{NetworkMode: "bridge"},
- NetworkSettings: &containertypes.NetworkSettings{
- Networks: map[string]*networktypes.EndpointSettings{
- "bridge": {},
- "arcane-internal": {},
- },
- },
- })
-
- require.Equal(t, "arcane-internal", mode)
- })
-
- t.Run("falls back to bridge when no custom network is attached", func(t *testing.T) {
- mode := SelectAutoNetworkMode(&containertypes.InspectResponse{
- HostConfig: &containertypes.HostConfig{NetworkMode: "bridge"},
- NetworkSettings: &containertypes.NetworkSettings{
- Networks: map[string]*networktypes.EndpointSettings{
- "bridge": {},
- },
- },
- })
-
- require.Equal(t, "bridge", mode)
- })
-}
-
func TestIsSynologyDockerHostInternal(t *testing.T) {
// DS220+ (Kernel 4.x): single-line
require.True(t, IsSynologyDockerHost("Synology NAS"))