Optional uvloop use

sanic/app.py

@@ -67,6 +67,7 @@
     URLBuildError,
 )
 from sanic.handlers import ErrorHandler
+from sanic.helpers import _default
 from sanic.log import LOGGING_CONFIG_DEFAULTS, Colors, error_logger, logger
 from sanic.mixins.listeners import ListenerEvent
 from sanic.models.futures import (
@@ -85,7 +86,7 @@
 from sanic.router import Router
 from sanic.server import AsyncioServer, HttpProtocol
 from sanic.server import Signal as ServerSignal
-from sanic.server import serve, serve_multiple, serve_single
+from sanic.server import serve, serve_multiple, serve_single, try_use_uvloop
 from sanic.server.protocols.websocket_protocol import WebSocketProtocol
 from sanic.server.websockets.impl import ConnectionClosed
 from sanic.signals import Signal, SignalRouter
@@ -1103,6 +1104,11 @@ def run(
             register_sys_signals=register_sys_signals,
         )
 
+        if self.config.USE_UVLOOP is True or (
+            self.config.USE_UVLOOP is _default and not OS_IS_WINDOWS
+        ):
+            try_use_uvloop()
+
         try:
             self.is_running = True
             self.is_stopping = False
@@ -1199,12 +1205,13 @@ async def create_server(
                 WebSocketProtocol if self.websocket_enabled else HttpProtocol
             )
 
-        # if access_log is passed explicitly change config.ACCESS_LOG
-        if access_log is not None:
-            self.config.ACCESS_LOG = access_log
-
-        if noisy_exceptions is not None:
-            self.config.NOISY_EXCEPTIONS = noisy_exceptions
+        # Set explicitly passed configuration values
+        for attribute, value in {
+            "ACCESS_LOG": access_log,
+            "NOISY_EXCEPTIONS": noisy_exceptions,
+        }.items():
+            if value is not None:
+                setattr(self.config, attribute, value)
 
         server_settings = self._helper(
             host=host,
@@ -1219,6 +1226,13 @@ async def create_server(
             run_async=return_asyncio_server,
         )
 
+        if self.config.USE_UVLOOP is not _default:
+            error_logger.warning(
+                "You are trying to configure uvloop, but this is only "
+                "supported when using the run(...) method. Sanic will now "
+                "continue to run using the existing event loop."
+            )
+
         main_start = server_settings.pop("main_start", None)
         main_stop = server_settings.pop("main_stop", None)
         if main_start or main_stop:

sanic/compat.py

@@ -8,6 +8,14 @@
 
 
 OS_IS_WINDOWS = os.name == "nt"
+UVLOOP_INSTALLED = False
+
+try:
+    import uvloop  # type: ignore # noqa
+
+    UVLOOP_INSTALLED = True
+except ImportError:
+    pass
 
 
 def enable_windows_color_support():

sanic/config.py

@@ -7,6 +7,7 @@
 from warnings import warn
 
 from sanic.errorpages import check_error_format
+from sanic.helpers import Default, _default
 from sanic.http import Http
 from sanic.utils import load_module_from_file_location, str_to_bool
 
@@ -40,6 +41,7 @@
     "REQUEST_MAX_SIZE": 100000000,  # 100 megabytes
     "REQUEST_TIMEOUT": 60,  # 60 seconds
     "RESPONSE_TIMEOUT": 60,  # 60 seconds
+    "USE_UVLOOP": _default,
     "WEBSOCKET_MAX_SIZE": 2 ** 20,  # 1 megabyte
     "WEBSOCKET_PING_INTERVAL": 20,
     "WEBSOCKET_PING_TIMEOUT": 20,
@@ -69,6 +71,7 @@ class Config(dict):
     REQUEST_TIMEOUT: int
     RESPONSE_TIMEOUT: int
     SERVER_NAME: str
+    USE_UVLOOP: Union[Default, bool]
     WEBSOCKET_MAX_SIZE: int
     WEBSOCKET_PING_INTERVAL: int
     WEBSOCKET_PING_TIMEOUT: int

sanic/server/__init__.py

@@ -1,20 +1,10 @@
-import asyncio
-
 from sanic.models.server_types import ConnInfo, Signal
 from sanic.server.async_server import AsyncioServer
+from sanic.server.loop import try_use_uvloop
 from sanic.server.protocols.http_protocol import HttpProtocol
 from sanic.server.runners import serve, serve_multiple, serve_single
 
 
-try:
-    import uvloop  # type: ignore
-
-    if not isinstance(asyncio.get_event_loop_policy(), uvloop.EventLoopPolicy):
-        asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
-except ImportError:
-    pass
-
-
 __all__ = (
     "AsyncioServer",
     "ConnInfo",
@@ -23,4 +13,5 @@
     "serve",
     "serve_multiple",
     "serve_single",
+    "try_use_uvloop",
 )

sanic/server/loop.py

@@ -0,0 +1,49 @@
+import asyncio
+
+from distutils.util import strtobool
+from os import getenv
+
+from sanic.compat import OS_IS_WINDOWS
+from sanic.log import error_logger
+
+
+def try_use_uvloop() -> None:
+    """
+    Use uvloop instead of the default asyncio loop.
+    """
+    if OS_IS_WINDOWS:
+        error_logger.warning(
+            "You are trying to use uvloop, but uvloop is not compatible "
+            "with your system. You can disable uvloop completely by setting "
+            "the 'USE_UVLOOP' configuration value to false, or simply not "
+            "defining it and letting Sanic handle it for you. Sanic will now "
+            "continue to run using the default event loop."
+        )
+        return
+
+    try:
+        import uvloop  # type: ignore
+    except ImportError:
+        error_logger.warning(
+            "You are trying to use uvloop, but uvloop is not "
+            "installed in your system. In order to use uvloop "
+            "you must first install it. Otherwise, you can disable "
+            "uvloop completely by setting the 'USE_UVLOOP' "
+            "configuration value to false. Sanic will now continue "
+            "to run with the default event loop."
+        )
+        return
+
+    uvloop_install_removed = strtobool(getenv("SANIC_NO_UVLOOP", "no"))
+    if uvloop_install_removed:
+        error_logger.info(
+            "You are requesting to run Sanic using uvloop, but the "
+            "install-time 'SANIC_NO_UVLOOP' environment variable (used to "
+            "opt-out of installing uvloop with Sanic) is set to true. If "
+            "you want to prevent Sanic from overriding the event loop policy "
+            "during runtime, set the 'USE_UVLOOP' configuration value to "
+            "false."
+        )
+
+    if not isinstance(asyncio.get_event_loop_policy(), uvloop.EventLoopPolicy):
+        asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())

sanic/worker.py

@@ -7,8 +7,9 @@
 
 from gunicorn.workers import base  # type: ignore
 
+from sanic.compat import UVLOOP_INSTALLED
 from sanic.log import logger
-from sanic.server import HttpProtocol, Signal, serve
+from sanic.server import HttpProtocol, Signal, serve, try_use_uvloop
 from sanic.server.protocols.websocket_protocol import WebSocketProtocol
 
 
@@ -17,12 +18,8 @@
 except ImportError:
     ssl = None  # type: ignore
 
-try:
-    import uvloop  # type: ignore
-
-    asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
-except ImportError:
-    pass
+if UVLOOP_INSTALLED:
+    try_use_uvloop()
 
 
 class GunicornWorker(base.Worker):

tests/test_app.py

@@ -9,8 +9,10 @@
 
 import py
 import pytest
+import sanic
 
 from sanic import Sanic
+from sanic.compat import OS_IS_WINDOWS, UVLOOP_INSTALLED
 from sanic.config import Config
 from sanic.exceptions import SanicException
 from sanic.response import text
@@ -21,15 +23,6 @@ def clear_app_registry():
     Sanic._app_registry = {}
 
 
-def uvloop_installed():
-    try:
-        import uvloop  # noqa
-
-        return True
-    except ImportError:
-        return False
-
-
 def test_app_loop_running(app):
     @app.get("/test")
     async def handler(request):
@@ -41,7 +34,7 @@ async def handler(request):
 
 
 def test_create_asyncio_server(app):
-    if not uvloop_installed():
+    if not UVLOOP_INSTALLED:
         loop = asyncio.get_event_loop()
         asyncio_srv_coro = app.create_server(return_asyncio_server=True)
         assert isawaitable(asyncio_srv_coro)
@@ -50,7 +43,7 @@ def test_create_asyncio_server(app):
 
 
 def test_asyncio_server_no_start_serving(app):
-    if not uvloop_installed():
+    if not UVLOOP_INSTALLED:
         loop = asyncio.get_event_loop()
         asyncio_srv_coro = app.create_server(
             port=43123,
@@ -62,7 +55,7 @@ def test_asyncio_server_no_start_serving(app):
 
 
 def test_asyncio_server_start_serving(app):
-    if not uvloop_installed():
+    if not UVLOOP_INSTALLED:
         loop = asyncio.get_event_loop()
         asyncio_srv_coro = app.create_server(
             port=43124,
@@ -448,6 +441,92 @@ class CustomContext:
     assert app.ctx == ctx
 
 
+def test_uvloop_config(app, monkeypatch):
+    @app.get("/test")
+    def handler(request):
+        return text("ok")
+
+    try_use_uvloop = Mock()
+    monkeypatch.setattr(sanic.app, "try_use_uvloop", try_use_uvloop)
+
+    # Default config
+    app.test_client.get("/test")
+    if OS_IS_WINDOWS:
+        try_use_uvloop.assert_not_called()
+    else:
+        try_use_uvloop.assert_called_once()
+
+    try_use_uvloop.reset_mock()
+    app.config["USE_UVLOOP"] = False
+    app.test_client.get("/test")
+    try_use_uvloop.assert_not_called()
+
+    try_use_uvloop.reset_mock()
+    app.config["USE_UVLOOP"] = True
+    app.test_client.get("/test")
+    try_use_uvloop.assert_called_once()
+
+
+def test_uvloop_is_never_called_with_create_server(app, caplog, monkeypatch):
+    @app.get("/test")
+    def handler(request):
+        return text("ok")
+
+    try_use_uvloop = Mock()
+    monkeypatch.setattr(sanic.app, "try_use_uvloop", try_use_uvloop)
+
+    loop = asyncio.get_event_loop()
+
+    # Default config
+    asyncio_srv_coro = app.create_server(
+        return_asyncio_server=True,
+        asyncio_server_kwargs=dict(start_serving=False)
+    )
+    loop.run_until_complete(asyncio_srv_coro)
+    try_use_uvloop.assert_not_called()
+
+    app.config["USE_UVLOOP"] = False
+    asyncio_srv_coro = app.create_server(
+        return_asyncio_server=True,
+        asyncio_server_kwargs=dict(start_serving=False)
+    )
+
+    with caplog.at_level(logging.WARNING):
+        loop.run_until_complete(asyncio_srv_coro)
+
+    for record in caplog.records:
+        if record.message.startswith("You are trying to configure"):
+            break
+
+    assert record.message == (
+        "You are trying to configure uvloop, but this is only "
+        "supported when using the run(...) method. Sanic will now "
+        "continue to run using the existing event loop."
+    )
+
+    try_use_uvloop.assert_not_called()
+
+    app.config["USE_UVLOOP"] = True
+    asyncio_srv_coro = app.create_server(
+        return_asyncio_server=True,
+        asyncio_server_kwargs=dict(start_serving=False)
+    )
+
+    with caplog.at_level(logging.WARNING):
+        loop.run_until_complete(asyncio_srv_coro)
+    try_use_uvloop.assert_not_called()
+
+    for record in caplog.records:
+        if record.message.startswith("You are trying to configure"):
+            break
+
+    assert record.message == (
+        "You are trying to configure uvloop, but this is only "
+        "supported when using the run(...) method. Sanic will now "
+        "continue to run using the existing event loop."
+    )
+
+
 def test_cannot_run_fast_and_workers(app):
     message = "You cannot use both fast=True and workers=X"
     with pytest.raises(RuntimeError, match=message):

tests/test_exceptions.py

@@ -271,9 +271,13 @@ async def feed(request, ws):
     with caplog.at_level(logging.INFO):
         app.test_client.websocket("/feed")
 
-    error_logs = [r for r in caplog.record_tuples if r[0] == "sanic.error"]
-    assert error_logs[1][1] == logging.ERROR
-    assert "Exception occurred while handling uri:" in error_logs[1][2]
+    for record in caplog.record_tuples:
+        if record[2].startswith("Exception occurred"):
+            break
+
+    assert record[0] == "sanic.error"
+    assert record[1] == logging.ERROR
+    assert "Exception occurred while handling uri:" in record[2]
 
 
 @pytest.mark.parametrize("debug", (True, False))