Add color changes

Switch blue to code block orange in sanic docs. Add sanic highlight override. Add darker sanic background (111) as option but in the comments so we can switch back if need be.
Add header background, change all dark theme grays to neutral grays.
2023-02-16 14:59:09 +02:00 · 2023-02-09 16:49:16 +08:00 · 2023-02-09 16:35:20 +08:00 · 2023-02-09 16:23:01 +08:00 · 2023-02-09 07:03:09 +08:00 · 2023-02-09 06:46:13 +08:00
105 changed files with 3129 additions and 1071 deletions
--- a/.coveragerc
+++ b/.coveragerc
@@ -9,6 +9,7 @@ omit =
    sanic/simple.py
    sanic/utils.py
    sanic/cli
+    sanic/pages

 [html]
 directory = coverage
--- a/.github/workflows/pr-bandit.yml
+++ b/.github/workflows/pr-bandit.yml
@@ -20,6 +20,7 @@ jobs:
          - { python-version: 3.8, tox-env: security}
          - { python-version: 3.9, tox-env: security}
          - { python-version: "3.10", tox-env: security}
+          - { python-version: "3.11", tox-env: security}
    steps:
      - name: Checkout the repository
        uses: actions/checkout@v2
--- a/.github/workflows/pr-docs.yml
+++ b/.github/workflows/pr-docs.yml
@@ -14,7 +14,7 @@ jobs:
    strategy:
      matrix:
        config:
-          - {python-version: "3.8", tox-env: "docs"}
+          - {python-version: "3.10", tox-env: "docs"}
      fail-fast: false


--- a/.github/workflows/pr-linter.yml
+++ b/.github/workflows/pr-linter.yml
@@ -16,7 +16,7 @@ jobs:
      matrix:
        os: [ubuntu-latest]
        config:
-          - { python-version: 3.8, tox-env: lint}
+          - { python-version: "3.10", tox-env: lint}
    steps:
      - name: Checkout the repository
        uses: actions/checkout@v2
--- a/.github/workflows/pr-python311.yml
+++ b/.github/workflows/pr-python311.yml
@@ -0,0 +1,47 @@
+name: Python 3.11 Tests
+on:
+  pull_request:
+    branches:
+      - main
+      - "*LTS"
+    types: [opened, synchronize, reopened, ready_for_review]
+
+jobs:
+  testPy311:
+    if: github.event.pull_request.draft == false
+    name: ut-${{ matrix.config.tox-env }}-${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        # os: [ubuntu-latest, macos-latest]
+        os: [ubuntu-latest]
+        config:
+          - {
+              python-version: "3.11",
+              tox-env: py311,
+              ignore-error-flake: "false",
+              command-timeout: "0",
+            }
+          - {
+              python-version: "3.11",
+              tox-env: py311-no-ext,
+              ignore-error-flake: "true",
+              command-timeout: "600000",
+            }
+    steps:
+      - name: Checkout the Repository
+        uses: actions/checkout@v2
+        id: checkout-branch
+
+      - name: Run Unit Tests
+        uses: harshanarayana/custom-actions@main
+        with:
+          python-version: ${{ matrix.config.python-version }}
+          test-infra-tool: tox
+          test-infra-version: latest
+          action: tests
+          test-additional-args: "-e=${{ matrix.config.tox-env }},-vv=''"
+          experimental-ignore-error: "${{ matrix.config.ignore-error-flake }}"
+          command-timeout: "${{ matrix.config.command-timeout }}"
+          test-failure-retry: "3"
--- a/.github/workflows/pr-type-check.yml
+++ b/.github/workflows/pr-type-check.yml
@@ -20,6 +20,7 @@ jobs:
          - { python-version: 3.8, tox-env: type-checking}
          - { python-version: 3.9, tox-env: type-checking}
          - { python-version: "3.10", tox-env: type-checking}
+          - { python-version: "3.11", tox-env: type-checking}
    steps:
      - name: Checkout the repository
        uses: actions/checkout@v2
--- a/.github/workflows/pr-windows.yml
+++ b/.github/workflows/pr-windows.yml
@@ -19,6 +19,7 @@ jobs:
          - { python-version: 3.8, tox-env: py38-no-ext }
          - { python-version: 3.9, tox-env: py39-no-ext }
          - { python-version: "3.10", tox-env: py310-no-ext }
+          - { python-version: "3.11", tox-env: py310-no-ext }
          - { python-version: pypy-3.7, tox-env: pypy37-no-ext }

    steps:
--- a/.github/workflows/publish-images.yml
+++ b/.github/workflows/publish-images.yml
@@ -14,7 +14,7 @@ jobs:
    strategy:
      fail-fast: true
      matrix:
-        python-version: ["3.7", "3.8", "3.9", "3.10"]
+        python-version: ["3.7", "3.8", "3.9", "3.10", "3.11"]

    steps:
      - name: Checkout repository
--- a/.github/workflows/publish-package.yml
+++ b/.github/workflows/publish-package.yml
@@ -11,7 +11,7 @@ jobs:
    strategy:
      fail-fast: true
      matrix:
-        python-version: ["3.8"]
+        python-version: ["3.10"]

    steps:
      - name: Checkout Repository
--- a/CHANGELOG.rst
+++ b/CHANGELOG.rst
@@ -313,8 +313,8 @@ Version 21.3.0
    `#2074 <https://github.com/sanic-org/sanic/pull/2074>`_
    Performance adjustments in ``handle_request_``

-Version 20.12.3 🔷
------------------
+Version 20.12.3
+---------------

 `Current LTS version`

@@ -350,8 +350,8 @@ Version 19.12.5
    `#2027 <https://github.com/sanic-org/sanic/pull/2027>`_
    Remove old chardet requirement, add in hard multidict requirement

-Version 20.12.0 🔹
-----------------
+Version 20.12.0
+---------------

 **Features**

--- a/SECURITY.md
+++ b/SECURITY.md
@@ -7,14 +7,15 @@ Sanic releases long term support release once a year in December. LTS releases r

 | Version | LTS           | Supported               |
 | ------- | ------------- | ----------------------- |
-| 22.9    |               | :white_check_mark:      |
+| 22.12   | until 2024-12 | :white_check_mark:      |
+| 22.9    |               | :x:                     |
 | 22.6    |               | :x:                     |
 | 22.3    |               | :x:                     |
-| 21.12   | until 2023-12 | :white_check_mark:      |
+| 21.12   | until 2023-12 | :ballot_box_with_check: |
 | 21.9    |               | :x:                     |
 | 21.6    |               | :x:                     |
 | 21.3    |               | :x:                     |
-| 20.12   | until 2022-12 | :ballot_box_with_check: |
+| 20.12   |               | :x:                     |
 | 20.9    |               | :x:                     |
 | 20.6    |               | :x:                     |
 | 20.3    |               | :x:                     |
--- a/codecov.yml
+++ b/codecov.yml
@@ -17,7 +17,8 @@ ignore:
  - "sanic/compat.py"
  - "sanic/simple.py"
  - "sanic/utils.py"
-  - "sanic/cli"
+  - "sanic/cli/"
+  - "sanic/pages/"
  - ".github/"
  - "changelogs/"
  - "docker/"
--- a/docs/sanic/changelog.rst
+++ b/docs/sanic/changelog.rst
@@ -1,6 +1,7 @@
 📜 Changelog
 ============

+.. mdinclude:: ./releases/22/22.12.md
 .. mdinclude:: ./releases/22/22.9.md
 .. mdinclude:: ./releases/22/22.6.md
 .. mdinclude:: ./releases/22/22.3.md
--- a/docs/sanic/releases/22/22.12.md
+++ b/docs/sanic/releases/22/22.12.md
@@ -0,0 +1,55 @@
+## Version 22.12.0 🔶
+
+_Current version_
+
+### Features
+
+- [#2569](https://github.com/sanic-org/sanic/pull/2569) Add `JSONResponse` class with some convenient methods when updating a response object
+- [#2598](https://github.com/sanic-org/sanic/pull/2598) Change `uvloop` requirement to `>=0.15.0`
+- [#2609](https://github.com/sanic-org/sanic/pull/2609) Add compatibility with `websockets` v11.0
+- [#2610](https://github.com/sanic-org/sanic/pull/2610) Kill server early on worker error
+    - Raise deadlock timeout to 30s
+- [#2617](https://github.com/sanic-org/sanic/pull/2617) Scale number of running server workers
+- [#2621](https://github.com/sanic-org/sanic/pull/2621) [#2634](https://github.com/sanic-org/sanic/pull/2634) Send `SIGKILL` on subsequent `ctrl+c` to force worker exit
+- [#2622](https://github.com/sanic-org/sanic/pull/2622) Add API to restart all workers from the multiplexer
+- [#2624](https://github.com/sanic-org/sanic/pull/2624) Default to `spawn` for all subprocesses unless specifically set:
+    ```python
+    from sanic import Sanic
+    
+    Sanic.start_method = "fork"
+    ```
+- [#2625](https://github.com/sanic-org/sanic/pull/2625) Filename normalisation of form-data/multipart file uploads
+- [#2626](https://github.com/sanic-org/sanic/pull/2626) Move to HTTP Inspector:
+    - Remote access to inspect running Sanic instances
+    - TLS support for encrypted calls to Inspector
+    - Authentication to Inspector with API key
+    - Ability to extend Inspector with custom commands
+- [#2632](https://github.com/sanic-org/sanic/pull/2632) Control order of restart operations
+- [#2633](https://github.com/sanic-org/sanic/pull/2633) Move reload interval to class variable
+- [#2636](https://github.com/sanic-org/sanic/pull/2636) Add `priority` to `register_middleware` method
+- [#2639](https://github.com/sanic-org/sanic/pull/2639) Add `unquote` to `add_route` method
+- [#2640](https://github.com/sanic-org/sanic/pull/2640) ASGI websockets to receive `text` or `bytes`
+
+
+### Bugfixes
+
+- [#2607](https://github.com/sanic-org/sanic/pull/2607) Force socket shutdown before close to allow rebinding
+- [#2590](https://github.com/sanic-org/sanic/pull/2590) Use actual `StrEnum` in Python 3.11+
+- [#2615](https://github.com/sanic-org/sanic/pull/2615) Ensure middleware executes only once per request timeout
+- [#2627](https://github.com/sanic-org/sanic/pull/2627) Crash ASGI application on lifespan failure
+- [#2635](https://github.com/sanic-org/sanic/pull/2635) Resolve error with low-level server creation on Windows
+
+
+### Deprecations and Removals
+
+- [#2608](https://github.com/sanic-org/sanic/pull/2608) [#2630](https://github.com/sanic-org/sanic/pull/2630) Signal conditions and triggers saved on `signal.extra` 
+- [#2626](https://github.com/sanic-org/sanic/pull/2626) Move to HTTP Inspector
+    - 🚨 *BREAKING CHANGE*: Moves the Inspector to a Sanic app from a simple TCP socket with a custom protocol
+    - *DEPRECATE*: The `--inspect*` commands have been deprecated in favor of `inspect ...` commands
+- [#2628](https://github.com/sanic-org/sanic/pull/2628) Replace deprecated `distutils.strtobool`
+
+
+### Developer infrastructure
+
+- [#2612](https://github.com/sanic-org/sanic/pull/2612) Add CI testing for Python 3.11
+
--- a/docs/sanic/releases/22/22.9.md
+++ b/docs/sanic/releases/22/22.9.md
@@ -1,6 +1,33 @@
-## Version 22.9.0 🔶
+## Version 22.9.1

-_Current version_
+### Features
+
+- [#2585](https://github.com/sanic-org/sanic/pull/2585) Improved error message when no applications have been registered
+
+
+### Bugfixes
+
+- [#2578](https://github.com/sanic-org/sanic/pull/2578) Add certificate loader for in process certificate creation
+- [#2591](https://github.com/sanic-org/sanic/pull/2591) Do not use sentinel identity for `spawn` compatibility
+- [#2592](https://github.com/sanic-org/sanic/pull/2592) Fix properties in nested blueprint groups
+- [#2595](https://github.com/sanic-org/sanic/pull/2595) Introduce sleep interval on new worker reloader
+
+
+### Deprecations and Removals
+
+
+### Developer infrastructure
+
+- [#2588](https://github.com/sanic-org/sanic/pull/2588) Markdown templates on issue forms
+
+
+### Improved Documentation
+
+- [#2556](https://github.com/sanic-org/sanic/pull/2556) v22.9 documentation
+- [#2582](https://github.com/sanic-org/sanic/pull/2582) Cleanup documentation on Windows support
+
+
+## Version 22.9.0

 ### Features

--- a/pyproject.toml
+++ b/pyproject.toml
@@ -22,5 +22,7 @@ module = [
    "httptools.*",
    "trustme.*",
    "sanic_routing.*",
+    "aioquic.*",
+    "html5tagger.*",
 ]
 ignore_missing_imports = true
--- a/sanic/version.py
+++ b/sanic/version.py
@@ -1 +1 @@
-__version__ = "22.12.0a0"
+__version__ = "23.3.0"
--- a/sanic/app.py
+++ b/sanic/app.py
@@ -61,7 +61,7 @@ from sanic.exceptions import (
    URLBuildError,
 )
 from sanic.handlers import ErrorHandler
-from sanic.helpers import Default
+from sanic.helpers import Default, _default
 from sanic.http import Stage
 from sanic.log import (
    LOGGING_CONFIG_DEFAULTS,
@@ -69,8 +69,10 @@ from sanic.log import (
    error_logger,
    logger,
 )
+from sanic.middleware import Middleware, MiddlewareLocation
 from sanic.mixins.listeners import ListenerEvent
 from sanic.mixins.startup import StartupMixin
+from sanic.mixins.static import StaticHandleMixin
 from sanic.models.futures import (
    FutureException,
    FutureListener,
@@ -78,7 +80,6 @@ from sanic.models.futures import (
    FutureRegistry,
    FutureRoute,
    FutureSignal,
-    FutureStatic,
 )
 from sanic.models.handler_types import ListenerType, MiddlewareType
 from sanic.models.handler_types import Sanic as SanicVar
@@ -105,7 +106,7 @@ if OS_IS_WINDOWS:  # no cov
    enable_windows_color_support()


-class Sanic(BaseSanic, StartupMixin, metaclass=TouchUpMeta):
+class Sanic(StaticHandleMixin, BaseSanic, StartupMixin, metaclass=TouchUpMeta):
    """
    The main application instance
    """
@@ -140,6 +141,7 @@ class Sanic(BaseSanic, StartupMixin, metaclass=TouchUpMeta):
        "configure_logging",
        "ctx",
        "error_handler",
+        "inspector_class",
        "go_fast",
        "listeners",
        "multiplexer",
@@ -155,6 +157,7 @@ class Sanic(BaseSanic, StartupMixin, metaclass=TouchUpMeta):
        "strict_slashes",
        "websocket_enabled",
        "websocket_tasks",
+        "wrappers",
    )

    _app_registry: Dict[str, "Sanic"] = {}
@@ -162,7 +165,7 @@ class Sanic(BaseSanic, StartupMixin, metaclass=TouchUpMeta):

    def __init__(
        self,
-        name: str = None,
+        name: Optional[str] = None,
        config: Optional[Config] = None,
        ctx: Optional[Any] = None,
        router: Optional[Router] = None,
@@ -176,6 +179,7 @@ class Sanic(BaseSanic, StartupMixin, metaclass=TouchUpMeta):
        dumps: Optional[Callable[..., AnyStr]] = None,
        loads: Optional[Callable[..., Any]] = None,
        inspector: bool = False,
+        inspector_class: Optional[Type[Inspector]] = None,
    ) -> None:
        super().__init__(name=name)
        # logging
@@ -211,6 +215,7 @@ class Sanic(BaseSanic, StartupMixin, metaclass=TouchUpMeta):
        self.configure_logging: bool = configure_logging
        self.ctx: Any = ctx or SimpleNamespace()
        self.error_handler: ErrorHandler = error_handler or ErrorHandler()
+        self.inspector_class: Type[Inspector] = inspector_class or Inspector
        self.listeners: Dict[str, List[ListenerType[Any]]] = defaultdict(list)
        self.named_request_middleware: Dict[str, Deque[MiddlewareType]] = {}
        self.named_response_middleware: Dict[str, Deque[MiddlewareType]] = {}
@@ -291,8 +296,12 @@ class Sanic(BaseSanic, StartupMixin, metaclass=TouchUpMeta):
        return listener

    def register_middleware(
-        self, middleware: MiddlewareType, attach_to: str = "request"
-    ) -> MiddlewareType:
+        self,
+        middleware: Union[MiddlewareType, Middleware],
+        attach_to: str = "request",
+        *,
+        priority: Union[Default, int] = _default,
+    ) -> Union[MiddlewareType, Middleware]:
        """
        Register an application level middleware that will be attached
        to all the API URLs registered under this application.
@@ -308,19 +317,37 @@ class Sanic(BaseSanic, StartupMixin, metaclass=TouchUpMeta):
            **response** - Invoke before the response is returned back
        :return: decorated method
        """
-        if attach_to == "request":
+        retval = middleware
+        location = MiddlewareLocation[attach_to.upper()]
+
+        if not isinstance(middleware, Middleware):
+            middleware = Middleware(
+                middleware,
+                location=location,
+                priority=priority if isinstance(priority, int) else 0,
+            )
+        elif middleware.priority != priority and isinstance(priority, int):
+            middleware = Middleware(
+                middleware.func,
+                location=middleware.location,
+                priority=priority,
+            )
+
+        if location is MiddlewareLocation.REQUEST:
            if middleware not in self.request_middleware:
                self.request_middleware.append(middleware)
-        if attach_to == "response":
+        if location is MiddlewareLocation.RESPONSE:
            if middleware not in self.response_middleware:
                self.response_middleware.appendleft(middleware)
-        return middleware
+        return retval

    def register_named_middleware(
        self,
        middleware: MiddlewareType,
        route_names: Iterable[str],
        attach_to: str = "request",
+        *,
+        priority: Union[Default, int] = _default,
    ):
        """
        Method for attaching middleware to specific routes. This is mainly an
@@ -334,19 +361,35 @@ class Sanic(BaseSanic, StartupMixin, metaclass=TouchUpMeta):
            defaults to "request"
        :type attach_to: str, optional
        """
-        if attach_to == "request":
+        retval = middleware
+        location = MiddlewareLocation[attach_to.upper()]
+
+        if not isinstance(middleware, Middleware):
+            middleware = Middleware(
+                middleware,
+                location=location,
+                priority=priority if isinstance(priority, int) else 0,
+            )
+        elif middleware.priority != priority and isinstance(priority, int):
+            middleware = Middleware(
+                middleware.func,
+                location=middleware.location,
+                priority=priority,
+            )
+
+        if location is MiddlewareLocation.REQUEST:
            for _rn in route_names:
                if _rn not in self.named_request_middleware:
                    self.named_request_middleware[_rn] = deque()
                if middleware not in self.named_request_middleware[_rn]:
                    self.named_request_middleware[_rn].append(middleware)
-        if attach_to == "response":
+        if location is MiddlewareLocation.RESPONSE:
            for _rn in route_names:
                if _rn not in self.named_response_middleware:
                    self.named_response_middleware[_rn] = deque()
                if middleware not in self.named_response_middleware[_rn]:
                    self.named_response_middleware[_rn].appendleft(middleware)
-        return middleware
+        return retval

    def _apply_exception_handler(
        self,
@@ -399,9 +442,6 @@ class Sanic(BaseSanic, StartupMixin, metaclass=TouchUpMeta):

        return routes

-    def _apply_static(self, static: FutureStatic) -> Route:
-        return self._register_static(static)
-
    def _apply_middleware(
        self,
        middleware: FutureMiddleware,
@@ -836,6 +876,8 @@ class Sanic(BaseSanic, StartupMixin, metaclass=TouchUpMeta):
        :param request: HTTP Request object
        :return: Nothing
        """
+        __tracebackhide__ = True
+
        await self.dispatch(
            "http.lifecycle.handle",
            inline=True,
@@ -848,11 +890,11 @@ class Sanic(BaseSanic, StartupMixin, metaclass=TouchUpMeta):
            Union[
                BaseHTTPResponse,
                Coroutine[Any, Any, Optional[BaseHTTPResponse]],
+                ResponseStream,
            ]
        ] = None
        run_middleware = True
        try:
-
            await self.dispatch(
                "http.routing.before",
                inline=True,
@@ -884,7 +926,6 @@ class Sanic(BaseSanic, StartupMixin, metaclass=TouchUpMeta):
                and request.stream.request_body
                and not route.extra.ignore_body
            ):
-
                if hasattr(handler, "is_stream"):
                    # Streaming handler: lift the size limit
                    request.stream.request_max_size = float("inf")
@@ -958,7 +999,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 +1008,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(
@@ -1531,6 +1572,7 @@ class Sanic(BaseSanic, StartupMixin, metaclass=TouchUpMeta):

        self.state.is_started = True

+    def ack(self):
        if hasattr(self, "multiplexer"):
            self.multiplexer.ack()

--- a/sanic/application/ext.py
+++ b/sanic/application/ext.py
@@ -8,11 +8,6 @@ from typing import TYPE_CHECKING
 if TYPE_CHECKING:
    from sanic import Sanic

-    try:
-        from sanic_ext import Extend  # type: ignore
-    except ImportError:
-        ...
-

 def setup_ext(app: Sanic, *, fail: bool = False, **kwargs):
    if not app.config.AUTO_EXTEND:
@@ -33,7 +28,7 @@ def setup_ext(app: Sanic, *, fail: bool = False, **kwargs):
        return

    if not getattr(app, "_ext", None):
-        Ext: Extend = getattr(sanic_ext, "Extend")
+        Ext = getattr(sanic_ext, "Extend")
        app._ext = Ext(app, **kwargs)

        return app.ext
--- a/sanic/application/logo.py
+++ b/sanic/application/logo.py
@@ -40,6 +40,8 @@ FULL_COLOR_LOGO = """

 """  # noqa

+SVG_LOGO_SIMPLE = """<svg id=logo-simple viewBox="0 0 964 279"><desc>Sanic</desc><path d="M107 222c9-2 10-20 1-22s-20-2-30-2-17 7-16 14 6 10 15 10h30zm115-1c16-2 30-11 35-23s6-24 2-33-6-14-15-20-24-11-38-10c-7 3-10 13-5 19s17-1 24 4 15 14 13 24-5 15-14 18-50 0-74 0h-17c-6 4-10 15-4 20s16 2 23 3zM251 83q9-1 9-7 0-15-10-16h-13c-10 6-10 20 0 22zM147 60c-4 0-10 3-11 11s5 13 10 12 42 0 67 0c5-3 7-10 6-15s-4-8-9-8zm-33 1c-8 0-16 0-24 3s-20 10-25 20-6 24-4 36 15 22 26 27 78 8 94 3c4-4 4-12 0-18s-69 8-93-10c-8-7-9-23 0-30s12-10 20-10 12 2 16-3 1-15-5-18z" fill="#ff0d68"/><path d="M676 74c0-14-18-9-20 0s0 30 0 39 20 9 20 2zm-297-10c-12 2-15 12-23 23l-41 58H340l22-30c8-12 23-13 30-4s20 24 24 38-10 10-17 10l-68 2q-17 1-48 30c-7 6-10 20 0 24s15-8 20-13 20 -20 58-21h50 c20 2 33 9 52 30 8 10 24-4 16-13L384 65q-3-2-5-1zm131 0c-10 1-12 12-11 20v96c1 10-3 23 5 32s20-5 17-15c0-23-3-46 2-67 5-12 22-14 32-5l103 87c7 5 19 1 18-9v-64c-3-10-20-9-21 2s-20 22-30 13l-97-80c-5-4-10-10-18-10zM701 76v128c2 10 15 12 20 4s0-102 0-124s-20-18-20-7z M850 63c-35 0-69-2-86 15s-20 60-13 66 13 8 16 0 1-10 1-27 12-26 20-32 66-5 85-5 31 4 31-10-18-7-54-7M764 159c-6-2-15-2-16 12s19 37 33 43 23 8 25-4-4-11-11-14q-9-3-22-18c-4-7-3-16-10-19zM828 196c-4 0-8 1-10 5s-4 12 0 15 8 2 12 2h60c5 0 10-2 12-6 3-7-1-16-8-16z" fill="#1f1f1f"/></svg>"""  # noqa
+
 ansi_pattern = re.compile(r"\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])")


--- a/sanic/asgi.py
+++ b/sanic/asgi.py
@@ -9,7 +9,7 @@ from sanic.compat import Header
 from sanic.exceptions import ServerError
 from sanic.helpers import Default
 from sanic.http import Stage
-from sanic.log import logger
+from sanic.log import error_logger, logger
 from sanic.models.asgi import ASGIReceive, ASGIScope, ASGISend, MockTransport
 from sanic.request import Request
 from sanic.response import BaseHTTPResponse
@@ -85,13 +85,27 @@ class Lifespan:
    ) -> None:
        message = await receive()
        if message["type"] == "lifespan.startup":
-            await self.startup()
-            await send({"type": "lifespan.startup.complete"})
+            try:
+                await self.startup()
+            except Exception as e:
+                error_logger.exception(e)
+                await send(
+                    {"type": "lifespan.startup.failed", "message": str(e)}
+                )
+            else:
+                await send({"type": "lifespan.startup.complete"})

        message = await receive()
        if message["type"] == "lifespan.shutdown":
-            await self.shutdown()
-            await send({"type": "lifespan.shutdown.complete"})
+            try:
+                await self.shutdown()
+            except Exception as e:
+                error_logger.exception(e)
+                await send(
+                    {"type": "lifespan.shutdown.failed", "message": str(e)}
+                )
+            else:
+                await send({"type": "lifespan.shutdown.complete"})


 class ASGIApp:
--- a/sanic/base/root.py
+++ b/sanic/base/root.py
@@ -1,6 +1,6 @@
 import re

-from typing import Any
+from typing import Any, Optional

 from sanic.base.meta import SanicMeta
 from sanic.exceptions import SanicException
@@ -9,6 +9,7 @@ from sanic.mixins.listeners import ListenerMixin
 from sanic.mixins.middleware import MiddlewareMixin
 from sanic.mixins.routes import RouteMixin
 from sanic.mixins.signals import SignalMixin
+from sanic.mixins.static import StaticMixin


 VALID_NAME = re.compile(r"^[a-zA-Z_][a-zA-Z0-9_\-]*$")
@@ -16,6 +17,7 @@ VALID_NAME = re.compile(r"^[a-zA-Z_][a-zA-Z0-9_\-]*$")

 class BaseSanic(
    RouteMixin,
+    StaticMixin,
    MiddlewareMixin,
    ListenerMixin,
    ExceptionMixin,
@@ -24,7 +26,9 @@ class BaseSanic(
 ):
    __slots__ = ("name",)

-    def __init__(self, name: str = None, *args: Any, **kwargs: Any) -> None:
+    def __init__(
+        self, name: Optional[str] = None, *args: Any, **kwargs: Any
+    ) -> None:
        class_name = self.__class__.__name__

        if name is None:
--- a/sanic/blueprints.py
+++ b/sanic/blueprints.py
@@ -105,6 +105,7 @@ class Blueprint(BaseSanic):
        "version",
        "version_prefix",
        "websocket_routes",
+        "wrappers",
    )

    def __init__(
@@ -304,9 +305,6 @@ class Blueprint(BaseSanic):

        # Routes
        for future in self._future_routes:
-            # attach the blueprint name to the handler so that it can be
-            # 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)

@@ -442,7 +440,7 @@ class Blueprint(BaseSanic):
            events.add(signal.ctx.event)

        return asyncio.wait(
-            [event.wait() for event in events],
+            [asyncio.create_task(event.wait()) for event in events],
            return_when=asyncio.FIRST_COMPLETED,
            timeout=timeout,
        )
--- a/sanic/cli/app.py
+++ b/sanic/cli/app.py
@@ -3,23 +3,21 @@ import os
 import shutil
 import sys

-from argparse import ArgumentParser, RawTextHelpFormatter
+from argparse import Namespace
 from functools import partial
 from textwrap import indent
-from typing import Any, List, Union
+from typing import List, Union, cast

 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.cli.base import SanicArgumentParser, SanicHelpFormatter
+from sanic.cli.inspector import make_inspector_parser
+from sanic.cli.inspector_client import InspectorClient
+from sanic.log import Colors, error_logger
 from sanic.worker.loader import AppLoader


-class SanicArgumentParser(ArgumentParser):
-    ...
-
-
 class SanicCLI:
    DESCRIPTION = indent(
        f"""
@@ -46,7 +44,7 @@ Or, a path to a directory to run as a simple HTTP server:
        self.parser = SanicArgumentParser(
            prog="sanic",
            description=self.DESCRIPTION,
-            formatter_class=lambda prog: RawTextHelpFormatter(
+            formatter_class=lambda prog: SanicHelpFormatter(
                prog,
                max_help_position=36 if width > 96 else 24,
                indent_increment=4,
@@ -58,16 +56,27 @@ Or, a path to a directory to run as a simple HTTP server:
        self.main_process = (
            os.environ.get("SANIC_RELOADER_PROCESS", "") != "true"
        )
-        self.args: List[Any] = []
+        self.args: Namespace = Namespace()
        self.groups: List[Group] = []
+        self.inspecting = False

    def attach(self):
+        if len(sys.argv) > 1 and sys.argv[1] == "inspect":
+            self.inspecting = True
+            self.parser.description = get_logo(True)
+            make_inspector_parser(self.parser)
+            return
+
        for group in Group._registry:
            instance = group.create(self.parser)
            instance.attach()
            self.groups.append(instance)

    def run(self, parse_args=None):
+        if self.inspecting:
+            self._inspector()
+            return
+
        legacy_version = False
        if not parse_args:
            # This is to provide backwards compat -v to display version
@@ -86,36 +95,21 @@ 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,
+            self.args.module, self.args.factory, self.args.simple, self.args
        )

+        if self.args.inspect or self.args.inspect_raw or self.args.trigger:
+            self._inspector_legacy(app_loader)
+            return
+
        try:
            app = self._get_app(app_loader)
            kwargs = self._build_run_kwargs()
        except ValueError as e:
            error_logger.exception(f"Failed to run app: {e}")
        else:
-            if self.args.inspect or self.args.inspect_raw or self.args.trigger:
-                os.environ["SANIC_IGNORE_PRODUCTION_WARNING"] = "true"
-            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:
-                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
-
+            for http_version in self.args.http:
+                app.prepare(**kwargs, version=http_version)
            if self.args.single:
                serve = Sanic.serve_single
            elif self.args.legacy:
@@ -124,6 +118,64 @@ Or, a path to a directory to run as a simple HTTP server:
                serve = partial(Sanic.serve, app_loader=app_loader)
            serve(app)

+    def _inspector_legacy(self, app_loader: AppLoader):
+        host = port = None
+        module = cast(str, self.args.module)
+        if ":" in module:
+            maybe_host, maybe_port = module.rsplit(":", 1)
+            if maybe_port.isnumeric():
+                host, port = maybe_host, int(maybe_port)
+        if not host:
+            app = self._get_app(app_loader)
+            host, port = app.config.INSPECTOR_HOST, app.config.INSPECTOR_PORT
+
+        action = self.args.trigger or "info"
+
+        InspectorClient(
+            str(host), int(port or 6457), False, self.args.inspect_raw, ""
+        ).do(action)
+        sys.stdout.write(
+            f"\n{Colors.BOLD}{Colors.YELLOW}WARNING:{Colors.END} "
+            "You are using the legacy CLI command that will be removed in "
+            f"{Colors.RED}v23.3{Colors.END}. See "
+            "https://sanic.dev/en/guide/release-notes/v22.12.html"
+            "#deprecations-and-removals or checkout the new "
+            "style commands:\n\n\t"
+            f"{Colors.YELLOW}sanic inspect --help{Colors.END}\n"
+        )
+
+    def _inspector(self):
+        args = sys.argv[2:]
+        self.args, unknown = self.parser.parse_known_args(args=args)
+        if unknown:
+            for arg in unknown:
+                if arg.startswith("--"):
+                    try:
+                        key, value = arg.split("=")
+                        key = key.lstrip("-")
+                    except ValueError:
+                        value = False if arg.startswith("--no-") else True
+                        key = (
+                            arg.replace("--no-", "")
+                            .lstrip("-")
+                            .replace("-", "_")
+                        )
+                    setattr(self.args, key, value)
+
+        kwargs = {**self.args.__dict__}
+        host = kwargs.pop("host")
+        port = kwargs.pop("port")
+        secure = kwargs.pop("secure")
+        raw = kwargs.pop("raw")
+        action = kwargs.pop("action") or "info"
+        api_key = kwargs.pop("api_key")
+        positional = kwargs.pop("positional", None)
+        if action == "<custom>" and positional:
+            action = positional[0]
+            if len(positional) > 1:
+                kwargs["args"] = positional[1:]
+        InspectorClient(host, port, secure, raw, api_key).do(action, **kwargs)
+
    def _precheck(self):
        # Custom TLS mismatch handling for better diagnostics
        if self.main_process and (
--- a/sanic/cli/base.py
+++ b/sanic/cli/base.py
@@ -0,0 +1,35 @@
+from argparse import (
+    SUPPRESS,
+    Action,
+    ArgumentParser,
+    RawTextHelpFormatter,
+    _SubParsersAction,
+)
+from typing import Any
+
+
+class SanicArgumentParser(ArgumentParser):
+    def _check_value(self, action: Action, value: Any) -> None:
+        if isinstance(action, SanicSubParsersAction):
+            return
+        super()._check_value(action, value)
+
+
+class SanicHelpFormatter(RawTextHelpFormatter):
+    def add_usage(self, usage, actions, groups, prefix=None):
+        if not usage:
+            usage = SUPPRESS
+            # Add one linebreak, but not two
+            self.add_text("\x1b[1A")
+        super().add_usage(usage, actions, groups, prefix)
+
+
+class SanicSubParsersAction(_SubParsersAction):
+    def __call__(self, parser, namespace, values, option_string=None):
+        self._name_parser_map
+        parser_name = values[0]
+        if parser_name not in self._name_parser_map:
+            self._name_parser_map[parser_name] = parser
+            values = ["<custom>", *values]
+
+        super().__call__(parser, namespace, values, option_string)
--- a/sanic/cli/inspector.py
+++ b/sanic/cli/inspector.py
@@ -0,0 +1,105 @@
+from argparse import ArgumentParser
+
+from sanic.application.logo import get_logo
+from sanic.cli.base import SanicHelpFormatter, SanicSubParsersAction
+
+
+def _add_shared(parser: ArgumentParser) -> None:
+    parser.add_argument(
+        "--host",
+        "-H",
+        default="localhost",
+        help="Inspector host address [default 127.0.0.1]",
+    )
+    parser.add_argument(
+        "--port",
+        "-p",
+        default=6457,
+        type=int,
+        help="Inspector port [default 6457]",
+    )
+    parser.add_argument(
+        "--secure",
+        "-s",
+        action="store_true",
+        help="Whether to access the Inspector via TLS encryption",
+    )
+    parser.add_argument("--api-key", "-k", help="Inspector authentication key")
+    parser.add_argument(
+        "--raw",
+        action="store_true",
+        help="Whether to output the raw response information",
+    )
+
+
+class InspectorSubParser(ArgumentParser):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        _add_shared(self)
+        if not self.description:
+            self.description = ""
+        self.description = get_logo(True) + self.description
+
+
+def make_inspector_parser(parser: ArgumentParser) -> None:
+    _add_shared(parser)
+    subparsers = parser.add_subparsers(
+        action=SanicSubParsersAction,
+        dest="action",
+        description=(
+            "Run one or none of the below subcommands. Using inspect without "
+            "a subcommand will fetch general information about the state "
+            "of the application instance.\n\n"
+            "Or, you can optionally follow inspect with a subcommand. "
+            "If you have created a custom "
+            "Inspector instance, then you can run custom commands. See "
+            "https://sanic.dev/en/guide/deployment/inspector.html "
+            "for more details."
+        ),
+        title="  Subcommands",
+        parser_class=InspectorSubParser,
+    )
+    reloader = subparsers.add_parser(
+        "reload",
+        help="Trigger a reload of the server workers",
+        formatter_class=SanicHelpFormatter,
+    )
+    reloader.add_argument(
+        "--zero-downtime",
+        action="store_true",
+        help=(
+            "Whether to wait for the new process to be online before "
+            "terminating the old"
+        ),
+    )
+    subparsers.add_parser(
+        "shutdown",
+        help="Shutdown the application and all processes",
+        formatter_class=SanicHelpFormatter,
+    )
+    scale = subparsers.add_parser(
+        "scale",
+        help="Scale the number of workers",
+        formatter_class=SanicHelpFormatter,
+    )
+    scale.add_argument(
+        "replicas",
+        type=int,
+        help="Number of workers requested",
+    )
+
+    custom = subparsers.add_parser(
+        "<custom>",
+        help="Run a custom command",
+        description=(
+            "keyword arguments:\n  When running a custom command, you can "
+            "add keyword arguments by appending them to your command\n\n"
+            "\tsanic inspect foo --one=1 --two=2"
+        ),
+        formatter_class=SanicHelpFormatter,
+    )
+    custom.add_argument(
+        "positional",
+        nargs="*",
+        help="Add one or more non-keyword args to your custom command",
+    )
--- a/sanic/cli/inspector_client.py
+++ b/sanic/cli/inspector_client.py
@@ -0,0 +1,119 @@
+from __future__ import annotations
+
+import sys
+
+from http.client import RemoteDisconnected
+from textwrap import indent
+from typing import Any, Dict, Optional
+from urllib.error import URLError
+from urllib.request import Request as URequest
+from urllib.request import urlopen
+
+from sanic.application.logo import get_logo
+from sanic.application.motd import MOTDTTY
+from sanic.log import Colors
+
+
+try:  # no cov
+    from ujson import dumps, loads
+except ModuleNotFoundError:  # no cov
+    from json import dumps, loads  # type: ignore
+
+
+class InspectorClient:
+    def __init__(
+        self,
+        host: str,
+        port: int,
+        secure: bool,
+        raw: bool,
+        api_key: Optional[str],
+    ) -> None:
+        self.scheme = "https" if secure else "http"
+        self.host = host
+        self.port = port
+        self.raw = raw
+        self.api_key = api_key
+
+        for scheme in ("http", "https"):
+            full = f"{scheme}://"
+            if self.host.startswith(full):
+                self.scheme = scheme
+                self.host = self.host[len(full) :]  # noqa E203
+
+    def do(self, action: str, **kwargs: Any) -> None:
+        if action == "info":
+            self.info()
+            return
+        result = self.request(action, **kwargs).get("result")
+        if result:
+            out = (
+                dumps(result)
+                if isinstance(result, (list, dict))
+                else str(result)
+            )
+            sys.stdout.write(out + "\n")
+
+    def info(self) -> None:
+        out = sys.stdout.write
+        response = self.request("", "GET")
+        if self.raw or not response:
+            return
+        data = response["result"]
+        display = data.pop("info")
+        extra = display.pop("extra", {})
+        display["packages"] = ", ".join(display["packages"])
+        MOTDTTY(get_logo(), self.base_url, display, extra).display(
+            version=False,
+            action="Inspecting",
+            out=out,
+        )
+        for name, info in data["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"
+            )
+
+    def request(self, action: str, method: str = "POST", **kwargs: Any) -> Any:
+        url = f"{self.base_url}/{action}"
+        params: Dict[str, Any] = {"method": method, "headers": {}}
+        if kwargs:
+            params["data"] = dumps(kwargs).encode()
+            params["headers"]["content-type"] = "application/json"
+        if self.api_key:
+            params["headers"]["authorization"] = f"Bearer {self.api_key}"
+        request = URequest(url, **params)
+
+        try:
+            with urlopen(request) as response:  # nosec B310
+                raw = response.read()
+                loaded = loads(raw)
+                if self.raw:
+                    sys.stdout.write(dumps(loaded.get("result")) + "\n")
+                    return {}
+                return loaded
+        except (URLError, RemoteDisconnected) as e:
+            sys.stderr.write(
+                f"{Colors.RED}Could not connect to inspector at: "
+                f"{Colors.YELLOW}{self.base_url}{Colors.END}\n"
+                "Either the application is not running, or it did not start "
+                f"an inspector instance.\n{e}\n"
+            )
+            sys.exit(1)
+
+    @property
+    def base_url(self):
+        return f"{self.scheme}://{self.host}:{self.port}"
--- a/sanic/compat.py
+++ b/sanic/compat.py
@@ -3,10 +3,23 @@ import os
 import signal
 import sys

-from typing import Awaitable
+from contextlib import contextmanager
+from enum import Enum
+from typing import Awaitable, Union

 from multidict import CIMultiDict  # type: ignore

+from sanic.helpers import Default
+
+
+if sys.version_info < (3, 8):  # no cov
+    StartMethod = Union[Default, str]
+else:  # no cov
+    from typing import Literal
+
+    StartMethod = Union[
+        Default, Literal["fork"], Literal["forkserver"], Literal["spawn"]
+    ]

 OS_IS_WINDOWS = os.name == "nt"
 UVLOOP_INSTALLED = False
@@ -18,6 +31,40 @@ try:
 except ImportError:
    pass

+# Python 3.11 changed the way Enum formatting works for mixed-in types.
+if sys.version_info < (3, 11, 0):
+
+    class StrEnum(str, Enum):
+        pass
+
+else:
+    from enum import StrEnum  # type: ignore # noqa
+
+
+class UpperStrEnum(StrEnum):
+    def _generate_next_value_(name, start, count, last_values):
+        return name.upper()
+
+    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
+
+
+@contextmanager
+def use_context(method: StartMethod):
+    from sanic import Sanic
+
+    orig = Sanic.start_method
+    Sanic.start_method = method
+    yield
+    Sanic.start_method = orig
+

 def enable_windows_color_support():
    import ctypes
--- a/sanic/config.py
+++ b/sanic/config.py
@@ -2,6 +2,7 @@ from __future__ import annotations

 import sys

+from abc import ABCMeta
 from inspect import getmembers, isclass, isdatadescriptor
 from os import environ
 from pathlib import Path
@@ -46,6 +47,9 @@ DEFAULT_CONFIG = {
    "INSPECTOR": False,
    "INSPECTOR_HOST": "localhost",
    "INSPECTOR_PORT": 6457,
+    "INSPECTOR_TLS_KEY": _default,
+    "INSPECTOR_TLS_CERT": _default,
+    "INSPECTOR_API_KEY": "",
    "KEEP_ALIVE_TIMEOUT": 5,  # 5 seconds
    "KEEP_ALIVE": True,
    "LOCAL_CERT_CREATOR": LocalCertCreator.AUTO,
@@ -72,7 +76,7 @@ DEFAULT_CONFIG = {
 }


-class DescriptorMeta(type):
+class DescriptorMeta(ABCMeta):
    def __init__(cls, *_):
        cls.__setters__ = {name for name, _ in getmembers(cls, cls._is_setter)}

@@ -93,6 +97,9 @@ class Config(dict, metaclass=DescriptorMeta):
    INSPECTOR: bool
    INSPECTOR_HOST: str
    INSPECTOR_PORT: int
+    INSPECTOR_TLS_KEY: Union[Path, str, Default]
+    INSPECTOR_TLS_CERT: Union[Path, str, Default]
+    INSPECTOR_API_KEY: str
    KEEP_ALIVE_TIMEOUT: int
    KEEP_ALIVE: bool
    LOCAL_CERT_CREATOR: Union[str, LocalCertCreator]
@@ -120,7 +127,9 @@ class Config(dict, metaclass=DescriptorMeta):

    def __init__(
        self,
-        defaults: Dict[str, Union[str, bool, int, float, None]] = None,
+        defaults: Optional[
+            Dict[str, Union[str, bool, int, float, None]]
+        ] = None,
        env_prefix: Optional[str] = SANIC_PREFIX,
        keep_alive: Optional[bool] = None,
        *,
--- a/sanic/constants.py
+++ b/sanic/constants.py
@@ -1,20 +1,9 @@
-from enum import Enum, auto
+from enum import auto
+
+from sanic.compat import UpperStrEnum


-class HTTPMethod(str, Enum):
-    def _generate_next_value_(name, start, count, last_values):
-        return name.upper()
-
-    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 HTTPMethod(UpperStrEnum):
    GET = auto()
    POST = auto()
    PUT = auto()
@@ -24,10 +13,7 @@ class HTTPMethod(str, Enum):
    DELETE = auto()


-class LocalCertCreator(str, Enum):
-    def _generate_next_value_(name, start, count, last_values):
-        return name.upper()
-
+class LocalCertCreator(UpperStrEnum):
    AUTO = auto()
    TRUSTME = auto()
    MKCERT = auto()
--- a/sanic/errorpages.py
+++ b/sanic/errorpages.py
@@ -12,6 +12,7 @@ Setting ``app.config.FALLBACK_ERROR_FORMAT = "auto"`` will enable a switch that
 will attempt to provide an appropriate response format based upon the
 request type.
 """
+from __future__ import annotations

 import sys
 import typing as t
@@ -21,8 +22,8 @@ from traceback import extract_tb

 from sanic.exceptions import BadRequest, SanicException
 from sanic.helpers import STATUS_CODES
-from sanic.request import Request
-from sanic.response import HTTPResponse, html, json, text
+from sanic.pages.error import ErrorPage
+from sanic.response import html, json, text


 dumps: t.Callable[..., str]
@@ -33,6 +34,8 @@ try:
 except ImportError:  # noqa
    from json import dumps

+if t.TYPE_CHECKING:
+    from sanic import HTTPResponse, Request

 DEFAULT_FORMAT = "auto"
 FALLBACK_TEXT = (
@@ -157,36 +160,21 @@ class HTMLRenderer(BaseRenderer):
        "{body}"
    )

-    def full(self) -> HTTPResponse:
-        return html(
-            self.OUTPUT_HTML.format(
-                title=self.title,
-                text=self.text,
-                style=self.TRACEBACK_STYLE,
-                body=self._generate_body(full=True),
-            ),
-            status=self.status,
+    def _page(self, full: bool) -> HTTPResponse:
+        page = ErrorPage(
+            title=super().title,
+            text=super().text,
+            request=self.request,
+            exc=self.exception,
+            full=full,
        )
+        return html(page.render(), status=self.status, headers=self.headers)
+
+    def full(self) -> HTTPResponse:
+        return self._page(full=True)

    def minimal(self) -> HTTPResponse:
-        return html(
-            self.OUTPUT_HTML.format(
-                title=self.title,
-                text=self.text,
-                style=self.TRACEBACK_STYLE,
-                body=self._generate_body(full=False),
-            ),
-            status=self.status,
-            headers=self.headers,
-        )
-
-    @property
-    def text(self):
-        return escape(super().text)
-
-    @property
-    def title(self):
-        return escape(f"⚠️ {super().title}")
+        return self._page(full=False)

    def _generate_body(self, *, full):
        lines = []
@@ -404,16 +392,13 @@ CONTENT_TYPE_BY_RENDERERS = {
    v: k for k, v in RENDERERS_BY_CONTENT_TYPE.items()
 }

+# Handler source code is checked for which response types it returns with the
+# route error_format="auto" (default) to determine which format to use.
 RESPONSE_MAPPING = {
-    "empty": "html",
    "json": "json",
    "text": "text",
-    "raw": "text",
    "html": "html",
-    "file": "html",
-    "file_stream": "text",
-    "stream": "text",
-    "redirect": "html",
+    "JSONResponse": "json",
    "text/plain": "text",
    "text/html": "html",
    "application/json": "json",
--- a/sanic/handlers/init.py
+++ b/sanic/handlers/init.py
@@ -0,0 +1,10 @@
+from .content_range import ContentRangeHandler
+from .directory import DirectoryHandler
+from .error import ErrorHandler
+
+
+__all__ = (
+    "ContentRangeHandler",
+    "DirectoryHandler",
+    "ErrorHandler",
+)
--- a/sanic/handlers/content_range.py
+++ b/sanic/handlers/content_range.py
@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+from sanic.exceptions import (
+    HeaderNotFound,
+    InvalidRangeType,
+    RangeNotSatisfiable,
+)
+
+
+class ContentRangeHandler:
+    """
+    A mechanism to parse and process the incoming request headers to
+    extract the content range information.
+
+    :param request: Incoming api request
+    :param stats: Stats related to the content
+
+    :type request: :class:`sanic.request.Request`
+    :type stats: :class:`posix.stat_result`
+
+    :ivar start: Content Range start
+    :ivar end: Content Range end
+    :ivar size: Length of the content
+    :ivar total: Total size identified by the :class:`posix.stat_result`
+        instance
+    :ivar ContentRangeHandler.headers: Content range header ``dict``
+    """
+
+    __slots__ = ("start", "end", "size", "total", "headers")
+
+    def __init__(self, request, stats):
+        self.total = stats.st_size
+        _range = request.headers.getone("range", None)
+        if _range is None:
+            raise HeaderNotFound("Range Header Not Found")
+        unit, _, value = tuple(map(str.strip, _range.partition("=")))
+        if unit != "bytes":
+            raise InvalidRangeType(
+                "%s is not a valid Range Type" % (unit,), self
+            )
+        start_b, _, end_b = tuple(map(str.strip, value.partition("-")))
+        try:
+            self.start = int(start_b) if start_b else None
+        except ValueError:
+            raise RangeNotSatisfiable(
+                "'%s' is invalid for Content Range" % (start_b,), self
+            )
+        try:
+            self.end = int(end_b) if end_b else None
+        except ValueError:
+            raise RangeNotSatisfiable(
+                "'%s' is invalid for Content Range" % (end_b,), self
+            )
+        if self.end is None:
+            if self.start is None:
+                raise RangeNotSatisfiable(
+                    "Invalid for Content Range parameters", self
+                )
+            else:
+                # this case represents `Content-Range: bytes 5-`
+                self.end = self.total - 1
+        else:
+            if self.start is None:
+                # this case represents `Content-Range: bytes -5`
+                self.start = self.total - self.end
+                self.end = self.total - 1
+        if self.start >= self.end:
+            raise RangeNotSatisfiable(
+                "Invalid for Content Range parameters", self
+            )
+        self.size = self.end - self.start + 1
+        self.headers = {
+            "Content-Range": "bytes %s-%s/%s"
+            % (self.start, self.end, self.total)
+        }
+
+    def __bool__(self):
+        return self.size > 0
--- a/sanic/handlers/directory.py
+++ b/sanic/handlers/directory.py
@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+from datetime import datetime
+from operator import itemgetter
+from pathlib import Path
+from stat import S_ISDIR
+from typing import Dict, Iterable, Optional, Sequence, Union, cast
+
+from sanic.exceptions import NotFound
+from sanic.pages.directory_page import DirectoryPage, FileInfo
+from sanic.request import Request
+from sanic.response import file, html, redirect
+
+
+class DirectoryHandler:
+    def __init__(
+        self,
+        uri: str,
+        directory: Path,
+        directory_view: bool = False,
+        index: Optional[Union[str, Sequence[str]]] = None,
+    ) -> None:
+        if isinstance(index, str):
+            index = [index]
+        elif index is None:
+            index = []
+        self.base = uri.strip("/")
+        self.directory = directory
+        self.directory_view = directory_view
+        self.index = tuple(index)
+
+    async def handle(self, request: Request, path: str):
+        current = path.strip("/")[len(self.base) :].strip("/")  # noqa: E203
+        for file_name in self.index:
+            index_file = self.directory / current / file_name
+            if index_file.is_file():
+                return await file(index_file)
+
+        if self.directory_view:
+            return self._index(
+                self.directory / current, path, request.app.debug
+            )
+
+        if self.index:
+            raise NotFound("File not found")
+
+        raise IsADirectoryError(f"{self.directory.as_posix()} is a directory")
+
+    def _index(self, location: Path, path: str, debug: bool):
+        # Remove empty path elements, append slash
+        if "//" in path or not path.endswith("/"):
+            return redirect(
+                "/" + "".join([f"{p}/" for p in path.split("/") if p])
+            )
+
+        # Render file browser
+        page = DirectoryPage(self._iter_files(location), path, debug)
+        return html(page.render())
+
+    def _prepare_file(self, path: Path) -> Dict[str, Union[int, str]]:
+        stat = path.stat()
+        modified = (
+            datetime.fromtimestamp(stat.st_mtime)
+            .isoformat()[:19]
+            .replace("T", " ")
+        )
+        is_dir = S_ISDIR(stat.st_mode)
+        icon = "📁" if is_dir else "📄"
+        file_name = path.name
+        if is_dir:
+            file_name += "/"
+        return {
+            "priority": is_dir * -1,
+            "file_name": file_name,
+            "icon": icon,
+            "file_access": modified,
+            "file_size": stat.st_size,
+        }
+
+    def _iter_files(self, location: Path) -> Iterable[FileInfo]:
+        prepared = [self._prepare_file(f) for f in location.iterdir()]
+        for item in sorted(prepared, key=itemgetter("priority", "file_name")):
+            del item["priority"]
+            yield cast(FileInfo, item)
--- a/sanic/handlers/error.py
+++ b/sanic/handlers/error.py
@@ -3,11 +3,6 @@ from __future__ import annotations
 from typing import Dict, List, Optional, Tuple, Type

 from sanic.errorpages import BaseRenderer, TextRenderer, exception_response
-from sanic.exceptions import (
-    HeaderNotFound,
-    InvalidRangeType,
-    RangeNotSatisfiable,
-)
 from sanic.log import deprecation, error_logger
 from sanic.models.handler_types import RouteHandler
 from sanic.response import text
@@ -23,7 +18,6 @@ class ErrorHandler:
    by the developers to perform a wide range of tasks from recording the error
    stats to reporting them to an external service that can be used for
    realtime alerting system.
-
    """

    def __init__(
@@ -36,14 +30,6 @@ class ErrorHandler:
        self.debug = False
        self.base = base

-    @classmethod
-    def finalize(cls, *args, **kwargs):
-        deprecation(
-            "ErrorHandler.finalize is deprecated and no longer needed. "
-            "Please remove update your code to remove it. ",
-            22.12,
-        )
-
    def _full_lookup(self, exception, route_name: Optional[str] = None):
        return self.lookup(exception, route_name)

@@ -204,74 +190,3 @@ class ErrorHandler:
            error_logger.exception(
                "Exception occurred while handling uri: %s", url
            )
-
-
-class ContentRangeHandler:
-    """
-    A mechanism to parse and process the incoming request headers to
-    extract the content range information.
-
-    :param request: Incoming api request
-    :param stats: Stats related to the content
-
-    :type request: :class:`sanic.request.Request`
-    :type stats: :class:`posix.stat_result`
-
-    :ivar start: Content Range start
-    :ivar end: Content Range end
-    :ivar size: Length of the content
-    :ivar total: Total size identified by the :class:`posix.stat_result`
-        instance
-    :ivar ContentRangeHandler.headers: Content range header ``dict``
-    """
-
-    __slots__ = ("start", "end", "size", "total", "headers")
-
-    def __init__(self, request, stats):
-        self.total = stats.st_size
-        _range = request.headers.getone("range", None)
-        if _range is None:
-            raise HeaderNotFound("Range Header Not Found")
-        unit, _, value = tuple(map(str.strip, _range.partition("=")))
-        if unit != "bytes":
-            raise InvalidRangeType(
-                "%s is not a valid Range Type" % (unit,), self
-            )
-        start_b, _, end_b = tuple(map(str.strip, value.partition("-")))
-        try:
-            self.start = int(start_b) if start_b else None
-        except ValueError:
-            raise RangeNotSatisfiable(
-                "'%s' is invalid for Content Range" % (start_b,), self
-            )
-        try:
-            self.end = int(end_b) if end_b else None
-        except ValueError:
-            raise RangeNotSatisfiable(
-                "'%s' is invalid for Content Range" % (end_b,), self
-            )
-        if self.end is None:
-            if self.start is None:
-                raise RangeNotSatisfiable(
-                    "Invalid for Content Range parameters", self
-                )
-            else:
-                # this case represents `Content-Range: bytes 5-`
-                self.end = self.total - 1
-        else:
-            if self.start is None:
-                # this case represents `Content-Range: bytes -5`
-                self.start = self.total - self.end
-                self.end = self.total - 1
-        if self.start >= self.end:
-            raise RangeNotSatisfiable(
-                "Invalid for Content Range parameters", self
-            )
-        self.size = self.end - self.start + 1
-        self.headers = {
-            "Content-Range": "bytes %s-%s/%s"
-            % (self.start, self.end, self.total)
-        }
-
-    def __bool__(self):
-        return self.size > 0
--- a/sanic/http/http1.py
+++ b/sanic/http/http1.py
@@ -71,7 +71,6 @@ class Http(Stream, metaclass=TouchUpMeta):
        "request_body",
        "request_bytes",
        "request_bytes_left",
-        "request_max_size",
        "response",
        "response_func",
        "response_size",
--- a/sanic/http/stream.py
+++ b/sanic/http/stream.py
@@ -19,7 +19,7 @@ class Stream:
    request_max_size: Union[int, float]

    __touchup__: Tuple[str, ...] = tuple()
-    __slots__ = ()
+    __slots__ = ("request_max_size",)

    def respond(
        self, response: BaseHTTPResponse
--- a/sanic/http/tls/context.py
+++ b/sanic/http/tls/context.py
@@ -24,13 +24,15 @@ def create_context(
    certfile: Optional[str] = None,
    keyfile: Optional[str] = None,
    password: Optional[str] = None,
+    purpose: ssl.Purpose = ssl.Purpose.CLIENT_AUTH,
 ) -> ssl.SSLContext:
    """Create a context with secure crypto and HTTP/1.1 in protocols."""
-    context = ssl.create_default_context(purpose=ssl.Purpose.CLIENT_AUTH)
+    context = ssl.create_default_context(purpose=purpose)
    context.minimum_version = ssl.TLSVersion.TLSv1_2
    context.set_ciphers(":".join(CIPHERS_TLS12))
    context.set_alpn_protocols(["http/1.1"])
-    context.sni_callback = server_name_callback
+    if purpose is ssl.Purpose.CLIENT_AUTH:
+        context.sni_callback = server_name_callback
    if certfile and keyfile:
        context.load_cert_chain(certfile, keyfile, password)
    return context
--- a/sanic/http/tls/creators.py
+++ b/sanic/http/tls/creators.py
@@ -126,7 +126,6 @@ class CertCreator(ABC):
        local_tls_key,
        local_tls_cert,
    ) -> CertCreator:
-
        creator: Optional[CertCreator] = None

        cert_creator_options: Tuple[
--- a/sanic/middleware.py
+++ b/sanic/middleware.py
@@ -32,6 +32,9 @@ class Middleware:
    def __call__(self, *args, **kwargs):
        return self.func(*args, **kwargs)

+    def __hash__(self) -> int:
+        return hash(self.func)
+
    def __repr__(self) -> str:
        return (
            f"{self.__class__.__name__}("
--- a/sanic/mixins/base.py
+++ b/sanic/mixins/base.py
@@ -0,0 +1,35 @@
+from typing import Optional
+
+from sanic.base.meta import SanicMeta
+
+
+class BaseMixin(metaclass=SanicMeta):
+    name: str
+    strict_slashes: Optional[bool]
+
+    def _generate_name(self, *objects) -> str:
+        name = None
+
+        for obj in objects:
+            if obj:
+                if isinstance(obj, str):
+                    name = obj
+                    break
+
+                try:
+                    name = obj.name
+                except AttributeError:
+                    try:
+                        name = obj.__name__
+                    except AttributeError:
+                        continue
+                else:
+                    break
+
+        if not name:  # noqa
+            raise ValueError("Could not generate a name for handler")
+
+        if not name.startswith(f"{self.name}."):
+            name = f"{self.name}.{name}"
+
+        return name
--- a/sanic/mixins/middleware.py
+++ b/sanic/mixins/middleware.py
@@ -14,6 +14,7 @@ class MiddlewareMixin(metaclass=SanicMeta):

    def __init__(self, *args, **kwargs) -> None:
        self._future_middleware: List[FutureMiddleware] = []
+        self.wrappers = []

    def _apply_middleware(self, middleware: FutureMiddleware):
        raise NotImplementedError  # noqa
@@ -140,3 +141,7 @@ class MiddlewareMixin(metaclass=SanicMeta):
                reverse=True,
            )[::-1]
        )
+
+    def wrap(self, handler):
+        self.wrappers.append(handler)
+        return handler
--- a/sanic/mixins/routes.py
+++ b/sanic/mixins/routes.py
@@ -1,11 +1,6 @@
 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 typing import (
    Any,
@@ -19,20 +14,15 @@ from typing import (
    Union,
    cast,
 )
-from urllib.parse import unquote

 from sanic_routing.route import Route

 from sanic.base.meta import SanicMeta
-from sanic.compat import stat_async
-from sanic.constants import DEFAULT_HTTP_CONTENT_TYPE, HTTP_METHODS
+from sanic.constants import HTTP_METHODS
 from sanic.errorpages import RESPONSE_MAPPING
-from sanic.exceptions import FileNotFound, HeaderNotFound, RangeNotSatisfiable
-from sanic.handlers import ContentRangeHandler
-from sanic.log import error_logger
+from sanic.mixins.base import BaseMixin
 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.types import HashableDict


@@ -41,20 +31,14 @@ RouteWrapper = Callable[
 ]


-class RouteMixin(metaclass=SanicMeta):
-    name: str
-
+class RouteMixin(BaseMixin, metaclass=SanicMeta):
    def __init__(self, *args, **kwargs) -> None:
        self._future_routes: Set[FutureRoute] = set()
        self._future_statics: Set[FutureStatic] = set()
-        self.strict_slashes: Optional[bool] = False

    def _apply_route(self, route: FutureRoute) -> List[Route]:
        raise NotImplementedError  # noqa

-    def _apply_static(self, static: FutureStatic) -> Route:
-        raise NotImplementedError  # noqa
-
    def route(
        self,
        uri: str,
@@ -218,6 +202,7 @@ class RouteMixin(metaclass=SanicMeta):
        stream: bool = False,
        version_prefix: str = "/v",
        error_format: Optional[str] = None,
+        unquote: bool = False,
        **ctx_kwargs: Any,
    ) -> RouteHandler:
        """A helper method to register class instance or
@@ -264,6 +249,7 @@ class RouteMixin(metaclass=SanicMeta):
            name=name,
            version_prefix=version_prefix,
            error_format=error_format,
+            unquote=unquote,
            **ctx_kwargs,
        )(handler)
        return handler
@@ -686,324 +672,6 @@ class RouteMixin(metaclass=SanicMeta):
            **ctx_kwargs,
        )(handler)

-    def static(
-        self,
-        uri: str,
-        file_or_directory: Union[str, bytes, PurePath],
-        pattern: str = r"/?.+",
-        use_modified_since: bool = True,
-        use_content_range: bool = False,
-        stream_large_files: bool = False,
-        name: str = "static",
-        host: Optional[str] = None,
-        strict_slashes: Optional[bool] = None,
-        content_type: Optional[bool] = None,
-        apply: bool = True,
-        resource_type: Optional[str] = None,
-    ):
-        """
-        Register a root to serve files from. The input can either be a
-        file or a directory. This method will enable an easy and simple way
-        to setup the :class:`Route` necessary to serve the static files.
-
-        :param uri: URL path to be used for serving static content
-        :param file_or_directory: Path for the Static file/directory with
-            static files
-        :param pattern: Regex Pattern identifying the valid static files
-        :param use_modified_since: If true, send file modified time, and return
-            not modified if the browser's matches the server's
-        :param use_content_range: If true, process header for range requests
-            and sends the file part that is requested
-        :param stream_large_files: If true, use the
-            :func:`StreamingHTTPResponse.file_stream` handler rather
-            than the :func:`HTTPResponse.file` handler to send the file.
-            If this is an integer, this represents the threshold size to
-            switch to :func:`StreamingHTTPResponse.file_stream`
-        :param name: user defined name used for url_for
-        :param host: Host IP or FQDN for the service to use
-        :param strict_slashes: Instruct :class:`Sanic` to check if the request
-            URLs need to terminate with a */*
-        :param content_type: user defined content type for header
-        :return: routes registered on the router
-        :rtype: List[sanic.router.Route]
-        """
-
-        name = self._generate_name(name)
-
-        if strict_slashes is None and self.strict_slashes is not None:
-            strict_slashes = self.strict_slashes
-
-        if not isinstance(file_or_directory, (str, bytes, PurePath)):
-            raise ValueError(
-                f"Static route must be a valid path, not {file_or_directory}"
-            )
-
-        static = FutureStatic(
-            uri,
-            file_or_directory,
-            pattern,
-            use_modified_since,
-            use_content_range,
-            stream_large_files,
-            name,
-            host,
-            strict_slashes,
-            content_type,
-            resource_type,
-        )
-        self._future_statics.add(static)
-
-        if apply:
-            self._apply_static(static)
-
-    def _generate_name(self, *objects) -> str:
-        name = None
-
-        for obj in objects:
-            if obj:
-                if isinstance(obj, str):
-                    name = obj
-                    break
-
-                try:
-                    name = obj.name
-                except AttributeError:
-                    try:
-                        name = obj.__name__
-                    except AttributeError:
-                        continue
-                else:
-                    break
-
-        if not name:  # noqa
-            raise ValueError("Could not generate a name for handler")
-
-        if not name.startswith(f"{self.name}."):
-            name = f"{self.name}.{name}"
-
-        return name
-
-    async def _get_file_path(self, file_or_directory, __file_uri__, not_found):
-        file_path_raw = Path(unquote(file_or_directory))
-        root_path = file_path = file_path_raw.resolve()
-
-        if __file_uri__:
-            # Strip all / that in the beginning of the URL to help prevent
-            # python from herping a derp and treating the uri as an
-            # absolute path
-            unquoted_file_uri = unquote(__file_uri__).lstrip("/")
-            file_path_raw = Path(file_or_directory, unquoted_file_uri)
-            file_path = file_path_raw.resolve()
-            if (
-                file_path < root_path and not file_path_raw.is_symlink()
-            ) or ".." in file_path_raw.parts:
-                error_logger.exception(
-                    f"File not found: path={file_or_directory}, "
-                    f"relative_url={__file_uri__}"
-                )
-                raise not_found
-
-        try:
-            file_path.relative_to(root_path)
-        except ValueError:
-            if not file_path_raw.is_symlink():
-                error_logger.exception(
-                    f"File not found: path={file_or_directory}, "
-                    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
-            # and it has not been modified since
-            stats = None
-            if use_modified_since:
-                stats = await stat_async(file_path)
-                modified_since = stats.st_mtime
-                response = await validate_file(request.headers, modified_since)
-                if response:
-                    return response
-                headers["Last-Modified"] = formatdate(
-                    modified_since, usegmt=True
-                )
-            _range = None
-            if use_content_range:
-                _range = None
-                if not stats:
-                    stats = await stat_async(file_path)
-                headers["Accept-Ranges"] = "bytes"
-                headers["Content-Length"] = str(stats.st_size)
-                if request.method != "HEAD":
-                    try:
-                        _range = ContentRangeHandler(request, stats)
-                    except HeaderNotFound:
-                        pass
-                    else:
-                        del headers["Content-Length"]
-                        headers.update(_range.headers)
-
-            if "content-type" not in headers:
-                content_type = (
-                    content_type
-                    or guess_type(file_path)[0]
-                    or DEFAULT_HTTP_CONTENT_TYPE
-                )
-
-                if "charset=" not in content_type and (
-                    content_type.startswith("text/")
-                    or content_type == "application/javascript"
-                ):
-                    content_type += "; charset=utf-8"
-
-                headers["Content-Type"] = content_type
-
-            if request.method == "HEAD":
-                return HTTPResponse(headers=headers)
-            else:
-                if stream_large_files:
-                    if type(stream_large_files) == int:
-                        threshold = stream_large_files
-                    else:
-                        threshold = 1024 * 1024
-
-                    if not stats:
-                        stats = await stat_async(file_path)
-                    if stats.st_size >= threshold:
-                        return await file_stream(
-                            file_path, headers=headers, _range=_range
-                        )
-                return await file(file_path, headers=headers, _range=_range)
-        except RangeNotSatisfiable:
-            raise
-        except FileNotFoundError:
-            raise not_found
-        except Exception:
-            error_logger.exception(
-                f"Exception in static request handler: "
-                f"path={file_or_directory}, "
-                f"relative_url={__file_uri__}"
-            )
-            raise
-
-    def _register_static(
-        self,
-        static: FutureStatic,
-    ):
-        # TODO: Though sanic is not a file server, I feel like we should
-        # at least make a good effort here.  Modified-since is nice, but
-        # we could also look into etags, expires, and caching
-        """
-        Register a static directory handler with Sanic by adding a route to the
-        router and registering a handler.
-
-        :param app: Sanic
-        :param file_or_directory: File or directory path to serve from
-        :type file_or_directory: Union[str,bytes,Path]
-        :param uri: URL to serve from
-        :type uri: str
-        :param pattern: regular expression used to match files in the URL
-        :param use_modified_since: If true, send file modified time, and return
-                                not modified if the browser's matches the
-                                server's
-        :param use_content_range: If true, process header for range requests
-                                and sends the file part that is requested
-        :param stream_large_files: If true, use the file_stream() handler
-                                rather than the file() handler to send the file
-                                If this is an integer, this represents the
-                                threshold size to switch to file_stream()
-        :param name: user defined name used for url_for
-        :type name: str
-        :param content_type: user defined content type for header
-        :return: registered static routes
-        :rtype: List[sanic.router.Route]
-        """
-
-        if isinstance(static.file_or_directory, bytes):
-            file_or_directory = static.file_or_directory.decode("utf-8")
-        elif isinstance(static.file_or_directory, PurePath):
-            file_or_directory = str(static.file_or_directory)
-        elif not isinstance(static.file_or_directory, str):
-            raise ValueError("Invalid file path string.")
-        else:
-            file_or_directory = static.file_or_directory
-
-        uri = static.uri
-        name = static.name
-        # If we're not trying to match a file directly,
-        # 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):
-                raise TypeError(
-                    "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
-        ):
-            raise TypeError(
-                "Resource type improperly identified as file. "
-                f"'{file_or_directory}'"
-            )
-        elif static.resource_type != "file":
-            raise ValueError(
-                "The resource_type should be set to 'file' or 'dir'"
-            )
-
-        # special prefix for static files
-        # if not static.name.startswith("_static_"):
-        #     name = f"_static_{static.name}"
-
-        _handler = wraps(self._static_request_handler)(
-            partial(
-                self._static_request_handler,
-                file_or_directory,
-                static.use_modified_since,
-                static.use_content_range,
-                static.stream_large_files,
-                content_type=static.content_type,
-            )
-        )
-
-        route, _ = self.route(  # type: ignore
-            uri=uri,
-            methods=["GET", "HEAD"],
-            name=name,
-            host=static.host,
-            strict_slashes=static.strict_slashes,
-            static=True,
-        )(_handler)
-
-        return route
-
    def _determine_error_format(self, handler) -> str:
        with suppress(OSError, TypeError):
            src = dedent(getsource(handler))
--- a/sanic/mixins/signals.py
+++ b/sanic/mixins/signals.py
@@ -20,7 +20,7 @@ class SignalMixin(metaclass=SanicMeta):
        event: Union[str, Enum],
        *,
        apply: bool = True,
-        condition: Dict[str, Any] = None,
+        condition: Optional[Dict[str, Any]] = None,
        exclusive: bool = True,
    ) -> Callable[[SignalHandler], SignalHandler]:
        """
@@ -64,7 +64,7 @@ class SignalMixin(metaclass=SanicMeta):
        self,
        handler: Optional[Callable[..., Any]],
        event: str,
-        condition: Dict[str, Any] = None,
+        condition: Optional[Dict[str, Any]] = None,
        exclusive: bool = True,
    ):
        if not handler:
--- a/sanic/mixins/startup.py
+++ b/sanic/mixins/startup.py
@@ -27,6 +27,7 @@ from typing import (
    Callable,
    Dict,
    List,
+    Mapping,
    Optional,
    Set,
    Tuple,
@@ -40,9 +41,9 @@ 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.compat import OS_IS_WINDOWS, StartMethod, is_atty
 from sanic.exceptions import ServerKilled
-from sanic.helpers import Default
+from sanic.helpers import Default, _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
@@ -58,7 +59,6 @@ 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
@@ -88,6 +88,7 @@ class StartupMixin(metaclass=SanicMeta):
    state: ApplicationState
    websocket_enabled: bool
    multiplexer: WorkerMultiplexer
+    start_method: StartMethod = _default

    def setup_loop(self):
        if not self.asgi:
@@ -125,7 +126,7 @@ class StartupMixin(metaclass=SanicMeta):
        register_sys_signals: bool = True,
        access_log: Optional[bool] = None,
        unix: Optional[str] = None,
-        loop: AbstractEventLoop = None,
+        loop: Optional[AbstractEventLoop] = None,
        reload_dir: Optional[Union[List[str], str]] = None,
        noisy_exceptions: Optional[bool] = None,
        motd: bool = True,
@@ -224,7 +225,7 @@ class StartupMixin(metaclass=SanicMeta):
        register_sys_signals: bool = True,
        access_log: Optional[bool] = None,
        unix: Optional[str] = None,
-        loop: AbstractEventLoop = None,
+        loop: Optional[AbstractEventLoop] = None,
        reload_dir: Optional[Union[List[str], str]] = None,
        noisy_exceptions: Optional[bool] = None,
        motd: bool = True,
@@ -266,11 +267,11 @@ class StartupMixin(metaclass=SanicMeta):
        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 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)
@@ -354,12 +355,12 @@ class StartupMixin(metaclass=SanicMeta):
        debug: bool = False,
        ssl: Union[None, SSLContext, dict, str, list, tuple] = None,
        sock: Optional[socket] = None,
-        protocol: Type[Protocol] = None,
+        protocol: Optional[Type[Protocol]] = None,
        backlog: int = 100,
        access_log: Optional[bool] = None,
        unix: Optional[str] = None,
        return_asyncio_server: bool = False,
-        asyncio_server_kwargs: Dict[str, Any] = None,
+        asyncio_server_kwargs: Optional[Dict[str, Any]] = None,
        noisy_exceptions: Optional[bool] = None,
    ) -> Optional[AsyncioServer]:
        """
@@ -480,7 +481,7 @@ class StartupMixin(metaclass=SanicMeta):
        sock: Optional[socket] = None,
        unix: Optional[str] = None,
        workers: int = 1,
-        loop: AbstractEventLoop = None,
+        loop: Optional[AbstractEventLoop] = None,
        protocol: Type[Protocol] = HttpProtocol,
        backlog: int = 100,
        register_sys_signals: bool = True,
@@ -692,12 +693,17 @@ class StartupMixin(metaclass=SanicMeta):
        return any(app.state.auto_reload for app in cls._app_registry.values())

    @classmethod
-    def _get_context(cls) -> BaseContext:
-        method = (
-            "spawn"
-            if "linux" not in sys.platform or cls.should_auto_reload()
-            else "fork"
+    def _get_startup_method(cls) -> str:
+        return (
+            cls.start_method
+            if not isinstance(cls.start_method, Default)
+            else "spawn"
        )
+
+    @classmethod
+    def _get_context(cls) -> BaseContext:
+        method = cls._get_startup_method()
+        logger.debug("Creating multiprocessing context using '%s'", method)
        return get_context(method)

    @classmethod
@@ -763,7 +769,7 @@ class StartupMixin(metaclass=SanicMeta):
            ]
            primary_server_info.settings["run_multiple"] = True
            monitor_sub, monitor_pub = Pipe(True)
-            worker_state: Dict[str, Any] = sync_manager.dict()
+            worker_state: Mapping[str, Any] = sync_manager.dict()
            kwargs: Dict[str, Any] = {
                **primary_server_info.settings,
                "monitor_publisher": monitor_pub,
@@ -819,7 +825,7 @@ class StartupMixin(metaclass=SanicMeta):
                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)
+                reloader = Reloader(monitor_pub, 0, reload_dirs, app_loader)
                manager.manage("Reloader", reloader, {}, transient=False)

            inspector = None
@@ -835,12 +841,15 @@ class StartupMixin(metaclass=SanicMeta):
                    "packages": [sanic_version, *packages],
                    "extra": extra,
                }
-                inspector = Inspector(
+                inspector = primary.inspector_class(
                    monitor_pub,
                    app_info,
                    worker_state,
                    primary.config.INSPECTOR_HOST,
                    primary.config.INSPECTOR_PORT,
+                    primary.config.INSPECTOR_API_KEY,
+                    primary.config.INSPECTOR_TLS_KEY,
+                    primary.config.INSPECTOR_TLS_CERT,
                )
                manager.manage("Inspector", inspector, {}, transient=False)

@@ -1100,7 +1109,6 @@ class StartupMixin(metaclass=SanicMeta):
        app: StartupMixin,
        server_info: ApplicationServerInfo,
    ) -> None:  # no cov
-
        try:
            # We should never get to this point without a server
            # This is primarily to keep mypy happy
--- a/sanic/mixins/static.py
+++ b/sanic/mixins/static.py
@@ -0,0 +1,348 @@
+from email.utils import formatdate
+from functools import partial, wraps
+from mimetypes import guess_type
+from os import PathLike, path
+from pathlib import Path, PurePath
+from typing import Optional, Sequence, Set, Union, cast
+from urllib.parse import unquote
+
+from sanic_routing.route import Route
+
+from sanic.base.meta import SanicMeta
+from sanic.compat import stat_async
+from sanic.constants import DEFAULT_HTTP_CONTENT_TYPE
+from sanic.exceptions import FileNotFound, HeaderNotFound, RangeNotSatisfiable
+from sanic.handlers import ContentRangeHandler
+from sanic.handlers.directory import DirectoryHandler
+from sanic.log import deprecation, error_logger
+from sanic.mixins.base import BaseMixin
+from sanic.models.futures import FutureStatic
+from sanic.request import Request
+from sanic.response import HTTPResponse, file, file_stream, validate_file
+
+
+class StaticMixin(BaseMixin, metaclass=SanicMeta):
+    def __init__(self, *args, **kwargs) -> None:
+        self._future_statics: Set[FutureStatic] = set()
+
+    def _apply_static(self, static: FutureStatic) -> Route:
+        raise NotImplementedError  # noqa
+
+    def static(
+        self,
+        uri: str,
+        file_or_directory: Union[PathLike, str, bytes],
+        pattern: str = r"/?.+",
+        use_modified_since: bool = True,
+        use_content_range: bool = False,
+        stream_large_files: Union[bool, int] = False,
+        name: str = "static",
+        host: Optional[str] = None,
+        strict_slashes: Optional[bool] = None,
+        content_type: Optional[str] = None,
+        apply: bool = True,
+        resource_type: Optional[str] = None,
+        index: Optional[Union[str, Sequence[str]]] = None,
+        directory_view: bool = False,
+        directory_handler: Optional[DirectoryHandler] = None,
+    ):
+        """
+        Register a root to serve files from. The input can either be a
+        file or a directory. This method will enable an easy and simple way
+        to setup the :class:`Route` necessary to serve the static files.
+
+        :param uri: URL path to be used for serving static content
+        :param file_or_directory: Path for the Static file/directory with
+            static files
+        :param pattern: Regex Pattern identifying the valid static files
+        :param use_modified_since: If true, send file modified time, and return
+            not modified if the browser's matches the server's
+        :param use_content_range: If true, process header for range requests
+            and sends the file part that is requested
+        :param stream_large_files: If true, use the
+            :func:`StreamingHTTPResponse.file_stream` handler rather
+            than the :func:`HTTPResponse.file` handler to send the file.
+            If this is an integer, this represents the threshold size to
+            switch to :func:`StreamingHTTPResponse.file_stream`
+        :param name: user defined name used for url_for
+        :param host: Host IP or FQDN for the service to use
+        :param strict_slashes: Instruct :class:`Sanic` to check if the request
+            URLs need to terminate with a */*
+        :param content_type: user defined content type for header
+        :param apply: If true, will register the route immediately
+        :param resource_type: Explicitly declare a resource to be a "
+            file" or a "dir"
+        :param index: When exposing against a directory, index is the name that
+            will be served as the default file. When multiple files names are
+            passed, then they will be tried in order.
+        :param directory_view: Whether to fallback to showing the directory
+            viewer when exposing a directory
+        :param directory_handler: An instance of :class:`DirectoryHandler`
+            that can be used for explicitly controlling and subclassing the
+            behavior of the default directory handler
+        :return: routes registered on the router
+        :rtype: List[sanic.router.Route]
+        """
+
+        name = self._generate_name(name)
+
+        if strict_slashes is None and self.strict_slashes is not None:
+            strict_slashes = self.strict_slashes
+
+        if not isinstance(file_or_directory, (str, bytes, PurePath)):
+            raise ValueError(
+                f"Static route must be a valid path, not {file_or_directory}"
+            )
+
+        if isinstance(file_or_directory, bytes):
+            deprecation(
+                "Serving a static directory with a bytes string is "
+                "deprecated and will be removed in v22.9.",
+                22.9,
+            )
+            file_or_directory = cast(str, file_or_directory.decode())
+        file_or_directory = Path(file_or_directory)
+
+        if directory_handler and (directory_view or index):
+            raise ValueError(
+                "When explicitly setting directory_handler, you cannot "
+                "set either directory_view or index. Instead, pass "
+                "these arguments to your DirectoryHandler instance."
+            )
+
+        if not directory_handler:
+            directory_handler = DirectoryHandler(
+                uri=uri,
+                directory=file_or_directory,
+                directory_view=directory_view,
+                index=index,
+            )
+
+        static = FutureStatic(
+            uri,
+            file_or_directory,
+            pattern,
+            use_modified_since,
+            use_content_range,
+            stream_large_files,
+            name,
+            host,
+            strict_slashes,
+            content_type,
+            resource_type,
+            directory_handler,
+        )
+        self._future_statics.add(static)
+
+        if apply:
+            self._apply_static(static)
+
+
+class StaticHandleMixin(metaclass=SanicMeta):
+    def _apply_static(self, static: FutureStatic) -> Route:
+        return self._register_static(static)
+
+    def _register_static(
+        self,
+        static: FutureStatic,
+    ):
+        # TODO: Though sanic is not a file server, I feel like we should
+        # at least make a good effort here.  Modified-since is nice, but
+        # we could also look into etags, expires, and caching
+        """
+        Register a static directory handler with Sanic by adding a route to the
+        router and registering a handler.
+        """
+
+        if isinstance(static.file_or_directory, bytes):
+            file_or_directory = static.file_or_directory.decode("utf-8")
+        elif isinstance(static.file_or_directory, PurePath):
+            file_or_directory = str(static.file_or_directory)
+        elif not isinstance(static.file_or_directory, str):
+            raise ValueError("Invalid file path string.")
+        else:
+            file_or_directory = static.file_or_directory
+
+        uri = static.uri
+        name = static.name
+        # If we're not trying to match a file directly,
+        # 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):
+                raise TypeError(
+                    "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
+        ):
+            raise TypeError(
+                "Resource type improperly identified as file. "
+                f"'{file_or_directory}'"
+            )
+        elif static.resource_type != "file":
+            raise ValueError(
+                "The resource_type should be set to 'file' or 'dir'"
+            )
+
+        # special prefix for static files
+        # if not static.name.startswith("_static_"):
+        #     name = f"_static_{static.name}"
+
+        _handler = wraps(self._static_request_handler)(
+            partial(
+                self._static_request_handler,
+                file_or_directory=file_or_directory,
+                use_modified_since=static.use_modified_since,
+                use_content_range=static.use_content_range,
+                stream_large_files=static.stream_large_files,
+                content_type=static.content_type,
+                directory_handler=static.directory_handler,
+            )
+        )
+
+        route, _ = self.route(  # type: ignore
+            uri=uri,
+            methods=["GET", "HEAD"],
+            name=name,
+            host=static.host,
+            strict_slashes=static.strict_slashes,
+            static=True,
+        )(_handler)
+
+        return route
+
+    async def _static_request_handler(
+        self,
+        request: Request,
+        *,
+        file_or_directory: PathLike,
+        use_modified_since: bool,
+        use_content_range: bool,
+        stream_large_files: Union[bool, int],
+        directory_handler: DirectoryHandler,
+        content_type: Optional[str] = None,
+        __file_uri__: Optional[str] = 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
+            # and it has not been modified since
+            stats = None
+            if use_modified_since:
+                stats = await stat_async(file_path)
+                modified_since = stats.st_mtime
+                response = await validate_file(request.headers, modified_since)
+                if response:
+                    return response
+                headers["Last-Modified"] = formatdate(
+                    modified_since, usegmt=True
+                )
+            _range = None
+            if use_content_range:
+                _range = None
+                if not stats:
+                    stats = await stat_async(file_path)
+                headers["Accept-Ranges"] = "bytes"
+                headers["Content-Length"] = str(stats.st_size)
+                if request.method != "HEAD":
+                    try:
+                        _range = ContentRangeHandler(request, stats)
+                    except HeaderNotFound:
+                        pass
+                    else:
+                        del headers["Content-Length"]
+                        headers.update(_range.headers)
+
+            if "content-type" not in headers:
+                content_type = (
+                    content_type
+                    or guess_type(file_path)[0]
+                    or DEFAULT_HTTP_CONTENT_TYPE
+                )
+
+                if "charset=" not in content_type and (
+                    content_type.startswith("text/")
+                    or content_type == "application/javascript"
+                ):
+                    content_type += "; charset=utf-8"
+
+                headers["Content-Type"] = content_type
+
+            if request.method == "HEAD":
+                return HTTPResponse(headers=headers)
+            else:
+                if stream_large_files:
+                    if isinstance(stream_large_files, bool):
+                        threshold = 1024 * 1024
+                    else:
+                        threshold = stream_large_files
+
+                    if not stats:
+                        stats = await stat_async(file_path)
+                    if stats.st_size >= threshold:
+                        return await file_stream(
+                            file_path, headers=headers, _range=_range
+                        )
+                return await file(file_path, headers=headers, _range=_range)
+        except (IsADirectoryError, PermissionError):
+            return await directory_handler.handle(request, request.path)
+        except RangeNotSatisfiable:
+            raise
+        except FileNotFoundError:
+            raise not_found
+        except Exception:
+            error_logger.exception(
+                "Exception in static request handler: "
+                f"path={file_or_directory}, "
+                f"relative_url={__file_uri__}"
+            )
+            raise
+
+    async def _get_file_path(self, file_or_directory, __file_uri__, not_found):
+        file_path_raw = Path(unquote(file_or_directory))
+        root_path = file_path = file_path_raw.resolve()
+
+        if __file_uri__:
+            # Strip all / that in the beginning of the URL to help prevent
+            # python from herping a derp and treating the uri as an
+            # absolute path
+            unquoted_file_uri = unquote(__file_uri__).lstrip("/")
+            file_path_raw = Path(file_or_directory, unquoted_file_uri)
+            file_path = file_path_raw.resolve()
+            if (
+                file_path < root_path and not file_path_raw.is_symlink()
+            ) or ".." in file_path_raw.parts:
+                error_logger.exception(
+                    f"File not found: path={file_or_directory}, "
+                    f"relative_url={__file_uri__}"
+                )
+                raise not_found
+
+        try:
+            file_path.relative_to(root_path)
+        except ValueError:
+            if not file_path_raw.is_symlink():
+                error_logger.exception(
+                    f"File not found: path={file_or_directory}, "
+                    f"relative_url={__file_uri__}"
+                )
+                raise not_found
+        return file_path
--- a/sanic/models/futures.py
+++ b/sanic/models/futures.py
@@ -1,6 +1,7 @@
-from pathlib import PurePath
+from pathlib import Path
 from typing import Dict, Iterable, List, NamedTuple, Optional, Union

+from sanic.handlers.directory import DirectoryHandler
 from sanic.models.handler_types import (
    ErrorMiddlewareType,
    ListenerType,
@@ -46,16 +47,17 @@ class FutureException(NamedTuple):

 class FutureStatic(NamedTuple):
    uri: str
-    file_or_directory: Union[str, bytes, PurePath]
+    file_or_directory: Path
    pattern: str
    use_modified_since: bool
    use_content_range: bool
-    stream_large_files: bool
+    stream_large_files: Union[bool, int]
    name: str
    host: Optional[str]
    strict_slashes: Optional[bool]
-    content_type: Optional[bool]
+    content_type: Optional[str]
    resource_type: Optional[str]
+    directory_handler: DirectoryHandler


 class FutureSignal(NamedTuple):
--- a/sanic/pages/init.py
+++ b/sanic/pages/init.py
--- a/sanic/pages/base.py
+++ b/sanic/pages/base.py
@@ -0,0 +1,52 @@
+from abc import ABC, abstractmethod
+
+from html5tagger import HTML, Document
+
+from sanic import __version__ as VERSION
+from sanic.application.logo import SVG_LOGO_SIMPLE
+from sanic.pages.css import CSS
+
+
+class BasePage(ABC, metaclass=CSS):  # no cov
+    TITLE = "Sanic"
+    CSS: str
+
+    def __init__(self, debug: bool = True) -> None:
+        self.doc = None
+        self.debug = debug
+
+    @property
+    def style(self) -> str:
+        return self.CSS
+
+    def render(self) -> str:
+        self.doc = Document(self.TITLE, lang="en")
+        self._head()
+        self._body()
+        self._foot()
+        return str(self.doc)
+
+    def _head(self) -> None:
+        self.doc.style(HTML(self.style))
+        with self.doc.header:
+            self.doc.div(self.TITLE)
+
+    def _foot(self) -> None:
+        with self.doc.footer:
+            self.doc.div("powered by")
+            with self.doc.div:
+                self._sanic_logo()
+            if self.debug:
+                self.doc.div(f"Version {VERSION}")
+
+    @abstractmethod
+    def _body(self) -> None:
+        ...
+
+    def _sanic_logo(self) -> None:
+        self.doc.a(
+            HTML(SVG_LOGO_SIMPLE),
+            href="https://sanic.dev",
+            target="_blank",
+            referrerpolicy="no-referrer",
+        )
--- a/sanic/pages/css.py
+++ b/sanic/pages/css.py
@@ -0,0 +1,35 @@
+from abc import ABCMeta
+from pathlib import Path
+from typing import Optional
+
+
+CURRENT_DIR = Path(__file__).parent
+
+
+def _extract_style(maybe_style: Optional[str], name: str) -> str:
+    if maybe_style is not None:
+        maybe_path = Path(maybe_style)
+        if maybe_path.exists():
+            return maybe_path.read_text(encoding="UTF-8")
+        return maybe_style
+    maybe_path = CURRENT_DIR / "styles" / f"{name}.css"
+    if maybe_path.exists():
+        return maybe_path.read_text(encoding="UTF-8")
+    return ""
+
+
+class CSS(ABCMeta):
+    """Cascade stylesheets, i.e. combine all ancestor styles"""
+
+    def __new__(cls, name, bases, attrs):
+        Page = super().__new__(cls, name, bases, attrs)
+        # Use a locally defined STYLE or the one from styles directory
+        Page.STYLE = _extract_style(attrs.get("STYLE_FILE"), name)
+        Page.STYLE += attrs.get("STYLE_APPEND", "")
+        # Combine with all ancestor styles
+        Page.CSS = "".join(
+            Class.STYLE
+            for Class in reversed(Page.__mro__)
+            if type(Class) is CSS
+        )
+        return Page
--- a/sanic/pages/directory_page.py
+++ b/sanic/pages/directory_page.py
@@ -0,0 +1,66 @@
+import sys
+
+from typing import Dict, Iterable
+
+from html5tagger import E
+
+from .base import BasePage
+
+
+if sys.version_info < (3, 8):  # no cov
+    FileInfo = Dict
+
+else:
+    from typing import TypedDict
+
+    class FileInfo(TypedDict):
+        icon: str
+        file_name: str
+        file_access: str
+        file_size: str
+
+
+class DirectoryPage(BasePage):  # no cov
+    TITLE = "Directory Viewer"
+
+    def __init__(
+        self, files: Iterable[FileInfo], url: str, debug: bool
+    ) -> None:
+        super().__init__(debug)
+        self.files = files
+        self.url = url
+
+    def _body(self) -> None:
+        with self.doc.main:
+            self._headline()
+            files = list(self.files)
+            if files:
+                self._file_table(files)
+            else:
+                self.doc.p("The folder is empty.")
+
+    def _headline(self):
+        """Implement a heading with the current path, combined with
+        breadcrumb links"""
+        with self.doc.h1(id="breadcrumbs"):
+            p = self.url.split("/")[:-1]
+
+            for i, part in enumerate(p):
+                path = "/".join(p[: i + 1]) + "/"
+                with self.doc.a(href=path):
+                    self.doc.span(part, class_="dir").span("/", class_="sep")
+
+    def _file_table(self, files: Iterable[FileInfo]):
+        with self.doc.table(class_="autoindex container"):
+            for f in files:
+                self._file_row(**f)
+
+    def _file_row(
+        self,
+        icon: str,
+        file_name: str,
+        file_access: str,
+        file_size: str,
+    ):
+        first = E.span(icon, class_="icon").a(file_name, href=file_name)
+        self.doc.tr.td(first).td(file_size).td(file_access)
--- a/sanic/pages/error.py
+++ b/sanic/pages/error.py
@@ -0,0 +1,105 @@
+from typing import Any, Mapping
+
+import tracerite.html
+
+from html5tagger import E
+from tracerite import html_traceback, inspector
+
+from sanic.request import Request
+
+from .base import BasePage
+
+
+# Avoid showing the request in the traceback variable inspectors
+inspector.blacklist_types += (Request,)
+
+ENDUSER_TEXT = """We're sorry, but it looks like something went wrong. Please try refreshing the page or navigating back to the homepage. If the issue persists, our technical team is working to resolve it as soon as possible. We apologize for the inconvenience and appreciate your patience."""  # noqa: E501
+
+
+class ErrorPage(BasePage):
+    STYLE_APPEND = tracerite.html.style
+
+    def __init__(
+        self,
+        title: str,
+        text: str,
+        request: Request,
+        exc: Exception,
+        full: bool,
+    ) -> None:
+        super().__init__()
+        # Internal server errors come with the text of the exception,
+        # which we don't want to show to the user.
+        # FIXME: Needs to be done in a better way, elsewhere
+        if "Internal Server Error" in title:
+            text = "The application encountered an unexpected error and could not continue."  # noqa: E501
+        name = request.app.name.replace("_", " ").strip()
+        if name.islower():
+            name = name.title()
+        self.TITLE = E("Application ").strong(name)(
+            " cannot handle your request"
+        )
+        self.title = title
+        self.text = text
+        self.request = request
+        self.exc = exc
+        self.full = full
+
+    def _head(self) -> None:
+        self.doc._script(tracerite.html.javascript)
+        super()._head()
+
+    def _body(self) -> None:
+        debug = self.request.app.debug
+        try:
+            route_name = self.request.route.name
+        except AttributeError:
+            route_name = "[route not found]"
+        with self.doc.main:
+            self.doc.h1(f"⚠️ {self.title}").p(self.text)
+            # Show context details if available on the exception
+            context = getattr(self.exc, "context", None)
+            if context:
+                self._key_value_table(
+                    "Issue context", "exception-context", context
+                )
+
+            if not debug:
+                with self.doc.div(id="enduser"):
+                    self.doc.p(ENDUSER_TEXT).p.a("Front Page", href="/")
+                return
+            # Show additional details in debug mode,
+            # open by default for 500 errors
+            with self.doc.details(open=self.full, class_="smalltext"):
+                # Show extra details if available on the exception
+                extra = getattr(self.exc, "extra", None)
+                if extra:
+                    self._key_value_table(
+                        "Issue extra data", "exception-extra", extra
+                    )
+
+                self.doc.summary(
+                    "Details for developers (Sanic debug mode only)"
+                )
+                if self.exc:
+                    self.doc.h2(f"Exception in {route_name}:")
+                    self.doc(html_traceback(self.exc, include_js_css=False))
+
+                self._key_value_table(
+                    f"{self.request.method} {self.request.path}",
+                    "request-headers",
+                    self.request.headers,
+                )
+
+    def _key_value_table(
+        self, title: str, table_id: str, data: Mapping[str, Any]
+    ) -> None:
+        self.doc.h2(title)
+        with self.doc.dl(id=table_id, class_="key-value-table smalltext"):
+            for key, value in data.items():
+                # Reading values may cause a new exception, so suppress it
+                try:
+                    value = str(value)
+                except Exception:
+                    value = E.em("Unable to display value")
+                self.doc.dt.span(key, class_="nobr key").span(": ").dd(value)
--- a/sanic/pages/styles/BasePage.css
+++ b/sanic/pages/styles/BasePage.css
@@ -0,0 +1,128 @@
+/** BasePage **/
+
+:root {
+    --sanic: #ff0d68;
+    --sanic-blue: #0092FF;
+    --sanic-yellow: #FFE900;
+    --sanic-purple: #833FE3;
+    --sanic-green: #37ae6f;
+    --sanic-background: #f1f5f9;
+    --sanic-text: #1f2937;
+    --sanic-tab-background: #fff;
+    --sanic-tab-text: #0f172a;
+    --sanic-tab-shadow: #adadad;
+    --sanic-highlight-background: var(--sanic-yellow);
+    --sanic-highlight-text: var(--sanic-text);
+    --sanic-header-background: #000;
+}
+
+@media (prefers-color-scheme: dark) {
+    :root {
+        --sanic-purple: #D246DE;
+        --sanic-green: #16DB93;
+        --sanic-background: #111;
+        --sanic-text: #e7e7e7;
+        --sanic-tab-background: #484848;
+        --sanic-tab-text: #e1e1e1;
+        --sanic-tab-shadow: #000;
+        --sanic-highlight-background: var(--sanic-yellow);
+        --sanic-highlight-text: #000;
+        --sanic-header-background: #000;
+    }
+}
+
+html {
+    font: 16px sans-serif;
+    background: var(--sanic-background);
+    color: var(--sanic-text);
+    scrollbar-gutter: stable;
+    overflow: hidden auto;
+}
+
+body {
+    margin: 0;
+    font-size: 1.25rem;
+    line-height: 125%;
+}
+
+body>* {
+    padding: 1rem 2vw;
+}
+
+@media (max-width: 1000px) {
+    body>* {
+        padding: 0.5rem 1.5vw;
+    }
+
+    html {
+        /* Scale everything by rem of 6px-16px by viewport width */
+        font-size: calc(6px + 10 * 100vw / 1000);
+    }
+}
+
+main {
+    min-height: 70vh;
+    /* Make sure the footer is closer to bottom */
+    padding: 1rem 2.5rem;
+    /* Generous padding for readability */
+}
+
+.smalltext {
+    font-size: 1.0rem;
+}
+
+.container {
+    min-width: 600px;
+    max-width: 1600px;
+}
+
+header {
+    background: #111;
+    color: #e1e1e1;
+    border-bottom: 1px solid #272727;
+    text-align: center;
+}
+
+footer {
+    text-align: center;
+    display: flex;
+    flex-direction: column;
+    font-size: 0.8rem;
+    margin-top: 2rem;
+}
+
+h1 {
+    text-align: left;
+}
+
+a:visited {
+    color: inherit;
+}
+
+a {
+    text-decoration: none;
+    color: #88f;
+}
+
+a:hover,
+a:focus {
+    text-decoration: underline;
+    outline: none;
+}
+
+
+span.icon {
+    margin-right: 1rem;
+}
+
+#logo-simple {
+    height: 1.75rem;
+    padding: 0 0.25rem;
+}
+
+
+@media (prefers-color-scheme: dark) {
+    #logo-simple path:last-child {
+        fill: #e1e1e1;
+    }
+}
--- a/sanic/pages/styles/DirectoryPage.css
+++ b/sanic/pages/styles/DirectoryPage.css
@@ -0,0 +1,63 @@
+/** DirectoryPage **/
+#breadcrumbs>a:hover {
+    text-decoration: none;
+}
+
+#breadcrumbs>a .dir {
+    padding: 0 0.25em;
+}
+
+#breadcrumbs>a:first-child:hover::before,
+#breadcrumbs>a .dir:hover {
+    text-decoration: underline;
+}
+
+#breadcrumbs>a:first-child::before {
+    content: "🏠";
+}
+
+#breadcrumbs>a:last-child {
+    color: #ff0d68;
+}
+
+main a {
+    color: inherit;
+    font-weight: bold;
+}
+
+table.autoindex {
+    width: 100%;
+    font-family: monospace;
+    font-size: 1.25rem;
+}
+
+table.autoindex tr {
+    display: flex;
+}
+
+table.autoindex tr:hover {
+    background-color: #ddd;
+}
+
+table.autoindex td {
+    margin: 0 0.5rem;
+}
+
+table.autoindex td:first-child {
+    flex: 1;
+}
+
+table.autoindex td:nth-child(2) {
+    text-align: right;
+}
+
+table.autoindex td:last-child {
+    text-align: right;
+}
+
+
+@media (prefers-color-scheme: dark) {
+    table.autoindex tr:hover {
+        background-color: #222;
+    }
+}
--- a/sanic/pages/styles/ErrorPage.css
+++ b/sanic/pages/styles/ErrorPage.css
@@ -0,0 +1,105 @@
+/** ErrorPage **/
+#enduser {
+    max-width: 30em;
+    margin: 5em auto 5em auto;
+    text-align: justify;
+    /*text-justify: both;*/
+}
+
+#enduser a {
+    color: var(--sanic-blue);
+}
+
+#enduser p:last-child {
+    text-align: right;
+}
+
+summary {
+    margin-top: 3em;
+    color: var(--sanic-blue);
+    cursor: pointer;
+}
+
+.tracerite {
+    --tracerite-var: var(--sanic-blue);
+    --tracerite-val: var(--sanic-text);
+    --tracerite-type: var(--sanic-green);
+    --tracerite-exception: var(--sanic);
+    --tracerite-highlight: var(--sanic-yellow);
+    --tracerite-tab: var(--sanic-tab-background);
+    --tracerite-tab-text: var(--sanic-tab-text);
+}
+
+.tracerite>h3 {
+    margin: 0.5rem 0 !important;
+}
+
+.tracerite .traceback-labels button {
+    font-size: 0.8rem !important;
+    line-height: 120% !important;
+    background: var(--tracerite-tab) !important;
+    color: var(--tracerite-tab-text) !important;
+    transition: 0.3s;
+    cursor: pointer;
+}
+
+.tracerite .traceback-labels {
+    padding-top: 5px;
+}
+
+.tracerite .traceback-labels button:hover {
+    filter: contrast(150%) brightness(120%) drop-shadow(0 -0 2px var(--sanic-tab-shadow));
+}
+
+.tracerite .traceback-details mark span {
+    background: var(--sanic-highlight-background) !important;
+    color: var(--sanic-highlight-text) !important;
+}
+
+header {
+    background: var(--sanic-header-background);
+}
+
+h1 {
+    /*margin-left: -1.5rem;  !* Emoji partially in the left margin *!*/
+}
+
+h2 {
+    margin: 1em 0 0.2em 0;
+    font-size: 1.25rem;
+    color: var(--sanic-text);
+}
+
+dl.key-value-table {
+    width: 100%;
+    margin: 0;
+    display: grid;
+    grid-template-columns: 1fr 5fr;
+    grid-gap: .3em;
+    white-space: pre-wrap;
+}
+
+dl.key-value-table * {
+    margin: 0;
+}
+
+dl.key-value-table dt {
+    color: #888;
+    word-break: break-word;
+}
+
+dl.key-value-table dd {
+    word-break: break-all;
+    /* Better breaking for cookies header and such */
+}
+
+.tracerite .codeline {
+    font-family:
+        "Fira Code",
+        "Source Code Pro",
+        Menlo,
+        Monaco,
+        Consolas,
+        Lucida Console,
+        monospace;
+}
--- a/sanic/request.py
+++ b/sanic/request.py
@@ -27,6 +27,7 @@ if TYPE_CHECKING:
    from sanic.app import Sanic

 import email.utils
+import unicodedata
 import uuid

 from collections import defaultdict
@@ -145,7 +146,6 @@ class Request:
        head: bytes = b"",
        stream_id: int = 0,
    ):
-
        self.raw_url = url_bytes
        try:
            self._parsed_url = parse_url(url_bytes)
@@ -1084,6 +1084,16 @@ def parse_multipart_form(body, boundary):
                        form_parameters["filename*"]
                    )
                    file_name = unquote(value, encoding=encoding)
+
+                # Normalize to NFC (Apple MacOS/iOS send NFD)
+                # Notes:
+                # - No effect for Windows, Linux or Android clients which
+                #   already send NFC
+                # - Python open() is tricky (creates files in NFC no matter
+                #   which form you use)
+                if file_name is not None:
+                    file_name = unicodedata.normalize("NFC", file_name)
+
            elif form_header_field == "content-type":
                content_type = form_header_value
                content_charset = form_parameters.get("charset", "utf-8")
--- a/sanic/router.py
+++ b/sanic/router.py
@@ -39,13 +39,13 @@ class Router(BaseRouter):
                extra={"host": host} if host else None,
            )
        except RoutingNotFound as e:
-            raise NotFound("Requested URL {} not found".format(e.path))
+            raise NotFound(f"Requested URL {e.path} not found") from None
        except NoMethod as e:
            raise MethodNotAllowed(
-                "Method {} not allowed for URL {}".format(method, path),
+                f"Method {method} not allowed for URL {path}",
                method=method,
                allowed_methods=e.allowed_methods,
-            )
+            ) from None

    @lru_cache(maxsize=ROUTER_CACHE_SIZE)
    def get(  # type: ignore
@@ -61,6 +61,7 @@ class Router(BaseRouter):
            correct response
        :rtype: Tuple[ Route, RouteHandler, Dict[str, Any]]
        """
+        __tracebackhide__ = True
        return self._get(path, method, host)

    def add(  # type: ignore
--- a/sanic/server/legacy.py
+++ b/sanic/server/legacy.py
@@ -94,7 +94,6 @@ def watchdog(sleep_interval, reload_dirs):

    try:
        while True:
-
            changed = set()
            for filename in itertools.chain(
                _iter_module_files(),
--- a/sanic/server/loop.py
+++ b/sanic/server/loop.py
@@ -1,11 +1,11 @@
 import asyncio
 import sys

-from distutils.util import strtobool
 from os import getenv

 from sanic.compat import OS_IS_WINDOWS
 from sanic.log import error_logger
+from sanic.utils import str_to_bool


 def try_use_uvloop() -> None:
@@ -35,7 +35,7 @@ def try_use_uvloop() -> None:
        )
        return

-    uvloop_install_removed = strtobool(getenv("SANIC_NO_UVLOOP", "no"))
+    uvloop_install_removed = str_to_bool(getenv("SANIC_NO_UVLOOP", "no"))
    if uvloop_install_removed:
        error_logger.info(
            "You are requesting to run Sanic using uvloop, but the "
--- a/sanic/server/runners.py
+++ b/sanic/server/runners.py
@@ -130,13 +130,14 @@ def _setup_system_signals(
    register_sys_signals: bool,
    loop: asyncio.AbstractEventLoop,
 ) -> None:  # no cov
+    print(">>>>>>>>>>>>>>>>>.", run_multiple)
    # Ignore SIGINT when run_multiple
    if run_multiple:
        signal_func(SIGINT, SIG_IGN)
        os.environ["SANIC_WORKER_PROCESS"] = "true"

    # Register signals for graceful termination
-    if register_sys_signals:
+    if register_sys_signals and False:
        if OS_IS_WINDOWS:
            ctrlc_workaround_for_windows(app)
        else:
@@ -200,7 +201,7 @@ def _serve_http_1(
    asyncio_server_kwargs = (
        asyncio_server_kwargs if asyncio_server_kwargs else {}
    )
-    if OS_IS_WINDOWS:
+    if OS_IS_WINDOWS and sock:
        pid = os.getpid()
        sock = sock.share(pid)
        sock = socket.fromshare(sock)
@@ -229,6 +230,7 @@ def _serve_http_1(

    loop.run_until_complete(app._startup())
    loop.run_until_complete(app._server_event("init", "before"))
+    app.ack()

    try:
        http_server = loop.run_until_complete(server_coroutine)
@@ -306,6 +308,7 @@ def _serve_http_3(
    server = AsyncioServer(app, loop, coro, [])
    loop.run_until_complete(server.startup())
    loop.run_until_complete(server.before_start())
+    app.ack()
    loop.run_until_complete(server)
    _setup_system_signals(app, run_multiple, register_sys_signals, loop)
    loop.run_until_complete(server.after_start())
--- a/sanic/server/websockets/connection.py
+++ b/sanic/server/websockets/connection.py
@@ -9,8 +9,10 @@ from typing import (
    Union,
 )

+from sanic.exceptions import InvalidUsage

-ASIMessage = MutableMapping[str, Any]
+
+ASGIMessage = MutableMapping[str, Any]


 class WebSocketConnection:
@@ -25,8 +27,8 @@ class WebSocketConnection:

    def __init__(
        self,
-        send: Callable[[ASIMessage], Awaitable[None]],
-        receive: Callable[[], Awaitable[ASIMessage]],
+        send: Callable[[ASGIMessage], Awaitable[None]],
+        receive: Callable[[], Awaitable[ASGIMessage]],
        subprotocols: Optional[List[str]] = None,
    ) -> None:
        self._send = send
@@ -43,11 +45,17 @@ class WebSocketConnection:

        await self._send(message)

-    async def recv(self, *args, **kwargs) -> Optional[str]:
+    async def recv(self, *args, **kwargs) -> Optional[Union[str, bytes]]:
        message = await self._receive()

        if message["type"] == "websocket.receive":
-            return message["text"]
+            try:
+                return message["text"]
+            except KeyError:
+                try:
+                    return message["bytes"]
+                except KeyError:
+                    raise InvalidUsage("Bad ASGI message received")
        elif message["type"] == "websocket.disconnect":
            pass

--- a/sanic/server/websockets/frame.py
+++ b/sanic/server/websockets/frame.py
@@ -52,7 +52,6 @@ class WebsocketFrameAssembler:
        paused: bool

    def __init__(self, protocol) -> None:
-
        self.protocol = protocol

        self.read_mutex = asyncio.Lock()
--- a/sanic/server/websockets/impl.py
+++ b/sanic/server/websockets/impl.py
@@ -686,7 +686,6 @@ class WebsocketImplProtocol:
        :raises TypeError: for unsupported inputs
        """
        async with self.conn_mutex:
-
            if self.ws_proto.state in (CLOSED, CLOSING):
                raise WebsocketClosed(
                    "Cannot write to websocket interface after it is closed."
--- a/sanic/signals.py
+++ b/sanic/signals.py
@@ -154,9 +154,7 @@ class SignalRouter(BaseRouter):
        try:
            for signal in signals:
                params.pop("__trigger__", None)
-                requirements = getattr(
-                    signal.handler, "__requirements__", None
-                )
+                requirements = signal.extra.requirements
                if (
                    (condition is None and signal.ctx.exclusive is False)
                    or (condition is None and not requirements)
@@ -219,8 +217,13 @@ class SignalRouter(BaseRouter):
        if not trigger:
            event = ".".join([*parts[:2], "<__trigger__>"])

-        handler.__requirements__ = condition  # type: ignore
-        handler.__trigger__ = trigger  # type: ignore
+        try:
+            # Attaching __requirements__ and __trigger__ to the handler
+            # is deprecated and will be removed in v23.6.
+            handler.__requirements__ = condition  # type: ignore
+            handler.__trigger__ = trigger  # type: ignore
+        except AttributeError:
+            pass

        signal = super().add(
            event,
@@ -232,6 +235,7 @@ class SignalRouter(BaseRouter):
        signal.ctx.exclusive = exclusive
        signal.ctx.trigger = trigger
        signal.ctx.definition = event_definition
+        signal.extra.requirements = condition

        return cast(Signal, signal)

--- a/sanic/simple.py
+++ b/sanic/simple.py
@@ -2,7 +2,6 @@ from pathlib import Path

 from sanic import Sanic
 from sanic.exceptions import SanicException
-from sanic.response import redirect


 def create_simple_server(directory: Path):
@@ -12,10 +11,8 @@ def create_simple_server(directory: Path):
        )

    app = Sanic("SimpleServer")
-    app.static("/", directory, name="main")
-
-    @app.get("/")
-    def index(_):
-        return redirect(app.url_for("main", filename="index.html"))
+    app.static(
+        "/", directory, name="main", directory_view=True, index="index.html"
+    )

    return app
--- a/sanic/touchup/meta.py
+++ b/sanic/touchup/meta.py
@@ -11,7 +11,6 @@ class TouchUpMeta(SanicMeta):
        methods = attrs.get("__touchup__")
        attrs["__touched__"] = False
        if methods:
-
            for method in methods:
                if method not in attrs:
                    raise SanicException(
--- a/sanic/utils.py
+++ b/sanic/utils.py
@@ -75,7 +75,6 @@ def load_module_from_file_location(
        location = location.decode(encoding)

    if isinstance(location, Path) or "/" in location or "$" in location:
-
        if not isinstance(location, Path):
            # A) Check if location contains any environment variables
            #    in format ${some_env_var}.
--- a/sanic/worker/constants.py
+++ b/sanic/worker/constants.py
@@ -0,0 +1,18 @@
+from enum import IntEnum, auto
+
+from sanic.compat import UpperStrEnum
+
+
+class RestartOrder(UpperStrEnum):
+    SHUTDOWN_FIRST = auto()
+    STARTUP_FIRST = auto()
+
+
+class ProcessState(IntEnum):
+    IDLE = auto()
+    RESTARTING = auto()
+    STARTING = auto()
+    STARTED = auto()
+    ACKED = auto()
+    JOINED = auto()
+    TERMINATED = auto()
--- a/sanic/worker/inspector.py
+++ b/sanic/worker/inspector.py
@@ -1,23 +1,17 @@
-import sys
+from __future__ import annotations

 from datetime import datetime
+from inspect import isawaitable
 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 os import environ
+from pathlib import Path
+from typing import Any, Dict, Mapping, Union

-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
+from sanic.exceptions import Unauthorized
+from sanic.helpers import Default
+from sanic.log import logger
+from sanic.request import Request
+from sanic.response import json


 class Inspector:
@@ -25,118 +19,105 @@ class Inspector:
        self,
        publisher: Connection,
        app_info: Dict[str, Any],
-        worker_state: Dict[str, Any],
+        worker_state: Mapping[str, Any],
        host: str,
        port: int,
+        api_key: str,
+        tls_key: Union[Path, str, Default],
+        tls_cert: Union[Path, str, Default],
    ):
        self._publisher = publisher
-        self.run = True
        self.app_info = app_info
        self.worker_state = worker_state
        self.host = host
        self.port = port
+        self.api_key = api_key
+        self.tls_key = tls_key
+        self.tls_cert = tls_cert

-    def __call__(self) -> None:
-        sock = configure_socket(
-            {"host": self.host, "port": self.port, "unix": None, "backlog": 1}
+    def __call__(self, run=True, **_) -> Inspector:
+        from sanic import Sanic
+
+        self.app = Sanic("Inspector")
+        self._setup()
+        if run:
+            self.app.run(
+                host=self.host,
+                port=self.port,
+                single_process=True,
+                ssl={"key": self.tls_key, "cert": self.tls_cert}
+                if not isinstance(self.tls_key, Default)
+                and not isinstance(self.tls_cert, Default)
+                else None,
+            )
+        return self
+
+    def _setup(self):
+        self.app.get("/")(self._info)
+        self.app.post("/<action:str>")(self._action)
+        if self.api_key:
+            self.app.on_request(self._authentication)
+        environ["SANIC_IGNORE_PRODUCTION_WARNING"] = "true"
+
+    def _authentication(self, request: Request) -> None:
+        if request.token != self.api_key:
+            raise Unauthorized("Bad API key")
+
+    async def _action(self, request: Request, action: str):
+        logger.info("Incoming inspector action: %s", action)
+        output: Any = None
+        method = getattr(self, action, None)
+        if method:
+            kwargs = {}
+            if request.body:
+                kwargs = request.json
+            args = kwargs.pop("args", ())
+            output = method(*args, **kwargs)
+            if isawaitable(output):
+                output = await output
+
+        return await self._respond(request, output)
+
+    async def _info(self, request: Request):
+        return await self._respond(request, self._state_to_json())
+
+    async def _respond(self, request: Request, output: Any):
+        name = request.match_info.get("action", "info")
+        return json(
+            {"meta": {"action": name}, "result": output},
+            escape_forward_slashes=False,
        )
-        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):
+    def _state_to_json(self) -> Dict[str, Any]:
        output = {"info": self.app_info}
-        output["workers"] = self.make_safe(dict(self.worker_state))
+        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]:
+    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)
+                obj[key] = Inspector._make_safe(value)
            elif isinstance(value, datetime):
                obj[key] = value.isoformat()
        return obj

+    def reload(self, zero_downtime: bool = False) -> None:
+        message = "__ALL_PROCESSES__:"
+        if zero_downtime:
+            message += ":STARTUP_FIRST"
+        self._publisher.send(message)

-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"
-            )
+    def scale(self, replicas) -> str:
+        num_workers = 1
+        if replicas:
+            num_workers = int(replicas)
+        log_msg = f"Scaling to {num_workers}"
+        logger.info(log_msg)
+        message = f"__SCALE__:{num_workers}"
+        self._publisher.send(message)
+        return log_msg
+
+    def shutdown(self) -> None:
+        message = "__TERMINATE__"
+        self._publisher.send(message)
--- a/sanic/worker/manager.py
+++ b/sanic/worker/manager.py
@@ -1,12 +1,16 @@
 import os

+from contextlib import suppress
+from itertools import count
+from random import choice
 from signal import SIGINT, SIGTERM, Signals
 from signal import signal as signal_func
-from typing import List, Optional
+from typing import Dict, List, Optional

 from sanic.compat import OS_IS_WINDOWS
 from sanic.exceptions import ServerKilled
 from sanic.log import error_logger, logger
+from sanic.worker.constants import RestartOrder
 from sanic.worker.process import ProcessState, Worker, WorkerProcess


@@ -17,7 +21,8 @@ else:


 class WorkerManager:
-    THRESHOLD = 300  # == 30 seconds
+    THRESHOLD = WorkerProcess.THRESHOLD
+    MAIN_IDENT = "Sanic-Main"

    def __init__(
        self,
@@ -30,39 +35,66 @@ class WorkerManager:
    ):
        self.num_server = number
        self.context = context
-        self.transient: List[Worker] = []
-        self.durable: List[Worker] = []
+        self.transient: Dict[str, Worker] = {}
+        self.durable: Dict[str, 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
+        self.worker_state[self.MAIN_IDENT] = {"pid": self.pid}
+        self._shutting_down = False
+        self._serve = serve
+        self._server_settings = server_settings
+        self._server_count = count()

        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,
-            )
+        for _ in range(number):
+            self.create_server()

        signal_func(SIGINT, self.shutdown_signal)
        signal_func(SIGTERM, self.shutdown_signal)

-    def manage(self, ident, func, kwargs, transient=False):
+    def manage(self, ident, func, kwargs, transient=False) -> Worker:
        container = self.transient if transient else self.durable
-        container.append(
-            Worker(ident, func, kwargs, self.context, self.worker_state)
+        worker = Worker(ident, func, kwargs, self.context, self.worker_state)
+        container[worker.ident] = worker
+        return worker
+
+    def create_server(self) -> Worker:
+        server_number = next(self._server_count)
+        return self.manage(
+            f"{WorkerProcess.SERVER_LABEL}-{server_number}",
+            self._serve,
+            self._server_settings,
+            transient=True,
        )

+    def shutdown_server(self, ident: Optional[str] = None) -> None:
+        if not ident:
+            servers = [
+                worker
+                for worker in self.transient.values()
+                if worker.ident.startswith(WorkerProcess.SERVER_LABEL)
+            ]
+            if not servers:
+                error_logger.error(
+                    "Server shutdown failed because a server was not found."
+                )
+                return
+            worker = choice(servers)  # nosec B311
+        else:
+            worker = self.transient[ident]
+
+        for process in worker.processes:
+            process.terminate()
+
+        del self.transient[worker.ident]
+
    def run(self):
        self.start()
        self.monitor()
        self.join()
        self.terminate()
-        # self.kill()

    def start(self):
        for process in self.processes:
@@ -84,15 +116,41 @@ class WorkerManager:
            self.join()

    def terminate(self):
-        if not self.terminated:
+        if not self._shutting_down:
            for process in self.processes:
                process.terminate()
-        self.terminated = True

-    def restart(self, process_names: Optional[List[str]] = None, **kwargs):
+    def restart(
+        self,
+        process_names: Optional[List[str]] = None,
+        restart_order=RestartOrder.SHUTDOWN_FIRST,
+        **kwargs,
+    ):
        for process in self.transient_processes:
            if not process_names or process.name in process_names:
-                process.restart(**kwargs)
+                process.restart(restart_order=restart_order, **kwargs)
+
+    def scale(self, num_worker: int):
+        if num_worker <= 0:
+            raise ValueError("Cannot scale to 0 workers.")
+
+        change = num_worker - self.num_server
+        if change == 0:
+            logger.info(
+                f"No change needed. There are already {num_worker} workers."
+            )
+            return
+
+        logger.info(f"Scaling from {self.num_server} to {num_worker} workers")
+        if change > 0:
+            for _ in range(change):
+                worker = self.create_server()
+                for process in worker.processes:
+                    process.start()
+        else:
+            for _ in range(abs(change)):
+                self.shutdown_server()
+        self.num_server = num_worker

    def monitor(self):
        self.wait_for_ack()
@@ -108,7 +166,15 @@ class WorkerManager:
                    elif message == "__TERMINATE__":
                        self.shutdown()
                        break
-                    split_message = message.split(":", 1)
+                    logger.debug(
+                        "Incoming monitor message: %s",
+                        message,
+                        extra={"verbosity": 1},
+                    )
+                    split_message = message.split(":", 2)
+                    if message.startswith("__SCALE__"):
+                        self.scale(int(split_message[-1]))
+                        continue
                    processes = split_message[0]
                    reloaded_files = (
                        split_message[1] if len(split_message) > 1 else None
@@ -118,10 +184,17 @@ class WorkerManager:
                    ]
                    if "__ALL_PROCESSES__" in process_names:
                        process_names = None
+                    order = (
+                        RestartOrder.STARTUP_FIRST
+                        if "STARTUP_FIRST" in split_message
+                        else RestartOrder.SHUTDOWN_FIRST
+                    )
                    self.restart(
                        process_names=process_names,
                        reloaded_files=reloaded_files,
+                        restart_order=order,
                    )
+                self._sync_states()
            except InterruptedError:
                if not OS_IS_WINDOWS:
                    raise
@@ -134,7 +207,7 @@ class WorkerManager:
            "online in the allowed time. Sanic is shutting down to avoid a "
            f"deadlock. The current threshold is {self.THRESHOLD / 10}s. "
            "If this problem persists, please check out the documentation "
-            "___."
+            "https://sanic.dev/en/guide/deployment/manager.html#worker-ack."
        )
        while not self._all_workers_ack():
            if self.monitor_subscriber.poll(0.1):
@@ -161,8 +234,8 @@ class WorkerManager:
                self.kill()

    @property
-    def workers(self):
-        return self.transient + self.durable
+    def workers(self) -> List[Worker]:
+        return list(self.transient.values()) + list(self.durable.values())

    @property
    def processes(self):
@@ -172,7 +245,7 @@ class WorkerManager:

    @property
    def transient_processes(self):
-        for worker in self.transient:
+        for worker in self.transient.values():
            for process in worker.processes:
                yield process

@@ -183,6 +256,11 @@ class WorkerManager:
        raise ServerKilled

    def shutdown_signal(self, signal, frame):
+        if self._shutting_down:
+            logger.info("Shutdown interrupted. Killing.")
+            with suppress(ServerKilled):
+                self.kill()
+
        logger.info("Received signal %s. Shutting down.", Signals(signal).name)
        self.monitor_publisher.send(None)
        self.shutdown()
@@ -191,6 +269,7 @@ class WorkerManager:
        for process in self.processes:
            if process.is_alive():
                process.terminate()
+        self._shutting_down = True

    @property
    def pid(self):
@@ -203,3 +282,9 @@ class WorkerManager:
            if worker_state.get("server")
        ]
        return all(acked) and len(acked) == self.num_server
+
+    def _sync_states(self):
+        for process in self.processes:
+            state = self.worker_state[process.name].get("state")
+            if state and process.state.name != state:
+                process.set_state(ProcessState[state], True)
--- a/sanic/worker/multiplexer.py
+++ b/sanic/worker/multiplexer.py
@@ -2,6 +2,7 @@ from multiprocessing.connection import Connection
 from os import environ, getpid
 from typing import Any, Dict

+from sanic.log import Colors, logger
 from sanic.worker.process import ProcessState
 from sanic.worker.state import WorkerState

@@ -16,12 +17,23 @@ class WorkerMultiplexer:
        self._state = WorkerState(worker_state, self.name)

    def ack(self):
+        logger.debug(
+            f"{Colors.BLUE}Process ack: {Colors.BOLD}{Colors.SANIC}"
+            f"%s {Colors.BLUE}[%s]{Colors.END}",
+            self.name,
+            self.pid,
+        )
        self._state._state[self.name] = {
            **self._state._state[self.name],
            "state": ProcessState.ACKED.name,
        }

-    def restart(self, name: str = "", all_workers: bool = False):
+    def restart(
+        self,
+        name: str = "",
+        all_workers: bool = False,
+        zero_downtime: bool = False,
+    ):
        if name and all_workers:
            raise ValueError(
                "Ambiguous restart with both a named process and"
@@ -29,10 +41,18 @@ class WorkerMultiplexer:
            )
        if not name:
            name = "__ALL_PROCESSES__:" if all_workers else self.name
+        if not name.endswith(":"):
+            name += ":"
+        if zero_downtime:
+            name += ":STARTUP_FIRST"
        self._monitor_publisher.send(name)

    reload = restart  # no cov

+    def scale(self, num_workers: int):
+        message = f"__SCALE__:{num_workers}"
+        self._monitor_publisher.send(message)
+
    def terminate(self, early: bool = False):
        message = "__TERMINATE_EARLY__" if early else "__TERMINATE__"
        self._monitor_publisher.send(message)
--- a/sanic/worker/process.py
+++ b/sanic/worker/process.py
@@ -1,12 +1,14 @@
 import os

 from datetime import datetime, timezone
-from enum import IntEnum, auto
 from multiprocessing.context import BaseContext
 from signal import SIGINT
+from threading import Thread
+from time import sleep
 from typing import Any, Dict, Set

 from sanic.log import Colors, logger
+from sanic.worker.constants import ProcessState, RestartOrder


 def get_now():
@@ -14,15 +16,8 @@ def get_now():
    return now


-class ProcessState(IntEnum):
-    IDLE = auto()
-    STARTED = auto()
-    ACKED = auto()
-    JOINED = auto()
-    TERMINATED = auto()
-
-
 class WorkerProcess:
+    THRESHOLD = 300  # == 30 seconds
    SERVER_LABEL = "Server"

    def __init__(self, factory, name, target, kwargs, worker_state):
@@ -54,8 +49,9 @@ class WorkerProcess:
            f"{Colors.SANIC}%s{Colors.END}",
            self.name,
        )
+        self.set_state(ProcessState.STARTING)
+        self._current_process.start()
        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],
@@ -67,7 +63,7 @@ class WorkerProcess:

    def join(self):
        self.set_state(ProcessState.JOINED)
-        self._process.join()
+        self._current_process.join()

    def terminate(self):
        if self.state is not ProcessState.TERMINATED:
@@ -80,21 +76,23 @@ class WorkerProcess:
            )
            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):
+    def restart(self, restart_order=RestartOrder.SHUTDOWN_FIRST, **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.set_state(ProcessState.RESTARTING, force=True)
+        if restart_order is RestartOrder.SHUTDOWN_FIRST:
+            self._terminate_now()
+        else:
+            self._old_process = self._current_process
        self.kwargs.update(
            {"config": {k.upper(): v for k, v in kwargs.items()}}
        )
@@ -104,6 +102,9 @@ class WorkerProcess:
        except AttributeError:
            raise RuntimeError("Restart failed")

+        if restart_order is RestartOrder.STARTUP_FIRST:
+            self._terminate_soon()
+
        self.worker_state[self.name] = {
            **self.worker_state[self.name],
            "pid": self.pid,
@@ -113,14 +114,14 @@ class WorkerProcess:

    def is_alive(self):
        try:
-            return self._process.is_alive()
+            return self._current_process.is_alive()
        except AssertionError:
            return False

    def spawn(self):
-        if self.state is not ProcessState.IDLE:
+        if self.state not in (ProcessState.IDLE, ProcessState.RESTARTING):
            raise Exception("Cannot spawn a worker process until it is idle.")
-        self._process = self.factory(
+        self._current_process = self.factory(
            name=self.name,
            target=self.target,
            kwargs=self.kwargs,
@@ -129,10 +130,61 @@ class WorkerProcess:

    @property
    def pid(self):
-        return self._process.pid
+        return self._current_process.pid
+
+    def _terminate_now(self):
+        logger.debug(
+            f"{Colors.BLUE}Begin restart termination: "
+            f"{Colors.BOLD}{Colors.SANIC}"
+            f"%s {Colors.BLUE}[%s]{Colors.END}",
+            self.name,
+            self._current_process.pid,
+        )
+        self._current_process.terminate()
+
+    def _terminate_soon(self):
+        logger.debug(
+            f"{Colors.BLUE}Begin restart termination: "
+            f"{Colors.BOLD}{Colors.SANIC}"
+            f"%s {Colors.BLUE}[%s]{Colors.END}",
+            self.name,
+            self._current_process.pid,
+        )
+        termination_thread = Thread(target=self._wait_to_terminate)
+        termination_thread.start()
+
+    def _wait_to_terminate(self):
+        logger.debug(
+            f"{Colors.BLUE}Waiting for process to be acked: "
+            f"{Colors.BOLD}{Colors.SANIC}"
+            f"%s {Colors.BLUE}[%s]{Colors.END}",
+            self.name,
+            self._old_process.pid,
+        )
+        misses = 0
+        while self.state is not ProcessState.ACKED:
+            sleep(0.1)
+            misses += 1
+            if misses > self.THRESHOLD:
+                raise TimeoutError(
+                    f"Worker {self.name} failed to come ack within "
+                    f"{self.THRESHOLD / 10} seconds"
+                )
+        else:
+            logger.debug(
+                f"{Colors.BLUE}Process acked. Terminating: "
+                f"{Colors.BOLD}{Colors.SANIC}"
+                f"%s {Colors.BLUE}[%s]{Colors.END}",
+                self.name,
+                self._old_process.pid,
+            )
+            self._old_process.terminate()
+        delattr(self, "_old_process")


 class Worker:
+    WORKER_PREFIX = "Sanic-"
+
    def __init__(
        self,
        ident: str,
@@ -151,8 +203,12 @@ class Worker:

    def create_process(self) -> WorkerProcess:
        process = WorkerProcess(
-            factory=self.context.Process,
-            name=f"Sanic-{self.ident}-{len(self.processes)}",
+            # Need to ignore this typing error - The problem is the
+            # BaseContext itself has no Process. But, all of its
+            # implementations do. We can safely ignore as it is a typing
+            # issue in the standard lib.
+            factory=self.context.Process,  # type: ignore
+            name=f"{self.WORKER_PREFIX}{self.ident}-{len(self.processes)}",
            target=self.serve,
            kwargs={**self.server_settings},
            worker_state=self.worker_state,
--- a/sanic/worker/reloader.py
+++ b/sanic/worker/reloader.py
@@ -17,6 +17,8 @@ from sanic.worker.loader import AppLoader


 class Reloader:
+    INTERVAL = 1.0  # seconds
+
    def __init__(
        self,
        publisher: Connection,
@@ -25,7 +27,7 @@ class Reloader:
        app_loader: AppLoader,
    ):
        self._publisher = publisher
-        self.interval = interval
+        self.interval = interval or self.INTERVAL
        self.reload_dirs = reload_dirs
        self.run = True
        self.app_loader = app_loader
--- a/sanic/worker/serve.py
+++ b/sanic/worker/serve.py
@@ -17,6 +17,7 @@ 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
+from sanic.worker.process import Worker, WorkerProcess


 def worker_serve(
@@ -79,7 +80,10 @@ def worker_serve(
                info.settings["ssl"] = ssl

        # When in a worker process, do some init
-        if os.environ.get("SANIC_WORKER_NAME"):
+        worker_name = os.environ.get("SANIC_WORKER_NAME")
+        if worker_name and worker_name.startswith(
+            Worker.WORKER_PREFIX + WorkerProcess.SERVER_LABEL
+        ):
            # Hydrate apps with any passed server info

            if monitor_publisher is None:
--- a/setup.py
+++ b/setup.py
@@ -6,8 +6,6 @@ import os
 import re
 import sys

-from distutils.util import strtobool
-
 from setuptools import find_packages, setup
 from setuptools.command.test import test as TestCommand

@@ -38,6 +36,27 @@ def open_local(paths, mode="r", encoding="utf8"):
    return codecs.open(path, mode, encoding)


+def str_to_bool(val: str) -> bool:
+    val = val.lower()
+    if val in {
+        "y",
+        "yes",
+        "yep",
+        "yup",
+        "t",
+        "true",
+        "on",
+        "enable",
+        "enabled",
+        "1",
+    }:
+        return True
+    elif val in {"n", "no", "f", "false", "off", "disable", "disabled", "0"}:
+        return False
+    else:
+        raise ValueError(f"Invalid truth value {val}")
+
+
 with open_local(["sanic", "__version__.py"], encoding="latin1") as fp:
    try:
        version = re.findall(
@@ -62,7 +81,7 @@ setup_kwargs = {
    ),
    "long_description": long_description,
    "packages": find_packages(exclude=("tests", "tests.*")),
-    "package_data": {"sanic": ["py.typed"]},
+    "package_data": {"sanic": ["py.typed", "pages/styles/*"]},
    "platforms": "any",
    "python_requires": ">=3.7",
    "classifiers": [
@@ -73,6 +92,7 @@ setup_kwargs = {
        "Programming Language :: Python :: 3.8",
        "Programming Language :: Python :: 3.9",
        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
    ],
    "entry_points": {"console_scripts": ["sanic = sanic.__main__:main"]},
 }
@@ -91,6 +111,8 @@ requirements = [
    "aiofiles>=0.6.0",
    "websockets>=10.0",
    "multidict>=5.0,<7.0",
+    "html5tagger>=1.2.1",
+    "tracerite>=1.0.0",
 ]

 tests_require = [
@@ -131,13 +153,13 @@ dev_require = tests_require + [

 all_require = list(set(dev_require + docs_require))

-if strtobool(os.environ.get("SANIC_NO_UJSON", "no")):
+if str_to_bool(os.environ.get("SANIC_NO_UJSON", "no")):
    print("Installing without uJSON")
    requirements.remove(ujson)
    tests_require.remove(types_ujson)

 # 'nt' means windows OS
-if strtobool(os.environ.get("SANIC_NO_UVLOOP", "no")):
+if str_to_bool(os.environ.get("SANIC_NO_UVLOOP", "no")):
    print("Installing without uvLoop")
    requirements.remove(uvloop)

--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -1,5 +1,7 @@
 import asyncio
+import inspect
 import logging
+import os
 import random
 import re
 import string
@@ -8,8 +10,8 @@ import uuid

 from contextlib import suppress
 from logging import LogRecord
-from typing import List, Tuple
-from unittest.mock import MagicMock
+from typing import Any, Dict, List, Tuple
+from unittest.mock import MagicMock, Mock, patch

 import pytest

@@ -54,11 +56,10 @@ TYPE_TO_GENERATOR_MAP = {
    "uuid": lambda: str(uuid.uuid1()),
 }

-CACHE = {}
+CACHE: Dict[str, Any] = {}


 class RouteStringGenerator:
-
    ROUTE_COUNT_PER_DEPTH = 100
    HTTP_METHODS = HTTP_METHODS
    ROUTE_PARAM_TYPES = ["str", "int", "float", "alpha", "uuid"]
@@ -147,6 +148,7 @@ def app(request):
        for target, method_name in TouchUp._registry:
            CACHE[method_name] = getattr(target, method_name)
    app = Sanic(slugify.sub("-", request.node.name))
+
    yield app
    for target, method_name in TouchUp._registry:
        setattr(target, method_name, CACHE[method_name])
@@ -220,3 +222,23 @@ def sanic_ext(ext_instance):  # noqa
    yield sanic_ext
    with suppress(KeyError):
        del sys.modules["sanic_ext"]
+
+
+@pytest.fixture
+def urlopen():
+    urlopen = Mock()
+    urlopen.return_value = urlopen
+    urlopen.__enter__ = Mock(return_value=urlopen)
+    urlopen.__exit__ = Mock()
+    urlopen.read = Mock()
+    with patch("sanic.cli.inspector_client.urlopen", urlopen):
+        yield urlopen
+
+
+@pytest.fixture(scope="module")
+def static_file_directory():
+    """The static directory to serve"""
+    current_file = inspect.getfile(inspect.currentframe())
+    current_directory = os.path.dirname(os.path.abspath(current_file))
+    static_directory = os.path.join(current_directory, "static")
+    return static_directory
--- a/tests/test_app.py
+++ b/tests/test_app.py
@@ -36,6 +36,7 @@ def test_app_loop_running(app: Sanic):
    assert response.text == "pass"


+@pytest.mark.asyncio
 def test_create_asyncio_server(app: Sanic):
    loop = asyncio.get_event_loop()
    asyncio_srv_coro = app.create_server(return_asyncio_server=True)
@@ -44,6 +45,7 @@ def test_create_asyncio_server(app: Sanic):
    assert srv.is_serving() is True


+@pytest.mark.asyncio
 def test_asyncio_server_no_start_serving(app: Sanic):
    loop = asyncio.get_event_loop()
    asyncio_srv_coro = app.create_server(
@@ -55,6 +57,7 @@ def test_asyncio_server_no_start_serving(app: Sanic):
    assert srv.is_serving() is False


+@pytest.mark.asyncio
 def test_asyncio_server_start_serving(app: Sanic):
    loop = asyncio.get_event_loop()
    asyncio_srv_coro = app.create_server(
@@ -72,6 +75,7 @@ def test_asyncio_server_start_serving(app: Sanic):
    # Looks like we can't easily test `serve_forever()`


+@pytest.mark.asyncio
 def test_create_server_main(app: Sanic, caplog):
    app.listener("main_process_start")(lambda *_: ...)
    loop = asyncio.get_event_loop()
@@ -86,6 +90,7 @@ def test_create_server_main(app: Sanic, caplog):
    ) in caplog.record_tuples


+@pytest.mark.asyncio
 def test_create_server_no_startup(app: Sanic):
    loop = asyncio.get_event_loop()
    asyncio_srv_coro = app.create_server(
@@ -101,6 +106,7 @@ def test_create_server_no_startup(app: Sanic):
        loop.run_until_complete(srv.start_serving())


+@pytest.mark.asyncio
 def test_create_server_main_convenience(app: Sanic, caplog):
    app.main_process_start(lambda *_: ...)
    loop = asyncio.get_event_loop()
@@ -126,7 +132,6 @@ def test_app_loop_not_running(app: Sanic):


 def test_app_run_raise_type_error(app: Sanic):
-
    with pytest.raises(TypeError) as excinfo:
        app.run(loop="loop")

@@ -139,7 +144,6 @@ def test_app_run_raise_type_error(app: Sanic):


 def test_app_route_raise_value_error(app: Sanic):
-
    with pytest.raises(ValueError) as excinfo:

        @app.route("/test")
@@ -221,7 +225,6 @@ def test_app_websocket_parameters(websocket_protocol_mock, app: Sanic):


 def test_handle_request_with_nested_exception(app: Sanic, monkeypatch):
-
    err_msg = "Mock Exception"

    def mock_error_handler_response(*args, **kwargs):
@@ -241,7 +244,6 @@ def test_handle_request_with_nested_exception(app: Sanic, monkeypatch):


 def test_handle_request_with_nested_exception_debug(app: Sanic, monkeypatch):
-
    err_msg = "Mock Exception"

    def mock_error_handler_response(*args, **kwargs):
@@ -348,12 +350,14 @@ def test_app_registry_retrieval_from_multiple():
 def test_get_app_does_not_exist():
    with pytest.raises(
        SanicException,
-        match="Sanic app name 'does-not-exist' not found.\n"
+        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")

@@ -468,6 +472,7 @@ def test_uvloop_config(app: Sanic, monkeypatch, use):
        try_use_uvloop.assert_not_called()


+@pytest.mark.asyncio
 def test_uvloop_cannot_never_called_with_create_server(caplog, monkeypatch):
    apps = (Sanic("default-uvloop"), Sanic("no-uvloop"), Sanic("yes-uvloop"))

@@ -504,6 +509,7 @@ def test_uvloop_cannot_never_called_with_create_server(caplog, monkeypatch):
    assert counter[(logging.WARNING, message)] == modified


+@pytest.mark.asyncio
 def test_multiple_uvloop_configs_display_warning(caplog):
    Sanic._uvloop_setting = None  # Reset the setting (changed in prev tests)

--- a/tests/test_asgi.py
+++ b/tests/test_asgi.py
@@ -8,7 +8,7 @@ import uvicorn

 from sanic import Sanic
 from sanic.application.state import Mode
-from sanic.asgi import MockTransport
+from sanic.asgi import ASGIApp, MockTransport
 from sanic.exceptions import BadRequest, Forbidden, ServiceUnavailable
 from sanic.request import Request
 from sanic.response import json, text
@@ -16,6 +16,12 @@ from sanic.server.websockets.connection import WebSocketConnection
 from sanic.signals import RESERVED_NAMESPACES


+try:
+    from unittest.mock import AsyncMock
+except ImportError:
+    from tests.asyncmock import AsyncMock  # type: ignore
+
+
@pytest.fixture
 def message_stack():
    return deque()
@@ -336,7 +342,7 @@ async def test_websocket_send(send, receive, message_stack):


@pytest.mark.asyncio
-async def test_websocket_receive(send, receive, message_stack):
+async def test_websocket_text_receive(send, receive, message_stack):
    msg = {"text": "hello", "type": "websocket.receive"}
    message_stack.append(msg)

@@ -345,6 +351,15 @@ async def test_websocket_receive(send, receive, message_stack):

    assert text == msg["text"]

+@pytest.mark.asyncio
+async def test_websocket_bytes_receive(send, receive, message_stack):
+    msg = {"bytes": b"hello", "type": "websocket.receive"}
+    message_stack.append(msg)
+
+    ws = WebSocketConnection(send, receive)
+    data = await ws.receive()
+
+    assert data == msg["bytes"]

@pytest.mark.asyncio
 async def test_websocket_accept_with_no_subprotocols(
@@ -558,3 +573,39 @@ async def test_asgi_serve_location(app):

    _, response = await app.asgi_client.get("/")
    assert response.text == "http://<ASGI>"
+
+
+@pytest.mark.asyncio
+async def test_error_on_lifespan_exception_start(app, caplog):
+    @app.before_server_start
+    async def before_server_start(_):
+        1 / 0
+
+    recv = AsyncMock(return_value={"type": "lifespan.startup"})
+    send = AsyncMock()
+    app.asgi = True
+
+    with caplog.at_level(logging.ERROR):
+        await ASGIApp.create(app, {"type": "lifespan"}, recv, send)
+
+    send.assert_awaited_once_with(
+        {"type": "lifespan.startup.failed", "message": "division by zero"}
+    )
+
+
+@pytest.mark.asyncio
+async def test_error_on_lifespan_exception_stop(app: Sanic):
+    @app.before_server_stop
+    async def before_server_stop(_):
+        1 / 0
+
+    recv = AsyncMock(return_value={"type": "lifespan.shutdown"})
+    send = AsyncMock()
+    app.asgi = True
+    await app._startup()
+
+    await ASGIApp.create(app, {"type": "lifespan"}, recv, send)
+
+    send.assert_awaited_once_with(
+        {"type": "lifespan.shutdown.failed", "message": "division by zero"}
+    )
--- a/tests/test_cli.py
+++ b/tests/test_cli.py
@@ -4,6 +4,7 @@ import sys

 from pathlib import Path
 from typing import List, Optional, Tuple
+from unittest.mock import patch

 import pytest

@@ -11,6 +12,7 @@ from sanic_routing import __version__ as __routing_version__

 from sanic import __version__
 from sanic.__main__ import main
+from sanic.cli.inspector_client import InspectorClient


@pytest.fixture(scope="module", autouse=True)
@@ -117,7 +119,13 @@ def test_error_with_path_as_instance_without_simple_arg(caplog):
    ),
 )
 def test_tls_options(cmd: Tuple[str, ...], caplog):
-    command = ["fake.server.app", *cmd, "--port=9999", "--debug"]
+    command = [
+        "fake.server.app",
+        *cmd,
+        "--port=9999",
+        "--debug",
+        "--single-process",
+    ]
    lines = capture(command, caplog)
    assert "Goin' Fast @ https://127.0.0.1:9999" in lines

@@ -286,3 +294,50 @@ def test_noisy_exceptions(cmd: str, expected: bool, caplog):
    info = read_app_info(lines)

    assert info["noisy_exceptions"] is expected
+
+
+def test_inspector_inspect(urlopen, caplog, capsys):
+    urlopen.read.return_value = json.dumps(
+        {
+            "result": {
+                "info": {
+                    "packages": ["foo"],
+                },
+                "extra": {
+                    "more": "data",
+                },
+                "workers": {"Worker-Name": {"some": "state"}},
+            }
+        }
+    ).encode()
+    with patch("sys.argv", ["sanic", "inspect"]):
+        capture(["inspect"], caplog)
+    captured = capsys.readouterr()
+    assert "Inspecting @ http://localhost:6457" in captured.out
+    assert "Worker-Name" in captured.out
+    assert captured.err == ""
+
+
+@pytest.mark.parametrize(
+    "command,params",
+    (
+        (["reload"], {"zero_downtime": False}),
+        (["reload", "--zero-downtime"], {"zero_downtime": True}),
+        (["shutdown"], {}),
+        (["scale", "9"], {"replicas": 9}),
+        (["foo", "--bar=something"], {"bar": "something"}),
+        (["foo", "--bar"], {"bar": True}),
+        (["foo", "--no-bar"], {"bar": False}),
+        (["foo", "positional"], {"args": ["positional"]}),
+        (
+            ["foo", "positional", "--bar=something"],
+            {"args": ["positional"], "bar": "something"},
+        ),
+    ),
+)
+def test_inspector_command(command, params):
+    with patch.object(InspectorClient, "request") as client:
+        with patch("sys.argv", ["sanic", "inspect", *command]):
+            main()
+
+    client.assert_called_once_with(command[0], **params)
--- a/tests/test_coffee.py
+++ b/tests/test_coffee.py
@@ -39,7 +39,7 @@ def test_logo_true(app, caplog):
    with patch("sys.stdout.isatty") as isatty:
        isatty.return_value = True
        with caplog.at_level(logging.DEBUG):
-            app.make_coffee()
+            app.make_coffee(single_process=True)

    # Only in the regular logo
    assert "    ▄███ █████ ██    " not in caplog.text
--- a/tests/test_cookies.py
+++ b/tests/test_cookies.py
@@ -148,7 +148,6 @@ def test_cookie_set_unknown_property():


 def test_cookie_set_same_key(app):
-
    cookies = {"test": "wait"}

    @app.get("/")
--- a/tests/test_create_task.py
+++ b/tests/test_create_task.py
@@ -2,7 +2,6 @@ import asyncio
 import sys

 from threading import Event
-from unittest.mock import Mock

 import pytest

@@ -75,7 +74,7 @@ def test_create_named_task(app):

        app.stop()

-    app.run()
+    app.run(single_process=True)


 def test_named_task_called(app):
--- a/tests/test_exceptions_handler.py
+++ b/tests/test_exceptions_handler.py
@@ -62,7 +62,6 @@ def exception_handler_app():

    @exception_handler_app.route("/8", error_format="html")
    def handler_8(request):
-
        raise ErrorWithRequestCtx("OK")

    @exception_handler_app.exception(ErrorWithRequestCtx, NotFound)
@@ -214,7 +213,7 @@ def test_error_handler_noisy_log(
    exception_handler_app: Sanic, monkeypatch: MonkeyPatch
 ):
    err_logger = Mock()
-    monkeypatch.setattr(handlers, "error_logger", err_logger)
+    monkeypatch.setattr(handlers.error, "error_logger", err_logger)

    exception_handler_app.config["NOISY_EXCEPTIONS"] = False
    exception_handler_app.test_client.get("/1")
--- a/tests/test_logging.py
+++ b/tests/test_logging.py
@@ -10,8 +10,7 @@ import pytest
 import sanic

 from sanic import Sanic
-from sanic.log import Colors
-from sanic.log import LOGGING_CONFIG_DEFAULTS, logger
+from sanic.log import LOGGING_CONFIG_DEFAULTS, Colors, logger
 from sanic.response import text


@@ -254,11 +253,11 @@ def test_verbosity(app, caplog, app_verbosity, log_verbosity, exists):


 def test_colors_enum_format():
-    assert f'{Colors.END}' == Colors.END.value
-    assert f'{Colors.BOLD}' == Colors.BOLD.value
-    assert f'{Colors.BLUE}' == Colors.BLUE.value
-    assert f'{Colors.GREEN}' == Colors.GREEN.value
-    assert f'{Colors.PURPLE}' == Colors.PURPLE.value
-    assert f'{Colors.RED}' == Colors.RED.value
-    assert f'{Colors.SANIC}' == Colors.SANIC.value
-    assert f'{Colors.YELLOW}' == Colors.YELLOW.value
+    assert f"{Colors.END}" == Colors.END.value
+    assert f"{Colors.BOLD}" == Colors.BOLD.value
+    assert f"{Colors.BLUE}" == Colors.BLUE.value
+    assert f"{Colors.GREEN}" == Colors.GREEN.value
+    assert f"{Colors.PURPLE}" == Colors.PURPLE.value
+    assert f"{Colors.RED}" == Colors.RED.value
+    assert f"{Colors.SANIC}" == Colors.SANIC.value
+    assert f"{Colors.YELLOW}" == Colors.YELLOW.value
--- a/tests/test_middleware_priority.py
+++ b/tests/test_middleware_priority.py
@@ -3,7 +3,7 @@ from functools import partial
 import pytest

 from sanic import Sanic
-from sanic.middleware import Middleware
+from sanic.middleware import Middleware, MiddlewareLocation
 from sanic.response import json


@@ -40,6 +40,86 @@ def reset_middleware():
    Middleware.reset_count()


+def test_add_register_priority(app: Sanic):
+    def foo(*_):
+        ...
+
+    app.register_middleware(foo, priority=999)
+    assert len(app.request_middleware) == 1
+    assert len(app.response_middleware) == 0
+    assert app.request_middleware[0].priority == 999  # type: ignore
+    app.register_middleware(foo, attach_to="response", priority=999)
+    assert len(app.request_middleware) == 1
+    assert len(app.response_middleware) == 1
+    assert app.response_middleware[0].priority == 999  # type: ignore
+
+
+def test_add_register_named_priority(app: Sanic):
+    def foo(*_):
+        ...
+
+    app.register_named_middleware(foo, route_names=["foo"], priority=999)
+    assert len(app.named_request_middleware) == 1
+    assert len(app.named_response_middleware) == 0
+    assert app.named_request_middleware["foo"][0].priority == 999  # type: ignore
+    app.register_named_middleware(
+        foo, attach_to="response", route_names=["foo"], priority=999
+    )
+    assert len(app.named_request_middleware) == 1
+    assert len(app.named_response_middleware) == 1
+    assert app.named_response_middleware["foo"][0].priority == 999  # type: ignore
+
+
+def test_add_decorator_priority(app: Sanic):
+    def foo(*_):
+        ...
+
+    app.middleware(foo, priority=999)
+    assert len(app.request_middleware) == 1
+    assert len(app.response_middleware) == 0
+    assert app.request_middleware[0].priority == 999  # type: ignore
+    app.middleware(foo, attach_to="response", priority=999)
+    assert len(app.request_middleware) == 1
+    assert len(app.response_middleware) == 1
+    assert app.response_middleware[0].priority == 999  # type: ignore
+
+
+def test_add_convenience_priority(app: Sanic):
+    def foo(*_):
+        ...
+
+    app.on_request(foo, priority=999)
+    assert len(app.request_middleware) == 1
+    assert len(app.response_middleware) == 0
+    assert app.request_middleware[0].priority == 999  # type: ignore
+    app.on_response(foo, priority=999)
+    assert len(app.request_middleware) == 1
+    assert len(app.response_middleware) == 1
+    assert app.response_middleware[0].priority == 999  # type: ignore
+
+
+def test_add_conflicting_priority(app: Sanic):
+    def foo(*_):
+        ...
+
+    middleware = Middleware(foo, MiddlewareLocation.REQUEST, priority=998)
+    app.register_middleware(middleware=middleware, priority=999)
+    assert app.request_middleware[0].priority == 999  # type: ignore
+    middleware.priority == 998
+
+
+def test_add_conflicting_priority_named(app: Sanic):
+    def foo(*_):
+        ...
+
+    middleware = Middleware(foo, MiddlewareLocation.REQUEST, priority=998)
+    app.register_named_middleware(
+        middleware=middleware, route_names=["foo"], priority=999
+    )
+    assert app.named_request_middleware["foo"][0].priority == 999  # type: ignore
+    middleware.priority == 998
+
+
@pytest.mark.parametrize(
    "expected,priorities",
    PRIORITY_TEST_CASES,
--- a/tests/test_multiprocessing.py
+++ b/tests/test_multiprocessing.py
@@ -3,6 +3,7 @@ import multiprocessing
 import pickle
 import random
 import signal
+import sys

 from asyncio import sleep

@@ -11,6 +12,7 @@ import pytest
 from sanic_testing.testing import HOST, PORT

 from sanic import Blueprint, text
+from sanic.compat import use_context
 from sanic.log import logger
 from sanic.server.socket import configure_socket

@@ -20,6 +22,10 @@ from sanic.server.socket import configure_socket
    reason="SIGALRM is not implemented for this platform, we have to come "
    "up with another timeout strategy to test these",
 )
+@pytest.mark.skipif(
+    sys.platform not in ("linux", "darwin"),
+    reason="This test requires fork context",
+)
 def test_multiprocessing(app):
    """Tests that the number of children we produce is correct"""
    # Selects a number at random so we can spot check
@@ -37,7 +43,8 @@ def test_multiprocessing(app):

    signal.signal(signal.SIGALRM, stop_on_alarm)
    signal.alarm(2)
-    app.run(HOST, 4120, workers=num_workers, debug=True)
+    with use_context("fork"):
+        app.run(HOST, 4120, workers=num_workers, debug=True)

    assert len(process_list) == num_workers + 1

@@ -136,6 +143,10 @@ def test_multiprocessing_legacy_unix(app):
    not hasattr(signal, "SIGALRM"),
    reason="SIGALRM is not implemented for this platform",
 )
+@pytest.mark.skipif(
+    sys.platform not in ("linux", "darwin"),
+    reason="This test requires fork context",
+)
 def test_multiprocessing_with_blueprint(app):
    # Selects a number at random so we can spot check
    num_workers = random.choice(range(2, multiprocessing.cpu_count() * 2 + 1))
@@ -155,7 +166,8 @@ def test_multiprocessing_with_blueprint(app):

    bp = Blueprint("test_text")
    app.blueprint(bp)
-    app.run(HOST, 4121, workers=num_workers, debug=True)
+    with use_context("fork"):
+        app.run(HOST, 4121, workers=num_workers, debug=True)

    assert len(process_list) == num_workers + 1

@@ -213,6 +225,10 @@ def test_pickle_app_with_static(app, protocol):
    up_p_app.run(single_process=True)


+@pytest.mark.skipif(
+    sys.platform not in ("linux", "darwin"),
+    reason="This test requires fork context",
+)
 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))
@@ -235,8 +251,9 @@ def test_main_process_event(app, caplog):
    def main_process_stop2(app, loop):
        logger.info("main_process_stop")

-    with caplog.at_level(logging.INFO):
-        app.run(HOST, PORT, workers=num_workers)
+    with use_context("fork"):
+        with caplog.at_level(logging.INFO):
+            app.run(HOST, PORT, workers=num_workers)

    assert (
        caplog.record_tuples.count(("sanic.root", 20, "main_process_start"))
--- a/tests/test_request_stream.py
+++ b/tests/test_request_stream.py
@@ -1,8 +1,5 @@
 import asyncio

-from contextlib import closing
-from socket import socket
-
 import pytest

 from sanic import Sanic
@@ -623,6 +620,4 @@ def test_streaming_echo():
        res = await read_chunk()
        assert res == None

-    # Use random port for tests
-    with closing(socket()) as sock:
-        app.run(access_log=False)
+    app.run(access_log=False, single_process=True)
--- a/tests/test_requests.py
+++ b/tests/test_requests.py
@@ -1293,6 +1293,24 @@ async def test_request_string_representation_asgi(app):
            "------sanic--\r\n",
            "filename_\u00A0_test",
        ),
+        # Umlaut using NFC normalization (Windows, Linux, Android)
+        (
+            "------sanic\r\n"
+            'content-disposition: form-data; filename*="utf-8\'\'filename_%C3%A4_test"; name="test"\r\n'
+            "\r\n"
+            "OK\r\n"
+            "------sanic--\r\n",
+            "filename_\u00E4_test",
+        ),
+        # Umlaut using NFD normalization (MacOS client)
+        (
+            "------sanic\r\n"
+            'content-disposition: form-data; filename*="utf-8\'\'filename_a%CC%88_test"; name="test"\r\n'
+            "\r\n"
+            "OK\r\n"
+            "------sanic--\r\n",
+            "filename_\u00E4_test",  # Sanic should normalize to NFC
+        ),
    ],
 )
 def test_request_multipart_files(app, payload, filename):
--- a/tests/test_response.py
+++ b/tests/test_response.py
@@ -514,7 +514,6 @@ def test_file_stream_head_response(
 def test_file_stream_response_range(
    app: Sanic, file_name, static_file_directory, size, start, end
 ):
-
    Range = namedtuple("Range", ["size", "start", "end", "total"])
    total = len(get_file_content(static_file_directory, file_name))
    range = Range(size=size, start=start, end=end, total=total)
--- a/tests/test_routes.py
+++ b/tests/test_routes.py
@@ -722,7 +722,6 @@ def test_add_webscoket_route_with_version(app):


 def test_route_duplicate(app):
-
    with pytest.raises(RouteExists):

        @app.route("/test")
@@ -803,8 +802,22 @@ def test_static_add_route(app, strict_slashes):
    assert response.text == "OK2"


-def test_dynamic_add_route(app):
+@pytest.mark.parametrize("unquote", [True, False, None])
+def test_unquote_add_route(app, unquote):
+    async def handler1(_, foo):
+        return text(foo)

+    app.add_route(handler1, "/<foo>", unquote=unquote)
+    value = "啊" if unquote else r"%E5%95%8A"
+
+    _, response = app.test_client.get("/啊")
+    assert response.text == value
+
+    _, response = app.test_client.get(r"/%E5%95%8A")
+    assert response.text == value
+
+
+def test_dynamic_add_route(app):
    results = []

    async def handler(request, name):
@@ -819,7 +832,6 @@ def test_dynamic_add_route(app):


 def test_dynamic_add_route_string(app):
-
    results = []

    async def handler(request, name):
@@ -923,7 +935,6 @@ def test_dynamic_add_route_unhashable(app):


 def test_add_route_duplicate(app):
-
    with pytest.raises(RouteExists):

        async def handler1(request):
@@ -1105,7 +1116,6 @@ def test_route_raise_ParameterNameConflicts(app):


 def test_route_invalid_host(app):
-
    host = 321
    with pytest.raises(ValueError) as excinfo:

--- a/tests/test_signal_handlers.py
+++ b/tests/test_signal_handlers.py
@@ -93,6 +93,7 @@ def test_dont_register_system_signals(app):
@pytest.mark.skipif(os.name == "nt", reason="windows cannot SIGINT processes")
 def test_windows_workaround():
    """Test Windows workaround (on any other OS)"""
+
    # At least some code coverage, even though this test doesn't work on
    # Windows...
    class MockApp:
--- a/tests/test_signals.py
+++ b/tests/test_signals.py
@@ -7,7 +7,7 @@ import pytest

 from sanic_routing.exceptions import NotFound

-from sanic import Blueprint
+from sanic import Blueprint, Sanic, empty
 from sanic.exceptions import InvalidSignal, SanicException


@@ -20,6 +20,31 @@ def test_add_signal(app):
    assert len(app.signal_router.routes) == 1


+def test_add_signal_method_handler(app):
+    counter = 0
+
+    class TestSanic(Sanic):
+        def __init__(self, *args, **kwargs):
+            super().__init__(*args, **kwargs)
+            self.add_signal(
+                self.after_routing_signal_handler, "http.routing.after"
+            )
+
+        def after_routing_signal_handler(self, *args, **kwargs):
+            nonlocal counter
+            counter += 1
+
+    app = TestSanic("Test")
+    assert len(app.signal_router.routes) == 1
+
+    @app.route("/")
+    async def handler(_):
+        return empty()
+
+    app.test_client.get("/")
+    assert counter == 1
+
+
 def test_add_signal_decorator(app):
    @app.signal("foo.bar.baz")
    def sync_signal(*_):
@@ -289,10 +314,10 @@ async def test_dispatch_signal_triggers_event_on_bp(app):
    waiter = bp.event("foo.bar.baz")
    assert isawaitable(waiter)

-    fut = asyncio.ensure_future(do_wait())
+    fut = do_wait()
    for signal in signal_group:
        signal.ctx.event.set()
-    await fut
+    await asyncio.gather(fut)

    assert bp_counter == 1

--- a/tests/test_static.py
+++ b/tests/test_static.py
@@ -1,4 +1,3 @@
-import inspect
 import logging
 import os
 import sys
@@ -13,15 +12,6 @@ from sanic import Sanic, text
 from sanic.exceptions import FileNotFound


-@pytest.fixture(scope="module")
-def static_file_directory():
-    """The static directory to serve"""
-    current_file = inspect.getfile(inspect.currentframe())
-    current_directory = os.path.dirname(os.path.abspath(current_file))
-    static_directory = os.path.join(current_directory, "static")
-    return static_directory
-
-
@pytest.fixture(scope="module")
 def double_dotted_directory_file(static_file_directory: str):
    """Generate double dotted directory and its files"""
@@ -118,7 +108,12 @@ def test_static_file_pathlib(app, static_file_directory, file_name):
 def test_static_file_bytes(app, static_file_directory, file_name):
    bsep = os.path.sep.encode("utf-8")
    file_path = static_file_directory.encode("utf-8") + bsep + file_name
-    app.static("/testing.file", file_path)
+    message = (
+        "Serving a static directory with a bytes "
+        "string is deprecated and will be removed in v22.9."
+    )
+    with pytest.warns(DeprecationWarning, match=message):
+        app.static("/testing.file", file_path)
    request, response = app.test_client.get("/testing.file")
    assert response.status == 200

@@ -431,7 +426,6 @@ def test_static_stream_large_file(
    "file_name", ["test.file", "decode me.txt", "python.png"]
 )
 def test_use_modified_since(app, static_file_directory, file_name):
-
    file_stat = os.stat(get_file_path(static_file_directory, file_name))
    modified_since = strftime(
        "%a, %d %b %Y %H:%M:%S GMT", gmtime(file_stat.st_mtime)
--- a/tests/test_static_directory.py
+++ b/tests/test_static_directory.py
@@ -0,0 +1,123 @@
+import os
+
+from pathlib import Path
+
+import pytest
+
+from sanic import Sanic
+from sanic.handlers.directory import DirectoryHandler
+
+
+def get_file_path(static_file_directory, file_name):
+    return os.path.join(static_file_directory, file_name)
+
+
+def get_file_content(static_file_directory, file_name):
+    """The content of the static file to check"""
+    with open(get_file_path(static_file_directory, file_name), "rb") as file:
+        return file.read()
+
+
+def test_static_directory_view(app: Sanic, static_file_directory: str):
+    app.static("/static", static_file_directory, directory_view=True)
+
+    _, response = app.test_client.get("/static/")
+    assert response.status == 200
+    assert response.content_type == "text/html; charset=utf-8"
+    assert "<title>Directory Viewer</title>" in response.text
+
+
+def test_static_index_single(app: Sanic, static_file_directory: str):
+    app.static("/static", static_file_directory, index="test.html")
+
+    _, response = app.test_client.get("/static/")
+    assert response.status == 200
+    assert response.body == get_file_content(
+        static_file_directory, "test.html"
+    )
+    assert response.headers["Content-Type"] == "text/html"
+
+
+def test_static_index_single_not_found(app: Sanic, static_file_directory: str):
+    app.static("/static", static_file_directory, index="index.html")
+
+    _, response = app.test_client.get("/static/")
+    assert response.status == 404
+
+
+def test_static_index_multiple(app: Sanic, static_file_directory: str):
+    app.static(
+        "/static",
+        static_file_directory,
+        index=["index.html", "test.html"],
+    )
+
+    _, response = app.test_client.get("/static/")
+    assert response.status == 200
+    assert response.body == get_file_content(
+        static_file_directory, "test.html"
+    )
+    assert response.headers["Content-Type"] == "text/html"
+
+
+def test_static_directory_view_and_index(
+    app: Sanic, static_file_directory: str
+):
+    app.static(
+        "/static",
+        static_file_directory,
+        directory_view=True,
+        index="foo.txt",
+    )
+
+    _, response = app.test_client.get("/static/nested/")
+    assert response.status == 200
+    assert response.content_type == "text/html; charset=utf-8"
+    assert "<title>Directory Viewer</title>" in response.text
+
+    _, response = app.test_client.get("/static/nested/dir/")
+    assert response.status == 200
+    assert response.body == get_file_content(
+        f"{static_file_directory}/nested/dir", "foo.txt"
+    )
+    assert response.content_type == "text/plain"
+
+
+def test_static_directory_handler(app: Sanic, static_file_directory: str):
+    dh = DirectoryHandler(
+        "/static",
+        Path(static_file_directory),
+        directory_view=True,
+        index="foo.txt",
+    )
+    app.static("/static", static_file_directory, directory_handler=dh)
+
+    _, response = app.test_client.get("/static/nested/")
+    assert response.status == 200
+    assert response.content_type == "text/html; charset=utf-8"
+    assert "<title>Directory Viewer</title>" in response.text
+
+    _, response = app.test_client.get("/static/nested/dir/")
+    assert response.status == 200
+    assert response.body == get_file_content(
+        f"{static_file_directory}/nested/dir", "foo.txt"
+    )
+    assert response.content_type == "text/plain"
+
+
+def test_static_directory_handler_fails(app: Sanic):
+    dh = DirectoryHandler(
+        "/static",
+        Path(""),
+        directory_view=True,
+        index="foo.txt",
+    )
+    message = (
+        "When explicitly setting directory_handler, you cannot "
+        "set either directory_view or index. Instead, pass "
+        "these arguments to your DirectoryHandler instance."
+    )
+    with pytest.raises(ValueError, match=message):
+        app.static("/static", "", directory_handler=dh, directory_view=True)
+    with pytest.raises(ValueError, match=message):
+        app.static("/static", "", directory_handler=dh, index="index.html")
--- a/tests/test_tls.py
+++ b/tests/test_tls.py
@@ -2,6 +2,7 @@ import logging
 import os
 import ssl
 import subprocess
+import sys

 from contextlib import contextmanager
 from multiprocessing import Event
@@ -17,6 +18,7 @@ import sanic.http.tls.creators

 from sanic import Sanic
 from sanic.application.constants import Mode
+from sanic.compat import use_context
 from sanic.constants import LocalCertCreator
 from sanic.exceptions import SanicException
 from sanic.helpers import _default
@@ -426,7 +428,12 @@ def test_logger_vhosts(caplog):
        app.stop()

    with caplog.at_level(logging.INFO):
-        app.run(host="127.0.0.1", port=42102, ssl=[localhost_dir, sanic_dir])
+        app.run(
+            host="127.0.0.1",
+            port=42102,
+            ssl=[localhost_dir, sanic_dir],
+            single_process=True,
+        )

    logmsg = [
        m for s, l, m in caplog.record_tuples if m.startswith("Certificate")
@@ -642,8 +649,11 @@ def test_sanic_ssl_context_create():
    assert isinstance(sanic_context, SanicSSLContext)


+@pytest.mark.skipif(
+    sys.platform not in ("linux", "darwin"),
+    reason="This test requires fork context",
+)
 def test_ssl_in_multiprocess_mode(app: Sanic, caplog):
-
    ssl_dict = {"cert": localhost_cert, "key": localhost_key}
    event = Event()

@@ -657,8 +667,9 @@ def test_ssl_in_multiprocess_mode(app: Sanic, caplog):
        app.stop()

    assert not event.is_set()
-    with caplog.at_level(logging.INFO):
-        app.run(ssl=ssl_dict)
+    with use_context("fork"):
+        with caplog.at_level(logging.INFO):
+            app.run(ssl=ssl_dict)
    assert event.is_set()

    assert (
--- a/tests/test_unix_socket.py
+++ b/tests/test_unix_socket.py
@@ -1,6 +1,7 @@
 # import asyncio
 import logging
 import os
+import sys

 from asyncio import AbstractEventLoop, sleep
 from string import ascii_lowercase
@@ -12,6 +13,7 @@ import pytest
 from pytest import LogCaptureFixture

 from sanic import Sanic
+from sanic.compat import use_context
 from sanic.request import Request
 from sanic.response import text

@@ -174,7 +176,8 @@ def handler(request: Request):

 async def client(app: Sanic, loop: AbstractEventLoop):
    try:
-        async with httpx.AsyncClient(uds=SOCKPATH) as client:
+        transport = httpx.AsyncHTTPTransport(uds=SOCKPATH)
+        async with httpx.AsyncClient(transport=transport) as client:
            r = await client.get("http://myhost.invalid/")
            assert r.status_code == 200
            assert r.text == os.path.abspath(SOCKPATH)
@@ -183,11 +186,16 @@ async def client(app: Sanic, loop: AbstractEventLoop):
        app.stop()


+@pytest.mark.skipif(
+    sys.platform not in ("linux", "darwin"),
+    reason="This test requires fork context",
+)
 def test_unix_connection_multiple_workers():
-    app_multi = Sanic(name="test")
-    app_multi.get("/")(handler)
-    app_multi.listener("after_server_start")(client)
-    app_multi.run(host="myhost.invalid", unix=SOCKPATH, workers=2)
+    with use_context("fork"):
+        app_multi = Sanic(name="test")
+        app_multi.get("/")(handler)
+        app_multi.listener("after_server_start")(client)
+        app_multi.run(host="myhost.invalid", unix=SOCKPATH, workers=2)


 # @pytest.mark.xfail(
--- a/tests/test_url_building.py
+++ b/tests/test_url_building.py
@@ -83,7 +83,6 @@ def test_simple_url_for_getting_with_more_params(app, args, url):


 def test_url_for_with_server_name(app):
-
    server_name = f"{test_host}:{test_port}"
    app.config.update({"SERVER_NAME": server_name})
    path = "/myurl"
--- a/tests/test_utils.py
+++ b/tests/test_utils.py
@@ -38,7 +38,6 @@ def test_load_module_from_file_location_with_non_existing_env_variable():
        LoadFileException,
        match="The following environment variables are not set: MuuMilk",
    ):
-
        load_module_from_file_location("${MuuMilk}")


--- a/tests/worker/test_inspector.py
+++ b/tests/worker/test_inspector.py
@@ -1,14 +1,20 @@
-import json
+try:  # no cov
+    from ujson import dumps
+except ModuleNotFoundError:  # no cov
+    from json import dumps  # type: ignore

 from datetime import datetime
-from logging import ERROR, INFO
-from socket import AF_INET, SOCK_STREAM, timeout
 from unittest.mock import Mock, patch
+from urllib.error import URLError

 import pytest

+from sanic_testing import TestManager
+
+from sanic.cli.inspector_client import InspectorClient
+from sanic.helpers import Default
 from sanic.log import Colors
-from sanic.worker.inspector import Inspector, inspect
+from sanic.worker.inspector import Inspector


 DATA = {
@@ -20,121 +26,90 @@ DATA = {
    },
    "workers": {"Worker-Name": {"some": "state"}},
 }
-SERIALIZED = json.dumps(DATA)
+FULL_SERIALIZED = dumps({"result": DATA})
+OUT_SERIALIZED = dumps(DATA)


-def test_inspector_stop():
-    inspector = Inspector(Mock(), {}, {}, "", 1)
-    assert inspector.run is True
-    inspector.stop()
-    assert inspector.run is False
+class FooInspector(Inspector):
+    async def foo(self, bar):
+        return f"bar is {bar}"


-@patch("sanic.worker.inspector.sys.stdout.write")
-@patch("sanic.worker.inspector.socket")
-@pytest.mark.parametrize("command", ("foo", "raw", "pretty"))
-def test_send_inspect(socket: Mock, write: Mock, command: str):
-    socket.return_value = socket
-    socket.__enter__.return_value = socket
-    socket.recv.return_value = SERIALIZED.encode()
-    inspect("localhost", 9999, command)
-
-    socket.sendall.assert_called_once_with(command.encode())
-    socket.recv.assert_called_once_with(4096)
-    socket.connect.assert_called_once_with(("localhost", 9999))
-    socket.assert_called_once_with(AF_INET, SOCK_STREAM)
-
-    if command == "raw":
-        write.assert_called_once_with(SERIALIZED)
-    elif command == "pretty":
-        write.assert_called()
-    else:
-        write.assert_not_called()
+@pytest.fixture
+def publisher():
+    publisher = Mock()
+    return publisher


-@patch("sanic.worker.inspector.sys")
-@patch("sanic.worker.inspector.socket")
-def test_send_inspect_conn_refused(socket: Mock, sys: Mock, caplog):
-    with caplog.at_level(INFO):
-        socket.return_value = socket
-        socket.__enter__.return_value = socket
-        socket.connect.side_effect = ConnectionRefusedError()
-        inspect("localhost", 9999, "foo")
+@pytest.fixture
+def inspector(publisher):
+    inspector = FooInspector(
+        publisher, {}, {}, "localhost", 9999, "", Default(), Default()
+    )
+    inspector(False)
+    return inspector

-        socket.close.assert_called_once()
-        sys.exit.assert_called_once_with(1)
+
+@pytest.fixture
+def http_client(inspector):
+    manager = TestManager(inspector.app)
+    return manager.test_client
+
+
+@pytest.mark.parametrize("command", ("info",))
+@patch("sanic.cli.inspector_client.sys.stdout.write")
+def test_send_inspect(write, urlopen, command: str):
+    urlopen.read.return_value = FULL_SERIALIZED.encode()
+    InspectorClient("localhost", 9999, False, False, None).do(command)
+    write.assert_called()
+    write.reset_mock()
+    InspectorClient("localhost", 9999, False, True, None).do(command)
+    write.assert_called_with(OUT_SERIALIZED + "\n")
+
+
+@patch("sanic.cli.inspector_client.sys")
+def test_send_inspect_conn_refused(sys: Mock, urlopen):
+    urlopen.side_effect = URLError("")
+    InspectorClient("localhost", 9999, False, False, None).do("info")

    message = (
        f"{Colors.RED}Could not connect to inspector at: "
-        f"{Colors.YELLOW}('localhost', 9999){Colors.END}\n"
+        f"{Colors.YELLOW}http://localhost:9999{Colors.END}\n"
        "Either the application is not running, or it did not start "
-        "an inspector instance."
+        "an inspector instance.\n<urlopen error >\n"
    )
-    assert ("sanic.error", ERROR, message) in caplog.record_tuples
+    sys.exit.assert_called_once_with(1)
+    sys.stderr.write.assert_called_once_with(message)


-@patch("sanic.worker.inspector.configure_socket")
-@pytest.mark.parametrize("action", (b"reload", b"shutdown", b"foo"))
-def test_run_inspector(configure_socket: Mock, action: bytes):
-    sock = Mock()
-    conn = Mock()
-    conn.recv.return_value = action
-    configure_socket.return_value = sock
-    inspector = Inspector(Mock(), {}, {}, "localhost", 9999)
-    inspector.reload = Mock()  # type: ignore
-    inspector.shutdown = Mock()  # type: ignore
-    inspector.state_to_json = Mock(return_value="foo")  # type: ignore
-
-    def accept():
-        inspector.run = False
-        return conn, ...
-
-    sock.accept = accept
-
-    inspector()
-
-    configure_socket.assert_called_once_with(
-        {"host": "localhost", "port": 9999, "unix": None, "backlog": 1}
-    )
-    conn.recv.assert_called_with(64)
-
-    if action == b"reload":
-        conn.send.assert_called_with(b"\n")
-        inspector.reload.assert_called()
-        inspector.shutdown.assert_not_called()
-        inspector.state_to_json.assert_not_called()
-    elif action == b"shutdown":
-        conn.send.assert_called_with(b"\n")
-        inspector.reload.assert_not_called()
-        inspector.shutdown.assert_called()
-        inspector.state_to_json.assert_not_called()
-    else:
-        conn.send.assert_called_with(b'"foo"')
-        inspector.reload.assert_not_called()
-        inspector.shutdown.assert_not_called()
-        inspector.state_to_json.assert_called()
+def test_run_inspector_reload(publisher, http_client):
+    _, response = http_client.post("/reload")
+    assert response.status == 200
+    publisher.send.assert_called_once_with("__ALL_PROCESSES__:")


-@patch("sanic.worker.inspector.configure_socket")
-def test_accept_timeout(configure_socket: Mock):
-    sock = Mock()
-    configure_socket.return_value = sock
-    inspector = Inspector(Mock(), {}, {}, "localhost", 9999)
-    inspector.reload = Mock()  # type: ignore
-    inspector.shutdown = Mock()  # type: ignore
-    inspector.state_to_json = Mock(return_value="foo")  # type: ignore
+def test_run_inspector_reload_zero_downtime(publisher, http_client):
+    _, response = http_client.post("/reload", json={"zero_downtime": True})
+    assert response.status == 200
+    publisher.send.assert_called_once_with("__ALL_PROCESSES__::STARTUP_FIRST")

-    def accept():
-        inspector.run = False
-        raise timeout

-    sock.accept = accept
+def test_run_inspector_shutdown(publisher, http_client):
+    _, response = http_client.post("/shutdown")
+    assert response.status == 200
+    publisher.send.assert_called_once_with("__TERMINATE__")

-    inspector()

-    inspector.reload.assert_not_called()
-    inspector.shutdown.assert_not_called()
-    inspector.state_to_json.assert_not_called()
+def test_run_inspector_scale(publisher, http_client):
+    _, response = http_client.post("/scale", json={"replicas": 4})
+    assert response.status == 200
+    publisher.send.assert_called_once_with("__SCALE__:4")
+
+
+def test_run_inspector_arbitrary(http_client):
+    _, response = http_client.post("/foo", json={"bar": 99})
+    assert response.status == 200
+    assert response.json == {"meta": {"action": "foo"}, "result": "bar is 99"}


 def test_state_to_json():
@@ -142,8 +117,10 @@ def test_state_to_json():
    now_iso = now.isoformat()
    app_info = {"app": "hello"}
    worker_state = {"Test": {"now": now, "nested": {"foo": now}}}
-    inspector = Inspector(Mock(), app_info, worker_state, "", 0)
-    state = inspector.state_to_json()
+    inspector = Inspector(
+        Mock(), app_info, worker_state, "", 0, "", Default(), Default()
+    )
+    state = inspector._state_to_json()

    assert state == {
        "info": app_info,
@@ -151,17 +128,14 @@ def test_state_to_json():
    }


-def test_reload():
-    publisher = Mock()
-    inspector = Inspector(publisher, {}, {}, "", 0)
-    inspector.reload()
-
-    publisher.send.assert_called_once_with("__ALL_PROCESSES__:")
-
-
-def test_shutdown():
-    publisher = Mock()
-    inspector = Inspector(publisher, {}, {}, "", 0)
-    inspector.shutdown()
-
-    publisher.send.assert_called_once_with("__TERMINATE__")
+def test_run_inspector_authentication():
+    inspector = Inspector(
+        Mock(), {}, {}, "", 0, "super-secret", Default(), Default()
+    )(False)
+    manager = TestManager(inspector.app)
+    _, response = manager.test_client.get("/")
+    assert response.status == 401
+    _, response = manager.test_client.get(
+        "/", headers={"Authorization": "Bearer super-secret"}
+    )
+    assert response.status == 200
--- a/tests/worker/test_manager.py
+++ b/tests/worker/test_manager.py
@@ -1,12 +1,21 @@
-from signal import SIGINT, SIGKILL
+from logging import ERROR, INFO
+from signal import SIGINT
 from unittest.mock import Mock, call, patch

 import pytest

+from sanic.compat import OS_IS_WINDOWS
 from sanic.exceptions import ServerKilled
+from sanic.worker.constants import RestartOrder
 from sanic.worker.manager import WorkerManager


+if not OS_IS_WINDOWS:
+    from signal import SIGKILL
+else:
+    SIGKILL = SIGINT
+
+
 def fake_serve():
    ...

@@ -14,14 +23,7 @@ def fake_serve():
 def test_manager_no_workers():
    message = "Cannot serve with no workers"
    with pytest.raises(RuntimeError, match=message):
-        WorkerManager(
-            0,
-            fake_serve,
-            {},
-            Mock(),
-            (Mock(), Mock()),
-            {},
-        )
+        WorkerManager(0, fake_serve, {}, Mock(), (Mock(), Mock()), {})


@patch("sanic.worker.process.os")
@@ -30,17 +32,8 @@ def test_terminate(os_mock: Mock):
    process.pid = 1234
    context = Mock()
    context.Process.return_value = process
-    manager = WorkerManager(
-        1,
-        fake_serve,
-        {},
-        context,
-        (Mock(), Mock()),
-        {},
-    )
-    assert manager.terminated is False
+    manager = WorkerManager(1, fake_serve, {}, context, (Mock(), Mock()), {})
    manager.terminate()
-    assert manager.terminated is True
    os_mock.kill.assert_called_once_with(1234, SIGINT)


@@ -51,14 +44,7 @@ def test_shutown(os_mock: Mock):
    process.is_alive.return_value = True
    context = Mock()
    context.Process.return_value = process
-    manager = WorkerManager(
-        1,
-        fake_serve,
-        {},
-        context,
-        (Mock(), Mock()),
-        {},
-    )
+    manager = WorkerManager(1, fake_serve, {}, context, (Mock(), Mock()), {})
    manager.shutdown()
    os_mock.kill.assert_called_once_with(1234, SIGINT)

@@ -69,32 +55,36 @@ def test_kill(os_mock: Mock):
    process.pid = 1234
    context = Mock()
    context.Process.return_value = process
-    manager = WorkerManager(
-        1,
-        fake_serve,
-        {},
-        context,
-        (Mock(), Mock()),
-        {},
-    )
+    manager = WorkerManager(1, fake_serve, {}, context, (Mock(), Mock()), {})
    with pytest.raises(ServerKilled):
        manager.kill()
    os_mock.kill.assert_called_once_with(1234, SIGKILL)


+@patch("sanic.worker.process.os")
+@patch("sanic.worker.manager.os")
+def test_shutdown_signal_send_kill(
+    manager_os_mock: Mock, process_os_mock: Mock
+):
+    process = Mock()
+    process.pid = 1234
+    context = Mock()
+    context.Process.return_value = process
+    manager = WorkerManager(1, fake_serve, {}, context, (Mock(), Mock()), {})
+    assert manager._shutting_down is False
+    manager.shutdown_signal(SIGINT, None)
+    assert manager._shutting_down is True
+    process_os_mock.kill.assert_called_once_with(1234, SIGINT)
+    manager.shutdown_signal(SIGINT, None)
+    manager_os_mock.kill.assert_called_once_with(1234, SIGKILL)
+
+
 def test_restart_all():
    p1 = Mock()
    p2 = Mock()
    context = Mock()
    context.Process.side_effect = [p1, p2, p1, p2]
-    manager = WorkerManager(
-        2,
-        fake_serve,
-        {},
-        context,
-        (Mock(), Mock()),
-        {},
-    )
+    manager = WorkerManager(2, fake_serve, {}, context, (Mock(), Mock()), {})
    assert len(list(manager.transient_processes))
    manager.restart()
    p1.terminate.assert_called_once()
@@ -129,91 +119,187 @@ def test_restart_all():
    )


-def test_monitor_all():
+@pytest.mark.parametrize("zero_downtime", (False, True))
+def test_monitor_all(zero_downtime):
    p1 = Mock()
    p2 = Mock()
    sub = Mock()
-    sub.recv.side_effect = ["__ALL_PROCESSES__:", ""]
+    incoming = (
+        "__ALL_PROCESSES__::STARTUP_FIRST"
+        if zero_downtime
+        else "__ALL_PROCESSES__:"
+    )
+    sub.recv.side_effect = [incoming, ""]
    context = Mock()
    context.Process.side_effect = [p1, p2]
-    manager = WorkerManager(
-        2,
-        fake_serve,
-        {},
-        context,
-        (Mock(), sub),
-        {},
-    )
+    manager = WorkerManager(2, fake_serve, {}, context, (Mock(), sub), {})
    manager.restart = Mock()  # type: ignore
    manager.wait_for_ack = Mock()  # type: ignore
    manager.monitor()

+    restart_order = (
+        RestartOrder.STARTUP_FIRST
+        if zero_downtime
+        else RestartOrder.SHUTDOWN_FIRST
+    )
    manager.restart.assert_called_once_with(
-        process_names=None, reloaded_files=""
+        process_names=None,
+        reloaded_files="",
+        restart_order=restart_order,
    )


-def test_monitor_all_with_files():
+@pytest.mark.parametrize("zero_downtime", (False, True))
+def test_monitor_all_with_files(zero_downtime):
    p1 = Mock()
    p2 = Mock()
    sub = Mock()
-    sub.recv.side_effect = ["__ALL_PROCESSES__:foo,bar", ""]
+    incoming = (
+        "__ALL_PROCESSES__:foo,bar:STARTUP_FIRST"
+        if zero_downtime
+        else "__ALL_PROCESSES__:foo,bar"
+    )
+    sub.recv.side_effect = [incoming, ""]
    context = Mock()
    context.Process.side_effect = [p1, p2]
-    manager = WorkerManager(
-        2,
-        fake_serve,
-        {},
-        context,
-        (Mock(), sub),
-        {},
-    )
+    manager = WorkerManager(2, fake_serve, {}, context, (Mock(), sub), {})
    manager.restart = Mock()  # type: ignore
    manager.wait_for_ack = Mock()  # type: ignore
    manager.monitor()

+    restart_order = (
+        RestartOrder.STARTUP_FIRST
+        if zero_downtime
+        else RestartOrder.SHUTDOWN_FIRST
+    )
    manager.restart.assert_called_once_with(
-        process_names=None, reloaded_files="foo,bar"
+        process_names=None,
+        reloaded_files="foo,bar",
+        restart_order=restart_order,
    )


-def test_monitor_one_process():
+@pytest.mark.parametrize("zero_downtime", (False, True))
+def test_monitor_one_process(zero_downtime):
    p1 = Mock()
    p1.name = "Testing"
    p2 = Mock()
    sub = Mock()
-    sub.recv.side_effect = [f"{p1.name}:foo,bar", ""]
+    incoming = (
+        f"{p1.name}:foo,bar:STARTUP_FIRST"
+        if zero_downtime
+        else f"{p1.name}:foo,bar"
+    )
+    sub.recv.side_effect = [incoming, ""]
    context = Mock()
    context.Process.side_effect = [p1, p2]
-    manager = WorkerManager(
-        2,
-        fake_serve,
-        {},
-        context,
-        (Mock(), sub),
-        {},
-    )
+    manager = WorkerManager(2, fake_serve, {}, context, (Mock(), sub), {})
    manager.restart = Mock()  # type: ignore
    manager.wait_for_ack = Mock()  # type: ignore
    manager.monitor()

+    restart_order = (
+        RestartOrder.STARTUP_FIRST
+        if zero_downtime
+        else RestartOrder.SHUTDOWN_FIRST
+    )
    manager.restart.assert_called_once_with(
-        process_names=[p1.name], reloaded_files="foo,bar"
+        process_names=[p1.name],
+        reloaded_files="foo,bar",
+        restart_order=restart_order,
    )


 def test_shutdown_signal():
    pub = Mock()
-    manager = WorkerManager(
-        1,
-        fake_serve,
-        {},
-        Mock(),
-        (pub, Mock()),
-        {},
-    )
+    manager = WorkerManager(1, fake_serve, {}, Mock(), (pub, Mock()), {})
    manager.shutdown = Mock()  # type: ignore

    manager.shutdown_signal(SIGINT, None)
    pub.send.assert_called_with(None)
    manager.shutdown.assert_called_once_with()
+
+
+def test_shutdown_servers(caplog):
+    p1 = Mock()
+    p1.pid = 1234
+    context = Mock()
+    context.Process.side_effect = [p1]
+    pub = Mock()
+    manager = WorkerManager(1, fake_serve, {}, context, (pub, Mock()), {})
+
+    with patch("os.kill") as kill:
+        with caplog.at_level(ERROR):
+            manager.shutdown_server()
+
+            kill.assert_called_once_with(1234, SIGINT)
+            kill.reset_mock()
+
+            assert not caplog.record_tuples
+
+            manager.shutdown_server()
+
+            kill.assert_not_called()
+
+            assert (
+                "sanic.error",
+                ERROR,
+                "Server shutdown failed because a server was not found.",
+            ) in caplog.record_tuples
+
+
+def test_shutdown_servers_named():
+    p1 = Mock()
+    p1.pid = 1234
+    p2 = Mock()
+    p2.pid = 6543
+    context = Mock()
+    context.Process.side_effect = [p1, p2]
+    pub = Mock()
+    manager = WorkerManager(2, fake_serve, {}, context, (pub, Mock()), {})
+
+    with patch("os.kill") as kill:
+        with pytest.raises(KeyError):
+            manager.shutdown_server("foo")
+        manager.shutdown_server("Server-1")
+
+        kill.assert_called_once_with(6543, SIGINT)
+
+
+def test_scale(caplog):
+    p1 = Mock()
+    p1.pid = 1234
+    p2 = Mock()
+    p2.pid = 3456
+    p3 = Mock()
+    p3.pid = 5678
+    context = Mock()
+    context.Process.side_effect = [p1, p2, p3]
+    pub = Mock()
+    manager = WorkerManager(1, fake_serve, {}, context, (pub, Mock()), {})
+
+    assert len(manager.transient) == 1
+
+    manager.scale(3)
+    assert len(manager.transient) == 3
+
+    with patch("os.kill") as kill:
+        manager.scale(2)
+        assert len(manager.transient) == 2
+
+        manager.scale(1)
+        assert len(manager.transient) == 1
+
+        kill.call_count == 2
+
+    with caplog.at_level(INFO):
+        manager.scale(1)
+
+    assert (
+        "sanic.root",
+        INFO,
+        "No change needed. There are already 1 workers.",
+    ) in caplog.record_tuples
+
+    with pytest.raises(ValueError, match=r"Cannot scale to 0 workers\."):
+        manager.scale(0)
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Adam Hopkins	d9f7086ee6	Add color changes	2023-02-16 14:59:09 +02:00
SML	26e999dec0	Switch blue to code block orange in sanic docs. Add sanic highlight override. Add darker sanic background (111) as option but in the comments so we can switch back if need be.	2023-02-09 16:49:16 +08:00
SML	8f305047c0	Add header background, change all dark theme grays to neutral grays.	2023-02-09 16:35:20 +08:00
SML	59f9b5cc28	Ensure sanic brand color be the same in dark mode.	2023-02-09 16:23:01 +08:00
SML	94eff28fda	Add tab hover shadow definition. Intended to have better hover accents for light theme.	2023-02-09 07:03:09 +08:00
SML	c111d93840	Define highlight and tab colors as variables	2023-02-09 06:46:13 +08:00
SML	3587a4fe15	Define sanic-background, sanic-text as top-level colors. Restructure color schemes to top of definition.	2023-02-09 06:13:00 +08:00
SML	51a9605668	Soften lightmode text color	2023-02-09 06:08:00 +08:00
SML	14f16352fc	Add tracerite tab color with new sanic-tab variable.	2023-02-09 06:07:45 +08:00
SML	ecf34896c8	Add margins for h3. Probably should be done in the tracerite package.	2023-02-09 04:56:30 +08:00
SML	e544cd8af6	Tweak color scheme for dark themes	2023-02-09 04:55:57 +08:00
SML	aa8af0dcea	invalid text justify css	2023-02-09 03:36:20 +08:00
SML	db0b9046d7	Add padding for main container so text doesn’t touch screen boundary	2023-02-09 00:39:26 +08:00
SML	f798eda446	Remove forced hanging emoji from error header	2023-02-09 00:36:20 +08:00
SML	21ad1ae61b	Remove tab styling	2023-02-09 00:14:06 +08:00
SML	d8bf65ad1b	Tweak colors for dark mode	2023-02-09 00:13:39 +08:00
SML	844cab2d6b	Tweak colors for light mode	2023-02-09 00:07:29 +08:00
SML	b0cb01d1a4	Add color sections for dark mode	2023-02-08 23:59:32 +08:00
L. Karkkainen	4c55051442	Fix scrollbar layout problems.	2023-02-08 01:34:41 +00:00
L. Karkkainen	37f3607ebc	Friendlify the error page.	2023-02-08 01:26:30 +00:00
L. Karkkainen	7e617c1769	Misc styling	2023-02-07 22:03:10 +00:00
L. Karkkainen	a5f732cc80	Style and layout changes, fix document title.	2023-02-07 21:25:14 +00:00
L. Karkkainen	ce19908bc0	Implement key-value-table as dl instead of table element.	2023-02-07 20:51:25 +00:00
L. Karkkainen	a6efebda56	Cleanup.	2023-02-07 11:00:05 +00:00
L. Karkkainen	da9ff33fa7	Add traceback suppressions to commonly shown internals.	2023-02-07 10:58:46 +00:00
L. Karkkainen	526115c3c5	Fix SVG: alt to desc, whitespace removed	2023-02-06 16:07:58 +00:00
Adam Hopkins	12ba685bf6	Some Sanic branding to error page (#2673 ) * Some Sanic branding to error page * Simplify logo compat	2023-02-06 15:41:01 +00:00
L. Karkkainen	39b98e6b45	Logo shadow to make it show up on white background.	2023-02-06 13:13:01 +00:00
L. Karkkainen	3ddbda61d9	Merge branch 'html-error-handling-suggestions' into niceback-error-handling	2023-02-06 13:02:31 +00:00
L. Karkkainen	68bf26df17	Merge branch 'main' into niceback-error-handling	2023-02-06 12:57:48 +00:00
Adam Hopkins	a773ad2354	Cleanup styles and add Sanic palette	2023-02-06 14:25:22 +02:00
Adam Hopkins	47b2459811	Suggestions	2023-02-06 10:05:51 +02:00
Adam Hopkins	7491d567a3	Merge branch 'niceback-error-handling' of github.com:sanic-org/sanic into niceback-error-handling	2023-02-05 22:13:03 +02:00
L. Karkkainen	783a29bc0b	Require tracerite=>1.0.0	2023-02-05 18:49:27 +00:00
L. Karkkainen	cf76c05d3f	CSS loading with STYLE_APPEND	2023-02-05 17:26:58 +00:00
Adam Hopkins	d6f2613623	Merge branch 'main' of github.com:sanic-org/sanic into niceback-error-handling	2023-02-05 18:37:08 +02:00
L. Karkkainen	a6ff13ceed	Fallback for route name when no route found.	2023-02-05 16:06:45 +00:00
L. Karkkainen	207f8af11f	setup.py	2023-02-05 15:58:25 +00:00
L. Karkkainen	5c65118d12	CSS files now start with comments, none inserted in code.	2023-02-05 15:58:09 +00:00
L. Karkkainen	f4792a2bc6	CSS fixes, incl. scaling layout for small screens.	2023-02-05 15:46:12 +00:00
L. Karkkainen	53b7a5a5a1	Merge branch 'main' into niceback-error-handling	2023-02-05 15:16:05 +00:00
Ryu Juheon	5e7f6998bd	fix(websocket): ASGI websocket must pass thru bytes as is (#2651 )	2023-02-05 16:41:54 +02:00
L. Kärkkäinen	c7a71cd00c	Use FALLBACK_ERROR_FORMAT for handlers that return empty() (#2659 ) Co-authored-by: L. Karkkainen <tronic@users.noreply.github.com> Co-authored-by: Adam Hopkins <adam@amhopkins.com>	2023-02-05 15:29:01 +02:00
Adam Hopkins	9cb9e88678	Establish basic file browser and index fallback (#2662 ) Co-authored-by: L. Kärkkäinen <98187+Tronic@users.noreply.github.com> Co-authored-by: L. Karkkainen <tronic@users.noreply.github.com>	2023-02-05 15:09:04 +02:00
L. Karkkainen	ebc2f46682	Minor style changes, loading TraceRite style and css properly, printing exception extra data.	2023-02-04 00:27:29 +00:00
L. Kärkkäinen	ff47448585	Merge branch 'issue2661' into niceback-error-handling	2023-02-02 14:14:56 +00:00
Adam Hopkins	2df5b19fd4	Sans serif w/ autoindex monospace	2023-01-31 11:09:24 +02:00
Adam Hopkins	5dfd48f855	Merge branch 'main' of github.com:sanic-org/sanic into issue2661	2023-01-31 10:44:49 +02:00
Adam Hopkins	ddf3a49988	Remove accidental file	2023-01-31 10:43:19 +02:00
Adam Hopkins	1b43aa5f2f	No auto registration of fallback error handlers	2023-01-31 10:40:47 +02:00
Adam Hopkins	713abe3cf2	Merge branch 'issue2661' of github.com:sanic-org/sanic into issue2661	2023-01-31 10:04:46 +02:00
Adam Hopkins	b46b81d43a	Set styles	2023-01-31 10:03:39 +02:00
Rodolfo Olivieri	30c53b6857	Remove deprecated property in blueprint (#2666 ) Fixes https://github.com/sanic-org/sanic/issues/2442	2023-01-30 09:26:55 +02:00
L. Kärkkäinen	4f000ab59c	Define colors for light/default mode as well. The background is not always white by default (e.g. when in an iframe), so it needs to be defined or text may become invisible (just had this problem today). I've taken the opportunity to make it slightly less bright as well.	2023-01-28 23:36:42 +00:00
L. Kärkkäinen	ae757c8ad6	Merge branch 'issue2661' into niceback-error-handling	2023-01-28 23:29:14 +00:00
Adam Hopkins	f30f53f67d	Move DirectoryHandler to app instance	2023-01-28 23:25:25 +02:00
L. Karkkainen	ea09906e0a	Refactored to sanic.pages.error module. Traceback and style tuning. Print also headers, and for other than 500 errors as well. 500 error message text UX workaround.	2023-01-27 18:50:35 +00:00
L. Karkkainen	77bdfa14ed	HTML error formatting rebuilt on top of BasePage, and using external module niceback to do the tracebacks.	2023-01-27 06:45:49 +00:00
L. Karkkainen	faf1ff8d4f	Fix the document title (needs positional argument).	2023-01-27 05:39:45 +00:00
L. Karkkainen	b5175238fb	URL sanitation.	2023-01-27 05:31:52 +00:00
L. Karkkainen	32d62c2db4	Style tweaks	2023-01-27 05:24:02 +00:00
L. Karkkainen	a00ec8ab37	Better UX for empty folders.	2023-01-27 04:38:49 +00:00
L. Karkkainen	859a8130c1	Fix Sanic brand colour in breadcrumbs.	2023-01-27 04:38:21 +00:00
L. Karkkainen	2038799d7a	Remove parent directory link from table	2023-01-27 04:30:23 +00:00
L. Karkkainen	41da8bbd61	Improve navigation with breadcrumbs	2023-01-27 04:29:15 +00:00
L. Karkkainen	e328d4406b	Timestamps a bit less ugly.	2023-01-27 03:23:12 +00:00
L. Karkkainen	d9c883eb9b	Add a header bar with Sanic logo. Remove duplicate title element. Avoid escaping in style element and add new styles.	2023-01-27 03:05:00 +00:00
Adam Hopkins	10d4f2803a	Simple server to include autoindex	2023-01-26 18:06:13 +02:00
Adam Hopkins	fa6dbddf69	Style fixes for file table	2023-01-26 17:26:42 +02:00
Adam Hopkins	2c8f1807d8	squash	2023-01-26 17:22:13 +02:00
Adam Hopkins	ca0e933813	No logging of exception	2023-01-26 17:12:51 +02:00
Adam Hopkins	2e36507a60	Refactor to allow for common pages	2023-01-26 16:50:45 +02:00
Adam Hopkins	39a4a75dcb	Add new pages module	2023-01-26 15:52:26 +02:00
Adam Hopkins	e8bb2834d6	Valid HTML5	2023-01-26 00:45:30 +02:00
Adam Hopkins	36e3cc9df7	Use html5tagger for AutoIndex	2023-01-26 00:36:37 +02:00
Adam Hopkins	fed2ef3527	Remove location information	2023-01-24 10:48:54 +02:00
Adam Hopkins	6673acf544	Establish basic file browser and index fallback	2023-01-24 10:27:55 +02:00
Adam Hopkins	4ad8168bb0	Version 22.12 release notes (#2637 )	2022-12-27 16:50:36 +02:00
Adam Hopkins	28f5b3c301	Add better inspector arg parsing (#2642 )	2022-12-26 12:27:40 +02:00
Adam Hopkins	c573019e7f	ASGI websocket recv text or bytes (#2640 )	2022-12-25 13:52:07 +02:00
Adam Hopkins	029f564032	Pass unquote thru add_route (#2639 )	2022-12-21 10:45:23 +02:00
Adam Hopkins	2abe66b670	Add priority to register_middleware method (#2636 )	2022-12-19 19:14:46 +02:00
Adam Hopkins	911485d52e	Fix Windows sock share (#2635 )	2022-12-18 15:04:10 +02:00
Adam Hopkins	4744a89c33	Fix double ctrl-c kill (#2634 )	2022-12-18 14:40:38 +02:00
Adam Hopkins	f7040ccec8	Implement restart ordering (#2632 )	2022-12-18 14:09:17 +02:00
Adam Hopkins	518152d97e	Reload interval on class variable (#2633 )	2022-12-18 13:36:54 +02:00
Adam Hopkins	0e44e9cacb	Move to HTTP Inspector (#2626 )	2022-12-18 10:29:58 +02:00
Adam Hopkins	bfb54b0969	Test for 3.11 support (#2612 ) Co-authored-by: Zhiwei <zhi.wei.liang@outlook.com>	2022-12-17 23:46:22 +02:00
Zhiwei	154863d6c6	Method Signal Handler Test (#2630 )	2022-12-17 20:38:46 +02:00
Adam Hopkins	a3ff0c13b7	ASGI lifespan failure on exception (#2627 )	2022-12-16 08:56:07 +02:00
Mary	95ee518aec	Replace deprecated distutils.strtobool (#2628 )	2022-12-16 07:48:41 +02:00
Zhiwei	71d3d87bcc	Deprecate Conditions and Triggers Saved in `handler` Callable; Save Condition in `signal.extra` Instead (#2608 )	2022-12-15 12:32:07 +02:00
Adam Hopkins	b276b91c21	Allow fork in limited cases (#2624 )	2022-12-15 11:49:26 +02:00
Adam Hopkins	064168f3c8	Add a SIGKILL to second ctrl+c (#2621 )	2022-12-14 23:51:11 +02:00
Adam Hopkins	db39e127bf	Scale workers (#2617 )	2022-12-13 09:28:23 +02:00
L. Kärkkäinen	13e9ab7ba9	Filename normalisation of form-data/multipart file uploads (umlauts on Apple clients) (#2625 ) Co-authored-by: L. Karkkainen <tronic@users.noreply.github.com>	2022-12-13 08:36:21 +02:00