Merge pull request #1278 from ashleysommer/graceful_cancel

Gracefully handle when the request_handler_task is cancelled.

sanic/app.py

@@ -571,6 +571,10 @@ class Sanic:
 
         :return: Nothing
         """
+        # Define `response` var here to remove warnings about
+        # allocation before assignment below.
+        response = None
+        cancelled = False
         try:
             # -------------------------------------------- #
             # Request Middleware
@@ -597,6 +601,13 @@ class Sanic:
                 response = handler(request, *args, **kwargs)
                 if isawaitable(response):
                     response = await response
+        except CancelledError:
+            # If response handler times out, the server handles the error
+            # and cancels the handle_request job.
+            # In this case, the transport is already closed and we cannot
+            # issue a response.
+            response = None
+            cancelled = True
         except Exception as e:
             # -------------------------------------------- #
             # Response Generation Failed
@@ -622,13 +633,22 @@ class Sanic:
             # -------------------------------------------- #
             # Response Middleware
             # -------------------------------------------- #
-            try:
+            # Don't run response middleware if response is None
-                response = await self._run_response_middleware(request,
+            if response is not None:
-                                                               response)
+                try:
-            except BaseException:
+                    response = await self._run_response_middleware(request,
-                error_logger.exception(
+                                                                   response)
-                    'Exception occurred in one of response middleware handlers'
+                except CancelledError:
-                )
+                    # Response middleware can timeout too, as above.
+                    response = None
+                    cancelled = True
+                except BaseException:
+                    error_logger.exception(
+                        'Exception occurred in one of response '
+                        'middleware handlers'
+                    )
+            if cancelled:
+                raise CancelledError()
 
         # pass the response to the correct callback
         if isinstance(response, StreamingHTTPResponse):

tests/test_response_timeout.py

@@ -7,6 +7,7 @@ from sanic.config import Config
 Config.RESPONSE_TIMEOUT = 1
 response_timeout_app = Sanic('test_response_timeout')
 response_timeout_default_app = Sanic('test_response_timeout_default')
+response_handler_cancelled_app = Sanic('test_response_handler_cancelled')
 
 
 @response_timeout_app.route('/1')
@@ -36,3 +37,29 @@ def test_default_server_error_response_timeout():
     request, response = response_timeout_default_app.test_client.get('/1')
     assert response.status == 503
     assert response.text == 'Error: Response Timeout'
+
+
+response_handler_cancelled_app.flag = False
+
+
+@response_handler_cancelled_app.exception(asyncio.CancelledError)
+def handler_cancelled(request, exception):
+    # If we get a CancelledError, it means sanic has already sent a response,
+    # we should not ever have to handle a CancelledError.
+    response_handler_cancelled_app.flag = True
+    return text("App received CancelledError!", 500)
+    # The client will never receive this response, because the socket
+    # is already closed when we get a CancelledError.
+
+
+@response_handler_cancelled_app.route('/1')
+async def handler_3(request):
+    await asyncio.sleep(2)
+    return text('OK')
+
+
+def test_response_handler_cancelled():
+    request, response = response_handler_cancelled_app.test_client.get('/1')
+    assert response.status == 503
+    assert response.text == 'Error: Response Timeout'
+    assert response_handler_cancelled_app.flag is False