Bump version

Co-authored-by: Adam Hopkins <adam@amhopkins.com>
Co-authored-by: Zhiwei Liang <zhi.wei.liang@outlook.com>
Co-authored-by: Néstor Pérez <25409753+prryplatypus@users.noreply.github.com>

.coveragerc

@@ -4,8 +4,8 @@ source = sanic
 omit =
     site-packages
     sanic/__main__.py
-    sanic/server/legacy.py
     sanic/compat.py
+    sanic/reloader_helpers.py
     sanic/simple.py
     sanic/utils.py
     sanic/cli
@@ -21,4 +21,12 @@ exclude_lines =
     NOQA
     pragma: no cover
     TYPE_CHECKING
+omit =
+    site-packages
+    sanic/__main__.py
+    sanic/compat.py
+    sanic/reloader_helpers.py
+    sanic/simple.py
+    sanic/utils.py
+    sanic/cli
 skip_empty = True

.github/ISSUE_TEMPLATE/bug-report.yml

@@ -1,66 +0,0 @@
-name: 🐞 Bug report
-description: Create a report to help us improve
-labels: ["bug", "triage"]
-body:
-  - type: checkboxes
-    id: existing
-    attributes:
-      label: Is there an existing issue for this?
-      description: Please search to see if an issue already exists for the bug you encountered.
-      options:
-      - label: I have searched the existing issues
-        required: true
-  - type: textarea
-    id: description
-    attributes:
-      label: Describe the bug
-      description: A clear and concise description of what the bug is, make sure to paste any exceptions and tracebacks using markdown code-block syntax to make it easier to read.
-    validations:
-      required: true
-  - type: textarea
-    id: code
-    attributes:
-      label: Code snippet
-      description: Relevant source code, make sure to remove what is not necessary.
-    validations:
-      required: false
-  - type: textarea
-    id: expected
-    attributes:
-      label: Expected Behavior
-      description: A concise description of what you expected to happen.
-    validations:
-      required: false
-  - type: dropdown
-    id: running
-    attributes:
-      label: How do you run Sanic?
-      options:
-        - Sanic CLI
-        - As a module
-        - As a script (`app.run` or `Sanic.serve`)
-        - ASGI
-    validations:
-      required: true
-  - type: input
-    id: os
-    attributes:
-      label: Operating System
-      description: What OS?
-    validations:
-      required: true
-  - type: input
-    id: version
-    attributes:
-      label: Sanic Version
-      description: Check startup logs or try `sanic --version`
-    validations:
-      required: true
-  - type: textarea
-    id: additional
-    attributes:
-      label: Additional context
-      description: Add any other context about the problem here.
-    validations:
-      required: false
-

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,25 @@
+---
+name: Bug report
+about: Create a report to help us improve
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is, make sure to paste any exceptions and tracebacks.
+
+
+**Code snippet**
+Relevant source code, make sure to remove what is not necessary.
+
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+
+**Environment (please complete the following information):**
+ - OS: [e.g. iOS]
+ - Version [e.g. 0.8.3]
+
+
+**Additional context**
+Add any other context about the problem here.

.github/ISSUE_TEMPLATE/config.yml

@@ -1,8 +1,5 @@
-blank_issues_enabled: false
+blank_issues_enabled: true
 contact_links:
   - name: Questions and Help
     url: https://community.sanicframework.org/c/questions-and-help
     about: Do you need help with Sanic? Ask your questions here.
-  - name: Discussion and Support
-    url: https://discord.gg/FARQzAEMAA
-    about: For live discussion and support, checkout the Sanic Discord server.

.github/ISSUE_TEMPLATE/feature-request.yml

@@ -1,34 +0,0 @@
-name: 🌟 Feature request
-description: Suggest an enhancement for Sanic
-labels: ["feature request"]
-body:
-  - type: checkboxes
-    id: existing
-    attributes:
-      label: Is there an existing issue for this?
-      description: Please search to see if an issue already exists for the enhancement you are proposing.
-      options:
-      - label: I have searched the existing issues
-        required: true
-  - type: textarea
-    id: description
-    attributes:
-      label: Is your feature request related to a problem? Please describe.
-      description: A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
-    validations:
-      required: false
-  - type: textarea
-    id: code
-    attributes:
-      label: Describe the solution you'd like
-      description: A clear and concise description of what you want to happen.
-    validations:
-      required: true
-  - type: textarea
-    id: additional
-    attributes:
-      label: Additional context
-      description: Add any other context about the problem here.
-    validations:
-      required: false
-

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,16 @@
+---
+name: Feature request
+about: Suggest an idea for Sanic
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+
+**Additional context**
+Add any other context or sample code about the feature request here.

CONDUCT.md

@@ -55,7 +55,7 @@ further defined and clarified by project maintainers.
 ## Enforcement
 
 Instances of abusive, harassing, or otherwise unacceptable behavior may be
-reported by contacting the project team at adam@sanicframework.org. All
+reported by contacting the project team at sanic-maintainers@googlegroups.com. All
 complaints will be reviewed and investigated and will result in a response that
 is deemed necessary and appropriate to the circumstances. The project team is
 obligated to maintain confidentiality with regard to the reporter of an incident.

CONTRIBUTING.rst

@@ -71,9 +71,9 @@ To execute only unittests, run ``tox`` with environment like so:
 
 .. code-block:: bash
 
-   tox -e py37 -v -- tests/test_config.py
+   tox -e py36 -v -- tests/test_config.py
    # or
-   tox -e py310 -v -- tests/test_config.py
+   tox -e py37 -v -- tests/test_config.py
 
 Run lint checks
 ---------------

README.rst

@@ -102,6 +102,9 @@ Installation
   If you are running on a clean install of Fedora 28 or above, please make sure you have the ``redhat-rpm-config`` package installed in case if you want to
   use ``sanic`` with ``ujson`` dependency.
 
+.. note::
+
+  Windows support is currently "experimental" and on a best-effort basis. Multiple workers are also not currently supported on Windows (see `Issue #1517 <https://github.com/sanic-org/sanic/issues/1517>`_), but setting ``workers=1`` should launch the server successfully.
 
 Hello World Example
 -------------------

SECURITY.md

@@ -4,41 +4,31 @@
 
 Sanic releases long term support release once a year in December. LTS releases receive bug and security updates for **24 months**. Interim releases throughout the year occur every three months, and are supported until the subsequent interim release.
 
+| Version | LTS           | Supported          |
+| ------- | ------------- | ------------------ |
+| 20.12   | until 2022-12 | :heavy_check_mark: |
+| 20.9    |               | :x:                |
+| 20.6    |               | :x:                |
+| 20.3    |               | :x:                |
+| 19.12   | until 2021-12 | :white_check_mark: |
+| 19.9    |               | :x:                |
+| 19.6    |               | :x:                |
+| 19.3    |               | :x:                |
+| 18.12   |               | :x:                |
+| 0.8.3   |               | :x:                |
+| 0.7.0   |               | :x:                |
+| 0.6.0   |               | :x:                |
+| 0.5.4   |               | :x:                |
+| 0.4.1   |               | :x:                |
+| 0.3.1   |               | :x:                |
+| 0.2.0   |               | :x:                |
+| 0.1.9   |               | :x:                |
 
-| Version | LTS           | Supported               |
+:white_check_mark: = security/bug fixes
-| ------- | ------------- | ----------------------- |
+:heavy_check_mark: = full support
-| 22.9    |               | :white_check_mark:      |
-| 22.6    |               | :x:                     |
-| 22.3    |               | :x:                     |
-| 21.12   | until 2023-12 | :white_check_mark:      |
-| 21.9    |               | :x:                     |
-| 21.6    |               | :x:                     |
-| 21.3    |               | :x:                     |
-| 20.12   | until 2022-12 | :ballot_box_with_check: |
-| 20.9    |               | :x:                     |
-| 20.6    |               | :x:                     |
-| 20.3    |               | :x:                     |
-| 19.12   |               | :x:                     |
-| 19.9    |               | :x:                     |
-| 19.6    |               | :x:                     |
-| 19.3    |               | :x:                     |
-| 18.12   |               | :x:                     |
-| 0.8.3   |               | :x:                     |
-| 0.7.0   |               | :x:                     |
-| 0.6.0   |               | :x:                     |
-| 0.5.4   |               | :x:                     |
-| 0.4.1   |               | :x:                     |
-| 0.3.1   |               | :x:                     |
-| 0.2.0   |               | :x:                     |
-| 0.1.9   |               | :x:                     |
-
-:ballot_box_with_check: = security/bug fixes 
-:white_check_mark: = full support
 
 ## Reporting a Vulnerability
 
 If you discover a security vulnerability, we ask that you **do not** create an issue on GitHub. Instead, please [send a message to the core-devs](https://community.sanicframework.org/g/core-devs) on the community forums. Once logged in, you can send a message to the core-devs by clicking the message button.
 
-Alternatively, you can send a private message to Adam Hopkins on Discord. Find him on the [Sanic discord server](https://discord.gg/FARQzAEMAA).
-
 This will help to not publicize the issue until the team can address it and resolve it.

codecov.yml

@@ -15,6 +15,7 @@ codecov:
 ignore:
   - "sanic/__main__.py"
   - "sanic/compat.py"
+  - "sanic/reloader_helpers.py"
   - "sanic/simple.py"
   - "sanic/utils.py"
   - "sanic/cli"

docs/_static/custom.css

@@ -2,12 +2,3 @@
 .wy-nav-top {
   background: #444444;
 }
-
-#changelog section {
-  padding-left: 3rem;
-}
-
-#changelog section h2,
-#changelog section h3 {
-  margin-left: -3rem;
-}

docs/sanic/changelog.rst

@@ -1,7 +1,6 @@
 📜 Changelog
 ============
 
-.. mdinclude:: ./releases/22/22.9.md
 .. mdinclude:: ./releases/22/22.6.md
 .. mdinclude:: ./releases/22/22.3.md
 .. mdinclude:: ./releases/21/21.12.md

docs/sanic/releases/22/22.6.md

@@ -1,17 +1,6 @@
-## Version 22.6.2
+## Version 22.6.0 🔶
 
-### Bugfixes
+_Current version_
-
-- [#2522](https://github.com/sanic-org/sanic/pull/2522) Always show server location in ASGI
-
-## Version 22.6.1
-
-### Bugfixes
-
-- [#2477](https://github.com/sanic-org/sanic/pull/2477) Sanic static directory fails when folder name ends with ".."
-
-
-## Version 22.6.0
 
 ### Features
 - [#2378](https://github.com/sanic-org/sanic/pull/2378) Introduce HTTP/3 and autogeneration of TLS certificates in `DEBUG` mode

docs/sanic/releases/22/22.9.md

@@ -1,47 +0,0 @@
-## Version 22.9.0 🔶
-
-_Current version_
-
-### Features
-
-- [#2445](https://github.com/sanic-org/sanic/pull/2445) Add custom loads function 
-- [#2490](https://github.com/sanic-org/sanic/pull/2490) Make `WebsocketImplProtocol` async iterable
-- [#2499](https://github.com/sanic-org/sanic/pull/2499) Sanic Server WorkerManager refactor
-- [#2506](https://github.com/sanic-org/sanic/pull/2506) Use `pathlib` for path resolution (for static file serving)
-- [#2508](https://github.com/sanic-org/sanic/pull/2508) Use `path.parts` instead of `match` (for static file serving)
-- [#2513](https://github.com/sanic-org/sanic/pull/2513) Better request cancel handling
-- [#2516](https://github.com/sanic-org/sanic/pull/2516) Add request properties for HTTP method info:
-    - `request.is_safe`
-    - `request.is_idempotent`
-    - `request.is_cacheable`
-    - *See* [MDN docs](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods) *for more information about when these apply*
-- [#2522](https://github.com/sanic-org/sanic/pull/2522) Always show server location in ASGI
-- [#2526](https://github.com/sanic-org/sanic/pull/2526) Cache control support for static files for returning 304 when appropriate
-- [#2533](https://github.com/sanic-org/sanic/pull/2533) Refactor `_static_request_handler`
-- [#2540](https://github.com/sanic-org/sanic/pull/2540) Add signals before and after handler execution
-    - `http.handler.before`
-    - `http.handler.after`
-- [#2542](https://github.com/sanic-org/sanic/pull/2542) Add *[redacted]* to CLI :)
-- [#2546](https://github.com/sanic-org/sanic/pull/2546) Add deprecation warning filter
-- [#2550](https://github.com/sanic-org/sanic/pull/2550) Middleware priority and performance enhancements
-
-### Bugfixes
-
-- [#2495](https://github.com/sanic-org/sanic/pull/2495) Prevent directory traversion with static files
-- [#2515](https://github.com/sanic-org/sanic/pull/2515) Do not apply double slash to paths in certain static dirs in Blueprints
-
-### Deprecations and Removals
-
-- [#2525](https://github.com/sanic-org/sanic/pull/2525) Warn on duplicate route names, will be prevented outright in v23.3
-- [#2537](https://github.com/sanic-org/sanic/pull/2537) Raise warning and deprecation notice on duplicate exceptions, will be prevented outright in v23.3
-
-### Developer infrastructure
-
-- [#2504](https://github.com/sanic-org/sanic/pull/2504) Cleanup test suite
-- [#2505](https://github.com/sanic-org/sanic/pull/2505) Replace Unsupported Python Version Number from the Contributing Doc
-- [#2530](https://github.com/sanic-org/sanic/pull/2530) Do not include tests folder in installed package resolver
-
-### Improved Documentation
-
-- [#2502](https://github.com/sanic-org/sanic/pull/2502) Fix a few typos
-- [#2517](https://github.com/sanic-org/sanic/pull/2517) [#2536](https://github.com/sanic-org/sanic/pull/2536) Add some type hints

examples/unix_socket.py

@@ -1,3 +1,6 @@
+import os
+import socket
+
 from sanic import Sanic, response
 
 
@@ -10,4 +13,13 @@ async def test(request):
 
 
 if __name__ == "__main__":
-    app.run(unix="./uds_socket")
+    server_address = "./uds_socket"
+    # Make sure the socket does not already exist
+    try:
+        os.unlink(server_address)
+    except OSError:
+        if os.path.exists(server_address):
+            raise
+    sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+    sock.bind(server_address)
+    app.run(sock=sock)

sanic/__init__.py

@@ -3,15 +3,7 @@ from sanic.app import Sanic
 from sanic.blueprints import Blueprint
 from sanic.constants import HTTPMethod
 from sanic.request import Request
-from sanic.response import (
+from sanic.response import HTTPResponse, html, json, text
-    HTTPResponse,
-    empty,
-    file,
-    html,
-    json,
-    redirect,
-    text,
-)
 from sanic.server.websockets.impl import WebsocketImplProtocol as Websocket
 
 
@@ -23,10 +15,7 @@ __all__ = (
     "HTTPResponse",
     "Request",
     "Websocket",
-    "empty",
-    "file",
     "html",
     "json",
-    "redirect",
     "text",
 )

sanic/__main__.py

@@ -6,10 +6,10 @@ if OS_IS_WINDOWS:
     enable_windows_color_support()
 
 
-def main(args=None):
+def main():
     cli = SanicCLI()
     cli.attach()
-    cli.run(args)
+    cli.run()
 
 
 if __name__ == "__main__":

sanic/__version__.py

@@ -1 +1 @@
-__version__ = "22.9.1"
+__version__ = "22.6.2"

sanic/app.py

@@ -19,7 +19,6 @@ from collections import defaultdict, deque
 from contextlib import suppress
 from functools import partial
 from inspect import isawaitable
-from os import environ
 from socket import socket
 from traceback import format_exc
 from types import SimpleNamespace
@@ -42,12 +41,13 @@ from typing import (
     Union,
 )
 from urllib.parse import urlencode, urlunparse
+from warnings import filterwarnings
 
 from sanic_routing.exceptions import FinalizationError, NotFound
 from sanic_routing.route import Route
 
 from sanic.application.ext import setup_ext
-from sanic.application.state import ApplicationState, ServerStage
+from sanic.application.state import ApplicationState, Mode, ServerStage
 from sanic.asgi import ASGIApp
 from sanic.base.root import BaseSanic
 from sanic.blueprint_group import BlueprintGroup
@@ -61,7 +61,7 @@ from sanic.exceptions import (
     URLBuildError,
 )
 from sanic.handlers import ErrorHandler
-from sanic.helpers import Default
+from sanic.helpers import _default
 from sanic.http import Stage
 from sanic.log import (
     LOGGING_CONFIG_DEFAULTS,
@@ -70,7 +70,7 @@ from sanic.log import (
     logger,
 )
 from sanic.mixins.listeners import ListenerEvent
-from sanic.mixins.startup import StartupMixin
+from sanic.mixins.runner import RunnerMixin
 from sanic.models.futures import (
     FutureException,
     FutureListener,
@@ -88,9 +88,6 @@ from sanic.router import Router
 from sanic.server.websockets.impl import ConnectionClosed
 from sanic.signals import Signal, SignalRouter
 from sanic.touchup import TouchUp, TouchUpMeta
-from sanic.types.shared_ctx import SharedContext
-from sanic.worker.inspector import Inspector
-from sanic.worker.manager import WorkerManager
 
 
 if TYPE_CHECKING:
@@ -104,8 +101,10 @@ if TYPE_CHECKING:
 if OS_IS_WINDOWS:  # no cov
     enable_windows_color_support()
 
+filterwarnings("once", category=DeprecationWarning)
 
-class Sanic(BaseSanic, StartupMixin, metaclass=TouchUpMeta):
+
+class Sanic(BaseSanic, RunnerMixin, metaclass=TouchUpMeta):
     """
     The main application instance
     """
@@ -129,8 +128,6 @@ class Sanic(BaseSanic, StartupMixin, metaclass=TouchUpMeta):
         "_future_routes",
         "_future_signals",
         "_future_statics",
-        "_inspector",
-        "_manager",
         "_state",
         "_task_registry",
         "_test_client",
@@ -142,14 +139,12 @@ class Sanic(BaseSanic, StartupMixin, metaclass=TouchUpMeta):
         "error_handler",
         "go_fast",
         "listeners",
-        "multiplexer",
         "named_request_middleware",
         "named_response_middleware",
         "request_class",
         "request_middleware",
         "response_middleware",
         "router",
-        "shared_ctx",
         "signal_router",
         "sock",
         "strict_slashes",
@@ -158,6 +153,7 @@ class Sanic(BaseSanic, StartupMixin, metaclass=TouchUpMeta):
     )
 
     _app_registry: Dict[str, "Sanic"] = {}
+    _uvloop_setting = None  # TODO: Remove in v22.6
     test_mode = False
 
     def __init__(
@@ -175,9 +171,9 @@ class Sanic(BaseSanic, StartupMixin, metaclass=TouchUpMeta):
         configure_logging: bool = True,
         dumps: Optional[Callable[..., AnyStr]] = None,
         loads: Optional[Callable[..., Any]] = None,
-        inspector: bool = False,
     ) -> None:
         super().__init__(name=name)
+
         # logging
         if configure_logging:
             dict_config = log_config or LOGGING_CONFIG_DEFAULTS
@@ -191,16 +187,12 @@ class Sanic(BaseSanic, StartupMixin, metaclass=TouchUpMeta):
 
         # First setup config
         self.config: Config = config or Config(env_prefix=env_prefix)
-        if inspector:
-            self.config.INSPECTOR = inspector
 
         # Then we can do the rest
         self._asgi_client: Any = None
         self._blueprint_order: List[Blueprint] = []
         self._delayed_tasks: List[str] = []
         self._future_registry: FutureRegistry = FutureRegistry()
-        self._inspector: Optional[Inspector] = None
-        self._manager: Optional[WorkerManager] = None
         self._state: ApplicationState = ApplicationState(app=self)
         self._task_registry: Dict[str, Task] = {}
         self._test_client: Any = None
@@ -218,7 +210,6 @@ class Sanic(BaseSanic, StartupMixin, metaclass=TouchUpMeta):
         self.request_middleware: Deque[MiddlewareType] = deque()
         self.response_middleware: Deque[MiddlewareType] = deque()
         self.router: Router = router or Router()
-        self.shared_ctx: SharedContext = SharedContext()
         self.signal_router: SignalRouter = signal_router or SignalRouter()
         self.sock: Optional[socket] = None
         self.strict_slashes: bool = strict_slashes
@@ -252,7 +243,7 @@ class Sanic(BaseSanic, StartupMixin, metaclass=TouchUpMeta):
             )
         try:
             return get_running_loop()
-        except RuntimeError:  # no cov
+        except RuntimeError:
             if sys.version_info > (3, 10):
                 return asyncio.get_event_loop_policy().get_event_loop()
             else:
@@ -393,8 +384,8 @@ class Sanic(BaseSanic, StartupMixin, metaclass=TouchUpMeta):
             routes = [routes]
 
         for r in routes:
-            r.extra.websocket = websocket
+            r.ctx.websocket = websocket
-            r.extra.static = params.get("static", False)
+            r.ctx.static = params.get("static", False)
             r.ctx.__dict__.update(ctx)
 
         return routes
@@ -467,7 +458,9 @@ class Sanic(BaseSanic, StartupMixin, metaclass=TouchUpMeta):
 
     def blueprint(
         self,
-        blueprint: Union[Blueprint, Iterable[Blueprint], BlueprintGroup],
+        blueprint: Union[
+            Blueprint, List[Blueprint], Tuple[Blueprint], BlueprintGroup
+        ],
         **options: Any,
     ):
         """Register a blueprint on the application.
@@ -476,20 +469,21 @@ class Sanic(BaseSanic, StartupMixin, metaclass=TouchUpMeta):
         :param options: option dictionary with blueprint defaults
         :return: Nothing
         """
-        if isinstance(blueprint, (Iterable, BlueprintGroup)):
+        if isinstance(blueprint, (list, tuple, BlueprintGroup)):
             for item in blueprint:
                 params = {**options}
                 if isinstance(blueprint, BlueprintGroup):
-                    merge_from = [
+                    if blueprint.url_prefix:
-                        options.get("url_prefix", ""),
+                        merge_from = [
-                        blueprint.url_prefix or "",
+                            options.get("url_prefix", ""),
-                    ]
+                            blueprint.url_prefix,
-                    if not isinstance(item, BlueprintGroup):
+                        ]
-                        merge_from.append(item.url_prefix or "")
+                        if not isinstance(item, BlueprintGroup):
-                    merged_prefix = "/".join(
+                            merge_from.append(item.url_prefix or "")
-                        u.strip("/") for u in merge_from if u
+                        merged_prefix = "/".join(
-                    ).rstrip("/")
+                            u.strip("/") for u in merge_from
-                    params["url_prefix"] = f"/{merged_prefix}"
+                        ).rstrip("/")
+                        params["url_prefix"] = f"/{merged_prefix}"
 
                     for _attr in ["version", "strict_slashes"]:
                         if getattr(item, _attr) is None:
@@ -587,7 +581,7 @@ class Sanic(BaseSanic, StartupMixin, metaclass=TouchUpMeta):
 
         uri = route.path
 
-        if getattr(route.extra, "static", None):
+        if getattr(route.ctx, "static", None):
             filename = kwargs.pop("filename", "")
             # it's static folder
             if "__file_uri__" in uri:
@@ -620,18 +614,18 @@ class Sanic(BaseSanic, StartupMixin, metaclass=TouchUpMeta):
         host = kwargs.pop("_host", None)
         external = kwargs.pop("_external", False) or bool(host)
         scheme = kwargs.pop("_scheme", "")
-        if route.extra.hosts and external:
+        if route.ctx.hosts and external:
-            if not host and len(route.extra.hosts) > 1:
+            if not host and len(route.ctx.hosts) > 1:
                 raise ValueError(
-                    f"Host is ambiguous: {', '.join(route.extra.hosts)}"
+                    f"Host is ambiguous: {', '.join(route.ctx.hosts)}"
                 )
-            elif host and host not in route.extra.hosts:
+            elif host and host not in route.ctx.hosts:
                 raise ValueError(
                     f"Requested host ({host}) is not available for this "
-                    f"route: {route.extra.hosts}"
+                    f"route: {route.ctx.hosts}"
                 )
             elif not host:
-                host = list(route.extra.hosts)[0]
+                host = list(route.ctx.hosts)[0]
 
         if scheme and not external:
             raise ValueError("When specifying _scheme, _external must be True")
@@ -707,10 +701,7 @@ class Sanic(BaseSanic, StartupMixin, metaclass=TouchUpMeta):
     # -------------------------------------------------------------------- #
 
     async def handle_exception(
-        self,
+        self, request: Request, exception: BaseException
-        request: Request,
-        exception: BaseException,
-        run_middleware: bool = True,
     ):  # no cov
         """
         A handler that catches specific exceptions and outputs a response.
@@ -719,7 +710,6 @@ class Sanic(BaseSanic, StartupMixin, metaclass=TouchUpMeta):
         :param exception: The exception that was raised
         :raises ServerError: response 500
         """
-        response = None
         await self.dispatch(
             "http.lifecycle.exception",
             inline=True,
@@ -760,11 +750,9 @@ class Sanic(BaseSanic, StartupMixin, metaclass=TouchUpMeta):
         # -------------------------------------------- #
         # Request Middleware
         # -------------------------------------------- #
-        if run_middleware:
+        response = await self._run_request_middleware(
-            middleware = (
+            request, request_name=None
-                request.route and request.route.extra.request_middleware
+        )
-            ) or self.request_middleware
-            response = await self._run_request_middleware(request, middleware)
         # No middleware results
         if not response:
             try:
@@ -844,13 +832,7 @@ class Sanic(BaseSanic, StartupMixin, metaclass=TouchUpMeta):
 
         # Define `response` var here to remove warnings about
         # allocation before assignment below.
-        response: Optional[
+        response = None
-            Union[
-                BaseHTTPResponse,
-                Coroutine[Any, Any, Optional[BaseHTTPResponse]],
-            ]
-        ] = None
-        run_middleware = True
         try:
 
             await self.dispatch(
@@ -882,7 +864,7 @@ class Sanic(BaseSanic, StartupMixin, metaclass=TouchUpMeta):
             if (
                 request.stream
                 and request.stream.request_body
-                and not route.extra.ignore_body
+                and not route.ctx.ignore_body
             ):
 
                 if hasattr(handler, "is_stream"):
@@ -895,11 +877,9 @@ class Sanic(BaseSanic, StartupMixin, metaclass=TouchUpMeta):
             # -------------------------------------------- #
             # Request Middleware
             # -------------------------------------------- #
-            run_middleware = False
+            response = await self._run_request_middleware(
-            if request.route.extra.request_middleware:
+                request, request_name=route.name
-                response = await self._run_request_middleware(
+            )
-                    request, request.route.extra.request_middleware
-                )
 
             # No middleware results
             if not response:
@@ -916,19 +896,9 @@ class Sanic(BaseSanic, StartupMixin, metaclass=TouchUpMeta):
                     )
 
                 # Run response handler
-                await self.dispatch(
-                    "http.handler.before",
-                    inline=True,
-                    context={"request": request},
-                )
                 response = handler(request, **request.match_info)
                 if isawaitable(response):
                     response = await response
-                await self.dispatch(
-                    "http.handler.after",
-                    inline=True,
-                    context={"request": request},
-                )
 
             if request.responded:
                 if response is not None:
@@ -940,7 +910,7 @@ class Sanic(BaseSanic, StartupMixin, metaclass=TouchUpMeta):
                 if request.stream is not None:
                     response = request.stream.response
             elif response is not None:
-                response = await request.respond(response)  # type: ignore
+                response = await request.respond(response)
             elif not hasattr(handler, "is_websocket"):
                 response = request.stream.response  # type: ignore
 
@@ -958,7 +928,7 @@ class Sanic(BaseSanic, StartupMixin, metaclass=TouchUpMeta):
                 ...
                 await response.send(end_stream=True)
             elif isinstance(response, ResponseStream):
-                resp = await response(request)  # type: ignore
+                resp = await response(request)
                 await self.dispatch(
                     "http.lifecycle.response",
                     inline=True,
@@ -967,7 +937,7 @@ class Sanic(BaseSanic, StartupMixin, metaclass=TouchUpMeta):
                         "response": resp,
                     },
                 )
-                await response.eof()  # type: ignore
+                await response.eof()
             else:
                 if not hasattr(handler, "is_websocket"):
                     raise ServerError(
@@ -979,9 +949,7 @@ class Sanic(BaseSanic, StartupMixin, metaclass=TouchUpMeta):
             raise
         except Exception as e:
             # Response Generation Failed
-            await self.handle_exception(
+            await self.handle_exception(request, e)
-                request, e, run_middleware=run_middleware
-            )
 
     async def _websocket_handler(
         self, handler, request, *args, subprotocols=None, **kwargs
@@ -1031,7 +999,7 @@ class Sanic(BaseSanic, StartupMixin, metaclass=TouchUpMeta):
     def asgi_client(self):  # noqa
         """
         A testing client that uses ASGI to reach into the application to
-        execute handlers.
+        execute hanlers.
 
         :return: testing client
         :rtype: :class:`SanicASGITestClient`
@@ -1050,72 +1018,86 @@ class Sanic(BaseSanic, StartupMixin, metaclass=TouchUpMeta):
     # -------------------------------------------------------------------- #
 
     async def _run_request_middleware(
-        self, request, middleware_collection
+        self, request, request_name=None
     ):  # no cov
-        request._request_middleware_started = True
+        # The if improves speed.  I don't know why
+        named_middleware = self.named_request_middleware.get(
+            request_name, deque()
+        )
+        applicable_middleware = self.request_middleware + named_middleware
 
-        for middleware in middleware_collection:
+        # request.request_middleware_started is meant as a stop-gap solution
-            await self.dispatch(
+        # until RFC 1630 is adopted
-                "http.middleware.before",
+        if applicable_middleware and not request.request_middleware_started:
-                inline=True,
+            request.request_middleware_started = True
-                context={
-                    "request": request,
-                    "response": None,
-                },
-                condition={"attach_to": "request"},
-            )
 
-            response = middleware(request)
+            for middleware in applicable_middleware:
-            if isawaitable(response):
+                await self.dispatch(
-                response = await response
+                    "http.middleware.before",
+                    inline=True,
+                    context={
+                        "request": request,
+                        "response": None,
+                    },
+                    condition={"attach_to": "request"},
+                )
 
-            await self.dispatch(
+                response = middleware(request)
-                "http.middleware.after",
+                if isawaitable(response):
-                inline=True,
+                    response = await response
-                context={
-                    "request": request,
-                    "response": None,
-                },
-                condition={"attach_to": "request"},
-            )
 
-            if response:
+                await self.dispatch(
-                return response
+                    "http.middleware.after",
+                    inline=True,
+                    context={
+                        "request": request,
+                        "response": None,
+                    },
+                    condition={"attach_to": "request"},
+                )
+
+                if response:
+                    return response
         return None
 
     async def _run_response_middleware(
-        self, request, response, middleware_collection
+        self, request, response, request_name=None
     ):  # no cov
-        for middleware in middleware_collection:
+        named_middleware = self.named_response_middleware.get(
-            await self.dispatch(
+            request_name, deque()
-                "http.middleware.before",
+        )
-                inline=True,
+        applicable_middleware = self.response_middleware + named_middleware
-                context={
+        if applicable_middleware:
-                    "request": request,
+            for middleware in applicable_middleware:
-                    "response": response,
+                await self.dispatch(
-                },
+                    "http.middleware.before",
-                condition={"attach_to": "response"},
+                    inline=True,
-            )
+                    context={
+                        "request": request,
+                        "response": response,
+                    },
+                    condition={"attach_to": "response"},
+                )
 
-            _response = middleware(request, response)
+                _response = middleware(request, response)
-            if isawaitable(_response):
+                if isawaitable(_response):
-                _response = await _response
+                    _response = await _response
 
-            await self.dispatch(
+                await self.dispatch(
-                "http.middleware.after",
+                    "http.middleware.after",
-                inline=True,
+                    inline=True,
-                context={
+                    context={
-                    "request": request,
+                        "request": request,
-                    "response": _response if _response else response,
+                        "response": _response if _response else response,
-                },
+                    },
-                condition={"attach_to": "response"},
+                    condition={"attach_to": "response"},
-            )
+                )
 
-            if _response:
+                if _response:
-                response = _response
+                    response = _response
-                if isinstance(response, BaseHTTPResponse):
+                    if isinstance(response, BaseHTTPResponse):
-                    response = request.stream.respond(response)
+                        response = request.stream.respond(response)
-                break
+                    break
         return response
 
     def _build_endpoint_name(self, *parts):
@@ -1202,7 +1184,7 @@ class Sanic(BaseSanic, StartupMixin, metaclass=TouchUpMeta):
         *,
         name: Optional[str] = None,
         register: bool = True,
-    ) -> Optional[Task[Any]]:
+    ) -> Optional[Task]:
         """
         Schedule a task to run later, after the loop has started.
         Different from asyncio.ensure_future in that it does not
@@ -1212,7 +1194,7 @@ class Sanic(BaseSanic, StartupMixin, metaclass=TouchUpMeta):
         `See user guide re: background tasks
         <https://sanicframework.org/guide/basics/tasks.html#background-tasks>`__
 
-        :param task: future, coroutine or awaitable
+        :param task: future, couroutine or awaitable
         """
         try:
             loop = self.loop  # Will raise SanicError if loop is not started
@@ -1344,6 +1326,18 @@ class Sanic(BaseSanic, StartupMixin, metaclass=TouchUpMeta):
     def debug(self):
         return self.state.is_debug
 
+    @debug.setter
+    def debug(self, value: bool):
+        deprecation(
+            "Setting the value of a Sanic application's debug value directly "
+            "is deprecated and will be removed in v22.9. Please set it using "
+            "the CLI, app.run, app.prepare, or directly set "
+            "app.state.mode to Mode.DEBUG.",
+            22.9,
+        )
+        mode = Mode.DEBUG if value else Mode.PRODUCTION
+        self.state.mode = mode
+
     @property
     def auto_reload(self):
         return self.config.AUTO_RELOAD
@@ -1351,7 +1345,6 @@ class Sanic(BaseSanic, StartupMixin, metaclass=TouchUpMeta):
     @auto_reload.setter
     def auto_reload(self, value: bool):
         self.config.AUTO_RELOAD = value
-        self.state.auto_reload = value
 
     @property
     def state(self) -> ApplicationState:  # type: ignore
@@ -1360,6 +1353,58 @@ class Sanic(BaseSanic, StartupMixin, metaclass=TouchUpMeta):
         """
         return self._state
 
+    @property
+    def is_running(self):
+        deprecation(
+            "Use of the is_running property is no longer used by Sanic "
+            "internally. The property is now deprecated and will be removed "
+            "in version 22.9. You may continue to set the property for your "
+            "own needs until that time. If you would like to check whether "
+            "the application is operational, please use app.state.stage. More "
+            "information is available at ___.",
+            22.9,
+        )
+        return self.state.is_running
+
+    @is_running.setter
+    def is_running(self, value: bool):
+        deprecation(
+            "Use of the is_running property is no longer used by Sanic "
+            "internally. The property is now deprecated and will be removed "
+            "in version 22.9. You may continue to set the property for your "
+            "own needs until that time. If you would like to check whether "
+            "the application is operational, please use app.state.stage. More "
+            "information is available at ___.",
+            22.9,
+        )
+        self.state.is_running = value
+
+    @property
+    def is_stopping(self):
+        deprecation(
+            "Use of the is_stopping property is no longer used by Sanic "
+            "internally. The property is now deprecated and will be removed "
+            "in version 22.9. You may continue to set the property for your "
+            "own needs until that time. If you would like to check whether "
+            "the application is operational, please use app.state.stage. More "
+            "information is available at ___.",
+            22.9,
+        )
+        return self.state.is_stopping
+
+    @is_stopping.setter
+    def is_stopping(self, value: bool):
+        deprecation(
+            "Use of the is_stopping property is no longer used by Sanic "
+            "internally. The property is now deprecated and will be removed "
+            "in version 22.9. You may continue to set the property for your "
+            "own needs until that time. If you would like to check whether "
+            "the application is operational, please use app.state.stage. More "
+            "information is available at ___.",
+            22.9,
+        )
+        self.state.is_stopping = value
+
     @property
     def reload_dirs(self):
         return self.state.reload_dirs
@@ -1417,18 +1462,6 @@ class Sanic(BaseSanic, StartupMixin, metaclass=TouchUpMeta):
 
         cls._app_registry[name] = app
 
-    @classmethod
-    def unregister_app(cls, app: "Sanic") -> None:
-        """
-        Unregister a Sanic instance
-        """
-        if not isinstance(app, cls):
-            raise SanicException("Registered app must be an instance of Sanic")
-
-        name = app.name
-        if name in cls._app_registry:
-            del cls._app_registry[name]
-
     @classmethod
     def get_app(
         cls, name: Optional[str] = None, *, force_create: bool = False
@@ -1448,28 +1481,9 @@ class Sanic(BaseSanic, StartupMixin, metaclass=TouchUpMeta):
         try:
             return cls._app_registry[name]
         except KeyError:
-            if name == "__main__":
-                return cls.get_app("__mp_main__", force_create=force_create)
             if force_create:
                 return cls(name)
-            raise SanicException(
+            raise SanicException(f'Sanic app name "{name}" not found.')
-                f"Sanic app name '{name}' not found.\n"
-                "App instantiation must occur outside "
-                "if __name__ == '__main__' "
-                "block or by using an AppLoader.\nSee "
-                "https://sanic.dev/en/guide/deployment/app-loader.html"
-                " for more details."
-            )
-
-    @classmethod
-    def _check_uvloop_conflict(cls) -> None:
-        values = {app.config.USE_UVLOOP for app in cls._app_registry.values()}
-        if len(values) > 1:
-            error_logger.warning(
-                "It looks like you're running several apps with different "
-                "uvloop settings. This is not supported and may lead to "
-                "unintended behaviour."
-            )
 
     # -------------------------------------------------------------------- #
     # Lifecycle
@@ -1481,7 +1495,6 @@ class Sanic(BaseSanic, StartupMixin, metaclass=TouchUpMeta):
         except FinalizationError as e:
             if not Sanic.test_mode:
                 raise e
-        self.finalize_middleware()
 
     def signalize(self, allow_fail_builtin=True):
         self.signal_router.allow_fail_builtin = allow_fail_builtin
@@ -1501,26 +1514,24 @@ class Sanic(BaseSanic, StartupMixin, metaclass=TouchUpMeta):
 
         if self.state.is_debug and self.config.TOUCHUP is not True:
             self.config.TOUCHUP = False
-        elif isinstance(self.config.TOUCHUP, Default):
+        elif self.config.TOUCHUP is _default:
             self.config.TOUCHUP = True
 
         # Setup routers
         self.signalize(self.config.TOUCHUP)
         self.finalize()
 
-        route_names = [route.name for route in self.router.routes]
+        # TODO: Replace in v22.6 to check against apps in app registry
-        duplicates = {
+        if (
-            name for name in route_names if route_names.count(name) > 1
+            self.__class__._uvloop_setting is not None
-        }
+            and self.__class__._uvloop_setting != self.config.USE_UVLOOP
-        if duplicates:
+        ):
-            names = ", ".join(duplicates)
+            error_logger.warning(
-            deprecation(
+                "It looks like you're running several apps with different "
-                f"Duplicate route names detected: {names}. In the future, "
+                "uvloop settings. This is not supported and may lead to "
-                "Sanic will enforce uniqueness in route naming.",
+                "unintended behaviour."
-                23.3,
             )
-
+        self.__class__._uvloop_setting = self.config.USE_UVLOOP
-        Sanic._check_uvloop_conflict()
 
         # Startup time optimizations
         if self.state.primary:
@@ -1531,9 +1542,6 @@ class Sanic(BaseSanic, StartupMixin, metaclass=TouchUpMeta):
 
         self.state.is_started = True
 
-        if hasattr(self, "multiplexer"):
-            self.multiplexer.ack()
-
     async def _server_event(
         self,
         concern: str,
@@ -1562,43 +1570,3 @@ class Sanic(BaseSanic, StartupMixin, metaclass=TouchUpMeta):
                 "loop": loop,
             },
         )
-
-    # -------------------------------------------------------------------- #
-    # Process Management
-    # -------------------------------------------------------------------- #
-
-    def refresh(
-        self,
-        passthru: Optional[Dict[str, Any]] = None,
-    ):
-        registered = self.__class__.get_app(self.name)
-        if self is not registered:
-            if not registered.state.server_info:
-                registered.state.server_info = self.state.server_info
-            self = registered
-        if passthru:
-            for attr, info in passthru.items():
-                if isinstance(info, dict):
-                    for key, value in info.items():
-                        setattr(getattr(self, attr), key, value)
-                else:
-                    setattr(self, attr, info)
-        if hasattr(self, "multiplexer"):
-            self.shared_ctx.lock()
-        return self
-
-    @property
-    def inspector(self):
-        if environ.get("SANIC_WORKER_PROCESS") or not self._inspector:
-            raise SanicException(
-                "Can only access the inspector from the main process"
-            )
-        return self._inspector
-
-    @property
-    def manager(self):
-        if environ.get("SANIC_WORKER_PROCESS") or not self._manager:
-            raise SanicException(
-                "Can only access the manager from the main process"
-            )
-        return self._manager

sanic/application/constants.py

@@ -1,24 +1,15 @@
 from enum import Enum, IntEnum, auto
 
 
-class StrEnum(str, Enum):  # no cov
+class StrEnum(str, Enum):
     def _generate_next_value_(name: str, *args) -> str:  # type: ignore
         return name.lower()
 
-    def __eq__(self, value: object) -> bool:
-        value = str(value).upper()
-        return super().__eq__(value)
-
-    def __hash__(self) -> int:
-        return hash(self.value)
-
-    def __str__(self) -> str:
-        return self.value
-
 
 class Server(StrEnum):
     SANIC = auto()
     ASGI = auto()
+    GUNICORN = auto()
 
 
 class Mode(StrEnum):

sanic/application/ext.py

@@ -22,7 +22,7 @@ def setup_ext(app: Sanic, *, fail: bool = False, **kwargs):
     with suppress(ModuleNotFoundError):
         sanic_ext = import_module("sanic_ext")
 
-    if not sanic_ext:  # no cov
+    if not sanic_ext:
         if fail:
             raise RuntimeError(
                 "Sanic Extensions is not installed. You can add it to your "

sanic/application/motd.py

@@ -80,23 +80,20 @@ class MOTDTTY(MOTD):
         )
         self.display_length = self.key_width + self.value_width + 2
 
-    def display(self, version=True, action="Goin' Fast", out=None):
+    def display(self):
-        if not out:
+        version = f"Sanic v{__version__}".center(self.centering_length)
-            out = logger.info
-        header = "Sanic"
-        if version:
-            header += f" v{__version__}"
-        header = header.center(self.centering_length)
         running = (
-            f"{action} @ {self.serve_location}" if self.serve_location else ""
+            f"Goin' Fast @ {self.serve_location}"
+            if self.serve_location
+            else ""
         ).center(self.centering_length)
-        length = len(header) + 2 - self.logo_line_length
+        length = len(version) + 2 - self.logo_line_length
         first_filler = "─" * (self.logo_line_length - 1)
         second_filler = "─" * length
         display_filler = "─" * (self.display_length + 2)
         lines = [
             f"\n┌{first_filler}─{second_filler}┐",
-            f"│ {header} │",
+            f"│ {version} │",
             f"│ {running} │",
             f"├{first_filler}┬{second_filler}┤",
         ]
@@ -110,7 +107,7 @@ class MOTDTTY(MOTD):
         self._render_fill(lines)
 
         lines.append(f"└{first_filler}┴{second_filler}┘\n")
-        out(indent("\n".join(lines), "  "))
+        logger.info(indent("\n".join(lines), "  "))
 
     def _render_data(self, lines, data, start):
         offset = 0

sanic/asgi.py

@@ -7,7 +7,7 @@ from urllib.parse import quote
 
 from sanic.compat import Header
 from sanic.exceptions import ServerError
-from sanic.helpers import Default
+from sanic.helpers import _default
 from sanic.http import Stage
 from sanic.log import logger
 from sanic.models.asgi import ASGIReceive, ASGIScope, ASGISend, MockTransport
@@ -61,7 +61,7 @@ class Lifespan:
         await self.asgi_app.sanic_app._server_event("init", "before")
         await self.asgi_app.sanic_app._server_event("init", "after")
 
-        if not isinstance(self.asgi_app.sanic_app.config.USE_UVLOOP, Default):
+        if self.asgi_app.sanic_app.config.USE_UVLOOP is not _default:
             warnings.warn(
                 "You have set the USE_UVLOOP configuration option, but Sanic "
                 "cannot control the event loop when running in ASGI mode."
@@ -234,7 +234,4 @@ class ASGIApp:
             self.stage = Stage.HANDLER
             await self.sanic_app.handle_request(self.request)
         except Exception as e:
-            try:
+            await self.sanic_app.handle_exception(self.request, e)
-                await self.sanic_app.handle_exception(self.request, e)
-            except Exception as exc:
-                await self.sanic_app.handle_exception(self.request, exc, False)

sanic/blueprints.py

@@ -308,7 +308,7 @@ class Blueprint(BaseSanic):
             # prefixed properly in the router
             future.handler.__blueprintname__ = self.name
             # Prepend the blueprint URI prefix if available
-            uri = self._setup_uri(future.uri, url_prefix)
+            uri = url_prefix + future.uri if url_prefix else future.uri
 
             version_prefix = self.version_prefix
             for prefix in (
@@ -333,7 +333,7 @@ class Blueprint(BaseSanic):
 
             apply_route = FutureRoute(
                 future.handler,
-                uri,
+                uri[1:] if uri.startswith("//") else uri,
                 future.methods,
                 host,
                 strict_slashes,
@@ -363,7 +363,7 @@ class Blueprint(BaseSanic):
         # Static Files
         for future in self._future_statics:
             # Prepend the blueprint URI prefix if available
-            uri = self._setup_uri(future.uri, url_prefix)
+            uri = url_prefix + future.uri if url_prefix else future.uri
             apply_route = FutureStatic(uri, *future[1:])
 
             if (self, apply_route) in app._future_registry:
@@ -406,7 +406,7 @@ class Blueprint(BaseSanic):
 
         self.routes += [route for route in routes if isinstance(route, Route)]
         self.websocket_routes += [
-            route for route in self.routes if route.extra.websocket
+            route for route in self.routes if route.ctx.websocket
         ]
         self.middlewares += middleware
         self.exceptions += exception_handlers
@@ -456,18 +456,6 @@ class Blueprint(BaseSanic):
                 break
         return value
 
-    @staticmethod
-    def _setup_uri(base: str, prefix: Optional[str]):
-        uri = base
-        if prefix:
-            uri = prefix
-            if base.startswith("/") and prefix.endswith("/"):
-                uri += base[1:]
-            else:
-                uri += base
-
-        return uri[1:] if uri.startswith("//") else uri
-
     @staticmethod
     def register_futures(
         apps: Set[Sanic], bp: Blueprint, futures: Sequence[Tuple[Any, ...]]

sanic/cli/app.py

@@ -1,10 +1,10 @@
-import logging
 import os
 import shutil
 import sys
 
 from argparse import ArgumentParser, RawTextHelpFormatter
-from functools import partial
+from importlib import import_module
+from pathlib import Path
 from textwrap import indent
 from typing import Any, List, Union
 
@@ -12,8 +12,7 @@ from sanic.app import Sanic
 from sanic.application.logo import get_logo
 from sanic.cli.arguments import Group
 from sanic.log import error_logger
-from sanic.worker.inspector import inspect
+from sanic.simple import create_simple_server
-from sanic.worker.loader import AppLoader
 
 
 class SanicArgumentParser(ArgumentParser):
@@ -67,17 +66,13 @@ Or, a path to a directory to run as a simple HTTP server:
             instance.attach()
             self.groups.append(instance)
 
-    def run(self, parse_args=None):
+    def run(self):
-        legacy_version = False
+        # This is to provide backwards compat -v to display version
-        if not parse_args:
+        legacy_version = len(sys.argv) == 2 and sys.argv[-1] == "-v"
-            # This is to provide backwards compat -v to display version
+        parse_args = ["--version"] if legacy_version else None
-            legacy_version = len(sys.argv) == 2 and sys.argv[-1] == "-v"
-            parse_args = ["--version"] if legacy_version else None
-        elif parse_args == ["-v"]:
-            parse_args = ["--version"]
 
-        if not legacy_version:
+        if not parse_args:
-            parsed, unknown = self.parser.parse_known_args(args=parse_args)
+            parsed, unknown = self.parser.parse_known_args()
             if unknown and parsed.factory:
                 for arg in unknown:
                     if arg.startswith("--"):
@@ -85,47 +80,20 @@ Or, a path to a directory to run as a simple HTTP server:
 
         self.args = self.parser.parse_args(args=parse_args)
         self._precheck()
-        app_loader = AppLoader(
-            self.args.module,
-            self.args.factory,
-            self.args.simple,
-            self.args,
-        )
 
         try:
-            app = self._get_app(app_loader)
+            app = self._get_app()
             kwargs = self._build_run_kwargs()
-        except ValueError as e:
+        except ValueError:
-            error_logger.exception(f"Failed to run app: {e}")
+            error_logger.exception("Failed to run app")
         else:
-            if self.args.inspect or self.args.inspect_raw or self.args.trigger:
+            for http_version in self.args.http:
-                os.environ["SANIC_IGNORE_PRODUCTION_WARNING"] = "true"
+                app.prepare(**kwargs, version=http_version)
-            else:
-                for http_version in self.args.http:
-                    app.prepare(**kwargs, version=http_version)
 
-            if self.args.inspect or self.args.inspect_raw or self.args.trigger:
+            Sanic.serve()
-                action = self.args.trigger or (
-                    "raw" if self.args.inspect_raw else "pretty"
-                )
-                inspect(
-                    app.config.INSPECTOR_HOST,
-                    app.config.INSPECTOR_PORT,
-                    action,
-                )
-                del os.environ["SANIC_IGNORE_PRODUCTION_WARNING"]
-                return
-
-            if self.args.single:
-                serve = Sanic.serve_single
-            elif self.args.legacy:
-                serve = Sanic.serve_legacy
-            else:
-                serve = partial(Sanic.serve, app_loader=app_loader)
-            serve(app)
 
     def _precheck(self):
-        # Custom TLS mismatch handling for better diagnostics
+        # # Custom TLS mismatch handling for better diagnostics
         if self.main_process and (
             # one of cert/key missing
             bool(self.args.cert) != bool(self.args.key)
@@ -145,14 +113,58 @@ Or, a path to a directory to run as a simple HTTP server:
             )
             error_logger.error(message)
             sys.exit(1)
-        if self.args.inspect or self.args.inspect_raw:
-            logging.disable(logging.CRITICAL)
 
-    def _get_app(self, app_loader: AppLoader):
+    def _get_app(self):
         try:
-            app = app_loader.load()
+            module_path = os.path.abspath(os.getcwd())
+            if module_path not in sys.path:
+                sys.path.append(module_path)
+
+            if self.args.simple:
+                path = Path(self.args.module)
+                app = create_simple_server(path)
+            else:
+                delimiter = ":" if ":" in self.args.module else "."
+                module_name, app_name = self.args.module.rsplit(delimiter, 1)
+
+                if module_name == "" and os.path.isdir(self.args.module):
+                    raise ValueError(
+                        "App not found.\n"
+                        "   Please use --simple if you are passing a "
+                        "directory to sanic.\n"
+                        f"   eg. sanic {self.args.module} --simple"
+                    )
+
+                if app_name.endswith("()"):
+                    self.args.factory = True
+                    app_name = app_name[:-2]
+
+                module = import_module(module_name)
+                app = getattr(module, app_name, None)
+                if self.args.factory:
+                    try:
+                        app = app(self.args)
+                    except TypeError:
+                        app = app()
+
+                app_type_name = type(app).__name__
+
+                if not isinstance(app, Sanic):
+                    if callable(app):
+                        solution = f"sanic {self.args.module} --factory"
+                        raise ValueError(
+                            "Module is not a Sanic app, it is a "
+                            f"{app_type_name}\n"
+                            "  If this callable returns a "
+                            f"Sanic instance try: \n{solution}"
+                        )
+
+                    raise ValueError(
+                        f"Module is not a Sanic app, it is a {app_type_name}\n"
+                        f"  Perhaps you meant {self.args.module}:app?"
+                    )
         except ImportError as e:
-            if app_loader.module_name.startswith(e.name):  # type: ignore
+            if module_name.startswith(e.name):
                 error_logger.error(
                     f"No module named {e.name} found.\n"
                     "  Example File: project/sanic_server.py -> app\n"
@@ -178,10 +190,8 @@ Or, a path to a directory to run as a simple HTTP server:
         elif len(ssl) == 1 and ssl[0] is not None:
             # Use only one cert, no TLSSelector.
             ssl = ssl[0]
-
         kwargs = {
             "access_log": self.args.access_log,
-            "coffee": self.args.coffee,
             "debug": self.args.debug,
             "fast": self.args.fast,
             "host": self.args.host,
@@ -193,8 +203,6 @@ Or, a path to a directory to run as a simple HTTP server:
             "verbosity": self.args.verbosity or 0,
             "workers": self.args.workers,
             "auto_tls": self.args.auto_tls,
-            "single_process": self.args.single,
-            "legacy": self.args.legacy,
         }
 
         for maybe_arg in ("auto_reload", "dev"):

sanic/cli/arguments.py

@@ -30,7 +30,7 @@ class Group:
         instance = cls(parser, cls.name)
         return instance
 
-    def add_bool_arguments(self, *args, nullable=False, **kwargs):
+    def add_bool_arguments(self, *args, **kwargs):
         group = self.container.add_mutually_exclusive_group()
         kwargs["help"] = kwargs["help"].capitalize()
         group.add_argument(*args, action="store_true", **kwargs)
@@ -38,9 +38,6 @@ class Group:
         group.add_argument(
             "--no-" + args[0][2:], *args[1:], action="store_false", **kwargs
         )
-        if nullable:
-            params = {args[0][2:].replace("-", "_"): None}
-            group.set_defaults(**params)
 
     def prepare(self, args) -> None:
         ...
@@ -70,8 +67,7 @@ class ApplicationGroup(Group):
     name = "Application"
 
     def attach(self):
-        group = self.container.add_mutually_exclusive_group()
+        self.container.add_argument(
-        group.add_argument(
             "--factory",
             action="store_true",
             help=(
@@ -79,7 +75,7 @@ class ApplicationGroup(Group):
                 "i.e. a () -> <Sanic app> callable"
             ),
         )
-        group.add_argument(
+        self.container.add_argument(
             "-s",
             "--simple",
             dest="simple",
@@ -89,32 +85,6 @@ class ApplicationGroup(Group):
                 "a directory\n(module arg should be a path)"
             ),
         )
-        group.add_argument(
-            "--inspect",
-            dest="inspect",
-            action="store_true",
-            help=("Inspect the state of a running instance, human readable"),
-        )
-        group.add_argument(
-            "--inspect-raw",
-            dest="inspect_raw",
-            action="store_true",
-            help=("Inspect the state of a running instance, JSON output"),
-        )
-        group.add_argument(
-            "--trigger-reload",
-            dest="trigger",
-            action="store_const",
-            const="reload",
-            help=("Trigger worker processes to reload"),
-        )
-        group.add_argument(
-            "--trigger-shutdown",
-            dest="trigger",
-            action="store_const",
-            const="shutdown",
-            help=("Trigger all processes to shutdown"),
-        )
 
 
 class HTTPVersionGroup(Group):
@@ -237,22 +207,8 @@ class WorkerGroup(Group):
             action="store_true",
             help="Set the number of workers to max allowed",
         )
-        group.add_argument(
-            "--single-process",
-            dest="single",
-            action="store_true",
-            help="Do not use multiprocessing, run server in a single process",
-        )
-        self.container.add_argument(
-            "--legacy",
-            action="store_true",
-            help="Use the legacy server manager",
-        )
         self.add_bool_arguments(
-            "--access-logs",
+            "--access-logs", dest="access_log", help="display access logs"
-            dest="access_log",
-            help="display access logs",
-            default=None,
         )
 
 
@@ -306,12 +262,6 @@ class OutputGroup(Group):
     name = "Output"
 
     def attach(self):
-        self.add_bool_arguments(
-            "--coffee",
-            dest="coffee",
-            default=False,
-            help="Uhm, coffee?",
-        )
         self.add_bool_arguments(
             "--motd",
             dest="motd",

sanic/config.py

@@ -1,51 +1,30 @@
 from __future__ import annotations
 
-import sys
-
 from inspect import getmembers, isclass, isdatadescriptor
 from os import environ
 from pathlib import Path
 from typing import Any, Callable, Dict, Optional, Sequence, Union
-from warnings import filterwarnings
 
 from sanic.constants import LocalCertCreator
 from sanic.errorpages import DEFAULT_FORMAT, check_error_format
 from sanic.helpers import Default, _default
 from sanic.http import Http
-from sanic.log import error_logger
+from sanic.log import deprecation, error_logger
 from sanic.utils import load_module_from_file_location, str_to_bool
 
 
-if sys.version_info >= (3, 8):
-    from typing import Literal
-
-    FilterWarningType = Union[
-        Literal["default"],
-        Literal["error"],
-        Literal["ignore"],
-        Literal["always"],
-        Literal["module"],
-        Literal["once"],
-    ]
-else:
-    FilterWarningType = str
-
 SANIC_PREFIX = "SANIC_"
 
 
 DEFAULT_CONFIG = {
     "_FALLBACK_ERROR_FORMAT": _default,
-    "ACCESS_LOG": False,
+    "ACCESS_LOG": True,
     "AUTO_EXTEND": True,
     "AUTO_RELOAD": False,
     "EVENT_AUTOREGISTER": False,
-    "DEPRECATION_FILTER": "once",
     "FORWARDED_FOR_HEADER": "X-Forwarded-For",
     "FORWARDED_SECRET": None,
     "GRACEFUL_SHUTDOWN_TIMEOUT": 15.0,  # 15 sec
-    "INSPECTOR": False,
-    "INSPECTOR_HOST": "localhost",
-    "INSPECTOR_PORT": 6457,
     "KEEP_ALIVE_TIMEOUT": 5,  # 5 seconds
     "KEEP_ALIVE": True,
     "LOCAL_CERT_CREATOR": LocalCertCreator.AUTO,
@@ -71,6 +50,10 @@ DEFAULT_CONFIG = {
     "WEBSOCKET_PING_TIMEOUT": 20,
 }
 
+# These values will be removed from the Config object in v22.6 and moved
+# to the application state
+DEPRECATED_CONFIG = ("SERVER_RUNNING", "RELOADER_PROCESS", "RELOADED_FILES")
+
 
 class DescriptorMeta(type):
     def __init__(cls, *_):
@@ -86,13 +69,9 @@ class Config(dict, metaclass=DescriptorMeta):
     AUTO_EXTEND: bool
     AUTO_RELOAD: bool
     EVENT_AUTOREGISTER: bool
-    DEPRECATION_FILTER: FilterWarningType
     FORWARDED_FOR_HEADER: str
     FORWARDED_SECRET: Optional[str]
     GRACEFUL_SHUTDOWN_TIMEOUT: float
-    INSPECTOR: bool
-    INSPECTOR_HOST: str
-    INSPECTOR_PORT: int
     KEEP_ALIVE_TIMEOUT: int
     KEEP_ALIVE: bool
     LOCAL_CERT_CREATOR: Union[str, LocalCertCreator]
@@ -128,7 +107,6 @@ class Config(dict, metaclass=DescriptorMeta):
     ):
         defaults = defaults or {}
         super().__init__({**DEFAULT_CONFIG, **defaults})
-        self._configure_warnings()
 
         self._converters = [str, str_to_bool, float, int]
 
@@ -149,19 +127,19 @@ class Config(dict, metaclass=DescriptorMeta):
         self._check_error_format()
         self._init = True
 
-    def __getattr__(self, attr: Any):
+    def __getattr__(self, attr):
         try:
             return self[attr]
         except KeyError as ke:
             raise AttributeError(f"Config has no '{ke.args[0]}'")
 
-    def __setattr__(self, attr: str, value: Any) -> None:
+    def __setattr__(self, attr, value) -> None:
         self.update({attr: value})
 
-    def __setitem__(self, attr: str, value: Any) -> None:
+    def __setitem__(self, attr, value) -> None:
         self.update({attr: value})
 
-    def update(self, *other: Any, **kwargs: Any) -> None:
+    def update(self, *other, **kwargs) -> None:
         kwargs.update({k: v for item in other for k, v in dict(item).items()})
         setters: Dict[str, Any] = {
             k: kwargs.pop(k)
@@ -194,12 +172,10 @@ class Config(dict, metaclass=DescriptorMeta):
             self.LOCAL_CERT_CREATOR = LocalCertCreator[
                 self.LOCAL_CERT_CREATOR.upper()
             ]
-        elif attr == "DEPRECATION_FILTER":
-            self._configure_warnings()
 
     @property
     def FALLBACK_ERROR_FORMAT(self) -> str:
-        if isinstance(self._FALLBACK_ERROR_FORMAT, Default):
+        if self._FALLBACK_ERROR_FORMAT is _default:
             return DEFAULT_FORMAT
         return self._FALLBACK_ERROR_FORMAT
 
@@ -207,7 +183,7 @@ class Config(dict, metaclass=DescriptorMeta):
     def FALLBACK_ERROR_FORMAT(self, value):
         self._check_error_format(value)
         if (
-            not isinstance(self._FALLBACK_ERROR_FORMAT, Default)
+            self._FALLBACK_ERROR_FORMAT is not _default
             and value != self._FALLBACK_ERROR_FORMAT
         ):
             error_logger.warning(
@@ -223,13 +199,6 @@ class Config(dict, metaclass=DescriptorMeta):
             self.REQUEST_MAX_SIZE,
         )
 
-    def _configure_warnings(self):
-        filterwarnings(
-            self.DEPRECATION_FILTER,
-            category=DeprecationWarning,
-            module=r"sanic.*",
-        )
-
     def _check_error_format(self, format: Optional[str] = None):
         check_error_format(format or self.FALLBACK_ERROR_FORMAT)
 
@@ -237,9 +206,7 @@ class Config(dict, metaclass=DescriptorMeta):
         """
         Looks for prefixed environment variables and applies them to the
         configuration if present. This is called automatically when Sanic
-        starts up to load environment variables into config. Environment
+        starts up to load environment variables into config.
-        variables should start with the defined prefix and should only
-        contain uppercase letters.
 
         It will automatically hydrate the following types:
 
@@ -265,9 +232,12 @@ class Config(dict, metaclass=DescriptorMeta):
         `See user guide re: config
         <https://sanicframework.org/guide/deployment/configuration.html>`__
         """
+        lower_case_var_found = False
         for key, value in environ.items():
-            if not key.startswith(prefix) or not key.isupper():
+            if not key.startswith(prefix):
                 continue
+            if not key.isupper():
+                lower_case_var_found = True
 
             _, config_key = key.split(prefix, 1)
 
@@ -277,6 +247,12 @@ class Config(dict, metaclass=DescriptorMeta):
                     break
                 except ValueError:
                     pass
+        if lower_case_var_found:
+            deprecation(
+                "Lowercase environment variables will not be "
+                "loaded into Sanic config beginning in v22.9.",
+                22.9,
+            )
 
     def update_config(self, config: Union[bytes, str, dict, Any]):
         """

sanic/constants.py

@@ -34,15 +34,6 @@ class LocalCertCreator(str, Enum):
 
 
 HTTP_METHODS = tuple(HTTPMethod.__members__.values())
-SAFE_HTTP_METHODS = (HTTPMethod.GET, HTTPMethod.HEAD, HTTPMethod.OPTIONS)
-IDEMPOTENT_HTTP_METHODS = (
-    HTTPMethod.GET,
-    HTTPMethod.HEAD,
-    HTTPMethod.PUT,
-    HTTPMethod.DELETE,
-    HTTPMethod.OPTIONS,
-)
-CACHEABLE_HTTP_METHODS = (HTTPMethod.GET, HTTPMethod.HEAD)
 DEFAULT_HTTP_CONTENT_TYPE = "application/octet-stream"
 DEFAULT_LOCAL_TLS_KEY = "key.pem"
 DEFAULT_LOCAL_TLS_CERT = "cert.pem"

sanic/errorpages.py

@@ -448,8 +448,8 @@ def exception_response(
             # from the route
             if request.route:
                 try:
-                    if request.route.extra.error_format:
+                    if request.route.ctx.error_format:
-                        render_format = request.route.extra.error_format
+                        render_format = request.route.ctx.error_format
                 except AttributeError:
                     ...
 

sanic/exceptions.py

@@ -1,13 +1,8 @@
-from asyncio import CancelledError
 from typing import Any, Dict, Optional, Union
 
 from sanic.helpers import STATUS_CODES
 
 
-class RequestCancelled(CancelledError):
-    quiet = True
-
-
 class SanicException(Exception):
     message: str = ""
 

sanic/handlers.py

@@ -47,28 +47,6 @@ class ErrorHandler:
     def _full_lookup(self, exception, route_name: Optional[str] = None):
         return self.lookup(exception, route_name)
 
-    def _add(
-        self,
-        key: Tuple[Type[BaseException], Optional[str]],
-        handler: RouteHandler,
-    ) -> None:
-        if key in self.cached_handlers:
-            exc, name = key
-            if name is None:
-                name = "__ALL_ROUTES__"
-
-            error_logger.warning(
-                f"Duplicate exception handler definition on: route={name} "
-                f"and exception={exc}"
-            )
-            deprecation(
-                "A duplicate exception handler definition was discovered. "
-                "This may cause unintended consequences. A warning has been "
-                "issued now, but it will not be allowed starting in v23.3.",
-                23.3,
-            )
-        self.cached_handlers[key] = handler
-
     def add(self, exception, handler, route_names: Optional[List[str]] = None):
         """
         Add a new exception handler to an already existing handler object.
@@ -84,9 +62,9 @@ class ErrorHandler:
         """
         if route_names:
             for route in route_names:
-                self._add((exception, route), handler)
+                self.cached_handlers[(exception, route)] = handler
         else:
-            self._add((exception, None), handler)
+            self.cached_handlers[(exception, None)] = handler
 
     def lookup(self, exception, route_name: Optional[str] = None):
         """

sanic/http/http1.py

@@ -14,8 +14,8 @@ from sanic.exceptions import (
     BadRequest,
     ExpectationFailed,
     PayloadTooLarge,
-    RequestCancelled,
     ServerError,
+    ServiceUnavailable,
 )
 from sanic.headers import format_http1_response
 from sanic.helpers import has_message_body
@@ -132,7 +132,7 @@ class Http(Stream, metaclass=TouchUpMeta):
 
                 if self.stage is Stage.RESPONSE:
                     await self.response.send(end_stream=True)
-            except CancelledError as exc:
+            except CancelledError:
                 # Write an appropriate response before exiting
                 if not self.protocol.transport:
                     logger.info(
@@ -140,11 +140,7 @@ class Http(Stream, metaclass=TouchUpMeta):
                         "stopped. Transport is closed."
                     )
                     return
-                e = (
+                e = self.exception or ServiceUnavailable("Cancelled")
-                    RequestCancelled()
-                    if self.protocol.conn_info.lost
-                    else (self.exception or exc)
-                )
                 self.exception = None
                 self.keep_alive = False
                 await self.error_response(e)
@@ -428,10 +424,7 @@ class Http(Stream, metaclass=TouchUpMeta):
             if self.request is None:
                 self.create_empty_request()
 
-            try:
+            await app.handle_exception(self.request, exception)
-                await app.handle_exception(self.request, exception)
-            except Exception as e:
-                await app.handle_exception(self.request, e, False)
 
     def create_empty_request(self) -> None:
         """

sanic/http/http3.py

@@ -22,7 +22,7 @@ from sanic.exceptions import PayloadTooLarge, SanicException, ServerError
 from sanic.helpers import has_message_body
 from sanic.http.constants import Stage
 from sanic.http.stream import Stream
-from sanic.http.tls.context import CertSelector, SanicSSLContext
+from sanic.http.tls.context import CertSelector, CertSimple, SanicSSLContext
 from sanic.log import Colors, logger
 from sanic.models.protocol_types import TransportProtocol
 from sanic.models.server_types import ConnInfo
@@ -378,7 +378,7 @@ def get_config(
     app: Sanic, ssl: Union[SanicSSLContext, CertSelector, SSLContext]
 ):
     # TODO:
-    # - proper selection needed if service with multiple certs insted of
+    # - proper selection needed if servince with multiple certs insted of
     #   just taking the first
     if isinstance(ssl, CertSelector):
         ssl = cast(SanicSSLContext, ssl.sanic_select[0])
@@ -389,8 +389,8 @@ def get_config(
             "should be able to use mkcert instead. For more information, see: "
             "https://github.com/aiortc/aioquic/issues/295."
         )
-    if not isinstance(ssl, SanicSSLContext):
+    if not isinstance(ssl, CertSimple):
-        raise SanicException("SSLContext is not SanicSSLContext")
+        raise SanicException("SSLContext is not CertSimple")
 
     config = QuicConfiguration(
         alpn_protocols=H3_ALPN + H0_ALPN + ["siduck"],

sanic/http/tls/creators.py

@@ -72,8 +72,7 @@ def get_ssl_context(
             "without passing a TLS certificate. If you are developing "
             "locally, please enable DEVELOPMENT mode and Sanic will "
             "generate a localhost TLS certificate. For more information "
-            "please see: https://sanic.dev/en/guide/deployment/development."
+            "please see: ___."
-            "html#automatic-tls-certificate."
         )
 
     creator = CertCreator.select(
@@ -152,8 +151,7 @@ class CertCreator(ABC):
             raise SanicException(
                 "Sanic could not find package to create a TLS certificate. "
                 "You must have either mkcert or trustme installed. See "
-                "https://sanic.dev/en/guide/deployment/development.html"
+                "_____ for more details."
-                "#automatic-tls-certificate for more details."
             )
 
         return creator
@@ -205,8 +203,7 @@ class MkcertCreator(CertCreator):
                 "to proceed. Installation instructions can be found here: "
                 "https://github.com/FiloSottile/mkcert.\n"
                 "Find out more information about your options here: "
-                "https://sanic.dev/en/guide/deployment/development.html#"
+                "_____"
-                "automatic-tls-certificate"
             ) from e
 
     def generate_cert(self, localhost: str) -> ssl.SSLContext:
@@ -243,12 +240,7 @@ class MkcertCreator(CertCreator):
                         self.cert_path.unlink()
                     self.tmpdir.rmdir()
 
-        context = CertSimple(self.cert_path, self.key_path)
+        return CertSimple(self.cert_path, self.key_path)
-        context.sanic["creator"] = "mkcert"
-        context.sanic["localhost"] = localhost
-        SanicSSLContext.create_from_ssl_context(context)
-
-        return context
 
 
 class TrustmeCreator(CertCreator):
@@ -263,28 +255,24 @@ class TrustmeCreator(CertCreator):
                 "to proceed. Installation instructions can be found here: "
                 "https://github.com/python-trio/trustme.\n"
                 "Find out more information about your options here: "
-                "https://sanic.dev/en/guide/deployment/development.html#"
+                "_____"
-                "automatic-tls-certificate"
             )
 
     def generate_cert(self, localhost: str) -> ssl.SSLContext:
-        context = SanicSSLContext.create_from_ssl_context(
+        context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
-            ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
+        sanic_context = SanicSSLContext.create_from_ssl_context(context)
-        )
+        sanic_context.sanic = {
-        context.sanic = {
             "cert": self.cert_path.absolute(),
             "key": self.key_path.absolute(),
         }
         ca = trustme.CA()
         server_cert = ca.issue_cert(localhost)
-        server_cert.configure_cert(context)
+        server_cert.configure_cert(sanic_context)
         ca.configure_trust(context)
 
         ca.cert_pem.write_to_path(str(self.cert_path.absolute()))
         server_cert.private_key_and_cert_chain_pem.write_to_path(
             str(self.key_path.absolute())
         )
-        context.sanic["creator"] = "trustme"
-        context.sanic["localhost"] = localhost
 
         return context

sanic/log.py

@@ -25,12 +25,6 @@ LOGGING_CONFIG_DEFAULTS: Dict[str, Any] = dict(  # no cov
             "propagate": True,
             "qualname": "sanic.access",
         },
-        "sanic.server": {
-            "level": "INFO",
-            "handlers": ["console"],
-            "propagate": True,
-            "qualname": "sanic.server",
-        },
     },
     handlers={
         "console": {
@@ -70,11 +64,10 @@ Defult logging configuration
 
 class Colors(str, Enum):  # no cov
     END = "\033[0m"
-    BOLD = "\033[1m"
+    BLUE = "\033[01;34m"
-    BLUE = "\033[34m"
+    GREEN = "\033[01;32m"
-    GREEN = "\033[32m"
+    PURPLE = "\033[01;35m"
-    PURPLE = "\033[35m"
+    RED = "\033[01;31m"
-    RED = "\033[31m"
     SANIC = "\033[38;2;255;13;104m"
     YELLOW = "\033[01;33m"
 
@@ -107,12 +100,6 @@ Logger used by Sanic for access logging
 """
 access_logger.addFilter(_verbosity_filter)
 
-server_logger = logging.getLogger("sanic.server")  # no cov
-"""
-Logger used by Sanic for server related messages
-"""
-logger.addFilter(_verbosity_filter)
-
 
 def deprecation(message: str, version: float):  # no cov
     version_info = f"[DEPRECATION v{version}] "

sanic/middleware.py

@@ -1,66 +0,0 @@
-from __future__ import annotations
-
-from collections import deque
-from enum import IntEnum, auto
-from itertools import count
-from typing import Deque, Sequence, Union
-
-from sanic.models.handler_types import MiddlewareType
-
-
-class MiddlewareLocation(IntEnum):
-    REQUEST = auto()
-    RESPONSE = auto()
-
-
-class Middleware:
-    _counter = count()
-
-    __slots__ = ("func", "priority", "location", "definition")
-
-    def __init__(
-        self,
-        func: MiddlewareType,
-        location: MiddlewareLocation,
-        priority: int = 0,
-    ) -> None:
-        self.func = func
-        self.priority = priority
-        self.location = location
-        self.definition = next(Middleware._counter)
-
-    def __call__(self, *args, **kwargs):
-        return self.func(*args, **kwargs)
-
-    def __repr__(self) -> str:
-        return (
-            f"{self.__class__.__name__}("
-            f"func=<function {self.func.__name__}>, "
-            f"priority={self.priority}, "
-            f"location={self.location.name})"
-        )
-
-    @property
-    def order(self):
-        return (self.priority, -self.definition)
-
-    @classmethod
-    def convert(
-        cls,
-        *middleware_collections: Sequence[Union[Middleware, MiddlewareType]],
-        location: MiddlewareLocation,
-    ) -> Deque[Middleware]:
-        return deque(
-            [
-                middleware
-                if isinstance(middleware, Middleware)
-                else Middleware(middleware, location)
-                for collection in middleware_collections
-                for middleware in collection
-            ]
-        )
-
-    @classmethod
-    def reset_count(cls):
-        cls._counter = count()
-        cls.count = next(cls._counter)

sanic/mixins/listeners.py

@@ -17,12 +17,9 @@ class ListenerEvent(str, Enum):
     BEFORE_SERVER_STOP = "server.shutdown.before"
     AFTER_SERVER_STOP = "server.shutdown.after"
     MAIN_PROCESS_START = auto()
-    MAIN_PROCESS_READY = auto()
     MAIN_PROCESS_STOP = auto()
     RELOAD_PROCESS_START = auto()
     RELOAD_PROCESS_STOP = auto()
-    BEFORE_RELOAD_TRIGGER = auto()
-    AFTER_RELOAD_TRIGGER = auto()
 
 
 class ListenerMixin(metaclass=SanicMeta):
@@ -101,11 +98,6 @@ class ListenerMixin(metaclass=SanicMeta):
     ) -> ListenerType[Sanic]:
         return self.listener(listener, "main_process_start")
 
-    def main_process_ready(
-        self, listener: ListenerType[Sanic]
-    ) -> ListenerType[Sanic]:
-        return self.listener(listener, "main_process_ready")
-
     def main_process_stop(
         self, listener: ListenerType[Sanic]
     ) -> ListenerType[Sanic]:
@@ -121,16 +113,6 @@ class ListenerMixin(metaclass=SanicMeta):
     ) -> ListenerType[Sanic]:
         return self.listener(listener, "reload_process_stop")
 
-    def before_reload_trigger(
-        self, listener: ListenerType[Sanic]
-    ) -> ListenerType[Sanic]:
-        return self.listener(listener, "before_reload_trigger")
-
-    def after_reload_trigger(
-        self, listener: ListenerType[Sanic]
-    ) -> ListenerType[Sanic]:
-        return self.listener(listener, "after_reload_trigger")
-
     def before_server_start(
         self, listener: ListenerType[Sanic]
     ) -> ListenerType[Sanic]:

sanic/mixins/middleware.py

@@ -1,17 +1,11 @@
-from collections import deque
 from functools import partial
-from operator import attrgetter
 from typing import List
 
 from sanic.base.meta import SanicMeta
-from sanic.middleware import Middleware, MiddlewareLocation
 from sanic.models.futures import FutureMiddleware
-from sanic.router import Router
 
 
 class MiddlewareMixin(metaclass=SanicMeta):
-    router: Router
-
     def __init__(self, *args, **kwargs) -> None:
         self._future_middleware: List[FutureMiddleware] = []
 
@@ -19,12 +13,7 @@ class MiddlewareMixin(metaclass=SanicMeta):
         raise NotImplementedError  # noqa
 
     def middleware(
-        self,
+        self, middleware_or_request, attach_to="request", apply=True
-        middleware_or_request,
-        attach_to="request",
-        apply=True,
-        *,
-        priority=0
     ):
         """
         Decorate and register middleware to be called before a request
@@ -41,12 +30,6 @@ class MiddlewareMixin(metaclass=SanicMeta):
         def register_middleware(middleware, attach_to="request"):
             nonlocal apply
 
-            location = (
-                MiddlewareLocation.REQUEST
-                if attach_to == "request"
-                else MiddlewareLocation.RESPONSE
-            )
-            middleware = Middleware(middleware, location, priority=priority)
             future_middleware = FutureMiddleware(middleware, attach_to)
             self._future_middleware.append(future_middleware)
             if apply:
@@ -63,7 +46,7 @@ class MiddlewareMixin(metaclass=SanicMeta):
                 register_middleware, attach_to=middleware_or_request
             )
 
-    def on_request(self, middleware=None, *, priority=0):
+    def on_request(self, middleware=None):
         """Register a middleware to be called before a request is handled.
 
         This is the same as *@app.middleware('request')*.
@@ -71,13 +54,11 @@ class MiddlewareMixin(metaclass=SanicMeta):
         :param: middleware: A callable that takes in request.
         """
         if callable(middleware):
-            return self.middleware(middleware, "request", priority=priority)
+            return self.middleware(middleware, "request")
         else:
-            return partial(
+            return partial(self.middleware, attach_to="request")
-                self.middleware, attach_to="request", priority=priority
-            )
 
-    def on_response(self, middleware=None, *, priority=0):
+    def on_response(self, middleware=None):
         """Register a middleware to be called after a response is created.
 
         This is the same as *@app.middleware('response')*.
@@ -86,57 +67,6 @@ class MiddlewareMixin(metaclass=SanicMeta):
             A callable that takes in a request and its response.
         """
         if callable(middleware):
-            return self.middleware(middleware, "response", priority=priority)
+            return self.middleware(middleware, "response")
         else:
-            return partial(
+            return partial(self.middleware, attach_to="response")
-                self.middleware, attach_to="response", priority=priority
-            )
-
-    def finalize_middleware(self):
-        for route in self.router.routes:
-            request_middleware = Middleware.convert(
-                self.request_middleware,
-                self.named_request_middleware.get(route.name, deque()),
-                location=MiddlewareLocation.REQUEST,
-            )
-            response_middleware = Middleware.convert(
-                self.response_middleware,
-                self.named_response_middleware.get(route.name, deque()),
-                location=MiddlewareLocation.RESPONSE,
-            )
-            route.extra.request_middleware = deque(
-                sorted(
-                    request_middleware,
-                    key=attrgetter("order"),
-                    reverse=True,
-                )
-            )
-            route.extra.response_middleware = deque(
-                sorted(
-                    response_middleware,
-                    key=attrgetter("order"),
-                    reverse=True,
-                )[::-1]
-            )
-        request_middleware = Middleware.convert(
-            self.request_middleware,
-            location=MiddlewareLocation.REQUEST,
-        )
-        response_middleware = Middleware.convert(
-            self.response_middleware,
-            location=MiddlewareLocation.RESPONSE,
-        )
-        self.request_middleware = deque(
-            sorted(
-                request_middleware,
-                key=attrgetter("order"),
-                reverse=True,
-            )
-        )
-        self.response_middleware = deque(
-            sorted(
-                response_middleware,
-                key=attrgetter("order"),
-                reverse=True,
-            )[::-1]
-        )

sanic/mixins/routes.py

@@ -1,16 +1,15 @@
 from ast import NodeVisitor, Return, parse
 from contextlib import suppress
-from email.utils import formatdate
 from functools import partial, wraps
 from inspect import getsource, signature
 from mimetypes import guess_type
 from os import path
 from pathlib import Path, PurePath
 from textwrap import dedent
+from time import gmtime, strftime
 from typing import (
     Any,
     Callable,
-    Dict,
     Iterable,
     List,
     Optional,
@@ -32,13 +31,21 @@ from sanic.handlers import ContentRangeHandler
 from sanic.log import error_logger
 from sanic.models.futures import FutureRoute, FutureStatic
 from sanic.models.handler_types import RouteHandler
-from sanic.response import HTTPResponse, file, file_stream, validate_file
+from sanic.response import HTTPResponse, file, file_stream
 from sanic.types import HashableDict
 
 
 RouteWrapper = Callable[
     [RouteHandler], Union[RouteHandler, Tuple[Route, RouteHandler]]
 ]
+RESTRICTED_ROUTE_CONTEXT = (
+    "ignore_body",
+    "stream",
+    "hosts",
+    "static",
+    "error_format",
+    "websocket",
+)
 
 
 class RouteMixin(metaclass=SanicMeta):
@@ -218,7 +225,7 @@ class RouteMixin(metaclass=SanicMeta):
         stream: bool = False,
         version_prefix: str = "/v",
         error_format: Optional[str] = None,
-        **ctx_kwargs: Any,
+        **ctx_kwargs,
     ) -> RouteHandler:
         """A helper method to register class instance or
         functions as a handler to the application url
@@ -279,7 +286,7 @@ class RouteMixin(metaclass=SanicMeta):
         ignore_body: bool = True,
         version_prefix: str = "/v",
         error_format: Optional[str] = None,
-        **ctx_kwargs: Any,
+        **ctx_kwargs,
     ) -> RouteHandler:
         """
         Add an API URL under the **GET** *HTTP* method
@@ -322,7 +329,7 @@ class RouteMixin(metaclass=SanicMeta):
         name: Optional[str] = None,
         version_prefix: str = "/v",
         error_format: Optional[str] = None,
-        **ctx_kwargs: Any,
+        **ctx_kwargs,
     ) -> RouteHandler:
         """
         Add an API URL under the **POST** *HTTP* method
@@ -365,7 +372,7 @@ class RouteMixin(metaclass=SanicMeta):
         name: Optional[str] = None,
         version_prefix: str = "/v",
         error_format: Optional[str] = None,
-        **ctx_kwargs: Any,
+        **ctx_kwargs,
     ) -> RouteHandler:
         """
         Add an API URL under the **PUT** *HTTP* method
@@ -408,7 +415,7 @@ class RouteMixin(metaclass=SanicMeta):
         ignore_body: bool = True,
         version_prefix: str = "/v",
         error_format: Optional[str] = None,
-        **ctx_kwargs: Any,
+        **ctx_kwargs,
     ) -> RouteHandler:
         """
         Add an API URL under the **HEAD** *HTTP* method
@@ -459,7 +466,7 @@ class RouteMixin(metaclass=SanicMeta):
         ignore_body: bool = True,
         version_prefix: str = "/v",
         error_format: Optional[str] = None,
-        **ctx_kwargs: Any,
+        **ctx_kwargs,
     ) -> RouteHandler:
         """
         Add an API URL under the **OPTIONS** *HTTP* method
@@ -510,7 +517,7 @@ class RouteMixin(metaclass=SanicMeta):
         name: Optional[str] = None,
         version_prefix: str = "/v",
         error_format: Optional[str] = None,
-        **ctx_kwargs: Any,
+        **ctx_kwargs,
     ) -> RouteHandler:
         """
         Add an API URL under the **PATCH** *HTTP* method
@@ -563,7 +570,7 @@ class RouteMixin(metaclass=SanicMeta):
         ignore_body: bool = True,
         version_prefix: str = "/v",
         error_format: Optional[str] = None,
-        **ctx_kwargs: Any,
+        **ctx_kwargs,
     ) -> RouteHandler:
         """
         Add an API URL under the **DELETE** *HTTP* method
@@ -607,7 +614,7 @@ class RouteMixin(metaclass=SanicMeta):
         apply: bool = True,
         version_prefix: str = "/v",
         error_format: Optional[str] = None,
-        **ctx_kwargs: Any,
+        **ctx_kwargs,
     ):
         """
         Decorate a function to be registered as a websocket route
@@ -651,7 +658,7 @@ class RouteMixin(metaclass=SanicMeta):
         name: Optional[str] = None,
         version_prefix: str = "/v",
         error_format: Optional[str] = None,
-        **ctx_kwargs: Any,
+        **ctx_kwargs,
     ):
         """
         A helper method to register a function as a websocket route.
@@ -688,18 +695,18 @@ class RouteMixin(metaclass=SanicMeta):
 
     def static(
         self,
-        uri: str,
+        uri,
         file_or_directory: Union[str, bytes, PurePath],
-        pattern: str = r"/?.+",
+        pattern=r"/?.+",
-        use_modified_since: bool = True,
+        use_modified_since=True,
-        use_content_range: bool = False,
+        use_content_range=False,
-        stream_large_files: bool = False,
+        stream_large_files=False,
-        name: str = "static",
+        name="static",
-        host: Optional[str] = None,
+        host=None,
-        strict_slashes: Optional[bool] = None,
+        strict_slashes=None,
-        content_type: Optional[bool] = None,
+        content_type=None,
-        apply: bool = True,
+        apply=True,
-        resource_type: Optional[str] = None,
+        resource_type=None,
     ):
         """
         Register a root to serve files from. The input can either be a
@@ -783,9 +790,24 @@ class RouteMixin(metaclass=SanicMeta):
 
         return name
 
-    async def _get_file_path(self, file_or_directory, __file_uri__, not_found):
+    async def _static_request_handler(
+        self,
+        file_or_directory,
+        use_modified_since,
+        use_content_range,
+        stream_large_files,
+        request,
+        content_type=None,
+        __file_uri__=None,
+    ):
+        # Merge served directory and requested file if provided
         file_path_raw = Path(unquote(file_or_directory))
         root_path = file_path = file_path_raw.resolve()
+        not_found = FileNotFound(
+            "File not found",
+            path=file_or_directory,
+            relative_url=__file_uri__,
+        )
 
         if __file_uri__:
             # Strip all / that in the beginning of the URL to help prevent
@@ -812,29 +834,6 @@ class RouteMixin(metaclass=SanicMeta):
                     f"relative_url={__file_uri__}"
                 )
                 raise not_found
-        return file_path
-
-    async def _static_request_handler(
-        self,
-        file_or_directory,
-        use_modified_since,
-        use_content_range,
-        stream_large_files,
-        request,
-        content_type=None,
-        __file_uri__=None,
-    ):
-        not_found = FileNotFound(
-            "File not found",
-            path=file_or_directory,
-            relative_url=__file_uri__,
-        )
-
-        # Merge served directory and requested file if provided
-        file_path = await self._get_file_path(
-            file_or_directory, __file_uri__, not_found
-        )
-
         try:
             headers = {}
             # Check if the client has been sent this file before
@@ -842,13 +841,15 @@ class RouteMixin(metaclass=SanicMeta):
             stats = None
             if use_modified_since:
                 stats = await stat_async(file_path)
-                modified_since = stats.st_mtime
+                modified_since = strftime(
-                response = await validate_file(request.headers, modified_since)
+                    "%a, %d %b %Y %H:%M:%S GMT", gmtime(stats.st_mtime)
-                if response:
-                    return response
-                headers["Last-Modified"] = formatdate(
-                    modified_since, usegmt=True
                 )
+                if (
+                    request.headers.getone("if-modified-since", None)
+                    == modified_since
+                ):
+                    return HTTPResponse(status=304)
+                headers["Last-Modified"] = modified_since
             _range = None
             if use_content_range:
                 _range = None
@@ -863,7 +864,8 @@ class RouteMixin(metaclass=SanicMeta):
                         pass
                     else:
                         del headers["Content-Length"]
-                        headers.update(_range.headers)
+                        for key, value in _range.headers.items():
+                            headers[key] = value
 
             if "content-type" not in headers:
                 content_type = (
@@ -956,7 +958,6 @@ class RouteMixin(metaclass=SanicMeta):
         # serve from the folder
         if not static.resource_type:
             if not path.isfile(file_or_directory):
-                uri = uri.rstrip("/")
                 uri += "/<__file_uri__:path>"
         elif static.resource_type == "dir":
             if path.isfile(file_or_directory):
@@ -964,7 +965,6 @@ class RouteMixin(metaclass=SanicMeta):
                     "Resource type improperly identified as directory. "
                     f"'{file_or_directory}'"
                 )
-            uri = uri.rstrip("/")
             uri += "/<__file_uri__:path>"
         elif static.resource_type == "file" and not path.isfile(
             file_or_directory
@@ -1039,12 +1039,24 @@ class RouteMixin(metaclass=SanicMeta):
 
         return types
 
-    def _build_route_context(self, raw: Dict[str, Any]) -> HashableDict:
+    def _build_route_context(self, raw):
         ctx_kwargs = {
             key.replace("ctx_", ""): raw.pop(key)
             for key in {**raw}.keys()
             if key.startswith("ctx_")
         }
+        restricted = [
+            key for key in ctx_kwargs.keys() if key in RESTRICTED_ROUTE_CONTEXT
+        ]
+        if restricted:
+            restricted_arguments = ", ".join(restricted)
+            raise AttributeError(
+                "Cannot use restricted route context: "
+                f"{restricted_arguments}. This limitation is only in place "
+                "until v22.9 when the restricted names will no longer be in"
+                "conflict. See https://github.com/sanic-org/sanic/issues/2303 "
+                "for more information."
+            )
         if raw:
             unexpected_arguments = ", ".join(raw.keys())
             raise TypeError(

sanic/mixins/runner.py

@@ -16,15 +16,12 @@ from asyncio import (
 from contextlib import suppress
 from functools import partial
 from importlib import import_module
-from multiprocessing import Manager, Pipe, get_context
-from multiprocessing.context import BaseContext
 from pathlib import Path
 from socket import socket
 from ssl import SSLContext
 from typing import (
     TYPE_CHECKING,
     Any,
-    Callable,
     Dict,
     List,
     Optional,
@@ -35,34 +32,24 @@ from typing import (
     cast,
 )
 
-from sanic.application.ext import setup_ext
+from sanic import reloader_helpers
 from sanic.application.logo import get_logo
 from sanic.application.motd import MOTD
 from sanic.application.state import ApplicationServerInfo, Mode, ServerStage
 from sanic.base.meta import SanicMeta
 from sanic.compat import OS_IS_WINDOWS, is_atty
-from sanic.helpers import Default
+from sanic.helpers import _default
 from sanic.http.constants import HTTP
 from sanic.http.tls import get_ssl_context, process_to_context
-from sanic.http.tls.context import SanicSSLContext
 from sanic.log import Colors, deprecation, error_logger, logger
 from sanic.models.handler_types import ListenerType
 from sanic.server import Signal as ServerSignal
 from sanic.server import try_use_uvloop
 from sanic.server.async_server import AsyncioServer
 from sanic.server.events import trigger_events
-from sanic.server.legacy import watchdog
-from sanic.server.loop import try_windows_loop
 from sanic.server.protocols.http_protocol import HttpProtocol
 from sanic.server.protocols.websocket_protocol import WebSocketProtocol
 from sanic.server.runners import serve, serve_multiple, serve_single
-from sanic.server.socket import configure_socket, remove_unix_socket
-from sanic.worker.inspector import Inspector
-from sanic.worker.loader import AppLoader
-from sanic.worker.manager import WorkerManager
-from sanic.worker.multiplexer import WorkerMultiplexer
-from sanic.worker.reloader import Reloader
-from sanic.worker.serve import worker_serve
 
 
 if TYPE_CHECKING:
@@ -72,36 +59,21 @@ if TYPE_CHECKING:
 
 SANIC_PACKAGES = ("sanic-routing", "sanic-testing", "sanic-ext")
 
-if sys.version_info < (3, 8):  # no cov
+if sys.version_info < (3, 8):
     HTTPVersion = Union[HTTP, int]
-else:  # no cov
+else:
     from typing import Literal
 
     HTTPVersion = Union[HTTP, Literal[1], Literal[3]]
 
 
-class StartupMixin(metaclass=SanicMeta):
+class RunnerMixin(metaclass=SanicMeta):
     _app_registry: Dict[str, Sanic]
+    asgi: bool
     config: Config
     listeners: Dict[str, List[ListenerType[Any]]]
     state: ApplicationState
     websocket_enabled: bool
-    multiplexer: WorkerMultiplexer
-
-    def setup_loop(self):
-        if not self.asgi:
-            if self.config.USE_UVLOOP is True or (
-                isinstance(self.config.USE_UVLOOP, Default)
-                and not OS_IS_WINDOWS
-            ):
-                try_use_uvloop()
-            elif OS_IS_WINDOWS:
-                try_windows_loop()
-
-    @property
-    def m(self) -> WorkerMultiplexer:
-        """Interface for interacting with the worker processes"""
-        return self.multiplexer
 
     def make_coffee(self, *args, **kwargs):
         self.state.coffee = True
@@ -132,8 +104,6 @@ class StartupMixin(metaclass=SanicMeta):
         verbosity: int = 0,
         motd_display: Optional[Dict[str, str]] = None,
         auto_tls: bool = False,
-        single_process: bool = False,
-        legacy: bool = False,
     ) -> None:
         """
         Run the HTTP Server and listen until keyboard interrupt or term
@@ -194,17 +164,9 @@ class StartupMixin(metaclass=SanicMeta):
             verbosity=verbosity,
             motd_display=motd_display,
             auto_tls=auto_tls,
-            single_process=single_process,
-            legacy=legacy,
         )
 
-        if single_process:
+        self.__class__.serve(primary=self)  # type: ignore
-            serve = self.__class__.serve_single
-        elif legacy:
-            serve = self.__class__.serve_legacy
-        else:
-            serve = self.__class__.serve
-        serve(primary=self)  # type: ignore
 
     def prepare(
         self,
@@ -230,10 +192,7 @@ class StartupMixin(metaclass=SanicMeta):
         fast: bool = False,
         verbosity: int = 0,
         motd_display: Optional[Dict[str, str]] = None,
-        coffee: bool = False,
         auto_tls: bool = False,
-        single_process: bool = False,
-        legacy: bool = False,
     ) -> None:
         if version == 3 and self.state.server_info:
             raise RuntimeError(
@@ -246,9 +205,6 @@ class StartupMixin(metaclass=SanicMeta):
             debug = True
             auto_reload = True
 
-        if debug and access_log is None:
-            access_log = True
-
         self.state.verbosity = verbosity
         if not self.state.auto_reload:
             self.state.auto_reload = bool(auto_reload)
@@ -256,21 +212,6 @@ class StartupMixin(metaclass=SanicMeta):
         if fast and workers != 1:
             raise RuntimeError("You cannot use both fast=True and workers=X")
 
-        if single_process and (fast or (workers > 1) or auto_reload):
-            raise RuntimeError(
-                "Single process cannot be run with multiple workers "
-                "or auto-reload"
-            )
-
-        if single_process and legacy:
-            raise RuntimeError("Cannot run single process and legacy mode")
-
-        if register_sys_signals is False and not (single_process or legacy):
-            raise RuntimeError(
-                "Cannot run Sanic.serve with register_sys_signals=False. "
-                "Use either Sanic.serve_single or Sanic.serve_legacy."
-            )
-
         if motd_display:
             self.config.MOTD_DISPLAY.update(motd_display)
 
@@ -294,6 +235,12 @@ class StartupMixin(metaclass=SanicMeta):
                 "#asynchronous-support"
             )
 
+        if (
+            self.__class__.should_auto_reload()
+            and os.environ.get("SANIC_SERVER_RUNNING") != "true"
+        ):  # no cov
+            return
+
         if sock is None:
             host, port = self.get_address(host, port, version, auto_tls)
 
@@ -319,9 +266,6 @@ class StartupMixin(metaclass=SanicMeta):
             except AttributeError:  # no cov
                 workers = os.cpu_count() or 1
 
-        if coffee:
-            self.state.coffee = True
-
         server_settings = self._helper(
             host=host,
             port=port,
@@ -340,10 +284,10 @@ class StartupMixin(metaclass=SanicMeta):
             ApplicationServerInfo(settings=server_settings)
         )
 
-        # if self.config.USE_UVLOOP is True or (
+        if self.config.USE_UVLOOP is True or (
-        #     self.config.USE_UVLOOP is _default and not OS_IS_WINDOWS
+            self.config.USE_UVLOOP is _default and not OS_IS_WINDOWS
-        # ):
+        ):
-        #     try_use_uvloop()
+            try_use_uvloop()
 
     async def create_server(
         self,
@@ -432,7 +376,7 @@ class StartupMixin(metaclass=SanicMeta):
             run_async=return_asyncio_server,
         )
 
-        if not isinstance(self.config.USE_UVLOOP, Default):
+        if self.config.USE_UVLOOP is not _default:
             error_logger.warning(
                 "You are trying to change the uvloop configuration, but "
                 "this is only effective when using the run(...) method. "
@@ -452,23 +396,18 @@ class StartupMixin(metaclass=SanicMeta):
             asyncio_server_kwargs=asyncio_server_kwargs, **server_settings
         )
 
-    def stop(self, terminate: bool = True, unregister: bool = False):
+    def stop(self):
         """
         This kills the Sanic
         """
-        if terminate and hasattr(self, "multiplexer"):
-            self.multiplexer.terminate()
         if self.state.stage is not ServerStage.STOPPED:
-            self.shutdown_tasks(timeout=0)  # type: ignore
+            self.shutdown_tasks(timeout=0)
             for task in all_tasks():
                 with suppress(AttributeError):
                     if task.get_name() == "RunServer":
                         task.cancel()
             get_event_loop().stop()
 
-        if unregister:
-            self.__class__.unregister_app(self)  # type: ignore
-
     def _helper(
         self,
         host: Optional[str] = None,
@@ -530,11 +469,7 @@ class StartupMixin(metaclass=SanicMeta):
 
         self.motd(server_settings=server_settings)
 
-        if (
+        if is_atty() and not self.state.is_debug:
-            is_atty()
-            and not self.state.is_debug
-            and not os.environ.get("SANIC_IGNORE_PRODUCTION_WARNING")
-        ):
             error_logger.warning(
                 f"{Colors.YELLOW}Sanic is running in PRODUCTION mode. "
                 "Consider using '--debug' or '--dev' while actively "
@@ -560,85 +495,80 @@ class StartupMixin(metaclass=SanicMeta):
 
     def motd(
         self,
+        serve_location: str = "",
         server_settings: Optional[Dict[str, Any]] = None,
     ):
-        if (
+        if serve_location:
-            os.environ.get("SANIC_WORKER_NAME")
+            deprecation(
-            or os.environ.get("SANIC_MOTD_OUTPUT")
+                "Specifying a serve_location in the MOTD is deprecated and "
-            or os.environ.get("SANIC_WORKER_PROCESS")
+                "will be removed.",
-            or os.environ.get("SANIC_SERVER_RUNNING")
+                22.9,
-        ):
-            return
-        serve_location = self.get_server_location(server_settings)
-        if self.config.MOTD:
-            logo = get_logo(coffee=self.state.coffee)
-            display, extra = self.get_motd_data(server_settings)
-
-            MOTD.output(logo, serve_location, display, extra)
-
-    def get_motd_data(
-        self, server_settings: Optional[Dict[str, Any]] = None
-    ) -> Tuple[Dict[str, Any], Dict[str, Any]]:
-        mode = [f"{self.state.mode},"]
-        if self.state.fast:
-            mode.append("goin' fast")
-        if self.state.asgi:
-            mode.append("ASGI")
-        else:
-            if self.state.workers == 1:
-                mode.append("single worker")
-            else:
-                mode.append(f"w/ {self.state.workers} workers")
-
-        if server_settings:
-            server = ", ".join(
-                (
-                    self.state.server,
-                    server_settings["version"].display(),  # type: ignore
-                )
             )
         else:
-            server = "ASGI" if self.asgi else "unknown"  # type: ignore
+            serve_location = self.get_server_location(server_settings)
+        if self.config.MOTD:
+            mode = [f"{self.state.mode},"]
+            if self.state.fast:
+                mode.append("goin' fast")
+            if self.state.asgi:
+                mode.append("ASGI")
+            else:
+                if self.state.workers == 1:
+                    mode.append("single worker")
+                else:
+                    mode.append(f"w/ {self.state.workers} workers")
 
-        display = {
+            if server_settings:
-            "mode": " ".join(mode),
+                server = ", ".join(
-            "server": server,
+                    (
-            "python": platform.python_version(),
+                        self.state.server,
-            "platform": platform.platform(),
+                        server_settings["version"].display(),  # type: ignore
-        }
+                    )
-        extra = {}
-        if self.config.AUTO_RELOAD:
-            reload_display = "enabled"
-            if self.state.reload_dirs:
-                reload_display += ", ".join(
-                    [
-                        "",
-                        *(
-                            str(path.absolute())
-                            for path in self.state.reload_dirs
-                        ),
-                    ]
                 )
-            display["auto-reload"] = reload_display
+            else:
+                server = "ASGI" if self.asgi else "unknown"  # type: ignore
 
-        packages = []
+            display = {
-        for package_name in SANIC_PACKAGES:
+                "mode": " ".join(mode),
-            module_name = package_name.replace("-", "_")
+                "server": server,
-            try:
+                "python": platform.python_version(),
-                module = import_module(module_name)
+                "platform": platform.platform(),
-                packages.append(
+            }
-                    f"{package_name}=={module.__version__}"  # type: ignore
+            extra = {}
-                )
+            if self.config.AUTO_RELOAD:
-            except ImportError:  # no cov
+                reload_display = "enabled"
-                ...
+                if self.state.reload_dirs:
+                    reload_display += ", ".join(
+                        [
+                            "",
+                            *(
+                                str(path.absolute())
+                                for path in self.state.reload_dirs
+                            ),
+                        ]
+                    )
+                display["auto-reload"] = reload_display
 
-        if packages:
+            packages = []
-            display["packages"] = ", ".join(packages)
+            for package_name in SANIC_PACKAGES:
+                module_name = package_name.replace("-", "_")
+                try:
+                    module = import_module(module_name)
+                    packages.append(
+                        f"{package_name}=={module.__version__}"  # type: ignore
+                    )
+                except ImportError:
+                    ...
 
-        if self.config.MOTD_DISPLAY:
+            if packages:
-            extra.update(self.config.MOTD_DISPLAY)
+                display["packages"] = ", ".join(packages)
 
-        return display, extra
+            if self.config.MOTD_DISPLAY:
+                extra.update(self.config.MOTD_DISPLAY)
+
+            logo = get_logo(coffee=self.state.coffee)
+
+            MOTD.output(logo, serve_location, display, extra)
 
     @property
     def serve_location(self) -> str:
@@ -658,20 +588,24 @@ class StartupMixin(metaclass=SanicMeta):
         if not server_settings:
             return serve_location
 
-        host = server_settings["host"]
+        if server_settings["ssl"] is not None:
-        port = server_settings["port"]
-
-        if server_settings.get("ssl") is not None:
             proto = "https"
-        if server_settings.get("unix"):
+        if server_settings["unix"]:
             serve_location = f'{server_settings["unix"]} {proto}://...'
-        elif server_settings.get("sock"):
+        elif server_settings["sock"]:
-            host, port, *_ = server_settings["sock"].getsockname()
+            serve_location = (
-
+                f'{server_settings["sock"].getsockname()} {proto}://...'
-        if not serve_location and host and port:
+            )
+        elif server_settings["host"] and server_settings["port"]:
             # colon(:) is legal for a host only in an ipv6 address
-            display_host = f"[{host}]" if ":" in host else host
+            display_host = (
-            serve_location = f"{proto}://{display_host}:{port}"
+                f'[{server_settings["host"]}]'
+                if ":" in server_settings["host"]
+                else server_settings["host"]
+            )
+            serve_location = (
+                f'{proto}://{display_host}:{server_settings["port"]}'
+            )
 
         return serve_location
 
@@ -691,254 +625,7 @@ class StartupMixin(metaclass=SanicMeta):
         return any(app.state.auto_reload for app in cls._app_registry.values())
 
     @classmethod
-    def _get_context(cls) -> BaseContext:
+    def serve(cls, primary: Optional[Sanic] = None) -> None:
-        method = (
-            "spawn"
-            if "linux" not in sys.platform or cls.should_auto_reload()
-            else "fork"
-        )
-        return get_context(method)
-
-    @classmethod
-    def serve(
-        cls,
-        primary: Optional[Sanic] = None,
-        *,
-        app_loader: Optional[AppLoader] = None,
-        factory: Optional[Callable[[], Sanic]] = None,
-    ) -> None:
-        os.environ["SANIC_MOTD_OUTPUT"] = "true"
-        apps = list(cls._app_registry.values())
-        if factory:
-            primary = factory()
-        else:
-            if not primary:
-                if app_loader:
-                    primary = app_loader.load()
-                if not primary:
-                    try:
-                        primary = apps[0]
-                    except IndexError:
-                        raise RuntimeError(
-                            "Did not find any applications."
-                        ) from None
-
-            # This exists primarily for unit testing
-            if not primary.state.server_info:  # no cov
-                for app in apps:
-                    app.state.server_info.clear()
-                return
-
-        try:
-            primary_server_info = primary.state.server_info[0]
-        except IndexError:
-            raise RuntimeError(
-                f"No server information found for {primary.name}. Perhaps you "
-                "need to run app.prepare(...)?"
-            ) from None
-
-        socks = []
-        sync_manager = Manager()
-        setup_ext(primary)
-        try:
-            primary_server_info.settings.pop("main_start", None)
-            primary_server_info.settings.pop("main_stop", None)
-            main_start = primary.listeners.get("main_process_start")
-            main_stop = primary.listeners.get("main_process_stop")
-            app = primary_server_info.settings.pop("app")
-            app.setup_loop()
-            loop = new_event_loop()
-            trigger_events(main_start, loop, primary)
-
-            socks = [
-                sock
-                for sock in [
-                    configure_socket(server_info.settings)
-                    for app in apps
-                    for server_info in app.state.server_info
-                ]
-                if sock
-            ]
-            primary_server_info.settings["run_multiple"] = True
-            monitor_sub, monitor_pub = Pipe(True)
-            worker_state: Dict[str, Any] = sync_manager.dict()
-            kwargs: Dict[str, Any] = {
-                **primary_server_info.settings,
-                "monitor_publisher": monitor_pub,
-                "worker_state": worker_state,
-            }
-
-            if not app_loader:
-                if factory:
-                    app_loader = AppLoader(factory=factory)
-                else:
-                    app_loader = AppLoader(
-                        factory=partial(cls.get_app, app.name)  # type: ignore
-                    )
-            kwargs["app_name"] = app.name
-            kwargs["app_loader"] = app_loader
-            kwargs["server_info"] = {}
-            kwargs["passthru"] = {
-                "auto_reload": app.auto_reload,
-                "state": {
-                    "verbosity": app.state.verbosity,
-                    "mode": app.state.mode,
-                },
-                "config": {
-                    "ACCESS_LOG": app.config.ACCESS_LOG,
-                    "NOISY_EXCEPTIONS": app.config.NOISY_EXCEPTIONS,
-                },
-                "shared_ctx": app.shared_ctx.__dict__,
-            }
-            for app in apps:
-                kwargs["server_info"][app.name] = []
-                for server_info in app.state.server_info:
-                    server_info.settings = {
-                        k: v
-                        for k, v in server_info.settings.items()
-                        if k not in ("main_start", "main_stop", "app", "ssl")
-                    }
-                    kwargs["server_info"][app.name].append(server_info)
-
-            ssl = kwargs.get("ssl")
-
-            if isinstance(ssl, SanicSSLContext):
-                kwargs["ssl"] = kwargs["ssl"].sanic
-
-            manager = WorkerManager(
-                primary.state.workers,
-                worker_serve,
-                kwargs,
-                cls._get_context(),
-                (monitor_pub, monitor_sub),
-                worker_state,
-            )
-            if cls.should_auto_reload():
-                reload_dirs: Set[Path] = primary.state.reload_dirs.union(
-                    *(app.state.reload_dirs for app in apps)
-                )
-                reloader = Reloader(monitor_pub, 1.0, reload_dirs, app_loader)
-                manager.manage("Reloader", reloader, {}, transient=False)
-
-            inspector = None
-            if primary.config.INSPECTOR:
-                display, extra = primary.get_motd_data()
-                packages = [
-                    pkg.strip() for pkg in display["packages"].split(",")
-                ]
-                module = import_module("sanic")
-                sanic_version = f"sanic=={module.__version__}"  # type: ignore
-                app_info = {
-                    **display,
-                    "packages": [sanic_version, *packages],
-                    "extra": extra,
-                }
-                inspector = Inspector(
-                    monitor_pub,
-                    app_info,
-                    worker_state,
-                    primary.config.INSPECTOR_HOST,
-                    primary.config.INSPECTOR_PORT,
-                )
-                manager.manage("Inspector", inspector, {}, transient=False)
-
-            primary._inspector = inspector
-            primary._manager = manager
-
-            ready = primary.listeners["main_process_ready"]
-            trigger_events(ready, loop, primary)
-
-            manager.run()
-        except BaseException:
-            kwargs = primary_server_info.settings
-            error_logger.exception(
-                "Experienced exception while trying to serve"
-            )
-            raise
-        finally:
-            logger.info("Server Stopped")
-            for app in apps:
-                app.state.server_info.clear()
-                app.router.reset()
-                app.signal_router.reset()
-
-            sync_manager.shutdown()
-            for sock in socks:
-                sock.close()
-            socks = []
-            trigger_events(main_stop, loop, primary)
-            loop.close()
-            cls._cleanup_env_vars()
-            cls._cleanup_apps()
-            unix = kwargs.get("unix")
-            if unix:
-                remove_unix_socket(unix)
-
-    @classmethod
-    def serve_single(cls, primary: Optional[Sanic] = None) -> None:
-        os.environ["SANIC_MOTD_OUTPUT"] = "true"
-        apps = list(cls._app_registry.values())
-
-        if not primary:
-            try:
-                primary = apps[0]
-            except IndexError:
-                raise RuntimeError("Did not find any applications.")
-
-        # This exists primarily for unit testing
-        if not primary.state.server_info:  # no cov
-            for app in apps:
-                app.state.server_info.clear()
-            return
-
-        primary_server_info = primary.state.server_info[0]
-        primary.before_server_start(partial(primary._start_servers, apps=apps))
-        kwargs = {
-            k: v
-            for k, v in primary_server_info.settings.items()
-            if k
-            not in (
-                "main_start",
-                "main_stop",
-                "app",
-            )
-        }
-        kwargs["app_name"] = primary.name
-        kwargs["app_loader"] = None
-        sock = configure_socket(kwargs)
-
-        kwargs["server_info"] = {}
-        kwargs["server_info"][primary.name] = []
-        for server_info in primary.state.server_info:
-            server_info.settings = {
-                k: v
-                for k, v in server_info.settings.items()
-                if k not in ("main_start", "main_stop", "app")
-            }
-            kwargs["server_info"][primary.name].append(server_info)
-
-        try:
-            worker_serve(monitor_publisher=None, **kwargs)
-        except BaseException:
-            error_logger.exception(
-                "Experienced exception while trying to serve"
-            )
-            raise
-        finally:
-            logger.info("Server Stopped")
-            for app in apps:
-                app.state.server_info.clear()
-                app.router.reset()
-                app.signal_router.reset()
-
-            if sock:
-                sock.close()
-
-            cls._cleanup_env_vars()
-            cls._cleanup_apps()
-
-    @classmethod
-    def serve_legacy(cls, primary: Optional[Sanic] = None) -> None:
         apps = list(cls._app_registry.values())
 
         if not primary:
@@ -959,7 +646,7 @@ class StartupMixin(metaclass=SanicMeta):
             reload_dirs: Set[Path] = primary.state.reload_dirs.union(
                 *(app.state.reload_dirs for app in apps)
             )
-            watchdog(1.0, reload_dirs)
+            reloader_helpers.watchdog(1.0, reload_dirs)
             trigger_events(reloader_stop, loop, primary)
             return
 
@@ -972,17 +659,11 @@ class StartupMixin(metaclass=SanicMeta):
         primary_server_info = primary.state.server_info[0]
         primary.before_server_start(partial(primary._start_servers, apps=apps))
 
-        deprecation(
-            f"{Colors.YELLOW}Running {Colors.SANIC}Sanic {Colors.YELLOW}w/ "
-            f"LEGACY manager.{Colors.END} Support for will be dropped in "
-            "version 23.3.",
-            23.3,
-        )
         try:
             primary_server_info.stage = ServerStage.SERVING
 
             if primary.state.workers > 1 and os.name != "posix":  # no cov
-                logger.warning(
+                logger.warn(
                     f"Multiprocessing is currently not supported on {os.name},"
                     " using workers=1 instead"
                 )
@@ -1003,9 +684,10 @@ class StartupMixin(metaclass=SanicMeta):
         finally:
             primary_server_info.stage = ServerStage.STOPPED
         logger.info("Server Stopped")
-
+        for app in apps:
-        cls._cleanup_env_vars()
+            app.state.server_info.clear()
-        cls._cleanup_apps()
+            app.router.reset()
+            app.signal_router.reset()
 
     async def _start_servers(
         self,
@@ -1043,7 +725,7 @@ class StartupMixin(metaclass=SanicMeta):
                         *server_info.settings.pop("main_start", []),
                         *server_info.settings.pop("main_stop", []),
                     ]
-                    if handlers:  # no cov
+                    if handlers:
                         error_logger.warning(
                             f"Sanic found {len(handlers)} listener(s) on "
                             "secondary applications attached to the main "
@@ -1056,15 +738,12 @@ class StartupMixin(metaclass=SanicMeta):
                     if not server_info.settings["loop"]:
                         server_info.settings["loop"] = get_running_loop()
 
-                    serve_args: Dict[str, Any] = {
-                        **server_info.settings,
-                        "run_async": True,
-                        "reuse_port": bool(primary.state.workers - 1),
-                    }
-                    if "app" not in serve_args:
-                        serve_args["app"] = app
                     try:
-                        server_info.server = await serve(**serve_args)
+                        server_info.server = await serve(
+                            **server_info.settings,
+                            run_async=True,
+                            reuse_port=bool(primary.state.workers - 1),
+                        )
                     except OSError as e:  # no cov
                         first_message = (
                             "An OSError was detected on startup. "
@@ -1090,9 +769,9 @@ class StartupMixin(metaclass=SanicMeta):
 
     async def _run_server(
         self,
-        app: StartupMixin,
+        app: RunnerMixin,
         server_info: ApplicationServerInfo,
-    ) -> None:  # no cov
+    ) -> None:
 
         try:
             # We should never get to this point without a server
@@ -1116,26 +795,3 @@ class StartupMixin(metaclass=SanicMeta):
         finally:
             server_info.stage = ServerStage.STOPPED
             server_info.server = None
-
-    @staticmethod
-    def _cleanup_env_vars():
-        variables = (
-            "SANIC_RELOADER_PROCESS",
-            "SANIC_IGNORE_PRODUCTION_WARNING",
-            "SANIC_WORKER_NAME",
-            "SANIC_MOTD_OUTPUT",
-            "SANIC_WORKER_PROCESS",
-            "SANIC_SERVER_RUNNING",
-        )
-        for var in variables:
-            try:
-                del os.environ[var]
-            except KeyError:
-                ...
-
-    @classmethod
-    def _cleanup_apps(cls):
-        for app in cls._app_registry.values():
-            app.state.server_info.clear()
-            app.router.reset()
-            app.signal_router.reset()

sanic/models/server_types.py

@@ -21,7 +21,6 @@ class ConnInfo:
         "client",
         "client_ip",
         "ctx",
-        "lost",
         "peername",
         "server_port",
         "server",
@@ -34,7 +33,6 @@ class ConnInfo:
 
     def __init__(self, transport: TransportProtocol, unix=None):
         self.ctx = SimpleNamespace()
-        self.lost = False
         self.peername = None
         self.server = self.client = ""
         self.server_port = self.client_port = 0

sanic/reloader_helpers.py

@@ -9,6 +9,7 @@ from time import sleep
 
 def _iter_module_files():
     """This iterates over all relevant Python files.
+
     It goes through all
     loaded files from modules, all files in folders of already loaded modules
     as well as all files reachable through a package.
@@ -51,7 +52,7 @@ def restart_with_reloader(changed=None):
     this one.
     """
     reloaded = ",".join(changed) if changed else ""
-    return subprocess.Popen(  # nosec B603
+    return subprocess.Popen(
         _get_args_for_reloading(),
         env={
             **os.environ,
@@ -78,6 +79,7 @@ def _check_file(filename, mtimes):
 
 def watchdog(sleep_interval, reload_dirs):
     """Watch project files, restart worker process if a change happened.
+
     :param sleep_interval: interval in second.
     :return: Nothing
     """

sanic/request.py

@@ -38,12 +38,7 @@ from httptools import parse_url
 from httptools.parser.errors import HttpParserInvalidURLError
 
 from sanic.compat import CancelledErrors, Header
-from sanic.constants import (
+from sanic.constants import DEFAULT_HTTP_CONTENT_TYPE
-    CACHEABLE_HTTP_METHODS,
-    DEFAULT_HTTP_CONTENT_TYPE,
-    IDEMPOTENT_HTTP_METHODS,
-    SAFE_HTTP_METHODS,
-)
 from sanic.exceptions import BadRequest, BadURL, ServerError
 from sanic.headers import (
     AcceptContainer,
@@ -56,7 +51,7 @@ from sanic.headers import (
     parse_xforwarded,
 )
 from sanic.http import Stage
-from sanic.log import deprecation, error_logger, logger
+from sanic.log import error_logger, logger
 from sanic.models.protocol_types import TransportProtocol
 from sanic.response import BaseHTTPResponse, HTTPResponse
 
@@ -103,7 +98,6 @@ class Request:
         "_port",
         "_protocol",
         "_remote_addr",
-        "_request_middleware_started",
         "_scheme",
         "_socket",
         "_stream_id",
@@ -127,6 +121,7 @@ class Request:
         "parsed_token",
         "raw_url",
         "responded",
+        "request_middleware_started",
         "route",
         "stream",
         "transport",
@@ -178,7 +173,7 @@ class Request:
         self.parsed_not_grouped_args: DefaultDict[
             Tuple[bool, bool, str, str], List[Tuple[str, str]]
         ] = defaultdict(list)
-        self._request_middleware_started = False
+        self.request_middleware_started = False
         self.responded: bool = False
         self.route: Optional[Route] = None
         self.stream: Optional[Stream] = None
@@ -193,7 +188,7 @@ class Request:
     @classmethod
     def get_current(cls) -> Request:
         """
-        Retrieve the current request object
+        Retrieve the currrent request object
 
         This implements `Context Variables
         <https://docs.python.org/3/library/contextvars.html>`_
@@ -219,16 +214,6 @@ class Request:
     def generate_id(*_):
         return uuid.uuid4()
 
-    @property
-    def request_middleware_started(self):
-        deprecation(
-            "Request.request_middleware_started has been deprecated and will"
-            "be removed. You should set a flag on the request context using"
-            "either middleware or signals if you need this feature.",
-            23.3,
-        )
-        return self._request_middleware_started
-
     @property
     def stream_id(self):
         """
@@ -334,13 +319,9 @@ class Request:
                 response = await response  # type: ignore
         # Run response middleware
         try:
-            middleware = (
+            response = await self.app._run_response_middleware(
-                self.route and self.route.extra.response_middleware
+                self, response, request_name=self.name
-            ) or self.app.response_middleware
+            )
-            if middleware:
-                response = await self.app._run_response_middleware(
-                    self, response, middleware
-                )
         except CancelledErrors:
             raise
         except Exception:
@@ -994,33 +975,6 @@ class Request:
 
         return self.transport.scope
 
-    @property
-    def is_safe(self) -> bool:
-        """
-        :return: Whether the HTTP method is safe.
-            See https://datatracker.ietf.org/doc/html/rfc7231#section-4.2.1
-        :rtype: bool
-        """
-        return self.method in SAFE_HTTP_METHODS
-
-    @property
-    def is_idempotent(self) -> bool:
-        """
-        :return: Whether the HTTP method is iempotent.
-            See https://datatracker.ietf.org/doc/html/rfc7231#section-4.2.2
-        :rtype: bool
-        """
-        return self.method in IDEMPOTENT_HTTP_METHODS
-
-    @property
-    def is_cacheable(self) -> bool:
-        """
-        :return: Whether the HTTP method is cacheable.
-            See https://datatracker.ietf.org/doc/html/rfc7231#section-4.2.3
-        :rtype: bool
-        """
-        return self.method in CACHEABLE_HTTP_METHODS
-
 
 class File(NamedTuple):
     """

sanic/response.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
-from datetime import datetime, timezone
+from datetime import datetime
-from email.utils import formatdate, parsedate_to_datetime
+from email.utils import formatdate
 from functools import partial
 from mimetypes import guess_type
 from os import path
@@ -33,7 +33,6 @@ from sanic.helpers import (
     remove_entity_headers,
 )
 from sanic.http import Http
-from sanic.log import logger
 from sanic.models.protocol_types import HTMLProtocol, Range
 
 
@@ -211,7 +210,7 @@ class HTTPResponse(BaseHTTPResponse):
 
 
 def empty(
-    status: int = 204, headers: Optional[Dict[str, str]] = None
+    status=204, headers: Optional[Dict[str, str]] = None
 ) -> HTTPResponse:
     """
     Returns an empty response to the client.
@@ -228,7 +227,7 @@ def json(
     headers: Optional[Dict[str, str]] = None,
     content_type: str = "application/json",
     dumps: Optional[Callable[..., str]] = None,
-    **kwargs: Any,
+    **kwargs,
 ) -> HTTPResponse:
     """
     Returns response object with body in json format.
@@ -320,34 +319,9 @@ def html(
     )
 
 
-async def validate_file(
-    request_headers: Header, last_modified: Union[datetime, float, int]
-):
-    try:
-        if_modified_since = request_headers.getone("If-Modified-Since")
-    except KeyError:
-        return
-    try:
-        if_modified_since = parsedate_to_datetime(if_modified_since)
-    except (TypeError, ValueError):
-        logger.warning(
-            "Ignorning invalid If-Modified-Since header received: " "'%s'",
-            if_modified_since,
-        )
-        return
-    if not isinstance(last_modified, datetime):
-        last_modified = datetime.fromtimestamp(
-            float(last_modified), tz=timezone.utc
-        ).replace(microsecond=0)
-    if last_modified <= if_modified_since:
-        return HTTPResponse(status=304)
-
-
 async def file(
     location: Union[str, PurePath],
     status: int = 200,
-    request_headers: Optional[Header] = None,
-    validate_when_requested: bool = True,
     mime_type: Optional[str] = None,
     headers: Optional[Dict[str, str]] = None,
     filename: Optional[str] = None,
@@ -357,12 +331,7 @@ async def file(
     _range: Optional[Range] = None,
 ) -> HTTPResponse:
     """Return a response object with file data.
-    :param status: HTTP response code. Won't enforce the passed in
+
-        status if only a part of the content will be sent (206)
-        or file is being validated (304).
-    :param request_headers: The request headers.
-    :param validate_when_requested: If True, will validate the
-        file when requested.
     :param location: Location of file on system.
     :param mime_type: Specific mime_type.
     :param headers: Custom Headers.
@@ -372,6 +341,11 @@ async def file(
     :param no_store: Any cache should not store this response.
     :param _range:
     """
+    headers = headers or {}
+    if filename:
+        headers.setdefault(
+            "Content-Disposition", f'attachment; filename="{filename}"'
+        )
 
     if isinstance(last_modified, datetime):
         last_modified = last_modified.replace(microsecond=0).timestamp()
@@ -379,24 +353,9 @@ async def file(
         stat = await stat_async(location)
         last_modified = stat.st_mtime
 
-    if (
-        validate_when_requested
-        and request_headers is not None
-        and last_modified
-    ):
-        response = await validate_file(request_headers, last_modified)
-        if response:
-            return response
-
-    headers = headers or {}
     if last_modified:
         headers.setdefault(
-            "Last-Modified", formatdate(last_modified, usegmt=True)
+            "last-modified", formatdate(last_modified, usegmt=True)
-        )
-
-    if filename:
-        headers.setdefault(
-            "Content-Disposition", f'attachment; filename="{filename}"'
         )
 
     if no_store:

sanic/router.py

@@ -133,14 +133,14 @@ class Router(BaseRouter):
                 params.update({"requirements": {"host": host}})
 
             route = super().add(**params)  # type: ignore
-            route.extra.ignore_body = ignore_body
+            route.ctx.ignore_body = ignore_body
-            route.extra.stream = stream
+            route.ctx.stream = stream
-            route.extra.hosts = hosts
+            route.ctx.hosts = hosts
-            route.extra.static = static
+            route.ctx.static = static
-            route.extra.error_format = error_format
+            route.ctx.error_format = error_format
 
             if error_format:
-                check_error_format(route.extra.error_format)
+                check_error_format(route.ctx.error_format)
 
             routes.append(route)
 

sanic/server/loop.py

@@ -1,5 +1,4 @@
 import asyncio
-import sys
 
 from distutils.util import strtobool
 from os import getenv
@@ -48,19 +47,3 @@ def try_use_uvloop() -> None:
 
     if not isinstance(asyncio.get_event_loop_policy(), uvloop.EventLoopPolicy):
         asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
-
-
-def try_windows_loop():
-    if not OS_IS_WINDOWS:
-        error_logger.warning(
-            "You are trying to use an event loop policy that is not "
-            "compatible with your system. You can simply let Sanic handle "
-            "selecting the best loop for you. Sanic will now continue to run "
-            "using the default event loop."
-        )
-        return
-
-    if sys.version_info >= (3, 8) and not isinstance(
-        asyncio.get_event_loop_policy(), asyncio.WindowsSelectorEventLoopPolicy
-    ):
-        asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())

sanic/server/protocols/base_protocol.py

@@ -2,14 +2,13 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Optional
 
-from sanic.exceptions import RequestCancelled
-
 
 if TYPE_CHECKING:
     from sanic.app import Sanic
 
 import asyncio
 
+from asyncio import CancelledError
 from asyncio.transports import Transport
 from time import monotonic as current_time
 
@@ -70,7 +69,7 @@ class SanicProtocol(asyncio.Protocol):
         """
         await self._can_write.wait()
         if self.transport.is_closing():
-            raise RequestCancelled
+            raise CancelledError
         self.transport.write(data)
         self._time = current_time()
 
@@ -121,7 +120,6 @@ class SanicProtocol(asyncio.Protocol):
         try:
             self.connections.discard(self)
             self.resume_writing()
-            self.conn_info.lost = True
             if self._task:
                 self._task.cancel()
         except BaseException:

sanic/server/protocols/http_protocol.py

@@ -15,11 +15,7 @@ import sys
 from asyncio import CancelledError
 from time import monotonic as current_time
 
-from sanic.exceptions import (
+from sanic.exceptions import RequestTimeout, ServiceUnavailable
-    RequestCancelled,
-    RequestTimeout,
-    ServiceUnavailable,
-)
 from sanic.http import Http, Stage
 from sanic.log import Colors, error_logger, logger
 from sanic.models.server_types import ConnInfo
@@ -229,7 +225,7 @@ class HttpProtocol(HttpProtocolMixin, SanicProtocol, metaclass=TouchUpMeta):
         """
         await self._can_write.wait()
         if self.transport.is_closing():
-            raise RequestCancelled
+            raise CancelledError
         await self.app.dispatch(
             "http.lifecycle.send",
             inline=True,
@@ -269,6 +265,7 @@ class HttpProtocol(HttpProtocolMixin, SanicProtocol, metaclass=TouchUpMeta):
             error_logger.exception("protocol.connect_made")
 
     def data_received(self, data: bytes):
+
         try:
             self._time = current_time()
             if not data:

sanic/server/runners.py

@@ -27,7 +27,7 @@ from signal import signal as signal_func
 from sanic.application.ext import setup_ext
 from sanic.compat import OS_IS_WINDOWS, ctrlc_workaround_for_windows
 from sanic.http.http3 import SessionTicketStore, get_config
-from sanic.log import error_logger, server_logger
+from sanic.log import error_logger, logger
 from sanic.models.server_types import Signal
 from sanic.server.async_server import AsyncioServer
 from sanic.server.protocols.http_protocol import Http3Protocol, HttpProtocol
@@ -129,7 +129,7 @@ def _setup_system_signals(
     run_multiple: bool,
     register_sys_signals: bool,
     loop: asyncio.AbstractEventLoop,
-) -> None:  # no cov
+) -> None:
     # Ignore SIGINT when run_multiple
     if run_multiple:
         signal_func(SIGINT, SIG_IGN)
@@ -141,20 +141,18 @@ def _setup_system_signals(
             ctrlc_workaround_for_windows(app)
         else:
             for _signal in [SIGTERM] if run_multiple else [SIGINT, SIGTERM]:
-                loop.add_signal_handler(
+                loop.add_signal_handler(_signal, app.stop)
-                    _signal, partial(app.stop, terminate=False)
-                )
 
 
 def _run_server_forever(loop, before_stop, after_stop, cleanup, unix):
     pid = os.getpid()
     try:
-        server_logger.info("Starting worker [%s]", pid)
+        logger.info("Starting worker [%s]", pid)
         loop.run_forever()
     except KeyboardInterrupt:
         pass
     finally:
-        server_logger.info("Stopping worker [%s]", pid)
+        logger.info("Stopping worker [%s]", pid)
 
         loop.run_until_complete(before_stop())
 
@@ -163,7 +161,6 @@ def _run_server_forever(loop, before_stop, after_stop, cleanup, unix):
 
         loop.run_until_complete(after_stop())
         remove_unix_socket(unix)
-        loop.close()
 
 
 def _serve_http_1(
@@ -200,12 +197,8 @@ def _serve_http_1(
     asyncio_server_kwargs = (
         asyncio_server_kwargs if asyncio_server_kwargs else {}
     )
-    if OS_IS_WINDOWS:
-        pid = os.getpid()
-        sock = sock.share(pid)
-        sock = socket.fromshare(sock)
     # UNIX sockets are always bound by us (to preserve semantics between modes)
-    elif unix:
+    if unix:
         sock = bind_unix_socket(unix, backlog=backlog)
     server_coroutine = loop.create_server(
         server,
@@ -372,9 +365,7 @@ def serve_multiple(server_settings, workers):
     processes = []
 
     def sig_handler(signal, frame):
-        server_logger.info(
+        logger.info("Received signal %s. Shutting down.", Signals(signal).name)
-            "Received signal %s. Shutting down.", Signals(signal).name
-        )
         for process in processes:
             os.kill(process.pid, SIGTERM)
 

sanic/server/socket.py

@@ -6,10 +6,7 @@ import socket
 import stat
 
 from ipaddress import ip_address
-from typing import Any, Dict, Optional
+from typing import Optional
-
-from sanic.exceptions import ServerError
-from sanic.http.constants import HTTP
 
 
 def bind_socket(host: str, port: int, *, backlog=100) -> socket.socket:
@@ -19,8 +16,6 @@ def bind_socket(host: str, port: int, *, backlog=100) -> socket.socket:
     :param backlog: Maximum number of connections to queue
     :return: socket.socket object
     """
-    location = (host, port)
-    # socket.share, socket.fromshare
     try:  # IP address: family must be specified for IPv6 at least
         ip = ip_address(host)
         host = str(ip)
@@ -30,9 +25,8 @@ def bind_socket(host: str, port: int, *, backlog=100) -> socket.socket:
     except ValueError:  # Hostname, may become AF_INET or AF_INET6
         sock = socket.socket()
     sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
-    sock.bind(location)
+    sock.bind((host, port))
     sock.listen(backlog)
-    sock.set_inheritable(True)
     return sock
 
 
@@ -42,7 +36,7 @@ def bind_unix_socket(path: str, *, mode=0o666, backlog=100) -> socket.socket:
     :param backlog: Maximum number of connections to queue
     :return: socket.socket object
     """
-
+    """Open or atomically replace existing socket with zero downtime."""
     # Sanitise and pre-verify socket path
     path = os.path.abspath(path)
     folder = os.path.dirname(path)
@@ -91,40 +85,3 @@ def remove_unix_socket(path: Optional[str]) -> None:
                     os.unlink(path)
     except FileNotFoundError:
         pass
-
-
-def configure_socket(
-    server_settings: Dict[str, Any]
-) -> Optional[socket.SocketType]:
-    # Create a listening socket or use the one in settings
-    if server_settings.get("version") is HTTP.VERSION_3:
-        return None
-    sock = server_settings.get("sock")
-    unix = server_settings["unix"]
-    backlog = server_settings["backlog"]
-    if unix:
-        sock = bind_unix_socket(unix, backlog=backlog)
-        server_settings["unix"] = unix
-    if sock is None:
-        try:
-            sock = bind_socket(
-                server_settings["host"],
-                server_settings["port"],
-                backlog=backlog,
-            )
-        except OSError as e:  # no cov
-            error = ServerError(
-                f"Sanic server could not start: {e}.\n\n"
-                "This may have happened if you are running Sanic in the "
-                "global scope and not inside of a "
-                '`if __name__ == "__main__"` block.\n\nSee more information: '
-                "https://sanic.dev/en/guide/deployment/manager.html#"
-                "how-sanic-server-starts-processes\n"
-            )
-            error.quiet = True
-            raise error
-        sock.set_inheritable(True)
-        server_settings["sock"] = sock
-        server_settings["host"] = None
-        server_settings["port"] = None
-    return sock

sanic/server/websockets/impl.py

@@ -13,11 +13,7 @@ from typing import (
 )
 
 from websockets.connection import CLOSED, CLOSING, OPEN, Event
-from websockets.exceptions import (
+from websockets.exceptions import ConnectionClosed, ConnectionClosedError
-    ConnectionClosed,
-    ConnectionClosedError,
-    ConnectionClosedOK,
-)
 from websockets.frames import Frame, Opcode
 from websockets.server import ServerConnection
 from websockets.typing import Data
@@ -256,7 +252,7 @@ class WebsocketImplProtocol:
 
     def _force_disconnect(self) -> bool:
         """
-        Internal method used by end_connection and fail_connection
+        Internal methdod used by end_connection and fail_connection
         only when the graceful auto-closer cannot be used
         """
         if self.auto_closer_task and not self.auto_closer_task.done():
@@ -844,10 +840,3 @@ class WebsocketImplProtocol:
         self.abort_pings()
         if self.connection_lost_waiter:
             self.connection_lost_waiter.set_result(None)
-
-    async def __aiter__(self):
-        try:
-            while True:
-                yield await self.recv()
-        except ConnectionClosedOK:
-            return

sanic/signals.py

@@ -30,8 +30,6 @@ class Event(Enum):
     HTTP_LIFECYCLE_RESPONSE = "http.lifecycle.response"
     HTTP_ROUTING_AFTER = "http.routing.after"
     HTTP_ROUTING_BEFORE = "http.routing.before"
-    HTTP_HANDLER_AFTER = "http.handler.after"
-    HTTP_HANDLER_BEFORE = "http.handler.before"
     HTTP_LIFECYCLE_SEND = "http.lifecycle.send"
     HTTP_MIDDLEWARE_AFTER = "http.middleware.after"
     HTTP_MIDDLEWARE_BEFORE = "http.middleware.before"
@@ -55,8 +53,6 @@ RESERVED_NAMESPACES = {
         Event.HTTP_LIFECYCLE_RESPONSE.value,
         Event.HTTP_ROUTING_AFTER.value,
         Event.HTTP_ROUTING_BEFORE.value,
-        Event.HTTP_HANDLER_AFTER.value,
-        Event.HTTP_HANDLER_BEFORE.value,
         Event.HTTP_LIFECYCLE_SEND.value,
         Event.HTTP_MIDDLEWARE_AFTER.value,
         Event.HTTP_MIDDLEWARE_BEFORE.value,
@@ -154,13 +150,13 @@ class SignalRouter(BaseRouter):
         try:
             for signal in signals:
                 params.pop("__trigger__", None)
-                requirements = getattr(
-                    signal.handler, "__requirements__", None
-                )
                 if (
                     (condition is None and signal.ctx.exclusive is False)
-                    or (condition is None and not requirements)
+                    or (
-                    or (condition == requirements)
+                        condition is None
+                        and not signal.handler.__requirements__
+                    )
+                    or (condition == signal.handler.__requirements__)
                 ) and (signal.ctx.trigger or event == signal.ctx.definition):
                     maybe_coroutine = signal.handler(**params)
                     if isawaitable(maybe_coroutine):
@@ -191,7 +187,7 @@ class SignalRouter(BaseRouter):
             fail_not_found=fail_not_found and inline,
             reverse=reverse,
         )
-        logger.debug(f"Dispatching signal: {event}", extra={"verbosity": 1})
+        logger.debug(f"Dispatching signal: {event}")
 
         if inline:
             return await dispatch

sanic/types/shared_ctx.py

@@ -1,57 +0,0 @@
-import os
-
-from types import SimpleNamespace
-from typing import Any, Iterable
-
-from sanic.log import Colors, error_logger
-
-
-class SharedContext(SimpleNamespace):
-    SAFE = ("_lock",)
-
-    def __init__(self, **kwargs: Any) -> None:
-        super().__init__(**kwargs)
-        self._lock = False
-
-    def __setattr__(self, name: str, value: Any) -> None:
-        if self.is_locked:
-            raise RuntimeError(
-                f"Cannot set {name} on locked SharedContext object"
-            )
-        if not os.environ.get("SANIC_WORKER_NAME"):
-            to_check: Iterable[Any]
-            if not isinstance(value, (tuple, frozenset)):
-                to_check = [value]
-            else:
-                to_check = value
-            for item in to_check:
-                self._check(name, item)
-        super().__setattr__(name, value)
-
-    def _check(self, name: str, value: Any) -> None:
-        if name in self.SAFE:
-            return
-        try:
-            module = value.__module__
-        except AttributeError:
-            module = ""
-        if not any(
-            module.startswith(prefix)
-            for prefix in ("multiprocessing", "ctypes")
-        ):
-            error_logger.warning(
-                f"{Colors.YELLOW}Unsafe object {Colors.PURPLE}{name} "
-                f"{Colors.YELLOW}with type {Colors.PURPLE}{type(value)} "
-                f"{Colors.YELLOW}was added to shared_ctx. It may not "
-                "not function as intended. Consider using the regular "
-                f"ctx.\nFor more information, please see https://sanic.dev/en"
-                "/guide/deployment/manager.html#using-shared-context-between-"
-                f"worker-processes.{Colors.END}"
-            )
-
-    @property
-    def is_locked(self) -> bool:
-        return getattr(self, "_lock", False)
-
-    def lock(self) -> None:
-        self._lock = True

sanic/worker/inspector.py

@@ -1,142 +0,0 @@
-import sys
-
-from datetime import datetime
-from multiprocessing.connection import Connection
-from signal import SIGINT, SIGTERM
-from signal import signal as signal_func
-from socket import AF_INET, SOCK_STREAM, socket, timeout
-from textwrap import indent
-from typing import Any, Dict
-
-from sanic.application.logo import get_logo
-from sanic.application.motd import MOTDTTY
-from sanic.log import Colors, error_logger, logger
-from sanic.server.socket import configure_socket
-
-
-try:  # no cov
-    from ujson import dumps, loads
-except ModuleNotFoundError:  # no cov
-    from json import dumps, loads  # type: ignore
-
-
-class Inspector:
-    def __init__(
-        self,
-        publisher: Connection,
-        app_info: Dict[str, Any],
-        worker_state: Dict[str, Any],
-        host: str,
-        port: int,
-    ):
-        self._publisher = publisher
-        self.run = True
-        self.app_info = app_info
-        self.worker_state = worker_state
-        self.host = host
-        self.port = port
-
-    def __call__(self) -> None:
-        sock = configure_socket(
-            {"host": self.host, "port": self.port, "unix": None, "backlog": 1}
-        )
-        assert sock
-        signal_func(SIGINT, self.stop)
-        signal_func(SIGTERM, self.stop)
-
-        logger.info(f"Inspector started on: {sock.getsockname()}")
-        sock.settimeout(0.5)
-        try:
-            while self.run:
-                try:
-                    conn, _ = sock.accept()
-                except timeout:
-                    continue
-                else:
-                    action = conn.recv(64)
-                    if action == b"reload":
-                        conn.send(b"\n")
-                        self.reload()
-                    elif action == b"shutdown":
-                        conn.send(b"\n")
-                        self.shutdown()
-                    else:
-                        data = dumps(self.state_to_json())
-                        conn.send(data.encode())
-                        conn.close()
-        finally:
-            logger.debug("Inspector closing")
-            sock.close()
-
-    def stop(self, *_):
-        self.run = False
-
-    def state_to_json(self):
-        output = {"info": self.app_info}
-        output["workers"] = self.make_safe(dict(self.worker_state))
-        return output
-
-    def reload(self):
-        message = "__ALL_PROCESSES__:"
-        self._publisher.send(message)
-
-    def shutdown(self):
-        message = "__TERMINATE__"
-        self._publisher.send(message)
-
-    @staticmethod
-    def make_safe(obj: Dict[str, Any]) -> Dict[str, Any]:
-        for key, value in obj.items():
-            if isinstance(value, dict):
-                obj[key] = Inspector.make_safe(value)
-            elif isinstance(value, datetime):
-                obj[key] = value.isoformat()
-        return obj
-
-
-def inspect(host: str, port: int, action: str):
-    out = sys.stdout.write
-    with socket(AF_INET, SOCK_STREAM) as sock:
-        try:
-            sock.connect((host, port))
-        except ConnectionRefusedError:
-            error_logger.error(
-                f"{Colors.RED}Could not connect to inspector at: "
-                f"{Colors.YELLOW}{(host, port)}{Colors.END}\n"
-                "Either the application is not running, or it did not start "
-                "an inspector instance."
-            )
-            sock.close()
-            sys.exit(1)
-        sock.sendall(action.encode())
-        data = sock.recv(4096)
-    if action == "raw":
-        out(data.decode())
-    elif action == "pretty":
-        loaded = loads(data)
-        display = loaded.pop("info")
-        extra = display.pop("extra", {})
-        display["packages"] = ", ".join(display["packages"])
-        MOTDTTY(get_logo(), f"{host}:{port}", display, extra).display(
-            version=False,
-            action="Inspecting",
-            out=out,
-        )
-        for name, info in loaded["workers"].items():
-            info = "\n".join(
-                f"\t{key}: {Colors.BLUE}{value}{Colors.END}"
-                for key, value in info.items()
-            )
-            out(
-                "\n"
-                + indent(
-                    "\n".join(
-                        [
-                            f"{Colors.BOLD}{Colors.SANIC}{name}{Colors.END}",
-                            info,
-                        ]
-                    ),
-                    "  ",
-                )
-                + "\n"
-            )

sanic/worker/loader.py

@@ -1,127 +0,0 @@
-from __future__ import annotations
-
-import os
-import sys
-
-from importlib import import_module
-from pathlib import Path
-from typing import TYPE_CHECKING, Any, Callable, Dict, Optional, Union, cast
-
-from sanic.http.tls.context import process_to_context
-from sanic.http.tls.creators import MkcertCreator, TrustmeCreator
-
-
-if TYPE_CHECKING:
-    from sanic import Sanic as SanicApp
-
-
-class AppLoader:
-    def __init__(
-        self,
-        module_input: str = "",
-        as_factory: bool = False,
-        as_simple: bool = False,
-        args: Any = None,
-        factory: Optional[Callable[[], SanicApp]] = None,
-    ) -> None:
-        self.module_input = module_input
-        self.module_name = ""
-        self.app_name = ""
-        self.as_factory = as_factory
-        self.as_simple = as_simple
-        self.args = args
-        self.factory = factory
-        self.cwd = os.getcwd()
-
-        if module_input:
-            delimiter = ":" if ":" in module_input else "."
-            if module_input.count(delimiter):
-                module_name, app_name = module_input.rsplit(delimiter, 1)
-                self.module_name = module_name
-                self.app_name = app_name
-                if self.app_name.endswith("()"):
-                    self.as_factory = True
-                    self.app_name = self.app_name[:-2]
-
-    def load(self) -> SanicApp:
-        module_path = os.path.abspath(self.cwd)
-        if module_path not in sys.path:
-            sys.path.append(module_path)
-
-        if self.factory:
-            return self.factory()
-        else:
-            from sanic.app import Sanic
-            from sanic.simple import create_simple_server
-
-            if self.as_simple:
-                path = Path(self.module_input)
-                app = create_simple_server(path)
-            else:
-                if self.module_name == "" and os.path.isdir(self.module_input):
-                    raise ValueError(
-                        "App not found.\n"
-                        "   Please use --simple if you are passing a "
-                        "directory to sanic.\n"
-                        f"   eg. sanic {self.module_input} --simple"
-                    )
-
-                module = import_module(self.module_name)
-                app = getattr(module, self.app_name, None)
-                if self.as_factory:
-                    try:
-                        app = app(self.args)
-                    except TypeError:
-                        app = app()
-
-                app_type_name = type(app).__name__
-
-                if (
-                    not isinstance(app, Sanic)
-                    and self.args
-                    and hasattr(self.args, "module")
-                ):
-                    if callable(app):
-                        solution = f"sanic {self.args.module} --factory"
-                        raise ValueError(
-                            "Module is not a Sanic app, it is a "
-                            f"{app_type_name}\n"
-                            "  If this callable returns a "
-                            f"Sanic instance try: \n{solution}"
-                        )
-
-                    raise ValueError(
-                        f"Module is not a Sanic app, it is a {app_type_name}\n"
-                        f"  Perhaps you meant {self.args.module}:app?"
-                    )
-        return app
-
-
-class CertLoader:
-    _creators = {
-        "mkcert": MkcertCreator,
-        "trustme": TrustmeCreator,
-    }
-
-    def __init__(self, ssl_data: Dict[str, Union[str, os.PathLike]]):
-        self._ssl_data = ssl_data
-
-        creator_name = cast(str, ssl_data.get("creator"))
-
-        self._creator_class = self._creators.get(creator_name)
-        if not creator_name:
-            return
-
-        if not self._creator_class:
-            raise RuntimeError(f"Unknown certificate creator: {creator_name}")
-
-        self._key = ssl_data["key"]
-        self._cert = ssl_data["cert"]
-        self._localhost = cast(str, ssl_data["localhost"])
-
-    def load(self, app: SanicApp):
-        if not self._creator_class:
-            return process_to_context(self._ssl_data)
-
-        creator = self._creator_class(app, self._key, self._cert)
-        return creator.generate_cert(self._localhost)

sanic/worker/manager.py

@@ -1,181 +0,0 @@
-import os
-import sys
-
-from signal import SIGINT, SIGTERM, Signals
-from signal import signal as signal_func
-from time import sleep
-from typing import List, Optional
-
-from sanic.compat import OS_IS_WINDOWS
-from sanic.log import error_logger, logger
-from sanic.worker.process import ProcessState, Worker, WorkerProcess
-
-
-if not OS_IS_WINDOWS:
-    from signal import SIGKILL
-else:
-    SIGKILL = SIGINT
-
-
-class WorkerManager:
-    THRESHOLD = 50
-
-    def __init__(
-        self,
-        number: int,
-        serve,
-        server_settings,
-        context,
-        monitor_pubsub,
-        worker_state,
-    ):
-        self.num_server = number
-        self.context = context
-        self.transient: List[Worker] = []
-        self.durable: List[Worker] = []
-        self.monitor_publisher, self.monitor_subscriber = monitor_pubsub
-        self.worker_state = worker_state
-        self.worker_state["Sanic-Main"] = {"pid": self.pid}
-        self.terminated = False
-
-        if number == 0:
-            raise RuntimeError("Cannot serve with no workers")
-
-        for i in range(number):
-            self.manage(
-                f"{WorkerProcess.SERVER_LABEL}-{i}",
-                serve,
-                server_settings,
-                transient=True,
-            )
-
-        signal_func(SIGINT, self.shutdown_signal)
-        signal_func(SIGTERM, self.shutdown_signal)
-
-    def manage(self, ident, func, kwargs, transient=False):
-        container = self.transient if transient else self.durable
-        container.append(
-            Worker(ident, func, kwargs, self.context, self.worker_state)
-        )
-
-    def run(self):
-        self.start()
-        self.monitor()
-        self.join()
-        self.terminate()
-        # self.kill()
-
-    def start(self):
-        for process in self.processes:
-            process.start()
-
-    def join(self):
-        logger.debug("Joining processes", extra={"verbosity": 1})
-        joined = set()
-        for process in self.processes:
-            logger.debug(
-                f"Found {process.pid} - {process.state.name}",
-                extra={"verbosity": 1},
-            )
-            if process.state < ProcessState.JOINED:
-                logger.debug(f"Joining {process.pid}", extra={"verbosity": 1})
-                joined.add(process.pid)
-                process.join()
-        if joined:
-            self.join()
-
-    def terminate(self):
-        if not self.terminated:
-            for process in self.processes:
-                process.terminate()
-        self.terminated = True
-
-    def restart(self, process_names: Optional[List[str]] = None, **kwargs):
-        for process in self.transient_processes:
-            if not process_names or process.name in process_names:
-                process.restart(**kwargs)
-
-    def monitor(self):
-        self.wait_for_ack()
-        while True:
-            try:
-                if self.monitor_subscriber.poll(0.1):
-                    message = self.monitor_subscriber.recv()
-                    logger.debug(
-                        f"Monitor message: {message}", extra={"verbosity": 2}
-                    )
-                    if not message:
-                        break
-                    elif message == "__TERMINATE__":
-                        self.shutdown()
-                        break
-                    split_message = message.split(":", 1)
-                    processes = split_message[0]
-                    reloaded_files = (
-                        split_message[1] if len(split_message) > 1 else None
-                    )
-                    process_names = [
-                        name.strip() for name in processes.split(",")
-                    ]
-                    if "__ALL_PROCESSES__" in process_names:
-                        process_names = None
-                    self.restart(
-                        process_names=process_names,
-                        reloaded_files=reloaded_files,
-                    )
-            except InterruptedError:
-                if not OS_IS_WINDOWS:
-                    raise
-                break
-
-    def wait_for_ack(self):  # no cov
-        misses = 0
-        while not self._all_workers_ack():
-            sleep(0.1)
-            misses += 1
-            if misses > self.THRESHOLD:
-                error_logger.error("Not all workers are ack. Shutting down.")
-                self.kill()
-                sys.exit(1)
-
-    @property
-    def workers(self):
-        return self.transient + self.durable
-
-    @property
-    def processes(self):
-        for worker in self.workers:
-            for process in worker.processes:
-                yield process
-
-    @property
-    def transient_processes(self):
-        for worker in self.transient:
-            for process in worker.processes:
-                yield process
-
-    def kill(self):
-        for process in self.processes:
-            os.kill(process.pid, SIGKILL)
-
-    def shutdown_signal(self, signal, frame):
-        logger.info("Received signal %s. Shutting down.", Signals(signal).name)
-        self.monitor_publisher.send(None)
-        self.shutdown()
-
-    def shutdown(self):
-        for process in self.processes:
-            if process.is_alive():
-                process.terminate()
-
-    @property
-    def pid(self):
-        return os.getpid()
-
-    def _all_workers_ack(self):
-        acked = [
-            worker_state.get("state") == ProcessState.ACKED.name
-            for worker_state in self.worker_state.values()
-            if worker_state.get("server")
-        ]
-        return all(acked) and len(acked) == self.num_server

sanic/worker/multiplexer.py

@@ -1,48 +0,0 @@
-from multiprocessing.connection import Connection
-from os import environ, getpid
-from typing import Any, Dict
-
-from sanic.worker.process import ProcessState
-from sanic.worker.state import WorkerState
-
-
-class WorkerMultiplexer:
-    def __init__(
-        self,
-        monitor_publisher: Connection,
-        worker_state: Dict[str, Any],
-    ):
-        self._monitor_publisher = monitor_publisher
-        self._state = WorkerState(worker_state, self.name)
-
-    def ack(self):
-        self._state._state[self.name] = {
-            **self._state._state[self.name],
-            "state": ProcessState.ACKED.name,
-        }
-
-    def restart(self, name: str = ""):
-        if not name:
-            name = self.name
-        self._monitor_publisher.send(name)
-
-    reload = restart  # no cov
-
-    def terminate(self):
-        self._monitor_publisher.send("__TERMINATE__")
-
-    @property
-    def pid(self) -> int:
-        return getpid()
-
-    @property
-    def name(self) -> str:
-        return environ.get("SANIC_WORKER_NAME", "")
-
-    @property
-    def state(self):
-        return self._state
-
-    @property
-    def workers(self) -> Dict[str, Any]:
-        return self.state.full()

sanic/worker/process.py

@@ -1,161 +0,0 @@
-import os
-
-from datetime import datetime, timezone
-from enum import IntEnum, auto
-from multiprocessing.context import BaseContext
-from signal import SIGINT
-from typing import Any, Dict, Set
-
-from sanic.log import Colors, logger
-
-
-def get_now():
-    now = datetime.now(tz=timezone.utc)
-    return now
-
-
-class ProcessState(IntEnum):
-    IDLE = auto()
-    STARTED = auto()
-    ACKED = auto()
-    JOINED = auto()
-    TERMINATED = auto()
-
-
-class WorkerProcess:
-    SERVER_LABEL = "Server"
-
-    def __init__(self, factory, name, target, kwargs, worker_state):
-        self.state = ProcessState.IDLE
-        self.factory = factory
-        self.name = name
-        self.target = target
-        self.kwargs = kwargs
-        self.worker_state = worker_state
-        if self.name not in self.worker_state:
-            self.worker_state[self.name] = {
-                "server": self.SERVER_LABEL in self.name
-            }
-        self.spawn()
-
-    def set_state(self, state: ProcessState, force=False):
-        if not force and state < self.state:
-            raise Exception("...")
-        self.state = state
-        self.worker_state[self.name] = {
-            **self.worker_state[self.name],
-            "state": self.state.name,
-        }
-
-    def start(self):
-        os.environ["SANIC_WORKER_NAME"] = self.name
-        logger.debug(
-            f"{Colors.BLUE}Starting a process: {Colors.BOLD}"
-            f"{Colors.SANIC}%s{Colors.END}",
-            self.name,
-        )
-        self.set_state(ProcessState.STARTED)
-        self._process.start()
-        if not self.worker_state[self.name].get("starts"):
-            self.worker_state[self.name] = {
-                **self.worker_state[self.name],
-                "pid": self.pid,
-                "start_at": get_now(),
-                "starts": 1,
-            }
-        del os.environ["SANIC_WORKER_NAME"]
-
-    def join(self):
-        self.set_state(ProcessState.JOINED)
-        self._process.join()
-
-    def terminate(self):
-        if self.state is not ProcessState.TERMINATED:
-            logger.debug(
-                f"{Colors.BLUE}Terminating a process: "
-                f"{Colors.BOLD}{Colors.SANIC}"
-                f"%s {Colors.BLUE}[%s]{Colors.END}",
-                self.name,
-                self.pid,
-            )
-            self.set_state(ProcessState.TERMINATED, force=True)
-            try:
-                # self._process.terminate()
-                os.kill(self.pid, SIGINT)
-                del self.worker_state[self.name]
-            except (KeyError, AttributeError, ProcessLookupError):
-                ...
-
-    def restart(self, **kwargs):
-        logger.debug(
-            f"{Colors.BLUE}Restarting a process: {Colors.BOLD}{Colors.SANIC}"
-            f"%s {Colors.BLUE}[%s]{Colors.END}",
-            self.name,
-            self.pid,
-        )
-        self._process.terminate()
-        self.set_state(ProcessState.IDLE, force=True)
-        self.kwargs.update(
-            {"config": {k.upper(): v for k, v in kwargs.items()}}
-        )
-        try:
-            self.spawn()
-            self.start()
-        except AttributeError:
-            raise RuntimeError("Restart failed")
-
-        self.worker_state[self.name] = {
-            **self.worker_state[self.name],
-            "pid": self.pid,
-            "starts": self.worker_state[self.name]["starts"] + 1,
-            "restart_at": get_now(),
-        }
-
-    def is_alive(self):
-        try:
-            return self._process.is_alive()
-        except AssertionError:
-            return False
-
-    def spawn(self):
-        if self.state is not ProcessState.IDLE:
-            raise Exception("Cannot spawn a worker process until it is idle.")
-        self._process = self.factory(
-            name=self.name,
-            target=self.target,
-            kwargs=self.kwargs,
-            daemon=True,
-        )
-
-    @property
-    def pid(self):
-        return self._process.pid
-
-
-class Worker:
-    def __init__(
-        self,
-        ident: str,
-        serve,
-        server_settings,
-        context: BaseContext,
-        worker_state: Dict[str, Any],
-    ):
-        self.ident = ident
-        self.context = context
-        self.serve = serve
-        self.server_settings = server_settings
-        self.worker_state = worker_state
-        self.processes: Set[WorkerProcess] = set()
-        self.create_process()
-
-    def create_process(self) -> WorkerProcess:
-        process = WorkerProcess(
-            factory=self.context.Process,
-            name=f"Sanic-{self.ident}-{len(self.processes)}",
-            target=self.serve,
-            kwargs={**self.server_settings},
-            worker_state=self.worker_state,
-        )
-        self.processes.add(process)
-        return process

sanic/worker/reloader.py

@@ -1,121 +0,0 @@
-from __future__ import annotations
-
-import os
-import sys
-
-from asyncio import new_event_loop
-from itertools import chain
-from multiprocessing.connection import Connection
-from pathlib import Path
-from signal import SIGINT, SIGTERM
-from signal import signal as signal_func
-from time import sleep
-from typing import Dict, Set
-
-from sanic.server.events import trigger_events
-from sanic.worker.loader import AppLoader
-
-
-class Reloader:
-    def __init__(
-        self,
-        publisher: Connection,
-        interval: float,
-        reload_dirs: Set[Path],
-        app_loader: AppLoader,
-    ):
-        self._publisher = publisher
-        self.interval = interval
-        self.reload_dirs = reload_dirs
-        self.run = True
-        self.app_loader = app_loader
-
-    def __call__(self) -> None:
-        app = self.app_loader.load()
-        signal_func(SIGINT, self.stop)
-        signal_func(SIGTERM, self.stop)
-        mtimes: Dict[str, float] = {}
-
-        reloader_start = app.listeners.get("reload_process_start")
-        reloader_stop = app.listeners.get("reload_process_stop")
-        before_trigger = app.listeners.get("before_reload_trigger")
-        after_trigger = app.listeners.get("after_reload_trigger")
-        loop = new_event_loop()
-        if reloader_start:
-            trigger_events(reloader_start, loop, app)
-
-        while self.run:
-            changed = set()
-            for filename in self.files():
-                try:
-                    if self.check_file(filename, mtimes):
-                        path = (
-                            filename
-                            if isinstance(filename, str)
-                            else filename.resolve()
-                        )
-                        changed.add(str(path))
-                except OSError:
-                    continue
-            if changed:
-                if before_trigger:
-                    trigger_events(before_trigger, loop, app)
-                self.reload(",".join(changed) if changed else "unknown")
-                if after_trigger:
-                    trigger_events(after_trigger, loop, app)
-            sleep(self.interval)
-        else:
-            if reloader_stop:
-                trigger_events(reloader_stop, loop, app)
-
-    def stop(self, *_):
-        self.run = False
-
-    def reload(self, reloaded_files):
-        message = f"__ALL_PROCESSES__:{reloaded_files}"
-        self._publisher.send(message)
-
-    def files(self):
-        return chain(
-            self.python_files(),
-            *(d.glob("**/*") for d in self.reload_dirs),
-        )
-
-    def python_files(self):  # no cov
-        """This iterates over all relevant Python files.
-
-        It goes through all
-        loaded files from modules, all files in folders of already loaded
-        modules as well as all files reachable through a package.
-        """
-        # The list call is necessary on Python 3 in case the module
-        # dictionary modifies during iteration.
-        for module in list(sys.modules.values()):
-            if module is None:
-                continue
-            filename = getattr(module, "__file__", None)
-            if filename:
-                old = None
-                while not os.path.isfile(filename):
-                    old = filename
-                    filename = os.path.dirname(filename)
-                    if filename == old:
-                        break
-                else:
-                    if filename[-4:] in (".pyc", ".pyo"):
-                        filename = filename[:-1]
-                    yield filename
-
-    @staticmethod
-    def check_file(filename, mtimes) -> bool:
-        need_reload = False
-
-        mtime = os.stat(filename).st_mtime
-        old_time = mtimes.get(filename)
-        if old_time is None:
-            mtimes[filename] = mtime
-        elif mtime > old_time:
-            mtimes[filename] = mtime
-            need_reload = True
-
-        return need_reload

sanic/worker/serve.py

@@ -1,124 +0,0 @@
-import asyncio
-import os
-import socket
-
-from functools import partial
-from multiprocessing.connection import Connection
-from ssl import SSLContext
-from typing import Any, Dict, List, Optional, Type, Union
-
-from sanic.application.constants import ServerStage
-from sanic.application.state import ApplicationServerInfo
-from sanic.http.constants import HTTP
-from sanic.models.server_types import Signal
-from sanic.server.protocols.http_protocol import HttpProtocol
-from sanic.server.runners import _serve_http_1, _serve_http_3
-from sanic.worker.loader import AppLoader, CertLoader
-from sanic.worker.multiplexer import WorkerMultiplexer
-
-
-def worker_serve(
-    host,
-    port,
-    app_name: str,
-    monitor_publisher: Optional[Connection],
-    app_loader: AppLoader,
-    worker_state: Optional[Dict[str, Any]] = None,
-    server_info: Optional[Dict[str, List[ApplicationServerInfo]]] = None,
-    ssl: Optional[
-        Union[SSLContext, Dict[str, Union[str, os.PathLike]]]
-    ] = None,
-    sock: Optional[socket.socket] = None,
-    unix: Optional[str] = None,
-    reuse_port: bool = False,
-    loop=None,
-    protocol: Type[asyncio.Protocol] = HttpProtocol,
-    backlog: int = 100,
-    register_sys_signals: bool = True,
-    run_multiple: bool = False,
-    run_async: bool = False,
-    connections=None,
-    signal=Signal(),
-    state=None,
-    asyncio_server_kwargs=None,
-    version=HTTP.VERSION_1,
-    config=None,
-    passthru: Optional[Dict[str, Any]] = None,
-):
-    from sanic import Sanic
-
-    if app_loader:
-        app = app_loader.load()
-    else:
-        app = Sanic.get_app(app_name)
-
-    app.refresh(passthru)
-    app.setup_loop()
-
-    loop = asyncio.new_event_loop()
-    asyncio.set_event_loop(loop)
-
-    # Hydrate server info if needed
-    if server_info:
-        for app_name, server_info_objects in server_info.items():
-            a = Sanic.get_app(app_name)
-            if not a.state.server_info:
-                a.state.server_info = []
-                for info in server_info_objects:
-                    if not info.settings.get("app"):
-                        info.settings["app"] = a
-                    a.state.server_info.append(info)
-
-    if isinstance(ssl, dict):
-        cert_loader = CertLoader(ssl)
-        ssl = cert_loader.load(app)
-        for info in app.state.server_info:
-            info.settings["ssl"] = ssl
-
-    # When in a worker process, do some init
-    if os.environ.get("SANIC_WORKER_NAME"):
-        # Hydrate apps with any passed server info
-
-        if monitor_publisher is None:
-            raise RuntimeError("No restart publisher found in worker process")
-        if worker_state is None:
-            raise RuntimeError("No worker state found in worker process")
-
-        # Run secondary servers
-        apps = list(Sanic._app_registry.values())
-        app.before_server_start(partial(app._start_servers, apps=apps))
-        for a in apps:
-            a.multiplexer = WorkerMultiplexer(monitor_publisher, worker_state)
-
-    if app.debug:
-        loop.set_debug(app.debug)
-
-    app.asgi = False
-
-    if app.state.server_info:
-        primary_server_info = app.state.server_info[0]
-        primary_server_info.stage = ServerStage.SERVING
-    if config:
-        app.update_config(config)
-
-    if version is HTTP.VERSION_3:
-        return _serve_http_3(host, port, app, loop, ssl)
-    return _serve_http_1(
-        host,
-        port,
-        app,
-        ssl,
-        sock,
-        unix,
-        reuse_port,
-        loop,
-        protocol,
-        backlog,
-        register_sys_signals,
-        run_multiple,
-        run_async,
-        connections,
-        signal,
-        state,
-        asyncio_server_kwargs,
-    )

sanic/worker/state.py

@@ -1,85 +0,0 @@
-from collections.abc import Mapping
-from typing import Any, Dict, ItemsView, Iterator, KeysView, List
-from typing import Mapping as MappingType
-from typing import ValuesView
-
-
-dict
-
-
-class WorkerState(Mapping):
-    RESTRICTED = (
-        "health",
-        "pid",
-        "requests",
-        "restart_at",
-        "server",
-        "start_at",
-        "starts",
-        "state",
-    )
-
-    def __init__(self, state: Dict[str, Any], current: str) -> None:
-        self._name = current
-        self._state = state
-
-    def __getitem__(self, key: str) -> Any:
-        return self._state[self._name][key]
-
-    def __setitem__(self, key: str, value: Any) -> None:
-        if key in self.RESTRICTED:
-            self._write_error([key])
-        self._state[self._name] = {
-            **self._state[self._name],
-            key: value,
-        }
-
-    def __delitem__(self, key: str) -> None:
-        if key in self.RESTRICTED:
-            self._write_error([key])
-        self._state[self._name] = {
-            k: v for k, v in self._state[self._name].items() if k != key
-        }
-
-    def __iter__(self) -> Iterator[Any]:
-        return iter(self._state[self._name])
-
-    def __len__(self) -> int:
-        return len(self._state[self._name])
-
-    def __repr__(self) -> str:
-        return repr(self._state[self._name])
-
-    def __eq__(self, other: object) -> bool:
-        return self._state[self._name] == other
-
-    def keys(self) -> KeysView[str]:
-        return self._state[self._name].keys()
-
-    def values(self) -> ValuesView[Any]:
-        return self._state[self._name].values()
-
-    def items(self) -> ItemsView[str, Any]:
-        return self._state[self._name].items()
-
-    def update(self, mapping: MappingType[str, Any]) -> None:
-        if any(k in self.RESTRICTED for k in mapping.keys()):
-            self._write_error(
-                [k for k in mapping.keys() if k in self.RESTRICTED]
-            )
-        self._state[self._name] = {
-            **self._state[self._name],
-            **mapping,
-        }
-
-    def pop(self) -> None:
-        raise NotImplementedError
-
-    def full(self) -> Dict[str, Any]:
-        return dict(self._state)
-
-    def _write_error(self, keys: List[str]) -> None:
-        raise LookupError(
-            f"Cannot set restricted key{'s' if len(keys) > 1 else ''} on "
-            f"WorkerState: {', '.join(keys)}"
-        )

setup.py

@@ -61,7 +61,7 @@ setup_kwargs = {
         "Build fast. Run fast."
     ),
     "long_description": long_description,
-    "packages": find_packages(exclude=("tests", "tests.*")),
+    "packages": find_packages(),
     "package_data": {"sanic": ["py.typed"]},
     "platforms": "any",
     "python_requires": ">=3.7",
@@ -84,7 +84,7 @@ ujson = "ujson>=1.35" + env_dependency
 uvloop = "uvloop>=0.5.3" + env_dependency
 types_ujson = "types-ujson" + env_dependency
 requirements = [
-    "sanic-routing>=22.8.0",
+    "sanic-routing>=22.3.0,<22.6.0",
     "httptools>=0.0.10",
     uvloop,
     ujson,
@@ -94,11 +94,14 @@ requirements = [
 ]
 
 tests_require = [
-    "sanic-testing>=22.9.0",
+    "sanic-testing>=22.3.0",
-    "pytest==7.1.*",
+    "pytest==6.2.5",
-    "coverage",
+    "coverage==5.3",
+    "gunicorn==20.0.4",
+    "pytest-cov",
     "beautifulsoup4",
     "pytest-sanic",
+    "pytest-sugar",
     "pytest-benchmark",
     "chardet==3.*",
     "flake8",

tests/conftest.py

@@ -126,7 +126,7 @@ def sanic_router(app):
             except RouteExists:
                 pass
         router.finalize()
-        return router, tuple(added_router)
+        return router, added_router
 
     return _setup
 

tests/fake/server.py

@@ -1,8 +1,6 @@
 import json
 
 from sanic import Sanic, text
-from sanic.application.constants import Mode
-from sanic.config import Config
 from sanic.log import LOGGING_CONFIG_DEFAULTS, logger
 
 
@@ -18,7 +16,7 @@ async def handler(request):
     return text(request.ip)
 
 
-@app.main_process_start
+@app.before_server_start
 async def app_info_dump(app: Sanic, _):
     app_data = {
         "access_log": app.config.ACCESS_LOG,
@@ -29,13 +27,6 @@ async def app_info_dump(app: Sanic, _):
     logger.info(json.dumps(app_data))
 
 
-@app.main_process_stop
-async def app_cleanup(app: Sanic, _):
-    app.state.auto_reload = False
-    app.state.mode = Mode.PRODUCTION
-    app.config = Config()
-
-
 @app.after_server_start
 async def shutdown(app: Sanic, _):
     app.stop()
@@ -47,8 +38,8 @@ def create_app():
 
 def create_app_with_args(args):
     try:
-        logger.info(f"foo={args.foo}")
+        print(f"foo={args.foo}")
     except AttributeError:
-        logger.info(f"module={args.module}")
+        print(f"module={args.module}")
 
     return app

tests/http3/test_server.py

@@ -35,7 +35,6 @@ def test_server_starts_http3(app: Sanic, version, caplog):
                 "cert": localhost_dir / "fullchain.pem",
                 "key": localhost_dir / "privkey.pem",
             },
-            single_process=True,
         )
 
     assert ev.is_set()
@@ -70,7 +69,7 @@ def test_server_starts_http1_and_http3(app: Sanic, caplog):
         },
     )
     with caplog.at_level(logging.INFO):
-        Sanic.serve_single()
+        Sanic.serve()
 
     assert (
         "sanic.root",

tests/test_app.py

@@ -4,7 +4,6 @@ import re
 
 from collections import Counter
 from inspect import isawaitable
-from os import environ
 from unittest.mock import Mock, patch
 
 import pytest
@@ -15,10 +14,8 @@ from sanic import Sanic
 from sanic.compat import OS_IS_WINDOWS
 from sanic.config import Config
 from sanic.exceptions import SanicException
-from sanic.helpers import Default
+from sanic.helpers import _default
-from sanic.log import LOGGING_CONFIG_DEFAULTS
 from sanic.response import text
-from sanic.router import Route
 
 
 @pytest.fixture(autouse=True)
@@ -26,7 +23,7 @@ def clear_app_registry():
     Sanic._app_registry = {}
 
 
-def test_app_loop_running(app: Sanic):
+def test_app_loop_running(app):
     @app.get("/test")
     async def handler(request):
         assert isinstance(app.loop, asyncio.AbstractEventLoop)
@@ -36,7 +33,7 @@ def test_app_loop_running(app: Sanic):
     assert response.text == "pass"
 
 
-def test_create_asyncio_server(app: Sanic):
+def test_create_asyncio_server(app):
     loop = asyncio.get_event_loop()
     asyncio_srv_coro = app.create_server(return_asyncio_server=True)
     assert isawaitable(asyncio_srv_coro)
@@ -44,7 +41,7 @@ def test_create_asyncio_server(app: Sanic):
     assert srv.is_serving() is True
 
 
-def test_asyncio_server_no_start_serving(app: Sanic):
+def test_asyncio_server_no_start_serving(app):
     loop = asyncio.get_event_loop()
     asyncio_srv_coro = app.create_server(
         port=43123,
@@ -55,7 +52,7 @@ def test_asyncio_server_no_start_serving(app: Sanic):
     assert srv.is_serving() is False
 
 
-def test_asyncio_server_start_serving(app: Sanic):
+def test_asyncio_server_start_serving(app):
     loop = asyncio.get_event_loop()
     asyncio_srv_coro = app.create_server(
         port=43124,
@@ -72,7 +69,7 @@ def test_asyncio_server_start_serving(app: Sanic):
     # Looks like we can't easily test `serve_forever()`
 
 
-def test_create_server_main(app: Sanic, caplog):
+def test_create_server_main(app, caplog):
     app.listener("main_process_start")(lambda *_: ...)
     loop = asyncio.get_event_loop()
     with caplog.at_level(logging.INFO):
@@ -86,7 +83,7 @@ def test_create_server_main(app: Sanic, caplog):
     ) in caplog.record_tuples
 
 
-def test_create_server_no_startup(app: Sanic):
+def test_create_server_no_startup(app):
     loop = asyncio.get_event_loop()
     asyncio_srv_coro = app.create_server(
         port=43124,
@@ -101,7 +98,7 @@ def test_create_server_no_startup(app: Sanic):
         loop.run_until_complete(srv.start_serving())
 
 
-def test_create_server_main_convenience(app: Sanic, caplog):
+def test_create_server_main_convenience(app, caplog):
     app.main_process_start(lambda *_: ...)
     loop = asyncio.get_event_loop()
     with caplog.at_level(logging.INFO):
@@ -115,7 +112,7 @@ def test_create_server_main_convenience(app: Sanic, caplog):
     ) in caplog.record_tuples
 
 
-def test_app_loop_not_running(app: Sanic):
+def test_app_loop_not_running(app):
     with pytest.raises(SanicException) as excinfo:
         app.loop
 
@@ -125,7 +122,7 @@ def test_app_loop_not_running(app: Sanic):
     )
 
 
-def test_app_run_raise_type_error(app: Sanic):
+def test_app_run_raise_type_error(app):
 
     with pytest.raises(TypeError) as excinfo:
         app.run(loop="loop")
@@ -138,7 +135,7 @@ def test_app_run_raise_type_error(app: Sanic):
     )
 
 
-def test_app_route_raise_value_error(app: Sanic):
+def test_app_route_raise_value_error(app):
 
     with pytest.raises(ValueError) as excinfo:
 
@@ -152,15 +149,11 @@ def test_app_route_raise_value_error(app: Sanic):
     )
 
 
-def test_app_handle_request_handler_is_none(app: Sanic, monkeypatch):
+def test_app_handle_request_handler_is_none(app, monkeypatch):
-    app.config.TOUCHUP = False
-    route = Mock(spec=Route)
-    route.extra.request_middleware = []
-    route.extra.response_middleware = []
-
     def mockreturn(*args, **kwargs):
-        return route, None, {}
+        return Mock(), None, {}
 
+    # Not sure how to make app.router.get() return None, so use mock here.
     monkeypatch.setattr(app.router, "get", mockreturn)
 
     @app.get("/test")
@@ -177,7 +170,7 @@ def test_app_handle_request_handler_is_none(app: Sanic, monkeypatch):
 
 @pytest.mark.parametrize("websocket_enabled", [True, False])
 @pytest.mark.parametrize("enable", [True, False])
-def test_app_enable_websocket(app: Sanic, websocket_enabled, enable):
+def test_app_enable_websocket(app, websocket_enabled, enable):
     app.websocket_enabled = websocket_enabled
     app.enable_websocket(enable=enable)
 
@@ -187,11 +180,11 @@ def test_app_enable_websocket(app: Sanic, websocket_enabled, enable):
     async def handler(request, ws):
         await ws.send("test")
 
-    assert app.websocket_enabled is True
+    assert app.websocket_enabled == True
 
 
-@patch("sanic.mixins.startup.WebSocketProtocol")
+@patch("sanic.mixins.runner.WebSocketProtocol")
-def test_app_websocket_parameters(websocket_protocol_mock, app: Sanic):
+def test_app_websocket_parameters(websocket_protocol_mock, app):
     app.config.WEBSOCKET_MAX_SIZE = 44
     app.config.WEBSOCKET_PING_TIMEOUT = 48
     app.config.WEBSOCKET_PING_INTERVAL = 50
@@ -201,10 +194,9 @@ def test_app_websocket_parameters(websocket_protocol_mock, app: Sanic):
         await ws.send("test")
 
     try:
-        # This will fail because WebSocketProtocol is mocked and only the
+        # This will fail because WebSocketProtocol is mocked and only the call kwargs matter
-        # call kwargs matter
         app.test_client.get("/ws")
-    except Exception:
+    except:
         pass
 
     websocket_protocol_call_args = websocket_protocol_mock.call_args
@@ -220,10 +212,11 @@ def test_app_websocket_parameters(websocket_protocol_mock, app: Sanic):
     )
 
 
-def test_handle_request_with_nested_exception(app: Sanic, monkeypatch):
+def test_handle_request_with_nested_exception(app, monkeypatch):
 
     err_msg = "Mock Exception"
 
+    # Not sure how to raise an exception in app.error_handler.response(), use mock here
     def mock_error_handler_response(*args, **kwargs):
         raise Exception(err_msg)
 
@@ -240,10 +233,11 @@ def test_handle_request_with_nested_exception(app: Sanic, monkeypatch):
     assert response.text == "An error occurred while handling an error"
 
 
-def test_handle_request_with_nested_exception_debug(app: Sanic, monkeypatch):
+def test_handle_request_with_nested_exception_debug(app, monkeypatch):
 
     err_msg = "Mock Exception"
 
+    # Not sure how to raise an exception in app.error_handler.response(), use mock here
     def mock_error_handler_response(*args, **kwargs):
         raise Exception(err_msg)
 
@@ -258,14 +252,13 @@ def test_handle_request_with_nested_exception_debug(app: Sanic, monkeypatch):
     request, response = app.test_client.get("/", debug=True)
     assert response.status == 500
     assert response.text.startswith(
-        f"Error while handling error: {err_msg}\n"
+        f"Error while handling error: {err_msg}\nStack: Traceback (most recent call last):\n"
-        "Stack: Traceback (most recent call last):\n"
     )
 
 
-def test_handle_request_with_nested_sanic_exception(
+def test_handle_request_with_nested_sanic_exception(app, monkeypatch, caplog):
-    app: Sanic, monkeypatch, caplog
+
-):
+    # Not sure how to raise an exception in app.error_handler.response(), use mock here
     def mock_error_handler_response(*args, **kwargs):
         raise SanicException("Mock SanicException")
 
@@ -308,12 +301,8 @@ def test_app_has_test_mode_sync():
 
 
 def test_app_registry():
-    assert len(Sanic._app_registry) == 0
     instance = Sanic("test")
-    assert len(Sanic._app_registry) == 1
     assert Sanic._app_registry["test"] is instance
-    Sanic.unregister_app(instance)
-    assert len(Sanic._app_registry) == 0
 
 
 def test_app_registry_wrong_type():
@@ -347,13 +336,7 @@ def test_app_registry_retrieval_from_multiple():
 
 def test_get_app_does_not_exist():
     with pytest.raises(
-        SanicException,
+        SanicException, match='Sanic app name "does-not-exist" not found.'
-        match="Sanic app name 'does-not-exist' not found.\n"
-            "App instantiation must occur outside "
-            "if __name__ == '__main__' "
-            "block or by using an AppLoader.\nSee "
-            "https://sanic.dev/en/guide/deployment/app-loader.html"
-            " for more details."
     ):
         Sanic.get_app("does-not-exist")
 
@@ -388,7 +371,7 @@ def test_get_app_default_ambiguous():
         Sanic.get_app()
 
 
-def test_app_set_attribute_warning(app: Sanic):
+def test_app_set_attribute_warning(app):
     message = (
         "Setting variables on Sanic instances is not allowed. You should "
         "change your Sanic instance to use instance.ctx.foo instead."
@@ -397,7 +380,7 @@ def test_app_set_attribute_warning(app: Sanic):
         app.foo = 1
 
 
-def test_app_set_context(app: Sanic):
+def test_app_set_context(app):
     app.ctx.foo = 1
 
     retrieved = Sanic.get_app(app.name)
@@ -443,13 +426,13 @@ def test_custom_context():
 
 
 @pytest.mark.parametrize("use", (False, True))
-def test_uvloop_config(app: Sanic, monkeypatch, use):
+def test_uvloop_config(app, monkeypatch, use):
     @app.get("/test")
     def handler(request):
         return text("ok")
 
     try_use_uvloop = Mock()
-    monkeypatch.setattr(sanic.mixins.startup, "try_use_uvloop", try_use_uvloop)
+    monkeypatch.setattr(sanic.mixins.runner, "try_use_uvloop", try_use_uvloop)
 
     # Default config
     app.test_client.get("/test")
@@ -475,7 +458,7 @@ def test_uvloop_cannot_never_called_with_create_server(caplog, monkeypatch):
     apps[2].config.USE_UVLOOP = True
 
     try_use_uvloop = Mock()
-    monkeypatch.setattr(sanic.mixins.startup, "try_use_uvloop", try_use_uvloop)
+    monkeypatch.setattr(sanic.mixins.runner, "try_use_uvloop", try_use_uvloop)
 
     loop = asyncio.get_event_loop()
 
@@ -497,9 +480,7 @@ def test_uvloop_cannot_never_called_with_create_server(caplog, monkeypatch):
     )
 
     counter = Counter([(r[1], r[2]) for r in caplog.record_tuples])
-    modified = sum(
+    modified = sum(1 for app in apps if app.config.USE_UVLOOP is not _default)
-        1 for app in apps if not isinstance(app.config.USE_UVLOOP, Default)
-    )
 
     assert counter[(logging.WARNING, message)] == modified
 
@@ -533,136 +514,15 @@ def test_multiple_uvloop_configs_display_warning(caplog):
 
     counter = Counter([(r[1], r[2]) for r in caplog.record_tuples])
 
-    assert counter[(logging.WARNING, message)] == 3
+    assert counter[(logging.WARNING, message)] == 2
 
 
-def test_cannot_run_fast_and_workers(app: Sanic):
+def test_cannot_run_fast_and_workers(app):
     message = "You cannot use both fast=True and workers=X"
     with pytest.raises(RuntimeError, match=message):
         app.run(fast=True, workers=4)
 
 
-def test_no_workers(app: Sanic):
+def test_no_workers(app):
     with pytest.raises(RuntimeError, match="Cannot serve with no workers"):
         app.run(workers=0)
-
-
-@pytest.mark.parametrize(
-    "extra",
-    (
-        {"fast": True},
-        {"workers": 2},
-        {"auto_reload": True},
-    ),
-)
-def test_cannot_run_single_process_and_workers_or_auto_reload(
-    app: Sanic, extra
-):
-    message = (
-        "Single process cannot be run with multiple workers or auto-reload"
-    )
-    with pytest.raises(RuntimeError, match=message):
-        app.run(single_process=True, **extra)
-
-
-def test_cannot_run_single_process_and_legacy(app: Sanic):
-    message = "Cannot run single process and legacy mode"
-    with pytest.raises(RuntimeError, match=message):
-        app.run(single_process=True, legacy=True)
-
-
-def test_cannot_run_without_sys_signals_with_workers(app: Sanic):
-    message = (
-        "Cannot run Sanic.serve with register_sys_signals=False. "
-        "Use either Sanic.serve_single or Sanic.serve_legacy."
-    )
-    with pytest.raises(RuntimeError, match=message):
-        app.run(register_sys_signals=False, single_process=False, legacy=False)
-
-
-def test_default_configure_logging():
-    with patch("sanic.app.logging") as mock:
-        Sanic("Test")
-
-    mock.config.dictConfig.assert_called_with(LOGGING_CONFIG_DEFAULTS)
-
-
-def test_custom_configure_logging():
-    with patch("sanic.app.logging") as mock:
-        Sanic("Test", log_config={"foo": "bar"})
-
-    mock.config.dictConfig.assert_called_with({"foo": "bar"})
-
-
-def test_disable_configure_logging():
-    with patch("sanic.app.logging") as mock:
-        Sanic("Test", configure_logging=False)
-
-    mock.config.dictConfig.assert_not_called()
-
-
-@pytest.mark.parametrize("inspector", (True, False))
-def test_inspector(inspector):
-    app = Sanic("Test", inspector=inspector)
-    assert app.config.INSPECTOR is inspector
-
-
-def test_build_endpoint_name():
-    app = Sanic("Test")
-    name = app._build_endpoint_name("foo", "bar")
-    assert name == "Test.foo.bar"
-
-
-def test_manager_in_main_process_only(app: Sanic):
-    message = "Can only access the manager from the main process"
-
-    with pytest.raises(SanicException, match=message):
-        app.manager
-
-    app._manager = 1
-    environ["SANIC_WORKER_PROCESS"] = "ok"
-
-    with pytest.raises(SanicException, match=message):
-        app.manager
-
-    del environ["SANIC_WORKER_PROCESS"]
-
-    assert app.manager == 1
-
-
-def test_inspector_in_main_process_only(app: Sanic):
-    message = "Can only access the inspector from the main process"
-
-    with pytest.raises(SanicException, match=message):
-        app.inspector
-
-    app._inspector = 1
-    environ["SANIC_WORKER_PROCESS"] = "ok"
-
-    with pytest.raises(SanicException, match=message):
-        app.inspector
-
-    del environ["SANIC_WORKER_PROCESS"]
-
-    assert app.inspector == 1
-
-
-def test_stop_trigger_terminate(app: Sanic):
-    app.multiplexer = Mock()
-
-    app.stop()
-
-    app.multiplexer.terminate.assert_called_once()
-    app.multiplexer.reset_mock()
-    assert len(Sanic._app_registry) == 1
-    Sanic._app_registry.clear()
-
-    app.stop(terminate=True)
-
-    app.multiplexer.terminate.assert_called_once()
-    app.multiplexer.reset_mock()
-    assert len(Sanic._app_registry) == 0
-    Sanic._app_registry.clear()
-
-    app.stop(unregister=False)
-    app.multiplexer.terminate.assert_called_once()

tests/test_asgi.py

@@ -531,8 +531,6 @@ async def test_signals_triggered(app):
         "http.lifecycle.handle",
         "http.routing.before",
         "http.routing.after",
-        "http.handler.before",
-        "http.handler.after",
         "http.lifecycle.response",
         # "http.lifecycle.send",
         # "http.lifecycle.complete",

tests/test_bad_request.py

@@ -1,16 +1,13 @@
 import asyncio
 
-from sanic import Sanic
 
-
+def test_bad_request_response(app):
-def test_bad_request_response(app: Sanic):
     lines = []
 
     app.get("/")(lambda x: ...)
 
     @app.listener("after_server_start")
     async def _request(sanic, loop):
-        nonlocal lines
         connect = asyncio.open_connection("127.0.0.1", 42101)
         reader, writer = await connect
         writer.write(b"not http\r\n\r\n")
@@ -21,6 +18,6 @@ def test_bad_request_response(app: Sanic):
             lines.append(line)
         app.stop()
 
-    app.run(host="127.0.0.1", port=42101, debug=False, single_process=True)
+    app.run(host="127.0.0.1", port=42101, debug=False)
     assert lines[0] == b"HTTP/1.1 400 Bad Request\r\n"
     assert b"Bad Request" in lines[-2]

tests/test_blueprint_group.py

@@ -323,20 +323,3 @@ def test_bp_group_properties():
     assert "api/v1/grouped/bp2/" in routes
     assert "api/v1/primary/grouped/bp1" in routes
     assert "api/v1/primary/grouped/bp2" in routes
-
-
-def test_nested_bp_group_properties():
-    one = Blueprint("one", url_prefix="/one")
-    two = Blueprint.group(one)
-    three = Blueprint.group(two, url_prefix="/three")
-
-    @one.route("/four")
-    def handler(request):
-        return text("pi")
-
-    app = Sanic("PropTest")
-    app.blueprint(three)
-    app.router.finalize()
-
-    routes = [route.path for route in app.router.routes]
-    assert routes == ["three/one/four"]

tests/test_blueprints.py

@@ -17,7 +17,7 @@ from sanic.response import json, text
 # ------------------------------------------------------------ #
 
 
-def test_bp(app: Sanic):
+def test_bp(app):
     bp = Blueprint("test_text")
 
     @bp.route("/")
@@ -30,7 +30,7 @@ def test_bp(app: Sanic):
     assert response.text == "Hello"
 
 
-def test_bp_app_access(app: Sanic):
+def test_bp_app_access(app):
     bp = Blueprint("test")
 
     with pytest.raises(
@@ -87,7 +87,7 @@ def test_versioned_routes_get(app, method):
     assert response.status == 200
 
 
-def test_bp_strict_slash(app: Sanic):
+def test_bp_strict_slash(app):
     bp = Blueprint("test_text")
 
     @bp.get("/get", strict_slashes=True)
@@ -114,7 +114,7 @@ def test_bp_strict_slash(app: Sanic):
     assert response.status == 404
 
 
-def test_bp_strict_slash_default_value(app: Sanic):
+def test_bp_strict_slash_default_value(app):
     bp = Blueprint("test_text", strict_slashes=True)
 
     @bp.get("/get")
@@ -134,7 +134,7 @@ def test_bp_strict_slash_default_value(app: Sanic):
     assert response.status == 404
 
 
-def test_bp_strict_slash_without_passing_default_value(app: Sanic):
+def test_bp_strict_slash_without_passing_default_value(app):
     bp = Blueprint("test_text")
 
     @bp.get("/get")
@@ -154,7 +154,7 @@ def test_bp_strict_slash_without_passing_default_value(app: Sanic):
     assert response.text == "OK"
 
 
-def test_bp_strict_slash_default_value_can_be_overwritten(app: Sanic):
+def test_bp_strict_slash_default_value_can_be_overwritten(app):
     bp = Blueprint("test_text", strict_slashes=True)
 
     @bp.get("/get", strict_slashes=False)
@@ -174,7 +174,7 @@ def test_bp_strict_slash_default_value_can_be_overwritten(app: Sanic):
     assert response.text == "OK"
 
 
-def test_bp_with_url_prefix(app: Sanic):
+def test_bp_with_url_prefix(app):
     bp = Blueprint("test_text", url_prefix="/test1")
 
     @bp.route("/")
@@ -187,7 +187,7 @@ def test_bp_with_url_prefix(app: Sanic):
     assert response.text == "Hello"
 
 
-def test_several_bp_with_url_prefix(app: Sanic):
+def test_several_bp_with_url_prefix(app):
     bp = Blueprint("test_text", url_prefix="/test1")
     bp2 = Blueprint("test_text2", url_prefix="/test2")
 
@@ -208,7 +208,7 @@ def test_several_bp_with_url_prefix(app: Sanic):
     assert response.text == "Hello2"
 
 
-def test_bp_with_host(app: Sanic):
+def test_bp_with_host(app):
     bp = Blueprint("test_bp_host", url_prefix="/test1", host="example.com")
 
     @bp.route("/")
@@ -230,7 +230,7 @@ def test_bp_with_host(app: Sanic):
     assert response.body == b"Hello subdomain!"
 
 
-def test_several_bp_with_host(app: Sanic):
+def test_several_bp_with_host(app):
     bp = Blueprint(
         "test_text",
         url_prefix="/test",
@@ -274,7 +274,7 @@ def test_several_bp_with_host(app: Sanic):
     assert response.text == "Hello3"
 
 
-def test_bp_with_host_list(app: Sanic):
+def test_bp_with_host_list(app):
     bp = Blueprint(
         "test_bp_host",
         url_prefix="/test1",
@@ -304,7 +304,7 @@ def test_bp_with_host_list(app: Sanic):
     assert response.text == "Hello subdomain!"
 
 
-def test_several_bp_with_host_list(app: Sanic):
+def test_several_bp_with_host_list(app):
     bp = Blueprint(
         "test_text",
         url_prefix="/test",
@@ -356,7 +356,7 @@ def test_several_bp_with_host_list(app: Sanic):
     assert response.text == "Hello3"
 
 
-def test_bp_middleware(app: Sanic):
+def test_bp_middleware(app):
     blueprint = Blueprint("test_bp_middleware")
 
     @blueprint.middleware("response")
@@ -375,7 +375,7 @@ def test_bp_middleware(app: Sanic):
     assert response.text == "FAIL"
 
 
-def test_bp_middleware_with_route(app: Sanic):
+def test_bp_middleware_with_route(app):
     blueprint = Blueprint("test_bp_middleware")
 
     @blueprint.middleware("response")
@@ -398,7 +398,7 @@ def test_bp_middleware_with_route(app: Sanic):
     assert response.text == "OK"
 
 
-def test_bp_middleware_order(app: Sanic):
+def test_bp_middleware_order(app):
     blueprint = Blueprint("test_bp_middleware_order")
     order = []
 
@@ -438,7 +438,7 @@ def test_bp_middleware_order(app: Sanic):
     assert order == [1, 2, 3, 4, 5, 6]
 
 
-def test_bp_exception_handler(app: Sanic):
+def test_bp_exception_handler(app):
     blueprint = Blueprint("test_middleware")
 
     @blueprint.route("/1")
@@ -470,7 +470,7 @@ def test_bp_exception_handler(app: Sanic):
     assert response.status == 200
 
 
-def test_bp_exception_handler_applied(app: Sanic):
+def test_bp_exception_handler_applied(app):
     class Error(Exception):
         pass
 
@@ -500,7 +500,7 @@ def test_bp_exception_handler_applied(app: Sanic):
     assert response.status == 500
 
 
-def test_bp_exception_handler_not_applied(app: Sanic):
+def test_bp_exception_handler_not_applied(app):
     class Error(Exception):
         pass
 
@@ -522,7 +522,7 @@ def test_bp_exception_handler_not_applied(app: Sanic):
     assert response.status == 500
 
 
-def test_bp_listeners(app: Sanic):
+def test_bp_listeners(app):
     app.route("/")(lambda x: x)
     blueprint = Blueprint("test_middleware")
 
@@ -559,7 +559,7 @@ def test_bp_listeners(app: Sanic):
     assert order == [1, 2, 3, 4, 5, 6]
 
 
-def test_bp_static(app: Sanic):
+def test_bp_static(app):
     current_file = inspect.getfile(inspect.currentframe())
     with open(current_file, "rb") as file:
         current_file_contents = file.read()
@@ -597,7 +597,7 @@ def test_bp_static_content_type(app, file_name):
     assert response.headers["Content-Type"] == "text/html; charset=utf-8"
 
 
-def test_bp_shorthand(app: Sanic):
+def test_bp_shorthand(app):
     blueprint = Blueprint("test_shorhand_routes")
     ev = asyncio.Event()
 
@@ -682,7 +682,7 @@ def test_bp_shorthand(app: Sanic):
     assert ev.is_set()
 
 
-def test_bp_group(app: Sanic):
+def test_bp_group(app):
     deep_0 = Blueprint("deep_0", url_prefix="/deep")
     deep_1 = Blueprint("deep_1", url_prefix="/deep1")
 
@@ -722,7 +722,7 @@ def test_bp_group(app: Sanic):
     assert response.text == "D1B_OK"
 
 
-def test_bp_group_with_default_url_prefix(app: Sanic):
+def test_bp_group_with_default_url_prefix(app):
     from sanic.response import json
 
     bp_resources = Blueprint("bp_resources")
@@ -873,7 +873,7 @@ def test_websocket_route(app: Sanic):
     assert event.is_set()
 
 
-def test_duplicate_blueprint(app: Sanic):
+def test_duplicate_blueprint(app):
     bp_name = "bp"
     bp = Blueprint(bp_name)
     bp1 = Blueprint(bp_name)
@@ -1056,7 +1056,7 @@ def test_bp_set_attribute_warning():
         bp.foo = 1
 
 
-def test_early_registration(app: Sanic):
+def test_early_registration(app):
     assert len(app.router.routes) == 0
 
     bp = Blueprint("bp")
@@ -1082,29 +1082,3 @@ def test_early_registration(app: Sanic):
     for path in ("one", "two", "three"):
         _, response = app.test_client.get(f"/{path}")
         assert response.text == path
-
-
-def test_remove_double_slashes_defined_on_bp(app: Sanic):
-    bp = Blueprint("bp", url_prefix="/foo/", strict_slashes=True)
-
-    @bp.get("/")
-    async def handler(_):
-        ...
-
-    app.blueprint(bp)
-    app.router.finalize()
-
-    assert app.router.routes[0].path == "foo/"
-
-
-def test_remove_double_slashes_defined_on_register(app: Sanic):
-    bp = Blueprint("bp")
-
-    @bp.get("/")
-    async def index(_):
-        ...
-
-    app.blueprint(bp, url_prefix="/foo/", strict_slashes=True)
-    app.router.finalize()
-
-    assert app.router.routes[0].path == "foo/"

tests/test_cancellederror.py

@@ -1,21 +0,0 @@
-import asyncio
-
-from asyncio import CancelledError
-
-import pytest
-
-from sanic import Request, Sanic, json
-
-
-def test_can_raise_in_handler(app: Sanic):
-    @app.get("/")
-    async def handler(request: Request):
-        raise CancelledError("STOP!!")
-
-    @app.exception(CancelledError)
-    async def handle_cancel(request: Request, exc: CancelledError):
-        return json({"message": exc.args[0]}, status=418)
-
-    _, response = app.test_client.get("/")
-    assert response.status == 418
-    assert response.json["message"] == "STOP!!"

tests/test_cli.py

@@ -1,6 +1,5 @@
 import json
-import os
+import subprocess
-import sys
 
 from pathlib import Path
 from typing import List, Optional, Tuple
@@ -10,30 +9,33 @@ import pytest
 from sanic_routing import __version__ as __routing_version__
 
 from sanic import __version__
-from sanic.__main__ import main
 
 
-@pytest.fixture(scope="module", autouse=True)
+def capture(command: List[str]):
-def tty():
+    proc = subprocess.Popen(
-    orig = sys.stdout.isatty
+        command,
-    sys.stdout.isatty = lambda: False
+        stdout=subprocess.PIPE,
-    yield
+        stderr=subprocess.PIPE,
-    sys.stdout.isatty = orig
+        cwd=Path(__file__).parent,
-
+    )
-
-def capture(command: List[str], caplog):
-    caplog.clear()
-    os.chdir(Path(__file__).parent)
     try:
-        main(command)
+        out, err = proc.communicate(timeout=10)
-    except SystemExit:
+    except subprocess.TimeoutExpired:
-        ...
+        proc.kill()
-    return [record.message for record in caplog.records]
+        out, err = proc.communicate()
+    return out, err, proc.returncode
+
+
+def starting_line(lines: List[str]):
+    for idx, line in enumerate(lines):
+        if line.strip().startswith(b"Sanic v"):
+            return idx
+    return 0
 
 
 def read_app_info(lines: List[str]):
     for line in lines:
-        if line.startswith("{") and line.endswith("}"):  # type: ignore
+        if line.startswith(b"{") and line.endswith(b"}"):
             return json.loads(line)
 
 
@@ -45,57 +47,59 @@ def read_app_info(lines: List[str]):
         ("fake.server.create_app()", None),
     ),
 )
-def test_server_run(
+def test_server_run(appname: str, extra: Optional[str]):
-    appname: str,
+    command = ["sanic", appname]
-    extra: Optional[str],
-    caplog: pytest.LogCaptureFixture,
-):
-    command = [appname]
     if extra:
         command.append(extra)
-    lines = capture(command, caplog)
+    out, err, exitcode = capture(command)
+    lines = out.split(b"\n")
+    firstline = lines[starting_line(lines) + 1]
 
-    assert "Goin' Fast @ http://127.0.0.1:8000" in lines
+    assert exitcode != 1
+    assert firstline == b"Goin' Fast @ http://127.0.0.1:8000"
 
 
-def test_server_run_factory_with_args(caplog):
+def test_server_run_factory_with_args():
     command = [
+        "sanic",
         "fake.server.create_app_with_args",
         "--factory",
     ]
-    lines = capture(command, caplog)
+    out, err, exitcode = capture(command)
+    lines = out.split(b"\n")
 
-    assert "module=fake.server.create_app_with_args" in lines
+    assert exitcode != 1, lines
+    assert b"module=fake.server.create_app_with_args" in lines
 
 
-def test_server_run_factory_with_args_arbitrary(caplog):
+def test_server_run_factory_with_args_arbitrary():
     command = [
+        "sanic",
         "fake.server.create_app_with_args",
         "--factory",
         "--foo=bar",
     ]
-    lines = capture(command, caplog)
+    out, err, exitcode = capture(command)
+    lines = out.split(b"\n")
 
-    assert "foo=bar" in lines
+    assert exitcode != 1, lines
+    assert b"foo=bar" in lines
 
 
-def test_error_with_function_as_instance_without_factory_arg(caplog):
+def test_error_with_function_as_instance_without_factory_arg():
-    command = ["fake.server.create_app"]
+    command = ["sanic", "fake.server.create_app"]
-    lines = capture(command, caplog)
+    out, err, exitcode = capture(command)
+    assert b"try: \nsanic fake.server.create_app --factory" in err
+    assert exitcode != 1
+
+
+def test_error_with_path_as_instance_without_simple_arg():
+    command = ["sanic", "./fake/"]
+    out, err, exitcode = capture(command)
     assert (
-        "Failed to run app: Module is not a Sanic app, it is a function\n  "
+        b"Please use --simple if you are passing a directory to sanic." in err
-        "If this callable returns a Sanic instance try: \n"
+    )
-        "sanic fake.server.create_app --factory"
+    assert exitcode != 1
-    ) in lines
-
-
-def test_error_with_path_as_instance_without_simple_arg(caplog):
-    command = ["./fake/"]
-    lines = capture(command, caplog)
-    assert (
-        "Failed to run app: App not found.\n   Please use --simple if you "
-        "are passing a directory to sanic.\n   eg. sanic ./fake/ --simple"
-    ) in lines
 
 
 @pytest.mark.parametrize(
@@ -116,10 +120,13 @@ def test_error_with_path_as_instance_without_simple_arg(caplog):
         ),
     ),
 )
-def test_tls_options(cmd: Tuple[str, ...], caplog):
+def test_tls_options(cmd: Tuple[str]):
-    command = ["fake.server.app", *cmd, "--port=9999", "--debug"]
+    command = ["sanic", "fake.server.app", *cmd, "-p=9999", "--debug"]
-    lines = capture(command, caplog)
+    out, err, exitcode = capture(command)
-    assert "Goin' Fast @ https://127.0.0.1:9999" in lines
+    assert exitcode != 1
+    lines = out.split(b"\n")
+    firstline = lines[starting_line(lines) + 1]
+    assert firstline == b"Goin' Fast @ https://127.0.0.1:9999"
 
 
 @pytest.mark.parametrize(
@@ -134,15 +141,14 @@ def test_tls_options(cmd: Tuple[str, ...], caplog):
         ("--tls-strict-host",),
     ),
 )
-def test_tls_wrong_options(cmd: Tuple[str, ...], caplog):
+def test_tls_wrong_options(cmd: Tuple[str]):
-    command = ["fake.server.app", *cmd, "-p=9999", "--debug"]
+    command = ["sanic", "fake.server.app", *cmd, "-p=9999", "--debug"]
-    lines = capture(command, caplog)
+    out, err, exitcode = capture(command)
+    assert exitcode == 1
+    assert not out
+    lines = err.decode().split("\n")
 
-    assert (
+    assert "TLS certificates must be specified by either of:" in lines
-        "TLS certificates must be specified by either of:\n  "
-        "--cert certdir/fullchain.pem --key certdir/privkey.pem\n  "
-        "--tls certdir  (equivalent to the above)"
-    ) in lines
 
 
 @pytest.mark.parametrize(
@@ -152,44 +158,65 @@ def test_tls_wrong_options(cmd: Tuple[str, ...], caplog):
         ("-H", "localhost", "-p", "9999"),
     ),
 )
-def test_host_port_localhost(cmd: Tuple[str, ...], caplog):
+def test_host_port_localhost(cmd: Tuple[str]):
-    command = ["fake.server.app", *cmd]
+    command = ["sanic", "fake.server.app", *cmd]
-    lines = capture(command, caplog)
+    out, err, exitcode = capture(command)
-    expected = "Goin' Fast @ http://localhost:9999"
+    lines = out.split(b"\n")
+    expected = b"Goin' Fast @ http://localhost:9999"
 
-    assert expected in lines
+    assert exitcode != 1
+    assert expected in lines, f"Lines found: {lines}\nErr output: {err}"
 
 
 @pytest.mark.parametrize(
-    "cmd,expected",
+    "cmd",
     (
-        (
+        ("--host=127.0.0.127", "--port=9999"),
-            ("--host=localhost", "--port=9999"),
+        ("-H", "127.0.0.127", "-p", "9999"),
-            "Goin' Fast @ http://localhost:9999",
-        ),
-        (
-            ("-H", "localhost", "-p", "9999"),
-            "Goin' Fast @ http://localhost:9999",
-        ),
-        (
-            ("--host=127.0.0.127", "--port=9999"),
-            "Goin' Fast @ http://127.0.0.127:9999",
-        ),
-        (
-            ("-H", "127.0.0.127", "-p", "9999"),
-            "Goin' Fast @ http://127.0.0.127:9999",
-        ),
-        (("--host=::", "--port=9999"), "Goin' Fast @ http://[::]:9999"),
-        (("-H", "::", "-p", "9999"), "Goin' Fast @ http://[::]:9999"),
-        (("--host=::1", "--port=9999"), "Goin' Fast @ http://[::1]:9999"),
-        (("-H", "::1", "-p", "9999"), "Goin' Fast @ http://[::1]:9999"),
     ),
 )
-def test_host_port(cmd: Tuple[str, ...], expected: str, caplog):
+def test_host_port_ipv4(cmd: Tuple[str]):
-    command = ["fake.server.app", *cmd]
+    command = ["sanic", "fake.server.app", *cmd]
-    lines = capture(command, caplog)
+    out, err, exitcode = capture(command)
+    lines = out.split(b"\n")
+    expected = b"Goin' Fast @ http://127.0.0.127:9999"
 
-    assert expected in lines
+    assert exitcode != 1
+    assert expected in lines, f"Lines found: {lines}\nErr output: {err}"
+
+
+@pytest.mark.parametrize(
+    "cmd",
+    (
+        ("--host=::", "--port=9999"),
+        ("-H", "::", "-p", "9999"),
+    ),
+)
+def test_host_port_ipv6_any(cmd: Tuple[str]):
+    command = ["sanic", "fake.server.app", *cmd]
+    out, err, exitcode = capture(command)
+    lines = out.split(b"\n")
+    expected = b"Goin' Fast @ http://[::]:9999"
+
+    assert exitcode != 1
+    assert expected in lines, f"Lines found: {lines}\nErr output: {err}"
+
+
+@pytest.mark.parametrize(
+    "cmd",
+    (
+        ("--host=::1", "--port=9999"),
+        ("-H", "::1", "-p", "9999"),
+    ),
+)
+def test_host_port_ipv6_loopback(cmd: Tuple[str]):
+    command = ["sanic", "fake.server.app", *cmd]
+    out, err, exitcode = capture(command)
+    lines = out.split(b"\n")
+    expected = b"Goin' Fast @ http://[::1]:9999"
+
+    assert exitcode != 1
+    assert expected in lines, f"Lines found: {lines}\nErr output: {err}"
 
 
 @pytest.mark.parametrize(
@@ -203,74 +230,82 @@ def test_host_port(cmd: Tuple[str, ...], expected: str, caplog):
         (4, ("-w", "4")),
     ),
 )
-def test_num_workers(num: int, cmd: Tuple[str, ...], caplog):
+def test_num_workers(num: int, cmd: Tuple[str]):
-    command = ["fake.server.app", *cmd]
+    command = ["sanic", "fake.server.app", *cmd]
-    lines = capture(command, caplog)
+    out, err, exitcode = capture(command)
+    lines = out.split(b"\n")
 
     if num == 1:
-        expected = "mode: production, single worker"
+        expected = b"mode: production, single worker"
     else:
-        expected = f"mode: production, w/ {num} workers"
+        expected = (f"mode: production, w/ {num} workers").encode()
 
-    assert expected in lines
+    assert exitcode != 1
+    assert expected in lines, f"Expected {expected}\nLines found: {lines}"
 
 
 @pytest.mark.parametrize("cmd", ("--debug",))
-def test_debug(cmd: str, caplog):
+def test_debug(cmd: str):
-    command = ["fake.server.app", cmd]
+    command = ["sanic", "fake.server.app", cmd]
-    lines = capture(command, caplog)
+    out, err, exitcode = capture(command)
+    lines = out.split(b"\n")
     info = read_app_info(lines)
 
-    assert info["debug"] is True
+    assert info["debug"] is True, f"Lines found: {lines}\nErr output: {err}"
-    assert info["auto_reload"] is False
+    assert (
+        info["auto_reload"] is False
+    ), f"Lines found: {lines}\nErr output: {err}"
+    assert "dev" not in info, f"Lines found: {lines}\nErr output: {err}"
 
 
 @pytest.mark.parametrize("cmd", ("--dev", "-d"))
-def test_dev(cmd: str, caplog):
+def test_dev(cmd: str):
-    command = ["fake.server.app", cmd]
+    command = ["sanic", "fake.server.app", cmd]
-    lines = capture(command, caplog)
+    out, err, exitcode = capture(command)
+    lines = out.split(b"\n")
     info = read_app_info(lines)
 
-    assert info["debug"] is True
+    assert info["debug"] is True, f"Lines found: {lines}\nErr output: {err}"
-    assert info["auto_reload"] is True
+    assert (
+        info["auto_reload"] is True
+    ), f"Lines found: {lines}\nErr output: {err}"
 
 
 @pytest.mark.parametrize("cmd", ("--auto-reload", "-r"))
-def test_auto_reload(cmd: str, caplog):
+def test_auto_reload(cmd: str):
-    command = ["fake.server.app", cmd]
+    command = ["sanic", "fake.server.app", cmd]
-    lines = capture(command, caplog)
+    out, err, exitcode = capture(command)
+    lines = out.split(b"\n")
     info = read_app_info(lines)
 
-    assert info["debug"] is False
+    assert info["debug"] is False, f"Lines found: {lines}\nErr output: {err}"
-    assert info["auto_reload"] is True
+    assert (
+        info["auto_reload"] is True
+    ), f"Lines found: {lines}\nErr output: {err}"
+    assert "dev" not in info, f"Lines found: {lines}\nErr output: {err}"
 
 
 @pytest.mark.parametrize(
-    "cmd,expected",
+    "cmd,expected", (("--access-log", True), ("--no-access-log", False))
-    (
-        ("", False),
-        ("--debug", True),
-        ("--access-log", True),
-        ("--no-access-log", False),
-    ),
 )
-def test_access_logs(cmd: str, expected: bool, caplog):
+def test_access_logs(cmd: str, expected: bool):
-    command = ["fake.server.app"]
+    command = ["sanic", "fake.server.app", cmd]
-    if cmd:
+    out, err, exitcode = capture(command)
-        command.append(cmd)
+    lines = out.split(b"\n")
-    lines = capture(command, caplog)
     info = read_app_info(lines)
 
-    assert info["access_log"] is expected
+    assert (
+        info["access_log"] is expected
+    ), f"Lines found: {lines}\nErr output: {err}"
 
 
 @pytest.mark.parametrize("cmd", ("--version", "-v"))
-def test_version(cmd: str, caplog, capsys):
+def test_version(cmd: str):
-    command = [cmd]
+    command = ["sanic", cmd]
-    capture(command, caplog)
+    out, err, exitcode = capture(command)
     version_string = f"Sanic {__version__}; Routing {__routing_version__}\n"
-    out, _ = capsys.readouterr()
+
-    assert version_string == out
+    assert out == version_string.encode("utf-8")
 
 
 @pytest.mark.parametrize(
@@ -280,9 +315,12 @@ def test_version(cmd: str, caplog, capsys):
         ("--no-noisy-exceptions", False),
     ),
 )
-def test_noisy_exceptions(cmd: str, expected: bool, caplog):
+def test_noisy_exceptions(cmd: str, expected: bool):
-    command = ["fake.server.app", cmd]
+    command = ["sanic", "fake.server.app", cmd]
-    lines = capture(command, caplog)
+    out, err, exitcode = capture(command)
+    lines = out.split(b"\n")
     info = read_app_info(lines)
 
-    assert info["noisy_exceptions"] is expected
+    assert (
+        info["noisy_exceptions"] is expected
+    ), f"Lines found: {lines}\nErr output: {err}"

tests/test_config.py

@@ -125,9 +125,14 @@ def test_env_w_custom_converter():
 
 
 def test_env_lowercase():
-    environ["SANIC_test_answer"] = "42"
+    with pytest.warns(None) as record:
-    app = Sanic(name="Test")
+        environ["SANIC_test_answer"] = "42"
-    assert "test_answer" not in app.config
+        app = Sanic(name="Test")
+        assert app.config.test_answer == 42
+    assert str(record[0].message) == (
+        "[DEPRECATION v22.9] Lowercase environment variables will not be "
+        "loaded into Sanic config beginning in v22.9."
+    )
     del environ["SANIC_test_answer"]
 
 
@@ -288,21 +293,26 @@ def test_config_custom_defaults_with_env():
         del environ[key]
 
 
-@pytest.mark.parametrize("access_log", (True, False))
+def test_config_access_log_passing_in_run(app: Sanic):
-def test_config_access_log_passing_in_run(app: Sanic, access_log):
+    assert app.config.ACCESS_LOG is True
-    assert app.config.ACCESS_LOG is False
 
     @app.listener("after_server_start")
     async def _request(sanic, loop):
         app.stop()
 
-    app.run(port=1340, access_log=access_log, single_process=True)
+    app.run(port=1340, access_log=False)
-    assert app.config.ACCESS_LOG is access_log
+    assert app.config.ACCESS_LOG is False
+
+    app.router.reset()
+    app.signal_router.reset()
+
+    app.run(port=1340, access_log=True)
+    assert app.config.ACCESS_LOG is True
 
 
 @pytest.mark.asyncio
 async def test_config_access_log_passing_in_create_server(app: Sanic):
-    assert app.config.ACCESS_LOG is False
+    assert app.config.ACCESS_LOG is True
 
     @app.listener("after_server_start")
     async def _request(sanic, loop):

tests/test_constants.py

@@ -1,24 +1,15 @@
-import pytest
-
 from sanic import Sanic, text
-from sanic.application.constants import Mode, Server, ServerStage
 from sanic.constants import HTTP_METHODS, HTTPMethod
 
 
-@pytest.mark.parametrize("enum", (HTTPMethod, Server, Mode))
+def test_string_compat():
-def test_string_compat(enum):
+    assert "GET" == HTTPMethod.GET
-    for key in enum.__members__.keys():
+    assert "GET" in HTTP_METHODS
-        assert key.upper() == getattr(enum, key).upper()
+    assert "get" == HTTPMethod.GET
-        assert key.lower() == getattr(enum, key).lower()
+    assert "get" in HTTP_METHODS
 
-
+    assert HTTPMethod.GET.lower() == "get"
-def test_http_methods():
+    assert HTTPMethod.GET.upper() == "GET"
-    for value in HTTPMethod.__members__.values():
-        assert value in HTTP_METHODS
-
-
-def test_server_stage():
-    assert ServerStage.SERVING > ServerStage.PARTIAL > ServerStage.STOPPED
 
 
 def test_use_in_routes(app: Sanic):

tests/test_deprecation.py

@@ -1,6 +1,5 @@
 import pytest
 
-from sanic import Sanic
 from sanic.log import deprecation
 
 
@@ -8,13 +7,3 @@ def test_deprecation():
     message = r"\[DEPRECATION v9\.9\] hello"
     with pytest.warns(DeprecationWarning, match=message):
         deprecation("hello", 9.9)
-
-
-@pytest.mark.parametrize(
-    "filter,expected",
-    (("default", 1), ("once", 1), ("ignore", 0)),
-)
-def test_deprecation_filter(app: Sanic, filter, expected, recwarn):
-    app.config.DEPRECATION_FILTER = filter
-    deprecation("hello", 9.9)
-    assert len(recwarn) == expected

tests/test_dynamic_routes.py

@@ -1,44 +1,44 @@
-import pytest
+# import pytest
 
-from sanic_routing.exceptions import RouteExists
+# from sanic.response import text
-
+# from sanic.router import RouteExists
-from sanic.response import text
 
 
-@pytest.mark.parametrize(
+# @pytest.mark.parametrize(
-    "method,attr, expected",
+#     "method,attr, expected",
-    [
+#     [
-        ("get", "text", "OK1 test"),
+#         ("get", "text", "OK1 test"),
-        ("post", "text", "OK2 test"),
+#         ("post", "text", "OK2 test"),
-        ("put", "text", "OK2 test"),
+#         ("put", "text", "OK2 test"),
-    ],
+#         ("delete", "status", 405),
-)
+#     ],
-def test_overload_dynamic_routes(app, method, attr, expected):
+# )
-    @app.route("/overload/<param>", methods=["GET"])
+# def test_overload_dynamic_routes(app, method, attr, expected):
-    async def handler1(request, param):
+#     @app.route("/overload/<param>", methods=["GET"])
-        return text("OK1 " + param)
+#     async def handler1(request, param):
+#         return text("OK1 " + param)
 
-    @app.route("/overload/<param>", methods=["POST", "PUT"])
+#     @app.route("/overload/<param>", methods=["POST", "PUT"])
-    async def handler2(request, param):
+#     async def handler2(request, param):
-        return text("OK2 " + param)
+#         return text("OK2 " + param)
 
-    request, response = getattr(app.test_client, method)("/overload/test")
+#     request, response = getattr(app.test_client, method)("/overload/test")
-    assert getattr(response, attr) == expected
+#     assert getattr(response, attr) == expected
 
 
-def test_overload_dynamic_routes_exist(app):
+# def test_overload_dynamic_routes_exist(app):
-    @app.route("/overload/<param>", methods=["GET"])
+#     @app.route("/overload/<param>", methods=["GET"])
-    async def handler1(request, param):
+#     async def handler1(request, param):
-        return text("OK1 " + param)
+#         return text("OK1 " + param)
 
-    @app.route("/overload/<param>", methods=["POST", "PUT"])
+#     @app.route("/overload/<param>", methods=["POST", "PUT"])
-    async def handler2(request, param):
+#     async def handler2(request, param):
-        return text("OK2 " + param)
+#         return text("OK2 " + param)
 
-    # if this doesn't raise an error, than at least the below should happen:
+#     # if this doesn't raise an error, than at least the below should happen:
-    # assert response.text == 'Duplicated'
+#     # assert response.text == 'Duplicated'
-    with pytest.raises(RouteExists):
+#     with pytest.raises(RouteExists):
 
-        @app.route("/overload/<param>", methods=["PUT", "DELETE"])
+#         @app.route("/overload/<param>", methods=["PUT", "DELETE"])
-        async def handler3(request, param):
+#         async def handler3(request, param):
-            return text("Duplicated")
+#             return text("Duplicated")

tests/test_errorpages.py

@@ -97,15 +97,15 @@ def test_auto_fallback_with_content_type(app):
 def test_route_error_format_set_on_auto(app):
     @app.get("/text")
     def text_response(request):
-        return text(request.route.extra.error_format)
+        return text(request.route.ctx.error_format)
 
     @app.get("/json")
     def json_response(request):
-        return json({"format": request.route.extra.error_format})
+        return json({"format": request.route.ctx.error_format})
 
     @app.get("/html")
     def html_response(request):
-        return html(request.route.extra.error_format)
+        return html(request.route.ctx.error_format)
 
     _, response = app.test_client.get("/text")
     assert response.text == "text"
@@ -353,7 +353,7 @@ def test_config_fallback_before_and_after_startup(app):
 
     _, response = app.test_client.get("/error")
     assert response.status == 500
-    assert response.content_type == "application/json"
+    assert response.content_type == "text/plain; charset=utf-8"
 
 
 def test_config_fallback_using_update_dict(app):

tests/test_exceptions_handler.py

@@ -7,7 +7,7 @@ from unittest.mock import Mock
 import pytest
 
 from bs4 import BeautifulSoup
-from pytest import LogCaptureFixture, MonkeyPatch, WarningsRecorder
+from pytest import LogCaptureFixture, MonkeyPatch
 
 from sanic import Sanic, handlers
 from sanic.exceptions import BadRequest, Forbidden, NotFound, ServerError
@@ -266,22 +266,3 @@ def test_exception_handler_response_was_sent(
 
     _, response = app.test_client.get("/2")
     assert "Error" in response.text
-
-
-def test_warn_on_duplicate(
-    app: Sanic, caplog: LogCaptureFixture, recwarn: WarningsRecorder
-):
-    @app.exception(ServerError)
-    async def exception_handler_1(request, exception):
-        ...
-
-    @app.exception(ServerError)
-    async def exception_handler_2(request, exception):
-        ...
-
-    assert len(caplog.records) == 1
-    assert len(recwarn) == 1
-    assert caplog.records[0].message == (
-        "Duplicate exception handler definition on: route=__ALL_ROUTES__ and "
-        "exception=<class 'sanic.exceptions.ServerError'>"
-    )

tests/test_ext_integration.py

@@ -25,19 +25,19 @@ def stoppable_app(app):
 
 
 def test_ext_is_loaded(stoppable_app: Sanic, sanic_ext):
-    stoppable_app.run(single_process=True)
+    stoppable_app.run()
     sanic_ext.Extend.assert_called_once_with(stoppable_app)
 
 
 def test_ext_is_not_loaded(stoppable_app: Sanic, sanic_ext):
     stoppable_app.config.AUTO_EXTEND = False
-    stoppable_app.run(single_process=True)
+    stoppable_app.run()
     sanic_ext.Extend.assert_not_called()
 
 
 def test_extend_with_args(stoppable_app: Sanic, sanic_ext):
     stoppable_app.extend(built_in_extensions=False)
-    stoppable_app.run(single_process=True)
+    stoppable_app.run()
     sanic_ext.Extend.assert_called_once_with(
         stoppable_app, built_in_extensions=False, config=None, extensions=None
     )
@@ -80,5 +80,5 @@ def test_can_access_app_ext_while_running(app: Sanic, sanic_ext, ext_instance):
         app.ext.injection(IceCream)
         app.stop()
 
-    app.run(single_process=True)
+    app.run()
     ext_instance.injection.assert_called_with(IceCream)

tests/test_graceful_shutdown.py

@@ -1,61 +1,48 @@
 import asyncio
 import logging
+import time
 
-from pytest import LogCaptureFixture
+from multiprocessing import Process
 
-from sanic.response import empty
+import httpx
 
 
 PORT = 42101
 
 
-def test_no_exceptions_when_cancel_pending_request(
+def test_no_exceptions_when_cancel_pending_request(app, caplog):
-    app, caplog: LogCaptureFixture
-):
     app.config.GRACEFUL_SHUTDOWN_TIMEOUT = 1
 
     @app.get("/")
     async def handler(request):
         await asyncio.sleep(5)
 
-    @app.listener("after_server_start")
+    @app.after_server_start
-    async def _request(sanic, loop):
+    def shutdown(app, _):
-        connect = asyncio.open_connection("127.0.0.1", 8000)
+        time.sleep(0.2)
-        _, writer = await connect
-        writer.write(b"GET / HTTP/1.1\r\n\r\n")
         app.stop()
 
-    with caplog.at_level(logging.INFO):
+    def ping():
-        app.run(single_process=True, access_log=True)
+        time.sleep(0.1)
+        response = httpx.get("http://127.0.0.1:8000")
+        print(response.status_code)
 
-    assert "Request: GET http:/// stopped. Transport is closed." in caplog.text
+    p = Process(target=ping)
-
+    p.start()
-
-def test_completes_request(app, caplog: LogCaptureFixture):
-    app.config.GRACEFUL_SHUTDOWN_TIMEOUT = 1
-
-    @app.get("/")
-    async def handler(request):
-        await asyncio.sleep(0.5)
-        return empty()
-
-    @app.listener("after_server_start")
-    async def _request(sanic, loop):
-        connect = asyncio.open_connection("127.0.0.1", 8000)
-        _, writer = await connect
-        writer.write(b"GET / HTTP/1.1\r\n\r\n")
-        app.stop()
 
     with caplog.at_level(logging.INFO):
-        app.run(single_process=True, access_log=True)
+        app.run()
 
-    assert ("sanic.access", 20, "") in caplog.record_tuples
+    p.kill()
 
-    # Make sure that the server starts shutdown process before access log
+    info = 0
-    index_stopping = 0
+    for record in caplog.record_tuples:
-    for idx, record in enumerate(caplog.records):
+        assert record[1] != logging.ERROR
-        if record.message.startswith("Stopping worker"):
+        if record[1] == logging.INFO:
-            index_stopping = idx
+            info += 1
-            break
+        if record[2].startswith("Request:"):
-    index_request = caplog.record_tuples.index(("sanic.access", 20, ""))
+            assert record[2] == (
-    assert index_request > index_stopping > 0
+                "Request: GET http://127.0.0.1:8000/ stopped. "
+                "Transport is closed."
+            )
+    assert info == 11

tests/test_handler.py

@@ -1,36 +0,0 @@
-from sanic.app import Sanic
-from sanic.response import empty
-from sanic.signals import Event
-
-
-def test_handler_operation_order(app: Sanic):
-    operations = []
-
-    @app.on_request
-    async def on_request(_):
-        nonlocal operations
-        operations.append(1)
-
-    @app.on_response
-    async def on_response(*_):
-        nonlocal operations
-        operations.append(5)
-
-    @app.get("/")
-    async def handler(_):
-        nonlocal operations
-        operations.append(3)
-        return empty()
-
-    @app.signal(Event.HTTP_HANDLER_BEFORE)
-    async def handler_before(**_):
-        nonlocal operations
-        operations.append(2)
-
-    @app.signal(Event.HTTP_HANDLER_AFTER)
-    async def handler_after(**_):
-        nonlocal operations
-        operations.append(4)
-
-    app.test_client.get("/")
-    assert operations == [1, 2, 3, 4, 5]

tests/test_http.py

@@ -36,7 +36,7 @@ def test_app(app: Sanic):
 
 
 @pytest.fixture
-def runner(test_app: Sanic):
+def runner(test_app):
     client = ReusableClient(test_app, port=PORT)
     client.run()
     yield client
@@ -44,7 +44,7 @@ def runner(test_app: Sanic):
 
 
 @pytest.fixture
-def client(runner: ReusableClient):
+def client(runner):
     client = namedtuple("Client", ("raw", "send", "recv"))
 
     raw = RawClient(runner.host, runner.port)

tests/test_http_alt_svc.py

@@ -61,6 +61,6 @@ def test_http1_response_has_alt_svc():
         version=1,
         port=PORT,
     )
-    Sanic.serve_single(app)
+    Sanic.serve()
 
     assert f'alt-svc: h3=":{PORT}"\r\n'.encode() in response

tests/test_init.py

@@ -1,25 +0,0 @@
-from importlib import import_module
-
-import pytest
-
-
-@pytest.mark.parametrize(
-    "item",
-    (
-        "__version__",
-        "Sanic",
-        "Blueprint",
-        "HTTPMethod",
-        "HTTPResponse",
-        "Request",
-        "Websocket",
-        "empty",
-        "file",
-        "html",
-        "json",
-        "redirect",
-        "text",
-    ),
-)
-def test_imports(item):
-    import_module("sanic", item)

tests/test_json_encoding.py

@@ -3,27 +3,18 @@ import sys
 from dataclasses import asdict, dataclass
 from functools import partial
 from json import dumps as sdumps
-from string import ascii_lowercase
-from typing import Dict
 
 import pytest
 
 
 try:
-    import ujson
-
     from ujson import dumps as udumps
 
-    ujson_version = tuple(
-        map(int, ujson.__version__.strip(ascii_lowercase).split("."))
-    )
-
     NO_UJSON = False
     DEFAULT_DUMPS = udumps
 except ModuleNotFoundError:
     NO_UJSON = True
     DEFAULT_DUMPS = partial(sdumps, separators=(",", ":"))
-    ujson_version = None
 
 from sanic import Sanic
 from sanic.response import BaseHTTPResponse, json
@@ -43,7 +34,7 @@ def foo():
 
 
 @pytest.fixture
-def payload(foo: Foo):
+def payload(foo):
     return {"foo": foo}
 
 
@@ -67,7 +58,7 @@ def test_change_encoder_to_some_custom():
 
 
 @pytest.mark.skipif(NO_UJSON is True, reason="ujson not installed")
-def test_json_response_ujson(payload: Dict[str, Foo]):
+def test_json_response_ujson(payload):
     """ujson will look at __json__"""
     response = json(payload)
     assert response.body == b'{"foo":{"bar":"bar"}}'
@@ -84,13 +75,7 @@ def test_json_response_ujson(payload: Dict[str, Foo]):
         json(payload)
 
 
-@pytest.mark.skipif(
+@pytest.mark.skipif(NO_UJSON is True, reason="ujson not installed")
-    NO_UJSON is True or ujson_version >= (5, 4, 0),
-    reason=(
-        "ujson not installed or version is 5.4.0 or newer, "
-        "which can handle arbitrary size integers"
-    ),
-)
 def test_json_response_json():
     """One of the easiest ways to tell the difference is that ujson cannot
     serialize over 64 bits"""

tests/test_logging.py

@@ -166,7 +166,6 @@ def test_access_log_client_ip_remote_addr(monkeypatch):
     monkeypatch.setattr(sanic.http.http1, "access_logger", access)
 
     app = Sanic("test_logging")
-    app.config.ACCESS_LOG = True
     app.config.PROXIES_COUNT = 2
 
     @app.route("/")
@@ -194,7 +193,6 @@ def test_access_log_client_ip_reqip(monkeypatch):
     monkeypatch.setattr(sanic.http.http1, "access_logger", access)
 
     app = Sanic("test_logging")
-    app.config.ACCESS_LOG = True
 
     @app.route("/")
     async def handler(request):

tests/test_logo.py

@@ -30,12 +30,9 @@ def test_get_logo_returns_expected_logo(tty, full, expected):
 
 
 def test_get_logo_returns_no_colors_on_apple_terminal():
-    platform = sys.platform
-    sys.platform = "darwin"
-    os.environ["TERM_PROGRAM"] = "Apple_Terminal"
     with patch("sys.stdout.isatty") as isatty:
         isatty.return_value = False
+        sys.platform = "darwin"
+        os.environ["TERM_PROGRAM"] = "Apple_Terminal"
         logo = get_logo()
     assert "\033" not in logo
-    sys.platform = platform
-    del os.environ["TERM_PROGRAM"]

tests/test_middleware.py

@@ -166,7 +166,7 @@ def test_middleware_response_raise_cancelled_error(app, caplog):
     with caplog.at_level(logging.ERROR):
         reqrequest, response = app.test_client.get("/")
 
-        assert response.status == 500
+        assert response.status == 503
         assert (
             "sanic.error",
             logging.ERROR,

tests/test_middleware_priority.py

@@ -1,90 +0,0 @@
-from functools import partial
-
-import pytest
-
-from sanic import Sanic
-from sanic.middleware import Middleware
-from sanic.response import json
-
-
-PRIORITY_TEST_CASES = (
-    ([0, 1, 2], [1, 1, 1]),
-    ([0, 1, 2], [1, 1, None]),
-    ([0, 1, 2], [1, None, None]),
-    ([0, 1, 2], [2, 1, None]),
-    ([0, 1, 2], [2, 2, None]),
-    ([0, 1, 2], [3, 2, 1]),
-    ([0, 1, 2], [None, None, None]),
-    ([0, 2, 1], [1, None, 1]),
-    ([0, 2, 1], [2, None, 1]),
-    ([0, 2, 1], [2, None, 2]),
-    ([0, 2, 1], [3, 1, 2]),
-    ([1, 0, 2], [1, 2, None]),
-    ([1, 0, 2], [2, 3, 1]),
-    ([1, 0, 2], [None, 1, None]),
-    ([1, 2, 0], [1, 3, 2]),
-    ([1, 2, 0], [None, 1, 1]),
-    ([1, 2, 0], [None, 2, 1]),
-    ([1, 2, 0], [None, 2, 2]),
-    ([2, 0, 1], [1, None, 2]),
-    ([2, 0, 1], [2, 1, 3]),
-    ([2, 0, 1], [None, None, 1]),
-    ([2, 1, 0], [1, 2, 3]),
-    ([2, 1, 0], [None, 1, 2]),
-)
-
-
-@pytest.fixture(autouse=True)
-def reset_middleware():
-    yield
-    Middleware.reset_count()
-
-
-@pytest.mark.parametrize(
-    "expected,priorities",
-    PRIORITY_TEST_CASES,
-)
-def test_request_middleware_order_priority(app: Sanic, expected, priorities):
-    order = []
-
-    def add_ident(request, ident):
-        order.append(ident)
-
-    @app.get("/")
-    def handler(request):
-        return json(None)
-
-    for ident, priority in enumerate(priorities):
-        kwargs = {}
-        if priority is not None:
-            kwargs["priority"] = priority
-        app.on_request(partial(add_ident, ident=ident), **kwargs)
-
-    app.test_client.get("/")
-
-    assert order == expected
-
-
-@pytest.mark.parametrize(
-    "expected,priorities",
-    PRIORITY_TEST_CASES,
-)
-def test_response_middleware_order_priority(app: Sanic, expected, priorities):
-    order = []
-
-    def add_ident(request, response, ident):
-        order.append(ident)
-
-    @app.get("/")
-    def handler(request):
-        return json(None)
-
-    for ident, priority in enumerate(priorities):
-        kwargs = {}
-        if priority is not None:
-            kwargs["priority"] = priority
-        app.on_response(partial(add_ident, ident=ident), **kwargs)
-
-    app.test_client.get("/")
-
-    assert order[::-1] == expected

tests/test_motd.py

@@ -3,23 +3,15 @@ import os
 import platform
 import sys
 
-from unittest.mock import Mock, patch
+from unittest.mock import Mock
 
 import pytest
 
-from sanic import __version__
+from sanic import Sanic, __version__
 from sanic.application.logo import BASE_LOGO
 from sanic.application.motd import MOTD, MOTDTTY
 
 
-@pytest.fixture(autouse=True)
-def reset():
-    try:
-        del os.environ["SANIC_MOTD_OUTPUT"]
-    except KeyError:
-        ...
-
-
 def test_logo_base(app, run_startup):
     logs = run_startup(app)
 
@@ -71,13 +63,20 @@ def test_motd_display(caplog):
 @pytest.mark.skipif(sys.version_info < (3, 8), reason="Not on 3.7")
 def test_reload_dirs(app):
     app.config.LOGO = None
-    app.config.MOTD = True
     app.config.AUTO_RELOAD = True
+    app.prepare(reload_dir="./", auto_reload=True, motd_display={"foo": "bar"})
 
-    with patch.object(MOTD, "output") as mock:
+    existing = MOTD.output
-        app.prepare(
+    MOTD.output = Mock()
-            reload_dir="./", auto_reload=True, motd_display={"foo": "bar"}
+
-        )
+    app.motd("foo")
-    mock.assert_called()
+
-    assert mock.call_args.args[2]["auto-reload"] == f"enabled, {os.getcwd()}"
+    MOTD.output.assert_called_once()
-    assert mock.call_args.args[3] == {"foo": "bar"}
+    assert (
+        MOTD.output.call_args.args[2]["auto-reload"]
+        == f"enabled, {os.getcwd()}"
+    )
+    assert MOTD.output.call_args.args[3] == {"foo": "bar"}
+
+    MOTD.output = existing
+    Sanic._app_registry = {}

tests/test_multi_serve.py

@@ -1,207 +1,207 @@
-# import logging
+import logging
 
-# from unittest.mock import Mock
+from unittest.mock import Mock
 
-# import pytest
+import pytest
 
-# from sanic import Sanic
+from sanic import Sanic
-# from sanic.response import text
+from sanic.response import text
-# from sanic.server.async_server import AsyncioServer
+from sanic.server.async_server import AsyncioServer
-# from sanic.signals import Event
+from sanic.signals import Event
-# from sanic.touchup.schemes.ode import OptionalDispatchEvent
+from sanic.touchup.schemes.ode import OptionalDispatchEvent
 
 
-# try:
+try:
-#     from unittest.mock import AsyncMock
+    from unittest.mock import AsyncMock
-# except ImportError:
+except ImportError:
-#     from tests.asyncmock import AsyncMock  # type: ignore
+    from tests.asyncmock import AsyncMock  # type: ignore
 
 
-# @pytest.fixture
+@pytest.fixture
-# def app_one():
+def app_one():
-#     app = Sanic("One")
+    app = Sanic("One")
 
-#     @app.get("/one")
+    @app.get("/one")
-#     async def one(request):
+    async def one(request):
-#         return text("one")
+        return text("one")
 
-#     return app
+    return app
 
 
-# @pytest.fixture
+@pytest.fixture
-# def app_two():
+def app_two():
-#     app = Sanic("Two")
+    app = Sanic("Two")
 
-#     @app.get("/two")
+    @app.get("/two")
-#     async def two(request):
+    async def two(request):
-#         return text("two")
+        return text("two")
 
-#     return app
+    return app
 
 
-# @pytest.fixture(autouse=True)
+@pytest.fixture(autouse=True)
-# def clean():
+def clean():
-#     Sanic._app_registry = {}
+    Sanic._app_registry = {}
-#     yield
+    yield
 
 
-# def test_serve_same_app_multiple_tuples(app_one, run_multi):
+def test_serve_same_app_multiple_tuples(app_one, run_multi):
-#     app_one.prepare(port=23456)
+    app_one.prepare(port=23456)
-#     app_one.prepare(port=23457)
+    app_one.prepare(port=23457)
 
-#     logs = run_multi(app_one)
+    logs = run_multi(app_one)
-#     assert (
+    assert (
-#         "sanic.root",
+        "sanic.root",
-#         logging.INFO,
+        logging.INFO,
-#         "Goin' Fast @ http://127.0.0.1:23456",
+        "Goin' Fast @ http://127.0.0.1:23456",
-#     ) in logs
+    ) in logs
-#     assert (
+    assert (
-#         "sanic.root",
+        "sanic.root",
-#         logging.INFO,
+        logging.INFO,
-#         "Goin' Fast @ http://127.0.0.1:23457",
+        "Goin' Fast @ http://127.0.0.1:23457",
-#     ) in logs
+    ) in logs
 
 
-# def test_serve_multiple_apps(app_one, app_two, run_multi):
+def test_serve_multiple_apps(app_one, app_two, run_multi):
-#     app_one.prepare(port=23456)
+    app_one.prepare(port=23456)
-#     app_two.prepare(port=23457)
+    app_two.prepare(port=23457)
 
-#     logs = run_multi(app_one)
+    logs = run_multi(app_one)
-#     assert (
+    assert (
-#         "sanic.root",
+        "sanic.root",
-#         logging.INFO,
+        logging.INFO,
-#         "Goin' Fast @ http://127.0.0.1:23456",
+        "Goin' Fast @ http://127.0.0.1:23456",
-#     ) in logs
+    ) in logs
-#     assert (
+    assert (
-#         "sanic.root",
+        "sanic.root",
-#         logging.INFO,
+        logging.INFO,
-#         "Goin' Fast @ http://127.0.0.1:23457",
+        "Goin' Fast @ http://127.0.0.1:23457",
-#     ) in logs
+    ) in logs
 
 
-# def test_listeners_on_secondary_app(app_one, app_two, run_multi):
+def test_listeners_on_secondary_app(app_one, app_two, run_multi):
-#     app_one.prepare(port=23456)
+    app_one.prepare(port=23456)
-#     app_two.prepare(port=23457)
+    app_two.prepare(port=23457)
 
-#     before_start = AsyncMock()
+    before_start = AsyncMock()
-#     after_start = AsyncMock()
+    after_start = AsyncMock()
-#     before_stop = AsyncMock()
+    before_stop = AsyncMock()
-#     after_stop = AsyncMock()
+    after_stop = AsyncMock()
 
-#     app_two.before_server_start(before_start)
+    app_two.before_server_start(before_start)
-#     app_two.after_server_start(after_start)
+    app_two.after_server_start(after_start)
-#     app_two.before_server_stop(before_stop)
+    app_two.before_server_stop(before_stop)
-#     app_two.after_server_stop(after_stop)
+    app_two.after_server_stop(after_stop)
 
-#     run_multi(app_one)
+    run_multi(app_one)
 
-#     before_start.assert_awaited_once()
+    before_start.assert_awaited_once()
-#     after_start.assert_awaited_once()
+    after_start.assert_awaited_once()
-#     before_stop.assert_awaited_once()
+    before_stop.assert_awaited_once()
-#     after_stop.assert_awaited_once()
+    after_stop.assert_awaited_once()
 
 
-# @pytest.mark.parametrize(
+@pytest.mark.parametrize(
-#     "events",
+    "events",
-#     (
+    (
-#         (Event.HTTP_LIFECYCLE_BEGIN,),
+        (Event.HTTP_LIFECYCLE_BEGIN,),
-#         (Event.HTTP_LIFECYCLE_BEGIN, Event.HTTP_LIFECYCLE_COMPLETE),
+        (Event.HTTP_LIFECYCLE_BEGIN, Event.HTTP_LIFECYCLE_COMPLETE),
-#         (
+        (
-#             Event.HTTP_LIFECYCLE_BEGIN,
+            Event.HTTP_LIFECYCLE_BEGIN,
-#             Event.HTTP_LIFECYCLE_COMPLETE,
+            Event.HTTP_LIFECYCLE_COMPLETE,
-#             Event.HTTP_LIFECYCLE_REQUEST,
+            Event.HTTP_LIFECYCLE_REQUEST,
-#         ),
+        ),
-#     ),
+    ),
-# )
+)
-# def test_signal_synchronization(app_one, app_two, run_multi, events):
+def test_signal_synchronization(app_one, app_two, run_multi, events):
-#     app_one.prepare(port=23456)
+    app_one.prepare(port=23456)
-#     app_two.prepare(port=23457)
+    app_two.prepare(port=23457)
 
-#     for event in events:
+    for event in events:
-#         app_one.signal(event)(AsyncMock())
+        app_one.signal(event)(AsyncMock())
 
-#     run_multi(app_one)
+    run_multi(app_one)
 
-#     assert len(app_two.signal_router.routes) == len(events) + 1
+    assert len(app_two.signal_router.routes) == len(events) + 1
 
-#     signal_handlers = {
+    signal_handlers = {
-#         signal.handler
+        signal.handler
-#         for signal in app_two.signal_router.routes
+        for signal in app_two.signal_router.routes
-#         if signal.name.startswith("http")
+        if signal.name.startswith("http")
-#     }
+    }
 
-#     assert len(signal_handlers) == 1
+    assert len(signal_handlers) == 1
-#     assert list(signal_handlers)[0] is OptionalDispatchEvent.noop
+    assert list(signal_handlers)[0] is OptionalDispatchEvent.noop
 
 
-# def test_warning_main_process_listeners_on_secondary(
+def test_warning_main_process_listeners_on_secondary(
-#     app_one, app_two, run_multi
+    app_one, app_two, run_multi
-# ):
+):
-#     app_two.main_process_start(AsyncMock())
+    app_two.main_process_start(AsyncMock())
-#     app_two.main_process_stop(AsyncMock())
+    app_two.main_process_stop(AsyncMock())
-#     app_one.prepare(port=23456)
+    app_one.prepare(port=23456)
-#     app_two.prepare(port=23457)
+    app_two.prepare(port=23457)
 
-#     log = run_multi(app_one)
+    log = run_multi(app_one)
 
-#     message = (
+    message = (
-#         f"Sanic found 2 listener(s) on "
+        f"Sanic found 2 listener(s) on "
-#         "secondary applications attached to the main "
+        "secondary applications attached to the main "
-#         "process. These will be ignored since main "
+        "process. These will be ignored since main "
-#         "process listeners can only be attached to your "
+        "process listeners can only be attached to your "
-#         "primary application: "
+        "primary application: "
-#         f"{repr(app_one)}"
+        f"{repr(app_one)}"
-#     )
+    )
 
-#     assert ("sanic.error", logging.WARNING, message) in log
+    assert ("sanic.error", logging.WARNING, message) in log
 
 
-# def test_no_applications():
+def test_no_applications():
-#     Sanic._app_registry = {}
+    Sanic._app_registry = {}
-#     message = "Did not find any applications."
+    message = "Did not find any applications."
-#     with pytest.raises(RuntimeError, match=message):
+    with pytest.raises(RuntimeError, match=message):
-#         Sanic.serve()
+        Sanic.serve()
 
 
-# def test_oserror_warning(app_one, app_two, run_multi, capfd):
+def test_oserror_warning(app_one, app_two, run_multi, capfd):
-#     orig = AsyncioServer.__await__
+    orig = AsyncioServer.__await__
-#     AsyncioServer.__await__ = Mock(side_effect=OSError("foo"))
+    AsyncioServer.__await__ = Mock(side_effect=OSError("foo"))
-#     app_one.prepare(port=23456, workers=2)
+    app_one.prepare(port=23456, workers=2)
-#     app_two.prepare(port=23457, workers=2)
+    app_two.prepare(port=23457, workers=2)
 
-#     run_multi(app_one)
+    run_multi(app_one)
 
-#     captured = capfd.readouterr()
+    captured = capfd.readouterr()
-#     assert (
+    assert (
-#         "An OSError was detected on startup. The encountered error was: foo"
+        "An OSError was detected on startup. The encountered error was: foo"
-#     ) in captured.err
+    ) in captured.err
 
-#     AsyncioServer.__await__ = orig
+    AsyncioServer.__await__ = orig
 
 
-# def test_running_multiple_offset_warning(app_one, app_two, run_multi, capfd):
+def test_running_multiple_offset_warning(app_one, app_two, run_multi, capfd):
-#     app_one.prepare(port=23456, workers=2)
+    app_one.prepare(port=23456, workers=2)
-#     app_two.prepare(port=23457)
+    app_two.prepare(port=23457)
 
-#     run_multi(app_one)
+    run_multi(app_one)
 
-#     captured = capfd.readouterr()
+    captured = capfd.readouterr()
-#     assert (
+    assert (
-#         f"The primary application {repr(app_one)} is running "
+        f"The primary application {repr(app_one)} is running "
-#         "with 2 worker(s). All "
+        "with 2 worker(s). All "
-#         "application instances will run with the same number. "
+        "application instances will run with the same number. "
-#         f"You requested {repr(app_two)} to run with "
+        f"You requested {repr(app_two)} to run with "
-#         "1 worker(s), which will be ignored "
+        "1 worker(s), which will be ignored "
-#         "in favor of the primary application."
+        "in favor of the primary application."
-#     ) in captured.err
+    ) in captured.err
 
 
-# def test_running_multiple_secondary(app_one, app_two, run_multi, capfd):
+def test_running_multiple_secondary(app_one, app_two, run_multi, capfd):
-#     app_one.prepare(port=23456, workers=2)
+    app_one.prepare(port=23456, workers=2)
-#     app_two.prepare(port=23457)
+    app_two.prepare(port=23457)
 
-#     before_start = AsyncMock()
+    before_start = AsyncMock()
-#     app_two.before_server_start(before_start)
+    app_two.before_server_start(before_start)
-#     run_multi(app_one)
+    run_multi(app_one)
 
-#     before_start.await_count == 2
+    before_start.await_count == 2

tests/test_multiprocessing.py

@@ -4,15 +4,13 @@ import pickle
 import random
 import signal
 
-from asyncio import sleep
-
 import pytest
 
 from sanic_testing.testing import HOST, PORT
 
-from sanic import Blueprint, text
+from sanic import Blueprint
 from sanic.log import logger
-from sanic.server.socket import configure_socket
+from sanic.response import text
 
 
 @pytest.mark.skipif(
@@ -26,108 +24,14 @@ def test_multiprocessing(app):
     num_workers = random.choice(range(2, multiprocessing.cpu_count() * 2 + 1))
     process_list = set()
 
-    @app.after_server_start
-    async def shutdown(app):
-        await sleep(2.1)
-        app.stop()
-
     def stop_on_alarm(*args):
         for process in multiprocessing.active_children():
             process_list.add(process.pid)
+            process.terminate()
 
     signal.signal(signal.SIGALRM, stop_on_alarm)
-    signal.alarm(2)
+    signal.alarm(3)
-    app.run(HOST, 4120, workers=num_workers, debug=True)
+    app.run(HOST, PORT, workers=num_workers)
-
-    assert len(process_list) == num_workers + 1
-
-
-@pytest.mark.skipif(
-    not hasattr(signal, "SIGALRM"),
-    reason="SIGALRM is not implemented for this platform, we have to come "
-    "up with another timeout strategy to test these",
-)
-def test_multiprocessing_legacy(app):
-    """Tests that the number of children we produce is correct"""
-    # Selects a number at random so we can spot check
-    num_workers = random.choice(range(2, multiprocessing.cpu_count() * 2 + 1))
-    process_list = set()
-
-    @app.after_server_start
-    async def shutdown(app):
-        await sleep(2.1)
-        app.stop()
-
-    def stop_on_alarm(*args):
-        for process in multiprocessing.active_children():
-            process_list.add(process.pid)
-
-    signal.signal(signal.SIGALRM, stop_on_alarm)
-    signal.alarm(2)
-    app.run(HOST, 4121, workers=num_workers, debug=True, legacy=True)
-
-    assert len(process_list) == num_workers
-
-
-@pytest.mark.skipif(
-    not hasattr(signal, "SIGALRM"),
-    reason="SIGALRM is not implemented for this platform, we have to come "
-    "up with another timeout strategy to test these",
-)
-def test_multiprocessing_legacy_sock(app):
-    """Tests that the number of children we produce is correct"""
-    # Selects a number at random so we can spot check
-    num_workers = random.choice(range(2, multiprocessing.cpu_count() * 2 + 1))
-    process_list = set()
-
-    @app.after_server_start
-    async def shutdown(app):
-        await sleep(2.1)
-        app.stop()
-
-    def stop_on_alarm(*args):
-        for process in multiprocessing.active_children():
-            process_list.add(process.pid)
-
-    signal.signal(signal.SIGALRM, stop_on_alarm)
-    signal.alarm(2)
-    sock = configure_socket(
-        {
-            "host": HOST,
-            "port": 4121,
-            "unix": None,
-            "backlog": 100,
-        }
-    )
-    app.run(workers=num_workers, debug=True, legacy=True, sock=sock)
-    sock.close()
-
-    assert len(process_list) == num_workers
-
-
-@pytest.mark.skipif(
-    not hasattr(signal, "SIGALRM"),
-    reason="SIGALRM is not implemented for this platform, we have to come "
-    "up with another timeout strategy to test these",
-)
-def test_multiprocessing_legacy_unix(app):
-    """Tests that the number of children we produce is correct"""
-    # Selects a number at random so we can spot check
-    num_workers = random.choice(range(2, multiprocessing.cpu_count() * 2 + 1))
-    process_list = set()
-
-    @app.after_server_start
-    async def shutdown(app):
-        await sleep(2.1)
-        app.stop()
-
-    def stop_on_alarm(*args):
-        for process in multiprocessing.active_children():
-            process_list.add(process.pid)
-
-    signal.signal(signal.SIGALRM, stop_on_alarm)
-    signal.alarm(2)
-    app.run(workers=num_workers, debug=True, legacy=True, unix="./test.sock")
 
     assert len(process_list) == num_workers
 
@@ -141,23 +45,19 @@ def test_multiprocessing_with_blueprint(app):
     num_workers = random.choice(range(2, multiprocessing.cpu_count() * 2 + 1))
     process_list = set()
 
-    @app.after_server_start
-    async def shutdown(app):
-        await sleep(2.1)
-        app.stop()
-
     def stop_on_alarm(*args):
         for process in multiprocessing.active_children():
             process_list.add(process.pid)
+            process.terminate()
 
     signal.signal(signal.SIGALRM, stop_on_alarm)
-    signal.alarm(2)
+    signal.alarm(3)
 
     bp = Blueprint("test_text")
     app.blueprint(bp)
-    app.run(HOST, 4121, workers=num_workers, debug=True)
+    app.run(HOST, PORT, workers=num_workers)
 
-    assert len(process_list) == num_workers + 1
+    assert len(process_list) == num_workers
 
 
 # this function must be outside a test function so that it can be
@@ -166,58 +66,62 @@ def handler(request):
     return text("Hello")
 
 
-def stop(app):
-    app.stop()
-
-
 # Multiprocessing on Windows requires app to be able to be pickled
 @pytest.mark.parametrize("protocol", [3, 4])
 def test_pickle_app(app, protocol):
     app.route("/")(handler)
-    app.after_server_start(stop)
+    app.router.finalize()
     app.router.reset()
-    app.signal_router.reset()
     p_app = pickle.dumps(app, protocol=protocol)
     del app
     up_p_app = pickle.loads(p_app)
+    up_p_app.router.finalize()
     assert up_p_app
-    up_p_app.run(single_process=True)
+    request, response = up_p_app.test_client.get("/")
+    assert response.text == "Hello"
 
 
 @pytest.mark.parametrize("protocol", [3, 4])
 def test_pickle_app_with_bp(app, protocol):
     bp = Blueprint("test_text")
     bp.route("/")(handler)
-    bp.after_server_start(stop)
     app.blueprint(bp)
+    app.router.finalize()
     app.router.reset()
-    app.signal_router.reset()
     p_app = pickle.dumps(app, protocol=protocol)
     del app
     up_p_app = pickle.loads(p_app)
+    up_p_app.router.finalize()
     assert up_p_app
-    up_p_app.run(single_process=True)
+    request, response = up_p_app.test_client.get("/")
+    assert response.text == "Hello"
 
 
 @pytest.mark.parametrize("protocol", [3, 4])
 def test_pickle_app_with_static(app, protocol):
     app.route("/")(handler)
-    app.after_server_start(stop)
     app.static("/static", "/tmp/static")
+    app.router.finalize()
     app.router.reset()
-    app.signal_router.reset()
     p_app = pickle.dumps(app, protocol=protocol)
     del app
     up_p_app = pickle.loads(p_app)
+    up_p_app.router.finalize()
     assert up_p_app
-    up_p_app.run(single_process=True)
+    request, response = up_p_app.test_client.get("/static/missing.txt")
+    assert response.status == 404
 
 
 def test_main_process_event(app, caplog):
     # Selects a number at random so we can spot check
     num_workers = random.choice(range(2, multiprocessing.cpu_count() * 2 + 1))
 
-    app.after_server_start(stop)
+    def stop_on_alarm(*args):
+        for process in multiprocessing.active_children():
+            process.terminate()
+
+    signal.signal(signal.SIGALRM, stop_on_alarm)
+    signal.alarm(1)
 
     @app.listener("main_process_start")
     def main_process_start(app, loop):

tests/test_pipelining.py

@@ -1,3 +1,4 @@
+from httpx import AsyncByteStream
 from sanic_testing.reusable import ReusableClient
 
 from sanic.response import json, text

tests/test_prepare.py

@@ -17,10 +17,6 @@ def no_skip():
     yield
     Sanic._app_registry = {}
     Sanic.should_auto_reload = should_auto_reload
-    try:
-        del os.environ["SANIC_MOTD_OUTPUT"]
-    except KeyError:
-        ...
 
 
 def get_primary(app: Sanic) -> ApplicationServerInfo:
@@ -59,21 +55,17 @@ def test_reload_dir(app: Sanic, dirs, caplog):
         assert ("sanic.root", logging.WARNING, message) in caplog.record_tuples
 
 
-def test_fast(app: Sanic, caplog):
+def test_fast(app: Sanic, run_multi):
-    @app.after_server_start
+    app.prepare(fast=True)
-    async def stop(app, _):
-        app.stop()
-
     try:
         workers = len(os.sched_getaffinity(0))
     except AttributeError:
         workers = os.cpu_count() or 1
 
-    with caplog.at_level(logging.INFO):
-        app.prepare(fast=True)
-
     assert app.state.fast
     assert app.state.workers == workers
 
-    messages = [m[2] for m in caplog.record_tuples]
+    logs = run_multi(app, logging.INFO)
+
+    messages = [m[2] for m in logs]
     assert f"mode: production, goin' fast w/ {workers} workers" in messages

tests/test_request.py

@@ -243,54 +243,3 @@ def test_request_stream_id(app):
 
     _, resp = app.test_client.get("/")
     assert resp.text == "Stream ID is only a property of a HTTP/3 request"
-
-
-@pytest.mark.parametrize(
-    "method,safe",
-    (
-        ("DELETE", False),
-        ("GET", True),
-        ("HEAD", True),
-        ("OPTIONS", True),
-        ("PATCH", False),
-        ("POST", False),
-        ("PUT", False),
-    ),
-)
-def test_request_safe(method, safe):
-    request = Request(b"/", {}, None, method, None, None)
-    assert request.is_safe is safe
-
-
-@pytest.mark.parametrize(
-    "method,idempotent",
-    (
-        ("DELETE", True),
-        ("GET", True),
-        ("HEAD", True),
-        ("OPTIONS", True),
-        ("PATCH", False),
-        ("POST", False),
-        ("PUT", True),
-    ),
-)
-def test_request_idempotent(method, idempotent):
-    request = Request(b"/", {}, None, method, None, None)
-    assert request.is_idempotent is idempotent
-
-
-@pytest.mark.parametrize(
-    "method,cacheable",
-    (
-        ("DELETE", False),
-        ("GET", True),
-        ("HEAD", True),
-        ("OPTIONS", False),
-        ("PATCH", False),
-        ("POST", False),
-        ("PUT", False),
-    ),
-)
-def test_request_cacheable(method, cacheable):
-    request = Request(b"/", {}, None, method, None, None)
-    assert request.is_cacheable is cacheable

tests/test_request_stream.py

@@ -568,7 +568,7 @@ def test_streaming_echo():
     @app.listener("after_server_start")
     async def client_task(app, loop):
         try:
-            reader, writer = await asyncio.open_connection("localhost", 8000)
+            reader, writer = await asyncio.open_connection(*addr)
             await client(app, reader, writer)
         finally:
             writer.close()
@@ -576,7 +576,7 @@ def test_streaming_echo():
 
     async def client(app, reader, writer):
         # Unfortunately httpx does not support 2-way streaming, so do it by hand.
-        host = f"host: localhost:8000\r\n".encode()
+        host = f"host: {addr[0]}:{addr[1]}\r\n".encode()
         writer.write(
             b"POST /echo HTTP/1.1\r\n" + host + b"content-length: 2\r\n"
             b"content-type: text/plain; charset=utf-8\r\n"
@@ -625,4 +625,6 @@ def test_streaming_echo():
 
     # Use random port for tests
     with closing(socket()) as sock:
-        app.run(access_log=False)
+        sock.bind(("127.0.0.1", 0))
+        addr = sock.getsockname()
+        app.run(sock=sock, access_log=False)

tests/test_response.py

@@ -1,11 +1,10 @@
 import asyncio
 import inspect
 import os
-import time
 
 from collections import namedtuple
-from datetime import datetime, timedelta
+from datetime import datetime
-from email.utils import formatdate, parsedate_to_datetime
+from email.utils import formatdate
 from logging import ERROR, LogRecord
 from mimetypes import guess_type
 from pathlib import Path
@@ -665,11 +664,13 @@ def test_multiple_responses(
 
     with caplog.at_level(ERROR):
         _, response = app.test_client.get("/4")
+        print(response.json)
         assert response.status == 200
         assert "foo" not in response.text
         assert "one" in response.headers
         assert response.headers["one"] == "one"
 
+        print(response.headers)
         assert message_in_records(caplog.records, error_msg2)
 
     with caplog.at_level(ERROR):
@@ -729,10 +730,8 @@ def test_file_response_headers(
     test_expires = test_last_modified.timestamp() + test_max_age
 
     @app.route("/files/cached/<filename>", methods=["GET"])
-    def file_route_cache(request: Request, filename: str):
+    def file_route_cache(request, filename):
-        file_path = (
+        file_path = (Path(static_file_directory) / file_name).absolute()
-            Path(static_file_directory) / unquote(filename)
-        ).absolute()
         return file(
             file_path, max_age=test_max_age, last_modified=test_last_modified
         )
@@ -740,26 +739,18 @@ def test_file_response_headers(
     @app.route(
         "/files/cached_default_last_modified/<filename>", methods=["GET"]
     )
-    def file_route_cache_default_last_modified(
+    def file_route_cache_default_last_modified(request, filename):
-        request: Request, filename: str
+        file_path = (Path(static_file_directory) / file_name).absolute()
-    ):
-        file_path = (
-            Path(static_file_directory) / unquote(filename)
-        ).absolute()
         return file(file_path, max_age=test_max_age)
 
     @app.route("/files/no_cache/<filename>", methods=["GET"])
-    def file_route_no_cache(request: Request, filename: str):
+    def file_route_no_cache(request, filename):
-        file_path = (
+        file_path = (Path(static_file_directory) / file_name).absolute()
-            Path(static_file_directory) / unquote(filename)
-        ).absolute()
         return file(file_path)
 
     @app.route("/files/no_store/<filename>", methods=["GET"])
-    def file_route_no_store(request: Request, filename: str):
+    def file_route_no_store(request, filename):
-        file_path = (
+        file_path = (Path(static_file_directory) / file_name).absolute()
-            Path(static_file_directory) / unquote(filename)
-        ).absolute()
         return file(file_path, no_store=True)
 
     _, response = app.test_client.get(f"/files/cached/{file_name}")
@@ -776,11 +767,11 @@ def test_file_response_headers(
         == formatdate(test_expires, usegmt=True)[:-6]
         # [:-6] to allow at most 1 min difference
         # It's minimal for cases like:
-        # Thu, 26 May 2022 05:36:59 GMT
+        # Thu, 26 May 2022 05:36:49 GMT
         # AND
-        # Thu, 26 May 2022 05:37:00 GMT
+        # Thu, 26 May 2022 05:36:50 GMT
     )
-    assert response.status == 200
+
     assert "last-modified" in headers and headers.get(
         "last-modified"
     ) == formatdate(test_last_modified.timestamp(), usegmt=True)
@@ -795,152 +786,15 @@ def test_file_response_headers(
     assert "last-modified" in headers and headers.get(
         "last-modified"
     ) == formatdate(file_last_modified, usegmt=True)
-    assert response.status == 200
 
     _, response = app.test_client.get(f"/files/no_cache/{file_name}")
     headers = response.headers
     assert "cache-control" in headers and f"no-cache" == headers.get(
         "cache-control"
     )
-    assert response.status == 200
 
     _, response = app.test_client.get(f"/files/no_store/{file_name}")
     headers = response.headers
     assert "cache-control" in headers and f"no-store" == headers.get(
         "cache-control"
     )
-    assert response.status == 200
-
-
-def test_file_validate(app: Sanic, static_file_directory: str):
-    file_name = "test_validate.txt"
-    static_file_directory = Path(static_file_directory)
-    file_path = static_file_directory / file_name
-    file_path = file_path.absolute()
-    test_max_age = 10
-
-    with open(file_path, "w+") as f:
-        f.write("foo\n")
-
-    @app.route("/validate", methods=["GET"])
-    def file_route_cache(request: Request):
-        return file(
-            file_path,
-            request_headers=request.headers,
-            max_age=test_max_age,
-            validate_when_requested=True,
-        )
-
-    _, response = app.test_client.get("/validate")
-    assert response.status == 200
-    assert response.body == b"foo\n"
-    last_modified = response.headers["Last-Modified"]
-
-    time.sleep(1)
-    with open(file_path, "a") as f:
-        f.write("bar\n")
-    _, response = app.test_client.get(
-        "/validate", headers={"If-Modified-Since": last_modified}
-    )
-
-    assert response.status == 200
-    assert response.body == b"foo\nbar\n"
-
-    last_modified = response.headers["Last-Modified"]
-    _, response = app.test_client.get(
-        "/validate", headers={"if-modified-since": last_modified}
-    )
-    assert response.status == 304
-    assert response.body == b""
-
-    file_path.unlink()
-
-
-@pytest.mark.parametrize(
-    "file_name", ["test.file", "decode me.txt", "python.png"]
-)
-def test_file_validating_invalid_header(
-    app: Sanic, file_name: str, static_file_directory: str
-):
-    @app.route("/files/<filename>", methods=["GET"])
-    def file_route(request: Request, filename: str):
-        handler_file_path = (
-            Path(static_file_directory) / unquote(filename)
-        ).absolute()
-
-        return file(
-            handler_file_path,
-            request_headers=request.headers,
-            validate_when_requested=True,
-        )
-
-    _, response = app.test_client.get(f"/files/{file_name}")
-    assert response.status == 200
-    assert response.body == get_file_content(static_file_directory, file_name)
-
-    _, response = app.test_client.get(
-        f"/files/{file_name}", headers={"if-modified-since": "invalid-value"}
-    )
-    assert response.status == 200
-    assert response.body == get_file_content(static_file_directory, file_name)
-
-    _, response = app.test_client.get(
-        f"/files/{file_name}", headers={"if-modified-since": ""}
-    )
-    assert response.status == 200
-    assert response.body == get_file_content(static_file_directory, file_name)
-
-
-@pytest.mark.parametrize(
-    "file_name", ["test.file", "decode me.txt", "python.png"]
-)
-def test_file_validating_304_response(
-    app: Sanic, file_name: str, static_file_directory: str
-):
-    @app.route("/files/<filename>", methods=["GET"])
-    def file_route(request: Request, filename: str):
-        handler_file_path = (
-            Path(static_file_directory) / unquote(filename)
-        ).absolute()
-
-        return file(
-            handler_file_path,
-            request_headers=request.headers,
-            validate_when_requested=True,
-        )
-
-    _, response = app.test_client.get(f"/files/{file_name}")
-    assert response.status == 200
-    assert response.body == get_file_content(static_file_directory, file_name)
-
-    _, response = app.test_client.get(
-        f"/files/{file_name}",
-        headers={"if-modified-since": response.headers["Last-Modified"]},
-    )
-    assert response.status == 304
-    assert response.body == b""
-
-
-@pytest.mark.parametrize(
-    "file_name", ["test.file", "decode me.txt", "python.png"]
-)
-def test_file_validating_304_response(
-    app: Sanic, file_name: str, static_file_directory: str
-):
-    app.static("static", Path(static_file_directory) / file_name)
-
-    _, response = app.test_client.get("/static")
-    assert response.status == 200
-    assert response.body == get_file_content(static_file_directory, file_name)
-    last_modified = parsedate_to_datetime(response.headers["Last-Modified"])
-    last_modified += timedelta(seconds=1)
-    _, response = app.test_client.get(
-        "/static",
-        headers={
-            "if-modified-since": formatdate(
-                last_modified.timestamp(), usegmt=True
-            )
-        },
-    )
-    assert response.status == 304
-    assert response.body == b""

tests/test_response_timeout.py

@@ -3,80 +3,69 @@ import logging
 
 from time import sleep
 
-import pytest
-
 from sanic import Sanic
 from sanic.exceptions import ServiceUnavailable
 from sanic.log import LOGGING_CONFIG_DEFAULTS
 from sanic.response import text
 
 
-@pytest.fixture
+response_timeout_app = Sanic("test_response_timeout")
-def response_timeout_app():
+response_timeout_default_app = Sanic("test_response_timeout_default")
-    app = Sanic("test_response_timeout")
+response_handler_cancelled_app = Sanic("test_response_handler_cancelled")
-    app.config.RESPONSE_TIMEOUT = 1
 
-    @app.route("/1")
+response_timeout_app.config.RESPONSE_TIMEOUT = 1
-    async def handler_1(request):
+response_timeout_default_app.config.RESPONSE_TIMEOUT = 1
-        await asyncio.sleep(2)
+response_handler_cancelled_app.config.RESPONSE_TIMEOUT = 1
-        return text("OK")
 
-    @app.exception(ServiceUnavailable)
+response_handler_cancelled_app.ctx.flag = False
-    def handler_exception(request, exception):
-        return text("Response Timeout from error_handler.", 503)
-
-    return app
 
 
-@pytest.fixture
+@response_timeout_app.route("/1")
-def response_timeout_default_app():
+async def handler_1(request):
-    app = Sanic("test_response_timeout_default")
+    await asyncio.sleep(2)
-    app.config.RESPONSE_TIMEOUT = 1
+    return text("OK")
-
-    @app.route("/1")
-    async def handler_2(request):
-        await asyncio.sleep(2)
-        return text("OK")
-
-    return app
 
 
-@pytest.fixture
+@response_timeout_app.exception(ServiceUnavailable)
-def response_handler_cancelled_app():
+def handler_exception(request, exception):
-    app = Sanic("test_response_handler_cancelled")
+    return text("Response Timeout from error_handler.", 503)
-    app.config.RESPONSE_TIMEOUT = 1
-    app.ctx.flag = False
-
-    @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.ctx.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.
-
-    @app.route("/1")
-    async def handler_3(request):
-        await asyncio.sleep(2)
-        return text("OK")
-
-    return app
 
 
-def test_server_error_response_timeout(response_timeout_app):
+@response_timeout_default_app.route("/1")
+async def handler_2(request):
+    await asyncio.sleep(2)
+    return text("OK")
+
+
+@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.ctx.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_server_error_response_timeout():
     request, response = response_timeout_app.test_client.get("/1")
     assert response.status == 503
     assert response.text == "Response Timeout from error_handler."
 
 
-def test_default_server_error_response_timeout(response_timeout_default_app):
+def test_default_server_error_response_timeout():
     request, response = response_timeout_default_app.test_client.get("/1")
     assert response.status == 503
     assert "Response Timeout" in response.text
 
 
-def test_response_handler_cancelled(response_handler_cancelled_app):
+def test_response_handler_cancelled():
     request, response = response_handler_cancelled_app.test_client.get("/1")
     assert response.status == 503
     assert "Response Timeout" in response.text