Add ability to read http_proxy from environment (#38)

adam-fowler · web-flow · commit e47325d1f6bf · 2026-02-24T10:23:35.000Z
* Add ability to read http_proxy from environment

* Add WebSocketProxySettings.environment

* Pass URL to getProxyEnvironmentValues

* Add support for no_proxy

* Fix swift 6.0
diff --git a/Sources/WSClient/Client/ClientConnection.swift b/Sources/WSClient/Client/ClientConnection.swift
@@ -71,7 +71,7 @@ public struct ClientConnection<ClientChannel: ClientConnectionChannel>: Sendable
         _ clientChannel: ClientChannel,
         address: Address,
         transportServicesTLSOptions: TSTLSOptions,
-        eventLoopGroup: EventLoopGroup = MultiThreadedEventLoopGroup.singleton,
+        eventLoopGroup: any EventLoopGroup = MultiThreadedEventLoopGroup.singleton,
         logger: Logger
     ) throws {
         self.clientChannel = clientChannel
diff --git a/Sources/WSClient/WebSocketClient.swift b/Sources/WSClient/WebSocketClient.swift
@@ -153,10 +153,25 @@ public struct WebSocketClient {
         guard var host = url.host else { throw WebSocketClientError.invalidURL }
         let requiresTLS = self.url.scheme == .wss || self.url.scheme == .https
         var port = self.url.port ?? (requiresTLS ? 443 : 80)
-        if let proxySettings = self.proxySettings {
-            host = proxySettings.host
-            port = proxySettings.port
+        var proxySettings = self.proxySettings
+        if let validProxySettings = proxySettings {
+            switch validProxySettings.address {
+            case .hostname(let proxyHost, let proxyPort):
+                self.logger.debug("Using proxy: \(proxyHost):\(proxyPort)")
+                host = proxyHost
+                port = proxyPort
+            case .environment:
+                if let (proxyHost, proxyPort) = WebSocketProxySettings.getProxyEnvironmentValues(for: self.url) {
+                    self.logger.debug("Using proxy: \(proxyHost):\(proxyPort)")
+                    proxySettings = .init(host: proxyHost, port: proxyPort, type: .http(), timeout: validProxySettings.timeout)
+                    host = proxyHost
+                    port = proxyPort
+                } else {
+                    proxySettings = nil
+                }
+            }
         }
+
         var tlsConfiguration: TLSConfiguration? = nil
         if requiresTLS {
             switch self.tlsConfiguration {
@@ -190,7 +205,7 @@ public struct WebSocketClient {
                 url: url,
                 configuration: self.configuration,
                 tlsConfiguration: tlsConfiguration,
-                proxySettings: self.proxySettings
+                proxySettings: proxySettings
             ),
             address: .hostname(host, port: port),
             eventLoopGroup: self.eventLoopGroup,
diff --git a/Sources/WSClient/WebSocketClientConfiguration.swift b/Sources/WSClient/WebSocketClientConfiguration.swift
@@ -11,6 +11,12 @@ import NIOCore
 import NIOSSL
 import WSCore
 
+#if canImport(FoundationEssentials)
+import FoundationEssentials
+#else
+import Foundation
+#endif
+
 /// Configuration for a client connecting to a WebSocket
 public struct WebSocketClientConfiguration: Sendable {
     /// Max websocket frame size that can be sent/received
@@ -70,10 +76,12 @@ public struct WebSocketProxySettings: Sendable {
         /// HTTP proxy
         public static func http(connectHeaders: HTTPFields = [:]) -> ProxyType { .init(value: .http(connectHeaders: connectHeaders)) }
     }
-    /// Proxy endpoint hostname
-    public var host: String
-    /// Proxy port
-    public var port: Int
+    public enum ProxyAddress: Sendable {
+        case hostname(String, port: Int)
+        case environment
+    }
+    /// Network address
+    public var address: ProxyAddress
     /// Proxy type
     public var type: ProxyType
     /// Timeout for CONNECT response
@@ -91,9 +99,61 @@ public struct WebSocketProxySettings: Sendable {
         type: ProxyType,
         timeout: Duration = .seconds(30)
     ) {
-        self.host = host
-        self.port = port
+        self.address = .hostname(host, port: port)
         self.type = type
         self.timeout = timeout
     }
+
+    ///  Return proxy settings that will use environment variables for settings
+    /// - Parameter timeout: Timeout for CONNECT request
+    /// - Returns: proxy settings
+    public static func environment(timeout: Duration = .seconds(30)) -> WebSocketProxySettings {
+        .init(address: .environment, type: .http(), timeout: timeout)
+    }
+
+    /// Internal init
+    internal init(address: ProxyAddress, type: ProxyType, timeout: Duration) {
+        self.address = address
+        self.type = type
+        self.timeout = timeout
+    }
+
+    /// Get proxy settings from environment
+    static func getProxyEnvironmentValues(for url: URI) -> (host: String, port: Int)? {
+        let requiresTLS = url.scheme == .wss || url.scheme == .https
+        let environment = ProcessInfo.processInfo.environment
+        let proxy =
+            if !requiresTLS {
+                environment["http_proxy"]
+            } else {
+                environment["https_proxy"] ?? environment["HTTPS_PROXY"] ?? environment["http_proxy"]
+            }
+        guard let proxy else { return nil }
+        // Check if URL matches domain in no_proxy environment variable
+        if let noProxy = environment["no_proxy"] ?? environment["NO_PROXY"] {
+            let filters = noProxy.split(separator: ",")
+            for filter in filters {
+                var filter = filter[...]
+                // drop whitespace
+                filter = filter.trimmingPrefix { $0.isWhitespace }
+                if let lastIndex = filter.lastIndex(of: " ") {
+                    filter = filter[..<lastIndex]
+                }
+                // Drop leading dot so `.github.com` will match `github.com`
+                if filter.first == "." {
+                    filter = filter.dropFirst()
+                }
+                if filter == "*" {
+                    return nil
+                } else if url.host?.hasSuffix(filter) == true {
+                    return nil
+                }
+            }
+        }
+        let proxyURL = URI(proxy)
+        guard proxyURL.scheme == .http else { return nil }
+        guard let host = proxyURL.host else { return nil }
+        guard let port = proxyURL.port else { return nil }
+        return (host: host, port: port)
+    }
 }
diff --git a/Tests/WebSocketTests/ProxySettingsTests.swift b/Tests/WebSocketTests/ProxySettingsTests.swift
@@ -0,0 +1,80 @@
+//
+// This source file is part of the Hummingbird server framework project
+// Copyright (c) the Hummingbird authors
+//
+// See LICENSE.txt for license information
+// SPDX-License-Identifier: Apache-2.0
+//
+
+import Foundation
+import Testing
+
+@testable import WSClient
+
+@Suite("ProxySettings Tests", .serialized)
+struct ProxySettingsTests {
+    @Test func testHTTPProxyEnvVar() async throws {
+        setenv("http_proxy", "http://test.com:8888", 1)
+        defer { unsetenv("http_proxy") }
+        let values = WebSocketProxySettings.getProxyEnvironmentValues(for: "ws://echo.websocket.org/")
+        #expect(values?.host == "test.com")
+        #expect(values?.port == 8888)
+    }
+
+    @Test func testHTTPSProxyEnvVar() async throws {
+        setenv("http_proxy", "http://test.com:8888", 1)
+        defer { unsetenv("http_proxy") }
+        setenv("https_proxy", "http://test2.com:8888", 1)
+        defer { unsetenv("https_proxy") }
+        let values = WebSocketProxySettings.getProxyEnvironmentValues(for: "wss://echo.websocket.org/")
+        #expect(values?.host == "test2.com")
+        #expect(values?.port == 8888)
+    }
+
+    @Test func testNoProxyWildcard() async throws {
+        setenv("http_proxy", "http://test.com:8888", 1)
+        defer { unsetenv("http_proxy") }
+        setenv("no_proxy", "*", 1)
+        defer { unsetenv("no_proxy") }
+        let values = WebSocketProxySettings.getProxyEnvironmentValues(for: "ws://echo.websocket.org/")
+        #expect(values == nil)
+    }
+
+    @Test func testNoProxyMatch() async throws {
+        setenv("http_proxy", "http://test.com:8888", 1)
+        defer { unsetenv("http_proxy") }
+        setenv("no_proxy", "websocket.org", 1)
+        defer { unsetenv("no_proxy") }
+        let values = WebSocketProxySettings.getProxyEnvironmentValues(for: "ws://echo.websocket.org/")
+        #expect(values == nil)
+    }
+
+    @Test func testNoProxyMatchWithLeadingDot() async throws {
+        setenv("http_proxy", "http://test.com:8888", 1)
+        defer { unsetenv("http_proxy") }
+        setenv("no_proxy", ".websocket.org", 1)
+        defer { unsetenv("no_proxy") }
+        let values = WebSocketProxySettings.getProxyEnvironmentValues(for: "ws://websocket.org/")
+        #expect(values == nil)
+    }
+
+    @Test func testNoProxyMultipleDomains() async throws {
+        setenv("http_proxy", "http://test.com:8888", 1)
+        defer { unsetenv("http_proxy") }
+        setenv("no_proxy", "ws.org,websocket.org", 1)
+        defer { unsetenv("no_proxy") }
+        let values = WebSocketProxySettings.getProxyEnvironmentValues(for: "ws://echo.websocket.org/")
+        #expect(values == nil)
+    }
+
+    @Test func testNoProxyMultipleDomainsWithWhitespace() async throws {
+        setenv("http_proxy", "http://test.com:8888", 1)
+        defer { unsetenv("http_proxy") }
+        setenv("no_proxy", "ws.org , websocket.org", 1)
+        defer { unsetenv("no_proxy") }
+        let values = WebSocketProxySettings.getProxyEnvironmentValues(for: "ws://echo.websocket.org/")
+        #expect(values == nil)
+        let values2 = WebSocketProxySettings.getProxyEnvironmentValues(for: "ws://echo.ws.org/")
+        #expect(values2 == nil)
+    }
+}
