Channel setup builder

Sources/Hummingbird/Application.swift

@@ -51,9 +51,9 @@ public protocol HBApplicationProtocol: Service where Context: HBRequestContext {
     typealias Context = Responder.Context
 
     /// Build the responder
-    func buildResponder() async throws -> Responder
+    var responder: Responder { get async throws }
     /// Server channel setup
-    func channelSetup(httpResponder: @escaping @Sendable (HBRequest, Channel) async throws -> HBResponse) throws -> ChannelSetup
+    var channelSetup: HBHTTPChannelSetupBuilder<ChannelSetup> { get }
 
     /// event loop group used by application
     var eventLoopGroup: EventLoopGroup { get }
@@ -67,11 +67,9 @@ public protocol HBApplicationProtocol: Service where Context: HBRequestContext {
     var services: [any Service] { get }
 }
 
-extension HBApplicationProtocol where ChannelSetup == HTTP1Channel {
-    /// Defautl channel setup function for HTTP1 channels
-    public func channelSetup(httpResponder: @escaping @Sendable (HBRequest, Channel) async throws -> HBResponse) -> ChannelSetup {
-        HTTP1Channel(responder: httpResponder)
-    }
+extension HBApplicationProtocol {
+    /// Server channel setup
+    public var channelSetup: HBHTTPChannelSetupBuilder<HTTP1Channel> { .http1() }
 }
 
 extension HBApplicationProtocol {
@@ -92,7 +90,7 @@ extension HBApplicationProtocol {
     /// Construct application and run it
     public func run() async throws {
         let dateCache = HBDateCache()
-        let responder = try await self.buildResponder()
+        let responder = try await self.responder
 
         // Function responding to HTTP request
         @Sendable func respond(to request: HBRequest, channel: Channel) async throws -> HBResponse {
@@ -110,7 +108,7 @@ extension HBApplicationProtocol {
             return response
         }
         // get channel Setup
-        let channelSetup = try self.channelSetup(httpResponder: respond)
+        let channelSetup = try self.channelSetup.build(respond)
         // create server
         let server = HBServer(
             childChannelSetup: channelSetup,
@@ -181,7 +179,7 @@ public struct HBApplication<Responder: HBResponder, ChannelSetup: HBChannelSetup
     /// on server running
     private var _onServerRunning: @Sendable (Channel) async -> Void
     /// Server channel setup
-    let channelSetup: ChannelSetup
+    public let channelSetup: HBHTTPChannelSetupBuilder<ChannelSetup>
     /// services attached to the application.
     public var services: [any Service]
 
@@ -190,7 +188,7 @@ public struct HBApplication<Responder: HBResponder, ChannelSetup: HBChannelSetup
     /// Initialize new Application
     public init(
         responder: Responder,
-        channelSetup: ChannelSetup = HTTP1Channel(),
+        channelSetup: HBHTTPChannelSetupBuilder<ChannelSetup> = .http1(),
         configuration: HBApplicationConfiguration = HBApplicationConfiguration(),
         eventLoopGroupProvider: EventLoopGroupProvider = .singleton
     ) {
@@ -219,12 +217,6 @@ public struct HBApplication<Responder: HBResponder, ChannelSetup: HBChannelSetup
         return self.responder
     }
 
-    public func channelSetup(httpResponder: @escaping @Sendable (HBRequest, Channel) async throws -> HBResponse) throws -> ChannelSetup {
-        var channelSetup = self.channelSetup
-        channelSetup.responder = httpResponder
-        return channelSetup
-    }
-
     public func onServerRunning(_ channel: Channel) async {
         await self._onServerRunning(channel)
     }

Sources/HummingbirdCore/Server/HTTP/HTTP1Channel.swift

@@ -22,8 +22,8 @@
     public typealias Value = NIOAsyncChannel<HTTPRequestPart, HTTPResponsePart>
 
     public init(
-        additionalChannelHandlers: @autoclosure @escaping @Sendable () -> [any RemovableChannelHandler] = [],
-        responder: @escaping @Sendable (HBRequest, Channel) async throws -> HBResponse = { _, _ in throw HBHTTPError(.notImplemented) }
+        responder: @escaping @Sendable (HBRequest, Channel) async throws -> HBResponse,
+        additionalChannelHandlers: @escaping @Sendable () -> [any RemovableChannelHandler] = { [] }
     ) {
         self.additionalChannelHandlers = additionalChannelHandlers
         self.responder = responder
@@ -51,6 +51,6 @@
         await handleHTTP(asyncChannel: asyncChannel, logger: logger)
     }
 
-    public var responder: @Sendable (HBRequest, Channel) async throws -> HBResponse
+    public let responder: @Sendable (HBRequest, Channel) async throws -> HBResponse
     let additionalChannelHandlers: @Sendable () -> [any RemovableChannelHandler]
 }

Sources/HummingbirdCore/Server/HTTP/HTTPChannelHandler.swift

@@ -21,7 +21,8 @@ import ServiceLifecycle
 
 /// Protocol for HTTP channels
 public protocol HTTPChannelHandler: HBChannelSetup {
-    var responder: @Sendable (HBRequest, Channel) async throws -> HBResponse { get set }
+    typealias Responder = @Sendable (HBRequest, Channel) async throws -> HBResponse
+    var responder: Responder { get }
 }
 
 /// Internal error thrown when an unexpected HTTP part is received eg we didn't receive

Sources/HummingbirdCore/Server/HTTP/HTTPChannelSetupBuilder.swift

@@ -0,0 +1,33 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Hummingbird server framework project
+//
+// Copyright (c) 2023 the Hummingbird authors
+// Licensed under Apache License v2.0
+//
+// See LICENSE.txt for license information
+// See hummingbird/CONTRIBUTORS.txt for the list of Hummingbird authors
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+//===----------------------------------------------------------------------===//
+
+import NIOCore
+
+/// Build Channel Setup that takes an HTTP responder
+public struct HBHTTPChannelSetupBuilder<ChannelSetup: HBChannelSetup>: Sendable {
+    public let build: @Sendable (@escaping HTTPChannelHandler.Responder) throws -> ChannelSetup
+    public init(_ build: @escaping @Sendable (@escaping HTTPChannelHandler.Responder) throws -> ChannelSetup) {
+        self.build = build
+    }
+}
+
+extension HBHTTPChannelSetupBuilder {
+    public static func http1(
+        additionalChannelHandlers: @autoclosure @escaping @Sendable () -> [any RemovableChannelHandler] = []
+    ) -> HBHTTPChannelSetupBuilder<HTTP1Channel> {
+        return .init { responder in
+            return HTTP1Channel(responder: responder, additionalChannelHandlers: additionalChannelHandlers)
+        }
+    }
+}

Sources/HummingbirdHTTP2/HTTP2Channel.swift

@@ -27,23 +27,20 @@
     public typealias Value = EventLoopFuture<NIONegotiatedHTTPVersion<HTTP1Channel.Value, (NIOAsyncChannel<HTTP2Frame, HTTP2Frame>, NIOHTTP2Handler.AsyncStreamMultiplexer<HTTP1Channel.Value>)>>
 
     private let sslContext: NIOSSLContext
-    private var http1: HTTP1Channel
+    private let http1: HTTP1Channel
     private let additionalChannelHandlers: @Sendable () -> [any RemovableChannelHandler]
-    public var responder: @Sendable (HBRequest, Channel) async throws -> HBResponse {
-        get { http1.responder }
-        set { http1.responder = newValue }
-    }
+    public var responder: @Sendable (HBRequest, Channel) async throws -> HBResponse { http1.responder }
 
     public init(
         tlsConfiguration: TLSConfiguration,
-        additionalChannelHandlers: @autoclosure @escaping @Sendable () -> [any RemovableChannelHandler] = [],
+        additionalChannelHandlers: @escaping @Sendable () -> [any RemovableChannelHandler] = { [] },
         responder: @escaping @Sendable (HBRequest, Channel) async throws -> HBResponse = { _, _ in throw HBHTTPError(.notImplemented) }
     ) throws {
         var tlsConfiguration = tlsConfiguration
         tlsConfiguration.applicationProtocols = NIOHTTP2SupportedALPNProtocols
         self.sslContext = try NIOSSLContext(configuration: tlsConfiguration)
         self.additionalChannelHandlers = additionalChannelHandlers
-        self.http1 = HTTP1Channel(additionalChannelHandlers: additionalChannelHandlers(), responder: responder)
+        self.http1 = HTTP1Channel(responder: responder, additionalChannelHandlers: additionalChannelHandlers)
     }
 
     public func initialize(channel: Channel, configuration: HBServerConfiguration, logger: Logger) -> EventLoopFuture<Value> {

Sources/HummingbirdHTTP2/HTTP2ChannelSetupBuilder.swift

@@ -0,0 +1,32 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Hummingbird server framework project
+//
+// Copyright (c) 2023 the Hummingbird authors
+// Licensed under Apache License v2.0
+//
+// See LICENSE.txt for license information
+// See hummingbird/CONTRIBUTORS.txt for the list of Hummingbird authors
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+//===----------------------------------------------------------------------===//
+
+import HummingbirdCore
+import NIOCore
+import NIOSSL
+
+extension HBHTTPChannelSetupBuilder {
+    public static func http2(
+        tlsConfiguration: TLSConfiguration,
+        additionalChannelHandlers: @autoclosure @escaping @Sendable () -> [any RemovableChannelHandler] = []
+    ) throws -> HBHTTPChannelSetupBuilder<HTTP2Channel> {
+        return .init { responder in
+            return try HTTP2Channel(
+                tlsConfiguration: tlsConfiguration,
+                additionalChannelHandlers: additionalChannelHandlers,
+                responder: responder
+            )
+        }
+    }
+}

Sources/HummingbirdTLS/TLSChannelSetup.swift

@@ -32,7 +32,6 @@
 
 extension TLSChannel: HTTPChannelHandler where BaseChannel: HTTPChannelHandler {
     public var responder: @Sendable (HBRequest, Channel) async throws -> HBResponse {
-        get { baseChannel.responder }
-        set { baseChannel.responder = newValue }
+        baseChannel.responder
     }
 }

Sources/HummingbirdTLS/TLSChannelSetupBuilder.swift

@@ -0,0 +1,27 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Hummingbird server framework project
+//
+// Copyright (c) 2023 the Hummingbird authors
+// Licensed under Apache License v2.0
+//
+// See LICENSE.txt for license information
+// See hummingbird/CONTRIBUTORS.txt for the list of Hummingbird authors
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+//===----------------------------------------------------------------------===//
+
+import HummingbirdCore
+import NIOSSL
+
+extension HBHTTPChannelSetupBuilder {
+    public static func tls<BaseChannel: HBChannelSetup>(
+        _ base: HBHTTPChannelSetupBuilder<BaseChannel> = .http1(),
+        tlsConfiguration: TLSConfiguration
+    ) throws -> HBHTTPChannelSetupBuilder<TLSChannel<BaseChannel>> {
+        return .init { responder in
+            return try TLSChannel(base.build(responder), tlsConfiguration: tlsConfiguration)
+        }
+    }
+}

Sources/HummingbirdXCT/HBXCTLive.swift

@@ -32,12 +32,12 @@ final class HBXCTLive<App: HBApplicationProtocol>: HBXCTApplication {
 
         let base: BaseApp
 
-        func buildResponder() async throws -> Responder {
-            try await self.base.buildResponder()
+        var responder: Responder {
+            get async throws { try await self.base.responder }
         }
 
-        func channelSetup(httpResponder: @escaping @Sendable (HBRequest, Channel) async throws -> HBResponse) throws -> ChannelSetup {
-            try self.base.channelSetup(httpResponder: httpResponder)
+        var channelSetup: HBHTTPChannelSetupBuilder<ChannelSetup> {
+            self.base.channelSetup
         }
 
         /// event loop group used by application

Sources/HummingbirdXCT/HBXCTRouter.swift

@@ -68,7 +68,7 @@ struct HBXCTRouter<Responder: HBResponder>: HBXCTApplication where Responder.Con
 
     init<App: HBApplicationProtocol>(app: App) async throws where App.Responder == Responder {
         self.eventLoopGroup = app.eventLoopGroup
-        self.responder = try await app.buildResponder()
+        self.responder = try await app.responder
         self.logger = app.logger
     }