From ef7b53633d0833b56ece4fca74b25d78761b7141 Mon Sep 17 00:00:00 2001 From: JT Date: Tue, 27 Oct 2026 11:55:04 +0800 Subject: [PATCH 1/3] Support native transport on unix sockets --- .github/workflows/ci.yml | 6 ++ README.md | 12 +++ .../Docker.DotNet.NativeHttp.csproj | 4 +- .../DockerHandlerFactory.cs | 68 +++++++++++++- src/Docker.DotNet/DockerClientBuilder.cs | 7 ++ .../DockerClientBuilderTests.cs | 22 ++++- .../DockerHandlerFactoryValidationTests.cs | 4 +- .../NativeHttpUnixSocketTests.cs | 91 +++++++++++++++++++ 8 files changed, 201 insertions(+), 13 deletions(-) create mode 100644 test/Docker.DotNet.TestsV2/NativeHttpUnixSocketTests.cs diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 9acc27b0..6b034147 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -48,6 +48,12 @@ jobs: cert_path: "" native_http: 0 needs_dind: false + - name: unix-native + docker_host: unix:///var/run/docker.sock + tls_verify: "" + cert_path: "" + native_http: 1 + needs_dind: false - name: tcp-2375 docker_host: tcp://localhost:2375 tls_verify: "" diff --git a/README.md b/README.md index eff27f3f..ff868b33 100644 --- a/README.md +++ b/README.md @@ -103,6 +103,18 @@ var client = new DockerClientBuilder() This is achieved by setting the environment variable `DOCKER_DOTNET_NATIVE_HTTP_ENABLED` to `1`. By doing so, the handler used to communicate with the Docker Engine will switch to the .NET built-in one, potentially improving performance and reliability. +The native handler serves `tcp://`, `http://`, and `https://` endpoints and, on .NET 8 or later, `unix://` endpoints. To select it without the environment variable: + +```csharp +using Docker.DotNet; +using Docker.DotNet.NativeHttp; + +var client = new DockerClientBuilder() + .WithEndpoint(new Uri("unix:///var/run/docker.sock")) + .WithTransportOptions(new NativeHttpTransportOptions()) + .Build(); +``` + ### Transport-specific options Use `WithTransportOptions` to select a transport explicitly and configure transport-specific options. diff --git a/src/Docker.DotNet.NativeHttp/Docker.DotNet.NativeHttp.csproj b/src/Docker.DotNet.NativeHttp/Docker.DotNet.NativeHttp.csproj index 84632d93..56fd7c21 100644 --- a/src/Docker.DotNet.NativeHttp/Docker.DotNet.NativeHttp.csproj +++ b/src/Docker.DotNet.NativeHttp/Docker.DotNet.NativeHttp.csproj @@ -2,7 +2,7 @@ Docker.DotNet.NativeHttp Docker.DotNet.Enhanced.NativeHttp - A Docker.DotNet transport implementation for HTTP(S) Docker Engine connections. + A Docker.DotNet transport implementation for HTTP(S) and, on .NET 8 or later, Unix domain socket Docker Engine connections. @@ -11,8 +11,10 @@ + + diff --git a/src/Docker.DotNet.NativeHttp/DockerHandlerFactory.cs b/src/Docker.DotNet.NativeHttp/DockerHandlerFactory.cs index e2673b9f..c247e7a3 100644 --- a/src/Docker.DotNet.NativeHttp/DockerHandlerFactory.cs +++ b/src/Docker.DotNet.NativeHttp/DockerHandlerFactory.cs @@ -32,9 +32,6 @@ public ResolvedTransport CreateHandler(NativeHttpTransportOptions transportOptio Validate(endpoint); - var scheme = clientOptions.AuthProvider.TlsEnabled ? Uri.UriSchemeHttps : Uri.UriSchemeHttp; - var uri = new UriBuilder(endpoint) { Scheme = scheme }.Uri; - #if NET var handler = new SocketsHttpHandler { @@ -43,8 +40,24 @@ public ResolvedTransport CreateHandler(NativeHttpTransportOptions transportOptio PooledConnectionIdleTimeout = PooledConnectionIdleTimeout, }; + Uri uri; + + if (IsUnixSocket(endpoint)) + { + // Every connection goes to the socket, so the request URI only supplies the Host header, named after + // the socket as the Unix transport names it. + var socketPath = endpoint.LocalPath; + uri = new UriBuilder(Uri.UriSchemeHttp, endpoint.Segments.Last()).Uri; + handler.ConnectCallback = (_, cancellationToken) => ConnectUnixSocketAsync(socketPath, cancellationToken); + } + else + { + uri = CreateHttpUri(endpoint, clientOptions); + } + transportOptions.ConfigureHandler(handler); #else + var uri = CreateHttpUri(endpoint, clientOptions); var handler = new HttpClientHandler(); transportOptions.ConfigureHandler(handler); #endif @@ -60,15 +73,60 @@ public async Task HijackStreamAsync(HttpContent content) return new WriteClosableStreamWrapper(stream); } + private static Uri CreateHttpUri(Uri endpoint, ResolvedClientOptions clientOptions) + { + var scheme = clientOptions.AuthProvider.TlsEnabled ? Uri.UriSchemeHttps : Uri.UriSchemeHttp; + return new UriBuilder(endpoint) { Scheme = scheme }.Uri; + } + +#if NET + private static bool IsUnixSocket(Uri endpoint) + { + return string.Equals(endpoint.Scheme, "unix", StringComparison.OrdinalIgnoreCase); + } + + private static async ValueTask ConnectUnixSocketAsync(string socketPath, CancellationToken cancellationToken) + { + var socket = new Socket(AddressFamily.Unix, SocketType.Stream, ProtocolType.Unspecified); + + try + { + await socket.ConnectAsync(new UnixDomainSocketEndPoint(socketPath), cancellationToken) + .ConfigureAwait(false); + + return new NetworkStream(socket, ownsSocket: true); + } + catch + { + socket.Dispose(); + throw; + } + } + + private static void Validate(Uri endpoint) + { + var scheme = endpoint.Scheme; + + if (!string.Equals(scheme, "tcp", StringComparison.OrdinalIgnoreCase) + && !string.Equals(scheme, Uri.UriSchemeHttp, StringComparison.OrdinalIgnoreCase) + && !string.Equals(scheme, Uri.UriSchemeHttps, StringComparison.OrdinalIgnoreCase) + && !IsUnixSocket(endpoint)) + { + throw new InvalidOperationException($"The selected '{nameof(NativeHttpTransportOptions)}' can only be used with endpoint schemes 'tcp', 'http', 'https', or 'unix', but '{scheme}' was provided."); + } + } +#else private static void Validate(Uri endpoint) { var scheme = endpoint.Scheme; + // HttpClientHandler cannot connect to a Unix domain socket; that needs SocketsHttpHandler's ConnectCallback. if (!string.Equals(scheme, "tcp", StringComparison.OrdinalIgnoreCase) && !string.Equals(scheme, Uri.UriSchemeHttp, StringComparison.OrdinalIgnoreCase) && !string.Equals(scheme, Uri.UriSchemeHttps, StringComparison.OrdinalIgnoreCase)) { - throw new InvalidOperationException($"The selected '{nameof(NativeHttpTransportOptions)}' can only be used with endpoint schemes 'tcp', 'http', or 'https', but '{scheme}' was provided."); + throw new InvalidOperationException($"The selected '{nameof(NativeHttpTransportOptions)}' can only be used with endpoint schemes 'tcp', 'http', or 'https' on this target framework, but '{scheme}' was provided."); } } -} \ No newline at end of file +#endif +} diff --git a/src/Docker.DotNet/DockerClientBuilder.cs b/src/Docker.DotNet/DockerClientBuilder.cs index b96c6d72..8a475b6c 100644 --- a/src/Docker.DotNet/DockerClientBuilder.cs +++ b/src/Docker.DotNet/DockerClientBuilder.cs @@ -294,7 +294,14 @@ protected virtual IDockerHandlerFactory ResolveTransportFactory(string scheme) return scheme.ToLowerInvariant() switch { "npipe" => NPipe.DockerHandlerFactory.Instance, +#if NET + "unix" => NativeHttpEnabled + ? NativeHttp.DockerHandlerFactory.Instance + : Unix.DockerHandlerFactory.Instance, +#else + // The native transport needs SocketsHttpHandler to reach a Unix domain socket. "unix" => Unix.DockerHandlerFactory.Instance, +#endif "tcp" or "http" or "https" => NativeHttpEnabled ? NativeHttp.DockerHandlerFactory.Instance : LegacyHttp.DockerHandlerFactory.Instance, diff --git a/test/Docker.DotNet.TestsV2/DockerClientBuilderTests.cs b/test/Docker.DotNet.TestsV2/DockerClientBuilderTests.cs index b4c009a1..fbef1038 100644 --- a/test/Docker.DotNet.TestsV2/DockerClientBuilderTests.cs +++ b/test/Docker.DotNet.TestsV2/DockerClientBuilderTests.cs @@ -293,14 +293,26 @@ public void PreservesEndpointInClientOptionsWhenTransportNormalizesEndpoint() Assert.Equal(expectedEndpoint, transportFactory.LastClientOptions.Endpoint); } - [Theory] - [InlineData("npipe://./pipe/docker_engine", typeof(NPipe.DockerHandlerFactory))] - [InlineData("unix:/var/run/docker.sock", typeof(Unix.DockerHandlerFactory))] - public void UsesExpectedFactoryWhenSocketSchemeIsProvided(string endpoint, Type expectedFactoryType) + [Fact] + public void UsesExpectedFactoryWhenNamedPipeSchemeIsProvided() { var builder = new TestDockerClientBuilder(); - var actualFactory = builder.ResolveTransportFactory(new Uri(endpoint)); + var actualFactory = builder.ResolveTransportFactory(new Uri("npipe://./pipe/docker_engine")); + + Assert.IsType(actualFactory); + } + + [Fact] + public void UsesExpectedFactoryWhenUnixSchemeIsProvided() + { + var builder = new TestDockerClientBuilder(); + + var actualFactory = builder.ResolveTransportFactory(new Uri("unix:/var/run/docker.sock")); + + var expectedFactoryType = Environment.GetEnvironmentVariable("DOCKER_DOTNET_NATIVE_HTTP_ENABLED") == "1" + ? typeof(NativeHttp.DockerHandlerFactory) + : typeof(Unix.DockerHandlerFactory); Assert.IsType(expectedFactoryType, actualFactory); } diff --git a/test/Docker.DotNet.TestsV2/DockerHandlerFactoryValidationTests.cs b/test/Docker.DotNet.TestsV2/DockerHandlerFactoryValidationTests.cs index 470f2a2e..9430be3a 100644 --- a/test/Docker.DotNet.TestsV2/DockerHandlerFactoryValidationTests.cs +++ b/test/Docker.DotNet.TestsV2/DockerHandlerFactoryValidationTests.cs @@ -14,9 +14,9 @@ public static TheoryData, Uri, st }, { options => NativeHttp.DockerHandlerFactory.Instance.CreateHandler(options, NullLogger.Instance), - new Uri("unix:/var/run/docker.sock"), + new Uri("npipe://./pipe/docker_engine"), "NativeHttpTransportOptions", - "tcp', 'http', or 'https" + "tcp', 'http', 'https', or 'unix" }, { options => NPipe.DockerHandlerFactory.Instance.CreateHandler(options, NullLogger.Instance), diff --git a/test/Docker.DotNet.TestsV2/NativeHttpUnixSocketTests.cs b/test/Docker.DotNet.TestsV2/NativeHttpUnixSocketTests.cs new file mode 100644 index 00000000..f1fdab22 --- /dev/null +++ b/test/Docker.DotNet.TestsV2/NativeHttpUnixSocketTests.cs @@ -0,0 +1,91 @@ +using System.Net.Sockets; +using System.Threading; + +namespace Docker.DotNet.TestsV2; + +public sealed class NativeHttpUnixSocketTests +{ + [Fact] + public void CreateHandler_ConnectsToTheSocket_WhenEndpointSchemeIsUnix() + { + var clientOptions = new ResolvedClientOptions { Endpoint = new Uri("unix:///var/run/docker.sock") }; + + var transport = NativeHttp.DockerHandlerFactory.Instance.CreateHandler(clientOptions, NullLogger.Instance); + + var handler = Assert.IsType(transport.Handler); + Assert.NotNull(handler.ConnectCallback); + Assert.Equal(new Uri("http://docker.sock/"), transport.EffectiveEndpoint); + } + + [Fact] + public void CreateHandler_AppliesConfigureHandlerAfterTheSocketConnectCallback() + { + Func> connectCallback = (_, _) => throw new NotSupportedException(); + var transportOptions = new NativeHttpTransportOptions { ConfigureHandler = handler => handler.ConnectCallback = connectCallback }; + var clientOptions = new ResolvedClientOptions { Endpoint = new Uri("unix:///var/run/docker.sock") }; + + var transport = NativeHttp.DockerHandlerFactory.Instance.CreateHandler(transportOptions, clientOptions, NullLogger.Instance); + + var handler = Assert.IsType(transport.Handler); + Assert.Same(connectCallback, handler.ConnectCallback); + } + + [Fact] + public async Task GetVersionAsync_ReadsTheResponse_FromADaemonOnAUnixSocket() + { + var socketPath = Path.Combine(Path.GetTempPath(), $"{Guid.NewGuid():N}.sock"); + + using var listener = new Socket(AddressFamily.Unix, SocketType.Stream, ProtocolType.Unspecified); + listener.Bind(new UnixDomainSocketEndPoint(socketPath)); + listener.Listen(1); + + try + { + var serving = ServeOneRequestAsync(listener); + + using var client = new DockerClientBuilder() + .WithEndpoint(new Uri("unix://" + socketPath)) + .WithTransportOptions(new NativeHttpTransportOptions()) + .Build(); + + using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10)); + + var version = await client.System.GetVersionAsync(cts.Token); + var requestLine = await serving; + + Assert.Equal("29.0.0", version.Version); + Assert.EndsWith("/version HTTP/1.1", requestLine, StringComparison.Ordinal); + } + finally + { + File.Delete(socketPath); + } + } + + private static async Task ServeOneRequestAsync(Socket listener) + { + const string body = "{\"Version\":\"29.0.0\",\"ApiVersion\":\"1.52\",\"MinAPIVersion\":\"1.24\"}"; + + using var connection = await listener.AcceptAsync(); + using var stream = new NetworkStream(connection, ownsSocket: false); + + var request = new StringBuilder(); + var buffer = new byte[4096]; + while (!request.ToString().Contains("\r\n\r\n")) + { + var read = await stream.ReadAsync(buffer, 0, buffer.Length); + if (read == 0) + { + break; + } + + request.Append(Encoding.ASCII.GetString(buffer, 0, read)); + } + + var response = Encoding.ASCII.GetBytes($"HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: {body.Length}\r\nConnection: close\r\n\r\n{body}"); + await stream.WriteAsync(response, 0, response.Length); + connection.Shutdown(SocketShutdown.Both); + + return request.ToString().Split(["\r\n"], StringSplitOptions.None)[0]; + } +} From 4ede287f9d4679e6ba3fe14379e7ed6f723d35d3 Mon Sep 17 00:00:00 2001 From: Andre Hofmeister <9199345+HofmeisterAn@users.noreply.github.com> Date: Fri, 30 Oct 2026 19:06:37 +0100 Subject: [PATCH 2/3] chore: Remove NativeHttpUnixSocketTests The unix-native CI matrix entry covers the transport against a real daemon, like the other transports. --- .../NativeHttpUnixSocketTests.cs | 91 ------------------- 1 file changed, 91 deletions(-) delete mode 100644 test/Docker.DotNet.TestsV2/NativeHttpUnixSocketTests.cs diff --git a/test/Docker.DotNet.TestsV2/NativeHttpUnixSocketTests.cs b/test/Docker.DotNet.TestsV2/NativeHttpUnixSocketTests.cs deleted file mode 100644 index f1fdab22..00000000 --- a/test/Docker.DotNet.TestsV2/NativeHttpUnixSocketTests.cs +++ /dev/null @@ -1,91 +0,0 @@ -using System.Net.Sockets; -using System.Threading; - -namespace Docker.DotNet.TestsV2; - -public sealed class NativeHttpUnixSocketTests -{ - [Fact] - public void CreateHandler_ConnectsToTheSocket_WhenEndpointSchemeIsUnix() - { - var clientOptions = new ResolvedClientOptions { Endpoint = new Uri("unix:///var/run/docker.sock") }; - - var transport = NativeHttp.DockerHandlerFactory.Instance.CreateHandler(clientOptions, NullLogger.Instance); - - var handler = Assert.IsType(transport.Handler); - Assert.NotNull(handler.ConnectCallback); - Assert.Equal(new Uri("http://docker.sock/"), transport.EffectiveEndpoint); - } - - [Fact] - public void CreateHandler_AppliesConfigureHandlerAfterTheSocketConnectCallback() - { - Func> connectCallback = (_, _) => throw new NotSupportedException(); - var transportOptions = new NativeHttpTransportOptions { ConfigureHandler = handler => handler.ConnectCallback = connectCallback }; - var clientOptions = new ResolvedClientOptions { Endpoint = new Uri("unix:///var/run/docker.sock") }; - - var transport = NativeHttp.DockerHandlerFactory.Instance.CreateHandler(transportOptions, clientOptions, NullLogger.Instance); - - var handler = Assert.IsType(transport.Handler); - Assert.Same(connectCallback, handler.ConnectCallback); - } - - [Fact] - public async Task GetVersionAsync_ReadsTheResponse_FromADaemonOnAUnixSocket() - { - var socketPath = Path.Combine(Path.GetTempPath(), $"{Guid.NewGuid():N}.sock"); - - using var listener = new Socket(AddressFamily.Unix, SocketType.Stream, ProtocolType.Unspecified); - listener.Bind(new UnixDomainSocketEndPoint(socketPath)); - listener.Listen(1); - - try - { - var serving = ServeOneRequestAsync(listener); - - using var client = new DockerClientBuilder() - .WithEndpoint(new Uri("unix://" + socketPath)) - .WithTransportOptions(new NativeHttpTransportOptions()) - .Build(); - - using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10)); - - var version = await client.System.GetVersionAsync(cts.Token); - var requestLine = await serving; - - Assert.Equal("29.0.0", version.Version); - Assert.EndsWith("/version HTTP/1.1", requestLine, StringComparison.Ordinal); - } - finally - { - File.Delete(socketPath); - } - } - - private static async Task ServeOneRequestAsync(Socket listener) - { - const string body = "{\"Version\":\"29.0.0\",\"ApiVersion\":\"1.52\",\"MinAPIVersion\":\"1.24\"}"; - - using var connection = await listener.AcceptAsync(); - using var stream = new NetworkStream(connection, ownsSocket: false); - - var request = new StringBuilder(); - var buffer = new byte[4096]; - while (!request.ToString().Contains("\r\n\r\n")) - { - var read = await stream.ReadAsync(buffer, 0, buffer.Length); - if (read == 0) - { - break; - } - - request.Append(Encoding.ASCII.GetString(buffer, 0, read)); - } - - var response = Encoding.ASCII.GetBytes($"HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: {body.Length}\r\nConnection: close\r\n\r\n{body}"); - await stream.WriteAsync(response, 0, response.Length); - connection.Shutdown(SocketShutdown.Both); - - return request.ToString().Split(["\r\n"], StringSplitOptions.None)[0]; - } -} From f3b94e5ddb44aac55a82e76e1406a5988ea0ff08 Mon Sep 17 00:00:00 2001 From: Andre Hofmeister <9199345+HofmeisterAn@users.noreply.github.com> Date: Fri, 30 Oct 2026 19:53:10 +0100 Subject: [PATCH 3/3] chore: Align native Unix socket transport with the Unix transport - Derive the socket name, path, and URI like the Unix transport and check the scheme once. - Disable the proxy for Unix domain sockets. - Keep the original validation message on netstandard and keep Validate in its original position. - Update the package description and README wording. --- README.md | 2 +- .../Docker.DotNet.NativeHttp.csproj | 2 +- .../DockerHandlerFactory.cs | 75 +++++++++---------- 3 files changed, 38 insertions(+), 41 deletions(-) diff --git a/README.md b/README.md index ff868b33..56e696b9 100644 --- a/README.md +++ b/README.md @@ -103,7 +103,7 @@ var client = new DockerClientBuilder() This is achieved by setting the environment variable `DOCKER_DOTNET_NATIVE_HTTP_ENABLED` to `1`. By doing so, the handler used to communicate with the Docker Engine will switch to the .NET built-in one, potentially improving performance and reliability. -The native handler serves `tcp://`, `http://`, and `https://` endpoints and, on .NET 8 or later, `unix://` endpoints. To select it without the environment variable: +The native handler supports `tcp://`, `http://`, and `https://` endpoints and, on .NET 8 or later, `unix://` endpoints. To select it without the environment variable: ```csharp using Docker.DotNet; diff --git a/src/Docker.DotNet.NativeHttp/Docker.DotNet.NativeHttp.csproj b/src/Docker.DotNet.NativeHttp/Docker.DotNet.NativeHttp.csproj index 56fd7c21..600e02a5 100644 --- a/src/Docker.DotNet.NativeHttp/Docker.DotNet.NativeHttp.csproj +++ b/src/Docker.DotNet.NativeHttp/Docker.DotNet.NativeHttp.csproj @@ -2,7 +2,7 @@ Docker.DotNet.NativeHttp Docker.DotNet.Enhanced.NativeHttp - A Docker.DotNet transport implementation for HTTP(S) and, on .NET 8 or later, Unix domain socket Docker Engine connections. + A Docker.DotNet transport implementation for HTTP(S) and Unix domain socket Docker Engine connections. diff --git a/src/Docker.DotNet.NativeHttp/DockerHandlerFactory.cs b/src/Docker.DotNet.NativeHttp/DockerHandlerFactory.cs index c247e7a3..29cf1869 100644 --- a/src/Docker.DotNet.NativeHttp/DockerHandlerFactory.cs +++ b/src/Docker.DotNet.NativeHttp/DockerHandlerFactory.cs @@ -28,9 +28,9 @@ public ResolvedTransport CreateHandler(NativeHttpTransportOptions transportOptio throw new ArgumentNullException(nameof(clientOptions)); } - var endpoint = clientOptions.Endpoint; + var uri = clientOptions.Endpoint; - Validate(endpoint); + Validate(uri); #if NET var handler = new SocketsHttpHandler @@ -40,24 +40,24 @@ public ResolvedTransport CreateHandler(NativeHttpTransportOptions transportOptio PooledConnectionIdleTimeout = PooledConnectionIdleTimeout, }; - Uri uri; - - if (IsUnixSocket(endpoint)) + if (IsUnixSocket(uri)) { - // Every connection goes to the socket, so the request URI only supplies the Host header, named after - // the socket as the Unix transport names it. - var socketPath = endpoint.LocalPath; - uri = new UriBuilder(Uri.UriSchemeHttp, endpoint.Segments.Last()).Uri; + var socketName = uri.Segments.Last(); + var socketPath = uri.LocalPath; + uri = new UriBuilder(Uri.UriSchemeHttp, socketName).Uri; + + // Proxies do not apply to Unix domain sockets. + handler.UseProxy = false; handler.ConnectCallback = (_, cancellationToken) => ConnectUnixSocketAsync(socketPath, cancellationToken); } else { - uri = CreateHttpUri(endpoint, clientOptions); + uri = CreateHttpUri(uri, clientOptions); } transportOptions.ConfigureHandler(handler); #else - var uri = CreateHttpUri(endpoint, clientOptions); + uri = CreateHttpUri(uri, clientOptions); var handler = new HttpClientHandler(); transportOptions.ConfigureHandler(handler); #endif @@ -73,10 +73,27 @@ public async Task HijackStreamAsync(HttpContent content) return new WriteClosableStreamWrapper(stream); } - private static Uri CreateHttpUri(Uri endpoint, ResolvedClientOptions clientOptions) + private static void Validate(Uri endpoint) { - var scheme = clientOptions.AuthProvider.TlsEnabled ? Uri.UriSchemeHttps : Uri.UriSchemeHttp; - return new UriBuilder(endpoint) { Scheme = scheme }.Uri; + var scheme = endpoint.Scheme; + +#if NET + if (IsUnixSocket(endpoint)) + { + return; + } +#endif + + if (!string.Equals(scheme, "tcp", StringComparison.OrdinalIgnoreCase) + && !string.Equals(scheme, Uri.UriSchemeHttp, StringComparison.OrdinalIgnoreCase) + && !string.Equals(scheme, Uri.UriSchemeHttps, StringComparison.OrdinalIgnoreCase)) + { +#if NET + throw new InvalidOperationException($"The selected '{nameof(NativeHttpTransportOptions)}' can only be used with endpoint schemes 'tcp', 'http', 'https', or 'unix', but '{scheme}' was provided."); +#else + throw new InvalidOperationException($"The selected '{nameof(NativeHttpTransportOptions)}' can only be used with endpoint schemes 'tcp', 'http', or 'https', but '{scheme}' was provided."); +#endif + } } #if NET @@ -102,31 +119,11 @@ await socket.ConnectAsync(new UnixDomainSocketEndPoint(socketPath), cancellation throw; } } +#endif - private static void Validate(Uri endpoint) - { - var scheme = endpoint.Scheme; - - if (!string.Equals(scheme, "tcp", StringComparison.OrdinalIgnoreCase) - && !string.Equals(scheme, Uri.UriSchemeHttp, StringComparison.OrdinalIgnoreCase) - && !string.Equals(scheme, Uri.UriSchemeHttps, StringComparison.OrdinalIgnoreCase) - && !IsUnixSocket(endpoint)) - { - throw new InvalidOperationException($"The selected '{nameof(NativeHttpTransportOptions)}' can only be used with endpoint schemes 'tcp', 'http', 'https', or 'unix', but '{scheme}' was provided."); - } - } -#else - private static void Validate(Uri endpoint) + private static Uri CreateHttpUri(Uri endpoint, ResolvedClientOptions clientOptions) { - var scheme = endpoint.Scheme; - - // HttpClientHandler cannot connect to a Unix domain socket; that needs SocketsHttpHandler's ConnectCallback. - if (!string.Equals(scheme, "tcp", StringComparison.OrdinalIgnoreCase) - && !string.Equals(scheme, Uri.UriSchemeHttp, StringComparison.OrdinalIgnoreCase) - && !string.Equals(scheme, Uri.UriSchemeHttps, StringComparison.OrdinalIgnoreCase)) - { - throw new InvalidOperationException($"The selected '{nameof(NativeHttpTransportOptions)}' can only be used with endpoint schemes 'tcp', 'http', or 'https' on this target framework, but '{scheme}' was provided."); - } + var scheme = clientOptions.AuthProvider.TlsEnabled ? Uri.UriSchemeHttps : Uri.UriSchemeHttp; + return new UriBuilder(endpoint) { Scheme = scheme }.Uri; } -#endif -} +} \ No newline at end of file