Release 23.3 (#2723)

Co-authored-by: L. Kärkkäinen <98187+Tronic@users.noreply.github.com>

.github/ISSUE_TEMPLATE/rfc.yml

@@ -0,0 +1,33 @@
+name: 💡 Request for Comments
+description: Open an RFC for discussion
+labels: ["RFC"]
+body:
+  - type: input
+    id: compare
+    attributes:
+      label: Link to code
+      description: If available, share a [comparison](https://github.com/sanic-org/sanic/compare) from a POC branch to main
+      placeholder: https://github.com/sanic-org/sanic/compare/main...some-new-branch
+    validations:
+      required: false
+  - type: textarea
+    id: proposal
+    attributes:
+      label: Proposal
+      description: A thorough discussion of the proposal discussing the problem it solves, potential code, use cases, and impacts
+    validations:
+      required: true
+  - type: textarea
+    id: additional
+    attributes:
+      label: Additional context
+      description: Add any other context that is relevant
+    validations:
+      required: false
+  - type: checkboxes
+    id: breaking
+    attributes:
+      label: Is this a breaking change?
+      options:
+        - label: "Yes"
+          required: false

CHANGELOG.rst

@@ -316,8 +316,6 @@ Version 21.3.0
 Version 20.12.3
 ---------------
 
-`Current LTS version`
-
 **Bugfixes**
 
   *

docs/sanic/changelog.rst

@@ -1,6 +1,11 @@
 📜 Changelog
 ============
 
+| 🔶 Current release
+| 🔷 In support release
+|
+
+.. mdinclude:: ./releases/23/23.3.md
 .. mdinclude:: ./releases/22/22.12.md
 .. mdinclude:: ./releases/22/22.9.md
 .. mdinclude:: ./releases/22/22.6.md

docs/sanic/releases/22/22.12.md

@@ -1,4 +1,4 @@
-## Version 22.12.0 🔶
+## Version 22.12.0 🔷
 
 _Current version_
 

docs/sanic/releases/23/23.3.md

@@ -0,0 +1,53 @@
+## Version 23.3.0 🔶
+
+### Features
+- [#2545](https://github.com/sanic-org/sanic/pull/2545) Standardize init of exceptions for more consistent control of HTTP responses using exceptions
+- [#2606](https://github.com/sanic-org/sanic/pull/2606) Decode headers as UTF-8 also in ASGI
+- [#2646](https://github.com/sanic-org/sanic/pull/2646) Separate ASGI request and lifespan callables
+- [#2659](https://github.com/sanic-org/sanic/pull/2659) Use ``FALLBACK_ERROR_FORMAT`` for handlers that return ``empty()``
+- [#2662](https://github.com/sanic-org/sanic/pull/2662) Add basic file browser (HTML page) and auto-index serving
+- [#2667](https://github.com/sanic-org/sanic/pull/2667) Nicer traceback formatting (HTML page)
+- [#2668](https://github.com/sanic-org/sanic/pull/2668) Smarter error page rendering format selection; more reliant upon header and "common sense" defaults
+- [#2680](https://github.com/sanic-org/sanic/pull/2680) Check the status of socket before shutting down with ``SHUT_RDWR``
+- [#2687](https://github.com/sanic-org/sanic/pull/2687) Refresh ``Request.accept`` functionality to be more performant and spec-compliant
+- [#2696](https://github.com/sanic-org/sanic/pull/2696) Add header accessors as properties
+    ```
+    Example-Field: Foo, Bar
+    Example-Field: Baz
+    ```
+    ```python
+    request.headers.example_field == "Foo, Bar,Baz"
+    ```
+- [#2700](https://github.com/sanic-org/sanic/pull/2700) Simpler CLI targets
+
+    ```sh
+    $ sanic path.to.module:app          # global app instance
+    $ sanic path.to.module:create_app   # factory pattern
+    $ sanic ./path/to/directory/        # simple serve
+    ```
+- [#2701](https://github.com/sanic-org/sanic/pull/2701) API to define a number of workers in managed processes
+- [#2704](https://github.com/sanic-org/sanic/pull/2704) Add convenience for dynamic changes to routing
+- [#2706](https://github.com/sanic-org/sanic/pull/2706) Add convenience methods for cookie creation and deletion
+    
+    ```python
+    response = text("...")
+    response.add_cookie("test", "It worked!", domain=".yummy-yummy-cookie.com")
+    ```
+- [#2707](https://github.com/sanic-org/sanic/pull/2707) Simplified ``parse_content_header`` escaping to be RFC-compliant and remove outdated FF hack
+- [#2710](https://github.com/sanic-org/sanic/pull/2710) Stricter charset handling and escaping of request URLs
+- [#2711](https://github.com/sanic-org/sanic/pull/2711) Consume body on ``DELETE`` by default
+- [#2719](https://github.com/sanic-org/sanic/pull/2719) Allow ``password`` to be passed to TLS context
+- [#2720](https://github.com/sanic-org/sanic/pull/2720) Skip middleware on ``RequestCancelled``
+- [#2721](https://github.com/sanic-org/sanic/pull/2721) Change access logging format to ``%s``
+- [#2722](https://github.com/sanic-org/sanic/pull/2722) Add ``CertLoader`` as application option for directly controlling ``SSLContext`` objects
+- [#2725](https://github.com/sanic-org/sanic/pull/2725) Worker sync state tolerance on race condition
+
+### Bugfixes
+- [#2651](https://github.com/sanic-org/sanic/pull/2651) ASGI websocket to pass thru bytes as is
+- [#2697](https://github.com/sanic-org/sanic/pull/2697) Fix comparison between datetime aware and naive in ``file`` when using ``If-Modified-Since``
+
+### Deprecations and Removals
+- [#2666](https://github.com/sanic-org/sanic/pull/2666) Remove deprecated ``__blueprintname__`` property
+
+### Improved Documentation
+- [#2712](https://github.com/sanic-org/sanic/pull/2712) Improved example using ``'https'`` to create the redirect

examples/http_redirect.py

@@ -29,7 +29,7 @@ def proxy(request, path):
         path=path,
         _server=https.config.SERVER_NAME,
         _external=True,
-        _scheme="http",
+        _scheme="https",
     )
     return response.redirect(url)
 

pyproject.toml

@@ -24,5 +24,6 @@ module = [
     "sanic_routing.*",
     "aioquic.*",
     "html5tagger.*",
+    "tracerite.*",
 ]
 ignore_missing_imports = true

sanic/__init__.py

@@ -2,6 +2,22 @@ from sanic.__version__ import __version__
 from sanic.app import Sanic
 from sanic.blueprints import Blueprint
 from sanic.constants import HTTPMethod
+from sanic.exceptions import (
+    BadRequest,
+    ExpectationFailed,
+    FileNotFound,
+    Forbidden,
+    HeaderNotFound,
+    InternalServerError,
+    InvalidHeader,
+    MethodNotAllowed,
+    NotFound,
+    RangeNotSatisfiable,
+    SanicException,
+    ServerError,
+    ServiceUnavailable,
+    Unauthorized,
+)
 from sanic.request import Request
 from sanic.response import (
     HTTPResponse,
@@ -9,6 +25,7 @@ from sanic.response import (
     file,
     html,
     json,
+    raw,
     redirect,
     text,
 )
@@ -17,16 +34,34 @@ from sanic.server.websockets.impl import WebsocketImplProtocol as Websocket
 
 __all__ = (
     "__version__",
+    # Common objects
     "Sanic",
     "Blueprint",
     "HTTPMethod",
     "HTTPResponse",
     "Request",
     "Websocket",
+    # Common exceptions
+    "BadRequest",
+    "ExpectationFailed",
+    "FileNotFound",
+    "Forbidden",
+    "HeaderNotFound",
+    "InternalServerError",
+    "InvalidHeader",
+    "MethodNotAllowed",
+    "NotFound",
+    "RangeNotSatisfiable",
+    "SanicException",
+    "ServerError",
+    "ServiceUnavailable",
+    "Unauthorized",
+    # Common response methods
     "empty",
     "file",
     "html",
     "json",
+    "raw",
     "redirect",
     "text",
 )

sanic/__version__.py

@@ -1 +1 @@
-__version__ = "22.12.0"
+__version__ = "23.3.0"

sanic/app.py

@@ -16,7 +16,7 @@ from asyncio import (
 )
 from asyncio.futures import Future
 from collections import defaultdict, deque
-from contextlib import suppress
+from contextlib import contextmanager, suppress
 from functools import partial
 from inspect import isawaitable
 from os import environ
@@ -33,6 +33,7 @@ from typing import (
     Deque,
     Dict,
     Iterable,
+    Iterator,
     List,
     Optional,
     Set,
@@ -48,7 +49,7 @@ from sanic_routing.route import Route
 
 from sanic.application.ext import setup_ext
 from sanic.application.state import ApplicationState, ServerStage
-from sanic.asgi import ASGIApp
+from sanic.asgi import ASGIApp, Lifespan
 from sanic.base.root import BaseSanic
 from sanic.blueprint_group import BlueprintGroup
 from sanic.blueprints import Blueprint
@@ -63,12 +64,7 @@ from sanic.exceptions import (
 from sanic.handlers import ErrorHandler
 from sanic.helpers import Default, _default
 from sanic.http import Stage
-from sanic.log import (
+from sanic.log import LOGGING_CONFIG_DEFAULTS, error_logger, logger
-    LOGGING_CONFIG_DEFAULTS,
-    deprecation,
-    error_logger,
-    logger,
-)
 from sanic.middleware import Middleware, MiddlewareLocation
 from sanic.mixins.listeners import ListenerEvent
 from sanic.mixins.startup import StartupMixin
@@ -91,6 +87,7 @@ from sanic.signals import Signal, SignalRouter
 from sanic.touchup import TouchUp, TouchUpMeta
 from sanic.types.shared_ctx import SharedContext
 from sanic.worker.inspector import Inspector
+from sanic.worker.loader import CertLoader
 from sanic.worker.manager import WorkerManager
 
 
@@ -119,6 +116,7 @@ class Sanic(StaticHandleMixin, BaseSanic, StartupMixin, metaclass=TouchUpMeta):
     )
     __slots__ = (
         "_asgi_app",
+        "_asgi_lifespan",
         "_asgi_client",
         "_blueprint_order",
         "_delayed_tasks",
@@ -137,6 +135,7 @@ class Sanic(StaticHandleMixin, BaseSanic, StartupMixin, metaclass=TouchUpMeta):
         "_test_client",
         "_test_manager",
         "blueprints",
+        "certloader_class",
         "config",
         "configure_logging",
         "ctx",
@@ -179,6 +178,7 @@ class Sanic(StaticHandleMixin, BaseSanic, StartupMixin, metaclass=TouchUpMeta):
         loads: Optional[Callable[..., Any]] = None,
         inspector: bool = False,
         inspector_class: Optional[Type[Inspector]] = None,
+        certloader_class: Optional[Type[CertLoader]] = None,
     ) -> None:
         super().__init__(name=name)
         # logging
@@ -198,6 +198,8 @@ class Sanic(StaticHandleMixin, BaseSanic, StartupMixin, metaclass=TouchUpMeta):
             self.config.INSPECTOR = inspector
 
         # Then we can do the rest
+        self._asgi_app: Optional[ASGIApp] = None
+        self._asgi_lifespan: Optional[Lifespan] = None
         self._asgi_client: Any = None
         self._blueprint_order: List[Blueprint] = []
         self._delayed_tasks: List[str] = []
@@ -211,6 +213,9 @@ class Sanic(StaticHandleMixin, BaseSanic, StartupMixin, metaclass=TouchUpMeta):
         self.asgi = False
         self.auto_reload = False
         self.blueprints: Dict[str, Blueprint] = {}
+        self.certloader_class: Type[CertLoader] = (
+            certloader_class or CertLoader
+        )
         self.configure_logging: bool = configure_logging
         self.ctx: Any = ctx or SimpleNamespace()
         self.error_handler: ErrorHandler = error_handler or ErrorHandler()
@@ -430,14 +435,15 @@ class Sanic(StaticHandleMixin, BaseSanic, StartupMixin, metaclass=TouchUpMeta):
 
         ctx = params.pop("route_context")
 
-        routes = self.router.add(**params)
+        with self.amend():
-        if isinstance(routes, Route):
+            routes = self.router.add(**params)
-            routes = [routes]
+            if isinstance(routes, Route):
+                routes = [routes]
 
-        for r in routes:
+            for r in routes:
-            r.extra.websocket = websocket
+                r.extra.websocket = websocket
-            r.extra.static = params.get("static", False)
+                r.extra.static = params.get("static", False)
-            r.ctx.__dict__.update(ctx)
+                r.ctx.__dict__.update(ctx)
 
         return routes
 
@@ -446,17 +452,19 @@ class Sanic(StaticHandleMixin, BaseSanic, StartupMixin, metaclass=TouchUpMeta):
         middleware: FutureMiddleware,
         route_names: Optional[List[str]] = None,
     ):
-        if route_names:
+        with self.amend():
-            return self.register_named_middleware(
+            if route_names:
-                middleware.middleware, route_names, middleware.attach_to
+                return self.register_named_middleware(
-            )
+                    middleware.middleware, route_names, middleware.attach_to
-        else:
+                )
-            return self.register_middleware(
+            else:
-                middleware.middleware, middleware.attach_to
+                return self.register_middleware(
-            )
+                    middleware.middleware, middleware.attach_to
+                )
 
     def _apply_signal(self, signal: FutureSignal) -> Signal:
-        return self.signal_router.add(*signal)
+        with self.amend():
+            return self.signal_router.add(*signal)
 
     def dispatch(
         self,
@@ -875,6 +883,8 @@ class Sanic(StaticHandleMixin, BaseSanic, StartupMixin, metaclass=TouchUpMeta):
         :param request: HTTP Request object
         :return: Nothing
         """
+        __tracebackhide__ = True
+
         await self.dispatch(
             "http.lifecycle.handle",
             inline=True,
@@ -1347,12 +1357,14 @@ class Sanic(StaticHandleMixin, BaseSanic, StartupMixin, metaclass=TouchUpMeta):
         three arguments: scope, receive, send. See the ASGI reference for more
         details: https://asgi.readthedocs.io/en/latest
         """
-        self.asgi = True
         if scope["type"] == "lifespan":
+            self.asgi = True
             self.motd("")
-        self._asgi_app = await ASGIApp.create(self, scope, receive, send)
+            self._asgi_lifespan = Lifespan(self, scope, receive, send)
-        asgi_app = self._asgi_app
+            await self._asgi_lifespan()
-        await asgi_app()
+        else:
+            self._asgi_app = await ASGIApp.create(self, scope, receive, send)
+            await self._asgi_app()
 
     _asgi_single_callable = True  # We conform to ASGI 3.0 single-callable
 
@@ -1513,6 +1525,27 @@ class Sanic(StaticHandleMixin, BaseSanic, StartupMixin, metaclass=TouchUpMeta):
     # Lifecycle
     # -------------------------------------------------------------------- #
 
+    @contextmanager
+    def amend(self) -> Iterator[None]:
+        """
+        If the application has started, this function allows changes
+        to be made to add routes, middleware, and signals.
+        """
+        if not self.state.is_started:
+            yield
+        else:
+            do_router = self.router.finalized
+            do_signal_router = self.signal_router.finalized
+            if do_router:
+                self.router.reset()
+            if do_signal_router:
+                self.signal_router.reset()
+            yield
+            if do_signal_router:
+                self.signalize(self.config.TOUCHUP)
+            if do_router:
+                self.finalize()
+
     def finalize(self):
         try:
             self.router.finalize()
@@ -1546,17 +1579,20 @@ class Sanic(StaticHandleMixin, BaseSanic, StartupMixin, metaclass=TouchUpMeta):
         self.signalize(self.config.TOUCHUP)
         self.finalize()
 
-        route_names = [route.name for route in self.router.routes]
+        route_names = [route.extra.ident for route in self.router.routes]
         duplicates = {
             name for name in route_names if route_names.count(name) > 1
         }
         if duplicates:
             names = ", ".join(duplicates)
-            deprecation(
+            message = (
-                f"Duplicate route names detected: {names}. In the future, "
+                f"Duplicate route names detected: {names}. You should rename "
-                "Sanic will enforce uniqueness in route naming.",
+                "one or more of them explicitly by using the `name` param, "
-                23.3,
+                "or changing the implicit name derived from the class and "
+                "function name. For more details, please see "
+                "https://sanic.dev/en/guide/release-notes/v23.3.html#duplicated-route-names-are-no-longer-allowed"  # noqa
             )
+            raise ServerError(message)
 
         Sanic._check_uvloop_conflict()
 

sanic/application/logo.py

@@ -40,7 +40,7 @@ FULL_COLOR_LOGO = """
 
 """  # noqa
 
-SVG_LOGO = """<svg id=logo alt=Sanic viewBox="0 0 964 279"><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="#e1e1e1"/></svg>"""  # 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-?]*[ -/]*[@-~])")
 

sanic/asgi.py

@@ -3,10 +3,9 @@ from __future__ import annotations
 import warnings
 
 from typing import TYPE_CHECKING, Optional
-from urllib.parse import quote
 
 from sanic.compat import Header
-from sanic.exceptions import ServerError
+from sanic.exceptions import BadRequest, ServerError
 from sanic.helpers import Default
 from sanic.http import Stage
 from sanic.log import error_logger, logger
@@ -22,13 +21,15 @@ if TYPE_CHECKING:
 
 
 class Lifespan:
-    def __init__(self, asgi_app: ASGIApp) -> None:
+    def __init__(
-        self.asgi_app = asgi_app
+        self, sanic_app, scope: ASGIScope, receive: ASGIReceive, send: ASGISend
+    ) -> None:
+        self.sanic_app = sanic_app
+        self.scope = scope
+        self.receive = receive
+        self.send = send
 
-        if (
+        if "server.init.before" in self.sanic_app.signal_router.name_index:
-            "server.init.before"
-            in self.asgi_app.sanic_app.signal_router.name_index
-        ):
             logger.debug(
                 'You have set a listener for "before_server_start" '
                 "in ASGI mode. "
@@ -36,10 +37,7 @@ class Lifespan:
                 "the ASGI server is started.",
                 extra={"verbosity": 1},
             )
-        if (
+        if "server.shutdown.after" in self.sanic_app.signal_router.name_index:
-            "server.shutdown.after"
-            in self.asgi_app.sanic_app.signal_router.name_index
-        ):
             logger.debug(
                 'You have set a listener for "after_server_stop" '
                 "in ASGI mode. "
@@ -57,11 +55,11 @@ class Lifespan:
         in sequence since the ASGI lifespan protocol only supports a single
         startup event.
         """
-        await self.asgi_app.sanic_app._startup()
+        await self.sanic_app._startup()
-        await self.asgi_app.sanic_app._server_event("init", "before")
+        await self.sanic_app._server_event("init", "before")
-        await self.asgi_app.sanic_app._server_event("init", "after")
+        await self.sanic_app._server_event("init", "after")
 
-        if not isinstance(self.asgi_app.sanic_app.config.USE_UVLOOP, Default):
+        if not isinstance(self.sanic_app.config.USE_UVLOOP, Default):
             warnings.warn(
                 "You have set the USE_UVLOOP configuration option, but Sanic "
                 "cannot control the event loop when running in ASGI mode."
@@ -77,35 +75,33 @@ class Lifespan:
         in sequence since the ASGI lifespan protocol only supports a single
         shutdown event.
         """
-        await self.asgi_app.sanic_app._server_event("shutdown", "before")
+        await self.sanic_app._server_event("shutdown", "before")
-        await self.asgi_app.sanic_app._server_event("shutdown", "after")
+        await self.sanic_app._server_event("shutdown", "after")
 
-    async def __call__(
+    async def __call__(self) -> None:
-        self, scope: ASGIScope, receive: ASGIReceive, send: ASGISend
+        while True:
-    ) -> None:
+            message = await self.receive()
-        message = await receive()
+            if message["type"] == "lifespan.startup":
-        if message["type"] == "lifespan.startup":
+                try:
-            try:
+                    await self.startup()
-                await self.startup()
+                except Exception as e:
-            except Exception as e:
+                    error_logger.exception(e)
-                error_logger.exception(e)
+                    await self.send(
-                await send(
+                        {"type": "lifespan.startup.failed", "message": str(e)}
-                    {"type": "lifespan.startup.failed", "message": str(e)}
+                    )
-                )
+                else:
-            else:
+                    await self.send({"type": "lifespan.startup.complete"})
-                await send({"type": "lifespan.startup.complete"})
+            elif message["type"] == "lifespan.shutdown":
-
+                try:
-        message = await receive()
+                    await self.shutdown()
-        if message["type"] == "lifespan.shutdown":
+                except Exception as e:
-            try:
+                    error_logger.exception(e)
-                await self.shutdown()
+                    await self.send(
-            except Exception as e:
+                        {"type": "lifespan.shutdown.failed", "message": str(e)}
-                error_logger.exception(e)
+                    )
-                await send(
+                else:
-                    {"type": "lifespan.shutdown.failed", "message": str(e)}
+                    await self.send({"type": "lifespan.shutdown.complete"})
-                )
+                return
-            else:
-                await send({"type": "lifespan.shutdown.complete"})
 
 
 class ASGIApp:
@@ -117,73 +113,78 @@ class ASGIApp:
     stage: Stage
     response: Optional[BaseHTTPResponse]
 
-    def __init__(self) -> None:
-        self.ws = None
-
     @classmethod
     async def create(
-        cls, sanic_app, scope: ASGIScope, receive: ASGIReceive, send: ASGISend
+        cls,
-    ) -> "ASGIApp":
+        sanic_app: Sanic,
+        scope: ASGIScope,
+        receive: ASGIReceive,
+        send: ASGISend,
+    ) -> ASGIApp:
         instance = cls()
+        instance.ws = None
         instance.sanic_app = sanic_app
         instance.transport = MockTransport(scope, receive, send)
         instance.transport.loop = sanic_app.loop
         instance.stage = Stage.IDLE
         instance.response = None
+        instance.sanic_app.state.is_started = True
         setattr(instance.transport, "add_task", sanic_app.loop.create_task)
 
-        headers = Header(
+        try:
-            [
+            headers = Header(
-                (key.decode("latin-1"), value.decode("latin-1"))
+                [
-                for key, value in scope.get("headers", [])
+                    (
-            ]
+                        key.decode("ASCII"),
-        )
+                        value.decode(errors="surrogateescape"),
-        instance.lifespan = Lifespan(instance)
+                    )
+                    for key, value in scope.get("headers", [])
+                ]
+            )
+        except UnicodeDecodeError:
+            raise BadRequest(
+                "Header names can only contain US-ASCII characters"
+            )
 
-        if scope["type"] == "lifespan":
+        if scope["type"] == "http":
-            await instance.lifespan(scope, receive, send)
+            version = scope["http_version"]
+            method = scope["method"]
+        elif scope["type"] == "websocket":
+            version = "1.1"
+            method = "GET"
+
+            instance.ws = instance.transport.create_websocket_connection(
+                send, receive
+            )
         else:
-            path = (
+            raise ServerError("Received unknown ASGI scope")
-                scope["path"][1:]
-                if scope["path"].startswith("/")
-                else scope["path"]
-            )
-            url = "/".join([scope.get("root_path", ""), quote(path)])
-            url_bytes = url.encode("latin-1")
-            url_bytes += b"?" + scope["query_string"]
 
-            if scope["type"] == "http":
+        url_bytes, query = scope["raw_path"], scope["query_string"]
-                version = scope["http_version"]
+        if query:
-                method = scope["method"]
+            # httpx ASGI client sends query string as part of raw_path
-            elif scope["type"] == "websocket":
+            url_bytes = url_bytes.split(b"?", 1)[0]
-                version = "1.1"
+            # All servers send them separately
-                method = "GET"
+            url_bytes = b"%b?%b" % (url_bytes, query)
 
-                instance.ws = instance.transport.create_websocket_connection(
+        request_class = sanic_app.request_class or Request
-                    send, receive
+        instance.request = request_class(
-                )
+            url_bytes,
-            else:
+            headers,
-                raise ServerError("Received unknown ASGI scope")
+            version,
+            method,
+            instance.transport,
+            sanic_app,
+        )
+        instance.request.stream = instance  # type: ignore
+        instance.request_body = True
+        instance.request.conn_info = ConnInfo(instance.transport)
 
-            request_class = sanic_app.request_class or Request
+        await instance.sanic_app.dispatch(
-            instance.request = request_class(
+            "http.lifecycle.request",
-                url_bytes,
+            inline=True,
-                headers,
+            context={"request": instance.request},
-                version,
+            fail_not_found=False,
-                method,
+        )
-                instance.transport,
-                sanic_app,
-            )
-            instance.request.stream = instance
-            instance.request_body = True
-            instance.request.conn_info = ConnInfo(instance.transport)
-
-            await sanic_app.dispatch(
-                "http.lifecycle.request",
-                inline=True,
-                context={"request": instance.request},
-                fail_not_found=False,
-            )
 
         return instance
 

sanic/blueprints.py

@@ -93,6 +93,7 @@ class Blueprint(BaseSanic):
         "_future_listeners",
         "_future_exceptions",
         "_future_signals",
+        "copied_from",
         "ctx",
         "exceptions",
         "host",
@@ -118,6 +119,7 @@ class Blueprint(BaseSanic):
     ):
         super().__init__(name=name)
         self.reset()
+        self.copied_from = ""
         self.ctx = SimpleNamespace()
         self.host = host
         self.strict_slashes = strict_slashes
@@ -213,6 +215,7 @@ class Blueprint(BaseSanic):
         self.reset()
         new_bp = deepcopy(self)
         new_bp.name = name
+        new_bp.copied_from = self.name
 
         if not isinstance(url_prefix, Default):
             new_bp.url_prefix = url_prefix
@@ -352,6 +355,16 @@ class Blueprint(BaseSanic):
 
             registered.add(apply_route)
             route = app._apply_route(apply_route)
+
+            # If it is a copied BP, then make sure all of the names of routes
+            # matchup with the new BP name
+            if self.copied_from:
+                for r in route:
+                    r.name = r.name.replace(self.copied_from, self.name)
+                    r.extra.ident = r.extra.ident.replace(
+                        self.copied_from, self.name
+                    )
+
             operation = (
                 routes.extend if isinstance(route, list) else routes.append
             )

sanic/cli/app.py

@@ -1,4 +1,3 @@
-import logging
 import os
 import shutil
 import sys
@@ -6,7 +5,7 @@ import sys
 from argparse import Namespace
 from functools import partial
 from textwrap import indent
-from typing import List, Union, cast
+from typing import List, Union
 
 from sanic.app import Sanic
 from sanic.application.logo import get_logo
@@ -14,7 +13,7 @@ from sanic.cli.arguments import Group
 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.log import error_logger
 from sanic.worker.loader import AppLoader
 
 
@@ -24,17 +23,22 @@ class SanicCLI:
 {get_logo(True)}
 
 To start running a Sanic application, provide a path to the module, where
-app is a Sanic() instance:
+app is a Sanic() instance in the global scope:
 
     $ sanic path.to.server:app
 
+If the Sanic instance variable is called 'app', you can leave off the last
+part, and only provide a path to the module where the instance is:
+
+    $ sanic path.to.server
+
 Or, a path to a callable that returns a Sanic() instance:
 
-    $ sanic path.to.factory:create_app --factory
+    $ sanic path.to.factory:create_app
 
 Or, a path to a directory to run as a simple HTTP server:
 
-    $ sanic ./path/to/static --simple
+    $ sanic ./path/to/static
 """,
         prefix=" ",
     )
@@ -95,13 +99,9 @@ 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.target, 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()
@@ -112,38 +112,10 @@ Or, a path to a directory to run as a simple HTTP server:
                 app.prepare(**kwargs, version=http_version)
             if self.args.single:
                 serve = Sanic.serve_single
-            elif self.args.legacy:
-                serve = Sanic.serve_legacy
             else:
                 serve = partial(Sanic.serve, app_loader=app_loader)
             serve(app)
 
-    def _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)
@@ -197,8 +169,6 @@ Or, a path to a directory to run as a simple HTTP server:
             )
             error_logger.error(message)
             sys.exit(1)
-        if self.args.inspect or self.args.inspect_raw:
-            logging.disable(logging.CRITICAL)
 
     def _get_app(self, app_loader: AppLoader):
         try:
@@ -246,7 +216,6 @@ Or, a path to a directory to run as a simple HTTP server:
             "workers": self.args.workers,
             "auto_tls": self.args.auto_tls,
             "single_process": self.args.single,
-            "legacy": self.args.legacy,
         }
 
         for maybe_arg in ("auto_reload", "dev"):

sanic/cli/arguments.py

@@ -57,11 +57,15 @@ class GeneralGroup(Group):
         )
 
         self.container.add_argument(
-            "module",
+            "target",
             help=(
-                "Path to your Sanic app. Example: path.to.server:app\n"
+                "Path to your Sanic app instance.\n"
-                "If running a Simple Server, path to directory to serve. "
+                "\tExample: path.to.server:app\n"
-                "Example: ./\n"
+                "If running a Simple Server, path to directory to serve.\n"
+                "\tExample: ./\n"
+                "Additionally, this can be a path to a factory function\n"
+                "that returns a Sanic app instance.\n"
+                "\tExample: path.to.server:create_app\n"
             ),
         )
 
@@ -89,32 +93,6 @@ class ApplicationGroup(Group):
                 "a directory\n(module arg should be a path)"
             ),
         )
-        group.add_argument(
-            "--inspect",
-            dest="inspect",
-            action="store_true",
-            help=("Inspect the state of a running instance, human readable"),
-        )
-        group.add_argument(
-            "--inspect-raw",
-            dest="inspect_raw",
-            action="store_true",
-            help=("Inspect the state of a running instance, JSON output"),
-        )
-        group.add_argument(
-            "--trigger-reload",
-            dest="trigger",
-            action="store_const",
-            const="reload",
-            help=("Trigger worker processes to reload"),
-        )
-        group.add_argument(
-            "--trigger-shutdown",
-            dest="trigger",
-            action="store_const",
-            const="shutdown",
-            help=("Trigger all processes to shutdown"),
-        )
 
 
 class HTTPVersionGroup(Group):
@@ -243,11 +221,6 @@ class WorkerGroup(Group):
             action="store_true",
             help="Do not use multiprocessing, run server in a single process",
         )
-        self.container.add_argument(
-            "--legacy",
-            action="store_true",
-            help="Use the legacy server manager",
-        )
         self.add_bool_arguments(
             "--access-logs",
             dest="access_log",

sanic/compat.py

@@ -88,6 +88,12 @@ class Header(CIMultiDict):
     very similar to a regular dictionary.
     """
 
+    def __getattr__(self, key: str) -> str:
+        if key.startswith("_"):
+            return self.__getattribute__(key)
+        key = key.rstrip("_").replace("_", "-")
+        return ",".join(self.getall(key, default=[]))
+
     def get_all(self, key: str):
         """
         Convenience method mapped to ``getall()``.

sanic/cookies.py

@@ -1,156 +0,0 @@
-import re
-import string
-
-from datetime import datetime
-from typing import Dict
-
-
-DEFAULT_MAX_AGE = 0
-
-# ------------------------------------------------------------ #
-#  SimpleCookie
-# ------------------------------------------------------------ #
-
-# Straight up copied this section of dark magic from SimpleCookie
-
-_LegalChars = string.ascii_letters + string.digits + "!#$%&'*+-.^_`|~:"
-_UnescapedChars = _LegalChars + " ()/<=>?@[]{}"
-
-_Translator = {
-    n: "\\%03o" % n for n in set(range(256)) - set(map(ord, _UnescapedChars))
-}
-_Translator.update({ord('"'): '\\"', ord("\\"): "\\\\"})
-
-
-def _quote(str):
-    r"""Quote a string for use in a cookie header.
-    If the string does not need to be double-quoted, then just return the
-    string.  Otherwise, surround the string in doublequotes and quote
-    (with a \) special characters.
-    """
-    if str is None or _is_legal_key(str):
-        return str
-    else:
-        return '"' + str.translate(_Translator) + '"'
-
-
-_is_legal_key = re.compile("[%s]+" % re.escape(_LegalChars)).fullmatch
-
-# ------------------------------------------------------------ #
-#  Custom SimpleCookie
-# ------------------------------------------------------------ #
-
-
-class CookieJar(dict):
-    """
-    CookieJar dynamically writes headers as cookies are added and removed
-    It gets around the limitation of one header per name by using the
-    MultiHeader class to provide a unique key that encodes to Set-Cookie.
-    """
-
-    def __init__(self, headers):
-        super().__init__()
-        self.headers: Dict[str, str] = headers
-        self.cookie_headers: Dict[str, str] = {}
-        self.header_key: str = "Set-Cookie"
-
-    def __setitem__(self, key, value):
-        # If this cookie doesn't exist, add it to the header keys
-        if not self.cookie_headers.get(key):
-            cookie = Cookie(key, value)
-            cookie["path"] = "/"
-            self.cookie_headers[key] = self.header_key
-            self.headers.add(self.header_key, cookie)
-            return super().__setitem__(key, cookie)
-        else:
-            self[key].value = value
-
-    def __delitem__(self, key):
-        if key not in self.cookie_headers:
-            self[key] = ""
-            self[key]["max-age"] = 0
-        else:
-            cookie_header = self.cookie_headers[key]
-            # remove it from header
-            cookies = self.headers.popall(cookie_header)
-            for cookie in cookies:
-                if cookie.key != key:
-                    self.headers.add(cookie_header, cookie)
-            del self.cookie_headers[key]
-            return super().__delitem__(key)
-
-
-class Cookie(dict):
-    """A stripped down version of Morsel from SimpleCookie #gottagofast"""
-
-    _keys = {
-        "expires": "expires",
-        "path": "Path",
-        "comment": "Comment",
-        "domain": "Domain",
-        "max-age": "Max-Age",
-        "secure": "Secure",
-        "httponly": "HttpOnly",
-        "version": "Version",
-        "samesite": "SameSite",
-    }
-    _flags = {"secure", "httponly"}
-
-    def __init__(self, key, value):
-        if key in self._keys:
-            raise KeyError("Cookie name is a reserved word")
-        if not _is_legal_key(key):
-            raise KeyError("Cookie key contains illegal characters")
-        self.key = key
-        self.value = value
-        super().__init__()
-
-    def __setitem__(self, key, value):
-        if key not in self._keys:
-            raise KeyError("Unknown cookie property")
-        if value is not False:
-            if key.lower() == "max-age":
-                if not str(value).isdigit():
-                    raise ValueError("Cookie max-age must be an integer")
-            elif key.lower() == "expires":
-                if not isinstance(value, datetime):
-                    raise TypeError(
-                        "Cookie 'expires' property must be a datetime"
-                    )
-            return super().__setitem__(key, value)
-
-    def encode(self, encoding):
-        """
-        Encode the cookie content in a specific type of encoding instructed
-        by the developer. Leverages the :func:`str.encode` method provided
-        by python.
-
-        This method can be used to encode and embed ``utf-8`` content into
-        the cookies.
-
-        :param encoding: Encoding to be used with the cookie
-        :return: Cookie encoded in a codec of choosing.
-        :except: UnicodeEncodeError
-        """
-        return str(self).encode(encoding)
-
-    def __str__(self):
-        """Format as a Set-Cookie header value."""
-        output = ["%s=%s" % (self.key, _quote(self.value))]
-        for key, value in self.items():
-            if key == "max-age":
-                try:
-                    output.append("%s=%d" % (self._keys[key], value))
-                except TypeError:
-                    output.append("%s=%s" % (self._keys[key], value))
-            elif key == "expires":
-                output.append(
-                    "%s=%s"
-                    % (self._keys[key], value.strftime("%a, %d-%b-%Y %T GMT"))
-                )
-            elif key in self._flags and self[key]:
-                output.append(self._keys[key])
-            else:
-                output.append("%s=%s" % (self._keys[key], value))
-
-        return "; ".join(output)

sanic/cookies/__init__.py

@@ -0,0 +1,4 @@
+from .response import Cookie, CookieJar
+
+
+__all__ = ("Cookie", "CookieJar")

sanic/cookies/request.py

@@ -0,0 +1,119 @@
+import re
+
+from typing import Any, Dict, List, Optional
+
+from sanic.cookies.response import Cookie
+from sanic.log import deprecation
+from sanic.request.parameters import RequestParameters
+
+
+COOKIE_NAME_RESERVED_CHARS = re.compile(
+    '[\x00-\x1F\x7F-\xFF()<>@,;:\\\\"/[\\]?={} \x09]'
+)
+OCTAL_PATTERN = re.compile(r"\\[0-3][0-7][0-7]")
+QUOTE_PATTERN = re.compile(r"[\\].")
+
+
+def _unquote(str):  # no cov
+    if str is None or len(str) < 2:
+        return str
+    if str[0] != '"' or str[-1] != '"':
+        return str
+
+    str = str[1:-1]
+
+    i = 0
+    n = len(str)
+    res = []
+    while 0 <= i < n:
+        o_match = OCTAL_PATTERN.search(str, i)
+        q_match = QUOTE_PATTERN.search(str, i)
+        if not o_match and not q_match:
+            res.append(str[i:])
+            break
+        # else:
+        j = k = -1
+        if o_match:
+            j = o_match.start(0)
+        if q_match:
+            k = q_match.start(0)
+        if q_match and (not o_match or k < j):
+            res.append(str[i:k])
+            res.append(str[k + 1])
+            i = k + 2
+        else:
+            res.append(str[i:j])
+            res.append(chr(int(str[j + 1 : j + 4], 8)))  # noqa: E203
+            i = j + 4
+    return "".join(res)
+
+
+def parse_cookie(raw: str):
+    cookies: Dict[str, List] = {}
+
+    for token in raw.split(";"):
+        name, __, value = token.partition("=")
+        name = name.strip()
+        value = value.strip()
+
+        if not name:
+            continue
+
+        if COOKIE_NAME_RESERVED_CHARS.search(name):  # no cov
+            continue
+
+        if len(value) > 2 and value[0] == '"' and value[-1] == '"':  # no cov
+            value = _unquote(value)
+
+        if name in cookies:
+            cookies[name].append(value)
+        else:
+            cookies[name] = [value]
+
+    return cookies
+
+
+class CookieRequestParameters(RequestParameters):
+    def __getitem__(self, key: str) -> Optional[str]:
+        deprecation(
+            f"You are accessing cookie key '{key}', which is currently in "
+            "compat mode returning a single cookie value. Starting in v24.3 "
+            "accessing a cookie value like this will return a list of values. "
+            "To avoid this behavior and continue accessing a single value, "
+            f"please upgrade from request.cookies['{key}'] to "
+            f"request.cookies.get('{key}'). See more details: "
+            "https://sanic.dev/en/guide/release-notes/v23.3.html#request-cookies",  # noqa
+            24.3,
+        )
+        try:
+            value = self._get_prefixed_cookie(key)
+        except KeyError:
+            value = super().__getitem__(key)
+        return value[0]
+
+    def __getattr__(self, key: str) -> str:
+        if key.startswith("_"):
+            return self.__getattribute__(key)
+        key = key.rstrip("_").replace("_", "-")
+        return str(self.get(key, ""))
+
+    def get(self, name: str, default: Optional[Any] = None) -> Optional[Any]:
+        try:
+            return self._get_prefixed_cookie(name)[0]
+        except KeyError:
+            return super().get(name, default)
+
+    def getlist(
+        self, name: str, default: Optional[Any] = None
+    ) -> Optional[Any]:
+        try:
+            return self._get_prefixed_cookie(name)
+        except KeyError:
+            return super().getlist(name, default)
+
+    def _get_prefixed_cookie(self, name: str) -> Any:
+        getitem = super().__getitem__
+        try:
+            return getitem(f"{Cookie.HOST_PREFIX}{name}")
+        except KeyError:
+            return getitem(f"{Cookie.SECURE_PREFIX}{name}")

sanic/cookies/response.py

@@ -0,0 +1,617 @@
+from __future__ import annotations
+
+import re
+import string
+import sys
+
+from datetime import datetime
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
+
+from sanic.exceptions import ServerError
+from sanic.log import deprecation
+
+
+if TYPE_CHECKING:
+    from sanic.compat import Header
+
+if sys.version_info < (3, 8):  # no cov
+    SameSite = str
+else:  # no cov
+    from typing import Literal
+
+    SameSite = Union[
+        Literal["Strict"],
+        Literal["Lax"],
+        Literal["None"],
+        Literal["strict"],
+        Literal["lax"],
+        Literal["none"],
+    ]
+
+DEFAULT_MAX_AGE = 0
+SAMESITE_VALUES = ("strict", "lax", "none")
+
+LEGAL_CHARS = string.ascii_letters + string.digits + "!#$%&'*+-.^_`|~:"
+UNESCAPED_CHARS = LEGAL_CHARS + " ()/<=>?@[]{}"
+TRANSLATOR = {ch: f"\\{ch:03o}" for ch in bytes(range(32)) + b'";\\\x7F'}
+
+
+def _quote(str):  # no cov
+    r"""Quote a string for use in a cookie header.
+    If the string does not need to be double-quoted, then just return the
+    string.  Otherwise, surround the string in doublequotes and quote
+    (with a \) special characters.
+    """
+    if str is None or _is_legal_key(str):
+        return str
+    else:
+        return f'"{str.translate(TRANSLATOR)}"'
+
+
+_is_legal_key = re.compile("[%s]+" % re.escape(LEGAL_CHARS)).fullmatch
+
+
+# In v24.3, we should remove this as being a subclass of dict
+class CookieJar(dict):
+    """
+    CookieJar dynamically writes headers as cookies are added and removed
+    It gets around the limitation of one header per name by using the
+    MultiHeader class to provide a unique key that encodes to Set-Cookie.
+    """
+
+    HEADER_KEY = "Set-Cookie"
+
+    def __init__(self, headers: Header):
+        super().__init__()
+        self.headers = headers
+
+    def __setitem__(self, key, value):
+        # If this cookie doesn't exist, add it to the header keys
+        deprecation(
+            "Setting cookie values using the dict pattern has been "
+            "deprecated. You should instead use the cookies.add_cookie "
+            "method. To learn more, please see: "
+            "https://sanic.dev/en/guide/release-notes/v23.3.html#response-cookies",  # noqa
+            0,
+        )
+        if key not in self:
+            self.add_cookie(key, value, secure=False, samesite=None)
+        else:
+            self[key].value = value
+
+    def __delitem__(self, key):
+        deprecation(
+            "Deleting cookie values using the dict pattern has been "
+            "deprecated. You should instead use the cookies.delete_cookie "
+            "method. To learn more, please see: "
+            "https://sanic.dev/en/guide/release-notes/v23.3.html#response-cookies",  # noqa
+            0,
+        )
+        if key in self:
+            super().__delitem__(key)
+        self.delete_cookie(key)
+
+    def __len__(self):  # no cov
+        return len(self.cookies)
+
+    def __getitem__(self, key: str) -> Cookie:
+        deprecation(
+            "Accessing cookies from the CookieJar by dict key is deprecated. "
+            "You should instead use the cookies.get_cookie method. "
+            "To learn more, please see: "
+            "https://sanic.dev/en/guide/release-notes/v23.3.html#response-cookies",  # noqa
+            0,
+        )
+        return super().__getitem__(key)
+
+    def __iter__(self):  # no cov
+        deprecation(
+            "Iterating over the CookieJar has been deprecated and will be "
+            "removed in v24.3. To learn more, please see: "
+            "https://sanic.dev/en/guide/release-notes/v23.3.html#response-cookies",  # noqa
+            24.3,
+        )
+        return super().__iter__()
+
+    def keys(self):  # no cov
+        deprecation(
+            "Accessing CookieJar.keys() has been deprecated and will be "
+            "removed in v24.3. To learn more, please see: "
+            "https://sanic.dev/en/guide/release-notes/v23.3.html#response-cookies",  # noqa
+            24.3,
+        )
+        return super().keys()
+
+    def values(self):  # no cov
+        deprecation(
+            "Accessing CookieJar.values() has been deprecated and will be "
+            "removed in v24.3. To learn more, please see: "
+            "https://sanic.dev/en/guide/release-notes/v23.3.html#response-cookies",  # noqa
+            24.3,
+        )
+        return super().values()
+
+    def items(self):  # no cov
+        deprecation(
+            "Accessing CookieJar.items() has been deprecated and will be "
+            "removed in v24.3. To learn more, please see: "
+            "https://sanic.dev/en/guide/release-notes/v23.3.html#response-cookies",  # noqa
+            24.3,
+        )
+        return super().items()
+
+    def get(self, *args, **kwargs):  # no cov
+        deprecation(
+            "Accessing cookies from the CookieJar using get is deprecated "
+            "and will be removed in v24.3. You should instead use the "
+            "cookies.get_cookie method. To learn more, please see: "
+            "https://sanic.dev/en/guide/release-notes/v23.3.html#response-cookies",  # noqa
+            24.3,
+        )
+        return super().get(*args, **kwargs)
+
+    def pop(self, key, *args, **kwargs):  # no cov
+        deprecation(
+            "Using CookieJar.pop() has been deprecated and will be "
+            "removed in v24.3. To learn more, please see: "
+            "https://sanic.dev/en/guide/release-notes/v23.3.html#response-cookies",  # noqa
+            24.3,
+        )
+        self.delete(key)
+        return super().pop(key, *args, **kwargs)
+
+    @property
+    def header_key(self):  # no cov
+        deprecation(
+            "The CookieJar.header_key property has been deprecated and will "
+            "be removed in version 24.3. Use CookieJar.HEADER_KEY. ",
+            24.3,
+        )
+        return CookieJar.HEADER_KEY
+
+    @property
+    def cookie_headers(self) -> Dict[str, str]:  # no cov
+        deprecation(
+            "The CookieJar.coookie_headers property has been deprecated "
+            "and will be removed in version 24.3. If you need to check if a "
+            "particular cookie key has been set, use CookieJar.has_cookie.",
+            24.3,
+        )
+        return {key: self.header_key for key in self}
+
+    @property
+    def cookies(self) -> List[Cookie]:
+        return self.headers.getall(self.HEADER_KEY)
+
+    def get_cookie(
+        self,
+        key: str,
+        path: str = "/",
+        domain: Optional[str] = None,
+        host_prefix: bool = False,
+        secure_prefix: bool = False,
+    ) -> Optional[Cookie]:
+        for cookie in self.cookies:
+            if (
+                cookie.key == Cookie.make_key(key, host_prefix, secure_prefix)
+                and cookie.path == path
+                and cookie.domain == domain
+            ):
+                return cookie
+        return None
+
+    def has_cookie(
+        self,
+        key: str,
+        path: str = "/",
+        domain: Optional[str] = None,
+        host_prefix: bool = False,
+        secure_prefix: bool = False,
+    ) -> bool:
+        for cookie in self.cookies:
+            if (
+                cookie.key == Cookie.make_key(key, host_prefix, secure_prefix)
+                and cookie.path == path
+                and cookie.domain == domain
+            ):
+                return True
+        return False
+
+    def add_cookie(
+        self,
+        key: str,
+        value: str,
+        *,
+        path: str = "/",
+        domain: Optional[str] = None,
+        secure: bool = True,
+        max_age: Optional[int] = None,
+        expires: Optional[datetime] = None,
+        httponly: bool = False,
+        samesite: Optional[SameSite] = "Lax",
+        partitioned: bool = False,
+        comment: Optional[str] = None,
+        host_prefix: bool = False,
+        secure_prefix: bool = False,
+    ) -> Cookie:
+        """
+        Add a cookie to the CookieJar
+
+        :param key: Key of the cookie
+        :type key: str
+        :param value: Value of the cookie
+        :type value: str
+        :param path: Path of the cookie, defaults to None
+        :type path: Optional[str], optional
+        :param domain: Domain of the cookie, defaults to None
+        :type domain: Optional[str], optional
+        :param secure: Whether to set it as a secure cookie, defaults to True
+        :type secure: bool
+        :param max_age: Max age of the cookie in seconds; if set to 0 a
+            browser should delete it, defaults to None
+        :type max_age: Optional[int], optional
+        :param expires: When the cookie expires; if set to None browsers
+            should set it as a session cookie, defaults to None
+        :type expires: Optional[datetime], optional
+        :param httponly: Whether to set it as HTTP only, defaults to False
+        :type httponly: bool
+        :param samesite: How to set the samesite property, should be
+            strict, lax or none (case insensitive), defaults to Lax
+        :type samesite: Optional[SameSite], optional
+        :param partitioned: Whether to set it as partitioned, defaults to False
+        :type partitioned: bool
+        :param comment: A cookie comment, defaults to None
+        :type comment: Optional[str], optional
+        :param host_prefix: Whether to add __Host- as a prefix to the key.
+            This requires that path="/", domain=None, and secure=True,
+            defaults to False
+        :type host_prefix: bool
+        :param secure_prefix: Whether to add __Secure- as a prefix to the key.
+            This requires that secure=True, defaults to False
+        :type secure_prefix: bool
+        :return: The instance of the created cookie
+        :rtype: Cookie
+        """
+        cookie = Cookie(
+            key,
+            value,
+            path=path,
+            expires=expires,
+            comment=comment,
+            domain=domain,
+            max_age=max_age,
+            secure=secure,
+            httponly=httponly,
+            samesite=samesite,
+            partitioned=partitioned,
+            host_prefix=host_prefix,
+            secure_prefix=secure_prefix,
+        )
+        self.headers.add(self.HEADER_KEY, cookie)
+
+        # This should be removed in v24.3
+        super().__setitem__(key, cookie)
+
+        return cookie
+
+    def delete_cookie(
+        self,
+        key: str,
+        *,
+        path: str = "/",
+        domain: Optional[str] = None,
+        host_prefix: bool = False,
+        secure_prefix: bool = False,
+    ) -> None:
+        """
+        Delete a cookie
+
+        This will effectively set it as Max-Age: 0, which a browser should
+        interpret it to mean: "delete the cookie".
+
+        Since it is a browser/client implementation, your results may vary
+        depending upon which client is being used.
+
+        :param key: The key to be deleted
+        :type key: str
+        :param path: Path of the cookie, defaults to None
+        :type path: Optional[str], optional
+        :param domain: Domain of the cookie, defaults to None
+        :type domain: Optional[str], optional
+        :param host_prefix: Whether to add __Host- as a prefix to the key.
+            This requires that path="/", domain=None, and secure=True,
+            defaults to False
+        :type host_prefix: bool
+        :param secure_prefix: Whether to add __Secure- as a prefix to the key.
+            This requires that secure=True, defaults to False
+        :type secure_prefix: bool
+        """
+        # remove it from header
+        cookies: List[Cookie] = self.headers.popall(self.HEADER_KEY, [])
+        for cookie in cookies:
+            if (
+                cookie.key != Cookie.make_key(key, host_prefix, secure_prefix)
+                or cookie.path != path
+                or cookie.domain != domain
+            ):
+                self.headers.add(self.HEADER_KEY, cookie)
+
+        # This should be removed in v24.3
+        try:
+            super().__delitem__(key)
+        except KeyError:
+            ...
+
+        self.add_cookie(
+            key=key,
+            value="",
+            path=path,
+            domain=domain,
+            max_age=0,
+            samesite=None,
+            host_prefix=host_prefix,
+            secure_prefix=secure_prefix,
+        )
+
+
+# In v24.3, we should remove this as being a subclass of dict
+# Instead, it should be an object with __slots__
+# All of the current property accessors should be removed in favor
+# of actual slotted properties.
+class Cookie(dict):
+    """A stripped down version of Morsel from SimpleCookie"""
+
+    HOST_PREFIX = "__Host-"
+    SECURE_PREFIX = "__Secure-"
+
+    _keys = {
+        "path": "Path",
+        "comment": "Comment",
+        "domain": "Domain",
+        "max-age": "Max-Age",
+        "expires": "expires",
+        "samesite": "SameSite",
+        "version": "Version",
+        "secure": "Secure",
+        "httponly": "HttpOnly",
+        "partitioned": "Partitioned",
+    }
+    _flags = {"secure", "httponly", "partitioned"}
+
+    def __init__(
+        self,
+        key: str,
+        value: str,
+        *,
+        path: str = "/",
+        domain: Optional[str] = None,
+        secure: bool = True,
+        max_age: Optional[int] = None,
+        expires: Optional[datetime] = None,
+        httponly: bool = False,
+        samesite: Optional[SameSite] = "Lax",
+        partitioned: bool = False,
+        comment: Optional[str] = None,
+        host_prefix: bool = False,
+        secure_prefix: bool = False,
+    ):
+        if key in self._keys:
+            raise KeyError("Cookie name is a reserved word")
+        if not _is_legal_key(key):
+            raise KeyError("Cookie key contains illegal characters")
+        if host_prefix:
+            if not secure:
+                raise ServerError(
+                    "Cannot set host_prefix on a cookie without secure=True"
+                )
+            if path != "/":
+                raise ServerError(
+                    "Cannot set host_prefix on a cookie unless path='/'"
+                )
+            if domain:
+                raise ServerError(
+                    "Cannot set host_prefix on a cookie with a defined domain"
+                )
+        elif secure_prefix and not secure:
+            raise ServerError(
+                "Cannot set secure_prefix on a cookie without secure=True"
+            )
+        if partitioned and not host_prefix:
+            # This is technically possible, but it is not advisable so we will
+            # take a stand and say "don't shoot yourself in the foot"
+            raise ServerError(
+                "Cannot create a partitioned cookie without "
+                "also setting host_prefix=True"
+            )
+
+        self.key = self.make_key(key, host_prefix, secure_prefix)
+        self.value = value
+        super().__init__()
+
+        # This is a temporary solution while this object is a dict. We update
+        # all of the values in bulk, except for the values that have
+        # key-specific validation in _set_value
+        self.update(
+            {
+                "path": path,
+                "comment": comment,
+                "domain": domain,
+                "secure": secure,
+                "httponly": httponly,
+                "partitioned": partitioned,
+                "expires": None,
+                "max-age": None,
+                "samesite": None,
+            }
+        )
+        if expires is not None:
+            self._set_value("expires", expires)
+        if max_age is not None:
+            self._set_value("max-age", max_age)
+        if samesite is not None:
+            self._set_value("samesite", samesite)
+
+    def __setitem__(self, key, value):
+        deprecation(
+            "Setting values on a Cookie object as a dict has been deprecated. "
+            "This feature will be removed in v24.3. You should instead set "
+            f"values on cookies as object properties: cookie.{key}=... ",
+            24.3,
+        )
+        self._set_value(key, value)
+
+    # This is a temporary method for backwards compat and should be removed
+    # in v24.3 when this is no longer a dict
+    def _set_value(self, key: str, value: Any) -> None:
+        if key not in self._keys:
+            raise KeyError("Unknown cookie property: %s=%s" % (key, value))
+
+        if value is not None:
+            if key.lower() == "max-age" and not str(value).isdigit():
+                raise ValueError("Cookie max-age must be an integer")
+            elif key.lower() == "expires" and not isinstance(value, datetime):
+                raise TypeError("Cookie 'expires' property must be a datetime")
+            elif key.lower() == "samesite":
+                if value.lower() not in SAMESITE_VALUES:
+                    raise TypeError(
+                        "Cookie 'samesite' property must "
+                        f"be one of: {','.join(SAMESITE_VALUES)}"
+                    )
+                value = value.title()
+
+        super().__setitem__(key, value)
+
+    def encode(self, encoding):
+        """
+        Encode the cookie content in a specific type of encoding instructed
+        by the developer. Leverages the :func:`str.encode` method provided
+        by python.
+
+        This method can be used to encode and embed ``utf-8`` content into
+        the cookies.
+
+        :param encoding: Encoding to be used with the cookie
+        :return: Cookie encoded in a codec of choosing.
+        :except: UnicodeEncodeError
+        """
+        deprecation(
+            "Direct encoding of a Cookie object has been deprecated and will "
+            "be removed in v24.3.",
+            24.3,
+        )
+        return str(self).encode(encoding)
+
+    def __str__(self):
+        """Format as a Set-Cookie header value."""
+        output = ["%s=%s" % (self.key, _quote(self.value))]
+        key_index = list(self._keys)
+        for key, value in sorted(
+            self.items(), key=lambda x: key_index.index(x[0])
+        ):
+            if value is not None and value is not False:
+                if key == "max-age":
+                    try:
+                        output.append("%s=%d" % (self._keys[key], value))
+                    except TypeError:
+                        output.append("%s=%s" % (self._keys[key], value))
+                elif key == "expires":
+                    output.append(
+                        "%s=%s"
+                        % (
+                            self._keys[key],
+                            value.strftime("%a, %d-%b-%Y %T GMT"),
+                        )
+                    )
+                elif key in self._flags:
+                    output.append(self._keys[key])
+                else:
+                    output.append("%s=%s" % (self._keys[key], value))
+
+        return "; ".join(output)
+
+    @property
+    def path(self) -> str:  # no cov
+        return self["path"]
+
+    @path.setter
+    def path(self, value: str) -> None:  # no cov
+        self._set_value("path", value)
+
+    @property
+    def expires(self) -> Optional[datetime]:  # no cov
+        return self.get("expires")
+
+    @expires.setter
+    def expires(self, value: datetime) -> None:  # no cov
+        self._set_value("expires", value)
+
+    @property
+    def comment(self) -> Optional[str]:  # no cov
+        return self.get("comment")
+
+    @comment.setter
+    def comment(self, value: str) -> None:  # no cov
+        self._set_value("comment", value)
+
+    @property
+    def domain(self) -> Optional[str]:  # no cov
+        return self.get("domain")
+
+    @domain.setter
+    def domain(self, value: str) -> None:  # no cov
+        self._set_value("domain", value)
+
+    @property
+    def max_age(self) -> Optional[int]:  # no cov
+        return self.get("max-age")
+
+    @max_age.setter
+    def max_age(self, value: int) -> None:  # no cov
+        self._set_value("max-age", value)
+
+    @property
+    def secure(self) -> bool:  # no cov
+        return self.get("secure", False)
+
+    @secure.setter
+    def secure(self, value: bool) -> None:  # no cov
+        self._set_value("secure", value)
+
+    @property
+    def httponly(self) -> bool:  # no cov
+        return self.get("httponly", False)
+
+    @httponly.setter
+    def httponly(self, value: bool) -> None:  # no cov
+        self._set_value("httponly", value)
+
+    @property
+    def samesite(self) -> Optional[SameSite]:  # no cov
+        return self.get("samesite")
+
+    @samesite.setter
+    def samesite(self, value: SameSite) -> None:  # no cov
+        self._set_value("samesite", value)
+
+    @property
+    def partitioned(self) -> bool:  # no cov
+        return self.get("partitioned", False)
+
+    @partitioned.setter
+    def partitioned(self, value: bool) -> None:  # no cov
+        self._set_value("partitioned", value)
+
+    @classmethod
+    def make_key(
+        cls, key: str, host_prefix: bool = False, secure_prefix: bool = False
+    ) -> str:
+        if host_prefix and secure_prefix:
+            raise ServerError(
+                "Both host_prefix and secure_prefix were requested. "
+                "A cookie should have only one prefix."
+            )
+        elif host_prefix:
+            key = cls.HOST_PREFIX + key
+        elif secure_prefix:
+            key = cls.SECURE_PREFIX + key
+        return key

sanic/errorpages.py

@@ -22,6 +22,8 @@ from traceback import extract_tb
 
 from sanic.exceptions import BadRequest, SanicException
 from sanic.helpers import STATUS_CODES
+from sanic.log import deprecation, logger
+from sanic.pages.error import ErrorPage
 from sanic.response import html, json, text
 
 
@@ -37,11 +39,11 @@ if t.TYPE_CHECKING:
     from sanic import HTTPResponse, Request
 
 DEFAULT_FORMAT = "auto"
-FALLBACK_TEXT = (
+FALLBACK_TEXT = """\
-    "The server encountered an internal error and "
+The application encountered an unexpected error and could not continue.\
-    "cannot complete your request."
+"""
-)
 FALLBACK_STATUS = 500
+JSON = "application/json"
 
 
 class BaseRenderer:
@@ -115,134 +117,18 @@ class HTMLRenderer(BaseRenderer):
     The default fallback type.
     """
 
-    TRACEBACK_STYLE = """
-        html { font-family: sans-serif }
-        h2 { color: #888; }
-        .tb-wrapper p, dl, dd { margin: 0 }
-        .frame-border { margin: 1rem }
-        .frame-line > *, dt, dd { padding: 0.3rem 0.6rem }
-        .frame-line, dl { margin-bottom: 0.3rem }
-        .frame-code, dd { font-size: 16px; padding-left: 4ch }
-        .tb-wrapper, dl { border: 1px solid #eee }
-        .tb-header,.obj-header {
-            background: #eee; padding: 0.3rem; font-weight: bold
-        }
-        .frame-descriptor, dt { background: #e2eafb; font-size: 14px }
-    """
-    TRACEBACK_WRAPPER_HTML = (
-        "<div class=tb-header>{exc_name}: {exc_value}</div>"
-        "<div class=tb-wrapper>{frame_html}</div>"
-    )
-    TRACEBACK_BORDER = (
-        "<div class=frame-border>"
-        "The above exception was the direct cause of the following exception:"
-        "</div>"
-    )
-    TRACEBACK_LINE_HTML = (
-        "<div class=frame-line>"
-        "<p class=frame-descriptor>"
-        "File {0.filename}, line <i>{0.lineno}</i>, "
-        "in <code><b>{0.name}</b></code>"
-        "<p class=frame-code><code>{0.line}</code>"
-        "</div>"
-    )
-    OBJECT_WRAPPER_HTML = (
-        "<div class=obj-header>{title}</div>"
-        "<dl class={obj_type}>{display_html}</dl>"
-    )
-    OBJECT_DISPLAY_HTML = "<dt>{key}</dt><dd><code>{value}</code></dd>"
-    OUTPUT_HTML = (
-        "<!DOCTYPE html><html lang=en>"
-        "<meta charset=UTF-8><title>{title}</title>\n"
-        "<style>{style}</style>\n"
-        "<h1>{title}</h1><p>{text}\n"
-        "{body}"
-    )
-
     def full(self) -> HTTPResponse:
-        return html(
+        page = ErrorPage(
-            self.OUTPUT_HTML.format(
+            debug=self.debug,
-                title=self.title,
+            title=super().title,
-                text=self.text,
+            text=super().text,
-                style=self.TRACEBACK_STYLE,
+            request=self.request,
-                body=self._generate_body(full=True),
+            exc=self.exception,
-            ),
-            status=self.status,
         )
+        return html(page.render(), status=self.status, headers=self.headers)
 
     def minimal(self) -> HTTPResponse:
-        return html(
+        return self.full()
-            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}")
-
-    def _generate_body(self, *, full):
-        lines = []
-        if full:
-            _, exc_value, __ = sys.exc_info()
-            exceptions = []
-            while exc_value:
-                exceptions.append(self._format_exc(exc_value))
-                exc_value = exc_value.__cause__
-
-            traceback_html = self.TRACEBACK_BORDER.join(reversed(exceptions))
-            appname = escape(self.request.app.name)
-            name = escape(self.exception.__class__.__name__)
-            value = escape(self.exception)
-            path = escape(self.request.path)
-            lines += [
-                f"<h2>Traceback of {appname} " "(most recent call last):</h2>",
-                f"{traceback_html}",
-                "<div class=summary><p>",
-                f"<b>{name}: {value}</b> "
-                f"while handling path <code>{path}</code>",
-                "</div>",
-            ]
-
-        for attr, display in (("context", True), ("extra", bool(full))):
-            info = getattr(self.exception, attr, None)
-            if info and display:
-                lines.append(self._generate_object_display(info, attr))
-
-        return "\n".join(lines)
-
-    def _generate_object_display(
-        self, obj: t.Dict[str, t.Any], descriptor: str
-    ) -> str:
-        display = "".join(
-            self.OBJECT_DISPLAY_HTML.format(key=key, value=value)
-            for key, value in obj.items()
-        )
-        return self.OBJECT_WRAPPER_HTML.format(
-            title=descriptor.title(),
-            display_html=display,
-            obj_type=descriptor.lower(),
-        )
-
-    def _format_exc(self, exc):
-        frames = extract_tb(exc.__traceback__)
-        frame_html = "".join(
-            self.TRACEBACK_LINE_HTML.format(frame) for frame in frames
-        )
-        return self.TRACEBACK_WRAPPER_HTML.format(
-            exc_name=escape(exc.__class__.__name__),
-            exc_value=escape(exc),
-            frame_html=frame_html,
-        )
 
 
 class TextRenderer(BaseRenderer):
@@ -390,21 +276,18 @@ def escape(text):
     return f"{text}".replace("&", "&amp;").replace("<", "&lt;")
 
 
-RENDERERS_BY_CONFIG = {
+MIME_BY_CONFIG = {
-    "html": HTMLRenderer,
+    "text": "text/plain",
-    "json": JSONRenderer,
+    "json": "application/json",
-    "text": TextRenderer,
+    "html": "text/html",
 }
-
+CONFIG_BY_MIME = {v: k for k, v in MIME_BY_CONFIG.items()}
 RENDERERS_BY_CONTENT_TYPE = {
     "text/plain": TextRenderer,
     "application/json": JSONRenderer,
     "multipart/form-data": HTMLRenderer,
     "text/html": HTMLRenderer,
 }
-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.
@@ -420,7 +303,7 @@ RESPONSE_MAPPING = {
 
 
 def check_error_format(format):
-    if format not in RENDERERS_BY_CONFIG and format != "auto":
+    if format not in MIME_BY_CONFIG and format != "auto":
         raise SanicException(f"Unknown format: {format}")
 
 
@@ -435,98 +318,68 @@ def exception_response(
     """
     Render a response for the default FALLBACK exception handler.
     """
-    content_type = None
-
     if not renderer:
-        # Make sure we have something set
+        mt = guess_mime(request, fallback)
-        renderer = base
+        renderer = RENDERERS_BY_CONTENT_TYPE.get(mt, base)
-        render_format = fallback
-
-        if request:
-            # If there is a request, try and get the format
-            # from the route
-            if request.route:
-                try:
-                    if request.route.extra.error_format:
-                        render_format = request.route.extra.error_format
-                except AttributeError:
-                    ...
-
-            content_type = request.headers.getone("content-type", "").split(
-                ";"
-            )[0]
-
-            acceptable = request.accept
-
-            # If the format is auto still, make a guess
-            if render_format == "auto":
-                # First, if there is an Accept header, check if text/html
-                # is the first option
-                # According to MDN Web Docs, all major browsers use text/html
-                # as the primary value in Accept (with the exception of IE 8,
-                # and, well, if you are supporting IE 8, then you have bigger
-                # problems to concern yourself with than what default exception
-                # renderer is used)
-                # Source:
-                # https://developer.mozilla.org/en-US/docs/Web/HTTP/Content_negotiation/List_of_default_Accept_values
-
-                if acceptable and acceptable[0].match(
-                    "text/html",
-                    allow_type_wildcard=False,
-                    allow_subtype_wildcard=False,
-                ):
-                    renderer = HTMLRenderer
-
-                # Second, if there is an Accept header, check if
-                # application/json is an option, or if the content-type
-                # is application/json
-                elif (
-                    acceptable
-                    and acceptable.match(
-                        "application/json",
-                        allow_type_wildcard=False,
-                        allow_subtype_wildcard=False,
-                    )
-                    or content_type == "application/json"
-                ):
-                    renderer = JSONRenderer
-
-                # Third, if there is no Accept header, assume we want text.
-                # The likely use case here is a raw socket.
-                elif not acceptable:
-                    renderer = TextRenderer
-                else:
-                    # Fourth, look to see if there was a JSON body
-                    # When in this situation, the request is probably coming
-                    # from curl, an API client like Postman or Insomnia, or a
-                    # package like requests or httpx
-                    try:
-                        # Give them the benefit of the doubt if they did:
-                        # $ curl localhost:8000 -d '{"foo": "bar"}'
-                        # And provide them with JSONRenderer
-                        renderer = JSONRenderer if request.json else base
-                    except BadRequest:
-                        renderer = base
-            else:
-                renderer = RENDERERS_BY_CONFIG.get(render_format, renderer)
-
-            # Lastly, if there is an Accept header, make sure
-            # our choice is okay
-            if acceptable:
-                type_ = CONTENT_TYPE_BY_RENDERERS.get(renderer)  # type: ignore
-                if type_ and type_ not in acceptable:
-                    # If the renderer selected is not in the Accept header
-                    # look through what is in the Accept header, and select
-                    # the first option that matches. Otherwise, just drop back
-                    # to the original default
-                    for accept in acceptable:
-                        mtype = f"{accept.type_}/{accept.subtype}"
-                        maybe = RENDERERS_BY_CONTENT_TYPE.get(mtype)
-                        if maybe:
-                            renderer = maybe
-                            break
-                    else:
-                        renderer = base
 
     renderer = t.cast(t.Type[BaseRenderer], renderer)
     return renderer(request, exception, debug).render()
+
+
+def guess_mime(req: Request, fallback: str) -> str:
+    # Attempt to find a suitable MIME format for the response.
+    # Insertion-ordered map of formats["html"] = "source of that suggestion"
+    formats = {}
+    name = ""
+    # Route error_format (by magic from handler code if auto, the default)
+    if req.route:
+        name = req.route.name
+        f = req.route.extra.error_format
+        if f in MIME_BY_CONFIG:
+            formats[f] = name
+
+    if not formats and fallback in MIME_BY_CONFIG:
+        formats[fallback] = "FALLBACK_ERROR_FORMAT"
+
+    # If still not known, check for the request for clues of JSON
+    if not formats and fallback == "auto" and req.accept.match(JSON):
+        if JSON in req.accept:  # Literally, not wildcard
+            formats["json"] = "request.accept"
+        elif JSON in req.headers.getone("content-type", ""):
+            formats["json"] = "content-type"
+        # DEPRECATION: Remove this block in 24.3
+        else:
+            c = None
+            try:
+                c = req.json
+            except BadRequest:
+                pass
+            if c:
+                formats["json"] = "request.json"
+                deprecation(
+                    "Response type was determined by the JSON content of "
+                    "the request. This behavior is deprecated and will be "
+                    "removed in v24.3. Please specify the format either by\n"
+                    f'  error_format="json" on route {name}, by\n'
+                    '  FALLBACK_ERROR_FORMAT = "json", or by adding header\n'
+                    "  accept: application/json to your requests.",
+                    24.3,
+                )
+
+    # Any other supported formats
+    if fallback == "auto":
+        for k in MIME_BY_CONFIG:
+            if k not in formats:
+                formats[k] = "any"
+
+    mimes = [MIME_BY_CONFIG[k] for k in formats]
+    m = req.accept.match(*mimes)
+    if m:
+        format = CONFIG_BY_MIME[m.mime]
+        source = formats[format]
+        logger.debug(
+            f"The client accepts {m.header}, using '{format}' from {source}"
+        )
+    else:
+        logger.debug(f"No format found, the client accepts {req.accept!r}")
+    return m.mime

sanic/exceptions.py

@@ -1,5 +1,6 @@
-from asyncio import CancelledError
+from asyncio import CancelledError, Protocol
-from typing import Any, Dict, Optional, Union
+from os import PathLike
+from typing import Any, Dict, Optional, Sequence, Union
 
 from sanic.helpers import STATUS_CODES
 
@@ -9,51 +10,158 @@ class RequestCancelled(CancelledError):
 
 
 class ServerKilled(Exception):
-    ...
+    """
+    Exception Sanic server uses when killing a server process for something
+    unexpected happening.
+    """
 
 
 class SanicException(Exception):
+    """
+    Generic exception that will generate an HTTP response when raised
+    in the context of a request lifecycle.
+
+    Usually it is best practice to use one of the more specific exceptions
+    than this generic. Even when trying to raise a 500, it is generally
+    preferrable to use :class:`.ServerError`
+
+    .. code-block:: python
+
+        raise SanicException(
+            "Something went wrong",
+            status_code=999,
+            context={
+                "info": "Some additional details",
+            },
+            headers={
+                "X-Foo": "bar"
+            }
+        )
+
+    :param message: The message to be sent to the client. If ``None``
+        then the appropriate HTTP response status message will be used
+        instead, defaults to None
+    :type message: Optional[Union[str, bytes]], optional
+    :param status_code: The HTTP response code to send, if applicable. If
+        ``None``, then it will be 500, defaults to None
+    :type status_code: Optional[int], optional
+    :param quiet: When ``True``, the error traceback will be suppressed
+        from the logs, defaults to None
+    :type quiet: Optional[bool], optional
+    :param context: Additional mapping of key/value data that will be
+        sent to the client upon exception, defaults to None
+    :type context: Optional[Dict[str, Any]], optional
+    :param extra: Additional mapping of key/value data that will NOT be
+        sent to the client when in PRODUCTION mode, defaults to None
+    :type extra: Optional[Dict[str, Any]], optional
+    :param headers: Additional headers that should be sent with the HTTP
+        response, defaults to None
+    :type headers: Optional[Dict[str, Any]], optional
+    """
+
+    status_code: int = 500
+    quiet: Optional[bool] = False
+    headers: Dict[str, str] = {}
     message: str = ""
 
     def __init__(
         self,
         message: Optional[Union[str, bytes]] = None,
         status_code: Optional[int] = None,
+        *,
         quiet: Optional[bool] = None,
         context: Optional[Dict[str, Any]] = None,
         extra: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, Any]] = None,
     ) -> None:
         self.context = context
         self.extra = extra
+        status_code = status_code or getattr(
+            self.__class__, "status_code", None
+        )
+        quiet = quiet or getattr(self.__class__, "quiet", None)
+        headers = headers or getattr(self.__class__, "headers", {})
         if message is None:
             if self.message:
                 message = self.message
-            elif status_code is not None:
+            elif status_code:
                 msg: bytes = STATUS_CODES.get(status_code, b"")
                 message = msg.decode("utf8")
 
         super().__init__(message)
 
-        if status_code is not None:
+        self.status_code = status_code
-            self.status_code = status_code
+        self.quiet = quiet
-
+        self.headers = headers
-        # quiet=None/False/True with None meaning choose by status
-        if quiet or quiet is None and status_code not in (None, 500):
-            self.quiet = True
 
 
-class NotFound(SanicException):
+class HTTPException(SanicException):
+    """
+    A base class for other exceptions and should not be called directly.
+    """
+
+    def __init__(
+        self,
+        message: Optional[Union[str, bytes]] = None,
+        *,
+        quiet: Optional[bool] = None,
+        context: Optional[Dict[str, Any]] = None,
+        extra: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        super().__init__(
+            message,
+            quiet=quiet,
+            context=context,
+            extra=extra,
+            headers=headers,
+        )
+
+
+class NotFound(HTTPException):
     """
     **Status**: 404 Not Found
+
+    :param message: The message to be sent to the client. If ``None``
+        then the HTTP status 'Not Found' will be sent, defaults to None
+    :type message: Optional[Union[str, bytes]], optional
+    :param quiet: When ``True``, the error traceback will be suppressed
+        from the logs, defaults to None
+    :type quiet: Optional[bool], optional
+    :param context: Additional mapping of key/value data that will be
+        sent to the client upon exception, defaults to None
+    :type context: Optional[Dict[str, Any]], optional
+    :param extra: Additional mapping of key/value data that will NOT be
+        sent to the client when in PRODUCTION mode, defaults to None
+    :type extra: Optional[Dict[str, Any]], optional
+    :param headers: Additional headers that should be sent with the HTTP
+        response, defaults to None
+    :type headers: Optional[Dict[str, Any]], optional
     """
 
     status_code = 404
     quiet = True
 
 
-class BadRequest(SanicException):
+class BadRequest(HTTPException):
     """
     **Status**: 400 Bad Request
+
+    :param message: The message to be sent to the client. If ``None``
+        then the HTTP status 'Bad Request' will be sent, defaults to None
+    :type message: Optional[Union[str, bytes]], optional
+    :param quiet: When ``True``, the error traceback will be suppressed
+        from the logs, defaults to None
+    :type quiet: Optional[bool], optional
+    :param context: Additional mapping of key/value data that will be
+        sent to the client upon exception, defaults to None
+    :type context: Optional[Dict[str, Any]], optional
+    :param extra: Additional mapping of key/value data that will NOT be
+        sent to the client when in PRODUCTION mode, defaults to None
+    :type extra: Optional[Dict[str, Any]], optional
+    :param headers: Additional headers that should be sent with the HTTP
+        response, defaults to None
+    :type headers: Optional[Dict[str, Any]], optional
     """
 
     status_code = 400
@@ -61,51 +169,133 @@ class BadRequest(SanicException):
 
 
 InvalidUsage = BadRequest
+BadURL = BadRequest
 
 
-class BadURL(BadRequest):
+class MethodNotAllowed(HTTPException):
-    ...
-
-
-class MethodNotAllowed(SanicException):
     """
     **Status**: 405 Method Not Allowed
+
+    :param message: The message to be sent to the client. If ``None``
+        then the HTTP status 'Method Not Allowed' will be sent,
+        defaults to None
+    :type message: Optional[Union[str, bytes]], optional
+    :param method: The HTTP method that was used, defaults to  an empty string
+    :type method: Optional[str], optional
+    :param allowed_methods: The HTTP methods that can be used instead of the
+        one that was attempted
+    :type allowed_methods: Optional[Sequence[str]], optional
+    :param quiet: When ``True``, the error traceback will be suppressed
+        from the logs, defaults to None
+    :type quiet: Optional[bool], optional
+    :param context: Additional mapping of key/value data that will be
+        sent to the client upon exception, defaults to None
+    :type context: Optional[Dict[str, Any]], optional
+    :param extra: Additional mapping of key/value data that will NOT be
+        sent to the client when in PRODUCTION mode, defaults to None
+    :type extra: Optional[Dict[str, Any]], optional
+    :param headers: Additional headers that should be sent with the HTTP
+        response, defaults to None
+    :type headers: Optional[Dict[str, Any]], optional
     """
 
     status_code = 405
     quiet = True
 
-    def __init__(self, message, method, allowed_methods):
+    def __init__(
-        super().__init__(message)
+        self,
-        self.headers = {"Allow": ", ".join(allowed_methods)}
+        message: Optional[Union[str, bytes]] = None,
+        method: str = "",
+        allowed_methods: Optional[Sequence[str]] = None,
+        *,
+        quiet: Optional[bool] = None,
+        context: Optional[Dict[str, Any]] = None,
+        extra: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, Any]] = None,
+    ):
+        super().__init__(
+            message,
+            quiet=quiet,
+            context=context,
+            extra=extra,
+            headers=headers,
+        )
+        if allowed_methods:
+            self.headers = {
+                **self.headers,
+                "Allow": ", ".join(allowed_methods),
+            }
+        self.method = method
+        self.allowed_methods = allowed_methods
 
 
 MethodNotSupported = MethodNotAllowed
 
 
-class ServerError(SanicException):
+class ServerError(HTTPException):
     """
     **Status**: 500 Internal Server Error
+
+    A general server-side error has occurred. If no other HTTP exception is
+    appropriate, then this should be used
+
+    :param message: The message to be sent to the client. If ``None``
+        then the HTTP status 'Internal Server Error' will be sent,
+         defaults to None
+    :type message: Optional[Union[str, bytes]], optional
+    :param quiet: When ``True``, the error traceback will be suppressed
+        from the logs, defaults to None
+    :type quiet: Optional[bool], optional
+    :param context: Additional mapping of key/value data that will be
+        sent to the client upon exception, defaults to None
+    :type context: Optional[Dict[str, Any]], optional
+    :param extra: Additional mapping of key/value data that will NOT be
+        sent to the client when in PRODUCTION mode, defaults to None
+    :type extra: Optional[Dict[str, Any]], optional
+    :param headers: Additional headers that should be sent with the HTTP
+        response, defaults to None
+    :type headers: Optional[Dict[str, Any]], optional
     """
 
     status_code = 500
 
 
-class ServiceUnavailable(SanicException):
+InternalServerError = ServerError
+
+
+class ServiceUnavailable(HTTPException):
     """
     **Status**: 503 Service Unavailable
 
     The server is currently unavailable (because it is overloaded or
     down for maintenance). Generally, this is a temporary state.
+
+    :param message: The message to be sent to the client. If ``None``
+        then the HTTP status 'Bad Request' will be sent, defaults to None
+    :type message: Optional[Union[str, bytes]], optional
+    :param quiet: When ``True``, the error traceback will be suppressed
+        from the logs, defaults to None
+    :type quiet: Optional[bool], optional
+    :param context: Additional mapping of key/value data that will be
+        sent to the client upon exception, defaults to None
+    :type context: Optional[Dict[str, Any]], optional
+    :param extra: Additional mapping of key/value data that will NOT be
+        sent to the client when in PRODUCTION mode, defaults to None
+    :type extra: Optional[Dict[str, Any]], optional
+    :param headers: Additional headers that should be sent with the HTTP
+        response, defaults to None
+    :type headers: Optional[Dict[str, Any]], optional
     """
 
     status_code = 503
     quiet = True
 
 
-class URLBuildError(ServerError):
+class URLBuildError(HTTPException):
     """
     **Status**: 500 Internal Server Error
+
+    An exception used by Sanic internals when unable to build a URL.
     """
 
     status_code = 500
@@ -114,30 +304,77 @@ class URLBuildError(ServerError):
 class FileNotFound(NotFound):
     """
     **Status**: 404 Not Found
+
+    A specific form of :class:`.NotFound` that is specifically when looking
+    for a file on the file system at a known path.
+
+    :param message: The message to be sent to the client. If ``None``
+        then the HTTP status 'Not Found' will be sent, defaults to None
+    :type message: Optional[Union[str, bytes]], optional
+    :param path: The path, if any, to the file that could not
+        be found, defaults to None
+    :type path: Optional[PathLike], optional
+    :param relative_url: A relative URL of the file, defaults to None
+    :type relative_url: Optional[str], optional
+    :param quiet: When ``True``, the error traceback will be suppressed
+        from the logs, defaults to None
+    :type quiet: Optional[bool], optional
+    :param context: Additional mapping of key/value data that will be
+        sent to the client upon exception, defaults to None
+    :type context: Optional[Dict[str, Any]], optional
+    :param extra: Additional mapping of key/value data that will NOT be
+        sent to the client when in PRODUCTION mode, defaults to None
+    :type extra: Optional[Dict[str, Any]], optional
+    :param headers: Additional headers that should be sent with the HTTP
+        response, defaults to None
+    :type headers: Optional[Dict[str, Any]], optional
     """
 
-    def __init__(self, message, path, relative_url):
+    def __init__(
-        super().__init__(message)
+        self,
+        message: Optional[Union[str, bytes]] = None,
+        path: Optional[PathLike] = None,
+        relative_url: Optional[str] = None,
+        *,
+        quiet: Optional[bool] = None,
+        context: Optional[Dict[str, Any]] = None,
+        extra: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, Any]] = None,
+    ):
+        super().__init__(
+            message,
+            quiet=quiet,
+            context=context,
+            extra=extra,
+            headers=headers,
+        )
         self.path = path
         self.relative_url = relative_url
 
 
-class RequestTimeout(SanicException):
+class RequestTimeout(HTTPException):
-    """The Web server (running the Web site) thinks that there has been too
+    """
+    The Web server (running the Web site) thinks that there has been too
     long an interval of time between 1) the establishment of an IP
     connection (socket) between the client and the server and
     2) the receipt of any data on that socket, so the server has dropped
     the connection. The socket connection has actually been lost - the Web
     server has 'timed out' on that particular socket connection.
+
+    This is an internal exception thrown by Sanic and should not be used
+    directly.
     """
 
     status_code = 408
     quiet = True
 
 
-class PayloadTooLarge(SanicException):
+class PayloadTooLarge(HTTPException):
     """
     **Status**: 413 Payload Too Large
+
+    This is an internal exception thrown by Sanic and should not be used
+    directly.
     """
 
     status_code = 413
@@ -147,34 +384,126 @@ class PayloadTooLarge(SanicException):
 class HeaderNotFound(BadRequest):
     """
     **Status**: 400 Bad Request
+
+    :param message: The message to be sent to the client. If ``None``
+        then the HTTP status 'Bad Request' will be sent, defaults to None
+    :type message: Optional[Union[str, bytes]], optional
+    :param quiet: When ``True``, the error traceback will be suppressed
+        from the logs, defaults to None
+    :type quiet: Optional[bool], optional
+    :param context: Additional mapping of key/value data that will be
+        sent to the client upon exception, defaults to None
+    :type context: Optional[Dict[str, Any]], optional
+    :param extra: Additional mapping of key/value data that will NOT be
+        sent to the client when in PRODUCTION mode, defaults to None
+    :type extra: Optional[Dict[str, Any]], optional
+    :param headers: Additional headers that should be sent with the HTTP
+        response, defaults to None
+    :type headers: Optional[Dict[str, Any]], optional
     """
 
 
 class InvalidHeader(BadRequest):
     """
     **Status**: 400 Bad Request
+
+    :param message: The message to be sent to the client. If ``None``
+        then the HTTP status 'Bad Request' will be sent, defaults to None
+    :type message: Optional[Union[str, bytes]], optional
+    :param quiet: When ``True``, the error traceback will be suppressed
+        from the logs, defaults to None
+    :type quiet: Optional[bool], optional
+    :param context: Additional mapping of key/value data that will be
+        sent to the client upon exception, defaults to None
+    :type context: Optional[Dict[str, Any]], optional
+    :param extra: Additional mapping of key/value data that will NOT be
+        sent to the client when in PRODUCTION mode, defaults to None
+    :type extra: Optional[Dict[str, Any]], optional
+    :param headers: Additional headers that should be sent with the HTTP
+        response, defaults to None
+    :type headers: Optional[Dict[str, Any]], optional
     """
 
 
-class RangeNotSatisfiable(SanicException):
+class ContentRange(Protocol):
+    total: int
+
+
+class RangeNotSatisfiable(HTTPException):
     """
     **Status**: 416 Range Not Satisfiable
+
+    :param message: The message to be sent to the client. If ``None``
+        then the HTTP status 'Range Not Satisfiable' will be sent,
+        defaults to None
+    :type message: Optional[Union[str, bytes]], optional
+    :param content_range: An object meeting the :class:`.ContentRange` protocol
+        that has a ``total`` property, defaults to None
+    :type content_range: Optional[ContentRange], optional
+    :param quiet: When ``True``, the error traceback will be suppressed
+        from the logs, defaults to None
+    :type quiet: Optional[bool], optional
+    :param context: Additional mapping of key/value data that will be
+        sent to the client upon exception, defaults to None
+    :type context: Optional[Dict[str, Any]], optional
+    :param extra: Additional mapping of key/value data that will NOT be
+        sent to the client when in PRODUCTION mode, defaults to None
+    :type extra: Optional[Dict[str, Any]], optional
+    :param headers: Additional headers that should be sent with the HTTP
+        response, defaults to None
+    :type headers: Optional[Dict[str, Any]], optional
     """
 
     status_code = 416
     quiet = True
 
-    def __init__(self, message, content_range):
+    def __init__(
-        super().__init__(message)
+        self,
-        self.headers = {"Content-Range": f"bytes */{content_range.total}"}
+        message: Optional[Union[str, bytes]] = None,
+        content_range: Optional[ContentRange] = None,
+        *,
+        quiet: Optional[bool] = None,
+        context: Optional[Dict[str, Any]] = None,
+        extra: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, Any]] = None,
+    ):
+        super().__init__(
+            message,
+            quiet=quiet,
+            context=context,
+            extra=extra,
+            headers=headers,
+        )
+        if content_range is not None:
+            self.headers = {
+                **self.headers,
+                "Content-Range": f"bytes */{content_range.total}",
+            }
 
 
 ContentRangeError = RangeNotSatisfiable
 
 
-class ExpectationFailed(SanicException):
+class ExpectationFailed(HTTPException):
     """
     **Status**: 417 Expectation Failed
+
+    :param message: The message to be sent to the client. If ``None``
+        then the HTTP status 'Expectation Failed' will be sent,
+        defaults to None
+    :type message: Optional[Union[str, bytes]], optional
+    :param quiet: When ``True``, the error traceback will be suppressed
+        from the logs, defaults to None
+    :type quiet: Optional[bool], optional
+    :param context: Additional mapping of key/value data that will be
+        sent to the client upon exception, defaults to None
+    :type context: Optional[Dict[str, Any]], optional
+    :param extra: Additional mapping of key/value data that will NOT be
+        sent to the client when in PRODUCTION mode, defaults to None
+    :type extra: Optional[Dict[str, Any]], optional
+    :param headers: Additional headers that should be sent with the HTTP
+        response, defaults to None
+    :type headers: Optional[Dict[str, Any]], optional
     """
 
     status_code = 417
@@ -184,9 +513,25 @@ class ExpectationFailed(SanicException):
 HeaderExpectationFailed = ExpectationFailed
 
 
-class Forbidden(SanicException):
+class Forbidden(HTTPException):
     """
     **Status**: 403 Forbidden
+
+    :param message: The message to be sent to the client. If ``None``
+        then the HTTP status 'Forbidden' will be sent, defaults to None
+    :type message: Optional[Union[str, bytes]], optional
+    :param quiet: When ``True``, the error traceback will be suppressed
+        from the logs, defaults to None
+    :type quiet: Optional[bool], optional
+    :param context: Additional mapping of key/value data that will be
+        sent to the client upon exception, defaults to None
+    :type context: Optional[Dict[str, Any]], optional
+    :param extra: Additional mapping of key/value data that will NOT be
+        sent to the client when in PRODUCTION mode, defaults to None
+    :type extra: Optional[Dict[str, Any]], optional
+    :param headers: Additional headers that should be sent with the HTTP
+        response, defaults to None
+    :type headers: Optional[Dict[str, Any]], optional
     """
 
     status_code = 403
@@ -202,20 +547,33 @@ class InvalidRangeType(RangeNotSatisfiable):
     quiet = True
 
 
-class PyFileError(Exception):
+class PyFileError(SanicException):
-    def __init__(self, file):
+    def __init__(
-        super().__init__("could not execute config file %s", file)
+        self,
+        file,
+        status_code: Optional[int] = None,
+        *,
+        quiet: Optional[bool] = None,
+        context: Optional[Dict[str, Any]] = None,
+        extra: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, Any]] = None,
+    ):
+        super().__init__(
+            "could not execute config file %s" % file,
+            status_code=status_code,
+            quiet=quiet,
+            context=context,
+            extra=extra,
+            headers=headers,
+        )
 
 
-class Unauthorized(SanicException):
+class Unauthorized(HTTPException):
     """
     **Status**: 401 Unauthorized
 
-    :param message: Message describing the exception.
+    When present, additional keyword arguments may be used to complete
-    :param status_code: HTTP Status code.
+    the WWW-Authentication header.
-    :param scheme: Name of the authentication scheme to be used.
-
-    When present, kwargs is used to complete the WWW-Authentication header.
 
     Examples::
 
@@ -240,21 +598,58 @@ class Unauthorized(SanicException):
         raise Unauthorized("Auth required.",
                            scheme="Bearer",
                            realm="Restricted Area")
+
+    :param message: The message to be sent to the client. If ``None``
+        then the HTTP status 'Bad Request' will be sent, defaults to None
+    :type message: Optional[Union[str, bytes]], optional
+    :param scheme: Name of the authentication scheme to be used.
+    :type scheme: Optional[str], optional
+    :param quiet: When ``True``, the error traceback will be suppressed
+        from the logs, defaults to None
+    :type quiet: Optional[bool], optional
+    :param context: Additional mapping of key/value data that will be
+        sent to the client upon exception, defaults to None
+    :type context: Optional[Dict[str, Any]], optional
+    :param extra: Additional mapping of key/value data that will NOT be
+        sent to the client when in PRODUCTION mode, defaults to None
+    :type extra: Optional[Dict[str, Any]], optional
+    :param headers: Additional headers that should be sent with the HTTP
+        response, defaults to None
+    :type headers: Optional[Dict[str, Any]], optional
     """
 
     status_code = 401
     quiet = True
 
-    def __init__(self, message, status_code=None, scheme=None, **kwargs):
+    def __init__(
-        super().__init__(message, status_code)
+        self,
+        message: Optional[Union[str, bytes]] = None,
+        scheme: Optional[str] = None,
+        *,
+        quiet: Optional[bool] = None,
+        context: Optional[Dict[str, Any]] = None,
+        extra: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, Any]] = None,
+        **challenges,
+    ):
+        super().__init__(
+            message,
+            quiet=quiet,
+            context=context,
+            extra=extra,
+            headers=headers,
+        )
 
         # if auth-scheme is specified, set "WWW-Authenticate" header
         if scheme is not None:
-            values = ['{!s}="{!s}"'.format(k, v) for k, v in kwargs.items()]
+            values = [
+                '{!s}="{!s}"'.format(k, v) for k, v in challenges.items()
+            ]
             challenge = ", ".join(values)
 
             self.headers = {
-                "WWW-Authenticate": f"{scheme} {challenge}".rstrip()
+                **self.headers,
+                "WWW-Authenticate": f"{scheme} {challenge}".rstrip(),
             }
 
 

sanic/handlers/content_range.py

@@ -75,4 +75,4 @@ class ContentRangeHandler:
         }
 
     def __bool__(self):
-        return self.size > 0
+        return hasattr(self, "size") and self.size > 0

sanic/handlers/error.py

@@ -3,7 +3,8 @@ from __future__ import annotations
 from typing import Dict, List, Optional, Tuple, Type
 
 from sanic.errorpages import BaseRenderer, TextRenderer, exception_response
-from sanic.log import deprecation, error_logger
+from sanic.exceptions import ServerError
+from sanic.log import error_logger
 from sanic.models.handler_types import RouteHandler
 from sanic.response import text
 
@@ -43,16 +44,11 @@ class ErrorHandler:
             if name is None:
                 name = "__ALL_ROUTES__"
 
-            error_logger.warning(
+            message = (
                 f"Duplicate exception handler definition on: route={name} "
                 f"and exception={exc}"
             )
-            deprecation(
+            raise ServerError(message)
-                "A duplicate exception handler definition was discovered. "
-                "This may cause unintended consequences. A warning has been "
-                "issued now, but it will not be allowed starting in v23.3.",
-                23.3,
-            )
         self.cached_handlers[key] = handler
 
     def add(self, exception, handler, route_names: Optional[List[str]] = None):

sanic/headers.py

@@ -19,7 +19,6 @@ OptionsIterable = Iterable[Tuple[str, str]]  # May contain duplicate keys
 
 _token, _quoted = r"([\w!#$%&'*+\-.^_`|~]+)", r'"([^"]*)"'
 _param = re.compile(rf";\s*{_token}=(?:{_token}|{_quoted})", re.ASCII)
-_firefox_quote_escape = re.compile(r'\\"(?!; |\s*$)')
 _ipv6 = "(?:[0-9A-Fa-f]{0,4}:){2,7}[0-9A-Fa-f]{0,4}"
 _ipv6_re = re.compile(_ipv6)
 _host_re = re.compile(
@@ -33,15 +32,6 @@ _host_re = re.compile(
 # For more information, consult ../tests/test_requests.py
 
 
-def parse_arg_as_accept(f):
-    def func(self, other, *args, **kwargs):
-        if not isinstance(other, MediaType) and other:
-            other = MediaType._parse(other)
-        return f(self, other, *args, **kwargs)
-
-    return func
-
-
 class MediaType:
     """A media type, as used in the Accept header."""
 
@@ -51,57 +41,67 @@ class MediaType:
         subtype: str,
         **params: str,
     ):
-        self.type_ = type_
+        self.type = type_
         self.subtype = subtype
         self.q = float(params.get("q", "1.0"))
         self.params = params
         self.mime = f"{type_}/{subtype}"
+        self.key = (
+            -1 * self.q,
+            -1 * len(self.params),
+            self.subtype == "*",
+            self.type == "*",
+        )
 
     def __repr__(self):
         return self.mime + "".join(f";{k}={v}" for k, v in self.params.items())
 
     def __eq__(self, other):
-        """Check for mime (str or MediaType) identical type/subtype."""
+        """Check for mime (str or MediaType) identical type/subtype.
+        Parameters such as q are not considered."""
         if isinstance(other, str):
+            # Give a friendly reminder if str contains parameters
+            if ";" in other:
+                raise ValueError("Use match() to compare with parameters")
             return self.mime == other
         if isinstance(other, MediaType):
+            # Ignore parameters silently with MediaType objects
             return self.mime == other.mime
         return NotImplemented
 
     def match(
         self,
-        mime: str,
+        mime_with_params: Union[str, MediaType],
-        allow_type_wildcard=True,
-        allow_subtype_wildcard=True,
     ) -> Optional[MediaType]:
         """Check if this media type matches the given mime type/subtype.
-
         Wildcards are supported both ways on both type and subtype.
-
+        If mime contains a semicolon, optionally followed by parameters,
+        the parameters of the two media types must match exactly.
         Note:  Use the `==` operator instead to check for literal matches
         without expanding wildcards.
-
         @param media_type: A type/subtype string to match.
         @return `self` if the media types are compatible, else `None`
         """
-        mt = MediaType._parse(mime)
+        mt = (
+            MediaType._parse(mime_with_params)
+            if isinstance(mime_with_params, str)
+            else mime_with_params
+        )
         return (
             self
             if (
+                mt
+                # All parameters given in the other media type must match
+                and all(self.params.get(k) == v for k, v in mt.params.items())
                 # Subtype match
-                (self.subtype in (mt.subtype, "*") or mt.subtype == "*")
-                # Type match
-                and (self.type_ in (mt.type_, "*") or mt.type_ == "*")
-                # Allow disabling wildcards (backwards compatibility with tests)
                 and (
-                    allow_type_wildcard
+                    self.subtype == mt.subtype
-                    or self.type_ != "*"
+                    or self.subtype == "*"
-                    and mt.type_ != "*"
+                    or mt.subtype == "*"
                 )
+                # Type match
                 and (
-                    allow_subtype_wildcard
+                    self.type == mt.type or self.type == "*" or mt.type == "*"
-                    or self.subtype != "*"
-                    and mt.subtype != "*"
                 )
             )
             else None
@@ -110,19 +110,16 @@ class MediaType:
     @property
     def has_wildcard(self) -> bool:
         """Return True if this media type has a wildcard in it."""
-        return "*" in (self.subtype, self.type_)
+        return any(part == "*" for part in (self.subtype, self.type))
-
-    @property
-    def is_wildcard(self) -> bool:
-        """Return True if this is the wildcard `*/*`"""
-        return self.type_ == "*" and self.subtype == "*"
 
     @classmethod
-    def _parse(cls, mime_with_params: str) -> MediaType:
+    def _parse(cls, mime_with_params: str) -> Optional[MediaType]:
         mtype = mime_with_params.strip()
+        if "/" not in mime_with_params:
+            return None
 
-        media, *raw_params = mtype.split(";")
+        mime, *raw_params = mtype.split(";")
-        type_, subtype = media.split("/", 1)
+        type_, subtype = mime.split("/", 1)
         if not type_ or not subtype:
             raise ValueError(f"Invalid media type: {mtype}")
 
@@ -136,17 +133,63 @@ class MediaType:
         return cls(type_.lstrip(), subtype.rstrip(), **params)
 
 
-class Matched(str):
+class Matched:
-    """A matching result of a MIME string against a MediaType."""
+    """A matching result of a MIME string against a header."""
 
-    def __new__(cls, mime: str, m: Optional[MediaType]):
+    def __init__(self, mime: str, header: Optional[MediaType]):
-        return super().__new__(cls, mime)
+        self.mime = mime
-
+        self.header = header
-    def __init__(self, mime: str, m: Optional[MediaType]):
-        self.m = m
 
     def __repr__(self):
-        return f"<{self} matched {self.m}>" if self else "<no match>"
+        return f"<{self} matched {self.header}>" if self else "<no match>"
+
+    def __str__(self):
+        return self.mime
+
+    def __bool__(self):
+        return self.header is not None
+
+    def __eq__(self, other: Any) -> bool:
+        try:
+            comp, other_accept = self._compare(other)
+        except TypeError:
+            return False
+
+        return bool(
+            comp
+            and (
+                (self.header and other_accept.header)
+                or (not self.header and not other_accept.header)
+            )
+        )
+
+    def _compare(self, other) -> Tuple[bool, Matched]:
+        if isinstance(other, str):
+            parsed = Matched.parse(other)
+            if self.mime == other:
+                return True, parsed
+            other = parsed
+
+        if isinstance(other, Matched):
+            return self.header == other.header, other
+
+        raise TypeError(
+            "Comparison not supported between unequal "
+            f"mime types of '{self.mime}' and '{other}'"
+        )
+
+    def match(self, other: Union[str, Matched]) -> Optional[Matched]:
+        accept = Matched.parse(other) if isinstance(other, str) else other
+        if not self.header or not accept.header:
+            return None
+        if self.header.match(accept.header):
+            return accept
+        return None
+
+    @classmethod
+    def parse(cls, raw: str) -> Matched:
+        media_type = MediaType._parse(raw)
+        return cls(raw, media_type)
 
 
 class AcceptList(list):
@@ -161,14 +204,15 @@ class AcceptList(list):
     -  operator 'in' for checking explicit matches (wildcards as literals)
     """
 
-    def match(self, *mimes: str) -> Matched:
+    def match(self, *mimes: str, accept_wildcards=True) -> Matched:
         """Find a media type accepted by the client.
 
         This method can be used to find which of the media types requested by
         the client is most preferred against the ones given as arguments.
 
         The ordering of preference is set by:
-        1. The q values on the Accept header, and those being equal,
+        1. The order set by RFC 7231, s. 5.3.2, giving a higher priority
+            to q values and more specific type definitions,
         2. The order of the arguments (first is most preferred), and
         3. The first matching entry on the Accept header.
 
@@ -181,29 +225,41 @@ class AcceptList(list):
         header entry `MediaType` or `None` is available as the `m` attribute.
 
         @param mimes: Any MIME types to search for in order of preference.
+        @param accept_wildcards: Match Accept entries with wildcards in them.
         @return A match object with the mime string and the MediaType object.
         """
-        l = sorted(
+        a = sorted(
-            [
+            (-acc.q, i, j, mime, acc)
-                (-acc.q, i, j, mime, acc)  # Sort by -q, i, j
+            for j, acc in enumerate(self)
-                for j, acc in enumerate(self)
+            if accept_wildcards or not acc.has_wildcard
-                for i, mime in enumerate(mimes)
+            for i, mime in enumerate(mimes)
-                if acc.match(mime)
+            if acc.match(mime)
-            ]
         )
-        return Matched(*(l[0][3:] if l else ("", None)))
+        return Matched(*(a[0][-2:] if a else ("", None)))
+
+    def __str__(self):
+        """Format as Accept header value (parsed, not original)."""
+        return ", ".join(str(m) for m in self)
 
 
-def parse_accept(accept: str) -> AcceptList:
+def parse_accept(accept: Optional[str]) -> AcceptList:
     """Parse an Accept header and order the acceptable media types in
-    accorsing to RFC 7231, s. 5.3.2
+    according to RFC 7231, s. 5.3.2
     https://datatracker.ietf.org/doc/html/rfc7231#section-5.3.2
     """
     if not accept:
-        return AcceptList()
+        if accept == "":
+            return AcceptList()  # Empty header, accept nothing
+        accept = "*/*"  # No header means that all types are accepted
     try:
-        a = [MediaType._parse(mtype) for mtype in accept.split(",")]
+        a = [
-        return AcceptList(sorted(a, key=lambda mtype: -mtype.q))
+            mt
+            for mt in [MediaType._parse(mtype) for mtype in accept.split(",")]
+            if mt
+        ]
+        if not a:
+            raise ValueError
+        return AcceptList(sorted(a, key=lambda x: x.key))
     except ValueError:
         raise InvalidHeader(f"Invalid header value in Accept: {accept}")
 
@@ -211,19 +267,23 @@ def parse_accept(accept: str) -> AcceptList:
 def parse_content_header(value: str) -> Tuple[str, Options]:
     """Parse content-type and content-disposition header values.
 
-    E.g. 'form-data; name=upload; filename=\"file.txt\"' to
+    E.g. `form-data; name=upload; filename="file.txt"` to
     ('form-data', {'name': 'upload', 'filename': 'file.txt'})
 
     Mostly identical to cgi.parse_header and werkzeug.parse_options_header
-    but runs faster and handles special characters better. Unescapes quotes.
+    but runs faster and handles special characters better.
+
+    Unescapes %22 to `"` and %0D%0A to `\n` in field values.
     """
-    value = _firefox_quote_escape.sub("%22", value)
     pos = value.find(";")
     if pos == -1:
         options: Dict[str, Union[int, str]] = {}
     else:
         options = {
-            m.group(1).lower(): m.group(2) or m.group(3).replace("%22", '"')
+            m.group(1)
+            .lower(): (m.group(2) or m.group(3))
+            .replace("%22", '"')
+            .replace("%0D%0A", "\n")
             for m in _param.finditer(value[pos:])
         }
         value = value[:pos]

sanic/http/http1.py

@@ -240,9 +240,14 @@ class Http(Stream, metaclass=TouchUpMeta):
             headers_instance.getone("upgrade", "").lower() == "websocket"
         )
 
+        try:
+            url_bytes = self.url.encode("ASCII")
+        except UnicodeEncodeError:
+            raise BadRequest("URL may only contain US-ASCII characters.")
+
         # Prepare a Request object
         request = self.protocol.request_class(
-            url_bytes=self.url.encode(),
+            url_bytes=url_bytes,
             headers=headers_instance,
             head=bytes(head),
             version=protocol[5:],
@@ -428,7 +433,9 @@ class Http(Stream, metaclass=TouchUpMeta):
             if self.request is None:
                 self.create_empty_request()
 
-            request_middleware = not isinstance(exception, ServiceUnavailable)
+            request_middleware = not isinstance(
+                exception, (ServiceUnavailable, RequestCancelled)
+            )
             try:
                 await app.handle_exception(
                     self.request, exception, request_middleware
@@ -443,9 +450,18 @@ class Http(Stream, metaclass=TouchUpMeta):
         bogus response for error handling use.
         """
 
+        # Reformat any URL already received with \xHH escapes for better logs
+        url_bytes = (
+            self.url.encode(errors="surrogateescape")
+            .decode("ASCII", errors="backslashreplace")
+            .encode("ASCII")
+            if self.url
+            else b"*"
+        )
+
         # FIXME: Avoid this by refactoring error handling and response code
         self.request = self.protocol.request_class(
-            url_bytes=self.url.encode() if self.url else b"*",
+            url_bytes=url_bytes,
             headers=Header({}),
             version="1.1",
             method="NONE",

sanic/http/http3.py

@@ -18,7 +18,12 @@ from typing import (
 
 from sanic.compat import Header
 from sanic.constants import LocalCertCreator
-from sanic.exceptions import PayloadTooLarge, SanicException, ServerError
+from sanic.exceptions import (
+    BadRequest,
+    PayloadTooLarge,
+    SanicException,
+    ServerError,
+)
 from sanic.helpers import has_message_body
 from sanic.http.constants import Stage
 from sanic.http.stream import Stream
@@ -333,7 +338,17 @@ class Http3:
         return self.receivers[stream_id]
 
     def _make_request(self, event: HeadersReceived) -> Request:
-        headers = Header(((k.decode(), v.decode()) for k, v in event.headers))
+        try:
+            headers = Header(
+                (
+                    (k.decode("ASCII"), v.decode(errors="surrogateescape"))
+                    for k, v in event.headers
+                )
+            )
+        except UnicodeDecodeError:
+            raise BadRequest(
+                "Header names may only contain US-ASCII characters."
+            )
         method = headers[":method"]
         path = headers[":path"]
         scheme = headers.pop(":scheme", "")
@@ -342,9 +357,14 @@ class Http3:
         if authority:
             headers["host"] = authority
 
+        try:
+            url_bytes = path.encode("ASCII")
+        except UnicodeEncodeError:
+            raise BadRequest("URL may only contain US-ASCII characters.")
+
         transport = HTTP3Transport(self.protocol)
         request = self.protocol.request_class(
-            path.encode(),
+            url_bytes,
             headers,
             "3",
             method,

sanic/http/tls/context.py

@@ -159,7 +159,7 @@ class CertSimple(SanicSSLContext):
         # try common aliases, rename to cert/key
         certfile = kw["cert"] = kw.pop("certificate", None) or cert
         keyfile = kw["key"] = kw.pop("keyfile", None) or key
-        password = kw.pop("password", None)
+        password = kw.get("password", None)
         if not certfile or not keyfile:
             raise ValueError("SSL dict needs filenames for cert and key.")
         subject = {}

sanic/log.py

@@ -62,13 +62,13 @@ LOGGING_CONFIG_DEFAULTS: Dict[str, Any] = dict(  # no cov
     },
     formatters={
         "generic": {
-            "format": "%(asctime)s [%(process)d] [%(levelname)s] %(message)s",
+            "format": "%(asctime)s [%(process)s] [%(levelname)s] %(message)s",
             "datefmt": "[%Y-%m-%d %H:%M:%S %z]",
             "class": "logging.Formatter",
         },
         "access": {
             "format": "%(asctime)s - (%(name)s)[%(levelname)s][%(host)s]: "
-            + "%(request)s %(message)s %(status)d %(byte)d",
+            + "%(request)s %(message)s %(status)s %(byte)s",
             "datefmt": "[%Y-%m-%d %H:%M:%S %z]",
             "class": "logging.Formatter",
         },
@@ -126,7 +126,26 @@ logger.addFilter(_verbosity_filter)
 
 
 def deprecation(message: str, version: float):  # no cov
-    version_info = f"[DEPRECATION v{version}] "
+    """
+    Add a deprecation notice
+
+    Example when a feature is being removed. In this case, version
+    should be AT LEAST next version + 2
+
+        deprecation("Helpful message", 99.9)
+
+    Example when a feature is deprecated but not being removed:
+
+        deprecation("Helpful message", 0)
+
+    :param message: The message of the notice
+    :type message: str
+    :param version: The version when the feature will be removed. If it is
+      not being removed, then set version=0.
+    :type version: float
+    """
+    version_display = f" v{version}" if version else ""
+    version_info = f"[DEPRECATION{version_display}] "
     if is_atty():
         version_info = f"{Colors.RED}{version_info}"
         message = f"{Colors.YELLOW}{message}{Colors.END}"

sanic/mixins/routes.py

@@ -546,7 +546,7 @@ class RouteMixin(BaseMixin, metaclass=SanicMeta):
         strict_slashes: Optional[bool] = None,
         version: Optional[Union[int, str, float]] = None,
         name: Optional[str] = None,
-        ignore_body: bool = True,
+        ignore_body: bool = False,
         version_prefix: str = "/v",
         error_format: Optional[str] = None,
         **ctx_kwargs: Any,

sanic/mixins/startup.py

@@ -47,17 +47,16 @@ 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
-from sanic.log import Colors, deprecation, error_logger, logger
+from sanic.log import Colors, error_logger, logger
 from sanic.models.handler_types import ListenerType
 from sanic.server import Signal as ServerSignal
 from sanic.server import try_use_uvloop
 from sanic.server.async_server import AsyncioServer
 from sanic.server.events import trigger_events
-from sanic.server.legacy import watchdog
 from sanic.server.loop import try_windows_loop
 from sanic.server.protocols.http_protocol import HttpProtocol
 from sanic.server.protocols.websocket_protocol import WebSocketProtocol
-from sanic.server.runners import serve, serve_multiple, serve_single
+from sanic.server.runners import serve
 from sanic.server.socket import configure_socket, remove_unix_socket
 from sanic.worker.loader import AppLoader
 from sanic.worker.manager import WorkerManager
@@ -135,7 +134,6 @@ class StartupMixin(metaclass=SanicMeta):
         motd_display: Optional[Dict[str, str]] = None,
         auto_tls: bool = False,
         single_process: bool = False,
-        legacy: bool = False,
     ) -> None:
         """
         Run the HTTP Server and listen until keyboard interrupt or term
@@ -197,13 +195,10 @@ class StartupMixin(metaclass=SanicMeta):
             motd_display=motd_display,
             auto_tls=auto_tls,
             single_process=single_process,
-            legacy=legacy,
         )
 
         if single_process:
             serve = self.__class__.serve_single
-        elif legacy:
-            serve = self.__class__.serve_legacy
         else:
             serve = self.__class__.serve
         serve(primary=self)  # type: ignore
@@ -235,7 +230,6 @@ class StartupMixin(metaclass=SanicMeta):
         coffee: bool = False,
         auto_tls: bool = False,
         single_process: bool = False,
-        legacy: bool = False,
     ) -> None:
         if version == 3 and self.state.server_info:
             raise RuntimeError(
@@ -264,13 +258,10 @@ class StartupMixin(metaclass=SanicMeta):
                 "or auto-reload"
             )
 
-        if single_process and legacy:
+        if register_sys_signals is False and not single_process:
-            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."
+                "Use Sanic.serve_single."
             )
 
         if motd_display:
@@ -811,7 +802,7 @@ class StartupMixin(metaclass=SanicMeta):
             ssl = kwargs.get("ssl")
 
             if isinstance(ssl, SanicSSLContext):
-                kwargs["ssl"] = kwargs["ssl"].sanic
+                kwargs["ssl"] = ssl.sanic
 
             manager = WorkerManager(
                 primary.state.workers,
@@ -877,7 +868,10 @@ class StartupMixin(metaclass=SanicMeta):
 
             sync_manager.shutdown()
             for sock in socks:
-                sock.shutdown(SHUT_RDWR)
+                try:
+                    sock.shutdown(SHUT_RDWR)
+                except OSError:
+                    ...
                 sock.close()
             socks = []
             trigger_events(main_stop, loop, primary)
@@ -953,76 +947,6 @@ class StartupMixin(metaclass=SanicMeta):
             cls._cleanup_env_vars()
             cls._cleanup_apps()
 
-    @classmethod
-    def serve_legacy(cls, primary: Optional[Sanic] = None) -> None:
-        apps = list(cls._app_registry.values())
-
-        if not primary:
-            try:
-                primary = apps[0]
-            except IndexError:
-                raise RuntimeError("Did not find any applications.")
-
-        reloader_start = primary.listeners.get("reload_process_start")
-        reloader_stop = primary.listeners.get("reload_process_stop")
-        # We want to run auto_reload if ANY of the applications have it enabled
-        if (
-            cls.should_auto_reload()
-            and os.environ.get("SANIC_SERVER_RUNNING") != "true"
-        ):  # no cov
-            loop = new_event_loop()
-            trigger_events(reloader_start, loop, primary)
-            reload_dirs: Set[Path] = primary.state.reload_dirs.union(
-                *(app.state.reload_dirs for app in apps)
-            )
-            watchdog(1.0, reload_dirs)
-            trigger_events(reloader_stop, loop, primary)
-            return
-
-        # This exists primarily for unit testing
-        if not primary.state.server_info:  # no cov
-            for app in apps:
-                app.state.server_info.clear()
-            return
-
-        primary_server_info = primary.state.server_info[0]
-        primary.before_server_start(partial(primary._start_servers, apps=apps))
-
-        deprecation(
-            f"{Colors.YELLOW}Running {Colors.SANIC}Sanic {Colors.YELLOW}w/ "
-            f"LEGACY manager.{Colors.END} Support for will be dropped in "
-            "version 23.3.",
-            23.3,
-        )
-        try:
-            primary_server_info.stage = ServerStage.SERVING
-
-            if primary.state.workers > 1 and os.name != "posix":  # no cov
-                logger.warning(
-                    f"Multiprocessing is currently not supported on {os.name},"
-                    " using workers=1 instead"
-                )
-                primary.state.workers = 1
-            if primary.state.workers == 1:
-                serve_single(primary_server_info.settings)
-            elif primary.state.workers == 0:
-                raise RuntimeError("Cannot serve with no workers")
-            else:
-                serve_multiple(
-                    primary_server_info.settings, primary.state.workers
-                )
-        except BaseException:
-            error_logger.exception(
-                "Experienced exception while trying to serve"
-            )
-            raise
-        finally:
-            primary_server_info.stage = ServerStage.STOPPED
-        logger.info("Server Stopped")
-
-        cls._cleanup_env_vars()
-        cls._cleanup_apps()
-
     async def _start_servers(
         self,
         primary: Sanic,

sanic/mixins/static.py

@@ -3,7 +3,7 @@ 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 typing import Optional, Sequence, Set, Union
 from urllib.parse import unquote
 
 from sanic_routing.route import Route
@@ -14,7 +14,7 @@ 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.log import error_logger
 from sanic.mixins.base import BaseMixin
 from sanic.models.futures import FutureStatic
 from sanic.request import Request
@@ -31,7 +31,7 @@ class StaticMixin(BaseMixin, metaclass=SanicMeta):
     def static(
         self,
         uri: str,
-        file_or_directory: Union[PathLike, str, bytes],
+        file_or_directory: Union[PathLike, str],
         pattern: str = r"/?.+",
         use_modified_since: bool = True,
         use_content_range: bool = False,
@@ -94,14 +94,12 @@ class StaticMixin(BaseMixin, metaclass=SanicMeta):
                 f"Static route must be a valid path, not {file_or_directory}"
             )
 
-        if isinstance(file_or_directory, bytes):
+        try:
-            deprecation(
+            file_or_directory = Path(file_or_directory)
-                "Serving a static directory with a bytes string is "
+        except TypeError:
-                "deprecated and will be removed in v22.9.",
+            raise TypeError(
-                22.9,
+                "Static file or directory must be a path-like object or string"
             )
-            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(

sanic/pages/base.py

@@ -1,18 +1,19 @@
 from abc import ABC, abstractmethod
 
-from html5tagger import HTML, Document
+from html5tagger import HTML, Builder, Document
 
 from sanic import __version__ as VERSION
-from sanic.application.logo import SVG_LOGO
+from sanic.application.logo import SVG_LOGO_SIMPLE
 from sanic.pages.css import CSS
 
 
 class BasePage(ABC, metaclass=CSS):  # no cov
-    TITLE = "Unknown"
+    TITLE = "Sanic"
+    HEADING = None
     CSS: str
+    doc: Builder
 
     def __init__(self, debug: bool = True) -> None:
-        self.doc = Document(self.TITLE, lang="en")
         self.debug = debug
 
     @property
@@ -20,6 +21,7 @@ class BasePage(ABC, metaclass=CSS):  # no cov
         return self.CSS
 
     def render(self) -> str:
+        self.doc = Document(self.TITLE, lang="en", id="sanic")
         self._head()
         self._body()
         self._foot()
@@ -28,7 +30,7 @@ class BasePage(ABC, metaclass=CSS):  # no cov
     def _head(self) -> None:
         self.doc.style(HTML(self.style))
         with self.doc.header:
-            self.doc.div(self.TITLE)
+            self.doc.div(self.HEADING or self.TITLE)
 
     def _foot(self) -> None:
         with self.doc.footer:
@@ -37,6 +39,23 @@ class BasePage(ABC, metaclass=CSS):  # no cov
                 self._sanic_logo()
             if self.debug:
                 self.doc.div(f"Version {VERSION}")
+                with self.doc.div:
+                    for idx, (title, href) in enumerate(
+                        (
+                            ("Docs", "https://sanic.dev"),
+                            ("Help", "https://sanic.dev/en/help.html"),
+                            ("GitHub", "https://github.com/sanic-org/sanic"),
+                        )
+                    ):
+                        if idx > 0:
+                            self.doc(" | ")
+                        self.doc.a(
+                            title,
+                            href=href,
+                            target="_blank",
+                            referrerpolicy="no-referrer",
+                        )
+                self.doc.div("DEBUG mode")
 
     @abstractmethod
     def _body(self) -> None:
@@ -44,7 +63,7 @@ class BasePage(ABC, metaclass=CSS):  # no cov
 
     def _sanic_logo(self) -> None:
         self.doc.a(
-            HTML(SVG_LOGO),
+            HTML(SVG_LOGO_SIMPLE),
             href="https://sanic.dev",
             target="_blank",
             referrerpolicy="no-referrer",

sanic/pages/css.py

@@ -24,8 +24,8 @@ class CSS(ABCMeta):
     def __new__(cls, name, bases, attrs):
         Page = super().__new__(cls, name, bases, attrs)
         # Use a locally defined STYLE or the one from styles directory
-        s = _extract_style(attrs.get("STYLE"), name)
+        Page.STYLE = _extract_style(attrs.get("STYLE_FILE"), name)
-        Page.STYLE = f"\n/* {name} */\n{s.strip()}\n" if s else ""
+        Page.STYLE += attrs.get("STYLE_APPEND", "")
         # Combine with all ancestor styles
         Page.CSS = "".join(
             Class.STYLE

sanic/pages/error.py

@@ -0,0 +1,109 @@
+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.\
+"""
+
+
+class ErrorPage(BasePage):
+    STYLE_APPEND = tracerite.html.style
+
+    def __init__(
+        self,
+        debug: bool,
+        title: str,
+        text: str,
+        request: Request,
+        exc: Exception,
+    ) -> None:
+        super().__init__(debug)
+        name = request.app.name.replace("_", " ").strip()
+        if name.islower():
+            name = name.title()
+        self.TITLE = f"Application {name} cannot handle your request"
+        self.HEADING = E("Application ").strong(name)(
+            " cannot handle your request"
+        )
+        self.title = title
+        self.text = text
+        self.request = request
+        self.exc = exc
+        self.details_open = not getattr(exc, "quiet", False)
+
+    def _head(self) -> None:
+        self.doc._script(tracerite.html.javascript)
+        super()._head()
+
+    def _body(self) -> None:
+        debug = self.request.app.debug
+        route_name = self.request.name or "[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.details_open, 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:
+                    with self.doc.div(class_="exception-wrapper"):
+                        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:
+        with self.doc.div(class_="key-value-display"):
+            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
+                    )

sanic/pages/styles/BasePage.css

@@ -1,37 +1,93 @@
+/** BasePage **/
+
+:root {
+    --sanic: #ff0d68;
+    --sanic-yellow: #FFE900;
+    --sanic-background: #efeced;
+    --sanic-text: #121010;
+    --sanic-text-lighter: #756169;
+    --sanic-link: #ff0d68;
+    --sanic-block-background: #f7f4f6;
+    --sanic-block-text: #000;
+    --sanic-block-alt-text: #6b6468;
+    --sanic-header-background: #272325;
+    --sanic-header-border: #fff;
+    --sanic-header-text: #fff;
+    --sanic-highlight-background: var(--sanic-yellow);
+    --sanic-highlight-text: var(--sanic-text);
+    --sanic-tab-background: #f7f4f6;
+    --sanic-tab-shadow: #f7f6f6;
+    --sanic-tab-text: #222021;
+    --sanic-tracerite-var: var(--sanic-text);
+    --sanic-tracerite-val: #ff0d68;
+    --sanic-tracerite-type: #6d6a6b;
+}
+
+
+@media (prefers-color-scheme: dark) {
+    :root {
+        --sanic-text: #f7f4f6;
+        --sanic-background: #121010;
+        --sanic-block-background: #0f0d0e;
+        --sanic-block-text: #f7f4f6;
+        --sanic-header-background: #030203;
+        --sanic-header-border: #000;
+        --sanic-highlight-text: var(--sanic-background);
+        --sanic-tab-background: #292728;
+        --sanic-tab-shadow: #0f0d0e;
+        --sanic-tab-text: #aea7ab;
+    }
+}
+
 html {
     font: 16px sans-serif;
-    background: #eee;
+    background: var(--sanic-background);
-    color: #111;
+    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: 1200px) {
+@media (max-width: 1000px) {
     body>* {
         padding: 0.5rem 1.5vw;
     }
 
-    body {
+    html {
-        font-size: 1rem;
+        /* Scale everything by rem of 6px-16px by viewport width */
+        font-size: calc(6px + 10 * 100vw / 1000);
     }
 }
 
+main {
+    /* Make sure the footer is closer to bottom */
+    min-height: 70vh;
+    /* Generous padding for readability */
+    padding: 1rem 2.5rem;
+}
+
+.smalltext {
+    font-size: 1.0rem;
+}
+
 .container {
     min-width: 600px;
     max-width: 1600px;
 }
 
 header {
-    background: #111;
+    background: var(--sanic-header-background);
-    color: #e1e1e1;
+    color: var(--sanic-header-text);
-    border-bottom: 1px solid #272727;
+    border-bottom: 1px solid var(--sanic-header-border);
     text-align: center;
 }
 
@@ -40,20 +96,17 @@ footer {
     display: flex;
     flex-direction: column;
     font-size: 0.8rem;
-    margin-top: 2rem;
+    margin: 2rem;
+    line-height: 1.5em;
 }
 
 h1 {
     text-align: left;
 }
 
-a:visited {
-    color: inherit;
-}
-
 a {
     text-decoration: none;
-    color: #88f;
+    color: var(--sanic-link);
 }
 
 a:hover,
@@ -62,18 +115,32 @@ a:focus {
     outline: none;
 }
 
-#logo {
-    height: 1.75rem;
-    padding: 0 0.25rem;
-}
 
 span.icon {
     margin-right: 1rem;
 }
 
+#logo-simple {
+    height: 1.75rem;
+    padding: 0 0.25rem;
+}
+
+
 @media (prefers-color-scheme: dark) {
-    html {
+    #logo-simple path:last-child {
-        background: #111;
+        fill: #e1e1e1;
-        color: #ccc;
     }
 }
+
+#sanic pre,
+#sanic code {
+    font-family: "Fira Code",
+        "Source Code Pro",
+        Menlo,
+        Meslo,
+        Monaco,
+        Consolas,
+        Lucida Console,
+        monospace;
+    font-size: 0.8rem;
+}

sanic/pages/styles/DirectoryPage.css

@@ -1,3 +1,4 @@
+/** DirectoryPage **/
 #breadcrumbs>a:hover {
     text-decoration: none;
 }

sanic/pages/styles/ErrorPage.css

@@ -0,0 +1,108 @@
+/** 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-text-lighter);
+    cursor: pointer;
+}
+
+.tracerite {
+    --tracerite-var: var(--sanic-tracerite-var);
+    --tracerite-val: var(--sanic-tracerite-val);
+    --tracerite-type: var(--sanic-tracerite-type);
+    --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;
+}
+
+#sanic .tracerite .traceback-labels button {
+    font-size: 0.8rem;
+    line-height: 120%;
+    background: var(--tracerite-tab);
+    color: var(--tracerite-tab-text);
+    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));
+}
+
+#sanic .tracerite .tracerite-tooltip::before {
+    bottom: 1.75em;
+}
+
+#sanic .tracerite .traceback-details mark span {
+    background: var(--sanic-highlight-background);
+    color: var(--sanic-highlight-text);
+}
+
+header {
+    background: var(--sanic-header-background);
+}
+
+h2 {
+    font-size: 1.3rem;
+    color: var(--sanic-text);
+}
+
+.key-value-display,
+.exception-wrapper {
+    padding: 0.5rem;
+    margin-top: 1rem;
+}
+
+.key-value-display {
+    background-color: var(--sanic-block-background);
+    color: var(--sanic-block-text);
+}
+
+.key-value-display h2 {
+    margin-bottom: 0.2em;
+}
+
+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: var(--sanic-block-alt-text);
+    word-break: break-word;
+}
+
+dl.key-value-table dd {
+    /* Better breaking for cookies header and such */
+    word-break: break-all;
+}

sanic/request/__init__.py

@@ -0,0 +1,11 @@
+from .form import File, parse_multipart_form
+from .parameters import RequestParameters
+from .types import Request
+
+
+__all__ = (
+    "File",
+    "parse_multipart_form",
+    "Request",
+    "RequestParameters",
+)

sanic/request/form.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+import email.utils
+import unicodedata
+
+from typing import NamedTuple
+from urllib.parse import unquote
+
+from sanic.headers import parse_content_header
+from sanic.log import logger
+
+from .parameters import RequestParameters
+
+
+class File(NamedTuple):
+    """
+    Model for defining a file. It is a ``namedtuple``, therefore you can
+    iterate over the object, or access the parameters by name.
+
+    :param type: The mimetype, defaults to text/plain
+    :param body: Bytes of the file
+    :param name: The filename
+    """
+
+    type: str
+    body: bytes
+    name: str
+
+
+def parse_multipart_form(body, boundary):
+    """
+    Parse a request body and returns fields and files
+
+    :param body: bytes request body
+    :param boundary: bytes multipart boundary
+    :return: fields (RequestParameters), files (RequestParameters)
+    """
+    files = {}
+    fields = {}
+
+    form_parts = body.split(boundary)
+    for form_part in form_parts[1:-1]:
+        file_name = None
+        content_type = "text/plain"
+        content_charset = "utf-8"
+        field_name = None
+        line_index = 2
+        line_end_index = 0
+        while not line_end_index == -1:
+            line_end_index = form_part.find(b"\r\n", line_index)
+            form_line = form_part[line_index:line_end_index].decode("utf-8")
+            line_index = line_end_index + 2
+
+            if not form_line:
+                break
+
+            colon_index = form_line.index(":")
+            idx = colon_index + 2
+            form_header_field = form_line[0:colon_index].lower()
+            form_header_value, form_parameters = parse_content_header(
+                form_line[idx:]
+            )
+
+            if form_header_field == "content-disposition":
+                field_name = form_parameters.get("name")
+                file_name = form_parameters.get("filename")
+
+                # non-ASCII filenames in RFC2231, "filename*" format
+                if file_name is None and form_parameters.get("filename*"):
+                    encoding, _, value = email.utils.decode_rfc2231(
+                        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")
+
+        if field_name:
+            post_data = form_part[line_index:-4]
+            if file_name is None:
+                value = post_data.decode(content_charset)
+                if field_name in fields:
+                    fields[field_name].append(value)
+                else:
+                    fields[field_name] = [value]
+            else:
+                form_file = File(
+                    type=content_type, name=file_name, body=post_data
+                )
+                if field_name in files:
+                    files[field_name].append(form_file)
+                else:
+                    files[field_name] = [form_file]
+        else:
+            logger.debug(
+                "Form-data field does not have a 'name' parameter "
+                "in the Content-Disposition header"
+            )
+
+    return RequestParameters(fields), RequestParameters(files)

sanic/request/parameters.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+from typing import Any, Optional
+
+
+class RequestParameters(dict):
+    """
+    Hosts a dict with lists as values where get returns the first
+    value of the list and getlist returns the whole shebang
+    """
+
+    def get(self, name: str, default: Optional[Any] = None) -> Optional[Any]:
+        """Return the first value, either the default or actual"""
+        return super().get(name, [default])[0]
+
+    def getlist(
+        self, name: str, default: Optional[Any] = None
+    ) -> Optional[Any]:
+        """
+        Return the entire list
+        """
+        return super().get(name, default)

sanic/request/types.py

@@ -8,10 +8,10 @@ from typing import (
     DefaultDict,
     Dict,
     List,
-    NamedTuple,
     Optional,
     Tuple,
     Union,
+    cast,
 )
 
 from sanic_routing.route import Route
@@ -26,14 +26,11 @@ if TYPE_CHECKING:
     from sanic.server import ConnInfo
     from sanic.app import Sanic
 
-import email.utils
-import unicodedata
 import uuid
 
 from collections import defaultdict
-from http.cookies import SimpleCookie
 from types import SimpleNamespace
-from urllib.parse import parse_qs, parse_qsl, unquote, urlunparse
+from urllib.parse import parse_qs, parse_qsl, urlunparse
 
 from httptools import parse_url
 from httptools.parser.errors import HttpParserInvalidURLError
@@ -45,6 +42,7 @@ from sanic.constants import (
     IDEMPOTENT_HTTP_METHODS,
     SAFE_HTTP_METHODS,
 )
+from sanic.cookies.request import CookieRequestParameters, parse_cookie
 from sanic.exceptions import BadRequest, BadURL, ServerError
 from sanic.headers import (
     AcceptList,
@@ -57,10 +55,13 @@ from sanic.headers import (
     parse_xforwarded,
 )
 from sanic.http import Stage
-from sanic.log import deprecation, error_logger, logger
+from sanic.log import error_logger
 from sanic.models.protocol_types import TransportProtocol
 from sanic.response import BaseHTTPResponse, HTTPResponse
 
+from .form import parse_multipart_form
+from .parameters import RequestParameters
+
 
 try:
     from ujson import loads as json_loads  # type: ignore
@@ -68,25 +69,6 @@ except ImportError:
     from json import loads as json_loads  # type: ignore
 
 
-class RequestParameters(dict):
-    """
-    Hosts a dict with lists as values where get returns the first
-    value of the list and getlist returns the whole shebang
-    """
-
-    def get(self, name: str, default: Optional[Any] = None) -> Optional[Any]:
-        """Return the first value, either the default or actual"""
-        return super().get(name, [default])[0]
-
-    def getlist(
-        self, name: str, default: Optional[Any] = None
-    ) -> Optional[Any]:
-        """
-        Return the entire list
-        """
-        return super().get(name, default)
-
-
 class Request:
     """
     Properties of an HTTP request such as URL, headers, etc.
@@ -120,6 +102,7 @@ class Request:
         "method",
         "parsed_accept",
         "parsed_args",
+        "parsed_cookies",
         "parsed_credentials",
         "parsed_files",
         "parsed_form",
@@ -150,7 +133,8 @@ class Request:
         try:
             self._parsed_url = parse_url(url_bytes)
         except HttpParserInvalidURLError:
-            raise BadURL(f"Bad URL: {url_bytes.decode()}")
+            url = url_bytes.decode(errors="backslashreplace")
+            raise BadURL(f"Bad URL: {url}")
         self._id: Optional[Union[uuid.UUID, str, int]] = None
         self._name: Optional[str] = None
         self._stream_id = stream_id
@@ -166,25 +150,25 @@ class Request:
         self.body = b""
         self.conn_info: Optional[ConnInfo] = None
         self.ctx = SimpleNamespace()
-        self.parsed_forwarded: Optional[Options] = None
         self.parsed_accept: Optional[AcceptList] = None
-        self.parsed_credentials: Optional[Credentials] = None
-        self.parsed_json = None
-        self.parsed_form: Optional[RequestParameters] = None
-        self.parsed_files: Optional[RequestParameters] = None
-        self.parsed_token: Optional[str] = None
         self.parsed_args: DefaultDict[
             Tuple[bool, bool, str, str], RequestParameters
         ] = defaultdict(RequestParameters)
+        self.parsed_cookies: Optional[RequestParameters] = None
+        self.parsed_credentials: Optional[Credentials] = None
+        self.parsed_files: Optional[RequestParameters] = None
+        self.parsed_form: Optional[RequestParameters] = None
+        self.parsed_forwarded: Optional[Options] = None
+        self.parsed_json = None
         self.parsed_not_grouped_args: DefaultDict[
             Tuple[bool, bool, str, str], List[Tuple[str, str]]
         ] = defaultdict(list)
+        self.parsed_token: Optional[str] = None
         self._request_middleware_started = False
         self._response_middleware_started = False
         self.responded: bool = False
         self.route: Optional[Route] = None
         self.stream: Optional[Stream] = None
-        self._cookies: Optional[Dict[str, str]] = None
         self._match_info: Dict[str, Any] = {}
         self._protocol = None
 
@@ -221,16 +205,6 @@ class Request:
     def generate_id(*_):
         return uuid.uuid4()
 
-    @property
-    def request_middleware_started(self):
-        deprecation(
-            "Request.request_middleware_started has been deprecated and will"
-            "be removed. You should set a flag on the request context using"
-            "either middleware or signals if you need this feature.",
-            23.3,
-        )
-        return self._request_middleware_started
-
     @property
     def stream_id(self):
         """
@@ -500,13 +474,16 @@ class Request:
 
     @property
     def accept(self) -> AcceptList:
-        """
+        """Accepted response content types.
+
+        A convenience handler for easier RFC-compliant matching of MIME types,
+        parsed as a list that can match wildcards and includes */* by default.
+
         :return: The ``Accept`` header parsed
-        :rtype: AcceptContainer
+        :rtype: AcceptList
         """
         if self.parsed_accept is None:
-            accept_header = self.headers.getone("accept", "")
+            self.parsed_accept = parse_accept(self.headers.get("accept"))
-            self.parsed_accept = parse_accept(accept_header)
         return self.parsed_accept
 
     @property
@@ -728,24 +705,21 @@ class Request:
     default values.
     """
 
+    def get_cookies(self) -> RequestParameters:
+        cookie = self.headers.getone("cookie", "")
+        self.parsed_cookies = CookieRequestParameters(parse_cookie(cookie))
+        return self.parsed_cookies
+
     @property
-    def cookies(self) -> Dict[str, str]:
+    def cookies(self) -> RequestParameters:
         """
         :return: Incoming cookies on the request
         :rtype: Dict[str, str]
         """
 
-        if self._cookies is None:
+        if self.parsed_cookies is None:
-            cookie = self.headers.getone("cookie", None)
+            self.get_cookies()
-            if cookie is not None:
+        return cast(CookieRequestParameters, self.parsed_cookies)
-                cookies: SimpleCookie = SimpleCookie()
-                cookies.load(cookie)
-                self._cookies = {
-                    name: cookie.value for name, cookie in cookies.items()
-                }
-            else:
-                self._cookies = {}
-        return self._cookies
 
     @property
     def content_type(self) -> str:
@@ -1023,101 +997,3 @@ class Request:
         :rtype: bool
         """
         return self.method in CACHEABLE_HTTP_METHODS
-
-
-class File(NamedTuple):
-    """
-    Model for defining a file. It is a ``namedtuple``, therefore you can
-    iterate over the object, or access the parameters by name.
-
-    :param type: The mimetype, defaults to text/plain
-    :param body: Bytes of the file
-    :param name: The filename
-    """
-
-    type: str
-    body: bytes
-    name: str
-
-
-def parse_multipart_form(body, boundary):
-    """
-    Parse a request body and returns fields and files
-
-    :param body: bytes request body
-    :param boundary: bytes multipart boundary
-    :return: fields (RequestParameters), files (RequestParameters)
-    """
-    files = RequestParameters()
-    fields = RequestParameters()
-
-    form_parts = body.split(boundary)
-    for form_part in form_parts[1:-1]:
-        file_name = None
-        content_type = "text/plain"
-        content_charset = "utf-8"
-        field_name = None
-        line_index = 2
-        line_end_index = 0
-        while not line_end_index == -1:
-            line_end_index = form_part.find(b"\r\n", line_index)
-            form_line = form_part[line_index:line_end_index].decode("utf-8")
-            line_index = line_end_index + 2
-
-            if not form_line:
-                break
-
-            colon_index = form_line.index(":")
-            idx = colon_index + 2
-            form_header_field = form_line[0:colon_index].lower()
-            form_header_value, form_parameters = parse_content_header(
-                form_line[idx:]
-            )
-
-            if form_header_field == "content-disposition":
-                field_name = form_parameters.get("name")
-                file_name = form_parameters.get("filename")
-
-                # non-ASCII filenames in RFC2231, "filename*" format
-                if file_name is None and form_parameters.get("filename*"):
-                    encoding, _, value = email.utils.decode_rfc2231(
-                        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")
-
-        if field_name:
-            post_data = form_part[line_index:-4]
-            if file_name is None:
-                value = post_data.decode(content_charset)
-                if field_name in fields:
-                    fields[field_name].append(value)
-                else:
-                    fields[field_name] = [value]
-            else:
-                form_file = File(
-                    type=content_type, name=file_name, body=post_data
-                )
-                if field_name in files:
-                    files[field_name].append(form_file)
-                else:
-                    files[field_name] = [form_file]
-        else:
-            logger.debug(
-                "Form-data field does not have a 'name' parameter "
-                "in the Content-Disposition header"
-            )
-
-    return fields, files

sanic/response/convenience.py

@@ -148,7 +148,26 @@ async def validate_file(
         last_modified = datetime.fromtimestamp(
             float(last_modified), tz=timezone.utc
         ).replace(microsecond=0)
-    if last_modified <= if_modified_since:
+
+    if (
+        last_modified.utcoffset() is None
+        and if_modified_since.utcoffset() is not None
+    ):
+        logger.warning(
+            "Cannot compare tz-aware and tz-naive datetimes. To avoid "
+            "this conflict Sanic is converting last_modified to UTC."
+        )
+        last_modified.replace(tzinfo=timezone.utc)
+    elif (
+        last_modified.utcoffset() is not None
+        and if_modified_since.utcoffset() is None
+    ):
+        logger.warning(
+            "Cannot compare tz-aware and tz-naive datetimes. To avoid "
+            "this conflict Sanic is converting if_modified_since to UTC."
+        )
+        if_modified_since.replace(tzinfo=timezone.utc)
+    if last_modified.timestamp() <= if_modified_since.timestamp():
         return HTTPResponse(status=304)
 
 

sanic/response/types.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from datetime import datetime
 from functools import partial
 from typing import (
     TYPE_CHECKING,
@@ -17,6 +18,7 @@ from typing import (
 
 from sanic.compat import Header
 from sanic.cookies import CookieJar
+from sanic.cookies.response import Cookie, SameSite
 from sanic.exceptions import SanicException, ServerError
 from sanic.helpers import (
     Default,
@@ -158,6 +160,117 @@ class BaseHTTPResponse:
             end_stream=end_stream or False,
         )
 
+    def add_cookie(
+        self,
+        key: str,
+        value: str,
+        *,
+        path: str = "/",
+        domain: Optional[str] = None,
+        secure: bool = True,
+        max_age: Optional[int] = None,
+        expires: Optional[datetime] = None,
+        httponly: bool = False,
+        samesite: Optional[SameSite] = "Lax",
+        partitioned: bool = False,
+        comment: Optional[str] = None,
+        host_prefix: bool = False,
+        secure_prefix: bool = False,
+    ) -> Cookie:
+        """
+        Add a cookie to the CookieJar
+
+        :param key: Key of the cookie
+        :type key: str
+        :param value: Value of the cookie
+        :type value: str
+        :param path: Path of the cookie, defaults to None
+        :type path: Optional[str], optional
+        :param domain: Domain of the cookie, defaults to None
+        :type domain: Optional[str], optional
+        :param secure: Whether to set it as a secure cookie, defaults to True
+        :type secure: bool
+        :param max_age: Max age of the cookie in seconds; if set to 0 a
+            browser should delete it, defaults to None
+        :type max_age: Optional[int], optional
+        :param expires: When the cookie expires; if set to None browsers
+            should set it as a session cookie, defaults to None
+        :type expires: Optional[datetime], optional
+        :param httponly: Whether to set it as HTTP only, defaults to False
+        :type httponly: bool
+        :param samesite: How to set the samesite property, should be
+            strict, lax or none (case insensitive), defaults to Lax
+        :type samesite: Optional[SameSite], optional
+        :param partitioned: Whether to set it as partitioned, defaults to False
+        :type partitioned: bool
+        :param comment: A cookie comment, defaults to None
+        :type comment: Optional[str], optional
+        :param host_prefix: Whether to add __Host- as a prefix to the key.
+            This requires that path="/", domain=None, and secure=True,
+            defaults to False
+        :type host_prefix: bool
+        :param secure_prefix: Whether to add __Secure- as a prefix to the key.
+            This requires that secure=True, defaults to False
+        :type secure_prefix: bool
+        :return: The instance of the created cookie
+        :rtype: Cookie
+        """
+        return self.cookies.add_cookie(
+            key=key,
+            value=value,
+            path=path,
+            domain=domain,
+            secure=secure,
+            max_age=max_age,
+            expires=expires,
+            httponly=httponly,
+            samesite=samesite,
+            partitioned=partitioned,
+            comment=comment,
+            host_prefix=host_prefix,
+            secure_prefix=secure_prefix,
+        )
+
+    def delete_cookie(
+        self,
+        key: str,
+        *,
+        path: str = "/",
+        domain: Optional[str] = None,
+        host_prefix: bool = False,
+        secure_prefix: bool = False,
+    ) -> None:
+        """
+        Delete a cookie
+
+        This will effectively set it as Max-Age: 0, which a browser should
+        interpret it to mean: "delete the cookie".
+
+        Since it is a browser/client implementation, your results may vary
+        depending upon which client is being used.
+
+        :param key: The key to be deleted
+        :type key: str
+        :param path: Path of the cookie, defaults to None
+        :type path: Optional[str], optional
+        :param domain: Domain of the cookie, defaults to None
+        :type domain: Optional[str], optional
+        :param host_prefix: Whether to add __Host- as a prefix to the key.
+            This requires that path="/", domain=None, and secure=True,
+            defaults to False
+        :type host_prefix: bool
+        :param secure_prefix: Whether to add __Secure- as a prefix to the key.
+            This requires that secure=True, defaults to False
+        :type secure_prefix: bool
+        """
+        self.cookies.delete_cookie(
+            key=key,
+            path=path,
+            domain=domain,
+            host_prefix=host_prefix,
+            secure_prefix=secure_prefix,
+        )
+
 
 class HTTPResponse(BaseHTTPResponse):
     """
@@ -407,6 +520,8 @@ class ResponseStream:
         headers: Optional[Union[Header, Dict[str, str]]] = None,
         content_type: Optional[str] = None,
     ):
+        if not isinstance(headers, Header):
+            headers = Header(headers)
         self.streaming_fn = streaming_fn
         self.status = status
         self.headers = headers or Header()

sanic/router.py

@@ -39,13 +39,15 @@ 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,
+                allowed_methods=tuple(e.allowed_methods)
-            )
+                if e.allowed_methods
+                else None,
+            ) from None
 
     @lru_cache(maxsize=ROUTER_CACHE_SIZE)
     def get(  # type: ignore
@@ -61,6 +63,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
@@ -132,7 +135,16 @@ class Router(BaseRouter):
             if host:
                 params.update({"requirements": {"host": host}})
 
+            ident = name
+            if len(hosts) > 1:
+                ident = (
+                    f"{name}_{host.replace('.', '_')}"
+                    if name
+                    else "__unnamed__"
+                )
+
             route = super().add(**params)  # type: ignore
+            route.extra.ident = ident
             route.extra.ignore_body = ignore_body
             route.extra.stream = stream
             route.extra.hosts = hosts

sanic/server/__init__.py

@@ -2,7 +2,7 @@ from sanic.models.server_types import ConnInfo, Signal
 from sanic.server.async_server import AsyncioServer
 from sanic.server.loop import try_use_uvloop
 from sanic.server.protocols.http_protocol import HttpProtocol
-from sanic.server.runners import serve, serve_multiple, serve_single
+from sanic.server.runners import serve
 
 
 __all__ = (
@@ -11,7 +11,5 @@ __all__ = (
     "HttpProtocol",
     "Signal",
     "serve",
-    "serve_multiple",
-    "serve_single",
     "try_use_uvloop",
 )

sanic/server/legacy.py

@@ -1,123 +0,0 @@
-import itertools
-import os
-import signal
-import subprocess
-import sys
-
-from time import sleep
-
-
-def _iter_module_files():
-    """This iterates over all relevant Python files.
-    It goes through all
-    loaded files from modules, all files in folders of already loaded modules
-    as well as all files reachable through a package.
-    """
-    # The list call is necessary on Python 3 in case the module
-    # dictionary modifies during iteration.
-    for module in list(sys.modules.values()):
-        if module is None:
-            continue
-        filename = getattr(module, "__file__", None)
-        if filename:
-            old = None
-            while not os.path.isfile(filename):
-                old = filename
-                filename = os.path.dirname(filename)
-                if filename == old:
-                    break
-            else:
-                if filename[-4:] in (".pyc", ".pyo"):
-                    filename = filename[:-1]
-                yield filename
-
-
-def _get_args_for_reloading():
-    """Returns the executable."""
-    main_module = sys.modules["__main__"]
-    mod_spec = getattr(main_module, "__spec__", None)
-    if sys.argv[0] in ("", "-c"):
-        raise RuntimeError(
-            f"Autoreloader cannot work with argv[0]={sys.argv[0]!r}"
-        )
-    if mod_spec:
-        # Parent exe was launched as a module rather than a script
-        return [sys.executable, "-m", mod_spec.name] + sys.argv[1:]
-    return [sys.executable] + sys.argv
-
-
-def restart_with_reloader(changed=None):
-    """Create a new process and a subprocess in it with the same arguments as
-    this one.
-    """
-    reloaded = ",".join(changed) if changed else ""
-    return subprocess.Popen(  # nosec B603
-        _get_args_for_reloading(),
-        env={
-            **os.environ,
-            "SANIC_SERVER_RUNNING": "true",
-            "SANIC_RELOADER_PROCESS": "true",
-            "SANIC_RELOADED_FILES": reloaded,
-        },
-    )
-
-
-def _check_file(filename, mtimes):
-    need_reload = False
-
-    mtime = os.stat(filename).st_mtime
-    old_time = mtimes.get(filename)
-    if old_time is None:
-        mtimes[filename] = mtime
-    elif mtime > old_time:
-        mtimes[filename] = mtime
-        need_reload = True
-
-    return need_reload
-
-
-def watchdog(sleep_interval, reload_dirs):
-    """Watch project files, restart worker process if a change happened.
-    :param sleep_interval: interval in second.
-    :return: Nothing
-    """
-
-    def interrupt_self(*args):
-        raise KeyboardInterrupt
-
-    mtimes = {}
-    signal.signal(signal.SIGTERM, interrupt_self)
-    if os.name == "nt":
-        signal.signal(signal.SIGBREAK, interrupt_self)
-
-    worker_process = restart_with_reloader()
-
-    try:
-        while True:
-            changed = set()
-            for filename in itertools.chain(
-                _iter_module_files(),
-                *(d.glob("**/*") for d in reload_dirs),
-            ):
-                try:
-                    if _check_file(filename, mtimes):
-                        path = (
-                            filename
-                            if isinstance(filename, str)
-                            else filename.resolve()
-                        )
-                        changed.add(str(path))
-                except OSError:
-                    continue
-
-            if changed:
-                worker_process.terminate()
-                worker_process.wait()
-                worker_process = restart_with_reloader(changed)
-
-            sleep(sleep_interval)
-    except KeyboardInterrupt:
-        pass
-    finally:
-        worker_process.terminate()
-        worker_process.wait()

sanic/server/protocols/websocket_protocol.py

@@ -10,7 +10,7 @@ except ImportError:  # websockets >= 11.0
 
 from websockets.typing import Subprotocol
 
-from sanic.exceptions import ServerError
+from sanic.exceptions import SanicException
 from sanic.log import logger
 from sanic.server import HttpProtocol
 
@@ -123,7 +123,7 @@ class WebSocketProtocol(HttpProtocol):
                 "Failed to open a WebSocket connection.\n"
                 "See server log for more information.\n"
             )
-            raise ServerError(msg, status_code=500)
+            raise SanicException(msg, status_code=500)
         if 100 <= resp.status_code <= 299:
             first_line = (
                 f"HTTP/1.1 {resp.status_code} {resp.reason_phrase}\r\n"
@@ -138,7 +138,7 @@ class WebSocketProtocol(HttpProtocol):
                 rbody += b"\r\n\r\n"
             await super().send(rbody)
         else:
-            raise ServerError(resp.body, resp.status_code)
+            raise SanicException(resp.body, resp.status_code)
         self.websocket = WebsocketImplProtocol(
             ws_proto,
             ping_interval=self.websocket_ping_interval,

sanic/server/runners.py

@@ -9,19 +9,17 @@ from sanic.config import Config
 from sanic.exceptions import ServerError
 from sanic.http.constants import HTTP
 from sanic.http.tls import get_ssl_context
-from sanic.server.events import trigger_events
 
 
 if TYPE_CHECKING:
     from sanic.app import Sanic
 
 import asyncio
-import multiprocessing
 import os
 import socket
 
 from functools import partial
-from signal import SIG_IGN, SIGINT, SIGTERM, Signals
+from signal import SIG_IGN, SIGINT, SIGTERM
 from signal import signal as signal_func
 
 from sanic.application.ext import setup_ext
@@ -31,11 +29,7 @@ from sanic.log import error_logger, server_logger
 from sanic.models.server_types import Signal
 from sanic.server.async_server import AsyncioServer
 from sanic.server.protocols.http_protocol import Http3Protocol, HttpProtocol
-from sanic.server.socket import (
+from sanic.server.socket import bind_unix_socket, remove_unix_socket
-    bind_socket,
-    bind_unix_socket,
-    remove_unix_socket,
-)
 
 
 try:
@@ -319,94 +313,6 @@ def _serve_http_3(
     )
 
 
-def serve_single(server_settings):
-    main_start = server_settings.pop("main_start", None)
-    main_stop = server_settings.pop("main_stop", None)
-
-    if not server_settings.get("run_async"):
-        # create new event_loop after fork
-        loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(loop)
-        server_settings["loop"] = loop
-
-    trigger_events(main_start, server_settings["loop"])
-    serve(**server_settings)
-    trigger_events(main_stop, server_settings["loop"])
-
-    server_settings["loop"].close()
-
-
-def serve_multiple(server_settings, workers):
-    """Start multiple server processes simultaneously.  Stop on interrupt
-    and terminate signals, and drain connections when complete.
-
-    :param server_settings: kw arguments to be passed to the serve function
-    :param workers: number of workers to launch
-    :param stop_event: if provided, is used as a stop signal
-    :return:
-    """
-    server_settings["reuse_port"] = True
-    server_settings["run_multiple"] = True
-
-    main_start = server_settings.pop("main_start", None)
-    main_stop = server_settings.pop("main_stop", None)
-    loop = asyncio.new_event_loop()
-    asyncio.set_event_loop(loop)
-
-    trigger_events(main_start, loop)
-
-    # Create a listening socket or use the one in settings
-    sock = server_settings.get("sock")
-    unix = server_settings["unix"]
-    backlog = server_settings["backlog"]
-    if unix:
-        sock = bind_unix_socket(unix, backlog=backlog)
-        server_settings["unix"] = unix
-    if sock is None:
-        sock = bind_socket(
-            server_settings["host"], server_settings["port"], backlog=backlog
-        )
-        sock.set_inheritable(True)
-        server_settings["sock"] = sock
-        server_settings["host"] = None
-        server_settings["port"] = None
-
-    processes = []
-
-    def sig_handler(signal, frame):
-        server_logger.info(
-            "Received signal %s. Shutting down.", Signals(signal).name
-        )
-        for process in processes:
-            os.kill(process.pid, SIGTERM)
-
-    signal_func(SIGINT, lambda s, f: sig_handler(s, f))
-    signal_func(SIGTERM, lambda s, f: sig_handler(s, f))
-    mp = multiprocessing.get_context("fork")
-
-    for _ in range(workers):
-        process = mp.Process(
-            target=serve,
-            kwargs=server_settings,
-        )
-        process.daemon = True
-        process.start()
-        processes.append(process)
-
-    for process in processes:
-        process.join()
-
-    # the above processes will block this until they're stopped
-    for process in processes:
-        process.terminate()
-
-    trigger_events(main_stop, loop)
-
-    sock.close()
-    loop.close()
-    remove_unix_socket(unix)
-
-
 def _build_protocol_kwargs(
     protocol: Type[asyncio.Protocol], config: Config
 ) -> Dict[str, Union[int, float]]:

sanic/server/websockets/impl.py

@@ -29,7 +29,7 @@ except ImportError:  # websockets >= 11.0
 
 from websockets.typing import Data
 
-from sanic.log import deprecation, error_logger, logger
+from sanic.log import error_logger, logger
 from sanic.server.protocols.base_protocol import SanicProtocol
 
 from ...exceptions import ServerError, WebsocketClosed
@@ -99,15 +99,6 @@ class WebsocketImplProtocol:
     def subprotocol(self):
         return self.ws_proto.subprotocol
 
-    @property
-    def connection(self):
-        deprecation(
-            "The connection property has been deprecated and will be removed. "
-            "Please use the ws_proto property instead going forward.",
-            22.6,
-        )
-        return self.ws_proto
-
     def pause_frames(self):
         if not self.can_pause:
             return False

sanic/worker/loader.py

@@ -3,8 +3,11 @@ from __future__ import annotations
 import os
 import sys
 
+from contextlib import suppress
 from importlib import import_module
+from inspect import isfunction
 from pathlib import Path
+from ssl import SSLContext
 from typing import TYPE_CHECKING, Any, Callable, Dict, Optional, Union, cast
 
 from sanic.http.tls.context import process_to_context
@@ -14,6 +17,8 @@ from sanic.http.tls.creators import MkcertCreator, TrustmeCreator
 if TYPE_CHECKING:
     from sanic import Sanic as SanicApp
 
+DEFAULT_APP_NAME = "app"
+
 
 class AppLoader:
     def __init__(
@@ -35,7 +40,11 @@ class AppLoader:
 
         if module_input:
             delimiter = ":" if ":" in module_input else "."
-            if module_input.count(delimiter):
+            if (
+                delimiter in module_input
+                and "\\" not in module_input
+                and "/" not in module_input
+            ):
                 module_name, app_name = module_input.rsplit(delimiter, 1)
                 self.module_name = module_name
                 self.app_name = app_name
@@ -54,21 +63,30 @@ class AppLoader:
             from sanic.app import Sanic
             from sanic.simple import create_simple_server
 
-            if self.as_simple:
+            maybe_path = Path(self.module_input)
-                path = Path(self.module_input)
+            if self.as_simple or (
-                app = create_simple_server(path)
+                maybe_path.is_dir()
+                and ("\\" in self.module_input or "/" in self.module_input)
+            ):
+                app = create_simple_server(maybe_path)
             else:
-                if self.module_name == "" and os.path.isdir(self.module_input):
+                implied_app_name = False
-                    raise ValueError(
+                if not self.module_name and not self.app_name:
-                        "App not found.\n"
+                    self.module_name = self.module_input
-                        "   Please use --simple if you are passing a "
+                    self.app_name = DEFAULT_APP_NAME
-                        "directory to sanic.\n"
+                    implied_app_name = True
-                        f"   eg. sanic {self.module_input} --simple"
-                    )
-
                 module = import_module(self.module_name)
                 app = getattr(module, self.app_name, None)
-                if self.as_factory:
+                if not app and implied_app_name:
+                    raise ValueError(
+                        "Looks like you only supplied a module name. Sanic "
+                        "tried to locate an application instance named "
+                        f"{self.module_name}:app, but was unable to locate "
+                        "an application instance. Please provide a path "
+                        "to a global instance of Sanic(), or a callable that "
+                        "will return a Sanic() application instance."
+                    )
+                if self.as_factory or isfunction(app):
                     try:
                         app = app(self.args)
                     except TypeError:
@@ -79,21 +97,18 @@ class AppLoader:
                 if (
                     not isinstance(app, Sanic)
                     and self.args
-                    and hasattr(self.args, "module")
+                    and hasattr(self.args, "target")
                 ):
-                    if callable(app):
+                    with suppress(ModuleNotFoundError):
-                        solution = f"sanic {self.args.module} --factory"
+                        maybe_module = import_module(self.module_input)
-                        raise ValueError(
+                        app = getattr(maybe_module, "app", None)
-                            "Module is not a Sanic app, it is a "
+                    if not app:
-                            f"{app_type_name}\n"
+                        message = (
-                            "  If this callable returns a "
+                            "Module is not a Sanic app, "
-                            f"Sanic instance try: \n{solution}"
+                            f"it is a {app_type_name}\n"
+                            f"  Perhaps you meant {self.args.target}:app?"
                         )
-
+                        raise ValueError(message)
-                    raise ValueError(
-                        f"Module is not a Sanic app, it is a {app_type_name}\n"
-                        f"  Perhaps you meant {self.args.module}:app?"
-                    )
         return app
 
 
@@ -103,8 +118,16 @@ class CertLoader:
         "trustme": TrustmeCreator,
     }
 
-    def __init__(self, ssl_data: Dict[str, Union[str, os.PathLike]]):
+    def __init__(
+        self,
+        ssl_data: Optional[
+            Union[SSLContext, Dict[str, Union[str, os.PathLike]]]
+        ],
+    ):
         self._ssl_data = ssl_data
+        self._creator_class = None
+        if not ssl_data or not isinstance(ssl_data, dict):
+            return
 
         creator_name = cast(str, ssl_data.get("creator"))
 

sanic/worker/manager.py

@@ -5,7 +5,7 @@ from itertools import count
 from random import choice
 from signal import SIGINT, SIGTERM, Signals
 from signal import signal as signal_func
-from typing import Dict, List, Optional
+from typing import Any, Callable, Dict, List, Optional
 
 from sanic.compat import OS_IS_WINDOWS
 from sanic.exceptions import ServerKilled
@@ -54,9 +54,36 @@ class WorkerManager:
         signal_func(SIGINT, self.shutdown_signal)
         signal_func(SIGTERM, self.shutdown_signal)
 
-    def manage(self, ident, func, kwargs, transient=False) -> Worker:
+    def manage(
+        self,
+        ident: str,
+        func: Callable[..., Any],
+        kwargs: Dict[str, Any],
+        transient: bool = False,
+        workers: int = 1,
+    ) -> Worker:
+        """
+        Instruct Sanic to manage a custom process.
+
+        :param ident: A name for the worker process
+        :type ident: str
+        :param func: The function to call in the background process
+        :type func: Callable[..., Any]
+        :param kwargs: Arguments to pass to the function
+        :type kwargs: Dict[str, Any]
+        :param transient: Whether to mark the process as transient. If True
+            then the Worker Manager will restart the process along
+            with any global restart (ex: auto-reload), defaults to False
+        :type transient: bool, optional
+        :param workers: The number of worker processes to run, defaults to 1
+        :type workers: int, optional
+        :return: The Worker instance
+        :rtype: Worker
+        """
         container = self.transient if transient else self.durable
-        worker = Worker(ident, func, kwargs, self.context, self.worker_state)
+        worker = Worker(
+            ident, func, kwargs, self.context, self.worker_state, workers
+        )
         container[worker.ident] = worker
         return worker
 
@@ -285,6 +312,10 @@ class WorkerManager:
 
     def _sync_states(self):
         for process in self.processes:
-            state = self.worker_state[process.name].get("state")
+            try:
+                state = self.worker_state[process.name].get("state")
+            except KeyError:
+                process.set_state(ProcessState.TERMINATED, True)
+                continue
             if state and process.state.name != state:
                 process.set_state(ProcessState[state], True)

sanic/worker/process.py

@@ -192,14 +192,17 @@ class Worker:
         server_settings,
         context: BaseContext,
         worker_state: Dict[str, Any],
+        num: int = 1,
     ):
         self.ident = ident
+        self.num = num
         self.context = context
         self.serve = serve
         self.server_settings = server_settings
         self.worker_state = worker_state
         self.processes: Set[WorkerProcess] = set()
-        self.create_process()
+        for _ in range(num):
+            self.create_process()
 
     def create_process(self) -> WorkerProcess:
         process = WorkerProcess(

sanic/worker/serve.py

@@ -73,8 +73,8 @@ def worker_serve(
                             info.settings["app"] = a
                         a.state.server_info.append(info)
 
-        if isinstance(ssl, dict):
+        if isinstance(ssl, dict) or app.certloader_class is not CertLoader:
-            cert_loader = CertLoader(ssl)
+            cert_loader = app.certloader_class(ssl or {})
             ssl = cert_loader.load(app)
             for info in app.state.server_info:
                 info.settings["ssl"] = ssl

setup.py

@@ -112,10 +112,11 @@ requirements = [
     "websockets>=10.0",
     "multidict>=5.0,<7.0",
     "html5tagger>=1.2.1",
+    "tracerite>=1.0.0",
 ]
 
 tests_require = [
-    "sanic-testing>=22.9.0",
+    "sanic-testing>=23.3.0",
     "pytest==7.1.*",
     "coverage",
     "beautifulsoup4",

tests/certs/password/fullchain.pem

@@ -0,0 +1,19 @@
+-----BEGIN CERTIFICATE-----
+MIIDCTCCAfGgAwIBAgIUa7OOlAGQfXOgUgRENJ9GbUgO7kwwDQYJKoZIhvcNAQEL
+BQAwFDESMBAGA1UEAwwJMTI3LjAuMC4xMB4XDTIzMDMyMDA3MzE1M1oXDTIzMDQx
+OTA3MzE1M1owFDESMBAGA1UEAwwJMTI3LjAuMC4xMIIBIjANBgkqhkiG9w0BAQEF
+AAOCAQ8AMIIBCgKCAQEAn2/RqVpzO7GFrgVGiowR5CzcFzf1tSFti1K/WIGr/jsu
+NP+1R3sim17pgg6SCOFnUMRS0KnDihkzoeP6z+0tFsrbCH4V1+fq0iud8WgYQrgD
+3ttUcHrz04p7wsMoeqndUQoLbyJzP8MpA2XJsoacdIVkuLv2AESGXLhJym/e9HGN
+g8bqdz25X0hVTczZW1FN9AZyWWVf9Go6jqC7LCaOnYXAnOkEy2/JHdkeNXYFZHB3
+71UemfkCjfp0vlRV8pVpkBGMhRNFphBTfxdqeWiGQwVqrhaJO4M7DJlQHCAPY16P
+o9ywnhLDhFHD7KIfTih9XxrdgTowqcwyGX3e3aJpTwIDAQABo1MwUTAdBgNVHQ4E
+FgQU5NogMq6mRBeGl4i6hIuUlcR2bVEwHwYDVR0jBBgwFoAU5NogMq6mRBeGl4i6
+hIuUlcR2bVEwDwYDVR0TAQH/BAUwAwEB/zANBgkqhkiG9w0BAQsFAAOCAQEAYW34
+JY1kd0UO5HE41oxJD4PioQboXXX0al4RgKaUUsPykeHQbK0q0TSYAZLwRjooTVUO
+Wvna5bU2mzyULqA2r/Cr/w4zb9xybO3SiHFHcU1RacouauHXROHwRm98i8A73xnH
+vHws5BADr2ggnVcPNh4VOQ9ZvBlC7jhgpvMjqOEu5ZPCovhfZYfSsvBDHcD74ZYm
+Di9DvqsJmrb23Dv3SUykm3W+Ql2q+JyjFj30rhD89CFwJ9iSlFwTYEwZLHA+mV6p
+UKy3I3Fiht1Oc+nIivX5uhRSMbDVvDTVHbjjPujxxFjkiHXMjtwvwfg4Sb6du61q
+AjBRFyXbNu4hZkkHOA==
+-----END CERTIFICATE-----

tests/certs/password/privkey.pem

@@ -0,0 +1,30 @@
+-----BEGIN ENCRYPTED PRIVATE KEY-----
+MIIFLTBXBgkqhkiG9w0BBQ0wSjApBgkqhkiG9w0BBQwwHAQI94UBqjaZlG4CAggA
+MAwGCCqGSIb3DQIJBQAwHQYJYIZIAWUDBAEqBBCvJhEy+3/+0Ec0gpd5dkP6BIIE
+0E7rLplTe9rxK3sR9V0cx8Xn6V+uFhG3p7dzeMDCCKpGo9MEaacF5m+paGnBkMlH
+Pz3rRoLA5jqzwXl4US/C5E1Or//2YBgF1XXKi3BPF/bVx/g6vR+xeobf9kQGbqQk
+FNPYtP7mpg2dekp5BUsKSosIt8BkknWFvhBeNuGZT/zlMUuq1WpMe4KIh/W9IdNr
+HolcuZJWBhQAwGPciWIZRyq48wKa++W7Jdg/aG8FviJQnjaAUv4CyZJHUJnaNwUx
+iHOETpzIC+bhF2K+s4g5w68VCj6Jtz78sIBEZKzo7LI5QHdRHqYB5SJ/dGiV+h09
+R/rQ/M+24mwHDlRSCxxq0yuDwUuGBlHyATeDCFeE3L5OX8yTLuqYJ6vUa6UbzMYA
+8H4l5zfu9RrAhKYa9tD+4ONxMmHziIgmn5zvSXeBwJKfeUbnN4IKWLsSoSVspBRh
+zLl51DMAnem4NEjLfIW8WYjhsvSYwd9BYqxXaAiv4Wjx9ZV1yLqFICC7tejpVdRT
+afI0qMOfWu4ma6xVBg1ezLgF1wHIPrq6euTvWdnifYQopVICALlltEo5oxQ2i/OM
+NY8RyovWujiGNsa3pId9HmZXiLyLXjKPstGWRK4liMyc2EiP099gTdBvrb+VQp+I
+EyPavmh3WNhgZGOh3qah39X8HrBprc0PPfSPlxpaWdNMIIMSbcIWWdJEA/e4tcy/
+uBaV4H3sNCtBApgrb6B9YUbS9CXNUburJo19T1sk2uCaO12qYfdu2IDEnFf8JiF3
+i7nyftotRuoKq2D+V8d0PeMi/vJSo6+eZIn7VNe6ejYf+w0s7sxlpiKVzkslyOhq
+n0T4M3ZkSwGIETzgkRRuTY1OK7slhglMgXlQ2FuIUUo6CRg9WjRJvI5rujLzLWfB
+hkgP8STirjTV0DUWPFGtUcenvEcZPkYIQcoPHxOJGNW3ZPXNpt4RjbvPLeVzDm0O
+WJiay/qhag/bXGqKraO3b6Y7FOzJa8kG4G0XrcFY1s2oCXRqRqYJAtwaEeVCjCSJ
+Qy0OZkqcJEU7pv98pLMpG9OWz4Gle77g4KoQUJjQGtmg0MUMoPd0iPRmvkxsYg8E
+Q9uZS3m6PpWmmYDY0Ik1w/4avs3skl2mW3dqcZGLEepkjiQSnFABsuvxKd+uIEQy
+lyf9FrynXVcUI87LUkuniLRKwZZzFALVuc+BwtO3SA5mvEK22ZEq9QOysbwlpN54
+G5xXJKJEeexUSjEUIij4J89RLsXldibhp7YYZ7rFviR6chIqC0V7G6VqAM9TOCrV
+PWZXr3ZY5/pCZYs5DYKFJBFMSQ2UT/++VYxdZCeBH75vaxugbS8RdUM+iVDevWpQ
+/AnP1FolNAgkVhi3Rw4L16SibkqpEzIi1svPWKMwXdvewA32UidLElhuTWWjI2Wm
+veXhmEqwk/7ML4JMI7wHcDQdvSKen0mCL2J9tB7A/pewYyDE0ffIUmjxglOtw30f
+ZOlQKhMaKJGXp00U2zsHA2NJRI/hThbJncsnZyvuLei0P42RrF+r64b/0gUH6IZ5
+wPUttT815KSNoy+XXXum9YGDYYFoAL+6WVEkl6dgo+X0hcH7DDf5Nkewiq8UcJGh
+/69vFIfp+JlpicXzZ+R42LO3T3luC907aFBywF3pmi//
+-----END ENCRYPTED PRIVATE KEY-----

tests/fake/server.py

@@ -49,6 +49,6 @@ def create_app_with_args(args):
     try:
         logger.info(f"foo={args.foo}")
     except AttributeError:
-        logger.info(f"module={args.module}")
+        logger.info(f"target={args.target}")
 
     return app

tests/http3/test_http_receiver.py

@@ -11,7 +11,7 @@ from aioquic.quic.events import ProtocolNegotiated
 from sanic import Request, Sanic
 from sanic.compat import Header
 from sanic.config import DEFAULT_CONFIG
-from sanic.exceptions import PayloadTooLarge
+from sanic.exceptions import BadRequest, PayloadTooLarge
 from sanic.http.constants import Stage
 from sanic.http.http3 import Http3, HTTPReceiver
 from sanic.models.server_types import ConnInfo
@@ -292,3 +292,48 @@ def test_request_conn_info(app):
     receiver = http3.get_receiver_by_stream_id(1)
 
     assert isinstance(receiver.request.conn_info, ConnInfo)
+
+
+def test_request_header_encoding(app):
+    protocol = generate_protocol(app)
+    http3 = Http3(protocol, protocol.transmit)
+    with pytest.raises(BadRequest) as exc_info:
+        http3.http_event_received(
+            HeadersReceived(
+                [
+                    (b":method", b"GET"),
+                    (b":path", b"/location"),
+                    (b":scheme", b"https"),
+                    (b":authority", b"localhost:8443"),
+                    ("foo\u00A0".encode(), b"bar"),
+                ],
+                1,
+                False,
+            )
+        )
+    assert exc_info.value.status_code == 400
+    assert (
+        str(exc_info.value)
+        == "Header names may only contain US-ASCII characters."
+    )
+
+
+def test_request_url_encoding(app):
+    protocol = generate_protocol(app)
+    http3 = Http3(protocol, protocol.transmit)
+    with pytest.raises(BadRequest) as exc_info:
+        http3.http_event_received(
+            HeadersReceived(
+                [
+                    (b":method", b"GET"),
+                    (b":path", b"/location\xA0"),
+                    (b":scheme", b"https"),
+                    (b":authority", b"localhost:8443"),
+                    (b"foo", b"bar"),
+                ],
+                1,
+                False,
+            )
+        )
+    assert exc_info.value.status_code == 400
+    assert str(exc_info.value) == "URL may only contain US-ASCII characters."

tests/test_app.py

@@ -448,7 +448,7 @@ def test_custom_context():
 
 @pytest.mark.parametrize("use", (False, True))
 def test_uvloop_config(app: Sanic, monkeypatch, use):
-    @app.get("/test")
+    @app.get("/test", name="test")
     def handler(request):
         return text("ok")
 
@@ -571,21 +571,6 @@ def test_cannot_run_single_process_and_workers_or_auto_reload(
         app.run(single_process=True, **extra)
 
 
-def test_cannot_run_single_process_and_legacy(app: Sanic):
-    message = "Cannot run single process and legacy mode"
-    with pytest.raises(RuntimeError, match=message):
-        app.run(single_process=True, legacy=True)
-
-
-def test_cannot_run_without_sys_signals_with_workers(app: Sanic):
-    message = (
-        "Cannot run Sanic.serve with register_sys_signals=False. "
-        "Use either Sanic.serve_single or Sanic.serve_legacy."
-    )
-    with pytest.raises(RuntimeError, match=message):
-        app.run(register_sys_signals=False, single_process=False, legacy=False)
-
-
 def test_default_configure_logging():
     with patch("sanic.app.logging") as mock:
         Sanic("Test")

tests/test_asgi.py

@@ -2,13 +2,17 @@ import asyncio
 import logging
 
 from collections import deque, namedtuple
+from unittest.mock import call
 
 import pytest
 import uvicorn
 
+from httpx import Headers
+from pytest import MonkeyPatch
+
 from sanic import Sanic
 from sanic.application.state import Mode
-from sanic.asgi import ASGIApp, MockTransport
+from sanic.asgi import ASGIApp, Lifespan, MockTransport
 from sanic.exceptions import BadRequest, Forbidden, ServiceUnavailable
 from sanic.request import Request
 from sanic.response import json, text
@@ -116,10 +120,6 @@ def test_listeners_triggered(caplog):
         stop_message,
     ) not in caplog.record_tuples
 
-    all_tasks = asyncio.all_tasks(asyncio.get_event_loop())
-    for task in all_tasks:
-        task.cancel()
-
     assert before_server_start
     assert after_server_start
     assert before_server_stop
@@ -218,10 +218,6 @@ def test_listeners_triggered_async(app, caplog):
         stop_message,
     ) not in caplog.record_tuples
 
-    all_tasks = asyncio.all_tasks(asyncio.get_event_loop())
-    for task in all_tasks:
-        task.cancel()
-
     assert before_server_start
     assert after_server_start
     assert before_server_stop
@@ -272,10 +268,6 @@ def test_non_default_uvloop_config_raises_warning(app):
     with pytest.warns(UserWarning) as records:
         server.run()
 
-    all_tasks = asyncio.all_tasks(asyncio.get_event_loop())
-    for task in all_tasks:
-        task.cancel()
-
     msg = ""
     for record in records:
         _msg = str(record.message)
@@ -351,6 +343,7 @@ async def test_websocket_text_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"}
@@ -361,6 +354,7 @@ async def test_websocket_bytes_receive(send, receive, message_stack):
 
     assert data == msg["bytes"]
 
+
 @pytest.mark.asyncio
 async def test_websocket_accept_with_no_subprotocols(
     send, receive, message_stack
@@ -581,15 +575,28 @@ async def test_error_on_lifespan_exception_start(app, caplog):
     async def before_server_start(_):
         1 / 0
 
-    recv = AsyncMock(return_value={"type": "lifespan.startup"})
+    recv = AsyncMock(
+        side_effect=[
+            {"type": "lifespan.startup"},
+            {"type": "lifespan.shutdown"},
+        ]
+    )
     send = AsyncMock()
     app.asgi = True
 
+    lifespan = Lifespan(app, {"type": "lifespan"}, recv, send)
     with caplog.at_level(logging.ERROR):
-        await ASGIApp.create(app, {"type": "lifespan"}, recv, send)
+        await lifespan()
 
-    send.assert_awaited_once_with(
+    send.assert_has_calls(
-        {"type": "lifespan.startup.failed", "message": "division by zero"}
+        [
+            call(
+                {
+                    "type": "lifespan.startup.failed",
+                    "message": "division by zero",
+                }
+            )
+        ]
     )
 
 
@@ -599,13 +606,63 @@ async def test_error_on_lifespan_exception_stop(app: Sanic):
     async def before_server_stop(_):
         1 / 0
 
-    recv = AsyncMock(return_value={"type": "lifespan.shutdown"})
+    recv = AsyncMock(
+        side_effect=[
+            {"type": "lifespan.startup"},
+            {"type": "lifespan.shutdown"},
+        ]
+    )
     send = AsyncMock()
     app.asgi = True
     await app._startup()
 
-    await ASGIApp.create(app, {"type": "lifespan"}, recv, send)
+    lifespan = Lifespan(app, {"type": "lifespan"}, recv, send)
+    await lifespan()
 
-    send.assert_awaited_once_with(
+    send.assert_has_calls(
-        {"type": "lifespan.shutdown.failed", "message": "division by zero"}
+        [
+            call(
+                {
+                    "type": "lifespan.shutdown.failed",
+                    "message": "division by zero",
+                }
+            )
+        ]
     )
+
+
+@pytest.mark.asyncio
+async def test_asgi_headers_decoding(app: Sanic, monkeypatch: MonkeyPatch):
+    @app.get("/")
+    def handler(request: Request):
+        return text("")
+
+    headers_init = Headers.__init__
+
+    def mocked_headers_init(self, *args, **kwargs):
+        if "encoding" in kwargs:
+            kwargs.pop("encoding")
+        headers_init(self, encoding="utf-8", *args, **kwargs)
+
+    monkeypatch.setattr(Headers, "__init__", mocked_headers_init)
+
+    message = "Header names can only contain US-ASCII characters"
+    with pytest.raises(BadRequest, match=message):
+        _, response = await app.asgi_client.get("/", headers={"😂": "😅"})
+
+    _, response = await app.asgi_client.get("/", headers={"Test-Header": "😅"})
+    assert response.status_code == 200
+
+
+@pytest.mark.asyncio
+async def test_asgi_url_decoding(app):
+    @app.get("/dir/<name>", unquote=True)
+    def _request(request: Request, name):
+        return text(name)
+
+    # 2F should not become a path separator (unquoted later)
+    _, response = await app.asgi_client.get("/dir/some%2Fpath")
+    assert response.text == "some/path"
+
+    _, response = await app.asgi_client.get("/dir/some%F0%9F%98%80path")
+    assert response.text == "some😀path"

tests/test_blueprint_copy.py

@@ -66,3 +66,11 @@ def test_bp_copy(app: Sanic):
 
     _, response = app.test_client.get("/version6/page")
     assert "Hello world!" in response.text
+
+    route_names = [route.name for route in app.router.routes]
+    assert "test_bp_copy.test_bp1.handle_request" in route_names
+    assert "test_bp_copy.test_bp2.handle_request" in route_names
+    assert "test_bp_copy.test_bp3.handle_request" in route_names
+    assert "test_bp_copy.test_bp4.handle_request" in route_names
+    assert "test_bp_copy.test_bp5.handle_request" in route_names
+    assert "test_bp_copy.test_bp6.handle_request" in route_names

tests/test_blueprints.py

@@ -303,6 +303,10 @@ def test_bp_with_host_list(app: Sanic):
 
     assert response.text == "Hello subdomain!"
 
+    route_names = [r.name for r in app.router.routes]
+    assert "test_bp_with_host_list.test_bp_host.handler1" in route_names
+    assert "test_bp_with_host_list.test_bp_host.handler2" in route_names
+
 
 def test_several_bp_with_host_list(app: Sanic):
     bp = Blueprint(

tests/test_cli.py

@@ -43,8 +43,10 @@ def read_app_info(lines: List[str]):
     "appname,extra",
     (
         ("fake.server.app", None),
+        ("fake.server", None),
         ("fake.server:create_app", "--factory"),
         ("fake.server.create_app()", None),
+        ("fake.server.create_app", None),
     ),
 )
 def test_server_run(
@@ -60,14 +62,17 @@ def test_server_run(
     assert "Goin' Fast @ http://127.0.0.1:8000" in lines
 
 
-def test_server_run_factory_with_args(caplog):
+@pytest.mark.parametrize(
-    command = [
+    "command",
-        "fake.server.create_app_with_args",
+    (
-        "--factory",
+        ["fake.server.create_app_with_args", "--factory"],
-    ]
+        ["fake.server.create_app_with_args"],
+    ),
+)
+def test_server_run_factory_with_args(caplog, command):
     lines = capture(command, caplog)
 
-    assert "module=fake.server.create_app_with_args" in lines
+    assert "target=fake.server.create_app_with_args" in lines
 
 
 def test_server_run_factory_with_args_arbitrary(caplog):
@@ -81,25 +86,6 @@ def test_server_run_factory_with_args_arbitrary(caplog):
     assert "foo=bar" in lines
 
 
-def test_error_with_function_as_instance_without_factory_arg(caplog):
-    command = ["fake.server.create_app"]
-    lines = capture(command, caplog)
-    assert (
-        "Failed to run app: Module is not a Sanic app, it is a function\n  "
-        "If this callable returns a Sanic instance try: \n"
-        "sanic fake.server.create_app --factory"
-    ) in lines
-
-
-def test_error_with_path_as_instance_without_simple_arg(caplog):
-    command = ["./fake/"]
-    lines = capture(command, caplog)
-    assert (
-        "Failed to run app: App not found.\n   Please use --simple if you "
-        "are passing a directory to sanic.\n   eg. sanic ./fake/ --simple"
-    ) in lines
-
-
 @pytest.mark.parametrize(
     "cmd",
     (

tests/test_cookies.py

@@ -1,11 +1,16 @@
 from datetime import datetime, timedelta
 from http.cookies import SimpleCookie
+from unittest.mock import Mock
 
 import pytest
 
-from sanic import Sanic
+from sanic import Request, Sanic
-from sanic.cookies import Cookie
+from sanic.compat import Header
+from sanic.cookies import Cookie, CookieJar
+from sanic.cookies.request import CookieRequestParameters
+from sanic.exceptions import ServerError
 from sanic.response import text
+from sanic.response.convenience import json
 
 
 # ------------------------------------------------------------ #
@@ -111,21 +116,23 @@ def test_cookie_options(app):
 
 
 def test_cookie_deletion(app):
+    cookie_jar = None
+
     @app.route("/")
     def handler(request):
+        nonlocal cookie_jar
         response = text("OK")
-        del response.cookies["i_want_to_die"]
+        del response.cookies["one"]
-        response.cookies["i_never_existed"] = "testing"
+        response.cookies["two"] = "testing"
-        del response.cookies["i_never_existed"]
+        del response.cookies["two"]
+        cookie_jar = response.cookies
         return response
 
-    request, response = app.test_client.get("/")
+    _, response = app.test_client.get("/")
-    response_cookies = SimpleCookie()
-    response_cookies.load(response.headers.get("Set-Cookie", {}))
 
-    assert int(response_cookies["i_want_to_die"]["max-age"]) == 0
+    assert cookie_jar.get_cookie("one").max_age == 0
-    with pytest.raises(KeyError):
+    assert cookie_jar.get_cookie("two").max_age == 0
-        response.cookies["i_never_existed"]
+    assert len(response.cookies) == 0
 
 
 def test_cookie_reserved_cookie():
@@ -252,3 +259,262 @@ def test_cookie_expires_illegal_instance_type(expires):
     with pytest.raises(expected_exception=TypeError) as e:
         c["expires"] = expires
         assert e.message == "Cookie 'expires' property must be a datetime"
+
+
+@pytest.mark.parametrize("value", ("foo=one; foo=two", "foo=one;foo=two"))
+def test_request_with_duplicate_cookie_key(value):
+    headers = Header({"Cookie": value})
+    request = Request(b"/", headers, "1.1", "GET", Mock(), Mock())
+
+    assert request.cookies["foo"] == "one"
+    assert request.cookies.get("foo") == "one"
+    assert request.cookies.getlist("foo") == ["one", "two"]
+    assert request.cookies.get("bar") is None
+
+
+def test_cookie_jar_cookies():
+    headers = Header()
+    jar = CookieJar(headers)
+    jar.add_cookie("foo", "one")
+    jar.add_cookie("foo", "two", domain="example.com")
+
+    assert len(jar.cookies) == 2
+    assert len(headers) == 2
+
+
+def test_cookie_jar_has_cookie():
+    headers = Header()
+    jar = CookieJar(headers)
+    jar.add_cookie("foo", "one")
+    jar.add_cookie("foo", "two", domain="example.com")
+
+    assert jar.has_cookie("foo")
+    assert jar.has_cookie("foo", domain="example.com")
+    assert not jar.has_cookie("foo", path="/unknown")
+    assert not jar.has_cookie("bar")
+
+
+def test_cookie_jar_get_cookie():
+    headers = Header()
+    jar = CookieJar(headers)
+    cookie1 = jar.add_cookie("foo", "one")
+    cookie2 = jar.add_cookie("foo", "two", domain="example.com")
+
+    assert jar.get_cookie("foo") is cookie1
+    assert jar.get_cookie("foo", domain="example.com") is cookie2
+    assert jar.get_cookie("foo", path="/unknown") is None
+    assert jar.get_cookie("bar") is None
+
+
+def test_cookie_jar_add_cookie_encode():
+    headers = Header()
+    jar = CookieJar(headers)
+    jar.add_cookie("foo", "one")
+    jar.add_cookie(
+        "foo",
+        "two",
+        domain="example.com",
+        path="/something",
+        secure=True,
+        max_age=999,
+        httponly=True,
+        samesite="strict",
+    )
+    jar.add_cookie("foo", "three", secure_prefix=True)
+    jar.add_cookie("foo", "four", host_prefix=True)
+    jar.add_cookie("foo", "five", host_prefix=True, partitioned=True)
+
+    encoded = [cookie.encode("ascii") for cookie in jar.cookies]
+    assert encoded == [
+        b"foo=one; Path=/; SameSite=Lax; Secure",
+        b"foo=two; Path=/something; Domain=example.com; Max-Age=999; SameSite=Strict; Secure; HttpOnly",  # noqa
+        b"__Secure-foo=three; Path=/; SameSite=Lax; Secure",
+        b"__Host-foo=four; Path=/; SameSite=Lax; Secure",
+        b"__Host-foo=five; Path=/; SameSite=Lax; Secure; Partitioned",
+    ]
+
+
+def test_cookie_jar_old_school_cookie_encode():
+    headers = Header()
+    jar = CookieJar(headers)
+    jar["foo"] = "one"
+    jar["bar"] = "two"
+    jar["bar"]["domain"] = "example.com"
+    jar["bar"]["path"] = "/something"
+    jar["bar"]["secure"] = True
+    jar["bar"]["max-age"] = 999
+    jar["bar"]["httponly"] = True
+    jar["bar"]["samesite"] = "strict"
+
+    encoded = [cookie.encode("ascii") for cookie in jar.cookies]
+    assert encoded == [
+        b"foo=one; Path=/",
+        b"bar=two; Path=/something; Domain=example.com; Max-Age=999; SameSite=Strict; Secure; HttpOnly",  # noqa
+    ]
+
+
+def test_cookie_jar_delete_cookie_encode():
+    headers = Header()
+    jar = CookieJar(headers)
+    jar.delete_cookie("foo")
+    jar.delete_cookie("foo", domain="example.com")
+
+    encoded = [cookie.encode("ascii") for cookie in jar.cookies]
+    assert encoded == [
+        b'foo=""; Path=/; Max-Age=0; Secure',
+        b'foo=""; Path=/; Domain=example.com; Max-Age=0; Secure',
+    ]
+
+
+def test_cookie_jar_old_school_delete_encode():
+    headers = Header()
+    jar = CookieJar(headers)
+    del jar["foo"]
+
+    encoded = [cookie.encode("ascii") for cookie in jar.cookies]
+    assert encoded == [
+        b'foo=""; Path=/; Max-Age=0; Secure',
+    ]
+
+
+def test_bad_cookie_prarms():
+    headers = Header()
+    jar = CookieJar(headers)
+
+    with pytest.raises(
+        ServerError,
+        match=(
+            "Both host_prefix and secure_prefix were requested. "
+            "A cookie should have only one prefix."
+        ),
+    ):
+        jar.add_cookie("foo", "bar", host_prefix=True, secure_prefix=True)
+
+    with pytest.raises(
+        ServerError,
+        match="Cannot set host_prefix on a cookie without secure=True",
+    ):
+        jar.add_cookie("foo", "bar", host_prefix=True, secure=False)
+
+    with pytest.raises(
+        ServerError,
+        match="Cannot set host_prefix on a cookie unless path='/'",
+    ):
+        jar.add_cookie(
+            "foo", "bar", host_prefix=True, secure=True, path="/foo"
+        )
+
+    with pytest.raises(
+        ServerError,
+        match="Cannot set host_prefix on a cookie with a defined domain",
+    ):
+        jar.add_cookie(
+            "foo", "bar", host_prefix=True, secure=True, domain="foo.bar"
+        )
+
+    with pytest.raises(
+        ServerError,
+        match="Cannot set secure_prefix on a cookie without secure=True",
+    ):
+        jar.add_cookie("foo", "bar", secure_prefix=True, secure=False)
+
+    with pytest.raises(
+        ServerError,
+        match=(
+            "Cannot create a partitioned cookie without "
+            "also setting host_prefix=True"
+        ),
+    ):
+        jar.add_cookie("foo", "bar", partitioned=True)
+
+
+def test_cookie_accessors(app: Sanic):
+    @app.get("/")
+    async def handler(request: Request):
+        return json(
+            {
+                "getitem": {
+                    "one": request.cookies["one"],
+                    "two": request.cookies["two"],
+                    "three": request.cookies["three"],
+                },
+                "get": {
+                    "one": request.cookies.get("one", "fallback"),
+                    "two": request.cookies.get("two", "fallback"),
+                    "three": request.cookies.get("three", "fallback"),
+                    "four": request.cookies.get("four", "fallback"),
+                },
+                "getlist": {
+                    "one": request.cookies.getlist("one", ["fallback"]),
+                    "two": request.cookies.getlist("two", ["fallback"]),
+                    "three": request.cookies.getlist("three", ["fallback"]),
+                    "four": request.cookies.getlist("four", ["fallback"]),
+                },
+                "getattr": {
+                    "one": request.cookies.one,
+                    "two": request.cookies.two,
+                    "three": request.cookies.three,
+                    "four": request.cookies.four,
+                },
+            }
+        )
+
+    _, response = app.test_client.get(
+        "/",
+        cookies={
+            "__Host-one": "1",
+            "__Secure-two": "2",
+            "three": "3",
+        },
+    )
+
+    assert response.json == {
+        "getitem": {
+            "one": "1",
+            "two": "2",
+            "three": "3",
+        },
+        "get": {
+            "one": "1",
+            "two": "2",
+            "three": "3",
+            "four": "fallback",
+        },
+        "getlist": {
+            "one": ["1"],
+            "two": ["2"],
+            "three": ["3"],
+            "four": ["fallback"],
+        },
+        "getattr": {
+            "one": "1",
+            "two": "2",
+            "three": "3",
+            "four": "",
+        },
+    }
+
+
+def test_cookie_accessor_hyphens():
+    cookies = CookieRequestParameters({"session-token": ["abc123"]})
+
+    assert cookies.get("session-token") == cookies.session_token
+
+
+def test_cookie_passthru(app):
+    cookie_jar = None
+
+    @app.route("/")
+    def handler(request):
+        nonlocal cookie_jar
+        response = text("OK")
+        response.add_cookie("one", "1", host_prefix=True)
+        response.delete_cookie("two", secure_prefix=True)
+        cookie_jar = response.cookies
+        return response
+
+    _, response = app.test_client.get("/")
+
+    assert cookie_jar.get_cookie("two", secure_prefix=True).max_age == 0
+    assert len(response.cookies) == 1
+    assert response.cookies["__Host-one"] == "1"

tests/test_errorpages.py

@@ -1,12 +1,14 @@
+import logging
+
 import pytest
 
 from sanic import Sanic
 from sanic.config import Config
-from sanic.errorpages import HTMLRenderer, exception_response
+from sanic.errorpages import TextRenderer, exception_response, guess_mime
 from sanic.exceptions import NotFound, SanicException
 from sanic.handlers import ErrorHandler
 from sanic.request import Request
-from sanic.response import HTTPResponse, html, json, text
+from sanic.response import HTTPResponse, empty, html, json, text
 
 
 @pytest.fixture
@@ -17,6 +19,44 @@ def app():
     def err(request):
         raise Exception("something went wrong")
 
+    @app.get("/forced_json/<fail>", error_format="json")
+    def manual_fail(request, fail):
+        if fail == "fail":
+            raise Exception
+        return html("")  # Should be ignored
+
+    @app.get("/empty/<fail>")
+    def empty_fail(request, fail):
+        if fail == "fail":
+            raise Exception
+        return empty()
+
+    @app.get("/json/<fail>")
+    def json_fail(request, fail):
+        if fail == "fail":
+            raise Exception
+        # After 23.3 route format should become json, older versions think it
+        # is mixed due to empty mapping to html, and don't find any format.
+        return json({"foo": "bar"}) if fail == "json" else empty()
+
+    @app.get("/html/<fail>")
+    def html_fail(request, fail):
+        if fail == "fail":
+            raise Exception
+        return html("<h1>foo</h1>")
+
+    @app.get("/text/<fail>")
+    def text_fail(request, fail):
+        if fail == "fail":
+            raise Exception
+        return text("foo")
+
+    @app.get("/mixed/<param>")
+    def mixed_fail(request, param):
+        if param not in ("json", "html"):
+            raise Exception
+        return json({}) if param == "json" else html("")
+
     return app
 
 
@@ -28,14 +68,14 @@ def fake_request(app):
 @pytest.mark.parametrize(
     "fallback,content_type, exception, status",
     (
-        (None, "text/html; charset=utf-8", Exception, 500),
+        (None, "text/plain; charset=utf-8", Exception, 500),
         ("html", "text/html; charset=utf-8", Exception, 500),
-        ("auto", "text/html; charset=utf-8", Exception, 500),
+        ("auto", "text/plain; charset=utf-8", Exception, 500),
         ("text", "text/plain; charset=utf-8", Exception, 500),
         ("json", "application/json", Exception, 500),
-        (None, "text/html; charset=utf-8", NotFound, 404),
+        (None, "text/plain; charset=utf-8", NotFound, 404),
         ("html", "text/html; charset=utf-8", NotFound, 404),
-        ("auto", "text/html; charset=utf-8", NotFound, 404),
+        ("auto", "text/plain; charset=utf-8", NotFound, 404),
         ("text", "text/plain; charset=utf-8", NotFound, 404),
         ("json", "application/json", NotFound, 404),
     ),
@@ -43,6 +83,10 @@ def fake_request(app):
 def test_should_return_html_valid_setting(
     fake_request, fallback, content_type, exception, status
 ):
+    # Note: if fallback is None or "auto", prior to PR #2668 base was returned
+    # and after that a text response is given because it matches */*. Changed
+    # base to TextRenderer in this test, like it is in Sanic itself, so the
+    # test passes with either version but still covers everything that it did.
     if fallback:
         fake_request.app.config.FALLBACK_ERROR_FORMAT = fallback
 
@@ -53,7 +97,7 @@ def test_should_return_html_valid_setting(
             fake_request,
             e,
             True,
-            base=HTMLRenderer,
+            base=TextRenderer,
             fallback=fake_request.app.config.FALLBACK_ERROR_FORMAT,
         )
 
@@ -204,9 +248,9 @@ def test_fallback_with_content_type_mismatch_accept(app):
 
     app.router.reset()
 
-    @app.route("/alt1")
+    @app.route("/alt1", name="alt1")
-    @app.route("/alt2", error_format="text")
+    @app.route("/alt2", error_format="text", name="alt2")
-    @app.route("/alt3", error_format="html")
+    @app.route("/alt3", error_format="html", name="alt3")
     def handler(_):
         raise Exception("problem here")
         # Yes, we know this return value is unreachable. This is on purpose.
@@ -259,15 +303,16 @@ def test_fallback_with_content_type_mismatch_accept(app):
     "accept,content_type,expected",
     (
         (None, None, "text/plain; charset=utf-8"),
-        ("foo/bar", None, "text/html; charset=utf-8"),
+        ("foo/bar", None, "text/plain; charset=utf-8"),
         ("application/json", None, "application/json"),
         ("application/json,text/plain", None, "application/json"),
         ("text/plain,application/json", None, "application/json"),
         ("text/plain,foo/bar", None, "text/plain; charset=utf-8"),
-        # Following test is valid after v22.3
+        ("text/plain,text/html", None, "text/plain; charset=utf-8"),
-        # ("text/plain,text/html", None, "text/plain; charset=utf-8"),
+        ("*/*", "foo/bar", "text/plain; charset=utf-8"),
-        ("*/*", "foo/bar", "text/html; charset=utf-8"),
         ("*/*", "application/json", "application/json"),
+        # App wants text/plain but accept has equal entries for it
+        ("text/*,*/plain", None, "text/plain; charset=utf-8"),
     ),
 )
 def test_combinations_for_auto(fake_request, accept, content_type, expected):
@@ -286,7 +331,7 @@ def test_combinations_for_auto(fake_request, accept, content_type, expected):
             fake_request,
             e,
             True,
-            base=HTMLRenderer,
+            base=TextRenderer,
             fallback="auto",
         )
 
@@ -376,3 +421,109 @@ def test_config_fallback_bad_value(app):
     message = "Unknown format: fake"
     with pytest.raises(SanicException, match=message):
         app.config.FALLBACK_ERROR_FORMAT = "fake"
+
+
+@pytest.mark.parametrize(
+    "route_format,fallback,accept,expected",
+    (
+        (
+            "json",
+            "html",
+            "*/*",
+            "The client accepts */*, using 'json' from fakeroute",
+        ),
+        (
+            "json",
+            "auto",
+            "text/html,*/*;q=0.8",
+            "The client accepts text/html, using 'html' from any",
+        ),
+        (
+            "json",
+            "json",
+            "text/html,*/*;q=0.8",
+            "The client accepts */*;q=0.8, using 'json' from fakeroute",
+        ),
+        (
+            "",
+            "html",
+            "text/*,*/plain",
+            "The client accepts text/*, using 'html' from FALLBACK_ERROR_FORMAT",
+        ),
+        (
+            "",
+            "json",
+            "text/*,*/*",
+            "The client accepts */*, using 'json' from FALLBACK_ERROR_FORMAT",
+        ),
+        (
+            "",
+            "auto",
+            "*/*,application/json;q=0.5",
+            "The client accepts */*, using 'json' from request.accept",
+        ),
+        (
+            "",
+            "auto",
+            "*/*",
+            "The client accepts */*, using 'json' from content-type",
+        ),
+        (
+            "",
+            "auto",
+            "text/html,text/plain",
+            "The client accepts text/plain, using 'text' from any",
+        ),
+        (
+            "",
+            "auto",
+            "text/html,text/plain;q=0.9",
+            "The client accepts text/html, using 'html' from any",
+        ),
+        (
+            "html",
+            "json",
+            "application/xml",
+            "No format found, the client accepts [application/xml]",
+        ),
+        ("", "auto", "*/*", "The client accepts */*, using 'text' from any"),
+        ("", "", "*/*", "No format found, the client accepts [*/*]"),
+        # DEPRECATED: remove in 24.3
+        (
+            "",
+            "auto",
+            "*/*",
+            "The client accepts */*, using 'json' from request.json",
+        ),
+    ),
+)
+def test_guess_mime_logging(
+    caplog, fake_request, route_format, fallback, accept, expected
+):
+    class FakeObject:
+        pass
+
+    fake_request.route = FakeObject()
+    fake_request.route.name = "fakeroute"
+    fake_request.route.extra = FakeObject()
+    fake_request.route.extra.error_format = route_format
+    if accept is None:
+        del fake_request.headers["accept"]
+    else:
+        fake_request.headers["accept"] = accept
+
+    if "content-type" in expected:
+        fake_request.headers["content-type"] = "application/json"
+
+    # Fake JSON content (DEPRECATED: remove in 24.3)
+    if "request.json" in expected:
+        fake_request.parsed_json = {"foo": "bar"}
+
+    with caplog.at_level(logging.DEBUG, logger="sanic.root"):
+        guess_mime(fake_request, fallback)
+
+    (logmsg,) = [
+        r.message for r in caplog.records if r.funcName == "guess_mime"
+    ]
+
+    assert logmsg == expected

tests/test_exceptions.py

@@ -23,11 +23,11 @@ from sanic.exceptions import (
 from sanic.response import text
 
 
-def dl_to_dict(soup, css_class):
+def dl_to_dict(soup, dl_id):
     keys, values = [], []
-    for dl in soup.find_all("dl", {"class": css_class}):
+    for dl in soup.find_all("dl", {"id": dl_id}):
         for dt in dl.find_all("dt"):
-            keys.append(dt.text.strip())
+            keys.append(dt.text.split(":", 1)[0])
         for dd in dl.find_all("dd"):
             values.append(dd.text.strip())
     return dict(zip(keys, values))
@@ -194,10 +194,7 @@ def test_handled_unhandled_exception(exception_app):
     assert "Internal Server Error" in soup.h1.text
 
     message = " ".join(soup.p.text.split())
-    assert message == (
+    assert "The application encountered an unexpected error" in message
-        "The server encountered an internal error and "
-        "cannot complete your request."
-    )
 
 
 def test_exception_in_exception_handler(exception_app):
@@ -288,9 +285,15 @@ def test_contextual_exception_context(debug):
     def fail():
         raise TeapotError(context={"foo": "bar"})
 
-    app.post("/coffee/json", error_format="json")(lambda _: fail())
+    app.post("/coffee/json", error_format="json", name="json")(
-    app.post("/coffee/html", error_format="html")(lambda _: fail())
+        lambda _: fail()
-    app.post("/coffee/text", error_format="text")(lambda _: fail())
+    )
+    app.post("/coffee/html", error_format="html", name="html")(
+        lambda _: fail()
+    )
+    app.post("/coffee/text", error_format="text", name="text")(
+        lambda _: fail()
+    )
 
     _, response = app.test_client.post("/coffee/json", debug=debug)
     assert response.status == 418
@@ -299,7 +302,7 @@ def test_contextual_exception_context(debug):
 
     _, response = app.test_client.post("/coffee/html", debug=debug)
     soup = BeautifulSoup(response.body, "html.parser")
-    dl = dl_to_dict(soup, "context")
+    dl = dl_to_dict(soup, "exception-context")
     assert response.status == 418
     assert "Sorry, I cannot brew coffee" in soup.find("p").text
     assert dl == {"foo": "bar"}
@@ -326,9 +329,15 @@ def test_contextual_exception_extra(debug):
     def fail():
         raise TeapotError(extra={"foo": "bar"})
 
-    app.post("/coffee/json", error_format="json")(lambda _: fail())
+    app.post("/coffee/json", error_format="json", name="json")(
-    app.post("/coffee/html", error_format="html")(lambda _: fail())
+        lambda _: fail()
-    app.post("/coffee/text", error_format="text")(lambda _: fail())
+    )
+    app.post("/coffee/html", error_format="html", name="html")(
+        lambda _: fail()
+    )
+    app.post("/coffee/text", error_format="text", name="text")(
+        lambda _: fail()
+    )
 
     _, response = app.test_client.post("/coffee/json", debug=debug)
     assert response.status == 418
@@ -340,7 +349,7 @@ def test_contextual_exception_extra(debug):
 
     _, response = app.test_client.post("/coffee/html", debug=debug)
     soup = BeautifulSoup(response.body, "html.parser")
-    dl = dl_to_dict(soup, "extra")
+    dl = dl_to_dict(soup, "exception-extra")
     assert response.status == 418
     assert "Found bar" in soup.find("p").text
     if debug:

tests/test_exceptions_handler.py

@@ -123,10 +123,10 @@ def test_html_traceback_output_in_debug_mode(exception_handler_app: Sanic):
     assert "handler_4" in html
     assert "foo = bar" in html
 
-    summary_text = " ".join(soup.select(".summary")[0].text.split())
+    summary_text = soup.select("h3")[0].text
-    assert (
+    assert "NameError: name 'bar' is not defined" == summary_text
-        "NameError: name 'bar' is not defined while handling path /4"
+    request_text = soup.select("h2")[-1].text
-    ) == summary_text
+    assert "GET /4" == request_text
 
 
 def test_inherited_exception_handler(exception_handler_app: Sanic):
@@ -146,11 +146,10 @@ def test_chained_exception_handler(exception_handler_app: Sanic):
     assert "handler_6" in html
     assert "foo = 1 / arg" in html
     assert "ValueError" in html
+    assert "GET /6" in html
 
-    summary_text = " ".join(soup.select(".summary")[0].text.split())
+    summary_text = soup.select("h3")[0].text
-    assert (
+    assert "ZeroDivisionError: division by zero" == summary_text
-        "ZeroDivisionError: division by zero while handling path /6/0"
-    ) == summary_text
 
 
 def test_exception_handler_lookup(exception_handler_app: Sanic):
@@ -267,20 +266,17 @@ def test_exception_handler_response_was_sent(
     assert "Error" in response.text
 
 
-def test_warn_on_duplicate(
+def test_errir_on_duplicate(app: Sanic):
-    app: Sanic, caplog: LogCaptureFixture, recwarn: WarningsRecorder
-):
     @app.exception(ServerError)
     async def exception_handler_1(request, exception):
         ...
 
-    @app.exception(ServerError)
+    message = (
-    async def exception_handler_2(request, exception):
-        ...
-
-    assert len(caplog.records) == 1
-    assert len(recwarn) == 1
-    assert caplog.records[0].message == (
         "Duplicate exception handler definition on: route=__ALL_ROUTES__ and "
         "exception=<class 'sanic.exceptions.ServerError'>"
     )
+    with pytest.raises(ServerError, match=message):
+
+        @app.exception(ServerError)
+        async def exception_handler_2(request, exception):
+            ...

tests/test_headers.py

@@ -2,12 +2,16 @@ from unittest.mock import Mock
 
 import pytest
 
-from sanic import headers, text
+from sanic import Sanic, headers, json, text
 from sanic.exceptions import InvalidHeader, PayloadTooLarge
 from sanic.http import Http
 from sanic.request import Request
 
 
+def make_request(headers) -> Request:
+    return Request(b"/", headers, "1.1", "GET", None, None)
+
+
 @pytest.fixture
 def raised_ceiling():
     Http.HEADER_CEILING = 32_768
@@ -45,29 +49,17 @@ def raised_ceiling():
             ("attachment", {"filename": "strange;name", "size": "123"}),
         ),
         (
-            'form-data; name="files"; filename="fo\\"o;bar\\"',
+            'form-data; name="foo"; value="%22\\%0D%0A"',
-            ("form-data", {"name": "files", "filename": 'fo"o;bar\\'})
+            ("form-data", {"name": "foo", "value": '"\\\n'}),
-            # cgi.parse_header:
-            # ('form-data', {'name': 'files', 'filename': 'fo"o;bar\\'})
-            # werkzeug.parse_options_header:
-            # ('form-data', {'name': 'files', 'filename': '"fo\\"o', 'bar\\"': None})
         ),
         # <input type=file name="foo&quot;;bar\"> with Unicode filename!
         (
-            # Chrome:
+            # Chrome, Firefox:
             # Content-Disposition: form-data; name="foo%22;bar\"; filename="😀"
             'form-data; name="foo%22;bar\\"; filename="😀"',
             ("form-data", {"name": 'foo";bar\\', "filename": "😀"})
             # cgi: ('form-data', {'name': 'foo%22;bar"; filename="😀'})
-            # werkzeug: ('form-data', {'name': 'foo%22;bar"; filename='})
+            # werkzeug (pre 2.3.0): ('form-data', {'name': 'foo%22;bar"; filename='})
-        ),
-        (
-            # Firefox:
-            # Content-Disposition: form-data; name="foo\";bar\"; filename="😀"
-            'form-data; name="foo\\";bar\\"; filename="😀"',
-            ("form-data", {"name": 'foo";bar\\', "filename": "😀"})
-            # cgi: ('form-data', {'name': 'foo";bar"; filename="😀'})
-            # werkzeug: ('form-data', {'name': 'foo";bar"; filename='})
         ),
     ],
 )
@@ -185,22 +177,27 @@ def test_request_line(app):
 
     assert request.request_line == b"GET / HTTP/1.1"
 
+
 @pytest.mark.parametrize(
-    "raw",
+    "raw,expected_subtype",
     (
-        "text/html, application/xhtml+xml, application/xml;q=0.9, */*;q=0.8",
+        ("show/first, show/second", "first"),
-        "application/xml;q=0.9, */*;q=0.8, text/html, application/xhtml+xml",
+        ("show/*, show/first", "first"),
-        "foo/bar;q=0.9, */*;q=0.8, text/html=0.8, text/plain, application/xhtml+xml",
+        ("*/*, show/first", "first"),
-    )
+        ("*/*, show/*", "*"),
+        ("other/*; q=0.1, show/*; q=0.2", "*"),
+        ("show/first; q=0.5, show/second; q=0.5", "first"),
+        ("show/first; foo=bar, show/second; foo=bar", "first"),
+        ("show/second, show/first; foo=bar", "first"),
+        ("show/second; q=0.5, show/first; foo=bar; q=0.5", "first"),
+        ("show/second; q=0.5, show/first; q=1.0", "first"),
+        ("show/first, show/second; q=1.0", "second"),
+    ),
 )
-def test_accept_ordering(raw):
+def test_parse_accept_ordered_okay(raw, expected_subtype):
-    """Should sort by q but also be stable."""
+    ordered = headers.parse_accept(raw)
-    accept = headers.parse_accept(raw)
+    assert ordered[0].type == "show"
-    assert accept[0].type_ == "text"
+    assert ordered[0].subtype == expected_subtype
-    raw1 =  ", ".join(str(a) for a in accept)
-    accept = headers.parse_accept(raw1)
-    raw2 =  ", ".join(str(a) for a in accept)
-    assert raw1 == raw2
 
 
 @pytest.mark.parametrize(
@@ -209,6 +206,7 @@ def test_accept_ordering(raw):
         "missing",
         "missing/",
         "/missing",
+        "/",
     ),
 )
 def test_bad_accept(raw):
@@ -224,75 +222,99 @@ def test_empty_accept():
 
 def test_wildcard_accept_set_ok():
     accept = headers.parse_accept("*/*")[0]
-    assert accept.is_wildcard
+    assert accept.type == "*"
+    assert accept.subtype == "*"
     assert accept.has_wildcard
 
     accept = headers.parse_accept("foo/*")[0]
-    assert not accept.is_wildcard
+    assert accept.type == "foo"
-    assert accept.has_wildcard
+    assert accept.subtype == "*"
-
-    accept = headers.parse_accept("*/bar")[0]
-    assert not accept.is_wildcard
     assert accept.has_wildcard
 
     accept = headers.parse_accept("foo/bar")[0]
-    assert not accept.is_wildcard
+    assert accept.type == "foo"
+    assert accept.subtype == "bar"
     assert not accept.has_wildcard
 
 
+def test_accept_parsed_against_str():
+    accept = headers.Matched.parse("foo/bar")
+    assert accept == "foo/bar; q=0.1"
+
+
+def test_media_type_matching():
+    assert headers.MediaType("foo", "bar").match(
+        headers.MediaType("foo", "bar")
+    )
+    assert headers.MediaType("foo", "bar").match("foo/bar")
+
+
 @pytest.mark.parametrize(
-    "value,other,outcome,allow_type,allow_subtype",
+    "value,other,outcome",
     (
         # ALLOW BOTH
-        ("foo/bar", "foo/bar", True, True, True),
+        ("foo/bar", "foo/bar", True),
-        ("foo/bar", "foo/*", True, True, True),
+        ("foo/bar", headers.Matched.parse("foo/bar"), True),
-        ("foo/bar", "*/*", True, True, True),
+        ("foo/bar", "foo/*", True),
-        ("foo/*", "foo/bar", True, True, True),
+        ("foo/bar", headers.Matched.parse("foo/*"), True),
-        ("foo/*", "foo/*", True, True, True),
+        ("foo/bar", "*/*", True),
-        ("foo/*", "*/*", True, True, True),
+        ("foo/bar", headers.Matched.parse("*/*"), True),
-        ("*/*", "foo/bar", True, True, True),
+        ("foo/*", "foo/bar", True),
-        ("*/*", "foo/*", True, True, True),
+        ("foo/*", headers.Matched.parse("foo/bar"), True),
-        ("*/*", "*/*", True, True, True),
+        ("foo/*", "foo/*", True),
-        # ALLOW TYPE
+        ("foo/*", headers.Matched.parse("foo/*"), True),
-        ("foo/bar", "foo/bar", True, True, False),
+        ("foo/*", "*/*", True),
-        ("foo/bar", "foo/*", False, True, False),
+        ("foo/*", headers.Matched.parse("*/*"), True),
-        ("foo/bar", "*/*", False, True, False),
+        ("*/*", "foo/bar", True),
-        ("foo/*", "foo/bar", False, True, False),
+        ("*/*", headers.Matched.parse("foo/bar"), True),
-        ("foo/*", "foo/*", False, True, False),
+        ("*/*", "foo/*", True),
-        ("foo/*", "*/*", False, True, False),
+        ("*/*", headers.Matched.parse("foo/*"), True),
-        ("*/*", "foo/bar", False, True, False),
+        ("*/*", "*/*", True),
-        ("*/*", "foo/*", False, True, False),
+        ("*/*", headers.Matched.parse("*/*"), True),
-        ("*/*", "*/*", False, True, False),
-        # ALLOW SUBTYPE
-        ("foo/bar", "foo/bar", True, False, True),
-        ("foo/bar", "foo/*", True, False, True),
-        ("foo/bar", "*/*", False, False, True),
-        ("foo/*", "foo/bar", True, False, True),
-        ("foo/*", "foo/*", True, False, True),
-        ("foo/*", "*/*", False, False, True),
-        ("*/*", "foo/bar", False, False, True),
-        ("*/*", "foo/*", False, False, True),
-        ("*/*", "*/*", False, False, True),
     ),
 )
-def test_accept_matching(value, other, outcome, allow_type, allow_subtype):
+def test_accept_matching(value, other, outcome):
-    assert (
+    assert bool(headers.Matched.parse(value).match(other)) is outcome
-        bool(headers.MediaType._parse(value).match(
+
-            other,
+
-            allow_type_wildcard=allow_type,
+@pytest.mark.parametrize("value", ("foo/bar", "foo/*", "*/*"))
-            allow_subtype_wildcard=allow_subtype,
+def test_value_in_accept(value):
-        ))
+    acceptable = headers.parse_accept(value)
-        is outcome
+    assert acceptable.match("foo/bar")
-    )
+    assert acceptable.match("foo/*")
+    assert acceptable.match("*/*")
 
 
 @pytest.mark.parametrize("value", ("foo/bar", "foo/*"))
 def test_value_not_in_accept(value):
     acceptable = headers.parse_accept(value)
+    assert not acceptable.match("no/match")
+    assert not acceptable.match("no/*")
     assert "*/*" not in acceptable
     assert "*/bar" not in acceptable
 
 
+@pytest.mark.parametrize(
+    "header,expected",
+    (
+        (
+            "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8",  # noqa: E501
+            [
+                "text/html",
+                "application/xhtml+xml",
+                "image/avif",
+                "image/webp",
+                "application/xml;q=0.9",
+                "*/*;q=0.8",
+            ],
+        ),
+    ),
+)
+def test_browser_headers_general(header, expected):
+    request = Request(b"/", {"accept": header}, "1.1", "GET", None, None)
+    assert [str(item) for item in request.accept] == expected
+
+
 @pytest.mark.parametrize(
     "header,expected",
     (
@@ -309,12 +331,139 @@ def test_value_not_in_accept(value):
         ),
     ),
 )
-def test_browser_headers(header, expected):
+def test_browser_headers_specific(header, expected):
     mimes = [e[0] for e in expected]
     qs = [e[1] for e in expected]
     request = Request(b"/", {"accept": header}, "1.1", "GET", None, None)
     assert request.accept == mimes
     for a, m, q in zip(request.accept, mimes, qs):
         assert a == m
-        assert a.str == m
+        assert a.mime == m
         assert a.q == q
+
+
+@pytest.mark.parametrize(
+    "raw",
+    (
+        "text/html, application/xhtml+xml, application/xml;q=0.9, */*;q=0.8",
+        "application/xml;q=0.9, */*;q=0.8, text/html, application/xhtml+xml",
+        (
+            "foo/bar;q=0.9, */*;q=0.8, text/html=0.8, "
+            "text/plain, application/xhtml+xml"
+        ),
+    ),
+)
+def test_accept_ordering(raw):
+    """Should sort by q but also be stable."""
+    accept = headers.parse_accept(raw)
+    assert accept[0].type == "text"
+    raw1 = ", ".join(str(a) for a in accept)
+    accept = headers.parse_accept(raw1)
+    raw2 = ", ".join(str(a) for a in accept)
+    assert raw1 == raw2
+
+
+def test_not_accept_wildcard():
+    accept = headers.parse_accept("*/*, foo/*, */bar, foo/bar;q=0.1")
+    assert not accept.match(
+        "text/html", "foo/foo", "bar/bar", accept_wildcards=False
+    )
+    # Should ignore wildcards in accept but still matches them from mimes
+    m = accept.match("text/plain", "*/*", accept_wildcards=False)
+    assert m.mime == "*/*"
+    assert m.match("*/*")
+    assert m.header == "foo/bar"
+    assert not accept.match(
+        "text/html", "foo/foo", "bar/bar", accept_wildcards=False
+    )
+
+
+def test_accept_misc():
+    header = (
+        "foo/bar;q=0.0, */plain;param=123, text/plain, text/*, foo/bar;q=0.5"
+    )
+    a = headers.parse_accept(header)
+    assert repr(a) == (
+        "[*/plain;param=123, text/plain, text/*, "
+        "foo/bar;q=0.5, foo/bar;q=0.0]"
+    )  # noqa: E501
+    assert str(a) == (
+        "*/plain;param=123, text/plain, text/*, "
+        "foo/bar;q=0.5, foo/bar;q=0.0"
+    )  # noqa: E501
+    # q=1 types don't match foo/bar but match the two others,
+    # text/* comes first and matches */plain because it
+    # comes first in the header
+    m = a.match("foo/bar", "text/*", "text/plain")
+    assert repr(m) == "<text/* matched */plain;param=123>"
+    assert m == "text/*"
+    assert m.mime == "text/*"
+    assert m.header.mime == "*/plain"
+    assert m.header.type == "*"
+    assert m.header.subtype == "plain"
+    assert m.header.q == 1.0
+    assert m.header.params == dict(param="123")
+    # Matches object against another Matched object (by mime and header)
+    assert m == a.match("text/*")
+    # Against unsupported type falls back to object id matching
+    assert m != 123
+    # Matches the highest q value
+    m = a.match("foo/bar")
+    assert repr(m) == "<foo/bar matched foo/bar;q=0.5>"
+    assert m == "foo/bar"
+    assert m == "foo/bar;q=0.5"
+    # Matching nothing special case
+    m = a.match()
+    assert m == ""
+    assert m.header is None
+    # No header means anything
+    a = headers.parse_accept(None)
+    assert a == ["*/*"]
+    assert a.match("foo/bar")
+    # Empty header means nothing
+    a = headers.parse_accept("")
+    assert a == []
+    assert not a.match("foo/bar")
+
+
+@pytest.mark.parametrize(
+    "headers,expected",
+    (
+        ({"foo": "bar"}, "bar"),
+        ((("foo", "bar"), ("foo", "baz")), "bar,baz"),
+        ({}, ""),
+    ),
+)
+def test_field_simple_accessor(headers, expected):
+    request = make_request(headers)
+    assert request.headers.foo == request.headers.foo_ == expected
+
+
+@pytest.mark.parametrize(
+    "headers,expected",
+    (
+        ({"foo-bar": "bar"}, "bar"),
+        ((("foo-bar", "bar"), ("foo-bar", "baz")), "bar,baz"),
+    ),
+)
+def test_field_hyphenated_accessor(headers, expected):
+    request = make_request(headers)
+    assert request.headers.foo_bar == request.headers.foo_bar_ == expected
+
+
+def test_bad_accessor():
+    request = make_request({})
+    msg = "'Header' object has no attribute '_foo'"
+    with pytest.raises(AttributeError, match=msg):
+        request.headers._foo
+
+
+def test_multiple_fields_accessor(app: Sanic):
+    @app.get("")
+    async def handler(request: Request):
+        return json({"field": request.headers.example_field})
+
+    _, response = app.test_client.get(
+        "/", headers=(("Example-Field", "Foo, Bar"), ("Example-Field", "Baz"))
+    )
+    assert response.json["field"] == "Foo, Bar,Baz"

tests/test_http.py

@@ -98,3 +98,17 @@ def test_transfer_chunked(client):
     data = stdjson.loads(body)
 
     assert data == ["foo", "bar"]
+
+
+def test_url_encoding(client):
+    client.send(
+        """
+        GET /invalid\xA0url HTTP/1.1
+
+        """
+    )
+    response = client.recv()
+    headers, body = response.rsplit(b"\r\n\r\n", 1)
+
+    assert b"400 Bad Request" in headers
+    assert b"URL may only contain US-ASCII characters." in body

tests/test_late_adds.py

@@ -0,0 +1,54 @@
+import pytest
+
+from sanic import Sanic, text
+
+
+@pytest.fixture
+def late_app(app: Sanic):
+    app.config.TOUCHUP = False
+    app.get("/")(lambda _: text(""))
+    return app
+
+
+def test_late_route(late_app: Sanic):
+    @late_app.before_server_start
+    async def late(app: Sanic):
+        @app.get("/late")
+        def handler(_):
+            return text("late")
+
+    _, response = late_app.test_client.get("/late")
+    assert response.status_code == 200
+    assert response.text == "late"
+
+
+def test_late_middleware(late_app: Sanic):
+    @late_app.get("/late")
+    def handler(request):
+        return text(request.ctx.late)
+
+    @late_app.before_server_start
+    async def late(app: Sanic):
+        @app.on_request
+        def handler(request):
+            request.ctx.late = "late"
+
+    _, response = late_app.test_client.get("/late")
+    assert response.status_code == 200
+    assert response.text == "late"
+
+
+def test_late_signal(late_app: Sanic):
+    @late_app.get("/late")
+    def handler(request):
+        return text(request.ctx.late)
+
+    @late_app.before_server_start
+    async def late(app: Sanic):
+        @app.signal("http.lifecycle.request")
+        def handler(request):
+            request.ctx.late = "late"
+
+    _, response = late_app.test_client.get("/late")
+    assert response.status_code == 200
+    assert response.text == "late"

tests/test_multiprocessing.py

@@ -49,96 +49,6 @@ def test_multiprocessing(app):
     assert len(process_list) == num_workers + 1
 
 
-@pytest.mark.skipif(
-    not hasattr(signal, "SIGALRM"),
-    reason="SIGALRM is not implemented for this platform, we have to come "
-    "up with another timeout strategy to test these",
-)
-def test_multiprocessing_legacy(app):
-    """Tests that the number of children we produce is correct"""
-    # Selects a number at random so we can spot check
-    num_workers = random.choice(range(2, multiprocessing.cpu_count() * 2 + 1))
-    process_list = set()
-
-    @app.after_server_start
-    async def shutdown(app):
-        await sleep(2.1)
-        app.stop()
-
-    def stop_on_alarm(*args):
-        for process in multiprocessing.active_children():
-            process_list.add(process.pid)
-
-    signal.signal(signal.SIGALRM, stop_on_alarm)
-    signal.alarm(2)
-    app.run(HOST, 4121, workers=num_workers, debug=True, legacy=True)
-
-    assert len(process_list) == num_workers
-
-
-@pytest.mark.skipif(
-    not hasattr(signal, "SIGALRM"),
-    reason="SIGALRM is not implemented for this platform, we have to come "
-    "up with another timeout strategy to test these",
-)
-def test_multiprocessing_legacy_sock(app):
-    """Tests that the number of children we produce is correct"""
-    # Selects a number at random so we can spot check
-    num_workers = random.choice(range(2, multiprocessing.cpu_count() * 2 + 1))
-    process_list = set()
-
-    @app.after_server_start
-    async def shutdown(app):
-        await sleep(2.1)
-        app.stop()
-
-    def stop_on_alarm(*args):
-        for process in multiprocessing.active_children():
-            process_list.add(process.pid)
-
-    signal.signal(signal.SIGALRM, stop_on_alarm)
-    signal.alarm(2)
-    sock = configure_socket(
-        {
-            "host": HOST,
-            "port": 4121,
-            "unix": None,
-            "backlog": 100,
-        }
-    )
-    app.run(workers=num_workers, debug=True, legacy=True, sock=sock)
-    sock.close()
-
-    assert len(process_list) == num_workers
-
-
-@pytest.mark.skipif(
-    not hasattr(signal, "SIGALRM"),
-    reason="SIGALRM is not implemented for this platform, we have to come "
-    "up with another timeout strategy to test these",
-)
-def test_multiprocessing_legacy_unix(app):
-    """Tests that the number of children we produce is correct"""
-    # Selects a number at random so we can spot check
-    num_workers = random.choice(range(2, multiprocessing.cpu_count() * 2 + 1))
-    process_list = set()
-
-    @app.after_server_start
-    async def shutdown(app):
-        await sleep(2.1)
-        app.stop()
-
-    def stop_on_alarm(*args):
-        for process in multiprocessing.active_children():
-            process_list.add(process.pid)
-
-    signal.signal(signal.SIGALRM, stop_on_alarm)
-    signal.alarm(2)
-    app.run(workers=num_workers, debug=True, legacy=True, unix="./test.sock")
-
-    assert len(process_list) == num_workers
-
-
 @pytest.mark.skipif(
     not hasattr(signal, "SIGALRM"),
     reason="SIGALRM is not implemented for this platform",

tests/test_request.py

@@ -1,3 +1,5 @@
+import uuid
+
 from unittest.mock import Mock
 from uuid import UUID, uuid4
 
@@ -5,7 +7,7 @@ import pytest
 
 from sanic import Sanic, response
 from sanic.exceptions import BadURL, SanicException
-from sanic.request import Request, uuid
+from sanic.request import Request
 from sanic.server import HttpProtocol
 
 
@@ -150,33 +152,47 @@ def test_request_accept():
     async def get(request):
         return response.empty()
 
+    header_value = "text/plain;format=flowed, text/plain, text/*, */*"
     request, _ = app.test_client.get(
         "/",
-        headers={
+        headers={"Accept": header_value},
-            "Accept": "text/*, text/plain, text/plain;format=flowed, */*"
-        },
     )
-    assert request.accept == [
+    assert str(request.accept) == header_value
+    match = request.accept.match(
+        "*/*;format=flowed",
         "text/plain;format=flowed",
         "text/plain",
         "text/*",
         "*/*",
-    ]
+    )
+    assert match == "*/*;format=flowed"
+    assert match.header.mime == "text/plain"
+    assert match.header.params == {"format": "flowed"}
 
+    header_value = (
+        "text/plain; q=0.5,   text/html, text/x-dvi; q=0.8, text/x-c"
+    )
     request, _ = app.test_client.get(
         "/",
-        headers={
+        headers={"Accept": header_value},
-            "Accept": (
-                "text/plain; q=0.5, text/html, text/x-dvi; q=0.8, text/x-c"
-            )
-        },
     )
-    assert request.accept == [
+    assert [str(i) for i in request.accept] == [
         "text/html",
         "text/x-c",
-        "text/x-dvi; q=0.8",
+        "text/x-dvi;q=0.8",
-        "text/plain; q=0.5",
+        "text/plain;q=0.5",
     ]
+    match = request.accept.match(
+        "application/json",
+        "text/plain",  # Has lower q in accept header
+        "text/html;format=flowed",  # Params mismatch
+        "text/*",  # Matches
+        "*/*",
+    )
+    assert match == "text/*"
+    assert match.header.mime == "text/html"
+    assert match.header.q == 1.0
+    assert not match.header.params
 
 
 def test_bad_url_parse():

tests/test_requests.py

@@ -16,8 +16,9 @@ from sanic_testing.testing import (
 )
 
 from sanic import Blueprint, Sanic
+from sanic.constants import DEFAULT_HTTP_CONTENT_TYPE
 from sanic.exceptions import ServerError
-from sanic.request import DEFAULT_HTTP_CONTENT_TYPE, RequestParameters
+from sanic.request import RequestParameters
 from sanic.response import html, json, text
 
 
@@ -104,11 +105,11 @@ def test_html(app):
         return html("<h1>Hello</h1>")
 
     @app.route("/foo")
-    async def handler(request):
+    async def handler_foo(request):
         return html(Foo())
 
     @app.route("/bar")
-    async def handler(request):
+    async def handler_bar(request):
         return html(Bar())
 
     request, response = app.test_client.get("/")
@@ -1813,8 +1814,8 @@ def test_request_cookies(app):
 
     request, response = app.test_client.get("/", cookies=cookies)
 
-    assert request.cookies == cookies
+    assert len(request.cookies) == len(cookies)
-    assert request.cookies == cookies  # For request._cookies
+    assert request.cookies["test"] == cookies["test"]
 
 
 @pytest.mark.asyncio
@@ -1827,8 +1828,8 @@ async def test_request_cookies_asgi(app):
 
     request, response = await app.asgi_client.get("/", cookies=cookies)
 
-    assert request.cookies == cookies
+    assert len(request.cookies) == len(cookies)
-    assert request.cookies == cookies  # For request._cookies
+    assert request.cookies["test"] == cookies["test"]
 
 
 def test_request_cookies_without_cookies(app):
@@ -2198,10 +2199,25 @@ def test_safe_method_with_body(app):
     assert response.body == b"OK"
 
 
-def test_conflicting_body_methods_overload(app):
+@pytest.mark.asyncio
+async def test_conflicting_body_methods_overload_error(app: Sanic):
     @app.put("/")
     @app.put("/p/")
     @app.put("/p/<foo>")
+    async def put(request, foo=None):
+        ...
+
+    with pytest.raises(
+        ServerError,
+        match="Duplicate route names detected: test_conflicting_body_methods_overload_error\.put.*",
+    ):
+        await app._startup()
+
+
+def test_conflicting_body_methods_overload(app: Sanic):
+    @app.put("/", name="one")
+    @app.put("/p/", name="two")
+    @app.put("/p/<foo>", name="three")
     async def put(request, foo=None):
         return json(
             {"name": request.route.name, "body": str(request.body), "foo": foo}
@@ -2219,21 +2235,21 @@ def test_conflicting_body_methods_overload(app):
     _, response = app.test_client.put("/", json=payload)
     assert response.status == 200
     assert response.json == {
-        "name": "test_conflicting_body_methods_overload.put",
+        "name": "test_conflicting_body_methods_overload.one",
         "foo": None,
         "body": data,
     }
     _, response = app.test_client.put("/p", json=payload)
     assert response.status == 200
     assert response.json == {
-        "name": "test_conflicting_body_methods_overload.put",
+        "name": "test_conflicting_body_methods_overload.two",
         "foo": None,
         "body": data,
     }
     _, response = app.test_client.put("/p/test", json=payload)
     assert response.status == 200
     assert response.json == {
-        "name": "test_conflicting_body_methods_overload.put",
+        "name": "test_conflicting_body_methods_overload.three",
         "foo": "test",
         "body": data,
     }
@@ -2246,9 +2262,26 @@ def test_conflicting_body_methods_overload(app):
     }
 
 
-def test_handler_overload(app):
+@pytest.mark.asyncio
+async def test_handler_overload_error(app: Sanic):
     @app.get("/long/sub/route/param_a/<param_a:str>/param_b/<param_b:str>")
     @app.post("/long/sub/route/")
+    def handler(request, **kwargs):
+        ...
+
+    with pytest.raises(
+        ServerError,
+        match="Duplicate route names detected: test_handler_overload_error\.handler.*",
+    ):
+        await app._startup()
+
+
+def test_handler_overload(app: Sanic):
+    @app.get(
+        "/long/sub/route/param_a/<param_a:str>/param_b/<param_b:str>",
+        name="one",
+    )
+    @app.post("/long/sub/route/", name="two")
     def handler(request, **kwargs):
         return json(kwargs)
 

tests/test_response_file.py

@@ -0,0 +1,55 @@
+from datetime import datetime, timezone
+from logging import INFO
+
+import pytest
+
+from sanic.compat import Header
+from sanic.response.convenience import validate_file
+
+
+@pytest.mark.parametrize(
+    "ifmod,lastmod,expected",
+    (
+        ("Sat, 01 Apr 2023 00:00:00 GMT", 1672524000, None),
+        (
+            "Sat, 01 Apr 2023 00:00:00",
+            1672524000,
+            "converting if_modified_since",
+        ),
+        (
+            "Sat, 01 Apr 2023 00:00:00 GMT",
+            datetime(2023, 1, 1, 0, 0, 0),
+            "converting last_modified",
+        ),
+        (
+            "Sat, 01 Apr 2023 00:00:00",
+            datetime(2023, 1, 1, 0, 0, 0),
+            None,
+        ),
+        (
+            "Sat, 01 Apr 2023 00:00:00 GMT",
+            datetime(2023, 1, 1, 0, 0, 0).replace(tzinfo=timezone.utc),
+            None,
+        ),
+        (
+            "Sat, 01 Apr 2023 00:00:00",
+            datetime(2023, 1, 1, 0, 0, 0).replace(tzinfo=timezone.utc),
+            "converting if_modified_since",
+        ),
+    ),
+)
+@pytest.mark.asyncio
+async def test_file_timestamp_validation(
+    lastmod, ifmod, expected, caplog: pytest.LogCaptureFixture
+):
+    headers = Header([["If-Modified-Since", ifmod]])
+
+    with caplog.at_level(INFO):
+        response = await validate_file(headers, lastmod)
+    assert response.status == 304
+    records = caplog.records
+    if not expected:
+        assert len(records) == 0
+    else:
+        record = records[0]
+        assert expected in record.message

tests/test_routes.py

@@ -12,7 +12,7 @@ from sanic_testing.testing import SanicTestClient
 
 from sanic import Blueprint, Sanic
 from sanic.constants import HTTP_METHODS
-from sanic.exceptions import NotFound, SanicException
+from sanic.exceptions import NotFound, SanicException, ServerError
 from sanic.request import Request
 from sanic.response import empty, json, text
 
@@ -744,8 +744,8 @@ def test_route_duplicate(app):
 
 
 def test_double_stack_route(app):
-    @app.route("/test/1")
+    @app.route("/test/1", name="test1")
-    @app.route("/test/2")
+    @app.route("/test/2", name="test2")
     async def handler1(request):
         return text("OK")
 
@@ -759,8 +759,8 @@ def test_double_stack_route(app):
 async def test_websocket_route_asgi(app):
     ev = asyncio.Event()
 
-    @app.websocket("/test/1")
+    @app.websocket("/test/1", name="test1")
-    @app.websocket("/test/2")
+    @app.websocket("/test/2", name="test2")
     async def handler(request, ws):
         ev.set()
 
@@ -1279,7 +1279,7 @@ async def test_added_callable_route_ctx_kwargs(app):
 
 
 @pytest.mark.asyncio
-async def test_duplicate_route_deprecation(app):
+async def test_duplicate_route_error(app):
     @app.route("/foo", name="duped")
     async def handler_foo(request):
         return text("...")
@@ -1289,9 +1289,7 @@ async def test_duplicate_route_deprecation(app):
         return text("...")
 
     message = (
-        r"\[DEPRECATION v23\.3\] Duplicate route names detected: "
+        "Duplicate route names detected: test_duplicate_route_error.duped."
-        r"test_duplicate_route_deprecation\.duped\. In the future, "
-        r"Sanic will enforce uniqueness in route naming\."
     )
-    with pytest.warns(DeprecationWarning, match=message):
+    with pytest.raises(ServerError, match=message):
         await app._startup()

tests/test_signal_handlers.py

@@ -66,8 +66,8 @@ def test_no_register_system_signals_fails(app):
     app.listener("after_server_stop")(after)
 
     message = (
-        "Cannot run Sanic.serve with register_sys_signals=False. Use "
+        r"Cannot run Sanic\.serve with register_sys_signals=False\. Use "
-        "either Sanic.serve_single or Sanic.serve_legacy."
+        r"Sanic.serve_single\."
     )
     with pytest.raises(RuntimeError, match=message):
         app.prepare(HOST, PORT, register_sys_signals=False)

tests/test_static.py

@@ -9,7 +9,7 @@ from time import gmtime, strftime
 import pytest
 
 from sanic import Sanic, text
-from sanic.exceptions import FileNotFound
+from sanic.exceptions import FileNotFound, ServerError
 
 
 @pytest.fixture(scope="module")
@@ -108,14 +108,9 @@ 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
-    message = (
+    message = "Static file or directory must be a path-like object or string"
-        "Serving a static directory with a bytes "
+    with pytest.raises(TypeError, match=message):
-        "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
 
 
 @pytest.mark.parametrize(
@@ -523,10 +518,26 @@ def test_no_stack_trace_on_not_found(app, static_file_directory, caplog):
     assert response.text == "No file: /static/non_existing_file.file"
 
 
-def test_multiple_statics(app, static_file_directory):
+@pytest.mark.asyncio
+async def test_multiple_statics_error(app, static_file_directory):
     app.static("/file", get_file_path(static_file_directory, "test.file"))
     app.static("/png", get_file_path(static_file_directory, "python.png"))
 
+    message = (
+        r"Duplicate route names detected: test_multiple_statics_error\.static"
+    )
+    with pytest.raises(ServerError, match=message):
+        await app._startup()
+
+
+def test_multiple_statics(app, static_file_directory):
+    app.static(
+        "/file", get_file_path(static_file_directory, "test.file"), name="file"
+    )
+    app.static(
+        "/png", get_file_path(static_file_directory, "python.png"), name="png"
+    )
+
     _, response = app.test_client.get("/file")
     assert response.status == 200
     assert response.body == get_file_content(
@@ -540,10 +551,22 @@ def test_multiple_statics(app, static_file_directory):
     )
 
 
-def test_resource_type_default(app, static_file_directory):
+@pytest.mark.asyncio
+async def test_resource_type_default_error(app, static_file_directory):
     app.static("/static", static_file_directory)
     app.static("/file", get_file_path(static_file_directory, "test.file"))
 
+    message = r"Duplicate route names detected: test_resource_type_default_error\.static"
+    with pytest.raises(ServerError, match=message):
+        await app._startup()
+
+
+def test_resource_type_default(app, static_file_directory):
+    app.static("/static", static_file_directory, name="static")
+    app.static(
+        "/file", get_file_path(static_file_directory, "test.file"), name="file"
+    )
+
     _, response = app.test_client.get("/static")
     assert response.status == 404
 

tests/test_tls.py

@@ -12,7 +12,7 @@ from urllib.parse import urlparse
 
 import pytest
 
-from sanic_testing.testing import HOST, PORT
+from sanic_testing.testing import HOST, PORT, SanicTestClient
 
 import sanic.http.tls.creators
 
@@ -29,16 +29,24 @@ from sanic.http.tls.creators import (
     get_ssl_context,
 )
 from sanic.response import text
+from sanic.worker.loader import CertLoader
 
 
 current_dir = os.path.dirname(os.path.realpath(__file__))
 localhost_dir = os.path.join(current_dir, "certs/localhost")
+password_dir = os.path.join(current_dir, "certs/password")
 sanic_dir = os.path.join(current_dir, "certs/sanic.example")
 invalid_dir = os.path.join(current_dir, "certs/invalid.nonexist")
 localhost_cert = os.path.join(localhost_dir, "fullchain.pem")
 localhost_key = os.path.join(localhost_dir, "privkey.pem")
 sanic_cert = os.path.join(sanic_dir, "fullchain.pem")
 sanic_key = os.path.join(sanic_dir, "privkey.pem")
+password_dict = {
+    "cert": os.path.join(password_dir, "fullchain.pem"),
+    "key": os.path.join(password_dir, "privkey.pem"),
+    "password": "password",
+    "names": ["localhost"],
+}
 
 
 @pytest.fixture
@@ -420,6 +428,29 @@ def test_no_certs_on_list(app):
     assert "No certificates" in str(excinfo.value)
 
 
+def test_custom_cert_loader():
+    class MyCertLoader(CertLoader):
+        def load(self, app: Sanic):
+            self._ssl_data = {
+                "key": localhost_key,
+                "cert": localhost_cert,
+            }
+            return super().load(app)
+
+    app = Sanic("custom", certloader_class=MyCertLoader)
+
+    @app.get("/test")
+    async def handler(request):
+        return text("ssl test")
+
+    client = SanicTestClient(app, port=44556)
+
+    request, response = client.get("https://localhost:44556/test")
+    assert request.scheme == "https"
+    assert response.status_code == 200
+    assert response.text == "ssl test"
+
+
 def test_logger_vhosts(caplog):
     app = Sanic(name="test_logger_vhosts")
 
@@ -677,3 +708,34 @@ def test_ssl_in_multiprocess_mode(app: Sanic, caplog):
         logging.INFO,
         "Goin' Fast @ https://127.0.0.1:8000",
     ) in caplog.record_tuples
+
+
+@pytest.mark.skipif(
+    sys.platform not in ("linux", "darwin"),
+    reason="This test requires fork context",
+)
+def test_ssl_in_multiprocess_mode_password(
+    app: Sanic, caplog: pytest.LogCaptureFixture
+):
+    event = Event()
+
+    @app.main_process_start
+    async def main_start(app: Sanic):
+        app.shared_ctx.event = event
+
+    @app.after_server_start
+    async def shutdown(app):
+        app.shared_ctx.event.set()
+        app.stop()
+
+    assert not event.is_set()
+    with use_context("fork"):
+        with caplog.at_level(logging.INFO):
+            app.run(ssl=password_dict)
+    assert event.is_set()
+
+    assert (
+        "sanic.root",
+        logging.INFO,
+        "Goin' Fast @ https://127.0.0.1:8000",
+    ) in caplog.record_tuples

tests/worker/test_loader.py

@@ -52,34 +52,23 @@ def test_cwd_in_path():
 
 def test_input_is_dir():
     loader = AppLoader(str(STATIC))
-    message = (
+    app = loader.load()
-        "App not found.\n   Please use --simple if you are passing a "
+    assert isinstance(app, Sanic)
-        f"directory to sanic.\n   eg. sanic {str(STATIC)} --simple"
-    )
-    with pytest.raises(ValueError, match=message):
-        loader.load()
 
 
 def test_input_is_factory():
-    ns = SimpleNamespace(module="foo")
+    ns = SimpleNamespace(target="foo")
     loader = AppLoader("tests.fake.server:create_app", args=ns)
-    message = (
+    app = loader.load()
-        "Module is not a Sanic app, it is a function\n  If this callable "
+    assert isinstance(app, Sanic)
-        "returns a Sanic instance try: \nsanic foo --factory"
-    )
-    with pytest.raises(ValueError, match=message):
-        loader.load()
 
 
 def test_input_is_module():
-    ns = SimpleNamespace(module="foo")
+    ns = SimpleNamespace(target="foo")
     loader = AppLoader("tests.fake.server", args=ns)
-    message = (
+
-        "Module is not a Sanic app, it is a module\n  "
+    app = loader.load()
-        "Perhaps you meant foo:app?"
+    assert isinstance(app, Sanic)
-    )
-    with pytest.raises(ValueError, match=message):
-        loader.load()
 
 
 @pytest.mark.parametrize("creator", ("mkcert", "trustme"))

tests/worker/test_multiplexer.py

@@ -72,24 +72,6 @@ def test_not_have_multiplexer_single(app: Sanic):
     assert not event.is_set()
 
 
-def test_not_have_multiplexer_legacy(app: Sanic):
-    event = Event()
-
-    @app.main_process_start
-    async def setup(app, _):
-        app.shared_ctx.event = event
-
-    @app.after_server_start
-    def stop(app):
-        if hasattr(app, "m") and isinstance(app.m, WorkerMultiplexer):
-            app.shared_ctx.event.set()
-        app.stop()
-
-    app.run(legacy=True)
-
-    assert not event.is_set()
-
-
 def test_ack(worker_state: Dict[str, Any], m: WorkerMultiplexer):
     worker_state["Test"] = {"foo": "bar"}
     m.ack()