another approach

Author: tomerd

Sources/SwiftAwsLambda/Lambda.swift

@@ -88,7 +88,7 @@ public enum Lambda {
         public let invokedFunctionArn: String
 
         /// The date that the function times out in Unix time milliseconds
-        public let deadline: Int64
+        public let deadline: DispatchWallTime
 
         /// For invocations from the AWS Mobile SDK, data about the Amazon Cognito identity provider.
         public let cognitoIdentity: String?
@@ -102,7 +102,7 @@ public enum Lambda {
         internal init(requestId: String,
                       traceId: String,
                       invokedFunctionArn: String,
-                      deadline: Int64,
+                      deadline: DispatchWallTime,
                       cognitoIdentity: String? = nil,
                       clientContext: String? = nil,
                       logger: Logger) {
@@ -118,17 +118,6 @@ 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.deadline,
+                  deadline: DispatchWallTime(millisSinceEpoch: invocation.deadline),
                   cognitoIdentity: invocation.cognitoIdentity,
                   clientContext: invocation.clientContext,
                   logger: logger)

Sources/SwiftAwsLambda/Utils.swift

@@ -64,3 +64,16 @@ internal enum Signal: Int32 {
     case ALRM = 14
     case TERM = 15
 }
+
+internal extension DispatchWallTime {
+    init(millisSinceEpoch: Int64) {
+        let nanoSinceEpoch = UInt64(millisSinceEpoch) * 1_000_000
+        let seconds = UInt64(nanoSinceEpoch / 1_000_000_000)
+        let nanoseconds = nanoSinceEpoch - (seconds * 1_000_000_000)
+        self.init(timespec: timespec(tv_sec: Int(seconds), tv_nsec: Int(nanoseconds)))
+    }
+
+    var millisSinceEpoch: Int64 {
+        return Int64(bitPattern: self.rawValue) / -1_000_000
+    }
+}

Tests/SwiftAwsLambdaTests/LambdaTest+XCTest.swift

@@ -36,6 +36,7 @@ extension LambdaTest {
             ("testBigPayload", testBigPayload),
             ("testKeepAliveServer", testKeepAliveServer),
             ("testNoKeepAliveServer", testNoKeepAliveServer),
+            ("testDeadline", testDeadline),
         ]
     }
 }

Tests/SwiftAwsLambdaTests/LambdaTest.swift

@@ -214,14 +214,43 @@ class LambdaTest: XCTestCase {
         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)
+    func testDeadline() {
+        let delta = Int.random(in: 1 ... 600)
+
+        let milli1 = Date(timeIntervalSinceNow: Double(delta)).millisSinceEpoch
+        let milli2 = (DispatchWallTime.now() + .seconds(delta)).millisSinceEpoch
+        XCTAssertEqual(Double(milli1), Double(milli2), accuracy: 2.0)
+
+        let now1 = DispatchWallTime.now()
+        let now2 = DispatchWallTime(millisSinceEpoch: Date().millisSinceEpoch)
+        XCTAssertEqual(Double(now2.rawValue), Double(now1.rawValue), accuracy: 2_000_000.0)
+
+        let future1 = DispatchWallTime.now() + .seconds(delta)
+        let future2 = DispatchWallTime(millisSinceEpoch: Date(timeIntervalSinceNow: Double(delta)).millisSinceEpoch)
+        XCTAssertEqual(Double(future1.rawValue), Double(future2.rawValue), accuracy: 2_000_000.0)
+
+        let past1 = DispatchWallTime.now() - .seconds(delta)
+        let past2 = DispatchWallTime(millisSinceEpoch: Date(timeIntervalSinceNow: Double(-delta)).millisSinceEpoch)
+        XCTAssertEqual(Double(past1.rawValue), Double(past2.rawValue), accuracy: 2_000_000.0)
+
+        let logger = Logger(label: "test")
+        let context = Lambda.Context(requestId: UUID().uuidString,
+                                     traceId: UUID().uuidString,
+                                     invokedFunctionArn: UUID().uuidString,
+                                     deadline: .now() + .seconds(1),
+                                     cognitoIdentity: nil,
+                                     clientContext: nil,
+                                     logger: logger)
+        XCTAssertGreaterThan(context.deadline, .now())
+
+        let expiredContext = Lambda.Context(requestId: UUID().uuidString,
+                                            traceId: UUID().uuidString,
+                                            invokedFunctionArn: UUID().uuidString,
+                                            deadline: .now() - .seconds(1),
+                                            cognitoIdentity: nil,
+                                            clientContext: nil,
+                                            logger: logger)
+        XCTAssertLessThan(expiredContext.deadline, .now())
     }
 }
 

Tests/SwiftAwsLambdaTests/MockLambdaServer.swift

@@ -140,7 +140,7 @@ internal final class HTTPHandler: ChannelInboundHandler {
                 }
                 responseStatus = .ok
                 responseBody = result
-                let deadline = Int64(Date(timeIntervalSinceNow: 60).timeIntervalSince1970 * 1000)
+                let deadline = Date(timeIntervalSinceNow: 60).millisSinceEpoch
                 responseHeaders = [
                     (AmazonHeaders.requestID, requestId),
                     (AmazonHeaders.invokedFunctionARN, "arn:aws:lambda:us-east-1:123456789012:function:custom-runtime"),

Tests/SwiftAwsLambdaTests/Utils.swift

@@ -93,3 +93,9 @@ struct TestError: Error, Equatable, CustomStringConvertible {
         self.description = description
     }
 }
+
+internal extension Date {
+    var millisSinceEpoch: Int64 {
+        return Int64(self.timeIntervalSince1970 * 1000)
+    }
+}