Remove BreezeLambdaWebHookService

Author: Andrea Scuderi

Sources/BreezeDemoHTTPApplication/BreezeDemoHTTPApplication.swift

@@ -29,10 +29,14 @@ struct DemoLambdaHandler: BreezeLambdaWebHookHandler, Sendable {
         self.handlerContext = handlerContext
     }
 
+    var httpClient: HTTPClient {
+        handlerContext.httpClient
+    }
+    
     func handle(_ event: APIGatewayV2Request, context: LambdaContext) async throws -> APIGatewayV2Response {
         context.logger.info("Received event: \(event)")
         let request = HTTPClientRequest(url: "https://example.com")
-        let response = try await handlerContext.httpClient.execute(request, timeout: .seconds(5))
+        let response = try await httpClient.execute(request, timeout: .seconds(5))
         let bytes = try await response.body.collect(upTo: 1024 * 1024) // 1 MB Buffer
         let body = String(buffer: bytes)
         context.logger.info("Response body: \(body)")

Sources/BreezeLambdaWebHook/BreezeLambdaWebHook.swift

@@ -53,18 +53,20 @@ public struct BreezeLambdaWebHook<LambdaHandler: BreezeLambdaWebHookHandler>: Se
     /// handling any errors that may occur during the process.
     /// It gracefully shuts down the service on termination signals.
     public func run() async throws {
+        let handlerContext = HandlerContext(config: config)
+        let lambdaHandler = LambdaHandler(handlerContext: handlerContext)
+        let runtime = LambdaRuntime(body: lambdaHandler.handle)
+
+        let serviceGroup = ServiceGroup(
+            services: [handlerContext, runtime],
+            gracefulShutdownSignals: [.sigterm, .sigint],
+            logger: config.logger
+        )
         do {
-            let lambdaService = BreezeLambdaWebHookService<LambdaHandler>(
-                config: config
-            )
-            let serviceGroup = ServiceGroup(
-                services: [lambdaService],
-                gracefulShutdownSignals: [.sigterm, .sigint],
-                logger: config.logger
-            )
             config.logger.error("Starting \(name) ...")
             try await serviceGroup.run()
         } catch {
+            try? handlerContext.syncShutdown()
             config.logger.error("Error running \(name): \(error.localizedDescription)")
         }
     }

Sources/BreezeLambdaWebHook/BreezeLambdaWebHookHandler.swift

@@ -32,8 +32,4 @@ public extension BreezeLambdaWebHookHandler {
     var handler: String? {
         Lambda.env("_HANDLER")
     }
-    
-    var httpClient: AsyncHTTPClient.HTTPClient {
-        handlerContext.httpClient
-    }
 }

Sources/BreezeLambdaWebHook/BreezeLambdaWebHookService.swift

@@ -0,0 +1,59 @@
+//    Copyright 2023 (c) Andrea Scuderi - https://github.com/swift-serverless
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+
+import AsyncHTTPClient
+import AWSLambdaEvents
+import AWSLambdaRuntime
+#if canImport(FoundationEssentials)
+import FoundationEssentials
+#else
+import Foundation
+#endif
+import ServiceLifecycle
+import Logging
+
+public struct HandlerContext: Service {
+    public let httpClient: HTTPClient
+    private let config: BreezeHTTPClientConfig
+    
+    public init(config: BreezeHTTPClientConfig) {
+        let timeout = HTTPClient.Configuration.Timeout(
+            connect: config.timeout,
+            read: config.timeout
+        )
+        let configuration = HTTPClient.Configuration(timeout: timeout)
+        self.httpClient = HTTPClient(
+            eventLoopGroupProvider: .singleton,
+            configuration: configuration
+        )
+        self.config = config
+    }
+
+    public func run() async throws {
+        config.logger.info("BreezeHTTPClientProvider started")
+        try await gracefulShutdown()
+        config.logger.info("BreezeHTTPClientProvider is gracefully shutting down ...")
+        try await onGracefulShutdown()
+    }
+
+    public func onGracefulShutdown() async throws {
+        try await httpClient.shutdown()
+        config.logger.info("BreezeHTTPClientProvider: HTTPClient shutdown is completed.")
+    }
+
+    public func syncShutdown() throws {
+        try httpClient.syncShutdown()
+        config.logger.info("BreezeHTTPClientProvider: HTTPClient syncShutdown is completed.")
+    }
+}

Sources/BreezeLambdaWebHook/HandlerContext.swift

@@ -33,22 +33,16 @@ struct BreezeLambdaWebHookServiceTests {
 
     let decoder = JSONDecoder()
 
-    @Test("HandlerContext initializes with provided HTTP client")
-    func handlerContextInitializesWithClient() throws {
-        let httpClient = HTTPClient(eventLoopGroupProvider: .singleton)
-        defer { try? httpClient.syncShutdown() }
-        let context = HandlerContext(httpClient: httpClient)
-        #expect(context.httpClient === httpClient)
-    }
-    
     @Test("Service creates HTTP client with correct timeout configuration")
     func serviceCreatesHTTPClientWithCorrectConfig() async throws {
         try await testGracefulShutdown { gracefulShutdownTestTrigger in
             let (gracefulStream, continuation) = AsyncStream<Void>.makeStream()
             try await withThrowingTaskGroup(of: Void.self) { group in
                 let logger = Logger(label: "test")
                 let config = BreezeHTTPClientConfig(timeout: .seconds(30), logger: logger)
-                let sut = BreezeLambdaWebHookService<MockHandler>(config: config)
+                let handlerContext = HandlerContext(config: config)
+                let lambdaHandler = MockHandler(handlerContext: handlerContext)
+                let sut = LambdaRuntime(body: lambdaHandler.handle)
                 group.addTask {
                     try await Task.sleep(nanoseconds: 1_000_000_000)
                     gracefulShutdownTestTrigger.triggerGracefulShutdown()
@@ -60,12 +54,12 @@ struct BreezeLambdaWebHookServiceTests {
                     } onGracefulShutdown: {
                         logger.info("On Graceful Shutdown")
                         continuation.yield()
-                        continuation.finish()
                     }
                 }
                 for await _ in gracefulStream {
+                    continuation.finish()
+                    try handlerContext.syncShutdown()
                     logger.info("Graceful shutdown stream received")
-                    let handlerContext = try #require(await sut.handlerContext)
                     #expect(handlerContext.httpClient.configuration.timeout.read == .seconds(30))
                     #expect(handlerContext.httpClient.configuration.timeout.connect == .seconds(30))
                     group.cancelAll()
@@ -74,29 +68,16 @@ struct BreezeLambdaWebHookServiceTests {
         }
     }
 
-    @Test("Handler throws when handlerContext is nil")
-    func handlerThrowsWhenContextIsNil() async throws {
-        let logger = Logger(label: "test")
-        let config = BreezeHTTPClientConfig(timeout: .seconds(30), logger: logger)
-        let service = BreezeLambdaWebHookService<MockHandler>(config: config)
-        
-        let createRequest = try Fixtures.fixture(name: Fixtures.getWebHook, type: "json")
-        let event = try decoder.decode(APIGatewayV2Request.self, from: createRequest)
-        let context = LambdaContext(requestID: "req1", traceID: "trace1", invokedFunctionARN: "", deadline: LambdaClock().now, logger: logger)
-        
-        await #expect(throws: BreezeClientServiceError.invalidHandler) {
-            try await service.handler(event: event, context: context)
-        }
-    }
-    
     @Test("Handler delegates to specific handler implementation")
     func handlerDelegatesToImplementation() async throws {
         try await testGracefulShutdown { gracefulShutdownTestTrigger in
             let (gracefulStream, continuation) = AsyncStream<Void>.makeStream()
             try await withThrowingTaskGroup(of: Void.self) { group in
                 let logger = Logger(label: "test")
                 let config = BreezeHTTPClientConfig(timeout: .seconds(30), logger: logger)
-                let sut = BreezeLambdaWebHookService<MockHandler>(config: config)
+                let handlerContext = HandlerContext(config: config)
+                let lambdaHandler = MockHandler(handlerContext: handlerContext)
+                let sut = LambdaRuntime(body: lambdaHandler.handle)
                 group.addTask {
                     try await Task.sleep(nanoseconds: 1_000_000_000)
                     gracefulShutdownTestTrigger.triggerGracefulShutdown()
@@ -116,14 +97,13 @@ struct BreezeLambdaWebHookServiceTests {
                     let createRequest = try Fixtures.fixture(name: Fixtures.getWebHook, type: "json")
                     let event = try decoder.decode(APIGatewayV2Request.self, from: createRequest)
                     let context = LambdaContext(requestID: "req1", traceID: "trace1", invokedFunctionARN: "", deadline: LambdaClock().now, logger: logger)
-                    
-                    let response = try await sut.handler(event: event, context: context)
-                    let handlerContext = try #require(await sut.handlerContext)
+                    let response = try await lambdaHandler.handle(event, context: context)
                     #expect(response.statusCode == 200)
                     #expect(response.body == "Mock response")
                     #expect(handlerContext.httpClient.configuration.timeout.read == .seconds(30))
                     #expect(handlerContext.httpClient.configuration.timeout.connect == .seconds(30))
                     group.cancelAll()
+                    try handlerContext.syncShutdown()
                 }
             }
         }

Tests/BreezeLambdaWebHookTests/BreezeLambdaWebHookService.swift

@@ -34,17 +34,12 @@ extension Lambda {
             let logger = Logger(label: "evaluateHandler")
             let decoder = JSONDecoder()
             let encoder = JSONEncoder()
-            let timeout = HTTPClient.Configuration.Timeout(
-                connect: config.timeout,
-                read: config.timeout
-            )
-            let configuration = HTTPClient.Configuration(timeout: timeout)
-            let httpClient = HTTPClient(
-                eventLoopGroupProvider: .singleton,
-                configuration: configuration
-            )
+            let handlerContext = HandlerContext(config: config)
+            defer {
+                try? handlerContext.syncShutdown()
+            }
             let sut = handlerType.init(
-                handlerContext: HandlerContext(httpClient: httpClient)
+                handlerContext: handlerContext
             )
             let closureHandler = ClosureHandler { event, context in
                 //Inject Mock Response
@@ -69,7 +64,6 @@ extension Lambda {
             try await handler.handle(event, responseWriter: writer, context: context)
             let result = await writer.output ?? ByteBuffer()
             let value = Data(result.readableBytesView)
-            try await httpClient.shutdown()
             return try decoder.decode(APIGatewayV2Response.self, from: value)
         }
 }