Remove ServerChildChannel generic associatedtype from ApplicationProtocol

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,

Sources/Hummingbird/Utils/PrecursorService.swift → Sources/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)
+    }
+}

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)
         }

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):

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
+        )
+    }
+}

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,

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)
+    }
+}

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)
         }
     }
 }

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
     }
 

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()
         }
     }
 }

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