update code to swift5 and nio2 (#10)

* update code to swift5 and nio2

motivation: support newer version of swift and underlying dependencies

changes:
* adjust code to swift 5
* use swift 5 result type and better error handling for json encoding/decoding
* adjust code to nio 2
* add dependency on swift-log for logging instead of print statements
* make logger as part of context
* improve error handling
* add dependecy on swift-backtrace to capture crashes
* improve lifecycle 
* adjust tests
* add default formatting rules and fix formatting
* improve readme

Author: tomerd

.swiftformat

@@ -0,0 +1,12 @@
+# file options
+
+--exclude .build
+
+# format options
+
+--self insert
+--patternlet inline
+--stripunusedargs unnamed-only
+--comments ignore
+
+# rules

Package.swift

@@ -1,9 +1,9 @@
-// swift-tools-version:4.0
+// swift-tools-version:5.0
 
 import PackageDescription
 
 var targets: [PackageDescription.Target] = [
-    .target(name: "SwiftAwsLambda", dependencies: ["NIOHTTP1"]),
+    .target(name: "SwiftAwsLambda", dependencies: ["Logging", "Backtrace", "NIOHTTP1"]),
     .target(name: "SwiftAwsLambdaSample", dependencies: ["SwiftAwsLambda"]),
     .target(name: "SwiftAwsLambdaStringSample", dependencies: ["SwiftAwsLambda"]),
     .target(name: "SwiftAwsLambdaCodableSample", dependencies: ["SwiftAwsLambda"]),
@@ -19,7 +19,9 @@ let package = Package(
         .executable(name: "SwiftAwsLambdaCodableSample", targets: ["SwiftAwsLambdaCodableSample"]),
     ],
     dependencies: [
-        .package(url: "https://github.com/apple/swift-nio.git", from: "1.0.0"),
+        .package(url: "https://github.com/apple/swift-nio.git", from: "2.0.0"),
+        .package(url: "https://github.com/apple/swift-log.git", from: "1.0.0"),
+        .package(url: "https://github.com/ianpartridge/swift-backtrace.git", from: "1.1.0"),
     ],
     targets: targets
 )

Sources/SwiftAwsLambda/HttpClient.swift

@@ -26,14 +26,14 @@ internal class HTTPClient {
 
     func get(url: String) -> EventLoopFuture<HTTPResponse> {
         guard let request = HTTPRequest(url: url, method: .GET) else {
-            return self.eventLoop.newFailedFuture(error: HTTPClientError.invalidRequest)
+            return self.eventLoop.makeFailedFuture(HTTPClientError.invalidRequest)
         }
         return self.execute(request)
     }
 
     func post(url: String, body: ByteBuffer? = nil) -> EventLoopFuture<HTTPResponse> {
         guard let request = HTTPRequest(url: url, method: .POST, body: body) else {
-            return self.eventLoop.newFailedFuture(error: HTTPClientError.invalidRequest)
+            return self.eventLoop.makeFailedFuture(HTTPClientError.invalidRequest)
         }
         return self.execute(request)
     }
@@ -42,18 +42,16 @@ internal class HTTPClient {
         let bootstrap = ClientBootstrap(group: eventLoop)
             .channelOption(ChannelOptions.socket(SocketOptionLevel(IPPROTO_TCP), TCP_NODELAY), value: 1)
             .channelInitializer { channel in
-                channel.pipeline.addHTTPClientHandlers().then {
-                    channel.pipeline.add(handler: HTTPPartsHandler())
-                }.then {
-                    channel.pipeline.add(handler: UnaryHTTPHandler())
+                channel.pipeline.addHTTPClientHandlers().flatMap {
+                    channel.pipeline.addHandlers([HTTPPartsHandler(), UnaryHTTPHandler()])
                 }
             }
 
-        return bootstrap.connect(host: request.host, port: request.port).then { channel in
-            let promise: EventLoopPromise<HTTPResponse> = channel.eventLoop.newPromise()
+        return bootstrap.connect(host: request.host, port: request.port).flatMap { channel in
+            let promise = channel.eventLoop.makePromise(of: HTTPResponse.self)
             let requestWrapper = HTTPRequestWrapper(request: request, promise: promise)
 
-            return channel.writeAndFlush(requestWrapper).then { _ in
+            return channel.writeAndFlush(NIOAny(requestWrapper)).flatMap { _ in
                 promise.futureResult
             }
         }
@@ -135,12 +133,12 @@ private struct HTTPResponseAccumulator {
         switch self.state {
         case .idle:
             preconditionFailure("no head received before body")
-        case let .head(head):
+        case .head(let head):
             self.state = .body(head, part)
         case .body(let head, var body):
             var part = part
-            body.write(buffer: &part)
-            state = .body(head, body)
+            body.writeBuffer(&part)
+            self.state = .body(head, body)
         case .end:
             preconditionFailure("request already processed")
         }
@@ -155,13 +153,13 @@ private class HTTPPartsHandler: ChannelInboundHandler, ChannelOutboundHandler {
 
     var accumulator = HTTPResponseAccumulator()
 
-    func write(ctx: ChannelHandlerContext, data: NIOAny, promise: EventLoopPromise<Void>?) {
+    func write(context: ChannelHandlerContext, data: NIOAny, promise: EventLoopPromise<Void>?) {
         let request = unwrapOutboundIn(data)
 
         var head = HTTPRequestHead(version: request.version, method: request.method, uri: request.target)
         var headers = request.headers
 
-        if request.version.major == 1 && request.version.minor == 1 && !request.headers.contains(name: "Host") {
+        if request.version.major == 1, request.version.minor == 1, !request.headers.contains(name: "Host") {
             headers.add(name: "Host", value: request.host)
         }
 
@@ -173,43 +171,43 @@ private class HTTPPartsHandler: ChannelInboundHandler, ChannelOutboundHandler {
 
         let part = HTTPClientRequestPart.head(head)
 
-        let headPromise: EventLoopPromise<Void> = ctx.eventLoop.newPromise()
-        let bodyPromise: EventLoopPromise<Void> = ctx.eventLoop.newPromise()
+        let headPromise = context.eventLoop.makePromise(of: Void.self)
+        let bodyPromise = context.eventLoop.makePromise(of: Void.self)
 
-        ctx.write(wrapOutboundOut(part), promise: headPromise)
+        context.write(wrapOutboundOut(part), promise: headPromise)
 
         if let body = request.body {
             let part = HTTPClientRequestPart.body(.byteBuffer(body))
 
-            ctx.write(wrapOutboundOut(part), promise: bodyPromise)
+            context.write(wrapOutboundOut(part), promise: bodyPromise)
         } else {
-            bodyPromise.succeed(result: ())
+            bodyPromise.succeed(())
         }
 
         if let promise = promise {
-            headPromise.futureResult.then { bodyPromise.futureResult }.cascade(promise: promise)
+            headPromise.futureResult.flatMap { bodyPromise.futureResult }.cascade(to: promise)
         }
 
-        ctx.flush()
+        context.flush()
     }
 
-    func channelRead(ctx: ChannelHandlerContext, data: NIOAny) {
+    func channelRead(context: ChannelHandlerContext, data: NIOAny) {
         let response = unwrapInboundIn(data)
 
         switch response {
-        case let .head(head):
+        case .head(let head):
             self.accumulator.handle(head)
-        case let .body(body):
+        case .body(let body):
             self.accumulator.handle(body)
         case .end:
             switch self.accumulator.state {
             case .idle:
                 preconditionFailure("no head received before end")
-            case let .head(head):
-                ctx.fireChannelRead(wrapInboundOut(HTTPResponse(status: head.status, headers: head.headers, body: nil)))
+            case .head(let head):
+                context.fireChannelRead(wrapInboundOut(HTTPResponse(status: head.status, headers: head.headers, body: nil)))
                 self.accumulator.state = .end
-            case let .body(head, body):
-                ctx.fireChannelRead(wrapInboundOut(HTTPResponse(status: head.status, headers: head.headers, body: body)))
+            case .body(let head, let body):
+                context.fireChannelRead(wrapInboundOut(HTTPResponse(status: head.status, headers: head.headers, body: body)))
                 self.accumulator.state = .end
             case .end:
                 preconditionFailure("request already processed")
@@ -225,36 +223,38 @@ private class UnaryHTTPHandler: ChannelInboundHandler, ChannelOutboundHandler {
 
     var buffer = CircularBuffer<EventLoopPromise<HTTPResponse>>()
 
-    func write(ctx: ChannelHandlerContext, data: NIOAny, promise: EventLoopPromise<Void>?) {
+    func write(context: ChannelHandlerContext, data: NIOAny, promise: EventLoopPromise<Void>?) {
         let wrapper = unwrapOutboundIn(data)
         buffer.append(wrapper.promise)
         var request = wrapper.request
         request.headers.add(name: "Connection", value: "close")
-        ctx.writeAndFlush(wrapOutboundOut(request), promise: promise)
+        context.writeAndFlush(wrapOutboundOut(request), promise: promise)
     }
 
-    func channelRead(ctx: ChannelHandlerContext, data: NIOAny) {
+    func channelRead(context: ChannelHandlerContext, data: NIOAny) {
         let response = unwrapInboundIn(data)
-        let promise = buffer.removeFirst()
-        promise.succeed(result: response)
-        ctx.close(promise: nil)
+        let promise = self.buffer.removeFirst()
+        context.close().whenComplete { _ in
+            promise.succeed(response)
+        }
     }
 
-    func errorCaught(ctx: ChannelHandlerContext, error: Error) {
-        // In HTTP we should fail all promises as we close the Channel.
-        self.failAllPromises(error: error)
-        ctx.close(promise: nil)
+    func errorCaught(context: ChannelHandlerContext, error: Error) {
+        context.close().whenComplete { _ in
+            // In HTTP we should fail all promises as we close the Channel.
+            self.failAllPromises(error: error)
+        }
     }
 
-    func channelInactive(ctx: ChannelHandlerContext) {
+    func channelInactive(context: ChannelHandlerContext) {
         // Fail all promises
         self.failAllPromises(error: HTTPClientError.connectionClosed)
-        ctx.fireChannelInactive()
+        context.fireChannelInactive()
     }
 
     private func failAllPromises(error: Error) {
         while let promise = buffer.first {
-            promise.fail(error: error)
+            promise.fail(error)
             self.buffer.removeFirst()
         }
     }

Sources/SwiftAwsLambda/Lambda+Codable.swift

@@ -43,7 +43,7 @@ extension Lambda {
 }
 
 /// A result type for a Lambda that returns a generic `Out`, having `Out` extend `Encodable`.
-public typealias LambdaCodableResult<Out> = ResultType<Out, String>
+public typealias LambdaCodableResult<Out> = Result<Out, Error>
 
 /// A callback for a Lambda that returns a `LambdaCodableResult<Out>` result type, having `Out` extend `Encodable`.
 public typealias LambdaCodableCallback<Out> = (LambdaCodableResult<Out>) -> Void
@@ -73,27 +73,31 @@ public extension LambdaCodableHandler {
 /// LambdaCodableCodec is an abstract/empty implementation for codec which does `Encodable` -> `[UInt8]` encoding and `[UInt8]` -> `Decodable' decoding.
 // TODO: would be nicer to use a protocol instead of this "abstract class", but generics get in the way
 public class LambdaCodableCodec<In: Decodable, Out: Encodable> {
-    func encode(_: Out) -> [UInt8]? { return nil }
-    func decode(_: [UInt8]) -> In? { return nil }
+    func encode(_: Out) -> Result<[UInt8], Error> { fatalError("not implmented") }
+    func decode(_: [UInt8]) -> Result<In, Error> { fatalError("not implmented") }
 }
 
 /// Default implementation of `Encodable` -> `[UInt8]` encoding and `[UInt8]` -> `Decodable' decoding
 public extension LambdaCodableHandler {
     func handle(context: LambdaContext, payload: [UInt8], callback: @escaping (LambdaResult) -> Void) {
-        guard let payloadAsCodable = codec.decode(payload) else {
-            return callback(.failure("failed decoding payload (in)"))
-        }
-        self.handle(context: context, payload: payloadAsCodable, callback: { result in
-            switch result {
-            case let .success(encodable):
-                guard let codableAsBytes = self.codec.encode(encodable) else {
-                    return callback(.failure("failed encoding result (out)"))
+        switch self.codec.decode(payload) {
+        case .failure(let error):
+            return callback(.failure(Errors.requestDecoding(error)))
+        case .success(let payloadAsCodable):
+            self.handle(context: context, payload: payloadAsCodable) { result in
+                switch result {
+                case .failure(let error):
+                    return callback(.failure(error))
+                case .success(let encodable):
+                    switch self.codec.encode(encodable) {
+                    case .failure(let error):
+                        return callback(.failure(Errors.responseEncoding(error)))
+                    case .success(let codableAsBytes):
+                        return callback(.success(codableAsBytes))
+                    }
                 }
-                return callback(.success(codableAsBytes))
-            case let .failure(error):
-                return callback(.failure(error))
             }
-        })
+        }
     }
 }
 
@@ -103,12 +107,20 @@ public extension LambdaCodableHandler {
 private class LambdaCodableJsonCodec<In: Decodable, Out: Encodable>: LambdaCodableCodec<In, Out> {
     private let encoder = JSONEncoder()
     private let decoder = JSONDecoder()
-    public override func encode(_ value: Out) -> [UInt8]? {
-        return try? [UInt8](self.encoder.encode(value))
+    public override func encode(_ value: Out) -> Result<[UInt8], Error> {
+        do {
+            return .success(try [UInt8](self.encoder.encode(value)))
+        } catch {
+            return .failure(error)
+        }
     }
 
-    public override func decode(_ data: [UInt8]) -> In? {
-        return try? self.decoder.decode(In.self, from: Data(data))
+    public override func decode(_ data: [UInt8]) -> Result<In, Error> {
+        do {
+            return .success(try self.decoder.decode(In.self, from: Data(data)))
+        } catch {
+            return .failure(error)
+        }
     }
 }
 
@@ -124,3 +136,8 @@ private struct LambdaClosureWrapper<In: Decodable, Out: Encodable>: LambdaCodabl
         self.closure(context, payload, callback)
     }
 }
+
+private enum Errors: Error {
+    case responseEncoding(Error)
+    case requestDecoding(Error)
+}

Sources/SwiftAwsLambda/Lambda+String.swift

@@ -40,7 +40,7 @@ extension Lambda {
 }
 
 /// A result type for a Lambda that returns a `String`.
-public typealias LambdaStringResult = ResultType<String, String>
+public typealias LambdaStringResult = Result<String, Error>
 
 /// A callback for a Lambda that returns a `LambdaStringResult` result type.
 public typealias LambdaStringCallback = (LambdaStringResult) -> Void
@@ -56,14 +56,14 @@ public protocol LambdaStringHandler: LambdaHandler {
 /// Default implementation of `String` -> `[UInt8]` encoding and `[UInt8]` -> `String' decoding
 public extension LambdaStringHandler {
     func handle(context: LambdaContext, payload: [UInt8], callback: @escaping LambdaCallback) {
-        self.handle(context: context, payload: String(decoding: payload, as: UTF8.self), callback: { result in
+        self.handle(context: context, payload: String(decoding: payload, as: UTF8.self)) { result in
             switch result {
-            case let .success(string):
+            case .success(let string):
                 return callback(.success([UInt8](string.utf8)))
-            case let .failure(error):
+            case .failure(let error):
                 return callback(.failure(error))
             }
-        })
+        }
     }
 }