Simplify Implementation - Graceful shutdown not working

Author: Andrea Scuderi

Package.swift

@@ -14,12 +14,8 @@ let package = Package(
     platforms: platforms,
     products: [
         .library(
-            name: "BreezeLambdaWebHookService",
-            targets: ["BreezeLambdaWebHookService"]
-        ),
-        .library(
-            name: "BreezeHTTPClientService",
-            targets: ["BreezeHTTPClientService"]
+            name: "BreezeLambdaWebHook",
+            targets: ["BreezeLambdaWebHook"]
         ),
         .executable(
             name: "BreezeDemoHTTPApplication",
@@ -28,38 +24,32 @@ let package = Package(
     ],
     dependencies: [
         .package(url: "https://github.com/swift-server/swift-aws-lambda-runtime.git", branch: "main"),
+//        .package(path: "../swift-aws-lambda-runtime"),
         .package(url: "https://github.com/swift-server/swift-aws-lambda-events.git", from: "0.5.0"),
         .package(url: "https://github.com/swift-server/async-http-client.git", from: "1.11.2"),
-        .package(url: "https://github.com/apple/swift-log.git", from: "1.6.2"),
+        .package(url: "https://github.com/swift-server/swift-service-lifecycle.git", from: "2.6.3")
     ],
     targets: [
         .target(
-            name: "BreezeLambdaWebHookService",
+            name: "BreezeLambdaWebHook",
             dependencies: [
-                "BreezeHTTPClientService",
                 .product(name: "AWSLambdaRuntime", package: "swift-aws-lambda-runtime"),
                 .product(name: "AWSLambdaEvents", package: "swift-aws-lambda-events"),
                 .product(name: "AsyncHTTPClient", package: "async-http-client"),
             ]
         ),
-        .target(
-            name: "BreezeHTTPClientService",
-            dependencies: [
-                .product(name: "AsyncHTTPClient", package: "async-http-client"),
-                .product(name: "Logging", package: "swift-log")
-            ]
-        ),
         .executableTarget(
             name: "BreezeDemoHTTPApplication",
             dependencies: [
-                "BreezeLambdaWebHookService"
+                "BreezeLambdaWebHook"
             ]
         ),
         .testTarget(
             name: "BreezeLambdaWebHookTests",
             dependencies: [
                 .product(name: "AWSLambdaRuntime", package: "swift-aws-lambda-runtime"),
-                "BreezeLambdaWebHookService"
+                .product(name: "ServiceLifecycleTestKit", package: "swift-service-lifecycle"),
+                "BreezeLambdaWebHook"
             ],
             resources: [.copy("Fixtures")]
         ),

Sources/BreezeDemoHTTPApplication/BreezeDemoHTTPApplication.swift

@@ -12,12 +12,17 @@
 //    See the License for the specific language governing permissions and
 //    limitations under the License.
 
-import BreezeLambdaWebHookService
-import BreezeHTTPClientService
+import BreezeLambdaWebHook
 import AWSLambdaEvents
 import AWSLambdaRuntime
+import AsyncHTTPClient
 import Logging
+import NIOCore
+import ServiceLifecycle
 
+/// This is a simple example of a Breeze Lambda WebHook handler.
+/// It uses the BreezeHTTPClientService to make an HTTP request to example.com
+/// and returns the response body as a string.
 struct DemoLambdaHandler: BreezeLambdaWebHookHandler, Sendable {
     var handlerContext: HandlerContext
 
@@ -27,26 +32,43 @@ struct DemoLambdaHandler: BreezeLambdaWebHookHandler, Sendable {
 
     func handle(_ event: APIGatewayV2Request, context: LambdaContext) async throws -> APIGatewayV2Response {
         context.logger.info("Received event: \(event)")
-        return APIGatewayV2Response(with: "Hello World", statusCode: .ok)
+        let request = HTTPClientRequest(url: "https://example.com")
+        let response = try await handlerContext.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)")
+        return APIGatewayV2Response(with: body, statusCode: .ok)
     }
 }
 
+/// This is the main entry point for the Breeze Lambda WebHook application.
+/// It creates an instance of the BreezeHTTPApplication and runs it.
+/// The application name is used for logging and metrics.
+/// The timeout is used to set the maximum time allowed for the Lambda function to run.
+/// The default timeout is 30 seconds, but it can be changed to any value.
+///
+/// Local Testing:
+///
+/// The application will listen for incoming HTTP requests on port 7000 when run locally.
+///
+/// Use CURL to invoke the Lambda function, passing a JSON file containg API Gateway V2 request:
+///
+/// `curl -X POST 127.0.0.1:7000/invoke -H "Content-Type: application/json" -d @Tests/BreezeLambdaWebHookTests/Fixtures/get_webhook_api_gtw.json`
 @main
-struct BreezeDemoApplication {
+struct BreezeDemoHTTPApplication {
+    
+    static let applicationName = "BreezeDemoHTTPApplication"
+    static let logger = Logger(label: "BreezeDemoHTTPApplication")
+    
     static func main() async throws {
-        do {
-            let logger = Logger(label: "BreezeDemoApplication")
-            let httpClientService = BreezeHTTPClientService(
-                timeout: .seconds(60),
-                logger: logger
-            )
-            let serviceConfig = BreezeClientServiceConfig(httpClientService: httpClientService)
-            let lambdaService = BreezeLambdaWebHookService<DemoLambdaHandler>(
-                serviceConfig: serviceConfig
-            )
-            try await lambdaService.run()
-        } catch {
-            print(error.localizedDescription)
-        }
+        let config = BreezeHTTPClientConfig(
+            timeout: .seconds(30),
+            logger: logger
+        )
+        let app = BreezeLambdaWebHook<DemoLambdaHandler>(
+            name: applicationName,
+            config: config,
+        )
+        try await app.run()
     }
 }

Sources/BreezeHTTPClientService/BreezeHTTPClientService.swift

@@ -13,16 +13,18 @@
 //    limitations under the License.
 
 import Logging
+import NIOCore
 
 public enum BreezeClientServiceError: Error {
     case invalidHttpClient
 }
 
-public struct BreezeClientServiceConfig: Sendable {
-    
-    public let httpClientService: BreezeHTTPClientServing
-    
-    public init(httpClientService: BreezeHTTPClientServing) {
-        self.httpClientService = httpClientService
+public struct BreezeHTTPClientConfig: Sendable {
+    public init(timeout: TimeAmount, logger: Logger) {
+        self.timeout = timeout
+        self.logger = logger
     }
+    
+    public let timeout: TimeAmount
+    public let logger: Logger
 }

Sources/BreezeLambdaWebHookService/APIGatewayV2Request+Extensions.swift renamed to Sources/BreezeLambdaWebHook/APIGatewayV2Request+Extensions.swift

@@ -0,0 +1,47 @@
+//    Copyright 2024 (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 AWSLambdaEvents
+import AWSLambdaRuntime
+import ServiceLifecycle
+import Logging
+import NIOCore
+
+public struct BreezeLambdaWebHook<LambdaHandler: BreezeLambdaWebHookHandler>: Service {
+    
+    public let name: String
+    public let config: BreezeHTTPClientConfig
+    
+    public init(name: String, config: BreezeHTTPClientConfig) {
+        self.name = name
+        self.config = config
+    }
+    
+    public func run() async throws {
+        do {
+            let lambdaService = BreezeLambdaWebHookService<LambdaHandler>(
+                config: config
+            )
+            let serviceGroup = ServiceGroup(
+                services: [lambdaService],
+                gracefulShutdownSignals: [.sigterm],
+                logger: config.logger
+            )
+            config.logger.error("Starting \(name) ...")
+            try await serviceGroup.run()
+        } catch {
+            config.logger.error("Error running \(name): \(error.localizedDescription)")
+        }
+    }
+}

Sources/BreezeLambdaWebHookService/APIGatewayV2Response+Extensions.swift renamed to Sources/BreezeLambdaWebHook/APIGatewayV2Response+Extensions.swift

@@ -17,7 +17,6 @@ import AWSLambdaEvents
 import AWSLambdaRuntime
 import Foundation
 import ServiceLifecycle
-import BreezeHTTPClientService
 import Logging
 
 public struct HandlerContext: Sendable {
@@ -30,19 +29,37 @@ public struct HandlerContext: Sendable {
 
 public actor BreezeLambdaWebHookService<Handler: BreezeLambdaWebHookHandler>: Service {
 
-    private let serviceConfig: BreezeClientServiceConfig
-    private var handlerContext: HandlerContext?
+    let config: BreezeHTTPClientConfig
+    var handlerContext: HandlerContext?
 
-    public init(serviceConfig: BreezeClientServiceConfig) {
-        self.serviceConfig = serviceConfig
+    public init(config: BreezeHTTPClientConfig) {
+        self.config = config
     }
 
     public func run() async throws {
-        let httpClient = await serviceConfig.httpClientService.httpClient
+        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(httpClient: httpClient)
         self.handlerContext = handlerContext
         let runtime = LambdaRuntime(body: handler)
-        try await runtime.run()
+        try await withGracefulShutdownHandler {
+            try await runtime.run()
+        } onGracefulShutdown: {
+            do {
+                self.config.logger.info("Shutting down HTTP client...")
+                try httpClient.syncShutdown()
+                self.config.logger.info("HTTP client has been shut down.")
+            } catch {
+                self.config.logger.error("Error shutting down HTTP client: \(error)")
+            }
+        }
     }
 
     func handler(event: APIGatewayV2Request, context: LambdaContext) async throws -> APIGatewayV2Response {