Remove ServerChildChannel generic associatedtype from ApplicationProt…

…ocol Instead use any ServerChildChannel . We don’t get any real benefit from the parameter being a generic over an existential, it gets converted to an existential Service anyway. But I’ve had to jump through a number of hoops to ensure we can keep generic parameters where they do make a performance improvement. The reason I’m doing this is I was trying to flip between a TLS and non-TLS child channel when build an application and it was really quite awkward as the child channel changed the type of the Application. Removing the ServerChildChannel generic parameter simplifies this considerably.
hummingbird-project · Apr 23, 2024 · c3be834 · c3be834
1 parent 32a724e
commit c3be834
Show file tree

Hide file tree

Showing 12 changed files with 128 additions and 113 deletions.
diff --git a/Sources/Hummingbird/Application.swift b/Sources/Hummingbird/Application.swift
@@ -44,15 +44,13 @@ public enum EventLoopGroupProvider {
 public protocol ApplicationProtocol: Service where Context: RequestContext {
     /// Responder that generates a response from a requests and context
     associatedtype Responder: HTTPResponder
-    /// Child Channel setup. This defaults to support HTTP1
-    associatedtype ChildChannel: ServerChildChannel & HTTPChannelHandler = HTTP1Channel
     /// Context passed with Request to responder
     typealias Context = Responder.Context
 
     /// Build the responder
     var responder: Responder { get async throws }
-    /// Server channel setup
-    var server: HTTPChannelBuilder<ChildChannel> { get }
+    /// Server channel builder
+    var server: HTTPChannelBuilder { get }
 
     /// event loop group used by application
     var eventLoopGroup: EventLoopGroup { get }
@@ -71,7 +69,7 @@ public protocol ApplicationProtocol: Service where Context: RequestContext {
 
 extension ApplicationProtocol {
     /// Server channel setup
-    public var server: HTTPChannelBuilder<HTTP1Channel> { .http1() }
+    public var server: HTTPChannelBuilder { .http1() }
 }
 
 extension ApplicationProtocol {
@@ -111,17 +109,16 @@ extension ApplicationProtocol {
             }
             return response
         }
-        // get channel Setup
-        let channelSetup = try self.server.build(respond)
-        // create server
-        let server = Server(
-            childChannelSetup: channelSetup,
+        // get server channel
+        let serverChannel = try self.server.build(respond)
+        // create server `Service``
+        let server = serverChannel.server(
             configuration: self.configuration.httpServer,
             onServerRunning: self.onServerRunning,
             eventLoopGroup: self.eventLoopGroup,
             logger: self.logger
         )
-        let serverService = PrecursorService(service: server) {
+        let serverService = server.withPrelude {
             for process in self.processesRunBeforeServerStart {
                 try await process()
             }
@@ -159,9 +156,8 @@ extension ApplicationProtocol {
 /// try await app.runService()
 /// ```
 /// Editing the application setup after calling `runService` will produce undefined behaviour.
-public struct Application<Responder: HTTPResponder, ChildChannel: ServerChildChannel & HTTPChannelHandler>: ApplicationProtocol where Responder.Context: RequestContext {
+public struct Application<Responder: HTTPResponder>: ApplicationProtocol where Responder.Context: RequestContext {
     public typealias Context = Responder.Context
-    public typealias ChildChannel = ChildChannel
     public typealias Responder = Responder
 
     // MARK: Member variables
@@ -177,7 +173,7 @@ public struct Application<Responder: HTTPResponder, ChildChannel: ServerChildCha
     /// on server running
     private var _onServerRunning: @Sendable (Channel) async -> Void
     /// Server channel setup
-    public let server: HTTPChannelBuilder<ChildChannel>
+    public let server: HTTPChannelBuilder
     /// services attached to the application.
     public var services: [any Service]
     /// Processes to be run before server is started
@@ -196,7 +192,7 @@ public struct Application<Responder: HTTPResponder, ChildChannel: ServerChildCha
     ///   - logger: Logger application uses
     public init(
         responder: Responder,
-        server: HTTPChannelBuilder<ChildChannel> = .http1(),
+        server: HTTPChannelBuilder = .http1(),
         configuration: ApplicationConfiguration = ApplicationConfiguration(),
         onServerRunning: @escaping @Sendable (Channel) async -> Void = { _ in },
         eventLoopGroupProvider: EventLoopGroupProvider = .singleton,
@@ -230,7 +226,7 @@ public struct Application<Responder: HTTPResponder, ChildChannel: ServerChildCha
     ///   - logger: Logger application uses
     public init<ResponderBuilder: HTTPResponderBuilder>(
         router: ResponderBuilder,
-        server: HTTPChannelBuilder<ChildChannel> = .http1(),
+        server: HTTPChannelBuilder = .http1(),
         configuration: ApplicationConfiguration = ApplicationConfiguration(),
         onServerRunning: @escaping @Sendable (Channel) async -> Void = { _ in },
         eventLoopGroupProvider: EventLoopGroupProvider = .singleton,

diff --git a/.../Hummingbird/Utils/PrecursorService.swift → ...es/Hummingbird/Utils/PreludeService.swift b/.../Hummingbird/Utils/PrecursorService.swift → ...es/Hummingbird/Utils/PreludeService.swift
@@ -14,22 +14,29 @@
 
 import ServiceLifecycle
 
-/// Wrap another service to run after a precursor closure has completed
-struct PrecursorService<S: Service>: Service, CustomStringConvertible {
-    let precursor: @Sendable () async throws -> Void
+/// Wrap another service to run after a prelude closure has completed
+struct PreludeService<S: Service>: Service, CustomStringConvertible {
+    let prelude: @Sendable () async throws -> Void
     let service: S
 
     var description: String {
-        "PrecursorService<\(S.self)>"
+        "PreludeService<\(S.self)>"
     }
 
-    init(service: S, process: @escaping @Sendable () async throws -> Void) {
+    init(service: S, prelude: @escaping @Sendable () async throws -> Void) {
         self.service = service
-        self.precursor = process
+        self.prelude = prelude
     }
 
     func run() async throws {
-        try await self.precursor()
+        try await self.prelude()
         try await self.service.run()
     }
 }
+
+extension Service {
+    /// Build existential ``PreludeService`` from an existential `Service`
+    func withPrelude(_ prelude: @escaping @Sendable () async throws -> Void) -> Service {
+        PreludeService(service: self, prelude: prelude)
+    }
+}
diff --git a/Sources/HummingbirdCore/Server/HTTP/HTTPChannelBuilder.swift b/Sources/HummingbirdCore/Server/HTTP/HTTPChannelBuilder.swift
@@ -18,13 +18,13 @@ import NIOCore
 ///
 /// Used when building an ``Hummingbird/Application``. It delays the building
 /// of the ``ServerChildChannel`` until the HTTP responder has been built.
-public struct HTTPChannelBuilder<ChildChannel: ServerChildChannel>: Sendable {
+public struct HTTPChannelBuilder: Sendable {
     /// build child channel from HTTP responder
-    public let build: @Sendable (@escaping HTTPChannelHandler.Responder) throws -> ChildChannel
+    public let build: @Sendable (@escaping HTTPChannelHandler.Responder) throws -> any ServerChildChannel
 
     /// Initialize HTTPChannelBuilder
     /// - Parameter build: closure building child channel from HTTP responder
-    public init(_ build: @escaping @Sendable (@escaping HTTPChannelHandler.Responder) throws -> ChildChannel) {
+    public init(_ build: @escaping @Sendable (@escaping HTTPChannelHandler.Responder) throws -> any ServerChildChannel) {
         self.build = build
     }
 }
@@ -43,7 +43,7 @@ extension HTTPChannelBuilder {
     /// - Returns: HTTPChannelHandler builder
     public static func http1(
         additionalChannelHandlers: @autoclosure @escaping @Sendable () -> [any RemovableChannelHandler] = []
-    ) -> HTTPChannelBuilder<HTTP1Channel> {
+    ) -> HTTPChannelBuilder {
         return .init { responder in
             return HTTP1Channel(responder: responder, additionalChannelHandlers: additionalChannelHandlers)
         }

diff --git a/Sources/HummingbirdCore/Server/Server.swift b/Sources/HummingbirdCore/Server/Server.swift
@@ -69,8 +69,11 @@ public actor Server<ChildChannel: ServerChildChannel>: Service {
 
     /// Initialize Server
     /// - Parameters:
-    ///   - group: EventLoopGroup server uses
+    ///   - childChannelSetup: Server child channel
     ///   - configuration: Configuration for server
+    ///   - onServerRunning: Closure to run once server is up and running
+    ///   - eventLoopGroup: EventLoopGroup the server uses
+    ///   = logger: Logger used by server
     public init(
         childChannelSetup: ChildChannel,
         configuration: ServerConfiguration,
@@ -209,7 +212,7 @@ public actor Server<ChildChannel: ServerChildChannel>: Service {
                         logger: self.logger
                     )
                 }
-                self.logger.info("Server started and listening on \(host):\(port)")
+                self.logger.info("Server started and listening on \(host):\(asyncChannel.channel.localAddress?.port ?? port)")
                 return asyncChannel
 
             case .unixDomainSocket(let path):

diff --git a/Sources/HummingbirdCore/Server/ServerChildChannel.swift b/Sources/HummingbirdCore/Server/ServerChildChannel.swift
@@ -14,6 +14,7 @@
 
 import Logging
 import NIOCore
+import ServiceLifecycle
 
 /// HTTPServer child channel setup protocol
 public protocol ServerChildChannel: Sendable {
@@ -32,3 +33,28 @@ public protocol ServerChildChannel: Sendable {
     ///   - logger: Logger to use while processing messages
     func handle(value: Value, logger: Logger) async
 }
+
+extension ServerChildChannel {
+    /// Build existential ``Server`` from existential `ServerChildChannel`
+    ///
+    /// - Parameters:
+    ///   - configuration: Configuration for server
+    ///   - onServerRunning: Closure to run once server is up and running
+    ///   - eventLoopGroup: EventLoopGroup the server uses
+    ///   = logger: Logger used by server
+    /// - Returns: Server Service
+    public func server(
+        configuration: ServerConfiguration,
+        onServerRunning: (@Sendable (Channel) async -> Void)? = { _ in },
+        eventLoopGroup: EventLoopGroup,
+        logger: Logger
+    ) -> Service {
+        Server(
+            childChannelSetup: self,
+            configuration: configuration,
+            onServerRunning: onServerRunning,
+            eventLoopGroup: eventLoopGroup,
+            logger: logger
+        )
+    }
+}
diff --git a/Sources/HummingbirdHTTP2/HTTP2ChannelBuilder.swift b/Sources/HummingbirdHTTP2/HTTP2ChannelBuilder.swift
@@ -33,7 +33,7 @@ extension HTTPChannelBuilder {
     public static func http2Upgrade(
         tlsConfiguration: TLSConfiguration,
         additionalChannelHandlers: @autoclosure @escaping @Sendable () -> [any RemovableChannelHandler] = []
-    ) throws -> HTTPChannelBuilder<HTTP2UpgradeChannel> {
+    ) throws -> HTTPChannelBuilder {
         return .init { responder in
             return try HTTP2UpgradeChannel(
                 tlsConfiguration: tlsConfiguration,

diff --git a/Sources/HummingbirdTLS/TLSChannel.swift b/Sources/HummingbirdTLS/TLSChannel.swift
@@ -62,3 +62,10 @@ extension TLSChannel: HTTPChannelHandler where BaseChannel: HTTPChannelHandler {
         baseChannel.responder
     }
 }
+
+extension ServerChildChannel {
+    /// Construct existential ``TLSChannel`` from existential `ServerChildChannel`
+    func withTLS(tlsConfiguration: TLSConfiguration) throws -> any ServerChildChannel {
+        try TLSChannel(self, tlsConfiguration: tlsConfiguration)
+    }
+}
diff --git a/Sources/HummingbirdTLS/TLSChannelBuilder.swift b/Sources/HummingbirdTLS/TLSChannelBuilder.swift
@@ -29,12 +29,12 @@ extension HTTPChannelBuilder {
     ///   - base: Base child channel to wrap with TLS
     ///   - tlsConfiguration: TLS configuration
     /// - Returns: HTTPChannelHandler builder
-    public static func tls<BaseChannel: ServerChildChannel>(
-        _ base: HTTPChannelBuilder<BaseChannel> = .http1(),
+    public static func tls(
+        _ base: HTTPChannelBuilder = .http1(),
         tlsConfiguration: TLSConfiguration
-    ) throws -> HTTPChannelBuilder<TLSChannel<BaseChannel>> {
+    ) throws -> HTTPChannelBuilder {
         return .init { responder in
-            return try TLSChannel(base.build(responder), tlsConfiguration: tlsConfiguration)
+            return try base.build(responder).withTLS(tlsConfiguration: tlsConfiguration)
         }
     }
 }
diff --git a/Sources/HummingbirdTesting/TestApplication.swift b/Sources/HummingbirdTesting/TestApplication.swift
@@ -23,15 +23,14 @@ import ServiceLifecycle
 /// This is needed to override the `onServerRunning` function
 internal struct TestApplication<BaseApp: ApplicationProtocol>: ApplicationProtocol, Service {
     typealias Responder = BaseApp.Responder
-    typealias ChildChannel = BaseApp.ChildChannel
 
     let base: BaseApp
 
     var responder: Responder {
         get async throws { try await self.base.responder }
     }
 
-    var server: HTTPChannelBuilder<ChildChannel> {
+    var server: HTTPChannelBuilder {
         self.base.server
     }
 

diff --git a/Tests/HummingbirdCoreTests/CoreTests.swift b/Tests/HummingbirdCoreTests/CoreTests.swift
@@ -309,53 +309,51 @@ class HummingBirdCoreTests: XCTestCase {
     }
 
     func testChildChannelGracefulShutdown() async throws {
-        let promise = Promise<Void>()
+        let handlerPromise = Promise<Void>()
 
-        try await testServer(
-            responder: { request, _ in
-                await promise.complete(())
-                try await Task.sleep(for: .milliseconds(500))
-                return Response(status: .ok, body: .init(asyncSequence: request.body.delayed()))
-            },
-            httpChannelSetup: .http1(),
-            configuration: .init(address: .hostname(port: 0)),
-            eventLoopGroup: Self.eventLoopGroup,
-            logger: Logger(label: "Hummingbird")
-        ) { server, client in
-            try await withTimeout(.seconds(5)) {
-                try await withThrowingTaskGroup(of: Void.self) { group in
-                    group.addTask {
-                        do {
-                            let response = try await client.get("/")
-                            XCTAssertEqual(response.status, .ok)
-                        } catch {
-                            XCTFail("Error: \(error)")
-                        }
-                    }
-                    await promise.wait()
-                    try await server.shutdownGracefully()
-                    try await group.waitForAll()
-                }
-            }
+        let childChannel = try HTTPChannelBuilder.http1().build { request, _ in
+            await handlerPromise.complete(())
+            try await Task.sleep(for: .milliseconds(500))
+            return Response(status: .ok, body: .init(asyncSequence: request.body.delayed()))
         }
-    }
-
-    func testIdleChildChannelGracefulShutdown() async throws {
-        try await testServer(
-            responder: { request, _ in
-                try await Task.sleep(for: .milliseconds(500))
-                return Response(status: .ok, body: .init(asyncSequence: request.body.delayed()))
-            },
-            httpChannelSetup: .http1(),
-            configuration: .init(address: .hostname(port: 0)),
-            eventLoopGroup: Self.eventLoopGroup,
-            logger: Logger(label: "Hummingbird")
-        ) { server, client in
-            try await withTimeout(.seconds(5)) {
-                let response = try await client.get("/")
-                XCTAssertEqual(response.status, .ok)
-                try await server.shutdownGracefully()
+        await withThrowingTaskGroup(of: Void.self) { group in
+            let portPromise = Promise<Int>()
+            let logger = Logger(label: "Hummingbird")
+            let server = childChannel.server(
+                configuration: .init(address: .hostname(port: 0)),
+                onServerRunning: { await portPromise.complete($0.localAddress!.port!) },
+                eventLoopGroup: Self.eventLoopGroup,
+                logger: logger
+            )
+            let serviceGroup = ServiceGroup(
+                configuration: .init(
+                    services: [server],
+                    gracefulShutdownSignals: [.sigterm, .sigint],
+                    logger: logger
+                )
+            )
+            group.addTask {
+                try await serviceGroup.run()
+            }
+            let client = await TestClient(
+                host: "localhost",
+                port: portPromise.wait(),
+                configuration: .init(),
+                eventLoopGroupProvider: .createNew
+            )
+            group.addTask {
+                do {
+                    client.connect()
+                    let response = try await client.get("/")
+                    XCTAssertEqual(response.status, .ok)
+                } catch {
+                    XCTFail("Error: \(error)")
+                }
             }
+            // wait until we are sure handler has been called
+            await handlerPromise.wait()
+            // trigger graceful shutdown
+            await serviceGroup.triggerGracefulShutdown()
         }
     }
 }

diff --git a/Tests/HummingbirdCoreTests/HTTP2Tests.swift b/Tests/HummingbirdCoreTests/HTTP2Tests.swift
@@ -36,7 +36,7 @@ class HummingBirdHTTP2Tests: XCTestCase {
             configuration: .init(address: .hostname(port: 0), serverName: testServerName),
             eventLoopGroup: eventLoopGroup,
             logger: Logger(label: "Hummingbird")
-        ) { _, port in
+        ) { port in
             var tlsConfiguration = try getClientTLSConfiguration()
             // no way to override the SSL server name with AsyncHTTPClient so need to set
             // hostname verification off