Add Deadline

Motivation:
- As a developer I want to be able to know how much time I have left to execute my lambda, before it times out

Changes:
- storing the deadline as Int64 on Context and Invocation
- added getRemainingTime() to Context which returns a TimeAmount
- in the FoundationCompat library we should offer something based on Date
- fixed MockLambdaServer to not return “keep-alive” anymore

Author: fabianfett

Sources/MockServer/main.swift

@@ -108,11 +108,12 @@ internal final class HTTPHandler: ChannelInboundHandler {
             case .json:
                 responseBody = "{ \"body\": \"\(requestId)\" }"
             }
+            let deadline = Int64(Date(timeIntervalSinceNow: 60).timeIntervalSince1970 * 1000)
             responseHeaders = [
                 (AmazonHeaders.requestID, requestId),
                 (AmazonHeaders.invokedFunctionARN, "arn:aws:lambda:us-east-1:123456789012:function:custom-runtime"),
                 (AmazonHeaders.traceID, "Root=1-5bef4de7-ad49b0e87f6ef6c87fc2e700;Parent=9a9197af755a6419;Sampled=1"),
-                (AmazonHeaders.deadline, String(Date(timeIntervalSinceNow: 60).timeIntervalSince1970 * 1000)),
+                (AmazonHeaders.deadline, String(deadline)),
             ]
         } else if request.head.uri.hasSuffix("/response") {
             responseStatus = .accepted

Sources/SwiftAwsLambda/Lambda.swift

@@ -78,20 +78,31 @@ public enum Lambda {
     }
 
     public class Context {
-        // from aws
+        /// The request ID, which identifies the request that triggered the function invocation.
         public let requestId: String
+
+        /// The AWS X-Ray tracing header.
         public let traceId: String
+
+        /// The ARN of the Lambda function, version, or alias that's specified in the invocation.
         public let invokedFunctionArn: String
-        public let deadline: String
+
+        /// The date that the function times out in Unix time milliseconds
+        public let deadline: Int64
+
+        /// For invocations from the AWS Mobile SDK, data about the Amazon Cognito identity provider.
         public let cognitoIdentity: String?
+
+        /// For invocations from the AWS Mobile SDK, data about the client application and device.
         public let clientContext: String?
-        // utility
+
+        /// a logger to log
         public let logger: Logger
 
         internal init(requestId: String,
                       traceId: String,
                       invokedFunctionArn: String,
-                      deadline: String,
+                      deadline: Int64,
                       cognitoIdentity: String? = nil,
                       clientContext: String? = nil,
                       logger: Logger) {
@@ -107,6 +118,17 @@ public enum Lambda {
             logger[metadataKey: "awsTraceId"] = .string(traceId)
             self.logger = logger
         }
+
+        @available(OSX 10.12, *)
+        public func getRemainingTime() -> TimeAmount {
+            func getTimeInMilliSeconds() -> Int64 {
+                var ts: timespec = timespec(tv_sec: 0, tv_nsec: 0)
+                clock_gettime(CLOCK_REALTIME, &ts)
+                return Int64(ts.tv_sec * 1000) + Int64(ts.tv_nsec / 1_000_000)
+            }
+
+            return .milliseconds(self.deadline - getTimeInMilliSeconds())
+        }
     }
 
     private final class Lifecycle {

Sources/SwiftAwsLambda/LambdaRunner.swift

@@ -130,7 +130,7 @@ private extension Lambda.Context {
         self.init(requestId: invocation.requestId,
                   traceId: invocation.traceId,
                   invokedFunctionArn: invocation.invokedFunctionArn,
-                  deadline: invocation.deadlineDate,
+                  deadline: invocation.deadline,
                   cognitoIdentity: invocation.cognitoIdentity,
                   clientContext: invocation.clientContext,
                   logger: logger)

Sources/SwiftAwsLambda/LambdaRuntimeClient.swift

@@ -181,7 +181,7 @@ private extension HTTPClient.Response {
 
 internal struct Invocation {
     let requestId: String
-    let deadlineDate: String
+    let deadline: Int64
     let invokedFunctionArn: String
     let traceId: String
     let clientContext: String?
@@ -192,7 +192,8 @@ internal struct Invocation {
             throw LambdaRuntimeClientError.invocationMissingHeader(AmazonHeaders.requestID)
         }
 
-        guard let unixTimeMilliseconds = headers.first(name: AmazonHeaders.deadline) else {
+        guard let deadline = headers.first(name: AmazonHeaders.deadline),
+            let unixTimeInMilliseconds = Int64(deadline) else {
             throw LambdaRuntimeClientError.invocationMissingHeader(AmazonHeaders.deadline)
         }
 
@@ -205,7 +206,7 @@ internal struct Invocation {
         }
 
         self.requestId = requestId
-        self.deadlineDate = unixTimeMilliseconds
+        self.deadline = unixTimeInMilliseconds
         self.invokedFunctionArn = invokedFunctionArn
         self.traceId = traceId
         self.clientContext = headers["Lambda-Runtime-Client-Context"].first

Tests/SwiftAwsLambdaTests/LambdaTest.swift

@@ -12,6 +12,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+import Logging
 import NIO
 @testable import SwiftAwsLambda
 import XCTest
@@ -212,6 +213,16 @@ class LambdaTest: XCTestCase {
         let result = Lambda.run(handler: EchoHandler(), configuration: configuration)
         assertLambdaLifecycleResult(result, shoudHaveRun: maxTimes)
     }
+
+    @available(OSX 10.12, *)
+    func testGetTimeRemaining() {
+        let deadline = round(Date(timeIntervalSinceNow: 60).timeIntervalSince1970 * 1000)
+        let context = Lambda.Context(requestId: "abc", traceId: "abc", invokedFunctionArn: "abc", deadline: Int64(deadline), logger: Logger(label: ""))
+
+        let remaining = context.getRemainingTime().nanoseconds
+        // maximal allowed time offset 2 milliseconds
+        XCTAssertLessThanOrEqual(abs(remaining - 60 * 1_000_000_000), 2_000_000)
+    }
 }
 
 private struct Behavior: LambdaServerBehavior {

Tests/SwiftAwsLambdaTests/MockLambdaServer.swift

@@ -140,11 +140,12 @@ internal final class HTTPHandler: ChannelInboundHandler {
                 }
                 responseStatus = .ok
                 responseBody = result
+                let deadline = Int64(Date(timeIntervalSinceNow: 60).timeIntervalSince1970 * 1000)
                 responseHeaders = [
                     (AmazonHeaders.requestID, requestId),
                     (AmazonHeaders.invokedFunctionARN, "arn:aws:lambda:us-east-1:123456789012:function:custom-runtime"),
                     (AmazonHeaders.traceID, "Root=1-5bef4de7-ad49b0e87f6ef6c87fc2e700;Parent=9a9197af755a6419;Sampled=1"),
-                    (AmazonHeaders.deadline, String(Date(timeIntervalSinceNow: 60).timeIntervalSince1970 * 1000)),
+                    (AmazonHeaders.deadline, String(deadline)),
                 ]
             case .failure(let error):
                 responseStatus = .init(statusCode: error.rawValue)
@@ -181,7 +182,9 @@ internal final class HTTPHandler: ChannelInboundHandler {
     func writeResponse(context: ChannelHandlerContext, status: HTTPResponseStatus, headers: [(String, String)]? = nil, body: String? = nil) {
         var headers = HTTPHeaders(headers ?? [])
         headers.add(name: "Content-Length", value: "\(body?.utf8.count ?? 0)")
-        headers.add(name: "Connection", value: self.keepAlive ? "keep-alive" : "close")
+        if !self.keepAlive {
+            headers.add(name: "Connection", value: "close")
+        }
         let head = HTTPResponseHead(version: HTTPVersion(major: 1, minor: 1), status: status, headers: headers)
 
         context.write(wrapOutboundOut(.head(head))).whenFailure { error in