Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
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.goindex 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.goindex 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.Treturn "/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 *testinreturn "/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_UnixDockerHostResolutionErrreturn "", 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.goindex 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.Conteinspect, 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.goindex 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.gonew file mode 100644index 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.goindex 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.goindex 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-linerequire.True(t, IsSynologyDockerHost("Synology NAS"))