Simplify Implementation - Graceful Shutdown Not Working

Author: Andrea Scuderi

Package.swift

@@ -16,10 +16,6 @@ let package = Package(
             name: "BreezeDynamoDBService",
             targets: ["BreezeDynamoDBService"]
         ),
-        .library(
-            name: "BreezeHTTPClientService",
-            targets: ["BreezeHTTPClientService"]
-        ),
         .library(
             name: "BreezeLambdaAPI",
             targets: ["BreezeLambdaAPI"]
@@ -35,7 +31,6 @@ let package = Package(
         .package(url: "https://github.com/swift-server/swift-service-lifecycle.git", from: "2.0.0"),
         .package(url: "https://github.com/soto-project/soto.git", from: "7.0.0"),
         .package(url: "https://github.com/apple/swift-log.git", from: "1.6.2"),
-        .package(url: "https://github.com/swift-server/async-http-client.git", from: "1.24.0"),
     ],
     targets: [
         .executableTarget(
@@ -44,20 +39,12 @@ let package = Package(
                 "BreezeLambdaAPI"
             ]
         ),
-        .target(
-            name: "BreezeHTTPClientService",
-            dependencies: [
-                .product(name: "AsyncHTTPClient", package: "async-http-client"),
-                .product(name: "Logging", package: "swift-log")
-            ]
-        ),
         .target(
             name: "BreezeDynamoDBService",
             dependencies: [
                 .product(name: "SotoDynamoDB", package: "soto"),
                 .product(name: "ServiceLifecycle", package: "swift-service-lifecycle"),
                 .product(name: "Logging", package: "swift-log"),
-                "BreezeHTTPClientService"
             ]
         ),
         .target(
@@ -87,14 +74,6 @@ let package = Package(
                 .product(name: "ServiceLifecycleTestKit", package: "swift-service-lifecycle"),
                 "BreezeDynamoDBService"
             ]
-        ),
-        .testTarget(
-            name: "BreezeHTTPClientServiceTests",
-            dependencies: [
-                .product(name: "ServiceLifecycle", package: "swift-service-lifecycle"),
-                .product(name: "ServiceLifecycleTestKit", package: "swift-service-lifecycle"),
-                "BreezeHTTPClientService"
-            ]
         )
     ]
 )

Sources/BreezeDemoApplication/BreezeDemoApplication.swift

@@ -48,7 +48,7 @@ struct APIConfiguration: APIConfiguring {
 struct BreezeDemoApplication {
     static func main() async throws {
         do {
-            let lambdaAPIService = try BreezeLambdaAPI<Item>(apiConfig: APIConfiguration())
+            let lambdaAPIService = try await BreezeLambdaAPI<Item>(apiConfig: APIConfiguration())
             try await lambdaAPIService.run()
         } catch {
             print(error.localizedDescription)

Sources/BreezeDynamoDBService/BreezeDynamoDBService.swift

@@ -13,75 +13,74 @@
 //    limitations under the License.
 
 import SotoDynamoDB
+import AsyncHTTPClient
 import ServiceLifecycle
-import BreezeHTTPClientService
 import Logging
 
-public protocol BreezeDynamoDBServing: Actor, Service {
+public protocol BreezeDynamoDBServing: Actor {
     func dbManager() async -> BreezeDynamoDBManaging
+    func gracefulShutdown() throws
 }
 
 public actor BreezeDynamoDBService: BreezeDynamoDBServing {
 
-    private var _dbManager: BreezeDynamoDBManaging?
+    private let dbManager: BreezeDynamoDBManaging
     private let config: BreezeDynamoDBConfig
-    private let serviceConfig: BreezeClientServiceConfig
+    private let httpConfig: BreezeHTTPClientConfig
+    private let logger: Logger
     private let DBManagingType: BreezeDynamoDBManaging.Type
+    private var awsClient: AWSClient
+    private let httpClient: HTTPClient
 
-    public func dbManager() async -> BreezeDynamoDBManaging {
-        if let _dbManager {
-            return _dbManager
-        }
-        let httpClient = await serviceConfig.httpClientService.httpClient
-        let awsClient = AWSClient(httpClient: httpClient)
-        self.awsClient = awsClient
+    public init(
+        config: BreezeDynamoDBConfig,
+        httpConfig: BreezeHTTPClientConfig,
+        logger: Logger,
+        DBManagingType: BreezeDynamoDBManaging.Type = BreezeDynamoDBManager.self
+    ) async {
+        logger.info("Init DynamoDBService with config...")
+        logger.info("region: \(config.region)")
+        logger.info("tableName: \(config.tableName)")
+        logger.info("keyName: \(config.keyName)")
+        
+        self.config = config
+        self.httpConfig = httpConfig
+        self.logger = logger
+        self.DBManagingType = DBManagingType
+        let timeout = HTTPClient.Configuration.Timeout(
+            connect: httpConfig.timeout,
+            read: httpConfig.timeout
+        )
+        let configuration = HTTPClient.Configuration(timeout: timeout)
+        self.httpClient = HTTPClient(
+            eventLoopGroupProvider: .singleton,
+            configuration: configuration
+        )
+        self.awsClient = AWSClient(httpClient: httpClient)
         let db = SotoDynamoDB.DynamoDB(
             client: awsClient,
             region: config.region,
             endpoint: config.endpoint
         )
-        let dbManager = DBManagingType.init(
+        self.dbManager = DBManagingType.init(
             db: db,
             tableName: config.tableName,
             keyName: config.keyName
         )
-        _dbManager = dbManager
-        return dbManager
-    }
-    
-    public init(
-        config: BreezeDynamoDBConfig,
-        serviceConfig: BreezeClientServiceConfig,
-        DBManagingType: BreezeDynamoDBManaging.Type = BreezeDynamoDBManager.self
-    ) {
-        self.config = config
-        self.serviceConfig = serviceConfig
-        self.DBManagingType = DBManagingType
+        logger.info("DBManager is ready.")
     }
 
-    private var awsClient: AWSClient?
-    
-    private var logger: Logger {
-        serviceConfig.logger
+    public func dbManager() async -> BreezeDynamoDBManaging {
+        self.dbManager
     }
 
-    public func run() async throws {
-        logger.info("Starting DynamoDBService...")
-        logger.info("DynamoDBService is running with config...")
-        logger.info("region: \(config.region)")
-        logger.info("tableName: \(config.tableName)")
-        logger.info("keyName: \(config.keyName)")
-        
-        try await gracefulShutdown()
-        
+    public func gracefulShutdown() throws {
         logger.info("Stopping DynamoDBService...")
-        try await awsClient?.shutdown()
-        self.awsClient = nil
+        try awsClient.syncShutdown()
         logger.info("DynamoDBService is stopped.")
-    }
-    
-    deinit {
-        try? awsClient?.syncShutdown()
+        logger.info("Stopping HTTPClient...")
+        try httpClient.syncShutdown()
+        logger.info("HTTPClient is stopped.")
     }
 }
 

Sources/BreezeHTTPClientService/BreezeClientServiceConfig.swift renamed to Sources/BreezeDynamoDBService/BreezeHTTPClientConfig.swift

@@ -13,17 +13,18 @@
 //    limitations under the License.
 
 import Logging
+import NIOCore
 
-public struct BreezeClientServiceConfig: Sendable {
-    
-    public let httpClientService: BreezeHTTPClientServing
-    public let logger: Logger
-    
-    public init(
-        httpClientService: BreezeHTTPClientServing,
-        logger: Logger
-    ) {
-        self.httpClientService = httpClientService
+public enum BreezeClientServiceError: Error {
+    case invalidHttpClient
+}
+
+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/BreezeHTTPClientService/BreezeHTTPClientService.swift

@@ -15,33 +15,31 @@
 import SotoDynamoDB
 import ServiceLifecycle
 import BreezeDynamoDBService
-import BreezeHTTPClientService
 import AWSLambdaRuntime
 
 public actor BreezeLambdaAPI<T: BreezeCodable>: Service {
 
     let logger = Logger(label: "service-group-breeze-lambda-api")
     let timeout: TimeAmount
-    let httpClientService: BreezeHTTPClientServing
     let dynamoDBService: BreezeDynamoDBServing
     let breezeLambdaService: BreezeLambdaService<T>
     private let serviceGroup: ServiceGroup
     private let apiConfig: any APIConfiguring
 
-    public init(apiConfig: APIConfiguring = BreezeAPIConfiguration()) throws {
+    public init(apiConfig: APIConfiguring = BreezeAPIConfiguration()) async throws {
         do {
             self.apiConfig = apiConfig
             self.timeout = .seconds(apiConfig.dbTimeout)
-            self.httpClientService = BreezeHTTPClientService(
-                timeout: timeout,
+            let config = try apiConfig.getConfig()
+            let httpConfig = BreezeHTTPClientConfig(
+                timeout: .seconds(60),
                 logger: logger
             )
-            let config = try apiConfig.getConfig()
-            let serviceConfig = BreezeClientServiceConfig(
-                httpClientService: httpClientService,
+            self.dynamoDBService = await BreezeDynamoDBService(
+                config: config,
+                httpConfig: httpConfig,
                 logger: logger
             )
-            self.dynamoDBService = BreezeDynamoDBService(config: config, serviceConfig: serviceConfig)
             self.breezeLambdaService = BreezeLambdaService<T>(
                 dynamoDBService: dynamoDBService,
                 operation: try apiConfig.operation(),
@@ -50,22 +48,13 @@ public actor BreezeLambdaAPI<T: BreezeCodable>: Service {
             self.serviceGroup = ServiceGroup(
                 configuration: .init(
                     services: [
-                        .init(
-                            service: httpClientService,
-                            successTerminationBehavior: .ignore,
-                            failureTerminationBehavior: .gracefullyShutdownGroup
-                        ),
-                        .init(
-                            service: dynamoDBService,
-                            successTerminationBehavior: .gracefullyShutdownGroup,
-                            failureTerminationBehavior: .gracefullyShutdownGroup
-                        ),
                         .init(
                             service: breezeLambdaService,
                             successTerminationBehavior: .gracefullyShutdownGroup,
                             failureTerminationBehavior: .gracefullyShutdownGroup
                         )
                     ],
+                    gracefulShutdownSignals: [.sigterm],
                     logger: logger
                 )
             )

Sources/BreezeLambdaAPI/BreezeLambdaAPI.swift

@@ -40,18 +40,24 @@ actor BreezeLambdaService<T: BreezeCodable>: Service {
     }
 
     func run() async throws {
-        do {
-            logger.info("Starting BreezeLambdaService...")
-            let dbManager = await dynamoDBService.dbManager()
-            let breezeApi = BreezeLambdaHandler<T>(dbManager: dbManager, operation: operation)
-            self.breezeApi = breezeApi
-            logger.info("Starting BreezeLambdaService...")
-            let runtime = LambdaRuntime(body: handler)
-            try await runtime.run()
-            logger.info("BreezeLambdaService stopped.")
-        } catch {
-            logger.error("\(error.localizedDescription)")
-            throw error
+        let dbManager = await dynamoDBService.dbManager()
+        try await withGracefulShutdownHandler {
+            do {
+                let breezeApi = BreezeLambdaHandler<T>(dbManager: dbManager, operation: operation)
+                self.breezeApi = breezeApi
+                logger.info("Starting BreezeLambdaService...")
+                logger.info("Starting BreezeLambdaService...")
+                let runtime = LambdaRuntime(body: handler)
+                try await runtime.run()
+                logger.info("BreezeLambdaService stopped.")
+            } catch {
+                logger.error("\(error.localizedDescription)")
+                throw error
+            }
+        } onGracefulShutdown: {
+            Task {
+                try await self.dynamoDBService.gracefulShutdown()
+            }
         }
     }
 }