cleanup

Author: tomerd

Package.swift

@@ -4,7 +4,7 @@ import PackageDescription
 
 let package = Package(
     name: "swift-aws-lambda-runtime",
-    platforms: [ .macOS(.v10_15) ],
+    platforms: [.macOS(.v10_15)],
     products: [
         // this library exports `AWSLambdaRuntimeCore` and adds Foundation convenience methods
         .library(name: "AWSLambdaRuntime", targets: ["AWSLambdaRuntime"]),

[email protected]

@@ -12,23 +12,17 @@
 //
 //===----------------------------------------------------------------------===//
 
-#if compiler(>=5.6)
 @preconcurrency import Dispatch
-@preconcurrency import Logging
-@preconcurrency import NIOCore
-#else
-import Dispatch
 import Logging
 import NIOCore
-#endif
 
 // MARK: - InitializationContext
 
 /// Lambda runtime initialization context.
 /// The Lambda runtime generates and passes the `LambdaInitializationContext` to the Handlers
 /// ``ByteBufferLambdaHandler/makeHandler(context:)`` or ``LambdaHandler/init(context:)``
 /// as an argument.
-public struct LambdaInitializationContext: _AWSLambdaSendable {
+public struct LambdaInitializationContext: Sendable {
     /// `Logger` to log with.
     ///
     /// - note: The `LogLevel` can be configured using the `LOG_LEVEL` environment variable.
@@ -71,8 +65,8 @@ public struct LambdaInitializationContext: _AWSLambdaSendable {
 
 /// Lambda runtime context.
 /// The Lambda runtime generates and passes the `LambdaContext` to the Lambda handler as an argument.
-public struct LambdaContext: CustomDebugStringConvertible, _AWSLambdaSendable {
-    final class _Storage: _AWSLambdaSendable {
+public struct LambdaContext: CustomDebugStringConvertible, Sendable {
+    final class _Storage: Sendable {
         let requestID: String
         let traceID: String
         let invokedFunctionARN: String

[email protected]

@@ -72,8 +72,7 @@ public protocol LambdaHandler {
 
 @available(macOS 12, iOS 15, tvOS 15, watchOS 8, *)
 final class CodableLambdaHandler<Underlying: LambdaHandler, Event, Output>: ByteBufferLambdaHandler
-    where Underlying.Event == Event, Underlying.Output == Output
-{
+    where Underlying.Event == Event, Underlying.Output == Output {
     private let handler: Underlying
     private var outputBuffer: ByteBuffer
 
@@ -228,15 +227,14 @@ extension EventLoopLambdaHandler where Output == Void {
 }
 
 internal final class CodableEventLoopLambdaHandler<Underlying: EventLoopLambdaHandler, Event, Output>: ByteBufferLambdaHandler
-    where Underlying.Event == Event, Underlying.Output == Output
-{
+    where Underlying.Event == Event, Underlying.Output == Output {
     private let handler: Underlying
     private var outputBuffer: ByteBuffer
 
     @inlinable
     static func makeHandler(context: LambdaInitializationContext) -> EventLoopFuture<CodableEventLoopLambdaHandler> {
         Underlying.makeHandler(context: context).map { handler -> CodableEventLoopLambdaHandler<Underlying, Event, Output> in
-            return CodableEventLoopLambdaHandler(handler: handler, allocator: context.allocator)
+            CodableEventLoopLambdaHandler(handler: handler, allocator: context.allocator)
         }
     }
 
@@ -332,4 +330,3 @@ enum CodecError: Error {
     case responseEncoding(Error)
     case invalidString
 }
-

Sources/AWSLambdaRuntimeCore/LambdaContext.swift

@@ -29,7 +29,7 @@ internal final class LambdaRunner {
         self.runtimeClient = LambdaRuntimeClient(eventLoop: self.eventLoop, configuration: configuration.runtimeEngine)
         self.allocator = ByteBufferAllocator()
     }
-    
+
     /// Run the user provided initializer. This *must* only be called once.
     ///
     /// - Returns: An `EventLoopFuture<LambdaHandler>` fulfilled with the outcome of the initialization.
@@ -44,11 +44,8 @@ internal final class LambdaRunner {
             terminator: terminator
         )
 
-        //let x: EventLoopFuture<some ByteBufferLambdaHandler> = handlerType.makeHandler(context: context)
-        //return x.map{ $0 as any ByteBufferLambdaHandler }
-
         return handlerType.makeHandler(context: context)
-            .map{ $0 as any ByteBufferLambdaHandler }
+            .map { $0 as any ByteBufferLambdaHandler }
             // Hopping back to "our" EventLoop is important in case the factory returns a future
             // that originated from a foreign EventLoop/EventLoopGroup.
             // This can happen if the factory uses a library (let's say a database client) that manages its own threads/loops

Sources/AWSLambdaRuntimeCore/LambdaHandler.swift

@@ -19,7 +19,7 @@ import NIOCore
 /// `LambdaRuntime` manages the Lambda process lifecycle.
 ///
 /// Use this API, if you build a higher level web framework which shall be able to run inside the Lambda environment.
-public final class LambdaRuntime{
+public final class LambdaRuntime {
     private let eventLoop: EventLoop
     private let shutdownPromise: EventLoopPromise<Int>
     private let logger: Logger
@@ -41,7 +41,7 @@ public final class LambdaRuntime{
     ///     - eventLoop: An `EventLoop` to run the Lambda on.
     ///     - logger: A `Logger` to log the Lambda events.
     @available(macOS 12, iOS 15, tvOS 15, watchOS 8, *)
-    public convenience init<T: LambdaHandler> (_ handlerType: T.Type, eventLoop: EventLoop, logger: Logger) {
+    public convenience init<T: LambdaHandler>(_ handlerType: T.Type, eventLoop: EventLoop, logger: Logger) {
         self.init(CodableLambdaHandler<T, T.Event, T.Output>.self, eventLoop: eventLoop, logger: logger)
     }
 
@@ -51,7 +51,7 @@ public final class LambdaRuntime{
     ///     - handlerType: The ``EventLoopLambdaHandler`` type the `LambdaRuntime` shall create and manage.
     ///     - eventLoop: An `EventLoop` to run the Lambda on.
     ///     - logger: A `Logger` to log the Lambda events.
-    public convenience init<T: EventLoopLambdaHandler> (_ handlerType: T.Type, eventLoop: EventLoop, logger: Logger) {
+    public convenience init<T: EventLoopLambdaHandler>(_ handlerType: T.Type, eventLoop: EventLoop, logger: Logger) {
         self.init(CodableEventLoopLambdaHandler<T, T.Event, T.Output>.self, eventLoop: eventLoop, logger: logger)
     }
 
@@ -61,9 +61,8 @@ public final class LambdaRuntime{
     ///     - handlerType: The ``ByteBufferLambdaHandler`` type the `LambdaRuntime` shall create and manage.
     ///     - eventLoop: An `EventLoop` to run the Lambda on.
     ///     - logger: A `Logger` to log the Lambda events.
-    public convenience init<T: ByteBufferLambdaHandler> (_ handlerType: T.Type, eventLoop: EventLoop, logger: Logger) {
+    public convenience init<T: ByteBufferLambdaHandler>(_ handlerType: T.Type, eventLoop: EventLoop, logger: Logger) {
         self.init(T.self, eventLoop: eventLoop, logger: logger, configuration: .init())
-
     }
 
     init<Handler: ByteBufferLambdaHandler>(_ handlerType: Handler.Type, eventLoop: EventLoop, logger: Logger, configuration: LambdaConfiguration) {

Sources/AWSLambdaRuntimeCore/LambdaRunner.swift

@@ -13,13 +13,8 @@
 //===----------------------------------------------------------------------===//
 
 import Logging
-#if compiler(>=5.6)
-@preconcurrency import NIOCore
-@preconcurrency import NIOHTTP1
-#else
 import NIOCore
 import NIOHTTP1
-#endif
 
 /// An HTTP based client for AWS Runtime Engine. This encapsulates the RESTful methods exposed by the Runtime Engine:
 /// * /runtime/invocation/next

Sources/AWSLambdaRuntimeCore/LambdaRuntime.swift

@@ -100,7 +100,7 @@ extension LambdaTerminator {
 
 extension LambdaTerminator {
     fileprivate final class Storage {
-        private let lock: Lock
+        private let lock: NIOLock
         private var index: [RegistrationKey]
         private var map: [RegistrationKey: (name: String, handler: Handler)]