Merge branch 'main' into accept-enhance

Co-authored-by: L. Karkkainen <tronic@users.noreply.github.com>
Co-authored-by: Adam Hopkins <adam@amhopkins.com>

.black.toml

@@ -1,2 +0,0 @@
-[tool.black]
-line-length = 79

.coveragerc

@@ -4,11 +4,12 @@ source = sanic
 omit =
     site-packages
     sanic/__main__.py
+    sanic/server/legacy.py
     sanic/compat.py
-    sanic/reloader_helpers.py
     sanic/simple.py
     sanic/utils.py
     sanic/cli
+    sanic/pages
 
 [html]
 directory = coverage
@@ -20,12 +21,5 @@ exclude_lines =
     noqa
     NOQA
     pragma: no cover
-omit =
-    site-packages
-    sanic/__main__.py
-    sanic/compat.py
-    sanic/reloader_helpers.py
-    sanic/simple.py
-    sanic/utils.py
-    sanic/cli
+    TYPE_CHECKING
 skip_empty = True

.github/ISSUE_TEMPLATE/bug-report.yml

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

.github/ISSUE_TEMPLATE/bug_report.md

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

.github/ISSUE_TEMPLATE/config.yml

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

.github/ISSUE_TEMPLATE/feature-request.yml

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

.github/ISSUE_TEMPLATE/feature_request.md

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

.github/workflows/pr-bandit.yml

@@ -20,6 +20,7 @@ jobs:
           - { python-version: 3.8, tox-env: security}
           - { python-version: 3.9, tox-env: security}
           - { python-version: "3.10", tox-env: security}
+          - { python-version: "3.11", tox-env: security}
     steps:
       - name: Checkout the repository
         uses: actions/checkout@v2

.github/workflows/pr-docs.yml

@@ -14,7 +14,7 @@ jobs:
     strategy:
       matrix:
         config:
-          - {python-version: "3.8", tox-env: "docs"}
+          - {python-version: "3.10", tox-env: "docs"}
       fail-fast: false
 
 

.github/workflows/pr-linter.yml

@@ -16,7 +16,7 @@ jobs:
       matrix:
         os: [ubuntu-latest]
         config:
-          - { python-version: 3.8, tox-env: lint}
+          - { python-version: "3.10", tox-env: lint}
     steps:
       - name: Checkout the repository
         uses: actions/checkout@v2

.github/workflows/pr-python311.yml

@@ -0,0 +1,47 @@
+name: Python 3.11 Tests
+on:
+  pull_request:
+    branches:
+      - main
+      - "*LTS"
+    types: [opened, synchronize, reopened, ready_for_review]
+
+jobs:
+  testPy311:
+    if: github.event.pull_request.draft == false
+    name: ut-${{ matrix.config.tox-env }}-${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        # os: [ubuntu-latest, macos-latest]
+        os: [ubuntu-latest]
+        config:
+          - {
+              python-version: "3.11",
+              tox-env: py311,
+              ignore-error-flake: "false",
+              command-timeout: "0",
+            }
+          - {
+              python-version: "3.11",
+              tox-env: py311-no-ext,
+              ignore-error-flake: "true",
+              command-timeout: "600000",
+            }
+    steps:
+      - name: Checkout the Repository
+        uses: actions/checkout@v2
+        id: checkout-branch
+
+      - name: Run Unit Tests
+        uses: harshanarayana/custom-actions@main
+        with:
+          python-version: ${{ matrix.config.python-version }}
+          test-infra-tool: tox
+          test-infra-version: latest
+          action: tests
+          test-additional-args: "-e=${{ matrix.config.tox-env }},-vv=''"
+          experimental-ignore-error: "${{ matrix.config.ignore-error-flake }}"
+          command-timeout: "${{ matrix.config.command-timeout }}"
+          test-failure-retry: "3"

.github/workflows/pr-type-check.yml

@@ -20,6 +20,7 @@ jobs:
           - { python-version: 3.8, tox-env: type-checking}
           - { python-version: 3.9, tox-env: type-checking}
           - { python-version: "3.10", tox-env: type-checking}
+          - { python-version: "3.11", tox-env: type-checking}
     steps:
       - name: Checkout the repository
         uses: actions/checkout@v2

.github/workflows/pr-windows.yml

@@ -19,6 +19,7 @@ jobs:
           - { python-version: 3.8, tox-env: py38-no-ext }
           - { python-version: 3.9, tox-env: py39-no-ext }
           - { python-version: "3.10", tox-env: py310-no-ext }
+          - { python-version: "3.11", tox-env: py310-no-ext }
           - { python-version: pypy-3.7, tox-env: pypy37-no-ext }
 
     steps:

.github/workflows/publish-images.yml

@@ -14,7 +14,7 @@ jobs:
     strategy:
       fail-fast: true
       matrix:
-        python-version: ["3.7", "3.8", "3.9", "3.10"]
+        python-version: ["3.7", "3.8", "3.9", "3.10", "3.11"]
 
     steps:
       - name: Checkout repository

.github/workflows/publish-package.yml

@@ -11,7 +11,7 @@ jobs:
     strategy:
       fail-fast: true
       matrix:
-        python-version: ["3.8"]
+        python-version: ["3.10"]
 
     steps:
       - name: Checkout Repository

CHANGELOG.rst

@@ -316,6 +316,8 @@ Version 21.3.0
 Version 20.12.3
 ---------------
 
+`Current LTS version`
+
 **Bugfixes**
 
   *
@@ -357,11 +359,6 @@ Version 20.12.0
     `#1993 <https://github.com/sanic-org/sanic/pull/1993>`_
     Add disable app registry
 
-Version 20.12.0
----------------
-
-**Features**
-
   *
     `#1945 <https://github.com/sanic-org/sanic/pull/1945>`_
     Static route more verbose if file not found

CODE_OF_CONDUCT.md

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

CONTRIBUTING.rst

@@ -71,9 +71,9 @@ To execute only unittests, run ``tox`` with environment like so:
 
 .. code-block:: bash
 
-   tox -e py36 -v -- tests/test_config.py
-   # or
    tox -e py37 -v -- tests/test_config.py
+   # or
+   tox -e py310 -v -- tests/test_config.py
 
 Run lint checks
 ---------------
@@ -140,6 +140,7 @@ To maintain the code consistency, Sanic uses following tools.
 #. `isort <https://github.com/timothycrosley/isort>`_
 #. `black <https://github.com/python/black>`_
 #. `flake8 <https://github.com/PyCQA/flake8>`_
+#. `slotscheck <https://github.com/ariebovenberg/slotscheck>`_
 
 isort
 *****
@@ -167,7 +168,13 @@ flake8
 #. pycodestyle
 #. Ned Batchelder's McCabe script
 
-``isort``\ , ``black`` and ``flake8`` checks are performed during ``tox`` lint checks.
+slotscheck
+**********
+
+``slotscheck`` ensures that there are no problems with ``__slots__``
+(e.g. overlaps, or missing slots in base classes).
+
+``isort``\ , ``black``\ , ``flake8`` and ``slotscheck`` checks are performed during ``tox`` lint checks.
 
 The **easiest** way to make your code conform is to run the following before committing.
 

Makefile

@@ -66,15 +66,15 @@ ifdef include_tests
 	isort -rc sanic tests
 else
 	$(info Sorting Imports)
-	isort -rc sanic tests  --profile=black
+	isort -rc sanic tests
 endif
 endif
 
 black:
-	black --config ./.black.toml sanic tests
+	black sanic tests
 
 isort:
-	isort sanic tests --profile=black
+	isort sanic tests
 
 pretty: black isort
 

README.rst

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

SECURITY.md

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

codecov.yml

@@ -4,6 +4,7 @@ coverage:
       default:
         target: auto
         threshold: 0.75
+        informational: true
     project:
       default:
         target: auto
@@ -14,10 +15,10 @@ codecov:
 ignore:
   - "sanic/__main__.py"
   - "sanic/compat.py"
-  - "sanic/reloader_helpers.py"
   - "sanic/simple.py"
   - "sanic/utils.py"
-  - "sanic/cli"
+  - "sanic/cli/"
+  - "sanic/pages/"
   - ".github/"
   - "changelogs/"
   - "docker/"

docs/_static/custom.css

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

docs/conf.py

@@ -24,7 +24,11 @@ import sanic
 
 # -- General configuration ------------------------------------------------
 
-extensions = ["sphinx.ext.autodoc", "m2r2"]
+extensions = [
+    "sphinx.ext.autodoc",
+    "m2r2",
+    "enum_tools.autoenum",
+]
 
 templates_path = ["_templates"]
 

docs/index.rst

@@ -9,7 +9,7 @@ API
 ===
 
 .. toctree::
-   :maxdepth: 2
+   :maxdepth: 3
 
    👥 User Guide <https://sanicframework.org/guide/>
    sanic/api_reference

docs/sanic/api/app.rst

@@ -15,3 +15,19 @@ sanic.config
 .. automodule:: sanic.config
     :members:
     :show-inheritance:
+
+sanic.application.constants
+---------------------------
+
+.. automodule:: sanic.application.constants
+    :exclude-members: StrEnum
+    :members:
+    :show-inheritance:
+    :inherited-members:
+
+sanic.application.state
+-----------------------
+
+.. automodule:: sanic.application.state
+    :members:
+    :show-inheritance:

docs/sanic/api/core.rst

@@ -17,6 +17,14 @@ sanic.handlers
     :show-inheritance:
 
 
+sanic.headers
+--------------
+
+.. automodule:: sanic.headers
+    :members:
+    :show-inheritance:
+
+
 sanic.request
 -------------
 

docs/sanic/api/server.rst

@@ -16,10 +16,3 @@ sanic.server
     :members:
     :show-inheritance:
 
-
-sanic.worker
-------------
-
-.. automodule:: sanic.worker
-    :members:
-    :show-inheritance:

docs/sanic/changelog.rst

@@ -1,6 +1,10 @@
 📜 Changelog
 ============
 
+.. mdinclude:: ./releases/22/22.12.md
+.. mdinclude:: ./releases/22/22.9.md
+.. mdinclude:: ./releases/22/22.6.md
+.. mdinclude:: ./releases/22/22.3.md
 .. mdinclude:: ./releases/21/21.12.md
 .. mdinclude:: ./releases/21/21.9.md
 .. include:: ../../CHANGELOG.rst

docs/sanic/releases/21/21.12.md

@@ -1,10 +1,12 @@
-## Version 21.12.1
+## Version 21.12.1 🔷
+
+_Current LTS version_
 
 - [#2349](https://github.com/sanic-org/sanic/pull/2349) Only display MOTD on startup
 - [#2354](https://github.com/sanic-org/sanic/pull/2354) Ignore name argument in Python 3.7
 - [#2355](https://github.com/sanic-org/sanic/pull/2355) Add config.update support for all config values
 
-## Version 21.12.0
+## Version 21.12.0 🔹
 
 ### Features
 - [#2260](https://github.com/sanic-org/sanic/pull/2260) Allow early Blueprint registrations to still apply later added objects

docs/sanic/releases/22/22.12.md

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

docs/sanic/releases/22/22.3.md

@@ -0,0 +1,52 @@
+## Version 22.3.0
+
+### Features
+- [#2347](https://github.com/sanic-org/sanic/pull/2347) API for multi-application server
+    - 🚨 *BREAKING CHANGE*: The old `sanic.worker.GunicornWorker` has been **removed**. To run Sanic with `gunicorn`, you should use it thru `uvicorn` [as described in their docs](https://www.uvicorn.org/#running-with-gunicorn).
+    - 🧁 *SIDE EFFECT*: Named background tasks are now supported, even in Python 3.7
+- [#2357](https://github.com/sanic-org/sanic/pull/2357) Parse `Authorization` header as `Request.credentials`
+- [#2361](https://github.com/sanic-org/sanic/pull/2361) Add config option to skip `Touchup` step in application startup
+- [#2372](https://github.com/sanic-org/sanic/pull/2372) Updates to CLI help messaging
+- [#2382](https://github.com/sanic-org/sanic/pull/2382) Downgrade warnings to backwater debug messages 
+- [#2396](https://github.com/sanic-org/sanic/pull/2396) Allow for `multidict` v0.6
+- [#2401](https://github.com/sanic-org/sanic/pull/2401) Upgrade CLI catching for alternative application run types
+- [#2402](https://github.com/sanic-org/sanic/pull/2402) Conditionally inject CLI arguments into factory
+- [#2413](https://github.com/sanic-org/sanic/pull/2413) Add new start and stop event listeners to reloader process
+- [#2414](https://github.com/sanic-org/sanic/pull/2414) Remove loop as required listener arg
+- [#2415](https://github.com/sanic-org/sanic/pull/2415) Better exception for bad URL parsing
+- [sanic-routing#47](https://github.com/sanic-org/sanic-routing/pull/47) Add a new extention parameter type: `<file:ext>`, `<file:ext=jpg>`, `<file:ext=jpg|png|gif|svg>`, `<file=int:ext>`, `<file=int:ext=jpg|png|gif|svg>`, `<file=float:ext=tar.gz>`
+    - 👶 *BETA FEATURE*: This feature will not work with `path` type matching, and is being released as a beta feature only.
+- [sanic-routing#57](https://github.com/sanic-org/sanic-routing/pull/57) Change `register_pattern` to accept a `str` or `Pattern`
+- [sanic-routing#58](https://github.com/sanic-org/sanic-routing/pull/58) Default matching on non-empty strings only, and new `strorempty` pattern type
+    - 🚨 *BREAKING CHANGE*: Previously a route with a dynamic string parameter (`/<foo>` or `/<foo:str>`) would match on any string, including empty strings. It will now **only** match a non-empty string. To retain the old behavior, you should use the new parameter type: `/<foo:strorempty>`.
+
+### Bugfixes
+- [#2373](https://github.com/sanic-org/sanic/pull/2373) Remove `error_logger` on websockets
+- [#2381](https://github.com/sanic-org/sanic/pull/2381) Fix newly assigned `None` in task registry
+- [sanic-routing#52](https://github.com/sanic-org/sanic-routing/pull/52) Add type casting to regex route matching
+- [sanic-routing#60](https://github.com/sanic-org/sanic-routing/pull/60) Add requirements check on regex routes (this resolves, for example, multiple static directories with differing `host` values)
+
+### Deprecations and Removals
+- [#2362](https://github.com/sanic-org/sanic/pull/2362) 22.3 Deprecations and changes
+    1. `debug=True` and `--debug` do _NOT_ automatically run `auto_reload`
+    2. Default error render is with plain text (browsers still get HTML by default because `auto` looks at headers)
+    3. `config` is required for `ErrorHandler.finalize`
+    4. `ErrorHandler.lookup` requires two positional args
+    5. Unused websocket protocol args removed
+- [#2344](https://github.com/sanic-org/sanic/pull/2344) Deprecate loading of lowercase environment variables
+
+### Developer infrastructure
+- [#2363](https://github.com/sanic-org/sanic/pull/2363) Revert code coverage back to Codecov
+- [#2405](https://github.com/sanic-org/sanic/pull/2405) Upgrade tests for `sanic-routing` changes
+- [sanic-testing#35](https://github.com/sanic-org/sanic-testing/pull/35) Allow for httpx v0.22
+
+### Improved Documentation
+- [#2350](https://github.com/sanic-org/sanic/pull/2350) Fix link in README for ASGI
+- [#2398](https://github.com/sanic-org/sanic/pull/2398) Document middleware on_request and on_response
+- [#2409](https://github.com/sanic-org/sanic/pull/2409) Add missing documentation for `Request.respond`
+
+### Miscellaneous
+- [#2376](https://github.com/sanic-org/sanic/pull/2376) Fix typing for `ListenerMixin.listener`
+- [#2383](https://github.com/sanic-org/sanic/pull/2383) Clear deprecation warning in `asyncio.wait`
+- [#2387](https://github.com/sanic-org/sanic/pull/2387) Cleanup `__slots__` implementations
+- [#2390](https://github.com/sanic-org/sanic/pull/2390) Clear deprecation warning in `asyncio.get_event_loop`

docs/sanic/releases/22/22.6.md

@@ -0,0 +1,54 @@
+## Version 22.6.2
+
+### Bugfixes
+
+- [#2522](https://github.com/sanic-org/sanic/pull/2522) Always show server location in ASGI
+
+## Version 22.6.1
+
+### Bugfixes
+
+- [#2477](https://github.com/sanic-org/sanic/pull/2477) Sanic static directory fails when folder name ends with ".."
+
+
+## Version 22.6.0
+
+### Features
+- [#2378](https://github.com/sanic-org/sanic/pull/2378) Introduce HTTP/3 and autogeneration of TLS certificates in `DEBUG` mode
+    - 👶 *EARLY RELEASE FEATURE*: Serving Sanic over HTTP/3 is an early release feature. It does not yet fully cover the HTTP/3 spec, but instead aims for feature parity with Sanic's existing HTTP/1.1 server. Websockets, WebTransport, push responses are examples of some features not yet implemented.
+    - 📦 *EXTRA REQUIREMENT*: Not all HTTP clients are capable of interfacing with HTTP/3 servers. You may need to install a [HTTP/3 capable client](https://curl.se/docs/http3.html).
+    - 📦 *EXTRA REQUIREMENT*: In order to use TLS autogeneration, you must install either [mkcert](https://github.com/FiloSottile/mkcert) or [trustme](https://github.com/python-trio/trustme).
+- [#2416](https://github.com/sanic-org/sanic/pull/2416) Add message to `task.cancel`
+- [#2420](https://github.com/sanic-org/sanic/pull/2420) Add exception aliases for more consistent naming with standard HTTP response types (`BadRequest`, `MethodNotAllowed`, `RangeNotSatisfiable`)
+- [#2432](https://github.com/sanic-org/sanic/pull/2432) Expose ASGI `scope` as a property on the `Request` object
+- [#2438](https://github.com/sanic-org/sanic/pull/2438) Easier access to websocket class for annotation: `from sanic import Websocket`
+- [#2439](https://github.com/sanic-org/sanic/pull/2439) New API for reading form values with options: `Request.get_form` 
+- [#2445](https://github.com/sanic-org/sanic/pull/2445) Add custom `loads` function
+- [#2447](https://github.com/sanic-org/sanic/pull/2447), [#2486](https://github.com/sanic-org/sanic/pull/2486) Improved API to support setting cache control headers
+- [#2453](https://github.com/sanic-org/sanic/pull/2453) Move verbosity filtering to logger
+- [#2475](https://github.com/sanic-org/sanic/pull/2475) Expose getter for current request using `Request.get_current()`
+
+### Bugfixes
+- [#2448](https://github.com/sanic-org/sanic/pull/2448) Fix to allow running with `pythonw.exe` or places where there is no `sys.stdout`
+- [#2451](https://github.com/sanic-org/sanic/pull/2451) Trigger `http.lifecycle.request` signal in ASGI mode
+- [#2455](https://github.com/sanic-org/sanic/pull/2455) Resolve typing of stacked route definitions
+- [#2463](https://github.com/sanic-org/sanic/pull/2463) Properly catch websocket CancelledError in websocket handler in Python 3.7
+
+### Deprecations and Removals
+- [#2487](https://github.com/sanic-org/sanic/pull/2487) v22.6 deprecations and changes
+    1. Optional application registry
+    1. Execution of custom handlers after some part of response was sent
+    1. Configuring fallback handlers on the `ErrorHandler`
+    1. Custom `LOGO` setting
+    1. `sanic.response.stream`
+    1. `AsyncioServer.init`
+
+### Developer infrastructure
+- [#2449](https://github.com/sanic-org/sanic/pull/2449) Clean up `black` and `isort` config
+- [#2479](https://github.com/sanic-org/sanic/pull/2479) Fix some flappy tests
+
+### Improved Documentation
+- [#2461](https://github.com/sanic-org/sanic/pull/2461) Update example to match current application naming standards
+- [#2466](https://github.com/sanic-org/sanic/pull/2466) Better type annotation for `Extend`
+- [#2485](https://github.com/sanic-org/sanic/pull/2485) Improved help messages in CLI
+

docs/sanic/releases/22/22.9.md

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

examples/delayed_response.py

@@ -4,6 +4,7 @@ from sanic import Sanic, response
 
 
 app = Sanic("DelayedResponseApp", strict_slashes=True)
+app.config.AUTO_EXTEND = False
 
 
 @app.get("/")
@@ -11,7 +12,7 @@ async def handler(request):
     return response.redirect("/sleep/3")
 
 
-@app.get("/sleep/<t:number>")
+@app.get("/sleep/<t:float>")
 async def handler2(request, t=0.3):
     await sleep(t)
     return response.text(f"Slept {t:.1f} seconds.\n")

examples/unix_socket.py

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

pyproject.toml

@@ -1,3 +1,28 @@
 [build-system]
 requires = ["setuptools<60.0", "wheel"]
 build-backend = "setuptools.build_meta"
+
+[tool.black]
+line-length = 79
+
+[tool.isort]
+atomic = true
+default_section = "THIRDPARTY"
+include_trailing_comma = true
+known_first_party = "sanic"
+known_third_party = "pytest"
+line_length = 79
+lines_after_imports = 2
+lines_between_types = 1
+multi_line_output = 3
+profile = "black"
+
+[[tool.mypy.overrides]]
+module = [
+    "httptools.*",
+    "trustme.*",
+    "sanic_routing.*",
+    "aioquic.*",
+    "html5tagger.*",
+]
+ignore_missing_imports = true

sanic/__init__.py

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

sanic/__main__.py

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

sanic/__version__.py

@@ -1 +1 @@
-__version__ = "22.3.0.dev1"
+__version__ = "22.12.0"

sanic/application/constants.py

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

sanic/application/ext.py

@@ -5,14 +5,9 @@ from importlib import import_module
 from typing import TYPE_CHECKING
 
 
-if TYPE_CHECKING:  # no cov
+if TYPE_CHECKING:
     from sanic import Sanic
 
-    try:
-        from sanic_ext import Extend  # type: ignore
-    except ImportError:
-        ...
-
 
 def setup_ext(app: Sanic, *, fail: bool = False, **kwargs):
     if not app.config.AUTO_EXTEND:
@@ -22,7 +17,7 @@ def setup_ext(app: Sanic, *, fail: bool = False, **kwargs):
     with suppress(ModuleNotFoundError):
         sanic_ext = import_module("sanic_ext")
 
-    if not sanic_ext:
+    if not sanic_ext:  # no cov
         if fail:
             raise RuntimeError(
                 "Sanic Extensions is not installed. You can add it to your "
@@ -33,7 +28,7 @@ def setup_ext(app: Sanic, *, fail: bool = False, **kwargs):
         return
 
     if not getattr(app, "_ext", None):
-        Ext: Extend = getattr(sanic_ext, "Extend")
+        Ext = getattr(sanic_ext, "Extend")
         app._ext = Ext(app, **kwargs)
 
         return app.ext

sanic/application/logo.py

@@ -3,6 +3,8 @@ import sys
 
 from os import environ
 
+from sanic.compat import is_atty
+
 
 BASE_LOGO = """
 
@@ -38,13 +40,15 @@ 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
+
 ansi_pattern = re.compile(r"\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])")
 
 
 def get_logo(full=False, coffee=False):
     logo = (
         (FULL_COLOR_LOGO if full else (COFFEE_LOGO if coffee else COLOR_LOGO))
-        if sys.stdout.isatty()
+        if is_atty()
         else BASE_LOGO
     )
 

sanic/application/motd.py

@@ -1,11 +1,10 @@
-import sys
-
 from abc import ABC, abstractmethod
 from shutil import get_terminal_size
 from textwrap import indent, wrap
 from typing import Dict, Optional
 
 from sanic import __version__
+from sanic.compat import is_atty
 from sanic.log import logger
 
 
@@ -36,7 +35,7 @@ class MOTD(ABC):
         data: Dict[str, str],
         extra: Dict[str, str],
     ) -> None:
-        motd_class = MOTDTTY if sys.stdout.isatty() else MOTDBasic
+        motd_class = MOTDTTY if is_atty() else MOTDBasic
         motd_class(logo, serve_location, data, extra).display()
 
 
@@ -81,20 +80,23 @@ class MOTDTTY(MOTD):
         )
         self.display_length = self.key_width + self.value_width + 2
 
-    def display(self):
-        version = f"Sanic v{__version__}".center(self.centering_length)
+    def display(self, version=True, action="Goin' Fast", out=None):
+        if not out:
+            out = logger.info
+        header = "Sanic"
+        if version:
+            header += f" v{__version__}"
+        header = header.center(self.centering_length)
         running = (
-            f"Goin' Fast @ {self.serve_location}"
-            if self.serve_location
-            else ""
+            f"{action} @ {self.serve_location}" if self.serve_location else ""
         ).center(self.centering_length)
-        length = len(version) + 2 - self.logo_line_length
+        length = len(header) + 2 - self.logo_line_length
         first_filler = "─" * (self.logo_line_length - 1)
         second_filler = "─" * length
         display_filler = "─" * (self.display_length + 2)
         lines = [
             f"\n┌{first_filler}─{second_filler}┐",
-            f"│ {version} │",
+            f"│ {header} │",
             f"│ {running} │",
             f"├{first_filler}┬{second_filler}┤",
         ]
@@ -108,7 +110,7 @@ class MOTDTTY(MOTD):
         self._render_fill(lines)
 
         lines.append(f"└{first_filler}┴{second_filler}┘\n")
-        logger.info(indent("\n".join(lines), "  "))
+        out(indent("\n".join(lines), "  "))
 
     def _render_data(self, lines, data, start):
         offset = 0

sanic/application/spinner.py

@@ -0,0 +1,86 @@
+import os
+import sys
+import time
+
+from contextlib import contextmanager
+from queue import Queue
+from threading import Thread
+
+
+if os.name == "nt":  # noqa
+    import ctypes  # noqa
+
+    class _CursorInfo(ctypes.Structure):
+        _fields_ = [("size", ctypes.c_int), ("visible", ctypes.c_byte)]
+
+
+class Spinner:  # noqa
+    def __init__(self, message: str) -> None:
+        self.message = message
+        self.queue: Queue[int] = Queue()
+        self.spinner = self.cursor()
+        self.thread = Thread(target=self.run)
+
+    def start(self):
+        self.queue.put(1)
+        self.thread.start()
+        self.hide()
+
+    def run(self):
+        while self.queue.get():
+            output = f"\r{self.message} [{next(self.spinner)}]"
+            sys.stdout.write(output)
+            sys.stdout.flush()
+            time.sleep(0.1)
+            self.queue.put(1)
+
+    def stop(self):
+        self.queue.put(0)
+        self.thread.join()
+        self.show()
+
+    @staticmethod
+    def cursor():
+        while True:
+            for cursor in "|/-\\":
+                yield cursor
+
+    @staticmethod
+    def hide():
+        if os.name == "nt":
+            ci = _CursorInfo()
+            handle = ctypes.windll.kernel32.GetStdHandle(-11)
+            ctypes.windll.kernel32.GetConsoleCursorInfo(
+                handle, ctypes.byref(ci)
+            )
+            ci.visible = False
+            ctypes.windll.kernel32.SetConsoleCursorInfo(
+                handle, ctypes.byref(ci)
+            )
+        elif os.name == "posix":
+            sys.stdout.write("\033[?25l")
+            sys.stdout.flush()
+
+    @staticmethod
+    def show():
+        if os.name == "nt":
+            ci = _CursorInfo()
+            handle = ctypes.windll.kernel32.GetStdHandle(-11)
+            ctypes.windll.kernel32.GetConsoleCursorInfo(
+                handle, ctypes.byref(ci)
+            )
+            ci.visible = True
+            ctypes.windll.kernel32.SetConsoleCursorInfo(
+                handle, ctypes.byref(ci)
+            )
+        elif os.name == "posix":
+            sys.stdout.write("\033[?25h")
+            sys.stdout.flush()
+
+
+@contextmanager
+def loading(message: str = "Loading"):  # noqa
+    spinner = Spinner(message)
+    spinner.start()
+    yield
+    spinner.stop()

sanic/application/state.py

@@ -3,42 +3,20 @@ from __future__ import annotations
 import logging
 
 from dataclasses import dataclass, field
-from enum import Enum, IntEnum, auto
 from pathlib import Path
 from socket import socket
 from ssl import SSLContext
 from typing import TYPE_CHECKING, Any, Dict, List, Optional, Set, Union
 
-from sanic.log import logger
+from sanic.application.constants import Mode, Server, ServerStage
+from sanic.log import VerbosityFilter, logger
 from sanic.server.async_server import AsyncioServer
 
 
-if TYPE_CHECKING:  # no cov
+if TYPE_CHECKING:
     from sanic import Sanic
 
 
-class StrEnum(str, Enum):
-    def _generate_next_value_(name: str, *args) -> str:  # type: ignore
-        return name.lower()
-
-
-class Server(StrEnum):
-    SANIC = auto()
-    ASGI = auto()
-    GUNICORN = auto()
-
-
-class Mode(StrEnum):
-    PRODUCTION = auto()
-    DEBUG = auto()
-
-
-class ServerStage(IntEnum):
-    STOPPED = auto()
-    PARTIAL = auto()
-    SERVING = auto()
-
-
 @dataclass
 class ApplicationServerInfo:
     settings: Dict[str, Any]
@@ -91,6 +69,9 @@ class ApplicationState:
         if getattr(self.app, "configure_logging", False) and self.app.debug:
             logger.setLevel(logging.DEBUG)
 
+    def set_verbosity(self, value: int):
+        VerbosityFilter.verbosity = value
+
     @property
     def is_debug(self):
         return self.mode is Mode.DEBUG

sanic/asgi.py

@@ -7,9 +7,9 @@ from urllib.parse import quote
 
 from sanic.compat import Header
 from sanic.exceptions import ServerError
-from sanic.helpers import _default
+from sanic.helpers import Default
 from sanic.http import Stage
-from sanic.log import logger
+from sanic.log import error_logger, logger
 from sanic.models.asgi import ASGIReceive, ASGIScope, ASGISend, MockTransport
 from sanic.request import Request
 from sanic.response import BaseHTTPResponse
@@ -17,7 +17,7 @@ from sanic.server import ConnInfo
 from sanic.server.websockets.connection import WebSocketConnection
 
 
-if TYPE_CHECKING:  # no cov
+if TYPE_CHECKING:
     from sanic import Sanic
 
 
@@ -25,27 +25,28 @@ class Lifespan:
     def __init__(self, asgi_app: ASGIApp) -> None:
         self.asgi_app = asgi_app
 
-        if self.asgi_app.sanic_app.state.verbosity > 0:
-            if (
-                "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. "
-                    "It will be executed as early as possible, but not before "
-                    "the ASGI server is started."
-                )
-            if (
-                "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. "
-                    "It will be executed as late as possible, but not after "
-                    "the ASGI server is stopped."
-                )
+        if (
+            "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. "
+                "It will be executed as early as possible, but not before "
+                "the ASGI server is started.",
+                extra={"verbosity": 1},
+            )
+        if (
+            "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. "
+                "It will be executed as late as possible, but not after "
+                "the ASGI server is stopped.",
+                extra={"verbosity": 1},
+            )
 
     async def startup(self) -> None:
         """
@@ -60,7 +61,7 @@ class Lifespan:
         await self.asgi_app.sanic_app._server_event("init", "before")
         await self.asgi_app.sanic_app._server_event("init", "after")
 
-        if self.asgi_app.sanic_app.config.USE_UVLOOP is not _default:
+        if not isinstance(self.asgi_app.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."
@@ -84,13 +85,27 @@ class Lifespan:
     ) -> None:
         message = await receive()
         if message["type"] == "lifespan.startup":
-            await self.startup()
-            await send({"type": "lifespan.startup.complete"})
+            try:
+                await self.startup()
+            except Exception as e:
+                error_logger.exception(e)
+                await send(
+                    {"type": "lifespan.startup.failed", "message": str(e)}
+                )
+            else:
+                await send({"type": "lifespan.startup.complete"})
 
         message = await receive()
         if message["type"] == "lifespan.shutdown":
-            await self.shutdown()
-            await send({"type": "lifespan.shutdown.complete"})
+            try:
+                await self.shutdown()
+            except Exception as e:
+                error_logger.exception(e)
+                await send(
+                    {"type": "lifespan.shutdown.failed", "message": str(e)}
+                )
+            else:
+                await send({"type": "lifespan.shutdown.complete"})
 
 
 class ASGIApp:
@@ -163,6 +178,13 @@ class ASGIApp:
             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
 
     async def read(self) -> Optional[bytes]:
@@ -226,4 +248,7 @@ class ASGIApp:
             self.stage = Stage.HANDLER
             await self.sanic_app.handle_request(self.request)
         except Exception as e:
-            await self.sanic_app.handle_exception(self.request, e)
+            try:
+                await self.sanic_app.handle_exception(self.request, e)
+            except Exception as exc:
+                await self.sanic_app.handle_exception(self.request, exc, False)

sanic/base/root.py

@@ -1,6 +1,6 @@
 import re
 
-from typing import Any
+from typing import Any, Optional
 
 from sanic.base.meta import SanicMeta
 from sanic.exceptions import SanicException
@@ -9,6 +9,7 @@ from sanic.mixins.listeners import ListenerMixin
 from sanic.mixins.middleware import MiddlewareMixin
 from sanic.mixins.routes import RouteMixin
 from sanic.mixins.signals import SignalMixin
+from sanic.mixins.static import StaticMixin
 
 
 VALID_NAME = re.compile(r"^[a-zA-Z_][a-zA-Z0-9_\-]*$")
@@ -16,6 +17,7 @@ VALID_NAME = re.compile(r"^[a-zA-Z_][a-zA-Z0-9_\-]*$")
 
 class BaseSanic(
     RouteMixin,
+    StaticMixin,
     MiddlewareMixin,
     ListenerMixin,
     ExceptionMixin,
@@ -24,7 +26,9 @@ class BaseSanic(
 ):
     __slots__ = ("name",)
 
-    def __init__(self, name: str = None, *args: Any, **kwargs: Any) -> None:
+    def __init__(
+        self, name: Optional[str] = None, *args: Any, **kwargs: Any
+    ) -> None:
         class_name = self.__class__.__name__
 
         if name is None:

sanic/blueprint_group.py

@@ -5,7 +5,7 @@ from functools import partial
 from typing import TYPE_CHECKING, List, Optional, Union
 
 
-if TYPE_CHECKING:  # no cov
+if TYPE_CHECKING:
     from sanic.blueprints import Blueprint
 
 

sanic/blueprints.py

@@ -21,8 +21,8 @@ from typing import (
     Union,
 )
 
-from sanic_routing.exceptions import NotFound  # type: ignore
-from sanic_routing.route import Route  # type: ignore
+from sanic_routing.exceptions import NotFound
+from sanic_routing.route import Route
 
 from sanic.base.root import BaseSanic
 from sanic.blueprint_group import BlueprintGroup
@@ -36,7 +36,7 @@ from sanic.models.handler_types import (
 )
 
 
-if TYPE_CHECKING:  # no cov
+if TYPE_CHECKING:
     from sanic import Sanic
 
 
@@ -304,11 +304,8 @@ class Blueprint(BaseSanic):
 
         # Routes
         for future in self._future_routes:
-            # attach the blueprint name to the handler so that it can be
-            # prefixed properly in the router
-            future.handler.__blueprintname__ = self.name
             # Prepend the blueprint URI prefix if available
-            uri = url_prefix + future.uri if url_prefix else future.uri
+            uri = self._setup_uri(future.uri, url_prefix)
 
             version_prefix = self.version_prefix
             for prefix in (
@@ -333,7 +330,7 @@ class Blueprint(BaseSanic):
 
             apply_route = FutureRoute(
                 future.handler,
-                uri[1:] if uri.startswith("//") else uri,
+                uri,
                 future.methods,
                 host,
                 strict_slashes,
@@ -363,7 +360,7 @@ class Blueprint(BaseSanic):
         # Static Files
         for future in self._future_statics:
             # Prepend the blueprint URI prefix if available
-            uri = url_prefix + future.uri if url_prefix else future.uri
+            uri = self._setup_uri(future.uri, url_prefix)
             apply_route = FutureStatic(uri, *future[1:])
 
             if (self, apply_route) in app._future_registry:
@@ -406,7 +403,7 @@ class Blueprint(BaseSanic):
 
         self.routes += [route for route in routes if isinstance(route, Route)]
         self.websocket_routes += [
-            route for route in self.routes if route.ctx.websocket
+            route for route in self.routes if route.extra.websocket
         ]
         self.middlewares += middleware
         self.exceptions += exception_handlers
@@ -442,7 +439,7 @@ class Blueprint(BaseSanic):
             events.add(signal.ctx.event)
 
         return asyncio.wait(
-            [event.wait() for event in events],
+            [asyncio.create_task(event.wait()) for event in events],
             return_when=asyncio.FIRST_COMPLETED,
             timeout=timeout,
         )
@@ -456,6 +453,18 @@ class Blueprint(BaseSanic):
                 break
         return value
 
+    @staticmethod
+    def _setup_uri(base: str, prefix: Optional[str]):
+        uri = base
+        if prefix:
+            uri = prefix
+            if base.startswith("/") and prefix.endswith("/"):
+                uri += base[1:]
+            else:
+                uri += base
+
+        return uri[1:] if uri.startswith("//") else uri
+
     @staticmethod
     def register_futures(
         apps: Set[Sanic], bp: Blueprint, futures: Sequence[Tuple[Any, ...]]

sanic/cli/app.py

@@ -1,22 +1,21 @@
+import logging
 import os
 import shutil
 import sys
 
-from argparse import ArgumentParser, RawTextHelpFormatter
-from importlib import import_module
-from pathlib import Path
+from argparse import Namespace
+from functools import partial
 from textwrap import indent
-from typing import Any, List, Union
+from typing import List, Union, cast
 
 from sanic.app import Sanic
 from sanic.application.logo import get_logo
 from sanic.cli.arguments import Group
-from sanic.log import error_logger
-from sanic.simple import create_simple_server
-
-
-class SanicArgumentParser(ArgumentParser):
-    ...
+from sanic.cli.base import SanicArgumentParser, SanicHelpFormatter
+from sanic.cli.inspector import make_inspector_parser
+from sanic.cli.inspector_client import InspectorClient
+from sanic.log import Colors, error_logger
+from sanic.worker.loader import AppLoader
 
 
 class SanicCLI:
@@ -45,7 +44,7 @@ Or, a path to a directory to run as a simple HTTP server:
         self.parser = SanicArgumentParser(
             prog="sanic",
             description=self.DESCRIPTION,
-            formatter_class=lambda prog: RawTextHelpFormatter(
+            formatter_class=lambda prog: SanicHelpFormatter(
                 prog,
                 max_help_position=36 if width > 96 else 24,
                 indent_increment=4,
@@ -57,29 +56,128 @@ Or, a path to a directory to run as a simple HTTP server:
         self.main_process = (
             os.environ.get("SANIC_RELOADER_PROCESS", "") != "true"
         )
-        self.args: List[Any] = []
+        self.args: Namespace = Namespace()
+        self.groups: List[Group] = []
+        self.inspecting = False
 
     def attach(self):
-        for group in Group._registry:
-            group.create(self.parser).attach()
+        if len(sys.argv) > 1 and sys.argv[1] == "inspect":
+            self.inspecting = True
+            self.parser.description = get_logo(True)
+            make_inspector_parser(self.parser)
+            return
 
-    def run(self):
-        # This is to provide backwards compat -v to display version
-        legacy_version = len(sys.argv) == 2 and sys.argv[-1] == "-v"
-        parse_args = ["--version"] if legacy_version else None
+        for group in Group._registry:
+            instance = group.create(self.parser)
+            instance.attach()
+            self.groups.append(instance)
+
+    def run(self, parse_args=None):
+        if self.inspecting:
+            self._inspector()
+            return
+
+        legacy_version = False
+        if not parse_args:
+            # This is to provide backwards compat -v to display version
+            legacy_version = len(sys.argv) == 2 and sys.argv[-1] == "-v"
+            parse_args = ["--version"] if legacy_version else None
+        elif parse_args == ["-v"]:
+            parse_args = ["--version"]
+
+        if not legacy_version:
+            parsed, unknown = self.parser.parse_known_args(args=parse_args)
+            if unknown and parsed.factory:
+                for arg in unknown:
+                    if arg.startswith("--"):
+                        self.parser.add_argument(arg.split("=")[0])
 
         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
+        )
+
+        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 = self._get_app(app_loader)
             kwargs = self._build_run_kwargs()
-            app.run(**kwargs)
-        except ValueError:
-            error_logger.exception("Failed to run app")
+        except ValueError as e:
+            error_logger.exception(f"Failed to run app: {e}")
+        else:
+            for http_version in self.args.http:
+                app.prepare(**kwargs, version=http_version)
+            if self.args.single:
+                serve = Sanic.serve_single
+            elif self.args.legacy:
+                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)
+        if unknown:
+            for arg in unknown:
+                if arg.startswith("--"):
+                    try:
+                        key, value = arg.split("=")
+                        key = key.lstrip("-")
+                    except ValueError:
+                        value = False if arg.startswith("--no-") else True
+                        key = (
+                            arg.replace("--no-", "")
+                            .lstrip("-")
+                            .replace("-", "_")
+                        )
+                    setattr(self.args, key, value)
+
+        kwargs = {**self.args.__dict__}
+        host = kwargs.pop("host")
+        port = kwargs.pop("port")
+        secure = kwargs.pop("secure")
+        raw = kwargs.pop("raw")
+        action = kwargs.pop("action") or "info"
+        api_key = kwargs.pop("api_key")
+        positional = kwargs.pop("positional", None)
+        if action == "<custom>" and positional:
+            action = positional[0]
+            if len(positional) > 1:
+                kwargs["args"] = positional[1:]
+        InspectorClient(host, port, secure, raw, api_key).do(action, **kwargs)
 
     def _precheck(self):
-        # # Custom TLS mismatch handling for better diagnostics
+        # Custom TLS mismatch handling for better diagnostics
         if self.main_process and (
             # one of cert/key missing
             bool(self.args.cert) != bool(self.args.key)
@@ -99,48 +197,27 @@ 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):
+    def _get_app(self, app_loader: AppLoader):
         try:
-            module_path = os.path.abspath(os.getcwd())
-            if module_path not in sys.path:
-                sys.path.append(module_path)
-
-            if self.args.simple:
-                path = Path(self.args.module)
-                app = create_simple_server(path)
-            else:
-                delimiter = ":" if ":" in self.args.module else "."
-                module_name, app_name = self.args.module.rsplit(delimiter, 1)
-
-                if app_name.endswith("()"):
-                    self.args.factory = True
-                    app_name = app_name[:-2]
-
-                module = import_module(module_name)
-                app = getattr(module, app_name, None)
-                if self.args.factory:
-                    app = app()
-
-                app_type_name = type(app).__name__
-
-                if not isinstance(app, Sanic):
-                    raise ValueError(
-                        f"Module is not a Sanic app, it is a {app_type_name}\n"
-                        f"  Perhaps you meant {self.args.module}.app?"
-                    )
+            app = app_loader.load()
         except ImportError as e:
-            if module_name.startswith(e.name):
+            if app_loader.module_name.startswith(e.name):  # type: ignore
                 error_logger.error(
                     f"No module named {e.name} found.\n"
                     "  Example File: project/sanic_server.py -> app\n"
                     "  Example Module: project.sanic_server.app"
                 )
+                sys.exit(1)
             else:
                 raise e
         return app
 
     def _build_run_kwargs(self):
+        for group in self.groups:
+            group.prepare(self.args)
         ssl: Union[None, dict, str, list] = []
         if self.args.tlshost:
             ssl.append(None)
@@ -153,8 +230,10 @@ Or, a path to a directory to run as a simple HTTP server:
         elif len(ssl) == 1 and ssl[0] is not None:
             # Use only one cert, no TLSSelector.
             ssl = ssl[0]
+
         kwargs = {
             "access_log": self.args.access_log,
+            "coffee": self.args.coffee,
             "debug": self.args.debug,
             "fast": self.args.fast,
             "host": self.args.host,
@@ -165,6 +244,9 @@ Or, a path to a directory to run as a simple HTTP server:
             "unix": self.args.unix,
             "verbosity": self.args.verbosity or 0,
             "workers": self.args.workers,
+            "auto_tls": self.args.auto_tls,
+            "single_process": self.args.single,
+            "legacy": self.args.legacy,
         }
 
         for maybe_arg in ("auto_reload", "dev"):
@@ -174,4 +256,5 @@ Or, a path to a directory to run as a simple HTTP server:
         if self.args.path:
             kwargs["auto_reload"] = True
             kwargs["reload_dir"] = self.args.path
+
         return kwargs

sanic/cli/arguments.py

@@ -3,9 +3,10 @@ from __future__ import annotations
 from argparse import ArgumentParser, _ArgumentGroup
 from typing import List, Optional, Type, Union
 
-from sanic_routing import __version__ as __routing_version__  # type: ignore
+from sanic_routing import __version__ as __routing_version__
 
 from sanic import __version__
+from sanic.http.constants import HTTP
 
 
 class Group:
@@ -29,7 +30,7 @@ class Group:
         instance = cls(parser, cls.name)
         return instance
 
-    def add_bool_arguments(self, *args, **kwargs):
+    def add_bool_arguments(self, *args, nullable=False, **kwargs):
         group = self.container.add_mutually_exclusive_group()
         kwargs["help"] = kwargs["help"].capitalize()
         group.add_argument(*args, action="store_true", **kwargs)
@@ -37,6 +38,12 @@ class Group:
         group.add_argument(
             "--no-" + args[0][2:], *args[1:], action="store_false", **kwargs
         )
+        if nullable:
+            params = {args[0][2:].replace("-", "_"): None}
+            group.set_defaults(**params)
+
+    def prepare(self, args) -> None:
+        ...
 
 
 class GeneralGroup(Group):
@@ -63,7 +70,8 @@ class ApplicationGroup(Group):
     name = "Application"
 
     def attach(self):
-        self.container.add_argument(
+        group = self.container.add_mutually_exclusive_group()
+        group.add_argument(
             "--factory",
             action="store_true",
             help=(
@@ -71,7 +79,7 @@ class ApplicationGroup(Group):
                 "i.e. a () -> <Sanic app> callable"
             ),
         )
-        self.container.add_argument(
+        group.add_argument(
             "-s",
             "--simple",
             dest="simple",
@@ -81,6 +89,70 @@ 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):
+    name = "HTTP version"
+
+    def attach(self):
+        http_values = [http.value for http in HTTP.__members__.values()]
+
+        self.container.add_argument(
+            "--http",
+            dest="http",
+            action="append",
+            choices=http_values,
+            type=int,
+            help=(
+                "Which HTTP version to use: HTTP/1.1 or HTTP/3. Value should\n"
+                "be either 1, or 3. [default 1]"
+            ),
+        )
+        self.container.add_argument(
+            "-1",
+            dest="http",
+            action="append_const",
+            const=1,
+            help=("Run Sanic server using HTTP/1.1"),
+        )
+        self.container.add_argument(
+            "-3",
+            dest="http",
+            action="append_const",
+            const=3,
+            help=("Run Sanic server using HTTP/3"),
+        )
+
+    def prepare(self, args):
+        if not args.http:
+            args.http = [1]
+        args.http = tuple(sorted(set(map(HTTP, args.http)), reverse=True))
 
 
 class SocketGroup(Group):
@@ -92,7 +164,6 @@ class SocketGroup(Group):
             "--host",
             dest="host",
             type=str,
-            default="127.0.0.1",
             help="Host address [default 127.0.0.1]",
         )
         self.container.add_argument(
@@ -100,7 +171,6 @@ class SocketGroup(Group):
             "--port",
             dest="port",
             type=int,
-            default=8000,
             help="Port to serve on [default 8000]",
         )
         self.container.add_argument(
@@ -167,8 +237,22 @@ class WorkerGroup(Group):
             action="store_true",
             help="Set the number of workers to max allowed",
         )
+        group.add_argument(
+            "--single-process",
+            dest="single",
+            action="store_true",
+            help="Do not use multiprocessing, run server in a single process",
+        )
+        self.container.add_argument(
+            "--legacy",
+            action="store_true",
+            help="Use the legacy server manager",
+        )
         self.add_bool_arguments(
-            "--access-logs", dest="access_log", help="display access logs"
+            "--access-logs",
+            dest="access_log",
+            help="display access logs",
+            default=None,
         )
 
 
@@ -180,11 +264,7 @@ class DevelopmentGroup(Group):
             "--debug",
             dest="debug",
             action="store_true",
-            help=(
-                "Run the server in DEBUG mode. It includes DEBUG logging,\n"
-                "additional context on exceptions, and other settings\n"
-                "not-safe for PRODUCTION, but helpful for debugging problems."
-            ),
+            help="Run the server in debug mode",
         )
         self.container.add_argument(
             "-r",
@@ -209,7 +289,16 @@ class DevelopmentGroup(Group):
             "--dev",
             dest="dev",
             action="store_true",
-            help=("debug + auto reload."),
+            help=("debug + auto reload"),
+        )
+        self.container.add_argument(
+            "--auto-tls",
+            dest="auto_tls",
+            action="store_true",
+            help=(
+                "Create a temporary TLS certificate for local development "
+                "(requires mkcert or trustme)"
+            ),
         )
 
 
@@ -217,6 +306,12 @@ class OutputGroup(Group):
     name = "Output"
 
     def attach(self):
+        self.add_bool_arguments(
+            "--coffee",
+            dest="coffee",
+            default=False,
+            help="Uhm, coffee?",
+        )
         self.add_bool_arguments(
             "--motd",
             dest="motd",

sanic/cli/base.py

@@ -0,0 +1,35 @@
+from argparse import (
+    SUPPRESS,
+    Action,
+    ArgumentParser,
+    RawTextHelpFormatter,
+    _SubParsersAction,
+)
+from typing import Any
+
+
+class SanicArgumentParser(ArgumentParser):
+    def _check_value(self, action: Action, value: Any) -> None:
+        if isinstance(action, SanicSubParsersAction):
+            return
+        super()._check_value(action, value)
+
+
+class SanicHelpFormatter(RawTextHelpFormatter):
+    def add_usage(self, usage, actions, groups, prefix=None):
+        if not usage:
+            usage = SUPPRESS
+            # Add one linebreak, but not two
+            self.add_text("\x1b[1A")
+        super().add_usage(usage, actions, groups, prefix)
+
+
+class SanicSubParsersAction(_SubParsersAction):
+    def __call__(self, parser, namespace, values, option_string=None):
+        self._name_parser_map
+        parser_name = values[0]
+        if parser_name not in self._name_parser_map:
+            self._name_parser_map[parser_name] = parser
+            values = ["<custom>", *values]
+
+        super().__call__(parser, namespace, values, option_string)

sanic/cli/inspector.py

@@ -0,0 +1,105 @@
+from argparse import ArgumentParser
+
+from sanic.application.logo import get_logo
+from sanic.cli.base import SanicHelpFormatter, SanicSubParsersAction
+
+
+def _add_shared(parser: ArgumentParser) -> None:
+    parser.add_argument(
+        "--host",
+        "-H",
+        default="localhost",
+        help="Inspector host address [default 127.0.0.1]",
+    )
+    parser.add_argument(
+        "--port",
+        "-p",
+        default=6457,
+        type=int,
+        help="Inspector port [default 6457]",
+    )
+    parser.add_argument(
+        "--secure",
+        "-s",
+        action="store_true",
+        help="Whether to access the Inspector via TLS encryption",
+    )
+    parser.add_argument("--api-key", "-k", help="Inspector authentication key")
+    parser.add_argument(
+        "--raw",
+        action="store_true",
+        help="Whether to output the raw response information",
+    )
+
+
+class InspectorSubParser(ArgumentParser):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        _add_shared(self)
+        if not self.description:
+            self.description = ""
+        self.description = get_logo(True) + self.description
+
+
+def make_inspector_parser(parser: ArgumentParser) -> None:
+    _add_shared(parser)
+    subparsers = parser.add_subparsers(
+        action=SanicSubParsersAction,
+        dest="action",
+        description=(
+            "Run one or none of the below subcommands. Using inspect without "
+            "a subcommand will fetch general information about the state "
+            "of the application instance.\n\n"
+            "Or, you can optionally follow inspect with a subcommand. "
+            "If you have created a custom "
+            "Inspector instance, then you can run custom commands. See "
+            "https://sanic.dev/en/guide/deployment/inspector.html "
+            "for more details."
+        ),
+        title="  Subcommands",
+        parser_class=InspectorSubParser,
+    )
+    reloader = subparsers.add_parser(
+        "reload",
+        help="Trigger a reload of the server workers",
+        formatter_class=SanicHelpFormatter,
+    )
+    reloader.add_argument(
+        "--zero-downtime",
+        action="store_true",
+        help=(
+            "Whether to wait for the new process to be online before "
+            "terminating the old"
+        ),
+    )
+    subparsers.add_parser(
+        "shutdown",
+        help="Shutdown the application and all processes",
+        formatter_class=SanicHelpFormatter,
+    )
+    scale = subparsers.add_parser(
+        "scale",
+        help="Scale the number of workers",
+        formatter_class=SanicHelpFormatter,
+    )
+    scale.add_argument(
+        "replicas",
+        type=int,
+        help="Number of workers requested",
+    )
+
+    custom = subparsers.add_parser(
+        "<custom>",
+        help="Run a custom command",
+        description=(
+            "keyword arguments:\n  When running a custom command, you can "
+            "add keyword arguments by appending them to your command\n\n"
+            "\tsanic inspect foo --one=1 --two=2"
+        ),
+        formatter_class=SanicHelpFormatter,
+    )
+    custom.add_argument(
+        "positional",
+        nargs="*",
+        help="Add one or more non-keyword args to your custom command",
+    )

sanic/cli/inspector_client.py

@@ -0,0 +1,119 @@
+from __future__ import annotations
+
+import sys
+
+from http.client import RemoteDisconnected
+from textwrap import indent
+from typing import Any, Dict, Optional
+from urllib.error import URLError
+from urllib.request import Request as URequest
+from urllib.request import urlopen
+
+from sanic.application.logo import get_logo
+from sanic.application.motd import MOTDTTY
+from sanic.log import Colors
+
+
+try:  # no cov
+    from ujson import dumps, loads
+except ModuleNotFoundError:  # no cov
+    from json import dumps, loads  # type: ignore
+
+
+class InspectorClient:
+    def __init__(
+        self,
+        host: str,
+        port: int,
+        secure: bool,
+        raw: bool,
+        api_key: Optional[str],
+    ) -> None:
+        self.scheme = "https" if secure else "http"
+        self.host = host
+        self.port = port
+        self.raw = raw
+        self.api_key = api_key
+
+        for scheme in ("http", "https"):
+            full = f"{scheme}://"
+            if self.host.startswith(full):
+                self.scheme = scheme
+                self.host = self.host[len(full) :]  # noqa E203
+
+    def do(self, action: str, **kwargs: Any) -> None:
+        if action == "info":
+            self.info()
+            return
+        result = self.request(action, **kwargs).get("result")
+        if result:
+            out = (
+                dumps(result)
+                if isinstance(result, (list, dict))
+                else str(result)
+            )
+            sys.stdout.write(out + "\n")
+
+    def info(self) -> None:
+        out = sys.stdout.write
+        response = self.request("", "GET")
+        if self.raw or not response:
+            return
+        data = response["result"]
+        display = data.pop("info")
+        extra = display.pop("extra", {})
+        display["packages"] = ", ".join(display["packages"])
+        MOTDTTY(get_logo(), self.base_url, display, extra).display(
+            version=False,
+            action="Inspecting",
+            out=out,
+        )
+        for name, info in data["workers"].items():
+            info = "\n".join(
+                f"\t{key}: {Colors.BLUE}{value}{Colors.END}"
+                for key, value in info.items()
+            )
+            out(
+                "\n"
+                + indent(
+                    "\n".join(
+                        [
+                            f"{Colors.BOLD}{Colors.SANIC}{name}{Colors.END}",
+                            info,
+                        ]
+                    ),
+                    "  ",
+                )
+                + "\n"
+            )
+
+    def request(self, action: str, method: str = "POST", **kwargs: Any) -> Any:
+        url = f"{self.base_url}/{action}"
+        params: Dict[str, Any] = {"method": method, "headers": {}}
+        if kwargs:
+            params["data"] = dumps(kwargs).encode()
+            params["headers"]["content-type"] = "application/json"
+        if self.api_key:
+            params["headers"]["authorization"] = f"Bearer {self.api_key}"
+        request = URequest(url, **params)
+
+        try:
+            with urlopen(request) as response:  # nosec B310
+                raw = response.read()
+                loaded = loads(raw)
+                if self.raw:
+                    sys.stdout.write(dumps(loaded.get("result")) + "\n")
+                    return {}
+                return loaded
+        except (URLError, RemoteDisconnected) as e:
+            sys.stderr.write(
+                f"{Colors.RED}Could not connect to inspector at: "
+                f"{Colors.YELLOW}{self.base_url}{Colors.END}\n"
+                "Either the application is not running, or it did not start "
+                f"an inspector instance.\n{e}\n"
+            )
+            sys.exit(1)
+
+    @property
+    def base_url(self):
+        return f"{self.scheme}://{self.host}:{self.port}"

sanic/compat.py

@@ -1,11 +1,25 @@
 import asyncio
 import os
 import signal
+import sys
 
-from sys import argv
+from contextlib import contextmanager
+from enum import Enum
+from typing import Awaitable, Union
 
 from multidict import CIMultiDict  # type: ignore
 
+from sanic.helpers import Default
+
+
+if sys.version_info < (3, 8):  # no cov
+    StartMethod = Union[Default, str]
+else:  # no cov
+    from typing import Literal
+
+    StartMethod = Union[
+        Default, Literal["fork"], Literal["forkserver"], Literal["spawn"]
+    ]
 
 OS_IS_WINDOWS = os.name == "nt"
 UVLOOP_INSTALLED = False
@@ -17,6 +31,40 @@ try:
 except ImportError:
     pass
 
+# Python 3.11 changed the way Enum formatting works for mixed-in types.
+if sys.version_info < (3, 11, 0):
+
+    class StrEnum(str, Enum):
+        pass
+
+else:
+    from enum import StrEnum  # type: ignore # noqa
+
+
+class UpperStrEnum(StrEnum):
+    def _generate_next_value_(name, start, count, last_values):
+        return name.upper()
+
+    def __eq__(self, value: object) -> bool:
+        value = str(value).upper()
+        return super().__eq__(value)
+
+    def __hash__(self) -> int:
+        return hash(self.value)
+
+    def __str__(self) -> str:
+        return self.value
+
+
+@contextmanager
+def use_context(method: StartMethod):
+    from sanic import Sanic
+
+    orig = Sanic.start_method
+    Sanic.start_method = method
+    yield
+    Sanic.start_method = orig
+
 
 def enable_windows_color_support():
     import ctypes
@@ -47,12 +95,12 @@ class Header(CIMultiDict):
         return self.getall(key, default=[])
 
 
-use_trio = argv[0].endswith("hypercorn") and "trio" in argv
+use_trio = sys.argv[0].endswith("hypercorn") and "trio" in sys.argv
 
 if use_trio:  # pragma: no cover
     import trio  # type: ignore
 
-    def stat_async(path):
+    def stat_async(path) -> Awaitable[os.stat_result]:
         return trio.Path(path).stat()
 
     open_async = trio.open_file
@@ -72,7 +120,7 @@ def ctrlc_workaround_for_windows(app):
         """Asyncio wakeups to allow receiving SIGINT in Python"""
         while not die:
             # If someone else stopped the app, just exit
-            if app.is_stopping:
+            if app.state.is_stopping:
                 return
             # Windows Python blocks signal handlers while the event loop is
             # waiting for I/O. Frequent wakeups keep interrupts flowing.
@@ -89,3 +137,7 @@ def ctrlc_workaround_for_windows(app):
     die = False
     signal.signal(signal.SIGINT, ctrlc_handler)
     app.add_task(stay_active)
+
+
+def is_atty() -> bool:
+    return bool(sys.stdout and sys.stdout.isatty())

sanic/config.py

@@ -1,55 +1,82 @@
 from __future__ import annotations
 
+import sys
+
+from abc import ABCMeta
 from inspect import getmembers, isclass, isdatadescriptor
 from os import environ
 from pathlib import Path
 from typing import Any, Callable, Dict, Optional, Sequence, Union
+from warnings import filterwarnings
 
+from sanic.constants import LocalCertCreator
 from sanic.errorpages import DEFAULT_FORMAT, check_error_format
 from sanic.helpers import Default, _default
 from sanic.http import Http
-from sanic.log import deprecation, error_logger
+from sanic.log import error_logger
 from sanic.utils import load_module_from_file_location, str_to_bool
 
 
+if sys.version_info >= (3, 8):
+    from typing import Literal
+
+    FilterWarningType = Union[
+        Literal["default"],
+        Literal["error"],
+        Literal["ignore"],
+        Literal["always"],
+        Literal["module"],
+        Literal["once"],
+    ]
+else:
+    FilterWarningType = str
+
 SANIC_PREFIX = "SANIC_"
 
 
 DEFAULT_CONFIG = {
     "_FALLBACK_ERROR_FORMAT": _default,
-    "ACCESS_LOG": True,
+    "ACCESS_LOG": False,
     "AUTO_EXTEND": True,
     "AUTO_RELOAD": False,
     "EVENT_AUTOREGISTER": False,
+    "DEPRECATION_FILTER": "once",
     "FORWARDED_FOR_HEADER": "X-Forwarded-For",
     "FORWARDED_SECRET": None,
     "GRACEFUL_SHUTDOWN_TIMEOUT": 15.0,  # 15 sec
+    "INSPECTOR": False,
+    "INSPECTOR_HOST": "localhost",
+    "INSPECTOR_PORT": 6457,
+    "INSPECTOR_TLS_KEY": _default,
+    "INSPECTOR_TLS_CERT": _default,
+    "INSPECTOR_API_KEY": "",
     "KEEP_ALIVE_TIMEOUT": 5,  # 5 seconds
     "KEEP_ALIVE": True,
+    "LOCAL_CERT_CREATOR": LocalCertCreator.AUTO,
+    "LOCAL_TLS_KEY": _default,
+    "LOCAL_TLS_CERT": _default,
+    "LOCALHOST": "localhost",
     "MOTD": True,
     "MOTD_DISPLAY": {},
     "NOISY_EXCEPTIONS": False,
     "PROXIES_COUNT": None,
     "REAL_IP_HEADER": None,
-    "REGISTER": True,
     "REQUEST_BUFFER_SIZE": 65536,  # 64 KiB
     "REQUEST_MAX_HEADER_SIZE": 8192,  # 8 KiB, but cannot exceed 16384
     "REQUEST_ID_HEADER": "X-Request-ID",
     "REQUEST_MAX_SIZE": 100000000,  # 100 megabytes
     "REQUEST_TIMEOUT": 60,  # 60 seconds
     "RESPONSE_TIMEOUT": 60,  # 60 seconds
+    "TLS_CERT_PASSWORD": "",
+    "TOUCHUP": _default,
     "USE_UVLOOP": _default,
     "WEBSOCKET_MAX_SIZE": 2**20,  # 1 megabyte
     "WEBSOCKET_PING_INTERVAL": 20,
     "WEBSOCKET_PING_TIMEOUT": 20,
 }
 
-# These values will be removed from the Config object in v22.6 and moved
-# to the application state
-DEPRECATED_CONFIG = ("SERVER_RUNNING", "RELOADER_PROCESS", "RELOADED_FILES")
 
-
-class DescriptorMeta(type):
+class DescriptorMeta(ABCMeta):
     def __init__(cls, *_):
         cls.__setters__ = {name for name, _ in getmembers(cls, cls._is_setter)}
 
@@ -63,17 +90,27 @@ class Config(dict, metaclass=DescriptorMeta):
     AUTO_EXTEND: bool
     AUTO_RELOAD: bool
     EVENT_AUTOREGISTER: bool
+    DEPRECATION_FILTER: FilterWarningType
     FORWARDED_FOR_HEADER: str
     FORWARDED_SECRET: Optional[str]
     GRACEFUL_SHUTDOWN_TIMEOUT: float
+    INSPECTOR: bool
+    INSPECTOR_HOST: str
+    INSPECTOR_PORT: int
+    INSPECTOR_TLS_KEY: Union[Path, str, Default]
+    INSPECTOR_TLS_CERT: Union[Path, str, Default]
+    INSPECTOR_API_KEY: str
     KEEP_ALIVE_TIMEOUT: int
     KEEP_ALIVE: bool
-    NOISY_EXCEPTIONS: bool
+    LOCAL_CERT_CREATOR: Union[str, LocalCertCreator]
+    LOCAL_TLS_KEY: Union[Path, str, Default]
+    LOCAL_TLS_CERT: Union[Path, str, Default]
+    LOCALHOST: str
     MOTD: bool
     MOTD_DISPLAY: Dict[str, str]
+    NOISY_EXCEPTIONS: bool
     PROXIES_COUNT: Optional[int]
     REAL_IP_HEADER: Optional[str]
-    REGISTER: bool
     REQUEST_BUFFER_SIZE: int
     REQUEST_MAX_HEADER_SIZE: int
     REQUEST_ID_HEADER: str
@@ -81,6 +118,8 @@ class Config(dict, metaclass=DescriptorMeta):
     REQUEST_TIMEOUT: int
     RESPONSE_TIMEOUT: int
     SERVER_NAME: str
+    TLS_CERT_PASSWORD: str
+    TOUCHUP: Union[Default, bool]
     USE_UVLOOP: Union[Default, bool]
     WEBSOCKET_MAX_SIZE: int
     WEBSOCKET_PING_INTERVAL: int
@@ -88,7 +127,9 @@ class Config(dict, metaclass=DescriptorMeta):
 
     def __init__(
         self,
-        defaults: Dict[str, Union[str, bool, int, float, None]] = None,
+        defaults: Optional[
+            Dict[str, Union[str, bool, int, float, None]]
+        ] = None,
         env_prefix: Optional[str] = SANIC_PREFIX,
         keep_alive: Optional[bool] = None,
         *,
@@ -96,9 +137,9 @@ class Config(dict, metaclass=DescriptorMeta):
     ):
         defaults = defaults or {}
         super().__init__({**DEFAULT_CONFIG, **defaults})
+        self._configure_warnings()
 
         self._converters = [str, str_to_bool, float, int]
-        self._LOGO = ""
 
         if converters:
             for converter in converters:
@@ -117,19 +158,19 @@ class Config(dict, metaclass=DescriptorMeta):
         self._check_error_format()
         self._init = True
 
-    def __getattr__(self, attr):
+    def __getattr__(self, attr: Any):
         try:
             return self[attr]
         except KeyError as ke:
             raise AttributeError(f"Config has no '{ke.args[0]}'")
 
-    def __setattr__(self, attr, value) -> None:
+    def __setattr__(self, attr: str, value: Any) -> None:
         self.update({attr: value})
 
-    def __setitem__(self, attr, value) -> None:
+    def __setitem__(self, attr: str, value: Any) -> None:
         self.update({attr: value})
 
-    def update(self, *other, **kwargs) -> None:
+    def update(self, *other: Any, **kwargs: Any) -> None:
         kwargs.update({k: v for item in other for k, v in dict(item).items()})
         setters: Dict[str, Any] = {
             k: kwargs.pop(k)
@@ -155,21 +196,19 @@ class Config(dict, metaclass=DescriptorMeta):
                 "REQUEST_MAX_SIZE",
             ):
                 self._configure_header_size()
-            elif attr == "LOGO":
-                self._LOGO = value
-                deprecation(
-                    "Setting the config.LOGO is deprecated and will no longer "
-                    "be supported starting in v22.6.",
-                    22.6,
-                )
 
-    @property
-    def LOGO(self):
-        return self._LOGO
+        if attr == "LOCAL_CERT_CREATOR" and not isinstance(
+            self.LOCAL_CERT_CREATOR, LocalCertCreator
+        ):
+            self.LOCAL_CERT_CREATOR = LocalCertCreator[
+                self.LOCAL_CERT_CREATOR.upper()
+            ]
+        elif attr == "DEPRECATION_FILTER":
+            self._configure_warnings()
 
     @property
     def FALLBACK_ERROR_FORMAT(self) -> str:
-        if self._FALLBACK_ERROR_FORMAT is _default:
+        if isinstance(self._FALLBACK_ERROR_FORMAT, Default):
             return DEFAULT_FORMAT
         return self._FALLBACK_ERROR_FORMAT
 
@@ -177,7 +216,7 @@ class Config(dict, metaclass=DescriptorMeta):
     def FALLBACK_ERROR_FORMAT(self, value):
         self._check_error_format(value)
         if (
-            self._FALLBACK_ERROR_FORMAT is not _default
+            not isinstance(self._FALLBACK_ERROR_FORMAT, Default)
             and value != self._FALLBACK_ERROR_FORMAT
         ):
             error_logger.warning(
@@ -193,6 +232,13 @@ class Config(dict, metaclass=DescriptorMeta):
             self.REQUEST_MAX_SIZE,
         )
 
+    def _configure_warnings(self):
+        filterwarnings(
+            self.DEPRECATION_FILTER,
+            category=DeprecationWarning,
+            module=r"sanic.*",
+        )
+
     def _check_error_format(self, format: Optional[str] = None):
         check_error_format(format or self.FALLBACK_ERROR_FORMAT)
 
@@ -200,7 +246,9 @@ class Config(dict, metaclass=DescriptorMeta):
         """
         Looks for prefixed environment variables and applies them to the
         configuration if present. This is called automatically when Sanic
-        starts up to load environment variables into config.
+        starts up to load environment variables into config. Environment
+        variables should start with the defined prefix and should only
+        contain uppercase letters.
 
         It will automatically hydrate the following types:
 
@@ -226,12 +274,9 @@ class Config(dict, metaclass=DescriptorMeta):
         `See user guide re: config
         <https://sanicframework.org/guide/deployment/configuration.html>`__
         """
-        lower_case_var_found = False
         for key, value in environ.items():
-            if not key.startswith(prefix):
+            if not key.startswith(prefix) or not key.isupper():
                 continue
-            if not key.isupper():
-                lower_case_var_found = True
 
             _, config_key = key.split(prefix, 1)
 
@@ -241,12 +286,6 @@ class Config(dict, metaclass=DescriptorMeta):
                     break
                 except ValueError:
                     pass
-        if lower_case_var_found:
-            deprecation(
-                "Lowercase environment variables will not be "
-                "loaded into Sanic config beginning in v22.9.",
-                22.9,
-            )
 
     def update_config(self, config: Union[bytes, str, dict, Any]):
         """

sanic/constants.py

@@ -1,20 +1,9 @@
-from enum import Enum, auto
+from enum import auto
+
+from sanic.compat import UpperStrEnum
 
 
-class HTTPMethod(str, Enum):
-    def _generate_next_value_(name, start, count, last_values):
-        return name.upper()
-
-    def __eq__(self, value: object) -> bool:
-        value = str(value).upper()
-        return super().__eq__(value)
-
-    def __hash__(self) -> int:
-        return hash(self.value)
-
-    def __str__(self) -> str:
-        return self.value
-
+class HTTPMethod(UpperStrEnum):
     GET = auto()
     POST = auto()
     PUT = auto()
@@ -24,5 +13,22 @@ class HTTPMethod(str, Enum):
     DELETE = auto()
 
 
+class LocalCertCreator(UpperStrEnum):
+    AUTO = auto()
+    TRUSTME = auto()
+    MKCERT = auto()
+
+
 HTTP_METHODS = tuple(HTTPMethod.__members__.values())
+SAFE_HTTP_METHODS = (HTTPMethod.GET, HTTPMethod.HEAD, HTTPMethod.OPTIONS)
+IDEMPOTENT_HTTP_METHODS = (
+    HTTPMethod.GET,
+    HTTPMethod.HEAD,
+    HTTPMethod.PUT,
+    HTTPMethod.DELETE,
+    HTTPMethod.OPTIONS,
+)
+CACHEABLE_HTTP_METHODS = (HTTPMethod.GET, HTTPMethod.HEAD)
 DEFAULT_HTTP_CONTENT_TYPE = "application/octet-stream"
+DEFAULT_LOCAL_TLS_KEY = "key.pem"
+DEFAULT_LOCAL_TLS_CERT = "cert.pem"

sanic/errorpages.py

@@ -12,6 +12,7 @@ Setting ``app.config.FALLBACK_ERROR_FORMAT = "auto"`` will enable a switch that
 will attempt to provide an appropriate response format based upon the
 request type.
 """
+from __future__ import annotations
 
 import sys
 import typing as t
@@ -19,10 +20,9 @@ import typing as t
 from functools import partial
 from traceback import extract_tb
 
-from sanic.exceptions import InvalidUsage, SanicException
+from sanic.exceptions import BadRequest, SanicException
 from sanic.helpers import STATUS_CODES
-from sanic.request import Request
-from sanic.response import HTTPResponse, html, json, text
+from sanic.response import html, json, text
 
 
 dumps: t.Callable[..., str]
@@ -33,6 +33,8 @@ try:
 except ImportError:  # noqa
     from json import dumps
 
+if t.TYPE_CHECKING:
+    from sanic import HTTPResponse, Request
 
 DEFAULT_FORMAT = "auto"
 FALLBACK_TEXT = (
@@ -404,16 +406,13 @@ CONTENT_TYPE_BY_RENDERERS = {
     v: k for k, v in RENDERERS_BY_CONTENT_TYPE.items()
 }
 
+# Handler source code is checked for which response types it returns with the
+# route error_format="auto" (default) to determine which format to use.
 RESPONSE_MAPPING = {
-    "empty": "html",
     "json": "json",
     "text": "text",
-    "raw": "text",
     "html": "html",
-    "file": "html",
-    "file_stream": "text",
-    "stream": "text",
-    "redirect": "html",
+    "JSONResponse": "json",
     "text/plain": "text",
     "text/html": "html",
     "application/json": "json",
@@ -448,8 +447,8 @@ def exception_response(
             # from the route
             if request.route:
                 try:
-                    if request.route.ctx.error_format:
-                        render_format = request.route.ctx.error_format
+                    if request.route.extra.error_format:
+                        render_format = request.route.extra.error_format
                 except AttributeError:
                     ...
 
@@ -506,7 +505,7 @@ def exception_response(
                         # $ curl localhost:8000 -d '{"foo": "bar"}'
                         # And provide them with JSONRenderer
                         renderer = JSONRenderer if request.json else base
-                    except InvalidUsage:
+                    except BadRequest:
                         renderer = base
             else:
                 renderer = RENDERERS_BY_CONFIG.get(render_format, renderer)

sanic/exceptions.py

@@ -1,8 +1,17 @@
+from asyncio import CancelledError
 from typing import Any, Dict, Optional, Union
 
 from sanic.helpers import STATUS_CODES
 
 
+class RequestCancelled(CancelledError):
+    quiet = True
+
+
+class ServerKilled(Exception):
+    ...
+
+
 class SanicException(Exception):
     message: str = ""
 
@@ -42,7 +51,7 @@ class NotFound(SanicException):
     quiet = True
 
 
-class InvalidUsage(SanicException):
+class BadRequest(SanicException):
     """
     **Status**: 400 Bad Request
     """
@@ -51,7 +60,14 @@ class InvalidUsage(SanicException):
     quiet = True
 
 
-class MethodNotSupported(SanicException):
+InvalidUsage = BadRequest
+
+
+class BadURL(BadRequest):
+    ...
+
+
+class MethodNotAllowed(SanicException):
     """
     **Status**: 405 Method Not Allowed
     """
@@ -64,6 +80,9 @@ class MethodNotSupported(SanicException):
         self.headers = {"Allow": ", ".join(allowed_methods)}
 
 
+MethodNotSupported = MethodNotAllowed
+
+
 class ServerError(SanicException):
     """
     **Status**: 500 Internal Server Error
@@ -125,19 +144,19 @@ class PayloadTooLarge(SanicException):
     quiet = True
 
 
-class HeaderNotFound(InvalidUsage):
+class HeaderNotFound(BadRequest):
     """
     **Status**: 400 Bad Request
     """
 
 
-class InvalidHeader(InvalidUsage):
+class InvalidHeader(BadRequest):
     """
     **Status**: 400 Bad Request
     """
 
 
-class ContentRangeError(SanicException):
+class RangeNotSatisfiable(SanicException):
     """
     **Status**: 416 Range Not Satisfiable
     """
@@ -150,7 +169,10 @@ class ContentRangeError(SanicException):
         self.headers = {"Content-Range": f"bytes */{content_range.total}"}
 
 
-class HeaderExpectationFailed(SanicException):
+ContentRangeError = RangeNotSatisfiable
+
+
+class ExpectationFailed(SanicException):
     """
     **Status**: 417 Expectation Failed
     """
@@ -159,6 +181,9 @@ class HeaderExpectationFailed(SanicException):
     quiet = True
 
 
+HeaderExpectationFailed = ExpectationFailed
+
+
 class Forbidden(SanicException):
     """
     **Status**: 403 Forbidden
@@ -168,7 +193,7 @@ class Forbidden(SanicException):
     quiet = True
 
 
-class InvalidRangeType(ContentRangeError):
+class InvalidRangeType(RangeNotSatisfiable):
     """
     **Status**: 416 Range Not Satisfiable
     """

sanic/handlers/__init__.py

@@ -0,0 +1,10 @@
+from .content_range import ContentRangeHandler
+from .directory import DirectoryHandler
+from .error import ErrorHandler
+
+
+__all__ = (
+    "ContentRangeHandler",
+    "DirectoryHandler",
+    "ErrorHandler",
+)

sanic/handlers/content_range.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+from sanic.exceptions import (
+    HeaderNotFound,
+    InvalidRangeType,
+    RangeNotSatisfiable,
+)
+
+
+class ContentRangeHandler:
+    """
+    A mechanism to parse and process the incoming request headers to
+    extract the content range information.
+
+    :param request: Incoming api request
+    :param stats: Stats related to the content
+
+    :type request: :class:`sanic.request.Request`
+    :type stats: :class:`posix.stat_result`
+
+    :ivar start: Content Range start
+    :ivar end: Content Range end
+    :ivar size: Length of the content
+    :ivar total: Total size identified by the :class:`posix.stat_result`
+        instance
+    :ivar ContentRangeHandler.headers: Content range header ``dict``
+    """
+
+    __slots__ = ("start", "end", "size", "total", "headers")
+
+    def __init__(self, request, stats):
+        self.total = stats.st_size
+        _range = request.headers.getone("range", None)
+        if _range is None:
+            raise HeaderNotFound("Range Header Not Found")
+        unit, _, value = tuple(map(str.strip, _range.partition("=")))
+        if unit != "bytes":
+            raise InvalidRangeType(
+                "%s is not a valid Range Type" % (unit,), self
+            )
+        start_b, _, end_b = tuple(map(str.strip, value.partition("-")))
+        try:
+            self.start = int(start_b) if start_b else None
+        except ValueError:
+            raise RangeNotSatisfiable(
+                "'%s' is invalid for Content Range" % (start_b,), self
+            )
+        try:
+            self.end = int(end_b) if end_b else None
+        except ValueError:
+            raise RangeNotSatisfiable(
+                "'%s' is invalid for Content Range" % (end_b,), self
+            )
+        if self.end is None:
+            if self.start is None:
+                raise RangeNotSatisfiable(
+                    "Invalid for Content Range parameters", self
+                )
+            else:
+                # this case represents `Content-Range: bytes 5-`
+                self.end = self.total - 1
+        else:
+            if self.start is None:
+                # this case represents `Content-Range: bytes -5`
+                self.start = self.total - self.end
+                self.end = self.total - 1
+        if self.start >= self.end:
+            raise RangeNotSatisfiable(
+                "Invalid for Content Range parameters", self
+            )
+        self.size = self.end - self.start + 1
+        self.headers = {
+            "Content-Range": "bytes %s-%s/%s"
+            % (self.start, self.end, self.total)
+        }
+
+    def __bool__(self):
+        return self.size > 0

sanic/handlers/directory.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+from datetime import datetime
+from operator import itemgetter
+from pathlib import Path
+from stat import S_ISDIR
+from typing import Dict, Iterable, Optional, Sequence, Union, cast
+
+from sanic.exceptions import NotFound
+from sanic.pages.directory_page import DirectoryPage, FileInfo
+from sanic.request import Request
+from sanic.response import file, html, redirect
+
+
+class DirectoryHandler:
+    def __init__(
+        self,
+        uri: str,
+        directory: Path,
+        directory_view: bool = False,
+        index: Optional[Union[str, Sequence[str]]] = None,
+    ) -> None:
+        if isinstance(index, str):
+            index = [index]
+        elif index is None:
+            index = []
+        self.base = uri.strip("/")
+        self.directory = directory
+        self.directory_view = directory_view
+        self.index = tuple(index)
+
+    async def handle(self, request: Request, path: str):
+        current = path.strip("/")[len(self.base) :].strip("/")  # noqa: E203
+        for file_name in self.index:
+            index_file = self.directory / current / file_name
+            if index_file.is_file():
+                return await file(index_file)
+
+        if self.directory_view:
+            return self._index(
+                self.directory / current, path, request.app.debug
+            )
+
+        if self.index:
+            raise NotFound("File not found")
+
+        raise IsADirectoryError(f"{self.directory.as_posix()} is a directory")
+
+    def _index(self, location: Path, path: str, debug: bool):
+        # Remove empty path elements, append slash
+        if "//" in path or not path.endswith("/"):
+            return redirect(
+                "/" + "".join([f"{p}/" for p in path.split("/") if p])
+            )
+
+        # Render file browser
+        page = DirectoryPage(self._iter_files(location), path, debug)
+        return html(page.render())
+
+    def _prepare_file(self, path: Path) -> Dict[str, Union[int, str]]:
+        stat = path.stat()
+        modified = (
+            datetime.fromtimestamp(stat.st_mtime)
+            .isoformat()[:19]
+            .replace("T", " ")
+        )
+        is_dir = S_ISDIR(stat.st_mode)
+        icon = "📁" if is_dir else "📄"
+        file_name = path.name
+        if is_dir:
+            file_name += "/"
+        return {
+            "priority": is_dir * -1,
+            "file_name": file_name,
+            "icon": icon,
+            "file_access": modified,
+            "file_size": stat.st_size,
+        }
+
+    def _iter_files(self, location: Path) -> Iterable[FileInfo]:
+        prepared = [self._prepare_file(f) for f in location.iterdir()]
+        for item in sorted(prepared, key=itemgetter("priority", "file_name")):
+            del item["priority"]
+            yield cast(FileInfo, item)

sanic/handlers/error.py

@@ -1,21 +1,8 @@
 from __future__ import annotations
 
-from typing import Dict, List, Optional, Tuple, Type, Union
+from typing import Dict, List, Optional, Tuple, Type
 
-from sanic.config import Config
-from sanic.errorpages import (
-    DEFAULT_FORMAT,
-    BaseRenderer,
-    TextRenderer,
-    exception_response,
-)
-from sanic.exceptions import (
-    ContentRangeError,
-    HeaderNotFound,
-    InvalidRangeType,
-    SanicException,
-)
-from sanic.helpers import Default, _default
+from sanic.errorpages import BaseRenderer, TextRenderer, exception_response
 from sanic.log import deprecation, error_logger
 from sanic.models.handler_types import RouteHandler
 from sanic.response import text
@@ -31,99 +18,43 @@ class ErrorHandler:
     by the developers to perform a wide range of tasks from recording the error
     stats to reporting them to an external service that can be used for
     realtime alerting system.
-
     """
 
     def __init__(
         self,
-        fallback: Union[str, Default] = _default,
         base: Type[BaseRenderer] = TextRenderer,
     ):
         self.cached_handlers: Dict[
             Tuple[Type[BaseException], Optional[str]], Optional[RouteHandler]
         ] = {}
         self.debug = False
-        self._fallback = fallback
         self.base = base
 
-        if fallback is not _default:
-            self._warn_fallback_deprecation()
-
-    @property
-    def fallback(self):  # no cov
-        # This is for backwards compat and can be removed in v22.6
-        if self._fallback is _default:
-            return DEFAULT_FORMAT
-        return self._fallback
-
-    @fallback.setter
-    def fallback(self, value: str):  # no cov
-        self._warn_fallback_deprecation()
-        if not isinstance(value, str):
-            raise SanicException(
-                f"Cannot set error handler fallback to: value={value}"
-            )
-        self._fallback = value
-
-    @staticmethod
-    def _warn_fallback_deprecation():
-        deprecation(
-            "Setting the ErrorHandler fallback value directly is "
-            "deprecated and no longer supported. This feature will "
-            "be removed in v22.6. Instead, use "
-            "app.config.FALLBACK_ERROR_FORMAT.",
-            22.6,
-        )
-
-    @classmethod
-    def _get_fallback_value(cls, error_handler: ErrorHandler, config: Config):
-        if error_handler._fallback is not _default:
-            if config._FALLBACK_ERROR_FORMAT is _default:
-                return error_handler.fallback
-
-            error_logger.warning(
-                "Conflicting error fallback values were found in the "
-                "error handler and in the app.config while handling an "
-                "exception. Using the value from app.config."
-            )
-        return config.FALLBACK_ERROR_FORMAT
-
-    @classmethod
-    def finalize(
-        cls,
-        error_handler: ErrorHandler,
-        config: Config,
-        fallback: Optional[str] = None,
-    ):
-        if fallback:
-            deprecation(
-                "Setting the ErrorHandler fallback value via finalize() "
-                "is deprecated and no longer supported. This feature will "
-                "be removed in v22.6. Instead, use "
-                "app.config.FALLBACK_ERROR_FORMAT.",
-                22.6,
-            )
-
-        if not fallback:
-            fallback = config.FALLBACK_ERROR_FORMAT
-
-        if fallback != DEFAULT_FORMAT:
-            if error_handler._fallback is not _default:
-                error_logger.warning(
-                    f"Setting the fallback value to {fallback}. This changes "
-                    "the current non-default value "
-                    f"'{error_handler._fallback}'."
-                )
-            error_handler._fallback = fallback
-
-        if not isinstance(error_handler, cls):
-            error_logger.warning(
-                f"Error handler is non-conforming: {type(error_handler)}"
-            )
-
     def _full_lookup(self, exception, route_name: Optional[str] = None):
         return self.lookup(exception, route_name)
 
+    def _add(
+        self,
+        key: Tuple[Type[BaseException], Optional[str]],
+        handler: RouteHandler,
+    ) -> None:
+        if key in self.cached_handlers:
+            exc, name = key
+            if name is None:
+                name = "__ALL_ROUTES__"
+
+            error_logger.warning(
+                f"Duplicate exception handler definition on: route={name} "
+                f"and exception={exc}"
+            )
+            deprecation(
+                "A duplicate exception handler definition was discovered. "
+                "This may cause unintended consequences. A warning has been "
+                "issued now, but it will not be allowed starting in v23.3.",
+                23.3,
+            )
+        self.cached_handlers[key] = handler
+
     def add(self, exception, handler, route_names: Optional[List[str]] = None):
         """
         Add a new exception handler to an already existing handler object.
@@ -139,9 +70,9 @@ class ErrorHandler:
         """
         if route_names:
             for route in route_names:
-                self.cached_handlers[(exception, route)] = handler
+                self._add((exception, route), handler)
         else:
-            self.cached_handlers[(exception, None)] = handler
+            self._add((exception, None), handler)
 
     def lookup(self, exception, route_name: Optional[str] = None):
         """
@@ -237,7 +168,7 @@ class ErrorHandler:
         :return:
         """
         self.log(request, exception)
-        fallback = ErrorHandler._get_fallback_value(self, request.app.config)
+        fallback = request.app.config.FALLBACK_ERROR_FORMAT
         return exception_response(
             request,
             exception,
@@ -259,74 +190,3 @@ class ErrorHandler:
             error_logger.exception(
                 "Exception occurred while handling uri: %s", url
             )
-
-
-class ContentRangeHandler:
-    """
-    A mechanism to parse and process the incoming request headers to
-    extract the content range information.
-
-    :param request: Incoming api request
-    :param stats: Stats related to the content
-
-    :type request: :class:`sanic.request.Request`
-    :type stats: :class:`posix.stat_result`
-
-    :ivar start: Content Range start
-    :ivar end: Content Range end
-    :ivar size: Length of the content
-    :ivar total: Total size identified by the :class:`posix.stat_result`
-        instance
-    :ivar ContentRangeHandler.headers: Content range header ``dict``
-    """
-
-    __slots__ = ("start", "end", "size", "total", "headers")
-
-    def __init__(self, request, stats):
-        self.total = stats.st_size
-        _range = request.headers.getone("range", None)
-        if _range is None:
-            raise HeaderNotFound("Range Header Not Found")
-        unit, _, value = tuple(map(str.strip, _range.partition("=")))
-        if unit != "bytes":
-            raise InvalidRangeType(
-                "%s is not a valid Range Type" % (unit,), self
-            )
-        start_b, _, end_b = tuple(map(str.strip, value.partition("-")))
-        try:
-            self.start = int(start_b) if start_b else None
-        except ValueError:
-            raise ContentRangeError(
-                "'%s' is invalid for Content Range" % (start_b,), self
-            )
-        try:
-            self.end = int(end_b) if end_b else None
-        except ValueError:
-            raise ContentRangeError(
-                "'%s' is invalid for Content Range" % (end_b,), self
-            )
-        if self.end is None:
-            if self.start is None:
-                raise ContentRangeError(
-                    "Invalid for Content Range parameters", self
-                )
-            else:
-                # this case represents `Content-Range: bytes 5-`
-                self.end = self.total - 1
-        else:
-            if self.start is None:
-                # this case represents `Content-Range: bytes -5`
-                self.start = self.total - self.end
-                self.end = self.total - 1
-        if self.start >= self.end:
-            raise ContentRangeError(
-                "Invalid for Content Range parameters", self
-            )
-        self.size = self.end - self.start + 1
-        self.headers = {
-            "Content-Range": "bytes %s-%s/%s"
-            % (self.start, self.end, self.total)
-        }
-
-    def __bool__(self):
-        return self.size > 0

sanic/headers.py

@@ -35,141 +35,96 @@ _host_re = re.compile(
 
 def parse_arg_as_accept(f):
     def func(self, other, *args, **kwargs):
-        if not isinstance(other, Accept) and other:
-            other = Accept.parse(other)
+        if not isinstance(other, MediaType) and other:
+            other = MediaType._parse(other)
         return f(self, other, *args, **kwargs)
 
     return func
 
 
-class MediaType(str):
-    def __new__(cls, value: str):
-        return str.__new__(cls, value)
-
-    def __init__(self, value: str) -> None:
-        self.value = value
-        self.is_wildcard = self.check_if_wildcard(value)
-
-    def __eq__(self, other):
-        if self.is_wildcard:
-            return True
-
-        if self.match(other):
-            return True
-
-        other_is_wildcard = (
-            other.is_wildcard
-            if isinstance(other, MediaType)
-            else self.check_if_wildcard(other)
-        )
-
-        return other_is_wildcard
-
-    def match(self, other):
-        other_value = other.value if isinstance(other, MediaType) else other
-        return self.value == other_value
-
-    @staticmethod
-    def check_if_wildcard(value):
-        return value == "*"
-
-
-class Accept(str):
-    def __new__(cls, value: str, *args, **kwargs):
-        return str.__new__(cls, value)
+class MediaType:
+    """A media type, as used in the Accept header."""
 
     def __init__(
         self,
-        value: str,
-        type_: MediaType,
-        subtype: MediaType,
-        *,
-        q: str = "1.0",
-        **kwargs: str,
+        type_: str,
+        subtype: str,
+        **params: str,
     ):
-        qvalue = float(q)
-        if qvalue > 1 or qvalue < 0:
-            raise InvalidHeader(
-                f"Accept header qvalue must be between 0 and 1, not: {qvalue}"
-            )
-        self.value = value
         self.type_ = type_
         self.subtype = subtype
-        self.qvalue = qvalue
-        self.params = kwargs
+        self.q = float(params.get("q", "1.0"))
+        self.params = params
+        self.mime = f"{type_}/{subtype}"
 
-    def _compare(self, other, method):
-        try:
-            return method(self.qvalue, other.qvalue)
-        except (AttributeError, TypeError):
-            return NotImplemented
+    def __repr__(self):
+        return self.mime + "".join(f";{k}={v}" for k, v in self.params.items())
 
-    @parse_arg_as_accept
-    def __lt__(self, other: Union[str, Accept]):
-        return self._compare(other, lambda s, o: s < o)
+    def __eq__(self, other):
+        """Check for mime (str or MediaType) identical type/subtype."""
+        if isinstance(other, str):
+            return self.mime == other
+        if isinstance(other, MediaType):
+            return self.mime == other.mime
+        return NotImplemented
 
-    @parse_arg_as_accept
-    def __le__(self, other: Union[str, Accept]):
-        return self._compare(other, lambda s, o: s <= o)
-
-    @parse_arg_as_accept
-    def __eq__(self, other: Union[str, Accept]):  # type: ignore
-        return self._compare(other, lambda s, o: s == o)
-
-    @parse_arg_as_accept
-    def __ge__(self, other: Union[str, Accept]):
-        return self._compare(other, lambda s, o: s >= o)
-
-    @parse_arg_as_accept
-    def __gt__(self, other: Union[str, Accept]):
-        return self._compare(other, lambda s, o: s > o)
-
-    @parse_arg_as_accept
-    def __ne__(self, other: Union[str, Accept]):  # type: ignore
-        return self._compare(other, lambda s, o: s != o)
-
-    @parse_arg_as_accept
     def match(
         self,
-        other,
-        *,
-        allow_type_wildcard: bool = True,
-        allow_subtype_wildcard: bool = True,
-    ) -> bool:
-        type_match = (
-            self.type_ == other.type_
-            if allow_type_wildcard
-            else (
-                self.type_.match(other.type_)
-                and not self.type_.is_wildcard
-                and not other.type_.is_wildcard
-            )
-        )
-        subtype_match = (
-            self.subtype == other.subtype
-            if allow_subtype_wildcard
-            else (
-                self.subtype.match(other.subtype)
-                and not self.subtype.is_wildcard
-                and not other.subtype.is_wildcard
+        mime: str,
+        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.
+
+        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)
+        return (
+            self
+            if (
+                # 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
+                    or self.type_ != "*"
+                    and mt.type_ != "*"
+                )
+                and (
+                    allow_subtype_wildcard
+                    or self.subtype != "*"
+                    and mt.subtype != "*"
+                )
             )
+            else None
         )
 
-        return type_match and subtype_match
+    @property
+    def has_wildcard(self) -> bool:
+        """Return True if this media type has a wildcard in it."""
+        return "*" 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, raw: str) -> Accept:
-        invalid = False
-        mtype = raw.strip()
+    def _parse(cls, mime_with_params: str) -> MediaType:
+        mtype = mime_with_params.strip()
 
-        try:
-            media, *raw_params = mtype.split(";")
-            type_, subtype = media.split("/")
-        except ValueError:
-            invalid = True
-
-        if invalid or not type_ or not subtype:
-            raise InvalidHeader(f"Header contains invalid Accept value: {raw}")
+        media, *raw_params = mtype.split(";")
+        type_, subtype = media.split("/", 1)
+        if not type_ or not subtype:
+            raise ValueError(f"Invalid media type: {mtype}")
 
         params = dict(
             [
@@ -178,28 +133,79 @@ class Accept(str):
             ]
         )
 
-        return cls(mtype, MediaType(type_), MediaType(subtype), **params)
+        return cls(type_.lstrip(), subtype.rstrip(), **params)
 
 
-class AcceptContainer(list):
-    def __contains__(self, o: object) -> bool:
-        return any(item.match(o) for item in self)
+class Matched(str):
+    """A matching result of a MIME string against a MediaType."""
 
-    def match(
-        self,
-        o: object,
-        *,
-        allow_type_wildcard: bool = True,
-        allow_subtype_wildcard: bool = True,
-    ) -> bool:
-        return any(
-            item.match(
-                o,
-                allow_type_wildcard=allow_type_wildcard,
-                allow_subtype_wildcard=allow_subtype_wildcard,
-            )
-            for item in self
+    def __new__(cls, mime: str, m: Optional[MediaType]):
+        return super().__new__(cls, mime)
+
+    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>"
+
+
+class AcceptList(list):
+    """A list of media types, as used in the Accept header.
+
+    The Accept header entries are listed in order of preference, starting
+    with the most preferred. This class is a list of `MediaType` objects,
+    that encapsulate also the q value or any other parameters.
+
+    Two separate methods are provided for searching the list:
+    - 'match' for finding the most preferred match (wildcards supported)
+    -  operator 'in' for checking explicit matches (wildcards as literals)
+    """
+
+    def match(self, *mimes: str) -> 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,
+        2. The order of the arguments (first is most preferred), and
+        3. The first matching entry on the Accept header.
+
+        Wildcards are matched both ways. A match is usually found, as the
+        Accept headers typically include `*/*`, in particular if the header
+        is missing, is not manually set, or if the client is a browser.
+
+        Note: the returned object behaves as a string of the mime argument
+        that matched, and is empty/falsy if no match was found. The matched
+        header entry `MediaType` or `None` is available as the `m` attribute.
+
+        @param mimes: Any MIME types to search for in order of preference.
+        @return A match object with the mime string and the MediaType object.
+        """
+        l = sorted(
+            [
+                (-acc.q, i, j, mime, acc)  # Sort by -q, i, j
+                for j, acc in enumerate(self)
+                for i, mime in enumerate(mimes)
+                if acc.match(mime)
+            ]
         )
+        return Matched(*(l[0][3:] if l else ("", None)))
+
+
+def parse_accept(accept: str) -> AcceptList:
+    """Parse an Accept header and order the acceptable media types in
+    accorsing to RFC 7231, s. 5.3.2
+    https://datatracker.ietf.org/doc/html/rfc7231#section-5.3.2
+    """
+    if not accept:
+        return AcceptList()
+    try:
+        a = [MediaType._parse(mtype) for mtype in accept.split(",")]
+        return AcceptList(sorted(a, key=lambda mtype: -mtype.q))
+    except ValueError:
+        raise InvalidHeader(f"Invalid header value in Accept: {accept}")
 
 
 def parse_content_header(value: str) -> Tuple[str, Options]:
@@ -368,34 +374,6 @@ def format_http1_response(status: int, headers: HeaderBytesIterable) -> bytes:
     return ret
 
 
-def _sort_accept_value(accept: Accept):
-    return (
-        accept.qvalue,
-        len(accept.params),
-        accept.subtype != "*",
-        accept.type_ != "*",
-    )
-
-
-def parse_accept(accept: str) -> AcceptContainer:
-    """Parse an Accept header and order the acceptable media types in
-    accorsing to RFC 7231, s. 5.3.2
-    https://datatracker.ietf.org/doc/html/rfc7231#section-5.3.2
-    """
-    media_types = accept.split(",")
-    accept_list: List[Accept] = []
-
-    for mtype in media_types:
-        if not mtype:
-            continue
-
-        accept_list.append(Accept.parse(mtype))
-
-    return AcceptContainer(
-        sorted(accept_list, key=_sort_accept_value, reverse=True)
-    )
-
-
 def parse_credentials(
     header: Optional[str],
     prefixes: Union[List, Tuple, Set] = None,

sanic/http/__init__.py

@@ -0,0 +1,6 @@
+from .constants import Stage
+from .http1 import Http
+from .http3 import Http3
+
+
+__all__ = ("Http", "Stage", "Http3")

sanic/http/constants.py

@@ -0,0 +1,29 @@
+from enum import Enum, IntEnum
+
+
+class Stage(Enum):
+    """
+    Enum for representing the stage of the request/response cycle
+
+    | ``IDLE``  Waiting for request
+    | ``REQUEST``  Request headers being received
+    | ``HANDLER``  Headers done, handler running
+    | ``RESPONSE``  Response headers sent, body in progress
+    | ``FAILED``  Unrecoverable state (error while sending response)
+    |
+    """
+
+    IDLE = 0  # Waiting for request
+    REQUEST = 1  # Request headers being received
+    HANDLER = 3  # Headers done, handler running
+    RESPONSE = 4  # Response headers sent, body in progress
+    FAILED = 100  # Unrecoverable state (error while sending response)
+
+
+class HTTP(IntEnum):
+    VERSION_1 = 1
+    VERSION_3 = 3
+
+    def display(self) -> str:
+        value = 1.1 if self.value == 1 else self.value
+        return f"HTTP/{value}"

sanic/http/http1.py

@@ -3,71 +3,53 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Optional
 
 
-if TYPE_CHECKING:  # no cov
+if TYPE_CHECKING:
     from sanic.request import Request
     from sanic.response import BaseHTTPResponse
 
 from asyncio import CancelledError, sleep
-from enum import Enum
 
 from sanic.compat import Header
 from sanic.exceptions import (
-    HeaderExpectationFailed,
-    InvalidUsage,
+    BadRequest,
+    ExpectationFailed,
     PayloadTooLarge,
+    RequestCancelled,
     ServerError,
     ServiceUnavailable,
 )
 from sanic.headers import format_http1_response
 from sanic.helpers import has_message_body
+from sanic.http.constants import Stage
+from sanic.http.stream import Stream
 from sanic.log import access_logger, error_logger, logger
 from sanic.touchup import TouchUpMeta
 
 
-class Stage(Enum):
-    """
-    Enum for representing the stage of the request/response cycle
-
-    | ``IDLE``  Waiting for request
-    | ``REQUEST``  Request headers being received
-    | ``HANDLER``  Headers done, handler running
-    | ``RESPONSE``  Response headers sent, body in progress
-    | ``FAILED``  Unrecoverable state (error while sending response)
-    |
-    """
-
-    IDLE = 0  # Waiting for request
-    REQUEST = 1  # Request headers being received
-    HANDLER = 3  # Headers done, handler running
-    RESPONSE = 4  # Response headers sent, body in progress
-    FAILED = 100  # Unrecoverable state (error while sending response)
-
-
 HTTP_CONTINUE = b"HTTP/1.1 100 Continue\r\n\r\n"
 
 
-class Http(metaclass=TouchUpMeta):
+class Http(Stream, metaclass=TouchUpMeta):
     """
-    Internal helper for managing the HTTP request/response cycle
+    Internal helper for managing the HTTP/1.1 request/response cycle
 
     :raises ServerError:
     :raises PayloadTooLarge:
     :raises Exception:
-    :raises InvalidUsage:
-    :raises HeaderExpectationFailed:
+    :raises BadRequest:
+    :raises ExpectationFailed:
     :raises RuntimeError:
     :raises ServerError:
     :raises ServerError:
-    :raises InvalidUsage:
-    :raises InvalidUsage:
-    :raises InvalidUsage:
+    :raises BadRequest:
+    :raises BadRequest:
+    :raises BadRequest:
     :raises PayloadTooLarge:
     :raises RuntimeError:
     """
 
     HEADER_CEILING = 16_384
     HEADER_MAX_SIZE = 0
-
     __touchup__ = (
         "http1_request_header",
         "http1_response_header",
@@ -89,7 +71,6 @@ class Http(metaclass=TouchUpMeta):
         "request_body",
         "request_bytes",
         "request_bytes_left",
-        "request_max_size",
         "response",
         "response_func",
         "response_size",
@@ -151,7 +132,7 @@ class Http(metaclass=TouchUpMeta):
 
                 if self.stage is Stage.RESPONSE:
                     await self.response.send(end_stream=True)
-            except CancelledError:
+            except CancelledError as exc:
                 # Write an appropriate response before exiting
                 if not self.protocol.transport:
                     logger.info(
@@ -159,7 +140,11 @@ class Http(metaclass=TouchUpMeta):
                         "stopped. Transport is closed."
                     )
                     return
-                e = self.exception or ServiceUnavailable("Cancelled")
+                e = (
+                    RequestCancelled()
+                    if self.protocol.conn_info.lost
+                    else (self.exception or exc)
+                )
                 self.exception = None
                 self.keep_alive = False
                 await self.error_response(e)
@@ -248,7 +233,7 @@ class Http(metaclass=TouchUpMeta):
 
                 headers.append(h)
         except Exception:
-            raise InvalidUsage("Bad Request")
+            raise BadRequest("Bad Request")
 
         headers_instance = Header(headers)
         self.upgrade_websocket = (
@@ -265,6 +250,7 @@ class Http(metaclass=TouchUpMeta):
             transport=self.protocol.transport,
             app=self.protocol.app,
         )
+        self.protocol.request_class._current.set(request)
         await self.dispatch(
             "http.lifecycle.request",
             inline=True,
@@ -281,7 +267,7 @@ class Http(metaclass=TouchUpMeta):
                 if expect.lower() == "100-continue":
                     self.expecting_continue = True
                 else:
-                    raise HeaderExpectationFailed(f"Unknown Expect: {expect}")
+                    raise ExpectationFailed(f"Unknown Expect: {expect}")
 
             if headers.getone("transfer-encoding", None) == "chunked":
                 self.request_body = "chunked"
@@ -352,6 +338,12 @@ class Http(metaclass=TouchUpMeta):
             self.response_func = self.head_response_ignored
 
         headers["connection"] = "keep-alive" if self.keep_alive else "close"
+
+        # This header may be removed or modified by the AltSvcCheck Touchup
+        # service. At server start, we either remove this header from ever
+        # being assigned, or we change the value as required.
+        headers["alt-svc"] = ""
+
         ret = format_http1_response(status, res.processed_headers)
         if data:
             ret += data
@@ -436,7 +428,13 @@ class Http(metaclass=TouchUpMeta):
             if self.request is None:
                 self.create_empty_request()
 
-            await app.handle_exception(self.request, exception)
+            request_middleware = not isinstance(exception, ServiceUnavailable)
+            try:
+                await app.handle_exception(
+                    self.request, exception, request_middleware
+                )
+            except Exception as e:
+                await app.handle_exception(self.request, e, False)
 
     def create_empty_request(self) -> None:
         """
@@ -510,7 +508,7 @@ class Http(metaclass=TouchUpMeta):
 
                 if len(buf) > 64:
                     self.keep_alive = False
-                    raise InvalidUsage("Bad chunked encoding")
+                    raise BadRequest("Bad chunked encoding")
 
                 await self._receive_more()
 
@@ -518,14 +516,14 @@ class Http(metaclass=TouchUpMeta):
                 size = int(buf[2:pos].split(b";", 1)[0].decode(), 16)
             except Exception:
                 self.keep_alive = False
-                raise InvalidUsage("Bad chunked encoding")
+                raise BadRequest("Bad chunked encoding")
 
             if size <= 0:
                 self.request_body = None
 
                 if size < 0:
                     self.keep_alive = False
-                    raise InvalidUsage("Bad chunked encoding")
+                    raise BadRequest("Bad chunked encoding")
 
                 # Consume CRLF, chunk size 0 and the two CRLF that follow
                 pos += 4

sanic/http/http3.py

@@ -0,0 +1,406 @@
+from __future__ import annotations
+
+import asyncio
+
+from abc import ABC, abstractmethod
+from ssl import SSLContext
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Dict,
+    List,
+    Optional,
+    Tuple,
+    Union,
+    cast,
+)
+
+from sanic.compat import Header
+from sanic.constants import LocalCertCreator
+from sanic.exceptions import PayloadTooLarge, SanicException, ServerError
+from sanic.helpers import has_message_body
+from sanic.http.constants import Stage
+from sanic.http.stream import Stream
+from sanic.http.tls.context import CertSelector, SanicSSLContext
+from sanic.log import Colors, logger
+from sanic.models.protocol_types import TransportProtocol
+from sanic.models.server_types import ConnInfo
+
+
+try:
+    from aioquic.h0.connection import H0_ALPN, H0Connection
+    from aioquic.h3.connection import H3_ALPN, H3Connection
+    from aioquic.h3.events import (
+        DatagramReceived,
+        DataReceived,
+        H3Event,
+        HeadersReceived,
+        WebTransportStreamDataReceived,
+    )
+    from aioquic.quic.configuration import QuicConfiguration
+    from aioquic.tls import SessionTicket
+
+    HTTP3_AVAILABLE = True
+except ModuleNotFoundError:  # no cov
+    HTTP3_AVAILABLE = False
+
+if TYPE_CHECKING:
+    from sanic import Sanic
+    from sanic.request import Request
+    from sanic.response import BaseHTTPResponse
+    from sanic.server.protocols.http_protocol import Http3Protocol
+
+    HttpConnection = Union[H0Connection, H3Connection]
+
+
+class HTTP3Transport(TransportProtocol):
+    __slots__ = ("_protocol",)
+
+    def __init__(self, protocol: Http3Protocol):
+        self._protocol = protocol
+
+    def get_protocol(self) -> Http3Protocol:
+        return self._protocol
+
+    def get_extra_info(self, info: str, default: Any = None) -> Any:
+        if (
+            info in ("socket", "sockname", "peername")
+            and self._protocol._transport
+        ):
+            return self._protocol._transport.get_extra_info(info, default)
+        elif info == "network_paths":
+            return self._protocol._quic._network_paths
+        elif info == "ssl_context":
+            return self._protocol.app.state.ssl
+        return default
+
+
+class Receiver(ABC):
+    future: asyncio.Future
+
+    def __init__(self, transmit, protocol, request: Request) -> None:
+        self.transmit = transmit
+        self.protocol = protocol
+        self.request = request
+
+    @abstractmethod
+    async def run(self):  # no cov
+        ...
+
+
+class HTTPReceiver(Receiver, Stream):
+    stage: Stage
+    request: Request
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self.request_body = None
+        self.stage = Stage.IDLE
+        self.headers_sent = False
+        self.response: Optional[BaseHTTPResponse] = None
+        self.request_max_size = self.protocol.request_max_size
+        self.request_bytes = 0
+
+    async def run(self, exception: Optional[Exception] = None):
+        self.stage = Stage.HANDLER
+        self.head_only = self.request.method.upper() == "HEAD"
+
+        if exception:
+            logger.info(  # no cov
+                f"{Colors.BLUE}[exception]: "
+                f"{Colors.RED}{exception}{Colors.END}",
+                exc_info=True,
+                extra={"verbosity": 1},
+            )
+            await self.error_response(exception)
+        else:
+            try:
+                logger.info(  # no cov
+                    f"{Colors.BLUE}[request]:{Colors.END} {self.request}",
+                    extra={"verbosity": 1},
+                )
+                await self.protocol.request_handler(self.request)
+            except Exception as e:  # no cov
+                # This should largely be handled within the request handler.
+                # But, just in case...
+                await self.run(e)
+        self.stage = Stage.IDLE
+
+    async def error_response(self, exception: Exception) -> None:
+        """
+        Handle response when exception encountered
+        """
+        # From request and handler states we can respond, otherwise be silent
+        app = self.protocol.app
+
+        await app.handle_exception(self.request, exception)
+
+    def _prepare_headers(
+        self, response: BaseHTTPResponse
+    ) -> List[Tuple[bytes, bytes]]:
+        size = len(response.body) if response.body else 0
+        headers = response.headers
+        status = response.status
+
+        if not has_message_body(status) and (
+            size
+            or "content-length" in headers
+            or "transfer-encoding" in headers
+        ):
+            headers.pop("content-length", None)
+            headers.pop("transfer-encoding", None)
+            logger.warning(  # no cov
+                f"Message body set in response on {self.request.path}. "
+                f"A {status} response may only have headers, no body."
+            )
+        elif "content-length" not in headers:
+            if size:
+                headers["content-length"] = size
+            else:
+                headers["transfer-encoding"] = "chunked"
+
+        headers = [
+            (b":status", str(response.status).encode()),
+            *response.processed_headers,
+        ]
+        return headers
+
+    def send_headers(self) -> None:
+        logger.debug(  # no cov
+            f"{Colors.BLUE}[send]: {Colors.GREEN}HEADERS{Colors.END}",
+            extra={"verbosity": 2},
+        )
+        if not self.response:
+            raise RuntimeError("no response")
+
+        response = self.response
+        headers = self._prepare_headers(response)
+
+        self.protocol.connection.send_headers(
+            stream_id=self.request.stream_id,
+            headers=headers,
+        )
+        self.headers_sent = True
+        self.stage = Stage.RESPONSE
+
+        if self.response.body and not self.head_only:
+            self._send(self.response.body, False)
+        elif self.head_only:
+            self.future.cancel()
+
+    def respond(self, response: BaseHTTPResponse) -> BaseHTTPResponse:
+        logger.debug(  # no cov
+            f"{Colors.BLUE}[respond]:{Colors.END} {response}",
+            extra={"verbosity": 2},
+        )
+
+        if self.stage is not Stage.HANDLER:
+            self.stage = Stage.FAILED
+            raise RuntimeError("Response already started")
+
+        # Disconnect any earlier but unused response object
+        if self.response is not None:
+            self.response.stream = None
+
+        self.response, response.stream = response, self
+
+        return response
+
+    def receive_body(self, data: bytes) -> None:
+        self.request_bytes += len(data)
+        if self.request_bytes > self.request_max_size:
+            raise PayloadTooLarge("Request body exceeds the size limit")
+
+        self.request.body += data
+
+    async def send(self, data: bytes, end_stream: bool) -> None:
+        logger.debug(  # no cov
+            f"{Colors.BLUE}[send]: {Colors.GREEN}data={data.decode()} "
+            f"end_stream={end_stream}{Colors.END}",
+            extra={"verbosity": 2},
+        )
+        self._send(data, end_stream)
+
+    def _send(self, data: bytes, end_stream: bool) -> None:
+        if not self.headers_sent:
+            self.send_headers()
+        if self.stage is not Stage.RESPONSE:
+            raise ServerError(f"not ready to send: {self.stage}")
+
+        # Chunked
+        if (
+            self.response
+            and self.response.headers.get("transfer-encoding") == "chunked"
+        ):
+            size = len(data)
+            if end_stream:
+                data = (
+                    b"%x\r\n%b\r\n0\r\n\r\n" % (size, data)
+                    if size
+                    else b"0\r\n\r\n"
+                )
+            elif size:
+                data = b"%x\r\n%b\r\n" % (size, data)
+
+        logger.debug(  # no cov
+            f"{Colors.BLUE}[transmitting]{Colors.END}",
+            extra={"verbosity": 2},
+        )
+        self.protocol.connection.send_data(
+            stream_id=self.request.stream_id,
+            data=data,
+            end_stream=end_stream,
+        )
+        self.transmit()
+
+        if end_stream:
+            self.stage = Stage.IDLE
+
+
+class WebsocketReceiver(Receiver):  # noqa
+    async def run(self):
+        ...
+
+
+class WebTransportReceiver(Receiver):  # noqa
+    async def run(self):
+        ...
+
+
+class Http3:
+    """
+    Internal helper for managing the HTTP/3 request/response cycle
+    """
+
+    if HTTP3_AVAILABLE:
+        HANDLER_PROPERTY_MAPPING = {
+            DataReceived: "stream_id",
+            HeadersReceived: "stream_id",
+            DatagramReceived: "flow_id",
+            WebTransportStreamDataReceived: "session_id",
+        }
+
+    def __init__(
+        self,
+        protocol: Http3Protocol,
+        transmit: Callable[[], None],
+    ) -> None:
+        self.protocol = protocol
+        self.transmit = transmit
+        self.receivers: Dict[int, Receiver] = {}
+
+    def http_event_received(self, event: H3Event) -> None:
+        logger.debug(  # no cov
+            f"{Colors.BLUE}[http_event_received]: "
+            f"{Colors.YELLOW}{event}{Colors.END}",
+            extra={"verbosity": 2},
+        )
+        receiver, created_new = self.get_or_make_receiver(event)
+        receiver = cast(HTTPReceiver, receiver)
+
+        if isinstance(event, HeadersReceived) and created_new:
+            receiver.future = asyncio.ensure_future(receiver.run())
+        elif isinstance(event, DataReceived):
+            try:
+                receiver.receive_body(event.data)
+            except Exception as e:
+                receiver.future.cancel()
+                receiver.future = asyncio.ensure_future(receiver.run(e))
+        else:
+            ...  # Intentionally here to help out Touchup
+            logger.debug(  # no cov
+                f"{Colors.RED}DOING NOTHING{Colors.END}",
+                extra={"verbosity": 2},
+            )
+
+    def get_or_make_receiver(self, event: H3Event) -> Tuple[Receiver, bool]:
+        if (
+            isinstance(event, HeadersReceived)
+            and event.stream_id not in self.receivers
+        ):
+            request = self._make_request(event)
+            receiver = HTTPReceiver(self.transmit, self.protocol, request)
+            request.stream = receiver
+
+            self.receivers[event.stream_id] = receiver
+            return receiver, True
+        else:
+            ident = getattr(event, self.HANDLER_PROPERTY_MAPPING[type(event)])
+            return self.receivers[ident], False
+
+    def get_receiver_by_stream_id(self, stream_id: int) -> Receiver:
+        return self.receivers[stream_id]
+
+    def _make_request(self, event: HeadersReceived) -> Request:
+        headers = Header(((k.decode(), v.decode()) for k, v in event.headers))
+        method = headers[":method"]
+        path = headers[":path"]
+        scheme = headers.pop(":scheme", "")
+        authority = headers.pop(":authority", "")
+
+        if authority:
+            headers["host"] = authority
+
+        transport = HTTP3Transport(self.protocol)
+        request = self.protocol.request_class(
+            path.encode(),
+            headers,
+            "3",
+            method,
+            transport,
+            self.protocol.app,
+            b"",
+        )
+        request.conn_info = ConnInfo(transport)
+        request._stream_id = event.stream_id
+        request._scheme = scheme
+
+        return request
+
+
+class SessionTicketStore:
+    """
+    Simple in-memory store for session tickets.
+    """
+
+    def __init__(self) -> None:
+        self.tickets: Dict[bytes, SessionTicket] = {}
+
+    def add(self, ticket: SessionTicket) -> None:
+        self.tickets[ticket.ticket] = ticket
+
+    def pop(self, label: bytes) -> Optional[SessionTicket]:
+        return self.tickets.pop(label, None)
+
+
+def get_config(
+    app: Sanic, ssl: Union[SanicSSLContext, CertSelector, SSLContext]
+):
+    # TODO:
+    # - proper selection needed if service with multiple certs insted of
+    #   just taking the first
+    if isinstance(ssl, CertSelector):
+        ssl = cast(SanicSSLContext, ssl.sanic_select[0])
+    if app.config.LOCAL_CERT_CREATOR is LocalCertCreator.TRUSTME:
+        raise SanicException(
+            "Sorry, you cannot currently use trustme as a local certificate "
+            "generator for an HTTP/3 server. This is not yet supported. You "
+            "should be able to use mkcert instead. For more information, see: "
+            "https://github.com/aiortc/aioquic/issues/295."
+        )
+    if not isinstance(ssl, SanicSSLContext):
+        raise SanicException("SSLContext is not SanicSSLContext")
+
+    config = QuicConfiguration(
+        alpn_protocols=H3_ALPN + H0_ALPN + ["siduck"],
+        is_client=False,
+        max_datagram_frame_size=65536,
+    )
+    password = app.config.TLS_CERT_PASSWORD or None
+
+    config.load_cert_chain(
+        ssl.sanic["cert"], ssl.sanic["key"], password=password
+    )
+
+    return config

sanic/http/stream.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Optional, Tuple, Union
+
+from sanic.http.constants import Stage
+
+
+if TYPE_CHECKING:
+    from sanic.response import BaseHTTPResponse
+    from sanic.server.protocols.http_protocol import HttpProtocol
+
+
+class Stream:
+    stage: Stage
+    response: Optional[BaseHTTPResponse]
+    protocol: HttpProtocol
+    url: Optional[str]
+    request_body: Optional[bytes]
+    request_max_size: Union[int, float]
+
+    __touchup__: Tuple[str, ...] = tuple()
+    __slots__ = ("request_max_size",)
+
+    def respond(
+        self, response: BaseHTTPResponse
+    ) -> BaseHTTPResponse:  # no cov
+        raise NotImplementedError("Not implemented")

sanic/http/tls/__init__.py

@@ -0,0 +1,5 @@
+from .context import process_to_context
+from .creators import get_ssl_context
+
+
+__all__ = ("get_ssl_context", "process_to_context")

sanic/http/tls/context.py

@@ -1,7 +1,9 @@
+from __future__ import annotations
+
 import os
 import ssl
 
-from typing import Iterable, Optional, Union
+from typing import Any, Dict, Iterable, Optional, Union
 
 from sanic.log import logger
 
@@ -22,13 +24,15 @@ def create_context(
     certfile: Optional[str] = None,
     keyfile: Optional[str] = None,
     password: Optional[str] = None,
+    purpose: ssl.Purpose = ssl.Purpose.CLIENT_AUTH,
 ) -> ssl.SSLContext:
     """Create a context with secure crypto and HTTP/1.1 in protocols."""
-    context = ssl.create_default_context(purpose=ssl.Purpose.CLIENT_AUTH)
+    context = ssl.create_default_context(purpose=purpose)
     context.minimum_version = ssl.TLSVersion.TLSv1_2
     context.set_ciphers(":".join(CIPHERS_TLS12))
     context.set_alpn_protocols(["http/1.1"])
-    context.sni_callback = server_name_callback
+    if purpose is ssl.Purpose.CLIENT_AUTH:
+        context.sni_callback = server_name_callback
     if certfile and keyfile:
         context.load_cert_chain(certfile, keyfile, password)
     return context
@@ -77,65 +81,6 @@ def load_cert_dir(p: str) -> ssl.SSLContext:
     return CertSimple(certfile, keyfile)
 
 
-class CertSimple(ssl.SSLContext):
-    """A wrapper for creating SSLContext with a sanic attribute."""
-
-    def __new__(cls, cert, key, **kw):
-        # 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)
-        if not certfile or not keyfile:
-            raise ValueError("SSL dict needs filenames for cert and key.")
-        subject = {}
-        if "names" not in kw:
-            cert = ssl._ssl._test_decode_cert(certfile)  # type: ignore
-            kw["names"] = [
-                name
-                for t, name in cert["subjectAltName"]
-                if t in ["DNS", "IP Address"]
-            ]
-            subject = {k: v for item in cert["subject"] for k, v in item}
-        self = create_context(certfile, keyfile, password)
-        self.__class__ = cls
-        self.sanic = {**subject, **kw}
-        return self
-
-    def __init__(self, cert, key, **kw):
-        pass  # Do not call super().__init__ because it is already initialized
-
-
-class CertSelector(ssl.SSLContext):
-    """Automatically select SSL certificate based on the hostname that the
-    client is trying to access, via SSL SNI. Paths to certificate folders
-    with privkey.pem and fullchain.pem in them should be provided, and
-    will be matched in the order given whenever there is a new connection.
-    """
-
-    def __new__(cls, ctxs):
-        return super().__new__(cls)
-
-    def __init__(self, ctxs: Iterable[Optional[ssl.SSLContext]]):
-        super().__init__()
-        self.sni_callback = selector_sni_callback  # type: ignore
-        self.sanic_select = []
-        self.sanic_fallback = None
-        all_names = []
-        for i, ctx in enumerate(ctxs):
-            if not ctx:
-                continue
-            names = dict(getattr(ctx, "sanic", {})).get("names", [])
-            all_names += names
-            self.sanic_select.append(ctx)
-            if i == 0:
-                self.sanic_fallback = ctx
-        if not all_names:
-            raise ValueError(
-                "No certificates with SubjectAlternativeNames found."
-            )
-        logger.info(f"Certificate vhosts: {', '.join(all_names)}")
-
-
 def find_cert(self: CertSelector, server_name: str):
     """Find the first certificate that matches the given SNI.
 
@@ -194,3 +139,73 @@ def server_name_callback(
 ) -> None:
     """Store the received SNI as sslobj.sanic_server_name."""
     sslobj.sanic_server_name = server_name  # type: ignore
+
+
+class SanicSSLContext(ssl.SSLContext):
+    sanic: Dict[str, os.PathLike]
+
+    @classmethod
+    def create_from_ssl_context(cls, context: ssl.SSLContext):
+        context.__class__ = cls
+        return context
+
+
+class CertSimple(SanicSSLContext):
+    """A wrapper for creating SSLContext with a sanic attribute."""
+
+    sanic: Dict[str, Any]
+
+    def __new__(cls, cert, key, **kw):
+        # 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)
+        if not certfile or not keyfile:
+            raise ValueError("SSL dict needs filenames for cert and key.")
+        subject = {}
+        if "names" not in kw:
+            cert = ssl._ssl._test_decode_cert(certfile)  # type: ignore
+            kw["names"] = [
+                name
+                for t, name in cert["subjectAltName"]
+                if t in ["DNS", "IP Address"]
+            ]
+            subject = {k: v for item in cert["subject"] for k, v in item}
+        self = create_context(certfile, keyfile, password)
+        self.__class__ = cls
+        self.sanic = {**subject, **kw}
+        return self
+
+    def __init__(self, cert, key, **kw):
+        pass  # Do not call super().__init__ because it is already initialized
+
+
+class CertSelector(ssl.SSLContext):
+    """Automatically select SSL certificate based on the hostname that the
+    client is trying to access, via SSL SNI. Paths to certificate folders
+    with privkey.pem and fullchain.pem in them should be provided, and
+    will be matched in the order given whenever there is a new connection.
+    """
+
+    def __new__(cls, ctxs):
+        return super().__new__(cls)
+
+    def __init__(self, ctxs: Iterable[Optional[ssl.SSLContext]]):
+        super().__init__()
+        self.sni_callback = selector_sni_callback  # type: ignore
+        self.sanic_select = []
+        self.sanic_fallback = None
+        all_names = []
+        for i, ctx in enumerate(ctxs):
+            if not ctx:
+                continue
+            names = dict(getattr(ctx, "sanic", {})).get("names", [])
+            all_names += names
+            self.sanic_select.append(ctx)
+            if i == 0:
+                self.sanic_fallback = ctx
+        if not all_names:
+            raise ValueError(
+                "No certificates with SubjectAlternativeNames found."
+            )
+        logger.info(f"Certificate vhosts: {', '.join(all_names)}")

sanic/http/tls/creators.py

@@ -0,0 +1,289 @@
+from __future__ import annotations
+
+import ssl
+import subprocess
+import sys
+
+from abc import ABC, abstractmethod
+from contextlib import suppress
+from pathlib import Path
+from tempfile import mkdtemp
+from types import ModuleType
+from typing import TYPE_CHECKING, Optional, Tuple, Type, Union, cast
+
+from sanic.application.constants import Mode
+from sanic.application.spinner import loading
+from sanic.constants import (
+    DEFAULT_LOCAL_TLS_CERT,
+    DEFAULT_LOCAL_TLS_KEY,
+    LocalCertCreator,
+)
+from sanic.exceptions import SanicException
+from sanic.helpers import Default
+from sanic.http.tls.context import CertSimple, SanicSSLContext
+
+
+try:
+    import trustme
+
+    TRUSTME_INSTALLED = True
+except (ImportError, ModuleNotFoundError):
+    trustme = ModuleType("trustme")
+    TRUSTME_INSTALLED = False
+
+if TYPE_CHECKING:
+    from sanic import Sanic
+
+
+# Only allow secure ciphers, notably leaving out AES-CBC mode
+# OpenSSL chooses ECDSA or RSA depending on the cert in use
+CIPHERS_TLS12 = [
+    "ECDHE-ECDSA-CHACHA20-POLY1305",
+    "ECDHE-ECDSA-AES256-GCM-SHA384",
+    "ECDHE-ECDSA-AES128-GCM-SHA256",
+    "ECDHE-RSA-CHACHA20-POLY1305",
+    "ECDHE-RSA-AES256-GCM-SHA384",
+    "ECDHE-RSA-AES128-GCM-SHA256",
+]
+
+
+def _make_path(maybe_path: Union[Path, str], tmpdir: Optional[Path]) -> Path:
+    if isinstance(maybe_path, Path):
+        return maybe_path
+    else:
+        path = Path(maybe_path)
+        if not path.exists():
+            if not tmpdir:
+                raise RuntimeError("Reached an unknown state. No tmpdir.")
+            return tmpdir / maybe_path
+
+    return path
+
+
+def get_ssl_context(
+    app: Sanic, ssl: Optional[ssl.SSLContext]
+) -> ssl.SSLContext:
+    if ssl:
+        return ssl
+
+    if app.state.mode is Mode.PRODUCTION:
+        raise SanicException(
+            "Cannot run Sanic as an HTTPS server in PRODUCTION mode "
+            "without passing a TLS certificate. If you are developing "
+            "locally, please enable DEVELOPMENT mode and Sanic will "
+            "generate a localhost TLS certificate. For more information "
+            "please see: https://sanic.dev/en/guide/deployment/development."
+            "html#automatic-tls-certificate."
+        )
+
+    creator = CertCreator.select(
+        app,
+        cast(LocalCertCreator, app.config.LOCAL_CERT_CREATOR),
+        app.config.LOCAL_TLS_KEY,
+        app.config.LOCAL_TLS_CERT,
+    )
+    context = creator.generate_cert(app.config.LOCALHOST)
+    return context
+
+
+class CertCreator(ABC):
+    def __init__(self, app, key, cert) -> None:
+        self.app = app
+        self.key = key
+        self.cert = cert
+        self.tmpdir = None
+
+        if isinstance(self.key, Default) or isinstance(self.cert, Default):
+            self.tmpdir = Path(mkdtemp())
+
+        key = (
+            DEFAULT_LOCAL_TLS_KEY
+            if isinstance(self.key, Default)
+            else self.key
+        )
+        cert = (
+            DEFAULT_LOCAL_TLS_CERT
+            if isinstance(self.cert, Default)
+            else self.cert
+        )
+
+        self.key_path = _make_path(key, self.tmpdir)
+        self.cert_path = _make_path(cert, self.tmpdir)
+
+    @abstractmethod
+    def check_supported(self) -> None:  # no cov
+        ...
+
+    @abstractmethod
+    def generate_cert(self, localhost: str) -> ssl.SSLContext:  # no cov
+        ...
+
+    @classmethod
+    def select(
+        cls,
+        app: Sanic,
+        cert_creator: LocalCertCreator,
+        local_tls_key,
+        local_tls_cert,
+    ) -> CertCreator:
+        creator: Optional[CertCreator] = None
+
+        cert_creator_options: Tuple[
+            Tuple[Type[CertCreator], LocalCertCreator], ...
+        ] = (
+            (MkcertCreator, LocalCertCreator.MKCERT),
+            (TrustmeCreator, LocalCertCreator.TRUSTME),
+        )
+        for creator_class, local_creator in cert_creator_options:
+            creator = cls._try_select(
+                app,
+                creator,
+                creator_class,
+                local_creator,
+                cert_creator,
+                local_tls_key,
+                local_tls_cert,
+            )
+            if creator:
+                break
+
+        if not creator:
+            raise SanicException(
+                "Sanic could not find package to create a TLS certificate. "
+                "You must have either mkcert or trustme installed. See "
+                "https://sanic.dev/en/guide/deployment/development.html"
+                "#automatic-tls-certificate for more details."
+            )
+
+        return creator
+
+    @staticmethod
+    def _try_select(
+        app: Sanic,
+        creator: Optional[CertCreator],
+        creator_class: Type[CertCreator],
+        creator_requirement: LocalCertCreator,
+        creator_requested: LocalCertCreator,
+        local_tls_key,
+        local_tls_cert,
+    ):
+        if creator or (
+            creator_requested is not LocalCertCreator.AUTO
+            and creator_requested is not creator_requirement
+        ):
+            return creator
+
+        instance = creator_class(app, local_tls_key, local_tls_cert)
+        try:
+            instance.check_supported()
+        except SanicException:
+            if creator_requested is creator_requirement:
+                raise
+            else:
+                return None
+
+        return instance
+
+
+class MkcertCreator(CertCreator):
+    def check_supported(self) -> None:
+        try:
+            subprocess.run(  # nosec B603 B607
+                ["mkcert", "-help"],
+                check=True,
+                stderr=subprocess.DEVNULL,
+                stdout=subprocess.DEVNULL,
+            )
+        except Exception as e:
+            raise SanicException(
+                "Sanic is attempting to use mkcert to generate local TLS "
+                "certificates since you did not supply a certificate, but "
+                "one is required. Sanic cannot proceed since mkcert does not "
+                "appear to be installed. Alternatively, you can use trustme. "
+                "Please install mkcert, trustme, or supply TLS certificates "
+                "to proceed. Installation instructions can be found here: "
+                "https://github.com/FiloSottile/mkcert.\n"
+                "Find out more information about your options here: "
+                "https://sanic.dev/en/guide/deployment/development.html#"
+                "automatic-tls-certificate"
+            ) from e
+
+    def generate_cert(self, localhost: str) -> ssl.SSLContext:
+        try:
+            if not self.cert_path.exists():
+                message = "Generating TLS certificate"
+                # TODO: Validate input for security
+                with loading(message):
+                    cmd = [
+                        "mkcert",
+                        "-key-file",
+                        str(self.key_path),
+                        "-cert-file",
+                        str(self.cert_path),
+                        localhost,
+                    ]
+                    resp = subprocess.run(  # nosec B603
+                        cmd,
+                        check=True,
+                        stdout=subprocess.PIPE,
+                        stderr=subprocess.STDOUT,
+                        text=True,
+                    )
+                sys.stdout.write("\r" + " " * (len(message) + 4))
+                sys.stdout.flush()
+                sys.stdout.write(resp.stdout)
+        finally:
+
+            @self.app.main_process_stop
+            async def cleanup(*_):  # no cov
+                if self.tmpdir:
+                    with suppress(FileNotFoundError):
+                        self.key_path.unlink()
+                        self.cert_path.unlink()
+                    self.tmpdir.rmdir()
+
+        context = CertSimple(self.cert_path, self.key_path)
+        context.sanic["creator"] = "mkcert"
+        context.sanic["localhost"] = localhost
+        SanicSSLContext.create_from_ssl_context(context)
+
+        return context
+
+
+class TrustmeCreator(CertCreator):
+    def check_supported(self) -> None:
+        if not TRUSTME_INSTALLED:
+            raise SanicException(
+                "Sanic is attempting to use trustme to generate local TLS "
+                "certificates since you did not supply a certificate, but "
+                "one is required. Sanic cannot proceed since trustme does not "
+                "appear to be installed. Alternatively, you can use mkcert. "
+                "Please install mkcert, trustme, or supply TLS certificates "
+                "to proceed. Installation instructions can be found here: "
+                "https://github.com/python-trio/trustme.\n"
+                "Find out more information about your options here: "
+                "https://sanic.dev/en/guide/deployment/development.html#"
+                "automatic-tls-certificate"
+            )
+
+    def generate_cert(self, localhost: str) -> ssl.SSLContext:
+        context = SanicSSLContext.create_from_ssl_context(
+            ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
+        )
+        context.sanic = {
+            "cert": self.cert_path.absolute(),
+            "key": self.key_path.absolute(),
+        }
+        ca = trustme.CA()
+        server_cert = ca.issue_cert(localhost)
+        server_cert.configure_cert(context)
+        ca.configure_trust(context)
+
+        ca.cert_pem.write_to_path(str(self.cert_path.absolute()))
+        server_cert.private_key_and_cert_chain_pem.write_to_path(
+            str(self.key_path.absolute())
+        )
+        context.sanic["creator"] = "trustme"
+        context.sanic["localhost"] = localhost
+
+        return context

sanic/log.py

@@ -2,9 +2,22 @@ import logging
 import sys
 
 from enum import Enum
-from typing import Any, Dict
+from typing import TYPE_CHECKING, Any, Dict
 from warnings import warn
 
+from sanic.compat import is_atty
+
+
+# Python 3.11 changed the way Enum formatting works for mixed-in types.
+if sys.version_info < (3, 11, 0):
+
+    class StrEnum(str, Enum):
+        pass
+
+else:
+    if not TYPE_CHECKING:
+        from enum import StrEnum
+
 
 LOGGING_CONFIG_DEFAULTS: Dict[str, Any] = dict(  # no cov
     version=1,
@@ -23,6 +36,12 @@ LOGGING_CONFIG_DEFAULTS: Dict[str, Any] = dict(  # no cov
             "propagate": True,
             "qualname": "sanic.access",
         },
+        "sanic.server": {
+            "level": "INFO",
+            "handlers": ["console"],
+            "propagate": True,
+            "qualname": "sanic.server",
+        },
     },
     handlers={
         "console": {
@@ -55,35 +74,60 @@ LOGGING_CONFIG_DEFAULTS: Dict[str, Any] = dict(  # no cov
         },
     },
 )
+"""
+Defult logging configuration
+"""
 
 
-class Colors(str, Enum):  # no cov
+class Colors(StrEnum):  # no cov
     END = "\033[0m"
-    BLUE = "\033[01;34m"
-    GREEN = "\033[01;32m"
+    BOLD = "\033[1m"
+    BLUE = "\033[34m"
+    GREEN = "\033[32m"
+    PURPLE = "\033[35m"
+    RED = "\033[31m"
+    SANIC = "\033[38;2;255;13;104m"
     YELLOW = "\033[01;33m"
-    RED = "\033[01;31m"
 
 
+class VerbosityFilter(logging.Filter):
+    verbosity: int = 0
+
+    def filter(self, record: logging.LogRecord) -> bool:
+        verbosity = getattr(record, "verbosity", 0)
+        return verbosity <= self.verbosity
+
+
+_verbosity_filter = VerbosityFilter()
+
 logger = logging.getLogger("sanic.root")  # no cov
 """
 General Sanic logger
 """
+logger.addFilter(_verbosity_filter)
 
 error_logger = logging.getLogger("sanic.error")  # no cov
 """
 Logger used by Sanic for error logging
 """
+error_logger.addFilter(_verbosity_filter)
 
 access_logger = logging.getLogger("sanic.access")  # no cov
 """
 Logger used by Sanic for access logging
 """
+access_logger.addFilter(_verbosity_filter)
+
+server_logger = logging.getLogger("sanic.server")  # no cov
+"""
+Logger used by Sanic for server related messages
+"""
+logger.addFilter(_verbosity_filter)
 
 
 def deprecation(message: str, version: float):  # no cov
     version_info = f"[DEPRECATION v{version}] "
-    if sys.stdout.isatty():
+    if is_atty():
         version_info = f"{Colors.RED}{version_info}"
         message = f"{Colors.YELLOW}{message}{Colors.END}"
     warn(version_info + message, DeprecationWarning)

sanic/middleware.py

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

sanic/mixins/base.py

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

sanic/mixins/listeners.py

@@ -1,8 +1,9 @@
 from enum import Enum, auto
 from functools import partial
-from typing import List, Optional, Union
+from typing import Callable, List, Optional, Union, overload
 
 from sanic.base.meta import SanicMeta
+from sanic.exceptions import BadRequest
 from sanic.models.futures import FutureListener
 from sanic.models.handler_types import ListenerType, Sanic
 
@@ -16,7 +17,12 @@ class ListenerEvent(str, Enum):
     BEFORE_SERVER_STOP = "server.shutdown.before"
     AFTER_SERVER_STOP = "server.shutdown.after"
     MAIN_PROCESS_START = auto()
+    MAIN_PROCESS_READY = auto()
     MAIN_PROCESS_STOP = auto()
+    RELOAD_PROCESS_START = auto()
+    RELOAD_PROCESS_STOP = auto()
+    BEFORE_RELOAD_TRIGGER = auto()
+    AFTER_RELOAD_TRIGGER = auto()
 
 
 class ListenerMixin(metaclass=SanicMeta):
@@ -26,12 +32,33 @@ class ListenerMixin(metaclass=SanicMeta):
     def _apply_listener(self, listener: FutureListener):
         raise NotImplementedError  # noqa
 
+    @overload
+    def listener(
+        self,
+        listener_or_event: ListenerType[Sanic],
+        event_or_none: str,
+        apply: bool = ...,
+    ) -> ListenerType[Sanic]:
+        ...
+
+    @overload
+    def listener(
+        self,
+        listener_or_event: str,
+        event_or_none: None = ...,
+        apply: bool = ...,
+    ) -> Callable[[ListenerType[Sanic]], ListenerType[Sanic]]:
+        ...
+
     def listener(
         self,
         listener_or_event: Union[ListenerType[Sanic], str],
         event_or_none: Optional[str] = None,
         apply: bool = True,
-    ) -> ListenerType[Sanic]:
+    ) -> Union[
+        ListenerType[Sanic],
+        Callable[[ListenerType[Sanic]], ListenerType[Sanic]],
+    ]:
         """
         Create a listener from a decorated function.
 
@@ -49,7 +76,9 @@ class ListenerMixin(metaclass=SanicMeta):
         :param event: event to listen to
         """
 
-        def register_listener(listener, event):
+        def register_listener(
+            listener: ListenerType[Sanic], event: str
+        ) -> ListenerType[Sanic]:
             nonlocal apply
 
             future_listener = FutureListener(listener, event)
@@ -59,6 +88,10 @@ class ListenerMixin(metaclass=SanicMeta):
             return listener
 
         if callable(listener_or_event):
+            if event_or_none is None:
+                raise BadRequest(
+                    "Invalid event registration: Missing event name."
+                )
             return register_listener(listener_or_event, event_or_none)
         else:
             return partial(register_listener, event=listener_or_event)
@@ -68,11 +101,36 @@ class ListenerMixin(metaclass=SanicMeta):
     ) -> ListenerType[Sanic]:
         return self.listener(listener, "main_process_start")
 
+    def main_process_ready(
+        self, listener: ListenerType[Sanic]
+    ) -> ListenerType[Sanic]:
+        return self.listener(listener, "main_process_ready")
+
     def main_process_stop(
         self, listener: ListenerType[Sanic]
     ) -> ListenerType[Sanic]:
         return self.listener(listener, "main_process_stop")
 
+    def reload_process_start(
+        self, listener: ListenerType[Sanic]
+    ) -> ListenerType[Sanic]:
+        return self.listener(listener, "reload_process_start")
+
+    def reload_process_stop(
+        self, listener: ListenerType[Sanic]
+    ) -> ListenerType[Sanic]:
+        return self.listener(listener, "reload_process_stop")
+
+    def before_reload_trigger(
+        self, listener: ListenerType[Sanic]
+    ) -> ListenerType[Sanic]:
+        return self.listener(listener, "before_reload_trigger")
+
+    def after_reload_trigger(
+        self, listener: ListenerType[Sanic]
+    ) -> ListenerType[Sanic]:
+        return self.listener(listener, "after_reload_trigger")
+
     def before_server_start(
         self, listener: ListenerType[Sanic]
     ) -> ListenerType[Sanic]:

sanic/mixins/middleware.py

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

sanic/mixins/routes.py

@@ -1,63 +1,44 @@
 from ast import NodeVisitor, Return, parse
 from contextlib import suppress
-from functools import partial, wraps
 from inspect import getsource, signature
-from mimetypes import guess_type
-from os import path
-from pathlib import PurePath
-from re import sub
 from textwrap import dedent
-from time import gmtime, strftime
-from typing import Any, Callable, Iterable, List, Optional, Set, Tuple, Union
-from urllib.parse import unquote
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    Iterable,
+    List,
+    Optional,
+    Set,
+    Tuple,
+    Union,
+    cast,
+)
 
-from sanic_routing.route import Route  # type: ignore
+from sanic_routing.route import Route
 
 from sanic.base.meta import SanicMeta
-from sanic.compat import stat_async
-from sanic.constants import DEFAULT_HTTP_CONTENT_TYPE, HTTP_METHODS
+from sanic.constants import HTTP_METHODS
 from sanic.errorpages import RESPONSE_MAPPING
-from sanic.exceptions import (
-    ContentRangeError,
-    FileNotFound,
-    HeaderNotFound,
-    InvalidUsage,
-)
-from sanic.handlers import ContentRangeHandler
-from sanic.log import deprecation, error_logger
+from sanic.mixins.base import BaseMixin
 from sanic.models.futures import FutureRoute, FutureStatic
 from sanic.models.handler_types import RouteHandler
-from sanic.response import HTTPResponse, file, file_stream
 from sanic.types import HashableDict
 
 
 RouteWrapper = Callable[
     [RouteHandler], Union[RouteHandler, Tuple[Route, RouteHandler]]
 ]
-RESTRICTED_ROUTE_CONTEXT = (
-    "ignore_body",
-    "stream",
-    "hosts",
-    "static",
-    "error_format",
-    "websocket",
-)
 
 
-class RouteMixin(metaclass=SanicMeta):
-    name: str
-
+class RouteMixin(BaseMixin, metaclass=SanicMeta):
     def __init__(self, *args, **kwargs) -> None:
         self._future_routes: Set[FutureRoute] = set()
         self._future_statics: Set[FutureStatic] = set()
-        self.strict_slashes: Optional[bool] = False
 
     def _apply_route(self, route: FutureRoute) -> List[Route]:
         raise NotImplementedError  # noqa
 
-    def _apply_static(self, static: FutureStatic) -> Route:
-        raise NotImplementedError  # noqa
-
     def route(
         self,
         uri: str,
@@ -221,7 +202,8 @@ class RouteMixin(metaclass=SanicMeta):
         stream: bool = False,
         version_prefix: str = "/v",
         error_format: Optional[str] = None,
-        **ctx_kwargs,
+        unquote: bool = False,
+        **ctx_kwargs: Any,
     ) -> RouteHandler:
         """A helper method to register class instance or
         functions as a handler to the application url
@@ -267,6 +249,7 @@ class RouteMixin(metaclass=SanicMeta):
             name=name,
             version_prefix=version_prefix,
             error_format=error_format,
+            unquote=unquote,
             **ctx_kwargs,
         )(handler)
         return handler
@@ -282,8 +265,8 @@ class RouteMixin(metaclass=SanicMeta):
         ignore_body: bool = True,
         version_prefix: str = "/v",
         error_format: Optional[str] = None,
-        **ctx_kwargs,
-    ) -> RouteWrapper:
+        **ctx_kwargs: Any,
+    ) -> RouteHandler:
         """
         Add an API URL under the **GET** *HTTP* method
 
@@ -299,17 +282,20 @@ class RouteMixin(metaclass=SanicMeta):
             will be appended to the route context (``route.ctx``)
         :return: Object decorated with :func:`route` method
         """
-        return self.route(
-            uri,
-            methods=frozenset({"GET"}),
-            host=host,
-            strict_slashes=strict_slashes,
-            version=version,
-            name=name,
-            ignore_body=ignore_body,
-            version_prefix=version_prefix,
-            error_format=error_format,
-            **ctx_kwargs,
+        return cast(
+            RouteHandler,
+            self.route(
+                uri,
+                methods=frozenset({"GET"}),
+                host=host,
+                strict_slashes=strict_slashes,
+                version=version,
+                name=name,
+                ignore_body=ignore_body,
+                version_prefix=version_prefix,
+                error_format=error_format,
+                **ctx_kwargs,
+            ),
         )
 
     def post(
@@ -322,8 +308,8 @@ class RouteMixin(metaclass=SanicMeta):
         name: Optional[str] = None,
         version_prefix: str = "/v",
         error_format: Optional[str] = None,
-        **ctx_kwargs,
-    ) -> RouteWrapper:
+        **ctx_kwargs: Any,
+    ) -> RouteHandler:
         """
         Add an API URL under the **POST** *HTTP* method
 
@@ -339,17 +325,20 @@ class RouteMixin(metaclass=SanicMeta):
             will be appended to the route context (``route.ctx``)
         :return: Object decorated with :func:`route` method
         """
-        return self.route(
-            uri,
-            methods=frozenset({"POST"}),
-            host=host,
-            strict_slashes=strict_slashes,
-            stream=stream,
-            version=version,
-            name=name,
-            version_prefix=version_prefix,
-            error_format=error_format,
-            **ctx_kwargs,
+        return cast(
+            RouteHandler,
+            self.route(
+                uri,
+                methods=frozenset({"POST"}),
+                host=host,
+                strict_slashes=strict_slashes,
+                stream=stream,
+                version=version,
+                name=name,
+                version_prefix=version_prefix,
+                error_format=error_format,
+                **ctx_kwargs,
+            ),
         )
 
     def put(
@@ -362,8 +351,8 @@ class RouteMixin(metaclass=SanicMeta):
         name: Optional[str] = None,
         version_prefix: str = "/v",
         error_format: Optional[str] = None,
-        **ctx_kwargs,
-    ) -> RouteWrapper:
+        **ctx_kwargs: Any,
+    ) -> RouteHandler:
         """
         Add an API URL under the **PUT** *HTTP* method
 
@@ -379,17 +368,20 @@ class RouteMixin(metaclass=SanicMeta):
             will be appended to the route context (``route.ctx``)
         :return: Object decorated with :func:`route` method
         """
-        return self.route(
-            uri,
-            methods=frozenset({"PUT"}),
-            host=host,
-            strict_slashes=strict_slashes,
-            stream=stream,
-            version=version,
-            name=name,
-            version_prefix=version_prefix,
-            error_format=error_format,
-            **ctx_kwargs,
+        return cast(
+            RouteHandler,
+            self.route(
+                uri,
+                methods=frozenset({"PUT"}),
+                host=host,
+                strict_slashes=strict_slashes,
+                stream=stream,
+                version=version,
+                name=name,
+                version_prefix=version_prefix,
+                error_format=error_format,
+                **ctx_kwargs,
+            ),
         )
 
     def head(
@@ -402,8 +394,8 @@ class RouteMixin(metaclass=SanicMeta):
         ignore_body: bool = True,
         version_prefix: str = "/v",
         error_format: Optional[str] = None,
-        **ctx_kwargs,
-    ) -> RouteWrapper:
+        **ctx_kwargs: Any,
+    ) -> RouteHandler:
         """
         Add an API URL under the **HEAD** *HTTP* method
 
@@ -427,17 +419,20 @@ class RouteMixin(metaclass=SanicMeta):
             will be appended to the route context (``route.ctx``)
         :return: Object decorated with :func:`route` method
         """
-        return self.route(
-            uri,
-            methods=frozenset({"HEAD"}),
-            host=host,
-            strict_slashes=strict_slashes,
-            version=version,
-            name=name,
-            ignore_body=ignore_body,
-            version_prefix=version_prefix,
-            error_format=error_format,
-            **ctx_kwargs,
+        return cast(
+            RouteHandler,
+            self.route(
+                uri,
+                methods=frozenset({"HEAD"}),
+                host=host,
+                strict_slashes=strict_slashes,
+                version=version,
+                name=name,
+                ignore_body=ignore_body,
+                version_prefix=version_prefix,
+                error_format=error_format,
+                **ctx_kwargs,
+            ),
         )
 
     def options(
@@ -450,8 +445,8 @@ class RouteMixin(metaclass=SanicMeta):
         ignore_body: bool = True,
         version_prefix: str = "/v",
         error_format: Optional[str] = None,
-        **ctx_kwargs,
-    ) -> RouteWrapper:
+        **ctx_kwargs: Any,
+    ) -> RouteHandler:
         """
         Add an API URL under the **OPTIONS** *HTTP* method
 
@@ -475,17 +470,20 @@ class RouteMixin(metaclass=SanicMeta):
             will be appended to the route context (``route.ctx``)
         :return: Object decorated with :func:`route` method
         """
-        return self.route(
-            uri,
-            methods=frozenset({"OPTIONS"}),
-            host=host,
-            strict_slashes=strict_slashes,
-            version=version,
-            name=name,
-            ignore_body=ignore_body,
-            version_prefix=version_prefix,
-            error_format=error_format,
-            **ctx_kwargs,
+        return cast(
+            RouteHandler,
+            self.route(
+                uri,
+                methods=frozenset({"OPTIONS"}),
+                host=host,
+                strict_slashes=strict_slashes,
+                version=version,
+                name=name,
+                ignore_body=ignore_body,
+                version_prefix=version_prefix,
+                error_format=error_format,
+                **ctx_kwargs,
+            ),
         )
 
     def patch(
@@ -498,8 +496,8 @@ class RouteMixin(metaclass=SanicMeta):
         name: Optional[str] = None,
         version_prefix: str = "/v",
         error_format: Optional[str] = None,
-        **ctx_kwargs,
-    ) -> RouteWrapper:
+        **ctx_kwargs: Any,
+    ) -> RouteHandler:
         """
         Add an API URL under the **PATCH** *HTTP* method
 
@@ -525,17 +523,20 @@ class RouteMixin(metaclass=SanicMeta):
             will be appended to the route context (``route.ctx``)
         :return: Object decorated with :func:`route` method
         """
-        return self.route(
-            uri,
-            methods=frozenset({"PATCH"}),
-            host=host,
-            strict_slashes=strict_slashes,
-            stream=stream,
-            version=version,
-            name=name,
-            version_prefix=version_prefix,
-            error_format=error_format,
-            **ctx_kwargs,
+        return cast(
+            RouteHandler,
+            self.route(
+                uri,
+                methods=frozenset({"PATCH"}),
+                host=host,
+                strict_slashes=strict_slashes,
+                stream=stream,
+                version=version,
+                name=name,
+                version_prefix=version_prefix,
+                error_format=error_format,
+                **ctx_kwargs,
+            ),
         )
 
     def delete(
@@ -548,8 +549,8 @@ class RouteMixin(metaclass=SanicMeta):
         ignore_body: bool = True,
         version_prefix: str = "/v",
         error_format: Optional[str] = None,
-        **ctx_kwargs,
-    ) -> RouteWrapper:
+        **ctx_kwargs: Any,
+    ) -> RouteHandler:
         """
         Add an API URL under the **DELETE** *HTTP* method
 
@@ -565,17 +566,20 @@ class RouteMixin(metaclass=SanicMeta):
             will be appended to the route context (``route.ctx``)
         :return: Object decorated with :func:`route` method
         """
-        return self.route(
-            uri,
-            methods=frozenset({"DELETE"}),
-            host=host,
-            strict_slashes=strict_slashes,
-            version=version,
-            name=name,
-            ignore_body=ignore_body,
-            version_prefix=version_prefix,
-            error_format=error_format,
-            **ctx_kwargs,
+        return cast(
+            RouteHandler,
+            self.route(
+                uri,
+                methods=frozenset({"DELETE"}),
+                host=host,
+                strict_slashes=strict_slashes,
+                version=version,
+                name=name,
+                ignore_body=ignore_body,
+                version_prefix=version_prefix,
+                error_format=error_format,
+                **ctx_kwargs,
+            ),
         )
 
     def websocket(
@@ -589,7 +593,7 @@ class RouteMixin(metaclass=SanicMeta):
         apply: bool = True,
         version_prefix: str = "/v",
         error_format: Optional[str] = None,
-        **ctx_kwargs,
+        **ctx_kwargs: Any,
     ):
         """
         Decorate a function to be registered as a websocket route
@@ -633,7 +637,7 @@ class RouteMixin(metaclass=SanicMeta):
         name: Optional[str] = None,
         version_prefix: str = "/v",
         error_format: Optional[str] = None,
-        **ctx_kwargs,
+        **ctx_kwargs: Any,
     ):
         """
         A helper method to register a function as a websocket route.
@@ -668,313 +672,6 @@ class RouteMixin(metaclass=SanicMeta):
             **ctx_kwargs,
         )(handler)
 
-    def static(
-        self,
-        uri,
-        file_or_directory: Union[str, bytes, PurePath],
-        pattern=r"/?.+",
-        use_modified_since=True,
-        use_content_range=False,
-        stream_large_files=False,
-        name="static",
-        host=None,
-        strict_slashes=None,
-        content_type=None,
-        apply=True,
-        resource_type=None,
-    ):
-        """
-        Register a root to serve files from. The input can either be a
-        file or a directory. This method will enable an easy and simple way
-        to setup the :class:`Route` necessary to serve the static files.
-
-        :param uri: URL path to be used for serving static content
-        :param file_or_directory: Path for the Static file/directory with
-            static files
-        :param pattern: Regex Pattern identifying the valid static files
-        :param use_modified_since: If true, send file modified time, and return
-            not modified if the browser's matches the server's
-        :param use_content_range: If true, process header for range requests
-            and sends the file part that is requested
-        :param stream_large_files: If true, use the
-            :func:`StreamingHTTPResponse.file_stream` handler rather
-            than the :func:`HTTPResponse.file` handler to send the file.
-            If this is an integer, this represents the threshold size to
-            switch to :func:`StreamingHTTPResponse.file_stream`
-        :param name: user defined name used for url_for
-        :param host: Host IP or FQDN for the service to use
-        :param strict_slashes: Instruct :class:`Sanic` to check if the request
-            URLs need to terminate with a */*
-        :param content_type: user defined content type for header
-        :return: routes registered on the router
-        :rtype: List[sanic.router.Route]
-        """
-
-        name = self._generate_name(name)
-
-        if strict_slashes is None and self.strict_slashes is not None:
-            strict_slashes = self.strict_slashes
-
-        if not isinstance(file_or_directory, (str, bytes, PurePath)):
-            raise ValueError(
-                f"Static route must be a valid path, not {file_or_directory}"
-            )
-
-        static = FutureStatic(
-            uri,
-            file_or_directory,
-            pattern,
-            use_modified_since,
-            use_content_range,
-            stream_large_files,
-            name,
-            host,
-            strict_slashes,
-            content_type,
-            resource_type,
-        )
-        self._future_statics.add(static)
-
-        if apply:
-            self._apply_static(static)
-
-    def _generate_name(self, *objects) -> str:
-        name = None
-
-        for obj in objects:
-            if obj:
-                if isinstance(obj, str):
-                    name = obj
-                    break
-
-                try:
-                    name = obj.name
-                except AttributeError:
-                    try:
-                        name = obj.__name__
-                    except AttributeError:
-                        continue
-                else:
-                    break
-
-        if not name:  # noqa
-            raise ValueError("Could not generate a name for handler")
-
-        if not name.startswith(f"{self.name}."):
-            name = f"{self.name}.{name}"
-
-        return name
-
-    async def _static_request_handler(
-        self,
-        file_or_directory,
-        use_modified_since,
-        use_content_range,
-        stream_large_files,
-        request,
-        content_type=None,
-        __file_uri__=None,
-    ):
-        # Using this to determine if the URL is trying to break out of the path
-        # served.  os.path.realpath seems to be very slow
-        if __file_uri__ and "../" in __file_uri__:
-            raise InvalidUsage("Invalid URL")
-        # Merge served directory and requested file if provided
-        # Strip all / that in the beginning of the URL to help prevent python
-        # from herping a derp and treating the uri as an absolute path
-        root_path = file_path = file_or_directory
-        if __file_uri__:
-            file_path = path.join(
-                file_or_directory, sub("^[/]*", "", __file_uri__)
-            )
-
-        # URL decode the path sent by the browser otherwise we won't be able to
-        # match filenames which got encoded (filenames with spaces etc)
-        file_path = path.abspath(unquote(file_path))
-        if not file_path.startswith(path.abspath(unquote(root_path))):
-            error_logger.exception(
-                f"File not found: path={file_or_directory}, "
-                f"relative_url={__file_uri__}"
-            )
-            raise FileNotFound(
-                "File not found",
-                path=file_or_directory,
-                relative_url=__file_uri__,
-            )
-        try:
-            headers = {}
-            # Check if the client has been sent this file before
-            # and it has not been modified since
-            stats = None
-            if use_modified_since:
-                stats = await stat_async(file_path)
-                modified_since = strftime(
-                    "%a, %d %b %Y %H:%M:%S GMT", gmtime(stats.st_mtime)
-                )
-                if (
-                    request.headers.getone("if-modified-since", None)
-                    == modified_since
-                ):
-                    return HTTPResponse(status=304)
-                headers["Last-Modified"] = modified_since
-            _range = None
-            if use_content_range:
-                _range = None
-                if not stats:
-                    stats = await stat_async(file_path)
-                headers["Accept-Ranges"] = "bytes"
-                headers["Content-Length"] = str(stats.st_size)
-                if request.method != "HEAD":
-                    try:
-                        _range = ContentRangeHandler(request, stats)
-                    except HeaderNotFound:
-                        pass
-                    else:
-                        del headers["Content-Length"]
-                        for key, value in _range.headers.items():
-                            headers[key] = value
-
-            if "content-type" not in headers:
-                content_type = (
-                    content_type
-                    or guess_type(file_path)[0]
-                    or DEFAULT_HTTP_CONTENT_TYPE
-                )
-
-                if "charset=" not in content_type and (
-                    content_type.startswith("text/")
-                    or content_type == "application/javascript"
-                ):
-                    content_type += "; charset=utf-8"
-
-                headers["Content-Type"] = content_type
-
-            if request.method == "HEAD":
-                return HTTPResponse(headers=headers)
-            else:
-                if stream_large_files:
-                    if type(stream_large_files) == int:
-                        threshold = stream_large_files
-                    else:
-                        threshold = 1024 * 1024
-
-                    if not stats:
-                        stats = await stat_async(file_path)
-                    if stats.st_size >= threshold:
-                        return await file_stream(
-                            file_path, headers=headers, _range=_range
-                        )
-                return await file(file_path, headers=headers, _range=_range)
-        except ContentRangeError:
-            raise
-        except FileNotFoundError:
-            raise FileNotFound(
-                "File not found",
-                path=file_or_directory,
-                relative_url=__file_uri__,
-            )
-        except Exception:
-            error_logger.exception(
-                f"Exception in static request handler: "
-                f"path={file_or_directory}, "
-                f"relative_url={__file_uri__}"
-            )
-            raise
-
-    def _register_static(
-        self,
-        static: FutureStatic,
-    ):
-        # TODO: Though sanic is not a file server, I feel like we should
-        # at least make a good effort here.  Modified-since is nice, but
-        # we could also look into etags, expires, and caching
-        """
-        Register a static directory handler with Sanic by adding a route to the
-        router and registering a handler.
-
-        :param app: Sanic
-        :param file_or_directory: File or directory path to serve from
-        :type file_or_directory: Union[str,bytes,Path]
-        :param uri: URL to serve from
-        :type uri: str
-        :param pattern: regular expression used to match files in the URL
-        :param use_modified_since: If true, send file modified time, and return
-                                not modified if the browser's matches the
-                                server's
-        :param use_content_range: If true, process header for range requests
-                                and sends the file part that is requested
-        :param stream_large_files: If true, use the file_stream() handler
-                                rather than the file() handler to send the file
-                                If this is an integer, this represents the
-                                threshold size to switch to file_stream()
-        :param name: user defined name used for url_for
-        :type name: str
-        :param content_type: user defined content type for header
-        :return: registered static routes
-        :rtype: List[sanic.router.Route]
-        """
-
-        if isinstance(static.file_or_directory, bytes):
-            file_or_directory = static.file_or_directory.decode("utf-8")
-        elif isinstance(static.file_or_directory, PurePath):
-            file_or_directory = str(static.file_or_directory)
-        elif not isinstance(static.file_or_directory, str):
-            raise ValueError("Invalid file path string.")
-        else:
-            file_or_directory = static.file_or_directory
-
-        uri = static.uri
-        name = static.name
-        # If we're not trying to match a file directly,
-        # serve from the folder
-        if not static.resource_type:
-            if not path.isfile(file_or_directory):
-                uri += "/<__file_uri__:path>"
-        elif static.resource_type == "dir":
-            if path.isfile(file_or_directory):
-                raise TypeError(
-                    "Resource type improperly identified as directory. "
-                    f"'{file_or_directory}'"
-                )
-            uri += "/<__file_uri__:path>"
-        elif static.resource_type == "file" and not path.isfile(
-            file_or_directory
-        ):
-            raise TypeError(
-                "Resource type improperly identified as file. "
-                f"'{file_or_directory}'"
-            )
-        elif static.resource_type != "file":
-            raise ValueError(
-                "The resource_type should be set to 'file' or 'dir'"
-            )
-
-        # special prefix for static files
-        # if not static.name.startswith("_static_"):
-        #     name = f"_static_{static.name}"
-
-        _handler = wraps(self._static_request_handler)(
-            partial(
-                self._static_request_handler,
-                file_or_directory,
-                static.use_modified_since,
-                static.use_content_range,
-                static.stream_large_files,
-                content_type=static.content_type,
-            )
-        )
-
-        route, _ = self.route(  # type: ignore
-            uri=uri,
-            methods=["GET", "HEAD"],
-            name=name,
-            host=static.host,
-            strict_slashes=static.strict_slashes,
-            static=True,
-        )(_handler)
-
-        return route
-
     def _determine_error_format(self, handler) -> str:
         with suppress(OSError, TypeError):
             src = dedent(getsource(handler))
@@ -994,17 +691,6 @@ class RouteMixin(metaclass=SanicMeta):
                 nonlocal types
 
                 with suppress(AttributeError):
-                    if node.value.func.id == "stream":  # type: ignore
-                        deprecation(
-                            "The sanic.response.stream method has been "
-                            "deprecated and will be removed in v22.6. Please "
-                            "upgrade your application to use the new style "
-                            "streaming pattern. See "
-                            "https://sanicframework.org/en/guide/advanced/"
-                            "streaming.html#response-streaming for more "
-                            "information.",
-                            22.6,
-                        )
                     checks = [node.value.func.id]  # type: ignore
                     if node.value.keywords:  # type: ignore
                         checks += [
@@ -1021,24 +707,12 @@ class RouteMixin(metaclass=SanicMeta):
 
         return types
 
-    def _build_route_context(self, raw):
+    def _build_route_context(self, raw: Dict[str, Any]) -> HashableDict:
         ctx_kwargs = {
             key.replace("ctx_", ""): raw.pop(key)
             for key in {**raw}.keys()
             if key.startswith("ctx_")
         }
-        restricted = [
-            key for key in ctx_kwargs.keys() if key in RESTRICTED_ROUTE_CONTEXT
-        ]
-        if restricted:
-            restricted_arguments = ", ".join(restricted)
-            raise AttributeError(
-                "Cannot use restricted route context: "
-                f"{restricted_arguments}. This limitation is only in place "
-                "until v22.3 when the restricted names will no longer be in"
-                "conflict. See https://github.com/sanic-org/sanic/issues/2303 "
-                "for more information."
-            )
         if raw:
             unexpected_arguments = ", ".join(raw.keys())
             raise TypeError(

sanic/mixins/signals.py

@@ -20,7 +20,7 @@ class SignalMixin(metaclass=SanicMeta):
         event: Union[str, Enum],
         *,
         apply: bool = True,
-        condition: Dict[str, Any] = None,
+        condition: Optional[Dict[str, Any]] = None,
         exclusive: bool = True,
     ) -> Callable[[SignalHandler], SignalHandler]:
         """
@@ -64,7 +64,7 @@ class SignalMixin(metaclass=SanicMeta):
         self,
         handler: Optional[Callable[..., Any]],
         event: str,
-        condition: Dict[str, Any] = None,
+        condition: Optional[Dict[str, Any]] = None,
         exclusive: bool = True,
     ):
         if not handler:

sanic/mixins/startup.py

@@ -11,47 +11,99 @@ from asyncio import (
     all_tasks,
     get_event_loop,
     get_running_loop,
+    new_event_loop,
 )
 from contextlib import suppress
 from functools import partial
 from importlib import import_module
+from multiprocessing import Manager, Pipe, get_context
+from multiprocessing.context import BaseContext
 from pathlib import Path
-from socket import socket
+from socket import SHUT_RDWR, socket
 from ssl import SSLContext
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Set, Type, Union
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Dict,
+    List,
+    Mapping,
+    Optional,
+    Set,
+    Tuple,
+    Type,
+    Union,
+    cast,
+)
 
-from sanic import reloader_helpers
+from sanic.application.ext import setup_ext
 from sanic.application.logo import get_logo
 from sanic.application.motd import MOTD
 from sanic.application.state import ApplicationServerInfo, Mode, ServerStage
 from sanic.base.meta import SanicMeta
-from sanic.compat import OS_IS_WINDOWS
-from sanic.helpers import _default
-from sanic.log import Colors, error_logger, logger
+from sanic.compat import OS_IS_WINDOWS, StartMethod, is_atty
+from sanic.exceptions import ServerKilled
+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.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.tls import process_to_context
+from sanic.server.socket import configure_socket, remove_unix_socket
+from sanic.worker.loader import AppLoader
+from sanic.worker.manager import WorkerManager
+from sanic.worker.multiplexer import WorkerMultiplexer
+from sanic.worker.reloader import Reloader
+from sanic.worker.serve import worker_serve
 
 
-if TYPE_CHECKING:  # no cov
+if TYPE_CHECKING:
     from sanic import Sanic
     from sanic.application.state import ApplicationState
     from sanic.config import Config
 
 SANIC_PACKAGES = ("sanic-routing", "sanic-testing", "sanic-ext")
 
+if sys.version_info < (3, 8):  # no cov
+    HTTPVersion = Union[HTTP, int]
+else:  # no cov
+    from typing import Literal
 
-class RunnerMixin(metaclass=SanicMeta):
+    HTTPVersion = Union[HTTP, Literal[1], Literal[3]]
+
+
+class StartupMixin(metaclass=SanicMeta):
     _app_registry: Dict[str, Sanic]
     config: Config
     listeners: Dict[str, List[ListenerType[Any]]]
     state: ApplicationState
     websocket_enabled: bool
+    multiplexer: WorkerMultiplexer
+    start_method: StartMethod = _default
+
+    def setup_loop(self):
+        if not self.asgi:
+            if self.config.USE_UVLOOP is True or (
+                isinstance(self.config.USE_UVLOOP, Default)
+                and not OS_IS_WINDOWS
+            ):
+                try_use_uvloop()
+            elif OS_IS_WINDOWS:
+                try_windows_loop()
+
+    @property
+    def m(self) -> WorkerMultiplexer:
+        """Interface for interacting with the worker processes"""
+        return self.multiplexer
 
     def make_coffee(self, *args, **kwargs):
         self.state.coffee = True
@@ -65,6 +117,7 @@ class RunnerMixin(metaclass=SanicMeta):
         dev: bool = False,
         debug: bool = False,
         auto_reload: Optional[bool] = None,
+        version: HTTPVersion = HTTP.VERSION_1,
         ssl: Union[None, SSLContext, dict, str, list, tuple] = None,
         sock: Optional[socket] = None,
         workers: int = 1,
@@ -73,13 +126,16 @@ class RunnerMixin(metaclass=SanicMeta):
         register_sys_signals: bool = True,
         access_log: Optional[bool] = None,
         unix: Optional[str] = None,
-        loop: AbstractEventLoop = None,
+        loop: Optional[AbstractEventLoop] = None,
         reload_dir: Optional[Union[List[str], str]] = None,
         noisy_exceptions: Optional[bool] = None,
         motd: bool = True,
         fast: bool = False,
         verbosity: int = 0,
         motd_display: Optional[Dict[str, str]] = None,
+        auto_tls: bool = False,
+        single_process: bool = False,
+        legacy: bool = False,
     ) -> None:
         """
         Run the HTTP Server and listen until keyboard interrupt or term
@@ -123,6 +179,7 @@ class RunnerMixin(metaclass=SanicMeta):
             dev=dev,
             debug=debug,
             auto_reload=auto_reload,
+            version=version,
             ssl=ssl,
             sock=sock,
             workers=workers,
@@ -138,9 +195,18 @@ class RunnerMixin(metaclass=SanicMeta):
             fast=fast,
             verbosity=verbosity,
             motd_display=motd_display,
+            auto_tls=auto_tls,
+            single_process=single_process,
+            legacy=legacy,
         )
 
-        self.__class__.serve(primary=self)  # type: ignore
+        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
 
     def prepare(
         self,
@@ -150,6 +216,7 @@ class RunnerMixin(metaclass=SanicMeta):
         dev: bool = False,
         debug: bool = False,
         auto_reload: Optional[bool] = None,
+        version: HTTPVersion = HTTP.VERSION_1,
         ssl: Union[None, SSLContext, dict, str, list, tuple] = None,
         sock: Optional[socket] = None,
         workers: int = 1,
@@ -158,18 +225,32 @@ class RunnerMixin(metaclass=SanicMeta):
         register_sys_signals: bool = True,
         access_log: Optional[bool] = None,
         unix: Optional[str] = None,
-        loop: AbstractEventLoop = None,
+        loop: Optional[AbstractEventLoop] = None,
         reload_dir: Optional[Union[List[str], str]] = None,
         noisy_exceptions: Optional[bool] = None,
         motd: bool = True,
         fast: bool = False,
         verbosity: int = 0,
         motd_display: Optional[Dict[str, str]] = None,
+        coffee: bool = False,
+        auto_tls: bool = False,
+        single_process: bool = False,
+        legacy: bool = False,
     ) -> None:
+        if version == 3 and self.state.server_info:
+            raise RuntimeError(
+                "Serving HTTP/3 instances as a secondary server is "
+                "not supported. There can only be a single HTTP/3 worker "
+                "and it must be the first instance prepared."
+            )
+
         if dev:
             debug = True
             auto_reload = True
 
+        if debug and access_log is None:
+            access_log = True
+
         self.state.verbosity = verbosity
         if not self.state.auto_reload:
             self.state.auto_reload = bool(auto_reload)
@@ -177,6 +258,21 @@ class RunnerMixin(metaclass=SanicMeta):
         if fast and workers != 1:
             raise RuntimeError("You cannot use both fast=True and workers=X")
 
+        if single_process and (fast or (workers > 1) or auto_reload):
+            raise RuntimeError(
+                "Single process cannot be run with multiple workers "
+                "or auto-reload"
+            )
+
+        if single_process and legacy:
+            raise RuntimeError("Cannot run single process and legacy mode")
+
+        if register_sys_signals is False and not (single_process or legacy):
+            raise RuntimeError(
+                "Cannot run Sanic.serve with register_sys_signals=False. "
+                "Use either Sanic.serve_single or Sanic.serve_legacy."
+            )
+
         if motd_display:
             self.config.MOTD_DISPLAY.update(motd_display)
 
@@ -200,14 +296,8 @@ class RunnerMixin(metaclass=SanicMeta):
                 "#asynchronous-support"
             )
 
-        if (
-            self.__class__.should_auto_reload()
-            and os.environ.get("SANIC_SERVER_RUNNING") != "true"
-        ):  # no cov
-            return
-
         if sock is None:
-            host, port = host or "127.0.0.1", port or 8000
+            host, port = self.get_address(host, port, version, auto_tls)
 
         if protocol is None:
             protocol = (
@@ -231,10 +321,14 @@ class RunnerMixin(metaclass=SanicMeta):
             except AttributeError:  # no cov
                 workers = os.cpu_count() or 1
 
+        if coffee:
+            self.state.coffee = True
+
         server_settings = self._helper(
             host=host,
             port=port,
             debug=debug,
+            version=version,
             ssl=ssl,
             sock=sock,
             unix=unix,
@@ -242,15 +336,16 @@ class RunnerMixin(metaclass=SanicMeta):
             protocol=protocol,
             backlog=backlog,
             register_sys_signals=register_sys_signals,
+            auto_tls=auto_tls,
         )
         self.state.server_info.append(
             ApplicationServerInfo(settings=server_settings)
         )
 
-        if self.config.USE_UVLOOP is True or (
-            self.config.USE_UVLOOP is _default and not OS_IS_WINDOWS
-        ):
-            try_use_uvloop()
+        # if self.config.USE_UVLOOP is True or (
+        #     self.config.USE_UVLOOP is _default and not OS_IS_WINDOWS
+        # ):
+        #     try_use_uvloop()
 
     async def create_server(
         self,
@@ -260,12 +355,12 @@ class RunnerMixin(metaclass=SanicMeta):
         debug: bool = False,
         ssl: Union[None, SSLContext, dict, str, list, tuple] = None,
         sock: Optional[socket] = None,
-        protocol: Type[Protocol] = None,
+        protocol: Optional[Type[Protocol]] = None,
         backlog: int = 100,
         access_log: Optional[bool] = None,
         unix: Optional[str] = None,
         return_asyncio_server: bool = False,
-        asyncio_server_kwargs: Dict[str, Any] = None,
+        asyncio_server_kwargs: Optional[Dict[str, Any]] = None,
         noisy_exceptions: Optional[bool] = None,
     ) -> Optional[AsyncioServer]:
         """
@@ -311,7 +406,7 @@ class RunnerMixin(metaclass=SanicMeta):
         """
 
         if sock is None:
-            host, port = host or "127.0.0.1", port or 8000
+            host, port = host, port = self.get_address(host, port)
 
         if protocol is None:
             protocol = (
@@ -339,7 +434,7 @@ class RunnerMixin(metaclass=SanicMeta):
             run_async=return_asyncio_server,
         )
 
-        if self.config.USE_UVLOOP is not _default:
+        if not isinstance(self.config.USE_UVLOOP, Default):
             error_logger.warning(
                 "You are trying to change the uvloop configuration, but "
                 "this is only effective when using the run(...) method. "
@@ -359,32 +454,39 @@ class RunnerMixin(metaclass=SanicMeta):
             asyncio_server_kwargs=asyncio_server_kwargs, **server_settings
         )
 
-    def stop(self):
+    def stop(self, terminate: bool = True, unregister: bool = False):
         """
         This kills the Sanic
         """
+        if terminate and hasattr(self, "multiplexer"):
+            self.multiplexer.terminate()
         if self.state.stage is not ServerStage.STOPPED:
-            self.shutdown_tasks(timeout=0)
+            self.shutdown_tasks(timeout=0)  # type: ignore
             for task in all_tasks():
                 with suppress(AttributeError):
                     if task.get_name() == "RunServer":
                         task.cancel()
             get_event_loop().stop()
 
+        if unregister:
+            self.__class__.unregister_app(self)  # type: ignore
+
     def _helper(
         self,
         host: Optional[str] = None,
         port: Optional[int] = None,
         debug: bool = False,
+        version: HTTPVersion = HTTP.VERSION_1,
         ssl: Union[None, SSLContext, dict, str, list, tuple] = None,
         sock: Optional[socket] = None,
         unix: Optional[str] = None,
         workers: int = 1,
-        loop: AbstractEventLoop = None,
+        loop: Optional[AbstractEventLoop] = None,
         protocol: Type[Protocol] = HttpProtocol,
         backlog: int = 100,
         register_sys_signals: bool = True,
         run_async: bool = False,
+        auto_tls: bool = False,
     ) -> Dict[str, Any]:
         """Helper function used by `run` and `create_server`."""
         if self.config.PROXIES_COUNT and self.config.PROXIES_COUNT < 0:
@@ -394,11 +496,18 @@ class RunnerMixin(metaclass=SanicMeta):
                 "#proxy-configuration"
             )
 
-        ssl = process_to_context(ssl)
-
         if not self.state.is_debug:
             self.state.mode = Mode.DEBUG if debug else Mode.PRODUCTION
 
+        if isinstance(version, int):
+            version = HTTP(version)
+
+        ssl = process_to_context(ssl)
+        if version is HTTP.VERSION_3 or auto_tls:
+            if TYPE_CHECKING:
+                self = cast(Sanic, self)
+            ssl = get_ssl_context(self, ssl)
+
         self.state.host = host or ""
         self.state.port = port or 0
         self.state.workers = workers
@@ -410,6 +519,7 @@ class RunnerMixin(metaclass=SanicMeta):
             "protocol": protocol,
             "host": host,
             "port": port,
+            "version": version,
             "sock": sock,
             "unix": unix,
             "ssl": ssl,
@@ -420,9 +530,13 @@ class RunnerMixin(metaclass=SanicMeta):
             "backlog": backlog,
         }
 
-        self.motd(self.serve_location)
+        self.motd(server_settings=server_settings)
 
-        if sys.stdout.isatty() and not self.state.is_debug:
+        if (
+            is_atty()
+            and not self.state.is_debug
+            and not os.environ.get("SANIC_IGNORE_PRODUCTION_WARNING")
+        ):
             error_logger.warning(
                 f"{Colors.YELLOW}Sanic is running in PRODUCTION mode. "
                 "Consider using '--debug' or '--dev' while actively "
@@ -446,90 +560,339 @@ class RunnerMixin(metaclass=SanicMeta):
 
         return server_settings
 
-    def motd(self, serve_location):
+    def motd(
+        self,
+        server_settings: Optional[Dict[str, Any]] = None,
+    ):
+        if (
+            os.environ.get("SANIC_WORKER_NAME")
+            or os.environ.get("SANIC_MOTD_OUTPUT")
+            or os.environ.get("SANIC_WORKER_PROCESS")
+            or os.environ.get("SANIC_SERVER_RUNNING")
+        ):
+            return
+        serve_location = self.get_server_location(server_settings)
         if self.config.MOTD:
-            mode = [f"{self.state.mode},"]
-            if self.state.fast:
-                mode.append("goin' fast")
-            if self.state.asgi:
-                mode.append("ASGI")
-            else:
-                if self.state.workers == 1:
-                    mode.append("single worker")
-                else:
-                    mode.append(f"w/ {self.state.workers} workers")
-
-            display = {
-                "mode": " ".join(mode),
-                "server": self.state.server,
-                "python": platform.python_version(),
-                "platform": platform.platform(),
-            }
-            extra = {}
-            if self.config.AUTO_RELOAD:
-                reload_display = "enabled"
-                if self.state.reload_dirs:
-                    reload_display += ", ".join(
-                        [
-                            "",
-                            *(
-                                str(path.absolute())
-                                for path in self.state.reload_dirs
-                            ),
-                        ]
-                    )
-                display["auto-reload"] = reload_display
-
-            packages = []
-            for package_name in SANIC_PACKAGES:
-                module_name = package_name.replace("-", "_")
-                try:
-                    module = import_module(module_name)
-                    packages.append(f"{package_name}=={module.__version__}")
-                except ImportError:
-                    ...
-
-            if packages:
-                display["packages"] = ", ".join(packages)
-
-            if self.config.MOTD_DISPLAY:
-                extra.update(self.config.MOTD_DISPLAY)
-
-            logo = (
-                get_logo(coffee=self.state.coffee)
-                if self.config.LOGO == "" or self.config.LOGO is True
-                else self.config.LOGO
-            )
+            logo = get_logo(coffee=self.state.coffee)
+            display, extra = self.get_motd_data(server_settings)
 
             MOTD.output(logo, serve_location, display, extra)
 
+    def get_motd_data(
+        self, server_settings: Optional[Dict[str, Any]] = None
+    ) -> Tuple[Dict[str, Any], Dict[str, Any]]:
+        mode = [f"{self.state.mode},"]
+        if self.state.fast:
+            mode.append("goin' fast")
+        if self.state.asgi:
+            mode.append("ASGI")
+        else:
+            if self.state.workers == 1:
+                mode.append("single worker")
+            else:
+                mode.append(f"w/ {self.state.workers} workers")
+
+        if server_settings:
+            server = ", ".join(
+                (
+                    self.state.server,
+                    server_settings["version"].display(),  # type: ignore
+                )
+            )
+        else:
+            server = "ASGI" if self.asgi else "unknown"  # type: ignore
+
+        display = {
+            "mode": " ".join(mode),
+            "server": server,
+            "python": platform.python_version(),
+            "platform": platform.platform(),
+        }
+        extra = {}
+        if self.config.AUTO_RELOAD:
+            reload_display = "enabled"
+            if self.state.reload_dirs:
+                reload_display += ", ".join(
+                    [
+                        "",
+                        *(
+                            str(path.absolute())
+                            for path in self.state.reload_dirs
+                        ),
+                    ]
+                )
+            display["auto-reload"] = reload_display
+
+        packages = []
+        for package_name in SANIC_PACKAGES:
+            module_name = package_name.replace("-", "_")
+            try:
+                module = import_module(module_name)
+                packages.append(
+                    f"{package_name}=={module.__version__}"  # type: ignore
+                )
+            except ImportError:  # no cov
+                ...
+
+        if packages:
+            display["packages"] = ", ".join(packages)
+
+        if self.config.MOTD_DISPLAY:
+            extra.update(self.config.MOTD_DISPLAY)
+
+        return display, extra
+
     @property
     def serve_location(self) -> str:
+        try:
+            server_settings = self.state.server_info[0].settings
+            return self.get_server_location(server_settings)
+        except IndexError:
+            location = "ASGI" if self.asgi else "unknown"  # type: ignore
+            return f"http://<{location}>"
+
+    @staticmethod
+    def get_server_location(
+        server_settings: Optional[Dict[str, Any]] = None
+    ) -> str:
         serve_location = ""
         proto = "http"
-        if self.state.ssl is not None:
+        if not server_settings:
+            return serve_location
+
+        host = server_settings["host"]
+        port = server_settings["port"]
+
+        if server_settings.get("ssl") is not None:
             proto = "https"
-        if self.state.unix:
-            serve_location = f"{self.state.unix} {proto}://..."
-        elif self.state.sock:
-            serve_location = f"{self.state.sock.getsockname()} {proto}://..."
-        elif self.state.host and self.state.port:
+        if server_settings.get("unix"):
+            serve_location = f'{server_settings["unix"]} {proto}://...'
+        elif server_settings.get("sock"):
+            host, port, *_ = server_settings["sock"].getsockname()
+
+        if not serve_location and host and port:
             # colon(:) is legal for a host only in an ipv6 address
-            display_host = (
-                f"[{self.state.host}]"
-                if ":" in self.state.host
-                else self.state.host
-            )
-            serve_location = f"{proto}://{display_host}:{self.state.port}"
+            display_host = f"[{host}]" if ":" in host else host
+            serve_location = f"{proto}://{display_host}:{port}"
 
         return serve_location
 
+    @staticmethod
+    def get_address(
+        host: Optional[str],
+        port: Optional[int],
+        version: HTTPVersion = HTTP.VERSION_1,
+        auto_tls: bool = False,
+    ) -> Tuple[str, int]:
+        host = host or "127.0.0.1"
+        port = port or (8443 if (version == 3 or auto_tls) else 8000)
+        return host, port
+
     @classmethod
     def should_auto_reload(cls) -> bool:
         return any(app.state.auto_reload for app in cls._app_registry.values())
 
     @classmethod
-    def serve(cls, primary: Optional[Sanic] = None) -> None:
+    def _get_startup_method(cls) -> str:
+        return (
+            cls.start_method
+            if not isinstance(cls.start_method, Default)
+            else "spawn"
+        )
+
+    @classmethod
+    def _get_context(cls) -> BaseContext:
+        method = cls._get_startup_method()
+        logger.debug("Creating multiprocessing context using '%s'", method)
+        return get_context(method)
+
+    @classmethod
+    def serve(
+        cls,
+        primary: Optional[Sanic] = None,
+        *,
+        app_loader: Optional[AppLoader] = None,
+        factory: Optional[Callable[[], Sanic]] = None,
+    ) -> None:
+        os.environ["SANIC_MOTD_OUTPUT"] = "true"
+        apps = list(cls._app_registry.values())
+        if factory:
+            primary = factory()
+        else:
+            if not primary:
+                if app_loader:
+                    primary = app_loader.load()
+                if not primary:
+                    try:
+                        primary = apps[0]
+                    except IndexError:
+                        raise RuntimeError(
+                            "Did not find any applications."
+                        ) from None
+
+            # This exists primarily for unit testing
+            if not primary.state.server_info:  # no cov
+                for app in apps:
+                    app.state.server_info.clear()
+                return
+
+        try:
+            primary_server_info = primary.state.server_info[0]
+        except IndexError:
+            raise RuntimeError(
+                f"No server information found for {primary.name}. Perhaps you "
+                "need to run app.prepare(...)?"
+            ) from None
+
+        socks = []
+        sync_manager = Manager()
+        setup_ext(primary)
+        exit_code = 0
+        try:
+            primary_server_info.settings.pop("main_start", None)
+            primary_server_info.settings.pop("main_stop", None)
+            main_start = primary.listeners.get("main_process_start")
+            main_stop = primary.listeners.get("main_process_stop")
+            app = primary_server_info.settings.pop("app")
+            app.setup_loop()
+            loop = new_event_loop()
+            trigger_events(main_start, loop, primary)
+
+            socks = [
+                sock
+                for sock in [
+                    configure_socket(server_info.settings)
+                    for app in apps
+                    for server_info in app.state.server_info
+                ]
+                if sock
+            ]
+            primary_server_info.settings["run_multiple"] = True
+            monitor_sub, monitor_pub = Pipe(True)
+            worker_state: Mapping[str, Any] = sync_manager.dict()
+            kwargs: Dict[str, Any] = {
+                **primary_server_info.settings,
+                "monitor_publisher": monitor_pub,
+                "worker_state": worker_state,
+            }
+
+            if not app_loader:
+                if factory:
+                    app_loader = AppLoader(factory=factory)
+                else:
+                    app_loader = AppLoader(
+                        factory=partial(cls.get_app, app.name)  # type: ignore
+                    )
+            kwargs["app_name"] = app.name
+            kwargs["app_loader"] = app_loader
+            kwargs["server_info"] = {}
+            kwargs["passthru"] = {
+                "auto_reload": app.auto_reload,
+                "state": {
+                    "verbosity": app.state.verbosity,
+                    "mode": app.state.mode,
+                },
+                "config": {
+                    "ACCESS_LOG": app.config.ACCESS_LOG,
+                    "NOISY_EXCEPTIONS": app.config.NOISY_EXCEPTIONS,
+                },
+                "shared_ctx": app.shared_ctx.__dict__,
+            }
+            for app in apps:
+                kwargs["server_info"][app.name] = []
+                for server_info in app.state.server_info:
+                    server_info.settings = {
+                        k: v
+                        for k, v in server_info.settings.items()
+                        if k not in ("main_start", "main_stop", "app", "ssl")
+                    }
+                    kwargs["server_info"][app.name].append(server_info)
+
+            ssl = kwargs.get("ssl")
+
+            if isinstance(ssl, SanicSSLContext):
+                kwargs["ssl"] = kwargs["ssl"].sanic
+
+            manager = WorkerManager(
+                primary.state.workers,
+                worker_serve,
+                kwargs,
+                cls._get_context(),
+                (monitor_pub, monitor_sub),
+                worker_state,
+            )
+            if cls.should_auto_reload():
+                reload_dirs: Set[Path] = primary.state.reload_dirs.union(
+                    *(app.state.reload_dirs for app in apps)
+                )
+                reloader = Reloader(monitor_pub, 0, reload_dirs, app_loader)
+                manager.manage("Reloader", reloader, {}, transient=False)
+
+            inspector = None
+            if primary.config.INSPECTOR:
+                display, extra = primary.get_motd_data()
+                packages = [
+                    pkg.strip() for pkg in display["packages"].split(",")
+                ]
+                module = import_module("sanic")
+                sanic_version = f"sanic=={module.__version__}"  # type: ignore
+                app_info = {
+                    **display,
+                    "packages": [sanic_version, *packages],
+                    "extra": extra,
+                }
+                inspector = primary.inspector_class(
+                    monitor_pub,
+                    app_info,
+                    worker_state,
+                    primary.config.INSPECTOR_HOST,
+                    primary.config.INSPECTOR_PORT,
+                    primary.config.INSPECTOR_API_KEY,
+                    primary.config.INSPECTOR_TLS_KEY,
+                    primary.config.INSPECTOR_TLS_CERT,
+                )
+                manager.manage("Inspector", inspector, {}, transient=False)
+
+            primary._inspector = inspector
+            primary._manager = manager
+
+            ready = primary.listeners["main_process_ready"]
+            trigger_events(ready, loop, primary)
+
+            manager.run()
+        except ServerKilled:
+            exit_code = 1
+        except BaseException:
+            kwargs = primary_server_info.settings
+            error_logger.exception(
+                "Experienced exception while trying to serve"
+            )
+            raise
+        finally:
+            logger.info("Server Stopped")
+            for app in apps:
+                app.state.server_info.clear()
+                app.router.reset()
+                app.signal_router.reset()
+
+            sync_manager.shutdown()
+            for sock in socks:
+                sock.shutdown(SHUT_RDWR)
+                sock.close()
+            socks = []
+            trigger_events(main_stop, loop, primary)
+            loop.close()
+            cls._cleanup_env_vars()
+            cls._cleanup_apps()
+            unix = kwargs.get("unix")
+            if unix:
+                remove_unix_socket(unix)
+        if exit_code:
+            os._exit(exit_code)
+
+    @classmethod
+    def serve_single(cls, primary: Optional[Sanic] = None) -> None:
+        os.environ["SANIC_MOTD_OUTPUT"] = "true"
         apps = list(cls._app_registry.values())
 
         if not primary:
@@ -538,15 +901,83 @@ class RunnerMixin(metaclass=SanicMeta):
             except IndexError:
                 raise RuntimeError("Did not find any applications.")
 
+        # This exists primarily for unit testing
+        if not primary.state.server_info:  # no cov
+            for app in apps:
+                app.state.server_info.clear()
+            return
+
+        primary_server_info = primary.state.server_info[0]
+        primary.before_server_start(partial(primary._start_servers, apps=apps))
+        kwargs = {
+            k: v
+            for k, v in primary_server_info.settings.items()
+            if k
+            not in (
+                "main_start",
+                "main_stop",
+                "app",
+            )
+        }
+        kwargs["app_name"] = primary.name
+        kwargs["app_loader"] = None
+        sock = configure_socket(kwargs)
+
+        kwargs["server_info"] = {}
+        kwargs["server_info"][primary.name] = []
+        for server_info in primary.state.server_info:
+            server_info.settings = {
+                k: v
+                for k, v in server_info.settings.items()
+                if k not in ("main_start", "main_stop", "app")
+            }
+            kwargs["server_info"][primary.name].append(server_info)
+
+        try:
+            worker_serve(monitor_publisher=None, **kwargs)
+        except BaseException:
+            error_logger.exception(
+                "Experienced exception while trying to serve"
+            )
+            raise
+        finally:
+            logger.info("Server Stopped")
+            for app in apps:
+                app.state.server_info.clear()
+                app.router.reset()
+                app.signal_router.reset()
+
+            if sock:
+                sock.close()
+
+            cls._cleanup_env_vars()
+            cls._cleanup_apps()
+
+    @classmethod
+    def serve_legacy(cls, primary: Optional[Sanic] = None) -> None:
+        apps = list(cls._app_registry.values())
+
+        if not primary:
+            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)
             )
-            return reloader_helpers.watchdog(1.0, reload_dirs)
+            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
@@ -557,11 +988,17 @@ class RunnerMixin(metaclass=SanicMeta):
         primary_server_info = primary.state.server_info[0]
         primary.before_server_start(partial(primary._start_servers, apps=apps))
 
+        deprecation(
+            f"{Colors.YELLOW}Running {Colors.SANIC}Sanic {Colors.YELLOW}w/ "
+            f"LEGACY manager.{Colors.END} Support for will be dropped in "
+            "version 23.3.",
+            23.3,
+        )
         try:
             primary_server_info.stage = ServerStage.SERVING
 
             if primary.state.workers > 1 and os.name != "posix":  # no cov
-                logger.warn(
+                logger.warning(
                     f"Multiprocessing is currently not supported on {os.name},"
                     " using workers=1 instead"
                 )
@@ -582,10 +1019,9 @@ class RunnerMixin(metaclass=SanicMeta):
         finally:
             primary_server_info.stage = ServerStage.STOPPED
         logger.info("Server Stopped")
-        for app in apps:
-            app.state.server_info.clear()
-            app.router.reset()
-            app.signal_router.reset()
+
+        cls._cleanup_env_vars()
+        cls._cleanup_apps()
 
     async def _start_servers(
         self,
@@ -607,7 +1043,7 @@ class RunnerMixin(metaclass=SanicMeta):
                     f"{app.state.workers} worker(s), which will be ignored "
                     "in favor of the primary application."
                 )
-                if sys.stdout.isatty():
+                if is_atty():
                     message = "".join(
                         [
                             Colors.YELLOW,
@@ -623,7 +1059,7 @@ class RunnerMixin(metaclass=SanicMeta):
                         *server_info.settings.pop("main_start", []),
                         *server_info.settings.pop("main_stop", []),
                     ]
-                    if handlers:
+                    if handlers:  # no cov
                         error_logger.warning(
                             f"Sanic found {len(handlers)} listener(s) on "
                             "secondary applications attached to the main "
@@ -636,19 +1072,22 @@ class RunnerMixin(metaclass=SanicMeta):
                     if not server_info.settings["loop"]:
                         server_info.settings["loop"] = get_running_loop()
 
+                    serve_args: Dict[str, Any] = {
+                        **server_info.settings,
+                        "run_async": True,
+                        "reuse_port": bool(primary.state.workers - 1),
+                    }
+                    if "app" not in serve_args:
+                        serve_args["app"] = app
                     try:
-                        server_info.server = await serve(
-                            **server_info.settings,
-                            run_async=True,
-                            reuse_port=bool(primary.state.workers - 1),
-                        )
+                        server_info.server = await serve(**serve_args)
                     except OSError as e:  # no cov
                         first_message = (
                             "An OSError was detected on startup. "
                             "The encountered error was: "
                         )
                         second_message = str(e)
-                        if sys.stdout.isatty():
+                        if is_atty():
                             message_parts = [
                                 Colors.YELLOW,
                                 first_message,
@@ -667,10 +1106,9 @@ class RunnerMixin(metaclass=SanicMeta):
 
     async def _run_server(
         self,
-        app: RunnerMixin,
+        app: StartupMixin,
         server_info: ApplicationServerInfo,
-    ) -> None:
-
+    ) -> None:  # no cov
         try:
             # We should never get to this point without a server
             # This is primarily to keep mypy happy
@@ -693,3 +1131,26 @@ class RunnerMixin(metaclass=SanicMeta):
         finally:
             server_info.stage = ServerStage.STOPPED
             server_info.server = None
+
+    @staticmethod
+    def _cleanup_env_vars():
+        variables = (
+            "SANIC_RELOADER_PROCESS",
+            "SANIC_IGNORE_PRODUCTION_WARNING",
+            "SANIC_WORKER_NAME",
+            "SANIC_MOTD_OUTPUT",
+            "SANIC_WORKER_PROCESS",
+            "SANIC_SERVER_RUNNING",
+        )
+        for var in variables:
+            try:
+                del os.environ[var]
+            except KeyError:
+                ...
+
+    @classmethod
+    def _cleanup_apps(cls):
+        for app in cls._app_registry.values():
+            app.state.server_info.clear()
+            app.router.reset()
+            app.signal_router.reset()

sanic/mixins/static.py

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

sanic/models/asgi.py

@@ -3,7 +3,8 @@ import sys
 
 from typing import Any, Awaitable, Callable, MutableMapping, Optional, Union
 
-from sanic.exceptions import InvalidUsage
+from sanic.exceptions import BadRequest
+from sanic.models.protocol_types import TransportProtocol
 from sanic.server.websockets.connection import WebSocketConnection
 
 
@@ -56,7 +57,7 @@ class MockProtocol:  # no cov
         await self._not_paused.wait()
 
 
-class MockTransport:  # no cov
+class MockTransport(TransportProtocol):  # no cov
     _protocol: Optional[MockProtocol]
 
     def __init__(
@@ -68,23 +69,25 @@ class MockTransport:  # no cov
         self._protocol = None
         self.loop = None
 
-    def get_protocol(self) -> MockProtocol:
+    def get_protocol(self) -> MockProtocol:  # type: ignore
         if not self._protocol:
             self._protocol = MockProtocol(self, self.loop)
         return self._protocol
 
-    def get_extra_info(self, info: str) -> Union[str, bool, None]:
+    def get_extra_info(
+        self, info: str, default=None
+    ) -> Optional[Union[str, bool]]:
         if info == "peername":
             return self.scope.get("client")
         elif info == "sslcontext":
             return self.scope.get("scheme") in ["https", "wss"]
-        return None
+        return default
 
     def get_websocket_connection(self) -> WebSocketConnection:
         try:
             return self._websocket_connection
         except AttributeError:
-            raise InvalidUsage("Improper websocket connection.")
+            raise BadRequest("Improper websocket connection.")
 
     def create_websocket_connection(
         self, send: ASGISend, receive: ASGIReceive

sanic/models/futures.py

@@ -1,6 +1,7 @@
-from pathlib import PurePath
+from pathlib import Path
 from typing import Dict, Iterable, List, NamedTuple, Optional, Union
 
+from sanic.handlers.directory import DirectoryHandler
 from sanic.models.handler_types import (
     ErrorMiddlewareType,
     ListenerType,
@@ -46,16 +47,17 @@ class FutureException(NamedTuple):
 
 class FutureStatic(NamedTuple):
     uri: str
-    file_or_directory: Union[str, bytes, PurePath]
+    file_or_directory: Path
     pattern: str
     use_modified_since: bool
     use_content_range: bool
-    stream_large_files: bool
+    stream_large_files: Union[bool, int]
     name: str
     host: Optional[str]
     strict_slashes: Optional[bool]
-    content_type: Optional[bool]
+    content_type: Optional[str]
     resource_type: Optional[str]
+    directory_handler: DirectoryHandler
 
 
 class FutureSignal(NamedTuple):

sanic/models/handler_types.py

@@ -1,11 +1,13 @@
 from asyncio.events import AbstractEventLoop
 from typing import Any, Callable, Coroutine, Optional, TypeVar, Union
 
+import sanic
+
 from sanic.request import Request
 from sanic.response import BaseHTTPResponse, HTTPResponse
 
 
-Sanic = TypeVar("Sanic")
+Sanic = TypeVar("Sanic", bound="sanic.Sanic")
 
 MiddlewareResponse = Union[
     Optional[HTTPResponse], Coroutine[Any, Any, Optional[HTTPResponse]]
@@ -18,8 +20,9 @@ ErrorMiddlewareType = Callable[
     [Request, BaseException], Optional[Coroutine[Any, Any, None]]
 ]
 MiddlewareType = Union[RequestMiddlewareType, ResponseMiddlewareType]
-ListenerType = Callable[
-    [Sanic, AbstractEventLoop], Optional[Coroutine[Any, Any, None]]
+ListenerType = Union[
+    Callable[[Sanic], Optional[Coroutine[Any, Any, None]]],
+    Callable[[Sanic, AbstractEventLoop], Optional[Coroutine[Any, Any, None]]],
 ]
 RouteHandler = Callable[..., Coroutine[Any, Any, Optional[HTTPResponse]]]
 SignalHandler = Callable[..., Coroutine[Any, Any, None]]

sanic/models/protocol_types.py

@@ -1,28 +1,22 @@
+from __future__ import annotations
+
 import sys
 
-from typing import Any, AnyStr, TypeVar, Union
+from asyncio import BaseTransport
+from typing import TYPE_CHECKING, Any, AnyStr
+
+
+if TYPE_CHECKING:
+    from sanic.models.asgi import ASGIScope
 
 
 if sys.version_info < (3, 8):
-    from asyncio import BaseTransport
-
-    # from sanic.models.asgi import MockTransport
-    MockTransport = TypeVar("MockTransport")
-
-    TransportProtocol = Union[MockTransport, BaseTransport]
     Range = Any
     HTMLProtocol = Any
 else:
     # Protocol is a 3.8+ feature
     from typing import Protocol
 
-    class TransportProtocol(Protocol):
-        def get_protocol(self):
-            ...
-
-        def get_extra_info(self, info: str) -> Union[str, bool, None]:
-            ...
-
     class HTMLProtocol(Protocol):
         def __html__(self) -> AnyStr:
             ...
@@ -42,3 +36,8 @@ else:
 
         def total(self) -> int:
             ...
+
+
+class TransportProtocol(BaseTransport):
+    scope: ASGIScope
+    __slots__ = ()

sanic/models/server_types.py

@@ -1,8 +1,8 @@
 from __future__ import annotations
 
-from ssl import SSLObject
+from ssl import SSLContext, SSLObject
 from types import SimpleNamespace
-from typing import Any, Dict, Optional
+from typing import Any, Dict, List, Optional
 
 from sanic.models.protocol_types import TransportProtocol
 
@@ -21,6 +21,7 @@ class ConnInfo:
         "client",
         "client_ip",
         "ctx",
+        "lost",
         "peername",
         "server_port",
         "server",
@@ -28,10 +29,12 @@ class ConnInfo:
         "sockname",
         "ssl",
         "cert",
+        "network_paths",
     )
 
     def __init__(self, transport: TransportProtocol, unix=None):
         self.ctx = SimpleNamespace()
+        self.lost = False
         self.peername = None
         self.server = self.client = ""
         self.server_port = self.client_port = 0
@@ -40,17 +43,22 @@ class ConnInfo:
         self.ssl = False
         self.server_name = ""
         self.cert: Dict[str, Any] = {}
+        self.network_paths: List[Any] = []
         sslobj: Optional[SSLObject] = transport.get_extra_info(
             "ssl_object"
         )  # type: ignore
+        sslctx: Optional[SSLContext] = transport.get_extra_info(
+            "ssl_context"
+        )  # type: ignore
         if sslobj:
             self.ssl = True
             self.server_name = getattr(sslobj, "sanic_server_name", None) or ""
             self.cert = dict(getattr(sslobj.context, "sanic", {}))
+        if sslctx and not self.cert:
+            self.cert = dict(getattr(sslctx, "sanic", {}))
         if isinstance(addr, str):  # UNIX socket
             self.server = unix or addr
             return
-
         # IPv4 (ip, port) or IPv6 (ip, port, flowinfo, scopeid)
         if isinstance(addr, tuple):
             self.server = addr[0] if len(addr) == 2 else f"[{addr[0]}]"
@@ -59,6 +67,9 @@ class ConnInfo:
             if addr[1] != (443 if self.ssl else 80):
                 self.server = f"{self.server}:{addr[1]}"
         self.peername = addr = transport.get_extra_info("peername")
+        self.network_paths = transport.get_extra_info(  # type: ignore
+            "network_paths"
+        )
 
         if isinstance(addr, tuple):
             self.client = addr[0] if len(addr) == 2 else f"[{addr[0]}]"

sanic/pages/base.py

@@ -0,0 +1,51 @@
+from abc import ABC, abstractmethod
+
+from html5tagger import HTML, Document
+
+from sanic import __version__ as VERSION
+from sanic.application.logo import SVG_LOGO
+from sanic.pages.css import CSS
+
+
+class BasePage(ABC, metaclass=CSS):  # no cov
+    TITLE = "Unknown"
+    CSS: str
+
+    def __init__(self, debug: bool = True) -> None:
+        self.doc = Document(self.TITLE, lang="en")
+        self.debug = debug
+
+    @property
+    def style(self) -> str:
+        return self.CSS
+
+    def render(self) -> str:
+        self._head()
+        self._body()
+        self._foot()
+        return str(self.doc)
+
+    def _head(self) -> None:
+        self.doc.style(HTML(self.style))
+        with self.doc.header:
+            self.doc.div(self.TITLE)
+
+    def _foot(self) -> None:
+        with self.doc.footer:
+            self.doc.div("powered by")
+            with self.doc.div:
+                self._sanic_logo()
+            if self.debug:
+                self.doc.div(f"Version {VERSION}")
+
+    @abstractmethod
+    def _body(self) -> None:
+        ...
+
+    def _sanic_logo(self) -> None:
+        self.doc.a(
+            HTML(SVG_LOGO),
+            href="https://sanic.dev",
+            target="_blank",
+            referrerpolicy="no-referrer",
+        )

sanic/pages/css.py

@@ -0,0 +1,35 @@
+from abc import ABCMeta
+from pathlib import Path
+from typing import Optional
+
+
+CURRENT_DIR = Path(__file__).parent
+
+
+def _extract_style(maybe_style: Optional[str], name: str) -> str:
+    if maybe_style is not None:
+        maybe_path = Path(maybe_style)
+        if maybe_path.exists():
+            return maybe_path.read_text(encoding="UTF-8")
+        return maybe_style
+    maybe_path = CURRENT_DIR / "styles" / f"{name}.css"
+    if maybe_path.exists():
+        return maybe_path.read_text(encoding="UTF-8")
+    return ""
+
+
+class CSS(ABCMeta):
+    """Cascade stylesheets, i.e. combine all ancestor styles"""
+
+    def __new__(cls, name, bases, attrs):
+        Page = super().__new__(cls, name, bases, attrs)
+        # Use a locally defined STYLE or the one from styles directory
+        s = _extract_style(attrs.get("STYLE"), name)
+        Page.STYLE = f"\n/* {name} */\n{s.strip()}\n" if s else ""
+        # Combine with all ancestor styles
+        Page.CSS = "".join(
+            Class.STYLE
+            for Class in reversed(Page.__mro__)
+            if type(Class) is CSS
+        )
+        return Page

sanic/pages/directory_page.py

@@ -0,0 +1,66 @@
+import sys
+
+from typing import Dict, Iterable
+
+from html5tagger import E
+
+from .base import BasePage
+
+
+if sys.version_info < (3, 8):  # no cov
+    FileInfo = Dict
+
+else:
+    from typing import TypedDict
+
+    class FileInfo(TypedDict):
+        icon: str
+        file_name: str
+        file_access: str
+        file_size: str
+
+
+class DirectoryPage(BasePage):  # no cov
+    TITLE = "Directory Viewer"
+
+    def __init__(
+        self, files: Iterable[FileInfo], url: str, debug: bool
+    ) -> None:
+        super().__init__(debug)
+        self.files = files
+        self.url = url
+
+    def _body(self) -> None:
+        with self.doc.main:
+            self._headline()
+            files = list(self.files)
+            if files:
+                self._file_table(files)
+            else:
+                self.doc.p("The folder is empty.")
+
+    def _headline(self):
+        """Implement a heading with the current path, combined with
+        breadcrumb links"""
+        with self.doc.h1(id="breadcrumbs"):
+            p = self.url.split("/")[:-1]
+
+            for i, part in enumerate(p):
+                path = "/".join(p[: i + 1]) + "/"
+                with self.doc.a(href=path):
+                    self.doc.span(part, class_="dir").span("/", class_="sep")
+
+    def _file_table(self, files: Iterable[FileInfo]):
+        with self.doc.table(class_="autoindex container"):
+            for f in files:
+                self._file_row(**f)
+
+    def _file_row(
+        self,
+        icon: str,
+        file_name: str,
+        file_access: str,
+        file_size: str,
+    ):
+        first = E.span(icon, class_="icon").a(file_name, href=file_name)
+        self.doc.tr.td(first).td(file_size).td(file_access)

sanic/pages/styles/BasePage.css

@@ -0,0 +1,79 @@
+html {
+    font: 16px sans-serif;
+    background: #eee;
+    color: #111;
+}
+
+body {
+    margin: 0;
+    font-size: 1.25rem;
+}
+
+body>* {
+    padding: 1rem 2vw;
+}
+
+@media (max-width: 1200px) {
+    body>* {
+        padding: 0.5rem 1.5vw;
+    }
+
+    body {
+        font-size: 1rem;
+    }
+}
+
+.container {
+    min-width: 600px;
+    max-width: 1600px;
+}
+
+header {
+    background: #111;
+    color: #e1e1e1;
+    border-bottom: 1px solid #272727;
+    text-align: center;
+}
+
+footer {
+    text-align: center;
+    display: flex;
+    flex-direction: column;
+    font-size: 0.8rem;
+    margin-top: 2rem;
+}
+
+h1 {
+    text-align: left;
+}
+
+a:visited {
+    color: inherit;
+}
+
+a {
+    text-decoration: none;
+    color: #88f;
+}
+
+a:hover,
+a:focus {
+    text-decoration: underline;
+    outline: none;
+}
+
+#logo {
+    height: 1.75rem;
+    padding: 0 0.25rem;
+}
+
+span.icon {
+    margin-right: 1rem;
+}
+
+@media (prefers-color-scheme: dark) {
+    html {
+        background: #111;
+        color: #ccc;
+    }
+}

sanic/pages/styles/DirectoryPage.css

@@ -0,0 +1,62 @@
+#breadcrumbs>a:hover {
+    text-decoration: none;
+}
+
+#breadcrumbs>a .dir {
+    padding: 0 0.25em;
+}
+
+#breadcrumbs>a:first-child:hover::before,
+#breadcrumbs>a .dir:hover {
+    text-decoration: underline;
+}
+
+#breadcrumbs>a:first-child::before {
+    content: "🏠";
+}
+
+#breadcrumbs>a:last-child {
+    color: #ff0d68;
+}
+
+main a {
+    color: inherit;
+    font-weight: bold;
+}
+
+table.autoindex {
+    width: 100%;
+    font-family: monospace;
+    font-size: 1.25rem;
+}
+
+table.autoindex tr {
+    display: flex;
+}
+
+table.autoindex tr:hover {
+    background-color: #ddd;
+}
+
+table.autoindex td {
+    margin: 0 0.5rem;
+}
+
+table.autoindex td:first-child {
+    flex: 1;
+}
+
+table.autoindex td:nth-child(2) {
+    text-align: right;
+}
+
+table.autoindex td:last-child {
+    text-align: right;
+}
+
+
+@media (prefers-color-scheme: dark) {
+    table.autoindex tr:hover {
+        background-color: #222;
+    }
+}

sanic/request.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+from contextvars import ContextVar
+from inspect import isawaitable
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -12,16 +14,20 @@ from typing import (
     Union,
 )
 
-from sanic_routing.route import Route  # type: ignore
+from sanic_routing.route import Route
 
+from sanic.http.constants import HTTP  # type: ignore
+from sanic.http.stream import Stream
+from sanic.models.asgi import ASGIScope
 from sanic.models.http_types import Credentials
 
 
-if TYPE_CHECKING:  # no cov
+if TYPE_CHECKING:
     from sanic.server import ConnInfo
     from sanic.app import Sanic
 
 import email.utils
+import unicodedata
 import uuid
 
 from collections import defaultdict
@@ -29,13 +35,19 @@ from http.cookies import SimpleCookie
 from types import SimpleNamespace
 from urllib.parse import parse_qs, parse_qsl, unquote, urlunparse
 
-from httptools import parse_url  # type: ignore
+from httptools import parse_url
+from httptools.parser.errors import HttpParserInvalidURLError
 
 from sanic.compat import CancelledErrors, Header
-from sanic.constants import DEFAULT_HTTP_CONTENT_TYPE
-from sanic.exceptions import InvalidUsage, ServerError
+from sanic.constants import (
+    CACHEABLE_HTTP_METHODS,
+    DEFAULT_HTTP_CONTENT_TYPE,
+    IDEMPOTENT_HTTP_METHODS,
+    SAFE_HTTP_METHODS,
+)
+from sanic.exceptions import BadRequest, BadURL, ServerError
 from sanic.headers import (
-    AcceptContainer,
+    AcceptList,
     Options,
     parse_accept,
     parse_content_header,
@@ -44,8 +56,8 @@ from sanic.headers import (
     parse_host,
     parse_xforwarded,
 )
-from sanic.http import Http, Stage
-from sanic.log import error_logger, logger
+from sanic.http import Stage
+from sanic.log import deprecation, error_logger, logger
 from sanic.models.protocol_types import TransportProtocol
 from sanic.response import BaseHTTPResponse, HTTPResponse
 
@@ -80,6 +92,9 @@ class Request:
     Properties of an HTTP request such as URL, headers, etc.
     """
 
+    _current: ContextVar[Request] = ContextVar("request")
+    _loads = json_loads
+
     __slots__ = (
         "__weakref__",
         "_cookies",
@@ -89,7 +104,11 @@ class Request:
         "_port",
         "_protocol",
         "_remote_addr",
+        "_request_middleware_started",
+        "_response_middleware_started",
+        "_scheme",
         "_socket",
+        "_stream_id",
         "_match_info",
         "_name",
         "app",
@@ -110,7 +129,6 @@ class Request:
         "parsed_token",
         "raw_url",
         "responded",
-        "request_middleware_started",
         "route",
         "stream",
         "transport",
@@ -126,13 +144,16 @@ class Request:
         transport: TransportProtocol,
         app: Sanic,
         head: bytes = b"",
+        stream_id: int = 0,
     ):
-
         self.raw_url = url_bytes
-        # TODO: Content-Encoding detection
-        self._parsed_url = parse_url(url_bytes)
+        try:
+            self._parsed_url = parse_url(url_bytes)
+        except HttpParserInvalidURLError:
+            raise BadURL(f"Bad URL: {url_bytes.decode()}")
         self._id: Optional[Union[uuid.UUID, str, int]] = None
         self._name: Optional[str] = None
+        self._stream_id = stream_id
         self.app = app
 
         self.headers = Header(headers)
@@ -146,11 +167,11 @@ class Request:
         self.conn_info: Optional[ConnInfo] = None
         self.ctx = SimpleNamespace()
         self.parsed_forwarded: Optional[Options] = None
-        self.parsed_accept: Optional[AcceptContainer] = None
+        self.parsed_accept: Optional[AcceptList] = None
         self.parsed_credentials: Optional[Credentials] = None
         self.parsed_json = None
-        self.parsed_form = None
-        self.parsed_files = 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
@@ -158,22 +179,72 @@ class Request:
         self.parsed_not_grouped_args: DefaultDict[
             Tuple[bool, bool, str, str], List[Tuple[str, str]]
         ] = defaultdict(list)
-        self.request_middleware_started = False
+        self._request_middleware_started = False
+        self._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.stream: Optional[Http] = None
-        self.route: Optional[Route] = None
         self._protocol = None
-        self.responded: bool = False
 
     def __repr__(self):
         class_name = self.__class__.__name__
         return f"<{class_name}: {self.method} {self.path}>"
 
+    @classmethod
+    def get_current(cls) -> Request:
+        """
+        Retrieve the current request object
+
+        This implements `Context Variables
+        <https://docs.python.org/3/library/contextvars.html>`_
+        to allow for accessing the current request from anywhere.
+
+        Raises :exc:`sanic.exceptions.ServerError` if it is outside of
+        a request lifecycle.
+
+        .. code-block:: python
+
+            from sanic import Request
+
+            current_request = Request.get_current()
+
+        :return: the current :class:`sanic.request.Request`
+        """
+        request = cls._current.get(None)
+        if not request:
+            raise ServerError("No current request")
+        return request
+
     @classmethod
     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):
+        """
+        Access the HTTP/3 stream ID.
+
+        Raises :exc:`sanic.exceptions.ServerError` if it is not an
+        HTTP/3 request.
+        """
+        if self.protocol.version is not HTTP.VERSION_3:
+            raise ServerError(
+                "Stream ID is only a property of a HTTP/3 request"
+            )
+        return self._stream_id
+
     def reset_response(self):
         try:
             if (
@@ -197,6 +268,53 @@ class Request:
         headers: Optional[Union[Header, Dict[str, str]]] = None,
         content_type: Optional[str] = None,
     ):
+        """Respond to the request without returning.
+
+        This method can only be called once, as you can only respond once.
+        If no ``response`` argument is passed, one will be created from the
+        ``status``, ``headers`` and ``content_type`` arguments.
+
+        **The first typical usecase** is if you wish to respond to the
+        request without returning from the handler:
+
+        .. code-block:: python
+
+            @app.get("/")
+            async def handler(request: Request):
+                data = ...  # Process something
+
+                json_response = json({"data": data})
+                await request.respond(json_response)
+
+                # You are now free to continue executing other code
+                ...
+
+            @app.on_response
+            async def add_header(_, response: HTTPResponse):
+                # Middlewares still get executed as expected
+                response.headers["one"] = "two"
+
+        **The second possible usecase** is for when you want to directly
+        respond to the request:
+
+        .. code-block:: python
+
+            response = await request.respond(content_type="text/csv")
+            await response.send("foo,")
+            await response.send("bar")
+
+            # You can control the completion of the response by calling
+            # the 'eof()' method:
+            await response.eof()
+
+        :param response: response instance to send
+        :param status: status code to return in the response
+        :param headers: headers to return in the response
+        :param content_type: Content-Type header of the response
+        :return: final response being sent (may be different from the
+            ``response`` parameter because of middlewares) which can be
+            used to manually send data
+        """
         try:
             if self.stream is not None and self.stream.response:
                 raise ServerError("Second respond call is not allowed.")
@@ -213,11 +331,19 @@ class Request:
         # Connect the response
         if isinstance(response, BaseHTTPResponse) and self.stream:
             response = self.stream.respond(response)
+
+            if isawaitable(response):
+                response = await response  # type: ignore
         # Run response middleware
         try:
-            response = await self.app._run_response_middleware(
-                self, response, request_name=self.name
-            )
+            middleware = (
+                self.route and self.route.extra.response_middleware
+            ) or self.app.response_middleware
+            if middleware and not self._response_middleware_started:
+                self._response_middleware_started = True
+                response = await self.app._run_response_middleware(
+                    self, response, middleware
+                )
         except CancelledErrors:
             raise
         except Exception:
@@ -240,7 +366,19 @@ class Request:
             self.body = b"".join([data async for data in self.stream])
 
     @property
-    def name(self):
+    def name(self) -> Optional[str]:
+        """
+        The route name
+
+        In the following pattern:
+
+        .. code-block::
+
+            <AppName>.[<BlueprintName>.]<HandlerName>
+
+        :return: Route name
+        :rtype: Optional[str]
+        """
         if self._name:
             return self._name
         elif self.route:
@@ -248,26 +386,47 @@ class Request:
         return None
 
     @property
-    def endpoint(self):
+    def endpoint(self) -> Optional[str]:
+        """
+        :return: Alias of :attr:`sanic.request.Request.name`
+        :rtype: Optional[str]
+        """
         return self.name
 
     @property
-    def uri_template(self):
-        return f"/{self.route.path}"
+    def uri_template(self) -> Optional[str]:
+        """
+        :return: The defined URI template
+        :rtype: Optional[str]
+        """
+        if self.route:
+            return f"/{self.route.path}"
+        return None
 
     @property
     def protocol(self):
+        """
+        :return: The HTTP protocol instance
+        """
         if not self._protocol:
             self._protocol = self.transport.get_protocol()
         return self._protocol
 
     @property
-    def raw_headers(self):
+    def raw_headers(self) -> bytes:
+        """
+        :return: The unparsed HTTP headers
+        :rtype: bytes
+        """
         _, headers = self.head.split(b"\r\n", 1)
         return bytes(headers)
 
     @property
-    def request_line(self):
+    def request_line(self) -> bytes:
+        """
+        :return: The first line of a HTTP request
+        :rtype: bytes
+        """
         reqline, _ = self.head.split(b"\r\n", 1)
         return bytes(reqline)
 
@@ -316,24 +475,35 @@ class Request:
         return self._id  # type: ignore
 
     @property
-    def json(self):
+    def json(self) -> Any:
+        """
+        :return: The request body parsed as JSON
+        :rtype: Any
+        """
         if self.parsed_json is None:
             self.load_json()
 
         return self.parsed_json
 
-    def load_json(self, loads=json_loads):
+    def load_json(self, loads=None):
         try:
+            if not loads:
+                loads = self.__class__._loads
+
             self.parsed_json = loads(self.body)
         except Exception:
             if not self.body:
                 return None
-            raise InvalidUsage("Failed when parsing body as json")
+            raise BadRequest("Failed when parsing body as json")
 
         return self.parsed_json
 
     @property
-    def accept(self) -> AcceptContainer:
+    def accept(self) -> AcceptList:
+        """
+        :return: The ``Accept`` header parsed
+        :rtype: AcceptContainer
+        """
         if self.parsed_accept is None:
             accept_header = self.headers.getone("accept", "")
             self.parsed_accept = parse_accept(accept_header)
@@ -376,33 +546,60 @@ class Request:
                 pass
         return self.parsed_credentials
 
+    def get_form(
+        self, keep_blank_values: bool = False
+    ) -> Optional[RequestParameters]:
+        """
+        Method to extract and parse the form data from a request.
+
+        :param keep_blank_values:
+            Whether to discard blank values from the form data
+        :type keep_blank_values: bool
+        :return: the parsed form data
+        :rtype: Optional[RequestParameters]
+        """
+        self.parsed_form = RequestParameters()
+        self.parsed_files = RequestParameters()
+        content_type = self.headers.getone(
+            "content-type", DEFAULT_HTTP_CONTENT_TYPE
+        )
+        content_type, parameters = parse_content_header(content_type)
+        try:
+            if content_type == "application/x-www-form-urlencoded":
+                self.parsed_form = RequestParameters(
+                    parse_qs(
+                        self.body.decode("utf-8"),
+                        keep_blank_values=keep_blank_values,
+                    )
+                )
+            elif content_type == "multipart/form-data":
+                # TODO: Stream this instead of reading to/from memory
+                boundary = parameters["boundary"].encode(  # type: ignore
+                    "utf-8"
+                )  # type: ignore
+                self.parsed_form, self.parsed_files = parse_multipart_form(
+                    self.body, boundary
+                )
+        except Exception:
+            error_logger.exception("Failed when parsing form")
+
+        return self.parsed_form
+
     @property
     def form(self):
+        """
+        :return: The request body parsed as form data
+        """
         if self.parsed_form is None:
-            self.parsed_form = RequestParameters()
-            self.parsed_files = RequestParameters()
-            content_type = self.headers.getone(
-                "content-type", DEFAULT_HTTP_CONTENT_TYPE
-            )
-            content_type, parameters = parse_content_header(content_type)
-            try:
-                if content_type == "application/x-www-form-urlencoded":
-                    self.parsed_form = RequestParameters(
-                        parse_qs(self.body.decode("utf-8"))
-                    )
-                elif content_type == "multipart/form-data":
-                    # TODO: Stream this instead of reading to/from memory
-                    boundary = parameters["boundary"].encode("utf-8")
-                    self.parsed_form, self.parsed_files = parse_multipart_form(
-                        self.body, boundary
-                    )
-            except Exception:
-                error_logger.exception("Failed when parsing form")
+            self.get_form()
 
         return self.parsed_form
 
     @property
     def files(self):
+        """
+        :return: The request body parsed as uploaded files
+        """
         if self.parsed_files is None:
             self.form  # compute form to get files
 
@@ -416,8 +613,8 @@ class Request:
         errors: str = "replace",
     ) -> RequestParameters:
         """
-        Method to parse `query_string` using `urllib.parse.parse_qs`.
-        This methods is used by `args` property.
+        Method to parse ``query_string`` using ``urllib.parse.parse_qs``.
+        This methods is used by ``args`` property.
         Can be used directly if you need to change default parameters.
 
         :param keep_blank_values:
@@ -466,6 +663,10 @@ class Request:
         ]
 
     args = property(get_args)
+    """
+    Convenience property to access :meth:`Request.get_args` with
+    default values.
+    """
 
     def get_query_args(
         self,
@@ -585,6 +786,9 @@ class Request:
 
     @property
     def socket(self):
+        """
+        :return: Information about the connected socket if available
+        """
         return self.conn_info.peername if self.conn_info else (None, None)
 
     @property
@@ -595,6 +799,13 @@ class Request:
         """
         return self._parsed_url.path.decode("utf-8")
 
+    @property
+    def network_paths(self):
+        """
+        Access the network paths if available
+        """
+        return self.conn_info.network_paths
+
     # Proxy properties (using SERVER_NAME/forwarded/request/transport info)
 
     @property
@@ -648,23 +859,25 @@ class Request:
         :return: http|https|ws|wss or arbitrary value given by the headers.
         :rtype: str
         """
-        if "//" in self.app.config.get("SERVER_NAME", ""):
-            return self.app.config.SERVER_NAME.split("//")[0]
-        if "proto" in self.forwarded:
-            return str(self.forwarded["proto"])
+        if not hasattr(self, "_scheme"):
+            if "//" in self.app.config.get("SERVER_NAME", ""):
+                return self.app.config.SERVER_NAME.split("//")[0]
+            if "proto" in self.forwarded:
+                return str(self.forwarded["proto"])
 
-        if (
-            self.app.websocket_enabled
-            and self.headers.getone("upgrade", "").lower() == "websocket"
-        ):
-            scheme = "ws"
-        else:
-            scheme = "http"
+            if (
+                self.app.websocket_enabled
+                and self.headers.getone("upgrade", "").lower() == "websocket"
+            ):
+                scheme = "ws"
+            else:
+                scheme = "http"
 
-        if self.transport.get_extra_info("sslcontext"):
-            scheme += "s"
+            if self.transport.get_extra_info("sslcontext"):
+                scheme += "s"
+            self._scheme = scheme
 
-        return scheme
+        return self._scheme
 
     @property
     def host(self) -> str:
@@ -769,6 +982,48 @@ class Request:
             view_name, _external=True, _scheme=scheme, _server=netloc, **kwargs
         )
 
+    @property
+    def scope(self) -> ASGIScope:
+        """
+        :return: The ASGI scope of the request.
+                 If the app isn't an ASGI app, then raises an exception.
+        :rtype: Optional[ASGIScope]
+        """
+        if not self.app.asgi:
+            raise NotImplementedError(
+                "App isn't running in ASGI mode. "
+                "Scope is only available for ASGI apps."
+            )
+
+        return self.transport.scope
+
+    @property
+    def is_safe(self) -> bool:
+        """
+        :return: Whether the HTTP method is safe.
+            See https://datatracker.ietf.org/doc/html/rfc7231#section-4.2.1
+        :rtype: bool
+        """
+        return self.method in SAFE_HTTP_METHODS
+
+    @property
+    def is_idempotent(self) -> bool:
+        """
+        :return: Whether the HTTP method is iempotent.
+            See https://datatracker.ietf.org/doc/html/rfc7231#section-4.2.2
+        :rtype: bool
+        """
+        return self.method in IDEMPOTENT_HTTP_METHODS
+
+    @property
+    def is_cacheable(self) -> bool:
+        """
+        :return: Whether the HTTP method is cacheable.
+            See https://datatracker.ietf.org/doc/html/rfc7231#section-4.2.3
+        :rtype: bool
+        """
+        return self.method in CACHEABLE_HTTP_METHODS
+
 
 class File(NamedTuple):
     """
@@ -829,6 +1084,16 @@ def parse_multipart_form(body, boundary):
                         form_parameters["filename*"]
                     )
                     file_name = unquote(value, encoding=encoding)
+
+                # Normalize to NFC (Apple MacOS/iOS send NFD)
+                # Notes:
+                # - No effect for Windows, Linux or Android clients which
+                #   already send NFC
+                # - Python open() is tricky (creates files in NFC no matter
+                #   which form you use)
+                if file_name is not None:
+                    file_name = unicodedata.normalize("NFC", file_name)
+
             elif form_header_field == "content-type":
                 content_type = form_header_value
                 content_charset = form_parameters.get("charset", "utf-8")

sanic/response.py

@@ -1,533 +0,0 @@
-from __future__ import annotations
-
-from functools import partial
-from mimetypes import guess_type
-from os import path
-from pathlib import PurePath
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    AnyStr,
-    Callable,
-    Coroutine,
-    Dict,
-    Iterator,
-    Optional,
-    Tuple,
-    TypeVar,
-    Union,
-)
-from urllib.parse import quote_plus
-
-from sanic.compat import Header, open_async
-from sanic.constants import DEFAULT_HTTP_CONTENT_TYPE
-from sanic.cookies import CookieJar
-from sanic.exceptions import SanicException, ServerError
-from sanic.helpers import has_message_body, remove_entity_headers
-from sanic.http import Http
-from sanic.models.protocol_types import HTMLProtocol, Range
-
-
-if TYPE_CHECKING:
-    from sanic.asgi import ASGIApp
-    from sanic.request import Request
-else:
-    Request = TypeVar("Request")
-
-
-try:
-    from ujson import dumps as json_dumps
-except ImportError:
-    # This is done in order to ensure that the JSON response is
-    # kept consistent across both ujson and inbuilt json usage.
-    from json import dumps
-
-    json_dumps = partial(dumps, separators=(",", ":"))
-
-
-class BaseHTTPResponse:
-    """
-    The base class for all HTTP Responses
-    """
-
-    _dumps = json_dumps
-
-    def __init__(self):
-        self.asgi: bool = False
-        self.body: Optional[bytes] = None
-        self.content_type: Optional[str] = None
-        self.stream: Optional[Union[Http, ASGIApp]] = None
-        self.status: int = None
-        self.headers = Header({})
-        self._cookies: Optional[CookieJar] = None
-
-    def _encode_body(self, data: Optional[AnyStr]):
-        if data is None:
-            return b""
-        return (
-            data.encode() if hasattr(data, "encode") else data  # type: ignore
-        )
-
-    @property
-    def cookies(self) -> CookieJar:
-        """
-        The response cookies. Cookies should be set and written as follows:
-
-        .. code-block:: python
-
-                response.cookies["test"] = "It worked!"
-                response.cookies["test"]["domain"] = ".yummy-yummy-cookie.com"
-                response.cookies["test"]["httponly"] = True
-
-        `See user guide re: cookies
-        <https://sanicframework.org/guide/basics/cookies.html>`__
-
-        :return: the cookie jar
-        :rtype: CookieJar
-        """
-        if self._cookies is None:
-            self._cookies = CookieJar(self.headers)
-        return self._cookies
-
-    @property
-    def processed_headers(self) -> Iterator[Tuple[bytes, bytes]]:
-        """
-        Obtain a list of header tuples encoded in bytes for sending.
-
-        Add and remove headers based on status and content_type.
-
-        :return: response headers
-        :rtype: Tuple[Tuple[bytes, bytes], ...]
-        """
-        # TODO: Make a blacklist set of header names and then filter with that
-        if self.status in (304, 412):  # Not Modified, Precondition Failed
-            self.headers = remove_entity_headers(self.headers)
-        if has_message_body(self.status):
-            self.headers.setdefault("content-type", self.content_type)
-        # Encode headers into bytes
-        return (
-            (name.encode("ascii"), f"{value}".encode(errors="surrogateescape"))
-            for name, value in self.headers.items()
-        )
-
-    async def send(
-        self,
-        data: Optional[AnyStr] = None,
-        end_stream: Optional[bool] = None,
-    ) -> None:
-        """
-        Send any pending response headers and the given data as body.
-
-        :param data: str or bytes to be written
-        :param end_stream: whether to close the stream after this block
-        """
-        if data is None and end_stream is None:
-            end_stream = True
-        if self.stream is None:
-            raise SanicException(
-                "No stream is connected to the response object instance."
-            )
-        if self.stream.send is None:
-            if end_stream and not data:
-                return
-            raise ServerError(
-                "Response stream was ended, no more response data is "
-                "allowed to be sent."
-            )
-        data = (
-            data.encode()  # type: ignore
-            if hasattr(data, "encode")
-            else data or b""
-        )
-        await self.stream.send(data, end_stream=end_stream)
-
-
-class HTTPResponse(BaseHTTPResponse):
-    """
-    HTTP response to be sent back to the client.
-
-    :param body: the body content to be returned
-    :type body: Optional[bytes]
-    :param status: HTTP response number. **Default=200**
-    :type status: int
-    :param headers: headers to be returned
-    :type headers: Optional;
-    :param content_type: content type to be returned (as a header)
-    :type content_type: Optional[str]
-    """
-
-    __slots__ = ("body", "status", "content_type", "headers", "_cookies")
-
-    def __init__(
-        self,
-        body: Optional[AnyStr] = None,
-        status: int = 200,
-        headers: Optional[Union[Header, Dict[str, str]]] = None,
-        content_type: Optional[str] = None,
-    ):
-        super().__init__()
-
-        self.content_type: Optional[str] = content_type
-        self.body = self._encode_body(body)
-        self.status = status
-        self.headers = Header(headers or {})
-        self._cookies = None
-
-    async def eof(self):
-        await self.send("", True)
-
-    async def __aenter__(self):
-        return self.send
-
-    async def __aexit__(self, *_):
-        await self.eof()
-
-
-def empty(
-    status=204, headers: Optional[Dict[str, str]] = None
-) -> HTTPResponse:
-    """
-    Returns an empty response to the client.
-
-    :param status Response code.
-    :param headers Custom Headers.
-    """
-    return HTTPResponse(body=b"", status=status, headers=headers)
-
-
-def json(
-    body: Any,
-    status: int = 200,
-    headers: Optional[Dict[str, str]] = None,
-    content_type: str = "application/json",
-    dumps: Optional[Callable[..., str]] = None,
-    **kwargs,
-) -> HTTPResponse:
-    """
-    Returns response object with body in json format.
-
-    :param body: Response data to be serialized.
-    :param status: Response code.
-    :param headers: Custom Headers.
-    :param kwargs: Remaining arguments that are passed to the json encoder.
-    """
-    if not dumps:
-        dumps = BaseHTTPResponse._dumps
-    return HTTPResponse(
-        dumps(body, **kwargs),
-        headers=headers,
-        status=status,
-        content_type=content_type,
-    )
-
-
-def text(
-    body: str,
-    status: int = 200,
-    headers: Optional[Dict[str, str]] = None,
-    content_type: str = "text/plain; charset=utf-8",
-) -> HTTPResponse:
-    """
-    Returns response object with body in text format.
-
-    :param body: Response data to be encoded.
-    :param status: Response code.
-    :param headers: Custom Headers.
-    :param content_type: the content type (string) of the response
-    """
-    if not isinstance(body, str):
-        raise TypeError(
-            f"Bad body type. Expected str, got {type(body).__name__})"
-        )
-
-    return HTTPResponse(
-        body, status=status, headers=headers, content_type=content_type
-    )
-
-
-def raw(
-    body: Optional[AnyStr],
-    status: int = 200,
-    headers: Optional[Dict[str, str]] = None,
-    content_type: str = DEFAULT_HTTP_CONTENT_TYPE,
-) -> HTTPResponse:
-    """
-    Returns response object without encoding the body.
-
-    :param body: Response data.
-    :param status: Response code.
-    :param headers: Custom Headers.
-    :param content_type: the content type (string) of the response.
-    """
-    return HTTPResponse(
-        body=body,
-        status=status,
-        headers=headers,
-        content_type=content_type,
-    )
-
-
-def html(
-    body: Union[str, bytes, HTMLProtocol],
-    status: int = 200,
-    headers: Optional[Dict[str, str]] = None,
-) -> HTTPResponse:
-    """
-    Returns response object with body in html format.
-
-    :param body: str or bytes-ish, or an object with __html__ or _repr_html_.
-    :param status: Response code.
-    :param headers: Custom Headers.
-    """
-    if not isinstance(body, (str, bytes)):
-        if hasattr(body, "__html__"):
-            body = body.__html__()
-        elif hasattr(body, "_repr_html_"):
-            body = body._repr_html_()
-
-    return HTTPResponse(  # type: ignore
-        body,
-        status=status,
-        headers=headers,
-        content_type="text/html; charset=utf-8",
-    )
-
-
-async def file(
-    location: Union[str, PurePath],
-    status: int = 200,
-    mime_type: Optional[str] = None,
-    headers: Optional[Dict[str, str]] = None,
-    filename: Optional[str] = None,
-    _range: Optional[Range] = None,
-) -> HTTPResponse:
-    """Return a response object with file data.
-
-    :param location: Location of file on system.
-    :param mime_type: Specific mime_type.
-    :param headers: Custom Headers.
-    :param filename: Override filename.
-    :param _range:
-    """
-    headers = headers or {}
-    if filename:
-        headers.setdefault(
-            "Content-Disposition", f'attachment; filename="{filename}"'
-        )
-    filename = filename or path.split(location)[-1]
-
-    async with await open_async(location, mode="rb") as f:
-        if _range:
-            await f.seek(_range.start)
-            out_stream = await f.read(_range.size)
-            headers[
-                "Content-Range"
-            ] = f"bytes {_range.start}-{_range.end}/{_range.total}"
-            status = 206
-        else:
-            out_stream = await f.read()
-
-    mime_type = mime_type or guess_type(filename)[0] or "text/plain"
-    return HTTPResponse(
-        body=out_stream,
-        status=status,
-        headers=headers,
-        content_type=mime_type,
-    )
-
-
-def redirect(
-    to: str,
-    headers: Optional[Dict[str, str]] = None,
-    status: int = 302,
-    content_type: str = "text/html; charset=utf-8",
-) -> HTTPResponse:
-    """
-    Abort execution and cause a 302 redirect (by default) by setting a
-    Location header.
-
-    :param to: path or fully qualified URL to redirect to
-    :param headers: optional dict of headers to include in the new request
-    :param status: status code (int) of the new request, defaults to 302
-    :param content_type: the content type (string) of the response
-    """
-    headers = headers or {}
-
-    # URL Quote the URL before redirecting
-    safe_to = quote_plus(to, safe=":/%#?&=@[]!$&'()*+,;")
-
-    # According to RFC 7231, a relative URI is now permitted.
-    headers["Location"] = safe_to
-
-    return HTTPResponse(
-        status=status, headers=headers, content_type=content_type
-    )
-
-
-class ResponseStream:
-    """
-    ResponseStream is a compat layer to bridge the gap after the deprecation
-    of StreamingHTTPResponse. In v22.6 it will be removed when:
-    - stream is removed
-    - file_stream is moved to new style streaming
-    - file and file_stream are combined into a single API
-    """
-
-    __slots__ = (
-        "_cookies",
-        "content_type",
-        "headers",
-        "request",
-        "response",
-        "status",
-        "streaming_fn",
-    )
-
-    def __init__(
-        self,
-        streaming_fn: Callable[
-            [Union[BaseHTTPResponse, ResponseStream]],
-            Coroutine[Any, Any, None],
-        ],
-        status: int = 200,
-        headers: Optional[Union[Header, Dict[str, str]]] = None,
-        content_type: Optional[str] = None,
-    ):
-        self.streaming_fn = streaming_fn
-        self.status = status
-        self.headers = headers or Header()
-        self.content_type = content_type
-        self.request: Optional[Request] = None
-        self._cookies: Optional[CookieJar] = None
-
-    async def write(self, message: str):
-        await self.response.send(message)
-
-    async def stream(self) -> HTTPResponse:
-        if not self.request:
-            raise ServerError("Attempted response to unknown request")
-        self.response = await self.request.respond(
-            headers=self.headers,
-            status=self.status,
-            content_type=self.content_type,
-        )
-        await self.streaming_fn(self)
-        return self.response
-
-    async def eof(self) -> None:
-        await self.response.eof()
-
-    @property
-    def cookies(self) -> CookieJar:
-        if self._cookies is None:
-            self._cookies = CookieJar(self.headers)
-        return self._cookies
-
-    @property
-    def processed_headers(self):
-        return self.response.processed_headers
-
-    @property
-    def body(self):
-        return self.response.body
-
-    def __call__(self, request: Request) -> ResponseStream:
-        self.request = request
-        return self
-
-    def __await__(self):
-        return self.stream().__await__()
-
-
-async def file_stream(
-    location: Union[str, PurePath],
-    status: int = 200,
-    chunk_size: int = 4096,
-    mime_type: Optional[str] = None,
-    headers: Optional[Dict[str, str]] = None,
-    filename: Optional[str] = None,
-    _range: Optional[Range] = None,
-) -> ResponseStream:
-    """Return a streaming response object with file data.
-
-    :param location: Location of file on system.
-    :param chunk_size: The size of each chunk in the stream (in bytes)
-    :param mime_type: Specific mime_type.
-    :param headers: Custom Headers.
-    :param filename: Override filename.
-    :param _range:
-    """
-    headers = headers or {}
-    if filename:
-        headers.setdefault(
-            "Content-Disposition", f'attachment; filename="{filename}"'
-        )
-    filename = filename or path.split(location)[-1]
-    mime_type = mime_type or guess_type(filename)[0] or "text/plain"
-    if _range:
-        start = _range.start
-        end = _range.end
-        total = _range.total
-
-        headers["Content-Range"] = f"bytes {start}-{end}/{total}"
-        status = 206
-
-    async def _streaming_fn(response):
-        async with await open_async(location, mode="rb") as f:
-            if _range:
-                await f.seek(_range.start)
-                to_send = _range.size
-                while to_send > 0:
-                    content = await f.read(min((_range.size, chunk_size)))
-                    if len(content) < 1:
-                        break
-                    to_send -= len(content)
-                    await response.write(content)
-            else:
-                while True:
-                    content = await f.read(chunk_size)
-                    if len(content) < 1:
-                        break
-                    await response.write(content)
-
-    return ResponseStream(
-        streaming_fn=_streaming_fn,
-        status=status,
-        headers=headers,
-        content_type=mime_type,
-    )
-
-
-def stream(
-    streaming_fn: Callable[
-        [Union[BaseHTTPResponse, ResponseStream]], Coroutine[Any, Any, None]
-    ],
-    status: int = 200,
-    headers: Optional[Dict[str, str]] = None,
-    content_type: str = "text/plain; charset=utf-8",
-) -> ResponseStream:
-    """Accepts a coroutine `streaming_fn` which can be used to
-    write chunks to a streaming response. Returns a `ResponseStream`.
-
-    Example usage::
-
-        @app.route("/")
-        async def index(request):
-            async def streaming_fn(response):
-                await response.write('foo')
-                await response.write('bar')
-
-            return stream(streaming_fn, content_type='text/plain')
-
-    :param streaming_fn: A coroutine accepts a response and
-        writes content to that response.
-    :param status: HTTP status.
-    :param content_type: Specific content_type.
-    :param headers: Custom Headers.
-    """
-    return ResponseStream(
-        streaming_fn,
-        headers=headers,
-        content_type=content_type,
-        status=status,
-    )

sanic/response/__init__.py

@@ -0,0 +1,36 @@
+from .convenience import (
+    empty,
+    file,
+    file_stream,
+    html,
+    json,
+    raw,
+    redirect,
+    text,
+    validate_file,
+)
+from .types import (
+    BaseHTTPResponse,
+    HTTPResponse,
+    JSONResponse,
+    ResponseStream,
+    json_dumps,
+)
+
+
+__all__ = (
+    "BaseHTTPResponse",
+    "HTTPResponse",
+    "JSONResponse",
+    "ResponseStream",
+    "empty",
+    "json",
+    "text",
+    "raw",
+    "html",
+    "validate_file",
+    "file",
+    "redirect",
+    "file_stream",
+    "json_dumps",
+)

sanic/response/convenience.py

@@ -0,0 +1,333 @@
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from email.utils import formatdate, parsedate_to_datetime
+from mimetypes import guess_type
+from os import path
+from pathlib import PurePath
+from time import time
+from typing import Any, AnyStr, Callable, Dict, Optional, Union
+from urllib.parse import quote_plus
+
+from sanic.compat import Header, open_async, stat_async
+from sanic.constants import DEFAULT_HTTP_CONTENT_TYPE
+from sanic.helpers import Default, _default
+from sanic.log import logger
+from sanic.models.protocol_types import HTMLProtocol, Range
+
+from .types import HTTPResponse, JSONResponse, ResponseStream
+
+
+def empty(
+    status: int = 204, headers: Optional[Dict[str, str]] = None
+) -> HTTPResponse:
+    """
+    Returns an empty response to the client.
+
+    :param status Response code.
+    :param headers Custom Headers.
+    """
+    return HTTPResponse(body=b"", status=status, headers=headers)
+
+
+def json(
+    body: Any,
+    status: int = 200,
+    headers: Optional[Dict[str, str]] = None,
+    content_type: str = "application/json",
+    dumps: Optional[Callable[..., str]] = None,
+    **kwargs: Any,
+) -> JSONResponse:
+    """
+    Returns response object with body in json format.
+
+    :param body: Response data to be serialized.
+    :param status: Response code.
+    :param headers: Custom Headers.
+    :param kwargs: Remaining arguments that are passed to the json encoder.
+    """
+
+    return JSONResponse(
+        body,
+        status=status,
+        headers=headers,
+        content_type=content_type,
+        dumps=dumps,
+        **kwargs,
+    )
+
+
+def text(
+    body: str,
+    status: int = 200,
+    headers: Optional[Dict[str, str]] = None,
+    content_type: str = "text/plain; charset=utf-8",
+) -> HTTPResponse:
+    """
+    Returns response object with body in text format.
+
+    :param body: Response data to be encoded.
+    :param status: Response code.
+    :param headers: Custom Headers.
+    :param content_type: the content type (string) of the response
+    """
+    if not isinstance(body, str):
+        raise TypeError(
+            f"Bad body type. Expected str, got {type(body).__name__})"
+        )
+
+    return HTTPResponse(
+        body, status=status, headers=headers, content_type=content_type
+    )
+
+
+def raw(
+    body: Optional[AnyStr],
+    status: int = 200,
+    headers: Optional[Dict[str, str]] = None,
+    content_type: str = DEFAULT_HTTP_CONTENT_TYPE,
+) -> HTTPResponse:
+    """
+    Returns response object without encoding the body.
+
+    :param body: Response data.
+    :param status: Response code.
+    :param headers: Custom Headers.
+    :param content_type: the content type (string) of the response.
+    """
+    return HTTPResponse(
+        body=body,
+        status=status,
+        headers=headers,
+        content_type=content_type,
+    )
+
+
+def html(
+    body: Union[str, bytes, HTMLProtocol],
+    status: int = 200,
+    headers: Optional[Dict[str, str]] = None,
+) -> HTTPResponse:
+    """
+    Returns response object with body in html format.
+
+    :param body: str or bytes-ish, or an object with __html__ or _repr_html_.
+    :param status: Response code.
+    :param headers: Custom Headers.
+    """
+    if not isinstance(body, (str, bytes)):
+        if hasattr(body, "__html__"):
+            body = body.__html__()
+        elif hasattr(body, "_repr_html_"):
+            body = body._repr_html_()
+
+    return HTTPResponse(  # type: ignore
+        body,
+        status=status,
+        headers=headers,
+        content_type="text/html; charset=utf-8",
+    )
+
+
+async def validate_file(
+    request_headers: Header, last_modified: Union[datetime, float, int]
+):
+    try:
+        if_modified_since = request_headers.getone("If-Modified-Since")
+    except KeyError:
+        return
+    try:
+        if_modified_since = parsedate_to_datetime(if_modified_since)
+    except (TypeError, ValueError):
+        logger.warning(
+            "Ignorning invalid If-Modified-Since header received: " "'%s'",
+            if_modified_since,
+        )
+        return
+    if not isinstance(last_modified, datetime):
+        last_modified = datetime.fromtimestamp(
+            float(last_modified), tz=timezone.utc
+        ).replace(microsecond=0)
+    if last_modified <= if_modified_since:
+        return HTTPResponse(status=304)
+
+
+async def file(
+    location: Union[str, PurePath],
+    status: int = 200,
+    request_headers: Optional[Header] = None,
+    validate_when_requested: bool = True,
+    mime_type: Optional[str] = None,
+    headers: Optional[Dict[str, str]] = None,
+    filename: Optional[str] = None,
+    last_modified: Optional[Union[datetime, float, int, Default]] = _default,
+    max_age: Optional[Union[float, int]] = None,
+    no_store: Optional[bool] = None,
+    _range: Optional[Range] = None,
+) -> HTTPResponse:
+    """Return a response object with file data.
+    :param status: HTTP response code. Won't enforce the passed in
+        status if only a part of the content will be sent (206)
+        or file is being validated (304).
+    :param request_headers: The request headers.
+    :param validate_when_requested: If True, will validate the
+        file when requested.
+    :param location: Location of file on system.
+    :param mime_type: Specific mime_type.
+    :param headers: Custom Headers.
+    :param filename: Override filename.
+    :param last_modified: The last modified date and time of the file.
+    :param max_age: Max age for cache control.
+    :param no_store: Any cache should not store this response.
+    :param _range:
+    """
+
+    if isinstance(last_modified, datetime):
+        last_modified = last_modified.replace(microsecond=0).timestamp()
+    elif isinstance(last_modified, Default):
+        stat = await stat_async(location)
+        last_modified = stat.st_mtime
+
+    if (
+        validate_when_requested
+        and request_headers is not None
+        and last_modified
+    ):
+        response = await validate_file(request_headers, last_modified)
+        if response:
+            return response
+
+    headers = headers or {}
+    if last_modified:
+        headers.setdefault(
+            "Last-Modified", formatdate(last_modified, usegmt=True)
+        )
+
+    if filename:
+        headers.setdefault(
+            "Content-Disposition", f'attachment; filename="{filename}"'
+        )
+
+    if no_store:
+        cache_control = "no-store"
+    elif max_age:
+        cache_control = f"public, max-age={max_age}"
+        headers.setdefault(
+            "expires",
+            formatdate(
+                time() + max_age,
+                usegmt=True,
+            ),
+        )
+    else:
+        cache_control = "no-cache"
+
+    headers.setdefault("cache-control", cache_control)
+
+    filename = filename or path.split(location)[-1]
+
+    async with await open_async(location, mode="rb") as f:
+        if _range:
+            await f.seek(_range.start)
+            out_stream = await f.read(_range.size)
+            headers[
+                "Content-Range"
+            ] = f"bytes {_range.start}-{_range.end}/{_range.total}"
+            status = 206
+        else:
+            out_stream = await f.read()
+
+    mime_type = mime_type or guess_type(filename)[0] or "text/plain"
+    return HTTPResponse(
+        body=out_stream,
+        status=status,
+        headers=headers,
+        content_type=mime_type,
+    )
+
+
+def redirect(
+    to: str,
+    headers: Optional[Dict[str, str]] = None,
+    status: int = 302,
+    content_type: str = "text/html; charset=utf-8",
+) -> HTTPResponse:
+    """
+    Abort execution and cause a 302 redirect (by default) by setting a
+    Location header.
+
+    :param to: path or fully qualified URL to redirect to
+    :param headers: optional dict of headers to include in the new request
+    :param status: status code (int) of the new request, defaults to 302
+    :param content_type: the content type (string) of the response
+    """
+    headers = headers or {}
+
+    # URL Quote the URL before redirecting
+    safe_to = quote_plus(to, safe=":/%#?&=@[]!$&'()*+,;")
+
+    # According to RFC 7231, a relative URI is now permitted.
+    headers["Location"] = safe_to
+
+    return HTTPResponse(
+        status=status, headers=headers, content_type=content_type
+    )
+
+
+async def file_stream(
+    location: Union[str, PurePath],
+    status: int = 200,
+    chunk_size: int = 4096,
+    mime_type: Optional[str] = None,
+    headers: Optional[Dict[str, str]] = None,
+    filename: Optional[str] = None,
+    _range: Optional[Range] = None,
+) -> ResponseStream:
+    """Return a streaming response object with file data.
+
+    :param location: Location of file on system.
+    :param chunk_size: The size of each chunk in the stream (in bytes)
+    :param mime_type: Specific mime_type.
+    :param headers: Custom Headers.
+    :param filename: Override filename.
+    :param _range:
+    """
+    headers = headers or {}
+    if filename:
+        headers.setdefault(
+            "Content-Disposition", f'attachment; filename="{filename}"'
+        )
+    filename = filename or path.split(location)[-1]
+    mime_type = mime_type or guess_type(filename)[0] or "text/plain"
+    if _range:
+        start = _range.start
+        end = _range.end
+        total = _range.total
+
+        headers["Content-Range"] = f"bytes {start}-{end}/{total}"
+        status = 206
+
+    async def _streaming_fn(response):
+        async with await open_async(location, mode="rb") as f:
+            if _range:
+                await f.seek(_range.start)
+                to_send = _range.size
+                while to_send > 0:
+                    content = await f.read(min((_range.size, chunk_size)))
+                    if len(content) < 1:
+                        break
+                    to_send -= len(content)
+                    await response.write(content)
+            else:
+                while True:
+                    content = await f.read(chunk_size)
+                    if len(content) < 1:
+                        break
+                    await response.write(content)
+
+    return ResponseStream(
+        streaming_fn=_streaming_fn,
+        status=status,
+        headers=headers,
+        content_type=mime_type,
+    )

sanic/response/types.py

@@ -0,0 +1,453 @@
+from __future__ import annotations
+
+from functools import partial
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    AnyStr,
+    Callable,
+    Coroutine,
+    Dict,
+    Iterator,
+    Optional,
+    Tuple,
+    TypeVar,
+    Union,
+)
+
+from sanic.compat import Header
+from sanic.cookies import CookieJar
+from sanic.exceptions import SanicException, ServerError
+from sanic.helpers import (
+    Default,
+    _default,
+    has_message_body,
+    remove_entity_headers,
+)
+from sanic.http import Http
+
+
+if TYPE_CHECKING:
+    from sanic.asgi import ASGIApp
+    from sanic.http.http3 import HTTPReceiver
+    from sanic.request import Request
+else:
+    Request = TypeVar("Request")
+
+
+try:
+    from ujson import dumps as json_dumps
+except ImportError:
+    # This is done in order to ensure that the JSON response is
+    # kept consistent across both ujson and inbuilt json usage.
+    from json import dumps
+
+    json_dumps = partial(dumps, separators=(",", ":"))
+
+
+class BaseHTTPResponse:
+    """
+    The base class for all HTTP Responses
+    """
+
+    __slots__ = (
+        "asgi",
+        "body",
+        "content_type",
+        "stream",
+        "status",
+        "headers",
+        "_cookies",
+    )
+
+    _dumps = json_dumps
+
+    def __init__(self):
+        self.asgi: bool = False
+        self.body: Optional[bytes] = None
+        self.content_type: Optional[str] = None
+        self.stream: Optional[Union[Http, ASGIApp, HTTPReceiver]] = None
+        self.status: int = None
+        self.headers = Header({})
+        self._cookies: Optional[CookieJar] = None
+
+    def __repr__(self):
+        class_name = self.__class__.__name__
+        return f"<{class_name}: {self.status} {self.content_type}>"
+
+    def _encode_body(self, data: Optional[AnyStr]):
+        if data is None:
+            return b""
+        return (
+            data.encode() if hasattr(data, "encode") else data  # type: ignore
+        )
+
+    @property
+    def cookies(self) -> CookieJar:
+        """
+        The response cookies. Cookies should be set and written as follows:
+
+        .. code-block:: python
+
+                response.cookies["test"] = "It worked!"
+                response.cookies["test"]["domain"] = ".yummy-yummy-cookie.com"
+                response.cookies["test"]["httponly"] = True
+
+        `See user guide re: cookies
+        <https://sanic.dev/en/guide/basics/cookies.html>`
+
+        :return: the cookie jar
+        :rtype: CookieJar
+        """
+        if self._cookies is None:
+            self._cookies = CookieJar(self.headers)
+        return self._cookies
+
+    @property
+    def processed_headers(self) -> Iterator[Tuple[bytes, bytes]]:
+        """
+        Obtain a list of header tuples encoded in bytes for sending.
+
+        Add and remove headers based on status and content_type.
+
+        :return: response headers
+        :rtype: Tuple[Tuple[bytes, bytes], ...]
+        """
+        # TODO: Make a blacklist set of header names and then filter with that
+        if self.status in (304, 412):  # Not Modified, Precondition Failed
+            self.headers = remove_entity_headers(self.headers)
+        if has_message_body(self.status):
+            self.headers.setdefault("content-type", self.content_type)
+        # Encode headers into bytes
+        return (
+            (name.encode("ascii"), f"{value}".encode(errors="surrogateescape"))
+            for name, value in self.headers.items()
+        )
+
+    async def send(
+        self,
+        data: Optional[AnyStr] = None,
+        end_stream: Optional[bool] = None,
+    ) -> None:
+        """
+        Send any pending response headers and the given data as body.
+
+        :param data: str or bytes to be written
+        :param end_stream: whether to close the stream after this block
+        """
+        if data is None and end_stream is None:
+            end_stream = True
+        if self.stream is None:
+            raise SanicException(
+                "No stream is connected to the response object instance."
+            )
+        if self.stream.send is None:
+            if end_stream and not data:
+                return
+            raise ServerError(
+                "Response stream was ended, no more response data is "
+                "allowed to be sent."
+            )
+        data = (
+            data.encode()  # type: ignore
+            if hasattr(data, "encode")
+            else data or b""
+        )
+        await self.stream.send(
+            data,  # type: ignore
+            end_stream=end_stream or False,
+        )
+
+
+class HTTPResponse(BaseHTTPResponse):
+    """
+    HTTP response to be sent back to the client.
+
+    :param body: the body content to be returned
+    :type body: Optional[bytes]
+    :param status: HTTP response number. **Default=200**
+    :type status: int
+    :param headers: headers to be returned
+    :type headers: Optional;
+    :param content_type: content type to be returned (as a header)
+    :type content_type: Optional[str]
+    """
+
+    __slots__ = ()
+
+    def __init__(
+        self,
+        body: Optional[Any] = None,
+        status: int = 200,
+        headers: Optional[Union[Header, Dict[str, str]]] = None,
+        content_type: Optional[str] = None,
+    ):
+        super().__init__()
+
+        self.content_type: Optional[str] = content_type
+        self.body = self._encode_body(body)
+        self.status = status
+        self.headers = Header(headers or {})
+        self._cookies = None
+
+    async def eof(self):
+        await self.send("", True)
+
+    async def __aenter__(self):
+        return self.send
+
+    async def __aexit__(self, *_):
+        await self.eof()
+
+
+class JSONResponse(HTTPResponse):
+    """
+    HTTP response to be sent back to the client, when the response
+    is of json type. Offers several utilities to manipulate common
+    json data types.
+
+    :param body: the body content to be returned
+    :type body: Optional[Any]
+    :param status: HTTP response number. **Default=200**
+    :type status: int
+    :param headers: headers to be returned
+    :type headers: Optional
+    :param content_type: content type to be returned (as a header)
+    :type content_type: Optional[str]
+    :param dumps: json.dumps function to use
+    :type dumps: Optional[Callable]
+    """
+
+    __slots__ = (
+        "_body",
+        "_body_manually_set",
+        "_initialized",
+        "_raw_body",
+        "_use_dumps",
+        "_use_dumps_kwargs",
+    )
+
+    def __init__(
+        self,
+        body: Optional[Any] = None,
+        status: int = 200,
+        headers: Optional[Union[Header, Dict[str, str]]] = None,
+        content_type: Optional[str] = None,
+        dumps: Optional[Callable[..., str]] = None,
+        **kwargs: Any,
+    ):
+        self._initialized = False
+        self._body_manually_set = False
+
+        self._use_dumps = dumps or BaseHTTPResponse._dumps
+        self._use_dumps_kwargs = kwargs
+
+        self._raw_body = body
+
+        super().__init__(
+            self._encode_body(self._use_dumps(body, **self._use_dumps_kwargs)),
+            headers=headers,
+            status=status,
+            content_type=content_type,
+        )
+
+        self._initialized = True
+
+    def _check_body_not_manually_set(self):
+        if self._body_manually_set:
+            raise SanicException(
+                "Cannot use raw_body after body has been manually set."
+            )
+
+    @property
+    def raw_body(self) -> Optional[Any]:
+        """Returns the raw body, as long as body has not been manually
+        set previously.
+
+        NOTE: This object should not be mutated, as it will not be
+        reflected in the response body. If you need to mutate the
+        response body, consider using one of the provided methods in
+        this class or alternatively call set_body() with the mutated
+        object afterwards or set the raw_body property to it.
+        """
+
+        self._check_body_not_manually_set()
+        return self._raw_body
+
+    @raw_body.setter
+    def raw_body(self, value: Any):
+        self._body_manually_set = False
+        self._body = self._encode_body(
+            self._use_dumps(value, **self._use_dumps_kwargs)
+        )
+        self._raw_body = value
+
+    @property  # type: ignore
+    def body(self) -> Optional[bytes]:  # type: ignore
+        return self._body
+
+    @body.setter
+    def body(self, value: Optional[bytes]):
+        self._body = value
+        if not self._initialized:
+            return
+        self._body_manually_set = True
+
+    def set_body(
+        self,
+        body: Any,
+        dumps: Optional[Callable[..., str]] = None,
+        **dumps_kwargs: Any,
+    ) -> None:
+        """Sets a new response body using the given dumps function
+        and kwargs, or falling back to the defaults given when
+        creating the object if none are specified.
+        """
+
+        self._body_manually_set = False
+        self._raw_body = body
+
+        use_dumps = dumps or self._use_dumps
+        use_dumps_kwargs = dumps_kwargs if dumps else self._use_dumps_kwargs
+
+        self._body = self._encode_body(use_dumps(body, **use_dumps_kwargs))
+
+    def append(self, value: Any) -> None:
+        """Appends a value to the response raw_body, ensuring that
+        body is kept up to date. This can only be used if raw_body
+        is a list.
+        """
+
+        self._check_body_not_manually_set()
+
+        if not isinstance(self._raw_body, list):
+            raise SanicException("Cannot append to a non-list object.")
+
+        self._raw_body.append(value)
+        self.raw_body = self._raw_body
+
+    def extend(self, value: Any) -> None:
+        """Extends the response's raw_body with the given values, ensuring
+        that body is kept up to date. This can only be used if raw_body is
+        a list.
+        """
+
+        self._check_body_not_manually_set()
+
+        if not isinstance(self._raw_body, list):
+            raise SanicException("Cannot extend a non-list object.")
+
+        self._raw_body.extend(value)
+        self.raw_body = self._raw_body
+
+    def update(self, *args, **kwargs) -> None:
+        """Updates the response's raw_body with the given values, ensuring
+        that body is kept up to date. This can only be used if raw_body is
+        a dict.
+        """
+
+        self._check_body_not_manually_set()
+
+        if not isinstance(self._raw_body, dict):
+            raise SanicException("Cannot update a non-dict object.")
+
+        self._raw_body.update(*args, **kwargs)
+        self.raw_body = self._raw_body
+
+    def pop(self, key: Any, default: Any = _default) -> Any:
+        """Pops a key from the response's raw_body, ensuring that body is
+        kept up to date. This can only be used if raw_body is a dict or a
+        list.
+        """
+
+        self._check_body_not_manually_set()
+
+        if not isinstance(self._raw_body, (list, dict)):
+            raise SanicException(
+                "Cannot pop from a non-list and non-dict object."
+            )
+
+        if isinstance(default, Default):
+            value = self._raw_body.pop(key)
+        elif isinstance(self._raw_body, list):
+            raise TypeError("pop doesn't accept a default argument for lists")
+        else:
+            value = self._raw_body.pop(key, default)
+
+        self.raw_body = self._raw_body
+
+        return value
+
+
+class ResponseStream:
+    """
+    ResponseStream is a compat layer to bridge the gap after the deprecation
+    of StreamingHTTPResponse. It will be removed when:
+    - file_stream is moved to new style streaming
+    - file and file_stream are combined into a single API
+    """
+
+    __slots__ = (
+        "_cookies",
+        "content_type",
+        "headers",
+        "request",
+        "response",
+        "status",
+        "streaming_fn",
+    )
+
+    def __init__(
+        self,
+        streaming_fn: Callable[
+            [Union[BaseHTTPResponse, ResponseStream]],
+            Coroutine[Any, Any, None],
+        ],
+        status: int = 200,
+        headers: Optional[Union[Header, Dict[str, str]]] = None,
+        content_type: Optional[str] = None,
+    ):
+        self.streaming_fn = streaming_fn
+        self.status = status
+        self.headers = headers or Header()
+        self.content_type = content_type
+        self.request: Optional[Request] = None
+        self._cookies: Optional[CookieJar] = None
+
+    async def write(self, message: str):
+        await self.response.send(message)
+
+    async def stream(self) -> HTTPResponse:
+        if not self.request:
+            raise ServerError("Attempted response to unknown request")
+        self.response = await self.request.respond(
+            headers=self.headers,
+            status=self.status,
+            content_type=self.content_type,
+        )
+        await self.streaming_fn(self)
+        return self.response
+
+    async def eof(self) -> None:
+        await self.response.eof()
+
+    @property
+    def cookies(self) -> CookieJar:
+        if self._cookies is None:
+            self._cookies = CookieJar(self.headers)
+        return self._cookies
+
+    @property
+    def processed_headers(self):
+        return self.response.processed_headers
+
+    @property
+    def body(self):
+        return self.response.body
+
+    def __call__(self, request: Request) -> ResponseStream:
+        self.request = request
+        return self
+
+    def __await__(self):
+        return self.stream().__await__()

sanic/router.py

@@ -5,16 +5,14 @@ from inspect import signature
 from typing import Any, Dict, Iterable, List, Optional, Tuple, Union
 from uuid import UUID
 
-from sanic_routing import BaseRouter  # type: ignore
-from sanic_routing.exceptions import NoMethod  # type: ignore
-from sanic_routing.exceptions import (
-    NotFound as RoutingNotFound,  # type: ignore
-)
-from sanic_routing.route import Route  # type: ignore
+from sanic_routing import BaseRouter
+from sanic_routing.exceptions import NoMethod
+from sanic_routing.exceptions import NotFound as RoutingNotFound
+from sanic_routing.route import Route
 
 from sanic.constants import HTTP_METHODS
 from sanic.errorpages import check_error_format
-from sanic.exceptions import MethodNotSupported, NotFound, SanicException
+from sanic.exceptions import MethodNotAllowed, NotFound, SanicException
 from sanic.models.handler_types import RouteHandler
 
 
@@ -43,7 +41,7 @@ class Router(BaseRouter):
         except RoutingNotFound as e:
             raise NotFound("Requested URL {} not found".format(e.path))
         except NoMethod as e:
-            raise MethodNotSupported(
+            raise MethodNotAllowed(
                 "Method {} not allowed for URL {}".format(method, path),
                 method=method,
                 allowed_methods=e.allowed_methods,
@@ -135,14 +133,14 @@ class Router(BaseRouter):
                 params.update({"requirements": {"host": host}})
 
             route = super().add(**params)  # type: ignore
-            route.ctx.ignore_body = ignore_body
-            route.ctx.stream = stream
-            route.ctx.hosts = hosts
-            route.ctx.static = static
-            route.ctx.error_format = error_format
+            route.extra.ignore_body = ignore_body
+            route.extra.stream = stream
+            route.extra.hosts = hosts
+            route.extra.static = static
+            route.extra.error_format = error_format
 
             if error_format:
-                check_error_format(route.ctx.error_format)
+                check_error_format(route.extra.error_format)
 
             routes.append(route)