fix race condition when shutting down server

motivation: fix a race condition that can lead to crash and failing tests

changes: close channel when canceling

Author: fabianfett

Sources/AWSLambdaRuntimeCore/HTTPClient.swift

@@ -274,10 +274,15 @@ private final class UnaryHandler: ChannelDuplexHandler {
             preconditionFailure("invalid state, no pending request")
         }
 
-        // As defined in RFC 2616 Section 8.1.2:
-        // [...] unless otherwise indicated, the client SHOULD assume
-        // that the server will maintain a persistent connection, even
-        // after error responses from the server.
+        // As defined in RFC 7230 Section 6.3:
+        // HTTP/1.1 defaults to the use of "persistent connections", allowing
+        // multiple requests and responses to be carried over a single
+        // connection.  The "close" connection option is used to signal that a
+        // connection will not persist after the current request/response.  HTTP
+        // implementations SHOULD support persistent connections.
+        //
+        // That's why we only assume the connection shall be closed if we receive
+        // a "connection = close" header.
         let serverCloseConnection = response.headers.first(name: "connection")?.lowercased() == "close"
 
         if !self.keepAlive || serverCloseConnection || response.version != .init(major: 1, minor: 1) {
@@ -308,6 +313,9 @@ private final class UnaryHandler: ChannelDuplexHandler {
         case is RequestCancelEvent:
             if self.pending != nil {
                 self.completeWith(.failure(HTTPClient.Errors.cancelled))
+                // after the cancel error has been send, we want to close the connection so
+                // that no more packets can be read on this connection.
+                _ = context.channel.close()
             }
         default:
             context.triggerUserOutboundEvent(event, promise: promise)

Sources/AWSLambdaRuntimeCore/LambdaLifecycle.swift

@@ -122,17 +122,21 @@ extension Lambda {
                     runner.run(logger: logger, handler: handler).whenComplete { result in
                         switch result {
                         case .success:
+                            logger.log(level: .debug, "lambda invocation sequence completed successfully")
                             // recursive! per aws lambda runtime spec the polling requests are to be done one at a time
                             _run(count + 1)
                         case .failure(HTTPClient.Errors.cancelled):
                             if case .shuttingdown = self.state {
                                 // if we ware shutting down, we expect to that the get next
                                 // invocation request might have been cancelled. For this reason we
                                 // succeed the promise here.
+                                logger.log(level: .info, "lambda invocation sequence has been cancelled for shutdown")
                                 return promise.succeed(count)
                             }
+                            logger.log(level: .error, "lambda invocation sequence has been cancelled unexpectedly")
                             promise.fail(HTTPClient.Errors.cancelled)
                         case .failure(let error):
+                            logger.log(level: .error, "lambda invocation sequence completed with error: \(error)")
                             promise.fail(error)
                         }
                     }

Sources/AWSLambdaRuntimeCore/LambdaRunner.swift

@@ -68,9 +68,6 @@ extension Lambda {
                 self.runtimeClient.reportResults(logger: logger, invocation: invocation, result: result).peekError { error in
                     logger.error("could not report results to lambda runtime engine: \(error)")
                 }
-            }.always { result in
-                // we are done!
-                logger.log(level: result.successful ? .debug : .warning, "lambda invocation sequence completed \(result.successful ? "successfully" : "with failure")")
             }
         }