Review comments.

Author: fabianfett

Sources/AWSLambdaRuntimeCore/HTTPClient.swift

@@ -65,7 +65,7 @@ internal final class HTTPClient {
     // TODO: cap reconnect attempt
     private func execute(_ request: Request, validate: Bool = true) -> EventLoopFuture<Response> {
         if validate {
-            precondition(self.executing == false)
+            precondition(self.executing == false, "expecting single request at a time")
             self.executing = true
         }
 
@@ -83,7 +83,7 @@ internal final class HTTPClient {
 
             let promise = channel.eventLoop.makePromise(of: Response.self)
             promise.futureResult.whenComplete { _ in
-                precondition(self.executing == true)
+                precondition(self.executing == true, "invalid execution state")
                 self.executing = false
             }
             let wrapper = HTTPRequestWrapper(request: request, promise: promise)
@@ -306,10 +306,9 @@ private final class UnaryHandler: ChannelDuplexHandler {
     func triggerUserOutboundEvent(context: ChannelHandlerContext, event: Any, promise: EventLoopPromise<Void>?) {
         switch event {
         case is RequestCancelEvent:
-            guard self.pending != nil else {
-                return
+            if self.pending != nil {
+                self.completeWith(.failure(HTTPClient.Errors.cancelled))
             }
-            self.completeWith(.failure(HTTPClient.Errors.cancelled))
         default:
             context.triggerUserOutboundEvent(event, promise: promise)
         }

Sources/AWSLambdaRuntimeCore/LambdaLifecycle.swift

@@ -27,8 +27,7 @@ extension Lambda {
         private let configuration: Configuration
         private let factory: HandlerFactory
 
-        private var _state = State.idle
-        private let stateLock = Lock()
+        private var state = State.idle
 
         /// Create a new `Lifecycle`.
         ///
@@ -88,11 +87,11 @@ extension Lambda {
         public func shutdown() {
             // make this method thread safe by dispatching onto the eventloop
             self.eventLoop.execute {
-                guard case .active(let runner, _) = self.state else {
-                    return
-                }
+                let oldState = self.state
                 self.state = .shuttingdown
-                runner.cancelWaitingForNextInvocation()
+                if case .active(let runner, _) = oldState {
+                    runner.cancelWaitingForNextInvocation()
+                }
             }
         }
         #endif
@@ -130,21 +129,6 @@ extension Lambda {
             _run(0)
         }
 
-        private var state: State {
-            get {
-                self.stateLock.withLock {
-                    self._state
-                }
-            }
-            set {
-                self.stateLock.withLockVoid {
-                    precondition(newValue.order > self._state.order, "invalid state \(newValue) after \(self._state)")
-                    self._state = newValue
-                }
-                self.logger.debug("lambda lifecycle state: \(newValue)")
-            }
-        }
-
         private enum State {
             case idle
             case initializing

Sources/AWSLambdaRuntimeCore/LambdaRunner.swift

@@ -74,14 +74,12 @@ extension Lambda {
             }
         }
 
-        #if DEBUG
         /// cancels the current run, if we are waiting for next invocation (long poll from Lambda control plane)
         /// only needed for debugging purposes.
         func cancelWaitingForNextInvocation() {
             guard self.isGettingNextInvocation else { return }
             self.runtimeClient.cancel()
         }
-        #endif
     }
 }
 

Sources/AWSLambdaRuntimeCore/LambdaRuntimeClient.swift

@@ -115,12 +115,10 @@ extension Lambda {
             }
         }
 
-        #if DEBUG
         /// Cancels the current request, if one is running. Only needed for debugging purposes
         func cancel() {
             self.httpClient.cancel()
         }
-        #endif
     }
 }