writable, convenient to use for users context

Author: ktoso

Diff for: Sources/AWSLambdaRuntimeCore/LambdaContext.swift

@@ -12,10 +12,10 @@
 //
 //===----------------------------------------------------------------------===//
 
+import BaggageContext
 import Dispatch
 import Logging
 import NIO
-import BaggageContext
 
 // MARK: - InitializationContext
 
@@ -50,52 +50,118 @@ extension Lambda {
 extension Lambda {
     /// Lambda runtime context.
     /// The Lambda runtime generates and passes the `Context` to the Lambda handler as an argument.
-    public final class Context: BaggageContext.Context, CustomDebugStringConvertible {
+    public struct Context: BaggageContext.Context, CustomDebugStringConvertible {
+        private var storage: _Storage
+
+        final class _Storage {
+            var baggage: Baggage
+
+            let invokedFunctionARN: String
+            let deadline: DispatchWallTime
+            let cognitoIdentity: String?
+            let clientContext: String?
+
+            var _logger: Logger
+
+            let eventLoop: EventLoop
+            let allocator: ByteBufferAllocator
+
+            init(
+                baggage: Baggage,
+                invokedFunctionARN: String,
+                deadline: DispatchWallTime,
+                cognitoIdentity: String?,
+                clientContext: String?,
+                _logger: Logger,
+                eventLoop: EventLoop,
+                allocator: ByteBufferAllocator
+            ) {
+                self.baggage = baggage
+                self.invokedFunctionARN = invokedFunctionARN
+                self.deadline = deadline
+                self.cognitoIdentity = cognitoIdentity
+                self.clientContext = clientContext
+                self._logger = _logger
+                self.eventLoop = eventLoop
+                self.allocator = allocator
+            }
+        }
 
         /// Contains contextual metadata such as request and trace identifiers, along with other information which may
         /// be carried throughout asynchronous and cross-node boundaries (e.g. through HTTPClient calls).
-        public let baggage: Baggage
+        public var baggage: Baggage {
+            get {
+                self.storage.baggage
+            }
+            set {
+                if isKnownUniquelyReferenced(&self.storage) {
+                    self.storage.baggage = newValue
+                } else {
+                    self.storage = _Storage(
+                        baggage: newValue,
+                        invokedFunctionARN: self.storage.invokedFunctionARN,
+                        deadline: self.storage.deadline,
+                        cognitoIdentity: self.storage.cognitoIdentity,
+                        clientContext: self.storage.clientContext,
+                        _logger: self.storage._logger,
+                        eventLoop: self.storage.eventLoop,
+                        allocator: self.storage.allocator
+                    )
+                }
+            }
+        }
 
         /// The request ID, which identifies the request that triggered the function invocation.
         public var requestID: String {
-            self.baggage.lambdaRequestID
+            self.storage.baggage.lambdaRequestID
         }
 
         /// The AWS X-Ray tracing header.
         public var traceID: String {
-            self.baggage.lambdaTraceID
+            self.storage.baggage.lambdaTraceID
         }
 
         /// The ARN of the Lambda function, version, or alias that's specified in the invocation.
-        public let invokedFunctionARN: String
+        public var invokedFunctionARN: String {
+            self.storage.invokedFunctionARN
+        }
 
         /// The timestamp that the function times out
-        public let deadline: DispatchWallTime
+        public var deadline: DispatchWallTime {
+            self.storage.deadline
+        }
 
         /// For invocations from the AWS Mobile SDK, data about the Amazon Cognito identity provider.
-        public let cognitoIdentity: String?
+        public var cognitoIdentity: String? {
+            self.storage.cognitoIdentity
+        }
 
         /// For invocations from the AWS Mobile SDK, data about the client application and device.
-        public let clientContext: String?
+        public var clientContext: String? {
+            self.storage.clientContext
+        }
 
         /// `Logger` to log with, it is automatically populated with `baggage` information (such as `traceID` and `requestID`).
         ///
         /// - note: The `LogLevel` can be configured using the `LOG_LEVEL` environment variable.
         public var logger: Logger {
-            self._logger.with(self.baggage)
+            self.storage._logger.with(self.baggage)
         }
-        private var _logger: Logger
 
         /// The `EventLoop` the Lambda is executed on. Use this to schedule work with.
         /// This is useful when implementing the `EventLoopLambdaHandler` protocol.
         ///
         /// - note: The `EventLoop` is shared with the Lambda runtime engine and should be handled with extra care.
         ///         Most importantly the `EventLoop` must never be blocked.
-        public let eventLoop: EventLoop
+        public var eventLoop: EventLoop {
+            self.storage.eventLoop
+        }
 
         /// `ByteBufferAllocator` to allocate `ByteBuffer`
         /// This is useful when implementing `EventLoopLambdaHandler`
-        public let allocator: ByteBufferAllocator
+        public var allocator: ByteBufferAllocator {
+            self.storage.allocator
+        }
 
         internal init(requestID: String,
                       traceID: String,
@@ -109,15 +175,17 @@ extension Lambda {
             var baggage = Baggage.background
             baggage.lambdaRequestID = requestID
             baggage.lambdaTraceID = traceID
-            self.baggage = baggage
-            self.invokedFunctionARN = invokedFunctionARN
-            self.cognitoIdentity = cognitoIdentity
-            self.clientContext = clientContext
-            self.deadline = deadline
-            // utility
-            self.eventLoop = eventLoop
-            self.allocator = allocator
-            self._logger = logger
+            self.storage = _Storage(
+                baggage: baggage,
+                invokedFunctionARN: invokedFunctionARN,
+                deadline: deadline,
+                cognitoIdentity: cognitoIdentity,
+                clientContext: clientContext,
+                // utility
+                _logger: logger,
+                eventLoop: eventLoop,
+                allocator: allocator
+            )
         }
 
         public func getRemainingTime() -> TimeAmount {
@@ -161,7 +229,6 @@ extension Lambda {
 // MARK: - Baggage Items
 
 extension Baggage {
-
     // MARK: - Baggage: RequestID
 
     enum LambdaRequestIDKey: Key {
@@ -172,9 +239,9 @@ extension Baggage {
     /// The request ID, which identifies the request that triggered the function invocation.
     public internal(set) var lambdaRequestID: String {
         get {
-            return self[LambdaRequestIDKey.self]! // !-safe, the runtime guarantees to always set an identifier, even in testing
+            self[LambdaRequestIDKey.self]! // !-safe, the runtime guarantees to always set an identifier, even in testing
         }
-         set {
+        set {
             self[LambdaRequestIDKey.self] = newValue
         }
     }
@@ -189,11 +256,10 @@ extension Baggage {
     /// The AWS X-Ray tracing header.
     public internal(set) var lambdaTraceID: String {
         get {
-            return self[LambdaTraceIDKey.self]! // !-safe, the runtime guarantees to always set an identifier, even in testing
+            self[LambdaTraceIDKey.self]! // !-safe, the runtime guarantees to always set an identifier, even in testing
         }
         set {
             self[LambdaTraceIDKey.self] = newValue
         }
     }
-
 }

Diff for: Sources/AWSLambdaRuntimeCore/LambdaRunner.swift

@@ -101,7 +101,7 @@ extension Lambda {
 }
 
 private extension Lambda.Context {
-    convenience init(logger: Logger, eventLoop: EventLoop, allocator: ByteBufferAllocator, invocation: Lambda.Invocation) {
+    init(logger: Logger, eventLoop: EventLoop, allocator: ByteBufferAllocator, invocation: Lambda.Invocation) {
         self.init(requestID: invocation.requestID,
                   traceID: invocation.traceID,
                   invokedFunctionARN: invocation.invokedFunctionARN,