Adopt concurrency adoption guidelines (#230)

Adopt Swift Concurrency adoption guidelines for Swift Server Libraries (swift-server/guides#70).

- Use #if compiler(>=5.5) && canImport(_Concurrency) to judge if Concurrency is available
- Some clean up

Author: stevapple

Examples/Deployment/README.md

@@ -87,7 +87,7 @@ The SAM template will provide an output labelled `LambdaApiGatewayEndpoint` whic
 
   ```
   curl <<LambdaApiGatewayEndpoint>>
-  ```  
+  ```
 
 ***Warning:*** This SAM template is only intended as a sample and creates a publicly accessible HTTP endpoint.
 
@@ -162,7 +162,7 @@ For example:
 
   ```
   curl https://r39lvhfng3.execute-api.us-east-1.amazonaws.com/api
-  ```  
+  ```
 
 ***Warning:*** This Serverless template is only intended as a sample and creates a publicly accessible HTTP endpoint.
 

Examples/Deployment/scripts/SAM/APIGateway-template.yml

@@ -12,7 +12,7 @@ provider:
               - logs:CreateLogGroup
               - logs:CreateLogStream
               - logs:PutLogEvents
-          Resource: "*"        
+          Resource: "*"
 
 functions:
     benchmarkFunction:

Examples/Deployment/scripts/serverless/APIGateway-template.yml

@@ -12,7 +12,7 @@ provider:
               - logs:CreateLogGroup
               - logs:CreateLogStream
               - logs:PutLogEvents
-          Resource: "*"        
+          Resource: "*"
 
 functions:
     hello:

Examples/Deployment/scripts/serverless/Benchmark-template.yml

@@ -53,7 +53,7 @@ public enum Lambda {
         return String(cString: value)
     }
 
-    #if swift(>=5.5)
+    #if compiler(>=5.5) && canImport(_Concurrency)
     // for testing and internal use
     @available(macOS 12, iOS 15, tvOS 15, watchOS 8, *)
     internal static func run<Handler: LambdaHandler>(configuration: Configuration = .init(), handlerType: Handler.Type) -> Result<Int, Error> {

Examples/Deployment/scripts/serverless/HelloWorld-template.yml

@@ -17,7 +17,7 @@ import NIOCore
 
 // MARK: - LambdaHandler
 
-#if compiler(>=5.5)
+#if compiler(>=5.5) && canImport(_Concurrency)
 /// Strongly typed, processing protocol for a Lambda that takes a user defined `Event` and returns a user defined `Output` async.
 @available(macOS 12, iOS 15, tvOS 15, watchOS 8, *)
 public protocol LambdaHandler: EventLoopLambdaHandler {

Sources/AWSLambdaRuntimeCore/Lambda.swift

@@ -33,9 +33,8 @@
 //     XCTAssertEqual(result, "echo" + input)
 // }
 
-#if swift(>=5.5)
+#if compiler(>=5.5) && canImport(_Concurrency)
 import AWSLambdaRuntime
-import AWSLambdaRuntimeCore
 import Dispatch
 import Logging
 import NIOCore

Sources/AWSLambdaRuntimeCore/LambdaHandler.swift

@@ -17,7 +17,7 @@ import NIOCore
 import XCTest
 
 class LambdaHandlerTest: XCTestCase {
-    #if compiler(>=5.5)
+    #if compiler(>=5.5) && canImport(_Concurrency)
 
     // MARK: - LambdaHandler
 

Sources/AWSLambdaTesting/Lambda+Testing.swift

@@ -82,7 +82,7 @@ class CodableLambdaTest: XCTestCase {
         XCTAssertEqual(response?.requestId, request.requestId)
     }
 
-    #if swift(>=5.5)
+    #if compiler(>=5.5) && canImport(_Concurrency)
     @available(macOS 12, iOS 15, tvOS 15, watchOS 8, *)
     func testCodableVoidHandler() {
         struct Handler: LambdaHandler {
@@ -183,7 +183,7 @@ private struct Response: Codable, Equatable {
     }
 }
 
-#if swift(>=5.5)
+#if compiler(>=5.5) && canImport(_Concurrency)
 // NOTE: workaround until we have async test support on linux
 //         https://github.com/apple/swift-corelibs-xctest/pull/326
 extension XCTestCase {

Tests/AWSLambdaRuntimeCoreTests/LambdaHandlerTest.swift

@@ -12,7 +12,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#if swift(>=5.5)
+#if compiler(>=5.5) && canImport(_Concurrency)
 import AWSLambdaRuntime
 import AWSLambdaTesting
 import NIOCore

Tests/AWSLambdaRuntimeTests/Lambda+CodeableTest.swift renamed to Tests/AWSLambdaRuntimeTests/Lambda+CodableTest.swift

@@ -144,7 +144,7 @@ First, add a dependency on the event packages:
 
  Beyond the small cognitive complexity of using the `EventLoopFuture` based APIs, note these APIs should be used with extra care. An `EventLoopLambdaHandler` will execute the user code on the same `EventLoop` (thread) as the library, making processing faster but requiring the user code to never call blocking APIs as it might prevent the underlying process from functioning.
 
-## Deploying to AWS Lambda   
+## Deploying to AWS Lambda
 
 To deploy Lambda functions to AWS Lambda, you need to compile the code for Amazon Linux which is the OS used on AWS Lambda microVMs, package it as a Zip file, and upload to AWS.
 
@@ -160,7 +160,7 @@ The library defines three protocols for the implementation of a Lambda Handler.
 
 ### ByteBufferLambdaHandler
 
-An `EventLoopFuture` based processing protocol for a Lambda that takes a `ByteBuffer` and returns a `ByteBuffer?` asynchronously.  
+An `EventLoopFuture` based processing protocol for a Lambda that takes a `ByteBuffer` and returns a `ByteBuffer?` asynchronously.
 
 `ByteBufferLambdaHandler` is the lowest level protocol designed to power the higher level `EventLoopLambdaHandler` and `LambdaHandler` based APIs. Users are not expected to use this protocol, though some performance sensitive applications that operate at the `ByteBuffer` level or have special serialization needs may choose to do so.