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"]),

Package@swift-5.5.swift

@@ -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

Package@swift-5.6.swift

@@ -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)]
 

Sources/AWSLambdaRuntimeCore/LambdaRuntimeClient.swift

@@ -17,7 +17,6 @@ import NIOCore
 import XCTest
 
 class LambdaHandlerTest: XCTestCase {
-
     // MARK: - LambdaHandler
 
     @available(macOS 12, iOS 15, tvOS 15, watchOS 8, *)

Sources/AWSLambdaRuntimeCore/Sendable.swift

@@ -13,14 +13,9 @@
 //===----------------------------------------------------------------------===//
 
 @testable import AWSLambdaRuntimeCore
-#if compiler(>=5.6)
-@preconcurrency import Logging
-@preconcurrency import NIOPosix
-#else
 import Logging
-import NIOPosix
-#endif
 import NIOCore
+import NIOPosix
 import XCTest
 
 class LambdaTest: XCTestCase {

Sources/AWSLambdaRuntimeCore/Terminator.swift

@@ -128,7 +128,6 @@ class CodableLambdaTest: XCTestCase {
         var outputBuffer: ByteBuffer?
         XCTAssertNoThrow(outputBuffer = try handler.handle(inputBuffer, context: context).wait())
         XCTAssertEqual(outputBuffer?.readableBytes, 0)
-
     }
 
     @available(macOS 12, iOS 15, tvOS 15, watchOS 8, *)

Tests/AWSLambdaRuntimeCoreTests/LambdaHandlerTest.swift

@@ -27,7 +27,7 @@ class LambdaTestingTests: XCTestCase {
             init(context: LambdaInitializationContext) {}
 
             func handle(_ event: String, context: LambdaContext) async throws -> String {
-                return event
+                event
             }
         }
 

Tests/AWSLambdaRuntimeCoreTests/LambdaTest.swift

@@ -1,4 +1,4 @@
-ARG swift_version=5.4
+ARG swift_version=5.7
 ARG base_image=swift:$swift_version-amazonlinux2
 FROM $base_image
 # needed to do again after FROM due to docker limitation
@@ -14,7 +14,7 @@ RUN echo 'export PATH="$HOME/.tools:$PATH"' >> $HOME/.profile
 
 # swiftformat (until part of the toolchain)
 
-ARG swiftformat_version=0.47.3
+ARG swiftformat_version=0.50.1
 RUN git clone --branch $swiftformat_version --depth 1 https://github.com/nicklockwood/SwiftFormat $HOME/.tools/swift-format
 RUN cd $HOME/.tools/swift-format && swift build -c release
 RUN ln -s $HOME/.tools/swift-format/.build/release/swiftformat $HOME/.tools/swiftformat