breakdown examples intro separate targets (#1)

motivation: easier to reason about examples

changes:
* move each example to its own target
* update deployment script to prompt for desired target when multiple targets exist
* add code comments on what the example is about
* add feature-reach example (CurrencyExchange) to help testing use of Foundation features that require curl and libxml

Author: tomerd

Package.swift

@@ -3,19 +3,40 @@
 import PackageDescription
 
 let package = Package(
-    name: "my-lambda",
+    name: "swift-aws-lambda-runtime-samples",
     platforms: [
         .macOS(.v10_13),
     ],
     products: [
-        .executable(name: "MyLambda", targets: ["MyLambda"]),
+        // introductory example
+        .executable(name: "HelloWorld", targets: ["HelloWorld"]),
+        // good for benchmarking
+        .executable(name: "Benchmark", targets: ["Benchmark"]),
+        // demonstrate different types of error handling
+        .executable(name: "ErrorHandling", targets: ["ErrorHandling"]),
+        // demostrate how to integrate with AWS API Gateway
+        .executable(name: "APIGateway", targets: ["APIGateway"]),
+        // fully featured example with domain specific business logic
+        .executable(name: "CurrencyExchange", targets: ["CurrencyExchange"]),
+
     ],
     dependencies: [
         .package(url: "git@github.com:swift-server/swift-aws-lambda-runtime.git", .branch("master")),
     ],
     targets: [
-        // lambda code is abstracted into a library since we cant have a test target depend on an executable
-        .target(name: "MyLambda", dependencies: [
+        .target(name: "HelloWorld", dependencies: [
+            .product(name: "AWSLambdaRuntime", package: "swift-aws-lambda-runtime"),
+        ]),
+        .target(name: "Benchmark", dependencies: [
+            .product(name: "AWSLambdaRuntime", package: "swift-aws-lambda-runtime"),
+        ]),
+        .target(name: "ErrorHandling", dependencies: [
+            .product(name: "AWSLambdaRuntime", package: "swift-aws-lambda-runtime"),
+        ]),
+        .target(name: "APIGateway", dependencies: [
+            .product(name: "AWSLambdaRuntime", package: "swift-aws-lambda-runtime"),
+        ]),
+        .target(name: "CurrencyExchange", dependencies: [
             .product(name: "AWSLambdaRuntime", package: "swift-aws-lambda-runtime"),
         ]),
     ]

Sources/APIGateway/main.swift

@@ -0,0 +1,85 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the SwiftAWSLambdaRuntime open source project
+//
+// Copyright (c) 2020 Apple Inc. and the SwiftAWSLambdaRuntime project authors
+// Licensed under Apache License v2.0
+//
+// See LICENSE.txt for license information
+// See CONTRIBUTORS.txt for the list of SwiftAWSLambdaRuntime project authors
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+//===----------------------------------------------------------------------===//
+
+import AWSLambdaRuntime
+import NIO
+
+// MARK: - Run Lambda
+
+Lambda.run(APIGatewayProxyLambda())
+
+// MARK: - Handler, Request and Response
+
+// FIXME: Use proper Event abstractions once added to AWSLambdaRuntime
+struct APIGatewayProxyLambda: EventLoopLambdaHandler {
+    public typealias In = APIGatewayRequest
+    public typealias Out = APIGatewayResponse
+
+    public func handle(context: Lambda.Context, payload: APIGatewayRequest) -> EventLoopFuture<APIGatewayResponse> {
+        context.logger.debug("hello, api gateway!")
+        return context.eventLoop.makeSucceededFuture(APIGatewayResponse(statusCode: 200,
+                                                                        headers: nil,
+                                                                        multiValueHeaders: nil,
+                                                                        body: "hello, world!",
+                                                                        isBase64Encoded: false))
+    }
+}
+
+struct APIGatewayRequest: Codable {
+    let resource: String
+    let path: String
+    let httpMethod: String?
+    let headers: [String: String]?
+    let multiValueHeaders: [String: [String]]?
+    let queryStringParameters: [String: String]?
+    let multiValueQueryStringParameters: [String: [String]]?
+    let pathParameters: [String: String]?
+    let stageVariables: [String: String]?
+    let requestContext: Context?
+    let body: String?
+    let isBase64Encoded: Bool?
+
+    struct Context: Codable {
+        let accountId: String?
+        let resourceId: String?
+        let stage: String?
+        let requestId: String?
+        let identity: Identity?
+        let resourcePath: String?
+        let httpMethod: String?
+        let apiId: String
+    }
+
+    struct Identity: Codable {
+        let cognitoIdentityPoolId: String?
+        let accountId: String?
+        let cognitoIdentityId: String?
+        let caller: String?
+        let apiKey: String?
+        let sourceIp: String?
+        let cognitoAuthenticationType: String?
+        let cognitoAuthenticationProvider: String?
+        let userArn: String?
+        let userAgent: String?
+        let user: String?
+    }
+}
+
+struct APIGatewayResponse: Codable {
+    let statusCode: Int
+    let headers: [String: String]?
+    let multiValueHeaders: [String: [String]]?
+    let body: String?
+    let isBase64Encoded: Bool?
+}

Sources/Benchmark/main.swift

@@ -0,0 +1,31 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the SwiftAWSLambdaRuntime open source project
+//
+// Copyright (c) 2020 Apple Inc. and the SwiftAWSLambdaRuntime project authors
+// Licensed under Apache License v2.0
+//
+// See LICENSE.txt for license information
+// See CONTRIBUTORS.txt for the list of SwiftAWSLambdaRuntime project authors
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+//===----------------------------------------------------------------------===//
+
+import AWSLambdaRuntime
+import NIO
+
+// If you would like to benchmark Swift's Lambda Runtime,
+// use this example which is more performant.
+// `EventLoopLambdaHandler` does not offload the Lambda processing to a separate thread
+// while the closure-based handlers do.
+Lambda.run(BenchmarkHandler())
+
+struct BenchmarkHandler: EventLoopLambdaHandler {
+    typealias In = String
+    typealias Out = String
+
+    func handle(context: Lambda.Context, payload: String) -> EventLoopFuture<String> {
+        context.eventLoop.makeSucceededFuture("hello, world!")
+    }
+}