internal/core: add docker context inspect to host lookup strategies

This fixes the user-facing panic, covers additional tests that should be reported as non-fatal, and most importantly
includes `docker context inxpect` in the docker host resolution strategies.

Fixes #2952

Author: tmc

internal/core/client.go

@@ -2,6 +2,7 @@ package core
 
 import (
 	"context"
+	"fmt"
 	"path/filepath"
 
 	"github.com/docker/docker/client"
@@ -14,7 +15,10 @@ import (
 func NewClient(ctx context.Context, ops ...client.Opt) (*client.Client, error) {
 	tcConfig := config.Read()
 
-	dockerHost := MustExtractDockerHost(ctx)
+	dockerHost, err := ExtractDockerHost(ctx)
+	if err != nil {
+		return nil, fmt.Errorf("extract docker host: %w", err)
+	}
 
 	opts := []client.Opt{client.FromEnv, client.WithAPIVersionNegotiation()}
 	if dockerHost != "" {

internal/core/docker_host.go

@@ -28,6 +28,7 @@ var (
 	ErrSocketNotFoundInPath           = errors.New("docker socket not found in " + DockerSocketPath)
 	// ErrTestcontainersHostNotSetInProperties this error is specific to Testcontainers
 	ErrTestcontainersHostNotSetInProperties = errors.New("tc.host not set in ~/.testcontainers.properties")
+	ErrDockerSocketNotSetInDockerContext    = errors.New("socket not found in docker context")
 )
 
 var (
@@ -73,7 +74,7 @@ var dockerHostCheck = func(ctx context.Context, host string) error {
 	return nil
 }
 
-// MustExtractDockerHost Extracts the docker host from the different alternatives, caching the result to avoid unnecessary
+// MustExtractDockerHost extracts the docker host from the different alternatives, caching the result to avoid unnecessary
 // calculations. Use this function to get the actual Docker host. This function does not consider Windows containers at the moment.
 // The possible alternatives are:
 //
@@ -86,7 +87,7 @@ var dockerHostCheck = func(ctx context.Context, host string) error {
 //  7. Else, because the Docker host is not set, it panics.
 func MustExtractDockerHost(ctx context.Context) string {
 	dockerHostOnce.Do(func() {
-		cache, err := extractDockerHost(ctx)
+		cache, err := ExtractDockerHost(ctx)
 		if err != nil {
 			panic(err)
 		}
@@ -118,13 +119,22 @@ func MustExtractDockerSocket(ctx context.Context) string {
 	return dockerSocketPathCache
 }
 
-// extractDockerHost Extracts the docker host from the different alternatives, without caching the result.
-// This internal method is handy for testing purposes.
-func extractDockerHost(ctx context.Context) (string, error) {
+// ExtractDockerHost Extracts the docker host from the different alternatives, without caching the result.
+// Use this function to get the actual Docker host. This function does not consider Windows containers at the moment.
+// The possible alternatives are:
+//
+//  1. Docker host from the "tc.host" property in the ~/.testcontainers.properties file.
+//  2. DOCKER_HOST environment variable.
+//  3. Docker host from context.
+//  4. Docker host from the default docker socket path, without the unix schema.
+//  5. Docker host from the "docker.host" property in the ~/.testcontainers.properties file.
+//  6. Rootless docker socket path.
+func ExtractDockerHost(ctx context.Context) (string, error) {
 	dockerHostFns := []func(context.Context) (string, error){
 		testcontainersHostFromProperties,
 		dockerHostFromEnv,
 		dockerHostFromContext,
+		dockerHostFromDockerContext,
 		dockerSocketPath,
 		dockerHostFromProperties,
 		rootlessDockerSocketPath,
@@ -149,6 +159,7 @@ func extractDockerHost(ctx context.Context) (string, error) {
 	}
 
 	if len(errs) > 0 {
+		panic(32)
 		return "", errors.Join(errs...)
 	}
 
@@ -212,7 +223,7 @@ func extractDockerSocketFromClient(ctx context.Context, cli client.APIClient) st
 		return DockerSocketPath
 	}
 
-	dockerHost, err := extractDockerHost(ctx)
+	dockerHost, err := ExtractDockerHost(ctx)
 	if err != nil {
 		panic(err) // Docker host is required to get the Docker socket
 	}
@@ -227,12 +238,14 @@ func isHostNotSet(err error) bool {
 	case errors.Is(err, ErrTestcontainersHostNotSetInProperties),
 		errors.Is(err, ErrDockerHostNotSet),
 		errors.Is(err, ErrDockerSocketNotSetInContext),
+		errors.Is(err, ErrDockerSocketNotSetInDockerContext),
 		errors.Is(err, ErrDockerSocketNotSetInProperties),
 		errors.Is(err, ErrSocketNotFoundInPath),
 		errors.Is(err, ErrXDGRuntimeDirNotSet),
 		errors.Is(err, ErrRootlessDockerNotFoundHomeRunDir),
 		errors.Is(err, ErrRootlessDockerNotFoundHomeDesktopDir),
-		errors.Is(err, ErrRootlessDockerNotFoundRunDir):
+		errors.Is(err, ErrRootlessDockerNotFoundRunDir),
+		errors.Is(err, ErrRootlessDockerNotFound):
 		return true
 	default:
 		return false
@@ -262,6 +275,17 @@ func dockerHostFromContext(ctx context.Context) (string, error) {
 	return "", ErrDockerSocketNotSetInContext
 }
 
+// dockerHostFromDockerContext returns the docker host from the DOCKER_CONTEXT environment variable, if it's not empty
+func dockerHostFromDockerContext(_ context.Context) (string, error) {
+	// exec `docker context inspect -f='{{.Endpoints.docker.Host}}'`
+	cmd := exec.Command("docker", "context", "inspect", "-f", "{{.Endpoints.docker.Host}}")
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		return "", fmt.Errorf("%w: %w", ErrDockerSocketNotSetInDockerContext, err)
+	}
+	return strings.TrimSpace(string(output)), nil
+}
+
 // dockerHostFromProperties returns the docker host from the ~/.testcontainers.properties file, if it's not empty
 func dockerHostFromProperties(_ context.Context) (string, error) {
 	cfg := config.Read()

internal/core/docker_host_test.go

@@ -88,7 +88,7 @@ func TestExtractDockerHost(t *testing.T) {
 
 		setupTestcontainersProperties(t, content)
 
-		host, err := extractDockerHost(context.Background())
+		host, err := ExtractDockerHost(context.Background())
 		require.NoError(t, err)
 		require.Equal(t, testRemoteHost, host)
 	})
@@ -102,14 +102,14 @@ func TestExtractDockerHost(t *testing.T) {
 		// mock the callback check to return an error
 		mockCallbackCheck(t, testCallbackCheckError)
 
-		host, err := extractDockerHost(context.Background())
+		host, err := ExtractDockerHost(context.Background())
 		require.Error(t, err)
 		require.Empty(t, host)
 	})
 
 	t.Run("Docker Host as environment variable", func(t *testing.T) {
 		t.Setenv("DOCKER_HOST", "/path/to/docker.sock")
-		host, err := extractDockerHost(context.Background())
+		host, err := ExtractDockerHost(context.Background())
 		require.NoError(t, err)
 		require.Equal(t, "/path/to/docker.sock", host)
 	})
@@ -120,7 +120,7 @@ func TestExtractDockerHost(t *testing.T) {
 
 		ctx := context.Background()
 
-		host, err := extractDockerHost(context.WithValue(ctx, DockerHostContextKey, "path-to-docker-sock"))
+		host, err := ExtractDockerHost(context.WithValue(ctx, DockerHostContextKey, "path-to-docker-sock"))
 		require.Error(t, err)
 		require.Empty(t, host)
 	})
@@ -130,15 +130,15 @@ func TestExtractDockerHost(t *testing.T) {
 		setupRootlessNotFound(t)
 		ctx := context.Background()
 
-		host, err := extractDockerHost(context.WithValue(ctx, DockerHostContextKey, "http://path to docker sock"))
+		host, err := ExtractDockerHost(context.WithValue(ctx, DockerHostContextKey, "http://path to docker sock"))
 		require.Error(t, err)
 		require.Empty(t, host)
 	})
 
 	t.Run("Unix Docker Host is passed in context", func(t *testing.T) {
 		ctx := context.Background()
 
-		host, err := extractDockerHost(context.WithValue(ctx, DockerHostContextKey, DockerSocketSchema+"/this/is/a/sample.sock"))
+		host, err := ExtractDockerHost(context.WithValue(ctx, DockerHostContextKey, DockerSocketSchema+"/this/is/a/sample.sock"))
 		require.NoError(t, err)
 		require.Equal(t, "/this/is/a/sample.sock", host)
 	})
@@ -150,7 +150,7 @@ func TestExtractDockerHost(t *testing.T) {
 
 		setupTestcontainersProperties(t, content)
 
-		host, err := extractDockerHost(context.Background())
+		host, err := ExtractDockerHost(context.Background())
 		require.NoError(t, err)
 		require.Equal(t, DockerSocketSchema+"/this/is/a/sample.sock", host)
 	})
@@ -159,15 +159,15 @@ func TestExtractDockerHost(t *testing.T) {
 		setupRootlessNotFound(t)
 		tmpSocket := setupDockerSocket(t)
 
-		host, err := extractDockerHost(context.Background())
+		host, err := ExtractDockerHost(context.Background())
 		require.NoError(t, err)
 		require.Equal(t, tmpSocket, host)
 	})
 
 	t.Run("Error when empty", func(t *testing.T) {
 		setupDockerSocketNotFound(t)
 		setupRootlessNotFound(t)
-		host, err := extractDockerHost(context.Background())
+		host, err := ExtractDockerHost(context.Background())
 		require.Error(t, err)
 		require.Empty(t, host)
 	})