feat: Get Docker endpoint from Docker context

docs/custom_configuration/index.md

@@ -6,6 +6,7 @@ Testcontainers supports various configurations to set up your test environment.
 |-----------------------------|--------------------------------------------|---------------------------------------------------------------------------------------------------------------------------|-----------------------------|
 | `docker.config`             | `DOCKER_CONFIG`                            | The directory path that contains the Docker configuration (`config.json`) file.                                           | `~/.docker/`                |
 | `docker.host`               | `DOCKER_HOST`                              | The Docker daemon socket to connect to.                                                                                   | -                           |
+| `docker.context`            | `DOCKER_CONTEXT`                           | The Docker context to connect to.                                                                                         | -                           |
 | `docker.auth.config`        | `DOCKER_AUTH_CONFIG`                       | The Docker configuration file content (GitLab: [Use statically-defined credentials][use-statically-defined-credentials]). | -                           |
 | `docker.cert.path`          | `DOCKER_CERT_PATH`                         | The directory path that contains the client certificate (`{ca,cert,key}.pem`) files.                                      | `~/.docker/`                |
 | `docker.tls`                | `DOCKER_TLS`                               | Enables TLS.                                                                                                              | `false`                     |
@@ -16,11 +17,11 @@ Testcontainers supports various configurations to set up your test environment.
 | `ryuk.container.privileged` | `TESTCONTAINERS_RYUK_CONTAINER_PRIVILEGED` | Runs Ryuk (resource reaper) in privileged mode.                                                                           | `false`                     |
 | `ryuk.container.image`      | `TESTCONTAINERS_RYUK_CONTAINER_IMAGE`      | The Ryuk (resource reaper) Docker image.                                                                                  | `testcontainers/ryuk:0.5.1` |
 | `hub.image.name.prefix`     | `TESTCONTAINERS_HUB_IMAGE_NAME_PREFIX`     | The name to use for substituting the Docker Hub registry part of the image name.                                          | -                           |
-<!-- | `wait.strategy.retries`     | `TESTCONTAINERS_WAIT_STRATEGY_RETRIES`     | The wait strategy retry count.                                                                                            | `infinite`                  |
+| `wait.strategy.retries`     | `TESTCONTAINERS_WAIT_STRATEGY_RETRIES`     | The wait strategy retry count.                                                                                            | `infinite`                  |
 | `wait.strategy.interval`    | `TESTCONTAINERS_WAIT_STRATEGY_INTERVAL`    | The wait strategy interval<sup>1</sup>.                                                                                   | `00:00:01`                  |
 | `wait.strategy.timeout`     | `TESTCONTAINERS_WAIT_STRATEGY_TIMEOUT`     | The wait strategy timeout<sup>1</sup>.                                                                                    | `01:00:00`                  |
 
-1) The value represent the string representation of a [TimeSpan](https://learn.microsoft.com/en-us/dotnet/api/system.timespan), for example, `00:00:01` for 1 second. -->
+1) The value represent the string representation of a [TimeSpan](https://learn.microsoft.com/en-us/dotnet/api/system.timespan), for example, `00:00:01` for 1 second.
 
 ## Configure remote container runtime
 
@@ -34,9 +35,24 @@ docker.host=tcp://docker:2375
 DOCKER_HOST=tcp://docker:2375
 ```
 
+## Use a different context
+
+You can switch between contexts using the properties file or an environment variable. Once the context is set, Testcontainers will connect to the specified endpoint based on the given value.
+
+    NAME   DESCRIPTION   DOCKER ENDPOINT           ERROR
+    tcc                  tcp://127.0.0.1:64453/0
+
+```console title="Properties File"
+docker.context=tcc
+```
+
+```console title="Environment Variable"
+DOCKER_CONTEXT=tcc
+```
+
 ## Enable logging
 
-In .NET logging usually goes through the test framework. Testcontainers is not aware of the project's test framework and may not forward log messages to the appropriate output stream. The default implementation forwards log messages to the `Console` (respectively `stdout` and `stderr`). The output should at least pop up in the IDE running tests in the `Debug` configuration. To override the default implementation, set the `TestcontainersSettings.Logger` property to an instance of an `ILogger` implementation before creating a Docker resource, such as a container.
+In .NET logging usually goes through the test framework. Testcontainers is not aware of the project's test framework and may not forward log messages to the appropriate output stream. The default implementation forwards log messages to the `Console` (respectively `stdout` and `stderr`). The output should at least pop up in the IDE running tests in the `Debug` configuration. To override the default implementation, use the builder's `WithLogger(ILogger)` method and provide an `ILogger` instance to replace the default console logger.
 
     [testcontainers.org 00:00:00.34] Connected to Docker:
       Host: tcp://127.0.0.1:60706/

src/Testcontainers/Builders/DockerConfig.cs

@@ -0,0 +1,211 @@
+namespace DotNet.Testcontainers.Builders
+{
+  using System;
+  using System.IO;
+  using System.Linq;
+  using System.Runtime.InteropServices;
+  using System.Security.Cryptography;
+  using System.Text;
+  using System.Text.Json;
+  using System.Text.Json.Serialization;
+  using DotNet.Testcontainers.Configurations;
+  using JetBrains.Annotations;
+
+  /// <summary>
+  /// Represents a Docker config.
+  /// </summary>
+  internal sealed class DockerConfig
+  {
+    private static readonly string UserProfileDockerConfigDirectoryPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".docker");
+
+    private static readonly string UserProfileDockerContextMetaDirectoryPath = Path.Combine(UserProfileDockerConfigDirectoryPath, "contexts", "meta");
+
+    private readonly FileInfo _dockerConfigFile;
+
+    private readonly ICustomConfiguration[] _customConfigurations;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="DockerConfig" /> class.
+    /// </summary>
+    [PublicAPI]
+    public DockerConfig()
+      : this(GetDockerConfigFile(), EnvironmentConfiguration.Instance, PropertiesFileConfiguration.Instance)
+    {
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="DockerConfig" /> class.
+    /// </summary>
+    /// <param name="customConfigurations">A list of custom configurations.</param>
+    [PublicAPI]
+    public DockerConfig(params ICustomConfiguration[] customConfigurations)
+      : this(GetDockerConfigFile(), customConfigurations)
+    {
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="DockerConfig" /> class.
+    /// </summary>
+    /// <param name="dockerConfigFile">The Docker config file.</param>
+    /// <param name="customConfigurations">A list of custom configurations.</param>
+    [PublicAPI]
+    public DockerConfig(FileInfo dockerConfigFile, params ICustomConfiguration[] customConfigurations)
+    {
+      _dockerConfigFile = dockerConfigFile;
+      _customConfigurations = customConfigurations;
+    }
+
+    /// <summary>
+    /// Gets the <see cref="DockerConfig" /> instance.
+    /// </summary>
+    public static DockerConfig Instance { get; }
+      = new DockerConfig();
+
+    /// <inheritdoc cref="FileInfo.Exists" />
+    public bool Exists => _dockerConfigFile.Exists;
+
+    /// <inheritdoc cref="FileInfo.Exists" />
+    public string FullName => _dockerConfigFile.FullName;
+
+    /// <summary>
+    /// Parses the Docker config file.
+    /// </summary>
+    /// <returns>A <see cref="JsonDocument" /> representing the Docker config.</returns>
+    public JsonDocument Parse()
+    {
+      using (var dockerConfigFileStream = _dockerConfigFile.OpenRead())
+      {
+        return JsonDocument.Parse(dockerConfigFileStream);
+      }
+    }
+
+    /// <summary>
+    /// Gets the current Docker endpoint.
+    /// </summary>
+    /// <remarks>
+    /// See the Docker CLI implementation <a href="https://github.com/docker/cli/blob/v25.0.0/cli/command/cli.go#L364-L390">comments</a>.
+    /// Executes a command equivalent to <c>docker context inspect --format {{.Endpoints.docker.Host}}</c>.
+    /// </remarks>
+    /// A <see cref="Uri" /> representing the current Docker endpoint if available; otherwise, <c>null</c>.
+    [CanBeNull]
+    public Uri GetCurrentEndpoint()
+    {
+      const string defaultDockerContext = "default";
+
+      var dockerHost = GetDockerHost();
+      if (dockerHost != null)
+      {
+        return dockerHost;
+      }
+
+      var dockerContext = GetCurrentContext();
+      if (string.IsNullOrEmpty(dockerContext) || defaultDockerContext.Equals(dockerContext))
+      {
+        return RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? NpipeEndpointAuthenticationProvider.DockerEngine : UnixEndpointAuthenticationProvider.DockerEngine;
+      }
+
+      using (var sha256 = SHA256.Create())
+      {
+        var dockerContextHash = BitConverter.ToString(sha256.ComputeHash(Encoding.Default.GetBytes(dockerContext))).Replace("-", string.Empty).ToLowerInvariant();
+        var metaFilePath = Path.Combine(UserProfileDockerContextMetaDirectoryPath, dockerContextHash, "meta.json");
+
+        if (!File.Exists(metaFilePath))
+        {
+          return null;
+        }
+
+        using (var metaFileStream = File.OpenRead(metaFilePath))
+        {
+          var meta = JsonSerializer.Deserialize(metaFileStream, SourceGenerationContext.Default.DockerContextMeta);
+          var host = meta?.Name == dockerContext ? meta.Endpoints?.Docker?.Host : null;
+          return string.IsNullOrEmpty(host) ? null : new Uri(host.Replace("npipe:////./", "npipe://./"));
+        }
+      }
+    }
+
+    [CanBeNull]
+    private string GetCurrentContext()
+    {
+      var dockerContext = GetDockerContext();
+      if (!string.IsNullOrEmpty(dockerContext))
+      {
+        return dockerContext;
+      }
+
+      if (!Exists)
+      {
+        return null;
+      }
+
+      using (var dockerConfigJsonDocument = Parse())
+      {
+        if (dockerConfigJsonDocument.RootElement.TryGetProperty("currentContext", out var currentContext) && currentContext.ValueKind == JsonValueKind.String)
+        {
+          return currentContext.GetString();
+        }
+        else
+        {
+          return null;
+        }
+      }
+    }
+
+    [CanBeNull]
+    private Uri GetDockerHost()
+    {
+      return _customConfigurations.Select(customConfiguration => customConfiguration.GetDockerHost()).FirstOrDefault(dockerHost => dockerHost != null);
+    }
+
+    [CanBeNull]
+    private string GetDockerContext()
+    {
+      return _customConfigurations.Select(customConfiguration => customConfiguration.GetDockerContext()).FirstOrDefault(dockerContext => !string.IsNullOrEmpty(dockerContext));
+    }
+
+    private static FileInfo GetDockerConfigFile()
+    {
+      var dockerConfigDirectoryPath = EnvironmentConfiguration.Instance.GetDockerConfig() ?? PropertiesFileConfiguration.Instance.GetDockerConfig() ?? UserProfileDockerConfigDirectoryPath;
+      return new FileInfo(Path.Combine(dockerConfigDirectoryPath, "config.json"));
+    }
+
+    internal sealed class DockerContextMeta
+    {
+      [JsonConstructor]
+      public DockerContextMeta(string name, DockerContextMetaEndpoints endpoints)
+      {
+        Name = name;
+        Endpoints = endpoints;
+      }
+
+      [JsonPropertyName("Name")]
+      public string Name { get; }
+
+      [JsonPropertyName("Endpoints")]
+      public DockerContextMetaEndpoints Endpoints { get; }
+    }
+
+    internal sealed class DockerContextMetaEndpoints
+    {
+      [JsonConstructor]
+      public DockerContextMetaEndpoints(DockerContextMetaEndpointsDocker docker)
+      {
+        Docker = docker;
+      }
+
+      [JsonPropertyName("docker")]
+      public DockerContextMetaEndpointsDocker Docker { get; }
+    }
+
+    internal sealed class DockerContextMetaEndpointsDocker
+    {
+      [JsonConstructor]
+      public DockerContextMetaEndpointsDocker(string host)
+      {
+        Host = host;
+      }
+
+      [JsonPropertyName("Host")]
+      public string Host { get; }
+    }
+  }
+}

src/Testcontainers/Builders/DockerDesktopEndpointAuthenticationProvider.cs

@@ -15,7 +15,7 @@ internal sealed class DockerDesktopEndpointAuthenticationProvider : RootlessUnix
     /// Initializes a new instance of the <see cref="DockerDesktopEndpointAuthenticationProvider" /> class.
     /// </summary>
     public DockerDesktopEndpointAuthenticationProvider()
-      : base(GetSocketPathFromHomeDesktopDir(), GetSocketPathFromHomeRunDir())
+      : base(DockerConfig.Instance.GetCurrentEndpoint()?.AbsolutePath, GetSocketPathFromHomeDesktopDir(), GetSocketPathFromHomeRunDir())
     {
     }
 
@@ -37,6 +37,12 @@ public Uri GetDockerHost()
       return null;
     }
 
+    /// <inheritdoc />
+    public string GetDockerContext()
+    {
+      return null;
+    }
+
     /// <inheritdoc />
     public string GetDockerHostOverride()
     {

src/Testcontainers/Builders/DockerRegistryAuthenticationProvider.cs

@@ -16,9 +16,7 @@ internal sealed class DockerRegistryAuthenticationProvider : IDockerRegistryAuth
 
     private static readonly ConcurrentDictionary<string, Lazy<IDockerRegistryAuthenticationConfiguration>> Credentials = new ConcurrentDictionary<string, Lazy<IDockerRegistryAuthenticationConfiguration>>();
 
-    private static readonly string UserProfileDockerConfigDirectoryPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".docker");
-
-    private readonly FileInfo _dockerConfigFilePath;
+    private readonly DockerConfig _dockerConfig;
 
     private readonly ILogger _logger;
 
@@ -28,7 +26,7 @@ internal sealed class DockerRegistryAuthenticationProvider : IDockerRegistryAuth
     /// <param name="logger">The logger.</param>
     [PublicAPI]
     public DockerRegistryAuthenticationProvider(ILogger logger)
-      : this(GetDefaultDockerConfigFilePath(), logger)
+      : this(DockerConfig.Instance, logger)
     {
     }
 
@@ -39,19 +37,19 @@ public DockerRegistryAuthenticationProvider(ILogger logger)
     /// <param name="logger">The logger.</param>
     [PublicAPI]
     public DockerRegistryAuthenticationProvider(string dockerConfigFilePath, ILogger logger)
-      : this(new FileInfo(dockerConfigFilePath), logger)
+      : this(new DockerConfig(new FileInfo(dockerConfigFilePath)), logger)
     {
     }
 
     /// <summary>
     /// Initializes a new instance of the <see cref="DockerRegistryAuthenticationProvider" /> class.
     /// </summary>
-    /// <param name="dockerConfigFilePath">The Docker config file path.</param>
+    /// <param name="dockerConfig">The Docker config.</param>
     /// <param name="logger">The logger.</param>
     [PublicAPI]
-    public DockerRegistryAuthenticationProvider(FileInfo dockerConfigFilePath, ILogger logger)
+    public DockerRegistryAuthenticationProvider(DockerConfig dockerConfig, ILogger logger)
     {
-      _dockerConfigFilePath = dockerConfigFilePath;
+      _dockerConfig = dockerConfig;
       _logger = logger;
     }
 
@@ -68,12 +66,6 @@ public IDockerRegistryAuthenticationConfiguration GetAuthConfig(string hostname)
       return lazyAuthConfig.Value;
     }
 
-    private static string GetDefaultDockerConfigFilePath()
-    {
-      var dockerConfigDirectoryPath = EnvironmentConfiguration.Instance.GetDockerConfig() ?? PropertiesFileConfiguration.Instance.GetDockerConfig() ?? UserProfileDockerConfigDirectoryPath;
-      return Path.Combine(dockerConfigDirectoryPath, "config.json");
-    }
-
     private static JsonDocument GetDefaultDockerAuthConfig()
     {
       return EnvironmentConfiguration.Instance.GetDockerAuthConfig() ?? PropertiesFileConfiguration.Instance.GetDockerAuthConfig() ?? JsonDocument.Parse("{}");
@@ -85,28 +77,25 @@ private IDockerRegistryAuthenticationConfiguration GetUncachedAuthConfig(string
       {
         IDockerRegistryAuthenticationConfiguration authConfig;
 
-        if (_dockerConfigFilePath.Exists)
+        if (_dockerConfig.Exists)
         {
-          using (var dockerConfigFileStream = new FileStream(_dockerConfigFilePath.FullName, FileMode.Open, FileAccess.Read))
+          using (var dockerConfigJsonDocument = _dockerConfig.Parse())
           {
-            using (var dockerConfigJsonDocument = JsonDocument.Parse(dockerConfigFileStream))
-            {
-              authConfig = new IDockerRegistryAuthenticationProvider[]
-                {
-                  new CredsHelperProvider(dockerConfigJsonDocument, _logger),
-                  new CredsStoreProvider(dockerConfigJsonDocument, _logger),
-                  new Base64Provider(dockerConfigJsonDocument, _logger),
-                  new Base64Provider(dockerAuthConfigJsonDocument, _logger),
-                }
-                .AsParallel()
-                .Select(authenticationProvider => authenticationProvider.GetAuthConfig(hostname))
-                .FirstOrDefault(authenticationProvider => authenticationProvider != null);
-            }
+            authConfig = new IDockerRegistryAuthenticationProvider[]
+              {
+                new CredsHelperProvider(dockerConfigJsonDocument, _logger),
+                new CredsStoreProvider(dockerConfigJsonDocument, _logger),
+                new Base64Provider(dockerConfigJsonDocument, _logger),
+                new Base64Provider(dockerAuthConfigJsonDocument, _logger),
+              }
+              .AsParallel()
+              .Select(authenticationProvider => authenticationProvider.GetAuthConfig(hostname))
+              .FirstOrDefault(authenticationProvider => authenticationProvider != null);
           }
         }
         else
         {
-          _logger.DockerConfigFileNotFound(_dockerConfigFilePath.FullName);
+          _logger.DockerConfigFileNotFound(_dockerConfig.FullName);
           IDockerRegistryAuthenticationProvider authConfigProvider = new Base64Provider(dockerAuthConfigJsonDocument, _logger);
           authConfig = authConfigProvider.GetAuthConfig(hostname);
         }

src/Testcontainers/Builders/RootlessUnixEndpointAuthenticationProvider.cs

@@ -27,10 +27,8 @@ public RootlessUnixEndpointAuthenticationProvider()
     /// <param name="socketPaths">A list of socket paths.</param>
     public RootlessUnixEndpointAuthenticationProvider(params string[] socketPaths)
     {
-      DockerEngine = socketPaths
-        .Where(File.Exists)
-        .Select(socketPath => new Uri("unix://" + socketPath))
-        .FirstOrDefault();
+      var socketPath = socketPaths.FirstOrDefault(File.Exists);
+      DockerEngine = socketPath == null ? null : new Uri("unix://" + socketPath);
     }
 
     /// <summary>