Lambda does not require to have response. (#7)

* Lambda handler has the option to not return a ByteBuffer. (empty result)
* Tested if we can send nothing as the response.

Author: fabianfett

Examples/SquareNumber/Sources/SquareNumber/main.swift

@@ -14,6 +14,11 @@ func squareNumber(input: Input, context: Context) -> Output {
   return Output(result: squaredNumber)
 }
 
+func printNumber(input: Input, context: Context) -> EventLoopFuture<Void> {
+  context.logger.info("Number is: \(input.number)")
+  return context.eventLoop.makeSucceededFuture(Void())
+}
+
 let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
 defer {
   try! group.syncShutdownGracefully()
@@ -24,6 +29,7 @@ do {
   defer { try! runtime.syncShutdown() }
 
   runtime.register(for: "squareNumber", handler: Runtime.codable(squareNumber))
+  runtime.register(for: "printNumber",  handler: Runtime.codable(printNumber))
   try runtime.start().wait()
 }
 catch {

Examples/SquareNumber/template.yaml

@@ -27,11 +27,15 @@ Resources:
       Handler: "SquareNumber.squareNumber"
       Runtime: provided
       Layers:
-        - !Ref SwiftLayer
-      Events:
-        HelloWorld:
-          Type: Api
-          Properties:
-            Path: /hello
-            Method: get
-  
+      - !Ref SwiftLayer
+
+  PrintNumberFunction:
+    Type: AWS::Serverless::Function
+    Properties:
+      CodeUri: Examples/SquareNumber/lambda.zip
+      Handler: "SquareNumber.printNumber"
+      Runtime: provided
+      Layers:
+      - !Ref SwiftLayer
+
+

Examples/TodoAPIGateway/Package.resolved

@@ -7,9 +7,9 @@ extension Runtime {
   /// wrapper to use for the register function that wraps the encoding and decoding
   public static func codable<Event: Decodable, Result: Encodable>(
     _ handler: @escaping (Event, Context) -> EventLoopFuture<Result>)
-    -> ((NIO.ByteBuffer, Context) -> EventLoopFuture<ByteBuffer>)
+    -> ((NIO.ByteBuffer, Context) -> EventLoopFuture<ByteBuffer?>)
   {
-    return { (inputBytes: NIO.ByteBuffer, ctx: Context) -> EventLoopFuture<ByteBuffer> in
+    return { (inputBytes: NIO.ByteBuffer, ctx: Context) -> EventLoopFuture<ByteBuffer?> in
       let input: Event
       do {
         input = try JSONDecoder().decode(Event.self, from: inputBytes)
@@ -25,10 +25,27 @@ extension Runtime {
     }
   }
 
+  public static func codable<Event: Decodable>(
+    _ handler: @escaping (Event, Context) -> EventLoopFuture<Void>)
+    -> ((NIO.ByteBuffer, Context) -> EventLoopFuture<ByteBuffer?>)
+  {
+    return { (inputBytes: NIO.ByteBuffer, ctx: Context) -> EventLoopFuture<ByteBuffer?> in
+      let input: Event
+      do {
+        input = try JSONDecoder().decode(Event.self, from: inputBytes)
+      }
+      catch {
+        return ctx.eventLoop.makeFailedFuture(error)
+      }
+      
+      return handler(input, ctx).map { return nil }
+    }
+  }
+  
   /// synchronous interface to use with codable
   public static func codable<Event: Decodable, Result: Encodable>(
     _ handler: @escaping (Event, Context) throws -> (Result))
-    -> ((NIO.ByteBuffer, Context) -> EventLoopFuture<ByteBuffer>)
+    -> ((NIO.ByteBuffer, Context) -> EventLoopFuture<ByteBuffer?>)
   {
     return Runtime.codable { (event: Event, context) -> EventLoopFuture<Result> in
       let promise = context.eventLoop.makePromise(of: Result.self)

Sources/AWSLambda/Runtime+Codable.swift

@@ -66,7 +66,7 @@ final public class Runtime {
   }
 
 
-  public typealias Handler = (NIO.ByteBuffer, Context) -> EventLoopFuture<NIO.ByteBuffer>
+  public typealias Handler = (NIO.ByteBuffer, Context) -> EventLoopFuture<NIO.ByteBuffer?>
 
   /// Registers a handler function for execution by the runtime. This method is
   /// not thread safe. Therefore it is only safe to invoke this function before
@@ -118,6 +118,12 @@ final public class Runtime {
 
         guard let handler = self.handlers[self.handlerName] else {
           return self.runtimeLoop.makeFailedFuture(RuntimeError.unknownLambdaHandler(self.handlerName))
+            .flatMapError { (error) -> EventLoopFuture<Void> in
+              return self.client.postInvocationError(for: context.requestId, error: error)
+            }
+            .flatMapErrorThrowing { (error) in
+              context.logger.error("Could not post lambda result to runtime. error: \(error)")
+            }
         }
 
         return handler(byteBuffer, context)
@@ -144,4 +150,3 @@ final public class Runtime {
       }
   }
 }
-

Sources/AWSLambda/Runtime.swift

@@ -51,7 +51,7 @@ public struct Invocation {
 protocol LambdaRuntimeAPI {
 
   func getNextInvocation() -> EventLoopFuture<(Invocation, NIO.ByteBuffer)>
-  func postInvocationResponse(for requestId: String, httpBody: NIO.ByteBuffer) -> EventLoopFuture<Void>
+  func postInvocationResponse(for requestId: String, httpBody: NIO.ByteBuffer?) -> EventLoopFuture<Void>
   func postInvocationError(for requestId: String, error: Error) -> EventLoopFuture<Void>
 
   func syncShutdown() throws
@@ -86,14 +86,15 @@ extension RuntimeAPIClient: LambdaRuntimeAPI {
         guard let data = response.body else {
           throw RuntimeError.invocationMissingData
         }
-          
+
         return (try Invocation(headers: response.headers), data)
       }
   }
 
-  func postInvocationResponse(for requestId: String, httpBody: NIO.ByteBuffer) -> EventLoopFuture<Void> {
+  func postInvocationResponse(for requestId: String, httpBody: NIO.ByteBuffer?) -> EventLoopFuture<Void> {
     let url = "http://\(lambdaRuntimeAPI)/2018-06-01/runtime/invocation/\(requestId)/response"
-    return self.httpClient.post(url: url, body: .byteBuffer(httpBody))
+    let body = httpBody != nil ? HTTPClient.Body.byteBuffer(httpBody!) : nil
+    return self.httpClient.post(url: url, body: body)
       .map { (_) -> Void in }
   }
 

Sources/AWSLambda/RuntimeAPIClient.swift

@@ -10,6 +10,4 @@ enum RuntimeError: Error, Equatable {
   case unknownLambdaHandler(String)
 
   case endpointError(String)
-
-  
 }

Sources/AWSLambda/RuntimeError.swift

@@ -22,7 +22,7 @@ class RuntimeCodableTests: XCTestCase {
     let greeting: String
   }
 
-  func testHappyPath() {
+  func testCodableHandlerWithResultSuccess() {
     let eventLoopGroup = MultiThreadedEventLoopGroup(numberOfThreads: 1)
     defer {
         XCTAssertNoThrow(try eventLoopGroup.syncShutdownGracefully())
@@ -35,8 +35,8 @@ class RuntimeCodableTests: XCTestCase {
       let inputBytes = try JSONEncoder().encodeAsByteBuffer(TestRequest(name: "world"), allocator: ByteBufferAllocator())
       let ctx = try Context(environment: .forTesting(), invocation: .forTesting(), eventLoop: eventLoopGroup.next())
 
-      let response = try handler(inputBytes, ctx).flatMapThrowing { (outputBytes) -> TestResponse in
-        return try JSONDecoder().decode(TestResponse.self, from: outputBytes)
+      let response = try handler(inputBytes, ctx).flatMapThrowing { (bytes) -> TestResponse in
+        return try JSONDecoder().decode(TestResponse.self, from: bytes!)
       }.wait()
 
       XCTAssertEqual(response, TestResponse(greeting: "Hello world!"))
@@ -46,7 +46,7 @@ class RuntimeCodableTests: XCTestCase {
     }
   }
 
-  func testInvalidJSONInput() {
+  func testCodableHandlerWithResultInvalidInput() {
     let eventLoopGroup = MultiThreadedEventLoopGroup(numberOfThreads: 1)
     defer {
         XCTAssertNoThrow(try eventLoopGroup.syncShutdownGracefully())
@@ -62,7 +62,7 @@ class RuntimeCodableTests: XCTestCase {
 
       _ = try handler(inputBytes, ctx).flatMapThrowing { (outputBytes) -> TestResponse in
         XCTFail("The function should not be invoked.")
-        return try JSONDecoder().decode(TestResponse.self, from: outputBytes)
+        return try JSONDecoder().decode(TestResponse.self, from: outputBytes!)
       }.wait()
 
       XCTFail("Did not expect to succeed.")
@@ -75,7 +75,80 @@ class RuntimeCodableTests: XCTestCase {
     }
   }
 
-  func testSynchronousCodableInterface() {
+  func testCodableHandlerWithoutResultSuccess() {
+    let eventLoopGroup = MultiThreadedEventLoopGroup(numberOfThreads: 1)
+    defer {
+        XCTAssertNoThrow(try eventLoopGroup.syncShutdownGracefully())
+    }
+    let handler = Runtime.codable { (req: TestRequest, ctx) -> EventLoopFuture<Void> in
+      return ctx.eventLoop.makeSucceededFuture(Void())
+    }
+    
+    do {
+      let inputBytes = try JSONEncoder().encodeAsByteBuffer(TestRequest(name: "world"), allocator: ByteBufferAllocator())
+      let ctx = try Context(environment: .forTesting(), invocation: .forTesting(), eventLoop: eventLoopGroup.next())
+      
+      _ = try handler(inputBytes, ctx).wait()
+    }
+    catch {
+      XCTFail("Unexpected error: \(error)")
+    }
+  }
+  
+  func testCodableHandlerWithoutResultInvalidInput() {
+    let eventLoopGroup = MultiThreadedEventLoopGroup(numberOfThreads: 1)
+    defer {
+        XCTAssertNoThrow(try eventLoopGroup.syncShutdownGracefully())
+    }
+    let handler = Runtime.codable { (req: TestRequest, ctx) -> EventLoopFuture<Void> in
+      return ctx.eventLoop.makeSucceededFuture(Void())
+    }
+    
+    do {
+      var inputBytes = try JSONEncoder().encodeAsByteBuffer(TestRequest(name: "world"), allocator: ByteBufferAllocator())
+      inputBytes.setString("asd", at: 0) // destroy the json
+      let ctx = try Context(environment: .forTesting(), invocation: .forTesting(), eventLoop: eventLoopGroup.next())
+      
+      _ = try handler(inputBytes, ctx).wait()
+      
+      XCTFail("Did not expect to succeed.")
+    }
+    catch DecodingError.dataCorrupted(_) {
+      // this is our expected case
+    }
+    catch {
+      XCTFail("Unexpected error: \(error)")
+    }
+  }
+  
+  func testCodableHandlerWithoutResultFailure() {
+    let eventLoopGroup = MultiThreadedEventLoopGroup(numberOfThreads: 1)
+    defer {
+        XCTAssertNoThrow(try eventLoopGroup.syncShutdownGracefully())
+    }
+    let handler = Runtime.codable { (req: TestRequest, ctx) -> EventLoopFuture<Void> in
+      return ctx.eventLoop.makeFailedFuture(RuntimeError.unknown)
+    }
+    
+    do {
+      let inputBytes = try JSONEncoder().encodeAsByteBuffer(TestRequest(name: "world"), allocator: ByteBufferAllocator())
+      let ctx = try Context(environment: .forTesting(), invocation: .forTesting(), eventLoop: eventLoopGroup.next())
+      
+      _ = try handler(inputBytes, ctx).wait()
+      
+      XCTFail("Did not expect to reach this point")
+    }
+    catch RuntimeError.unknown {
+      // expected case
+    }
+    catch {
+      XCTFail("Unexpected error: \(error)")
+    }
+  }
+
+  // MARK: - Synchrounous Interface -
+  
+  func testSynchronousCodableInterfaceSuccess() {
     let eventLoopGroup = MultiThreadedEventLoopGroup(numberOfThreads: 1)
     defer {
         XCTAssertNoThrow(try eventLoopGroup.syncShutdownGracefully())
@@ -88,8 +161,8 @@ class RuntimeCodableTests: XCTestCase {
       let inputBytes = try JSONEncoder().encodeAsByteBuffer(TestRequest(name: "world"), allocator: ByteBufferAllocator())
       let ctx = try Context(environment: .forTesting(), invocation: .forTesting(), eventLoop: eventLoopGroup.next())
 
-      let response = try handler(inputBytes, ctx).flatMapThrowing { (outputBytes) -> TestResponse in
-        return try JSONDecoder().decode(TestResponse.self, from: outputBytes)
+      let response = try handler(inputBytes, ctx).flatMapThrowing { (bytes) -> TestResponse in
+        return try JSONDecoder().decode(TestResponse.self, from: bytes!)
       }.wait()
 
       XCTAssertEqual(response, TestResponse(greeting: "Hello world!"))

Tests/AWSLambdaTests/Runtime+CodableTests.swift

@@ -66,7 +66,7 @@ class RuntimeTests: XCTestCase {
     }
   }
 
-  func testCreateRuntimeMissingHanlder() {
+  func testCreateRuntimeMissingHandler() {
     setenv("AWS_LAMBDA_RUNTIME_API", "localhost", 1)
     unsetenv("_HANDLER")
 

Tests/AWSLambdaTests/RuntimeTests.swift

@@ -48,7 +48,7 @@ extension MockLambdaRuntimeAPI: LambdaRuntimeAPI {
     }
   }
 
-  func postInvocationResponse(for requestId: String, httpBody: ByteBuffer) -> EventLoopFuture<Void> {
+  func postInvocationResponse(for requestId: String, httpBody: ByteBuffer?) -> EventLoopFuture<Void> {
     return self.runLoop.makeSucceededFuture(Void())
   }