mirror of
https://github.com/django/daphne.git
synced 2025-04-22 17:52:08 +03:00
Compare commits
No commits in common. "main" and "3.0.1" have entirely different histories.
11
.flake8
11
.flake8
|
|
@ -1,11 +0,0 @@
|
|||
[flake8]
|
||||
exclude =
|
||||
.venv,
|
||||
.tox,
|
||||
docs,
|
||||
testproject,
|
||||
js_client,
|
||||
.eggs
|
||||
|
||||
extend-ignore = E123, E128, E266, E402, W503, E731, W601, B036
|
||||
max-line-length = 120
|
||||
6
.github/dependabot.yml
vendored
6
.github/dependabot.yml
vendored
|
|
@ -1,6 +0,0 @@
|
|||
version: 2
|
||||
updates:
|
||||
- package-ecosystem: github-actions
|
||||
directory: "/"
|
||||
schedule:
|
||||
interval: weekly
|
||||
48
.github/workflows/tests.yml
vendored
48
.github/workflows/tests.yml
vendored
|
|
@ -3,41 +3,45 @@ name: Tests
|
|||
on:
|
||||
push:
|
||||
branches:
|
||||
- main
|
||||
- master
|
||||
pull_request:
|
||||
workflow_dispatch:
|
||||
|
||||
permissions:
|
||||
contents: read
|
||||
|
||||
jobs:
|
||||
tests:
|
||||
runs-on: ${{ matrix.os }}-latest
|
||||
runs-on: ubuntu-latest
|
||||
strategy:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
os:
|
||||
- ubuntu
|
||||
- windows
|
||||
python-version:
|
||||
- "3.9"
|
||||
- "3.10"
|
||||
- "3.11"
|
||||
- "3.12"
|
||||
- "3.13"
|
||||
- 3.6
|
||||
- 3.7
|
||||
- 3.8
|
||||
- 3.9
|
||||
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
|
||||
- uses: actions/checkout@v2
|
||||
- name: Set up Python ${{ matrix.python-version }}
|
||||
uses: actions/setup-python@v5
|
||||
uses: actions/setup-python@v2
|
||||
with:
|
||||
python-version: ${{ matrix.python-version }}
|
||||
|
||||
- name: Install dependencies
|
||||
run: |
|
||||
python -m pip install --upgrade pip setuptools wheel
|
||||
python -m pip install --upgrade tox
|
||||
|
||||
python -m pip install --upgrade pip wheel setuptools tox
|
||||
- name: Run tox targets for ${{ matrix.python-version }}
|
||||
run: tox run -f py$(echo ${{ matrix.python-version }} | tr -d .)
|
||||
run: |
|
||||
ENV_PREFIX=$(tr -C -d "0-9" <<< "${{ matrix.python-version }}")
|
||||
TOXENV=$(tox --listenvs | grep "^py$ENV_PREFIX" | tr '\n' ',') python -m tox
|
||||
|
||||
lint:
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@v2
|
||||
- name: Set up Python
|
||||
uses: actions/setup-python@v2
|
||||
with:
|
||||
python-version: 3.9
|
||||
- name: Install dependencies
|
||||
run: |
|
||||
python -m pip install --upgrade pip tox
|
||||
- name: Run lint
|
||||
run: tox -e qa
|
||||
|
|
|
|||
1
.gitignore
vendored
1
.gitignore
vendored
|
|
@ -13,4 +13,3 @@ test_consumer*
|
|||
.python-version
|
||||
.pytest_cache/
|
||||
.vscode
|
||||
.coverage
|
||||
|
|
|
|||
|
|
@ -1,23 +0,0 @@
|
|||
repos:
|
||||
- repo: https://github.com/asottile/pyupgrade
|
||||
rev: v3.19.1
|
||||
hooks:
|
||||
- id: pyupgrade
|
||||
args: [--py39-plus]
|
||||
- repo: https://github.com/psf/black
|
||||
rev: 25.1.0
|
||||
hooks:
|
||||
- id: black
|
||||
language_version: python3
|
||||
- repo: https://github.com/pycqa/isort
|
||||
rev: 6.0.1
|
||||
hooks:
|
||||
- id: isort
|
||||
- repo: https://github.com/PyCQA/flake8
|
||||
rev: 7.2.0
|
||||
hooks:
|
||||
- id: flake8
|
||||
additional_dependencies:
|
||||
- flake8-bugbear
|
||||
ci:
|
||||
autoupdate_schedule: quarterly
|
||||
|
|
@ -1,96 +1,3 @@
|
|||
4.2.0 (to be released)
|
||||
------------------
|
||||
|
||||
* Added support for Python 3.13.
|
||||
|
||||
* Drop support for EOL Python 3.8.
|
||||
|
||||
* Removed unused pytest-runner
|
||||
|
||||
* Fixed sdist file to ensure it includes all tests
|
||||
|
||||
4.1.2 (2024-04-11)
|
||||
------------------
|
||||
|
||||
* Fixed a setuptools configuration error in 4.1.1.
|
||||
|
||||
4.1.1 (2024-04-10)
|
||||
------------------
|
||||
|
||||
* Fixed a twisted.plugin packaging error in 4.1.0.
|
||||
|
||||
Thanks to sdc50.
|
||||
|
||||
4.1.0 (2024-02-10)
|
||||
------------------
|
||||
|
||||
* Added support for Python 3.12.
|
||||
|
||||
* Dropped support for EOL Python 3.7.
|
||||
|
||||
* Handled root path for websocket scopes.
|
||||
|
||||
* Validate HTTP header names as per RFC 9110.
|
||||
|
||||
4.0.0 (2022-10-07)
|
||||
------------------
|
||||
|
||||
Major versioning targeting use with Channels 4.0 and beyond. Except where
|
||||
noted should remain usable with Channels v3 projects, but updating Channels to the latest version is recommended.
|
||||
|
||||
* Added a ``runserver`` command to run an ASGI Django development server.
|
||||
|
||||
Added ``"daphne"`` to the ``INSTALLED_APPS`` setting, before
|
||||
``"django.contrib.staticfiles"`` to enable:
|
||||
|
||||
INSTALLED_APPS = [
|
||||
"daphne",
|
||||
...
|
||||
]
|
||||
|
||||
This replaces the Channels implementation of ``runserver``, which is removed
|
||||
in Channels 4.0.
|
||||
|
||||
* Made the ``DaphneProcess`` tests helper class compatible with the ``spawn``
|
||||
process start method, which is used on macOS and Windows.
|
||||
|
||||
Note that requires Channels v4 if using with ``ChannelsLiveServerTestCase``.
|
||||
|
||||
* Dropped support for Python 3.6.
|
||||
|
||||
* Updated dependencies to the latest versions.
|
||||
|
||||
Previously a range of Twisted versions have been supported. Recent Twisted
|
||||
releases (22.2, 22.4) have issued security fixes, so those are now the
|
||||
minimum supported version. Given the stability of Twisted, supporting a
|
||||
range of versions does not represent a good use of maintainer time. Going
|
||||
forward the latest Twisted version will be required.
|
||||
|
||||
* Set ``daphne`` as default ``Server`` header.
|
||||
|
||||
This can be configured with the ``--server-name`` CLI argument.
|
||||
|
||||
Added the new ``--no-server-name`` CLI argument to disable the ``Server``
|
||||
header, which is equivalent to ``--server-name=` (an empty name).
|
||||
|
||||
* Added ``--log-fmt`` CLI argument.
|
||||
|
||||
* Added support for ``ASGI_THREADS`` environment variable, setting the maximum
|
||||
number of workers used by a ``SyncToAsync`` thread-pool executor.
|
||||
|
||||
Set e.g. ``ASGI_THREADS=4 daphne ...`` when running to limit the number of
|
||||
workers.
|
||||
|
||||
* Removed deprecated ``--ws_protocols`` CLI option.
|
||||
|
||||
3.0.2 (2021-04-07)
|
||||
------------------
|
||||
|
||||
* Fixed a bug where ``send`` passed to applications wasn't a true async
|
||||
function but a lambda wrapper, preventing it from being used with
|
||||
``asgiref.sync.async_to_sync()``.
|
||||
|
||||
|
||||
3.0.1 (2020-11-12)
|
||||
------------------
|
||||
|
||||
|
|
|
|||
|
|
@ -1,2 +1 @@
|
|||
include LICENSE
|
||||
recursive-include tests *.py
|
||||
12
README.rst
12
README.rst
|
|
@ -5,8 +5,8 @@ daphne
|
|||
:target: https://pypi.python.org/pypi/daphne
|
||||
|
||||
Daphne is a HTTP, HTTP2 and WebSocket protocol server for
|
||||
`ASGI <https://github.com/django/asgiref/blob/main/specs/asgi.rst>`_ and
|
||||
`ASGI-HTTP <https://github.com/django/asgiref/blob/main/specs/www.rst>`_,
|
||||
`ASGI <https://github.com/django/asgiref/blob/master/specs/asgi.rst>`_ and
|
||||
`ASGI-HTTP <https://github.com/django/asgiref/blob/master/specs/www.rst>`_,
|
||||
developed to power Django Channels.
|
||||
|
||||
It supports automatic negotiation of protocols; there's no need for URL
|
||||
|
|
@ -54,7 +54,7 @@ Daphne supports terminating HTTP/2 connections natively. You'll
|
|||
need to do a couple of things to get it working, though. First, you need to
|
||||
make sure you install the Twisted ``http2`` and ``tls`` extras::
|
||||
|
||||
pip install -U "Twisted[tls,http2]"
|
||||
pip install -U 'Twisted[tls,http2]'
|
||||
|
||||
Next, because all current browsers only support HTTP/2 when using TLS, you will
|
||||
need to start Daphne with TLS turned on, which can be done using the Twisted endpoint syntax::
|
||||
|
|
@ -108,14 +108,14 @@ should start with a slash, but not end with one; for example::
|
|||
Python Support
|
||||
--------------
|
||||
|
||||
Daphne requires Python 3.9 or later.
|
||||
Daphne requires Python 3.6 or later.
|
||||
|
||||
|
||||
Contributing
|
||||
------------
|
||||
|
||||
Please refer to the
|
||||
`main Channels contributing docs <https://github.com/django/channels/blob/main/CONTRIBUTING.rst>`_.
|
||||
`main Channels contributing docs <https://github.com/django/channels/blob/master/CONTRIBUTING.rst>`_.
|
||||
|
||||
To run tests, make sure you have installed the ``tests`` extra with the package::
|
||||
|
||||
|
|
@ -134,4 +134,4 @@ https://docs.djangoproject.com/en/dev/internals/security/.
|
|||
To report bugs or request new features, please open a new GitHub issue.
|
||||
|
||||
This repository is part of the Channels project. For the shepherd and maintenance team, please see the
|
||||
`main Channels readme <https://github.com/django/channels/blob/main/README.rst>`_.
|
||||
`main Channels readme <https://github.com/django/channels/blob/master/README.rst>`_.
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
import sys
|
||||
|
||||
__version__ = "4.1.3"
|
||||
__version__ = "3.0.1"
|
||||
|
||||
|
||||
# Windows on Python 3.8+ uses ProactorEventLoop, which is not compatible with
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
import datetime
|
||||
|
||||
|
||||
class AccessLogGenerator:
|
||||
class AccessLogGenerator(object):
|
||||
"""
|
||||
Object that implements the Daphne "action logger" internal interface in
|
||||
order to provide an access log in something resembling NCSA format.
|
||||
|
|
|
|||
|
|
@ -1,16 +0,0 @@
|
|||
# Import the server here to ensure the reactor is installed very early on in case other
|
||||
# packages import twisted.internet.reactor (e.g. raven does this).
|
||||
from django.apps import AppConfig
|
||||
from django.core import checks
|
||||
|
||||
import daphne.server # noqa: F401
|
||||
|
||||
from .checks import check_daphne_installed
|
||||
|
||||
|
||||
class DaphneConfig(AppConfig):
|
||||
name = "daphne"
|
||||
verbose_name = "Daphne"
|
||||
|
||||
def ready(self):
|
||||
checks.register(check_daphne_installed, checks.Tags.staticfiles)
|
||||
|
|
@ -1,21 +0,0 @@
|
|||
# Django system check to ensure daphne app is listed in INSTALLED_APPS before django.contrib.staticfiles.
|
||||
from django.core.checks import Error, register
|
||||
|
||||
|
||||
@register()
|
||||
def check_daphne_installed(app_configs, **kwargs):
|
||||
from django.apps import apps
|
||||
from django.contrib.staticfiles.apps import StaticFilesConfig
|
||||
|
||||
from daphne.apps import DaphneConfig
|
||||
|
||||
for app in apps.get_app_configs():
|
||||
if isinstance(app, DaphneConfig):
|
||||
return []
|
||||
if isinstance(app, StaticFilesConfig):
|
||||
return [
|
||||
Error(
|
||||
"Daphne must be listed before django.contrib.staticfiles in INSTALLED_APPS.",
|
||||
id="daphne.E001",
|
||||
)
|
||||
]
|
||||
|
|
@ -16,7 +16,7 @@ DEFAULT_HOST = "127.0.0.1"
|
|||
DEFAULT_PORT = 8000
|
||||
|
||||
|
||||
class CommandLineInterface:
|
||||
class CommandLineInterface(object):
|
||||
"""
|
||||
Acts as the main CLI entry point for running the server.
|
||||
"""
|
||||
|
|
@ -90,11 +90,6 @@ class CommandLineInterface:
|
|||
help="Where to write the access log (- for stdout, the default for verbosity=1)",
|
||||
default=None,
|
||||
)
|
||||
self.parser.add_argument(
|
||||
"--log-fmt",
|
||||
help="Log format to use",
|
||||
default="%(asctime)-15s %(levelname)-8s %(message)s",
|
||||
)
|
||||
self.parser.add_argument(
|
||||
"--ping-interval",
|
||||
type=int,
|
||||
|
|
@ -113,6 +108,13 @@ class CommandLineInterface:
|
|||
help="The number of seconds an ASGI application has to exit after client disconnect before it is killed",
|
||||
default=10,
|
||||
)
|
||||
self.parser.add_argument(
|
||||
"--ws-protocol",
|
||||
nargs="*",
|
||||
dest="ws_protocols",
|
||||
help="The WebSocket protocols you wish to support",
|
||||
default=None,
|
||||
)
|
||||
self.parser.add_argument(
|
||||
"--root-path",
|
||||
dest="root_path",
|
||||
|
|
@ -155,10 +157,7 @@ class CommandLineInterface:
|
|||
"--server-name",
|
||||
dest="server_name",
|
||||
help="specify which value should be passed to response header Server attribute",
|
||||
default="daphne",
|
||||
)
|
||||
self.parser.add_argument(
|
||||
"--no-server-name", dest="server_name", action="store_const", const=""
|
||||
default="Daphne",
|
||||
)
|
||||
|
||||
self.server = None
|
||||
|
|
@ -216,7 +215,7 @@ class CommandLineInterface:
|
|||
2: logging.DEBUG,
|
||||
3: logging.DEBUG, # Also turns on asyncio debug
|
||||
}[args.verbosity],
|
||||
format=args.log_fmt,
|
||||
format="%(asctime)-15s %(levelname)-8s %(message)s",
|
||||
)
|
||||
# If verbosity is 1 or greater, or they told us explicitly, set up access log
|
||||
access_log_stream = None
|
||||
|
|
@ -259,7 +258,7 @@ class CommandLineInterface:
|
|||
)
|
||||
endpoints = sorted(args.socket_strings + endpoints)
|
||||
# Start the server
|
||||
logger.info("Starting server at {}".format(", ".join(endpoints)))
|
||||
logger.info("Starting server at %s" % (", ".join(endpoints),))
|
||||
self.server = self.server_class(
|
||||
application=application,
|
||||
endpoints=endpoints,
|
||||
|
|
@ -270,16 +269,17 @@ class CommandLineInterface:
|
|||
websocket_connect_timeout=args.websocket_connect_timeout,
|
||||
websocket_handshake_timeout=args.websocket_connect_timeout,
|
||||
application_close_timeout=args.application_close_timeout,
|
||||
action_logger=(
|
||||
AccessLogGenerator(access_log_stream) if access_log_stream else None
|
||||
),
|
||||
action_logger=AccessLogGenerator(access_log_stream)
|
||||
if access_log_stream
|
||||
else None,
|
||||
ws_protocols=args.ws_protocols,
|
||||
root_path=args.root_path,
|
||||
verbosity=args.verbosity,
|
||||
proxy_forwarded_address_header=self._get_forwarded_host(args=args),
|
||||
proxy_forwarded_port_header=self._get_forwarded_port(args=args),
|
||||
proxy_forwarded_proto_header=(
|
||||
"X-Forwarded-Proto" if args.proxy_headers else None
|
||||
),
|
||||
proxy_forwarded_proto_header="X-Forwarded-Proto"
|
||||
if args.proxy_headers
|
||||
else None,
|
||||
server_name=args.server_name,
|
||||
)
|
||||
self.server.run()
|
||||
|
|
|
|||
|
|
@ -9,7 +9,7 @@ from twisted.protocols.policies import ProtocolWrapper
|
|||
from twisted.web import http
|
||||
from zope.interface import implementer
|
||||
|
||||
from .utils import HEADER_NAME_RE, parse_x_forwarded_for
|
||||
from .utils import parse_x_forwarded_for
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
|
@ -50,8 +50,6 @@ class WebRequest(http.Request):
|
|||
) # Shorten it a bit, bytes wise
|
||||
|
||||
def __init__(self, *args, **kwargs):
|
||||
self.client_addr = None
|
||||
self.server_addr = None
|
||||
try:
|
||||
http.Request.__init__(self, *args, **kwargs)
|
||||
# Easy server link
|
||||
|
|
@ -69,13 +67,6 @@ class WebRequest(http.Request):
|
|||
def process(self):
|
||||
try:
|
||||
self.request_start = time.time()
|
||||
|
||||
# Validate header names.
|
||||
for name, _ in self.requestHeaders.getAllRawHeaders():
|
||||
if not HEADER_NAME_RE.fullmatch(name):
|
||||
self.basic_error(400, b"Bad Request", "Invalid header name")
|
||||
return
|
||||
|
||||
# Get upgrade header
|
||||
upgrade_header = None
|
||||
if self.requestHeaders.hasHeader(b"Upgrade"):
|
||||
|
|
@ -86,6 +77,9 @@ class WebRequest(http.Request):
|
|||
# requires unicode string.
|
||||
self.client_addr = [str(self.client.host), self.client.port]
|
||||
self.server_addr = [str(self.host.host), self.host.port]
|
||||
else:
|
||||
self.client_addr = None
|
||||
self.server_addr = None
|
||||
|
||||
self.client_scheme = "https" if self.isSecure() else "http"
|
||||
|
||||
|
|
@ -256,8 +250,8 @@ class WebRequest(http.Request):
|
|||
# Write headers
|
||||
for header, value in message.get("headers", {}):
|
||||
self.responseHeaders.addRawHeader(header, value)
|
||||
if self.server.server_name and not self.responseHeaders.hasHeader("server"):
|
||||
self.setHeader(b"server", self.server.server_name.encode())
|
||||
if self.server.server_name and self.server.server_name.lower() != "daphne":
|
||||
self.setHeader(b"server", self.server.server_name.encode("utf-8"))
|
||||
logger.debug(
|
||||
"HTTP %s response started for %s", message["status"], self.client_addr
|
||||
)
|
||||
|
|
@ -286,11 +280,9 @@ class WebRequest(http.Request):
|
|||
"path": uri,
|
||||
"status": self.code,
|
||||
"method": self.method.decode("ascii", "replace"),
|
||||
"client": (
|
||||
"%s:%s" % tuple(self.client_addr)
|
||||
"client": "%s:%s" % tuple(self.client_addr)
|
||||
if self.client_addr
|
||||
else None
|
||||
),
|
||||
else None,
|
||||
"time_taken": self.duration(),
|
||||
"size": self.sentLength,
|
||||
},
|
||||
|
|
|
|||
|
|
@ -1,203 +0,0 @@
|
|||
import datetime
|
||||
import importlib
|
||||
import logging
|
||||
import sys
|
||||
|
||||
from django.apps import apps
|
||||
from django.conf import settings
|
||||
from django.contrib.staticfiles.handlers import ASGIStaticFilesHandler
|
||||
from django.core.exceptions import ImproperlyConfigured
|
||||
from django.core.management import CommandError
|
||||
from django.core.management.commands.runserver import Command as RunserverCommand
|
||||
|
||||
from daphne import __version__
|
||||
from daphne.endpoints import build_endpoint_description_strings
|
||||
from daphne.server import Server
|
||||
|
||||
logger = logging.getLogger("django.channels.server")
|
||||
|
||||
|
||||
def get_default_application():
|
||||
"""
|
||||
Gets the default application, set in the ASGI_APPLICATION setting.
|
||||
"""
|
||||
try:
|
||||
path, name = settings.ASGI_APPLICATION.rsplit(".", 1)
|
||||
except (ValueError, AttributeError):
|
||||
raise ImproperlyConfigured("Cannot find ASGI_APPLICATION setting.")
|
||||
try:
|
||||
module = importlib.import_module(path)
|
||||
except ImportError:
|
||||
raise ImproperlyConfigured("Cannot import ASGI_APPLICATION module %r" % path)
|
||||
try:
|
||||
value = getattr(module, name)
|
||||
except AttributeError:
|
||||
raise ImproperlyConfigured(
|
||||
f"Cannot find {name!r} in ASGI_APPLICATION module {path}"
|
||||
)
|
||||
return value
|
||||
|
||||
|
||||
class Command(RunserverCommand):
|
||||
protocol = "http"
|
||||
server_cls = Server
|
||||
|
||||
def add_arguments(self, parser):
|
||||
super().add_arguments(parser)
|
||||
parser.add_argument(
|
||||
"--noasgi",
|
||||
action="store_false",
|
||||
dest="use_asgi",
|
||||
default=True,
|
||||
help="Run the old WSGI-based runserver rather than the ASGI-based one",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--http_timeout",
|
||||
action="store",
|
||||
dest="http_timeout",
|
||||
type=int,
|
||||
default=None,
|
||||
help=(
|
||||
"Specify the daphne http_timeout interval in seconds "
|
||||
"(default: no timeout)"
|
||||
),
|
||||
)
|
||||
parser.add_argument(
|
||||
"--websocket_handshake_timeout",
|
||||
action="store",
|
||||
dest="websocket_handshake_timeout",
|
||||
type=int,
|
||||
default=5,
|
||||
help=(
|
||||
"Specify the daphne websocket_handshake_timeout interval in "
|
||||
"seconds (default: 5)"
|
||||
),
|
||||
)
|
||||
parser.add_argument(
|
||||
"--nostatic",
|
||||
action="store_false",
|
||||
dest="use_static_handler",
|
||||
help="Tells Django to NOT automatically serve static files at STATIC_URL.",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--insecure",
|
||||
action="store_true",
|
||||
dest="insecure_serving",
|
||||
help="Allows serving static files even if DEBUG is False.",
|
||||
)
|
||||
|
||||
def handle(self, *args, **options):
|
||||
self.http_timeout = options.get("http_timeout", None)
|
||||
self.websocket_handshake_timeout = options.get("websocket_handshake_timeout", 5)
|
||||
# Check Channels is installed right
|
||||
if options["use_asgi"] and not hasattr(settings, "ASGI_APPLICATION"):
|
||||
raise CommandError(
|
||||
"You have not set ASGI_APPLICATION, which is needed to run the server."
|
||||
)
|
||||
# Dispatch upward
|
||||
super().handle(*args, **options)
|
||||
|
||||
def inner_run(self, *args, **options):
|
||||
# Maybe they want the wsgi one?
|
||||
if not options.get("use_asgi", True):
|
||||
if hasattr(RunserverCommand, "server_cls"):
|
||||
self.server_cls = RunserverCommand.server_cls
|
||||
return RunserverCommand.inner_run(self, *args, **options)
|
||||
# Run checks
|
||||
self.stdout.write("Performing system checks...\n\n")
|
||||
self.check(display_num_errors=True)
|
||||
self.check_migrations()
|
||||
# Print helpful text
|
||||
quit_command = "CTRL-BREAK" if sys.platform == "win32" else "CONTROL-C"
|
||||
now = datetime.datetime.now().strftime("%B %d, %Y - %X")
|
||||
self.stdout.write(now)
|
||||
self.stdout.write(
|
||||
(
|
||||
"Django version %(version)s, using settings %(settings)r\n"
|
||||
"Starting ASGI/Daphne version %(daphne_version)s development server"
|
||||
" at %(protocol)s://%(addr)s:%(port)s/\n"
|
||||
"Quit the server with %(quit_command)s.\n"
|
||||
)
|
||||
% {
|
||||
"version": self.get_version(),
|
||||
"daphne_version": __version__,
|
||||
"settings": settings.SETTINGS_MODULE,
|
||||
"protocol": self.protocol,
|
||||
"addr": "[%s]" % self.addr if self._raw_ipv6 else self.addr,
|
||||
"port": self.port,
|
||||
"quit_command": quit_command,
|
||||
}
|
||||
)
|
||||
|
||||
# Launch server in 'main' thread. Signals are disabled as it's still
|
||||
# actually a subthread under the autoreloader.
|
||||
logger.debug("Daphne running, listening on %s:%s", self.addr, self.port)
|
||||
|
||||
# build the endpoint description string from host/port options
|
||||
endpoints = build_endpoint_description_strings(host=self.addr, port=self.port)
|
||||
try:
|
||||
self.server_cls(
|
||||
application=self.get_application(options),
|
||||
endpoints=endpoints,
|
||||
signal_handlers=not options["use_reloader"],
|
||||
action_logger=self.log_action,
|
||||
http_timeout=self.http_timeout,
|
||||
root_path=getattr(settings, "FORCE_SCRIPT_NAME", "") or "",
|
||||
websocket_handshake_timeout=self.websocket_handshake_timeout,
|
||||
).run()
|
||||
logger.debug("Daphne exited")
|
||||
except KeyboardInterrupt:
|
||||
shutdown_message = options.get("shutdown_message", "")
|
||||
if shutdown_message:
|
||||
self.stdout.write(shutdown_message)
|
||||
return
|
||||
|
||||
def get_application(self, options):
|
||||
"""
|
||||
Returns the static files serving application wrapping the default application,
|
||||
if static files should be served. Otherwise just returns the default
|
||||
handler.
|
||||
"""
|
||||
staticfiles_installed = apps.is_installed("django.contrib.staticfiles")
|
||||
use_static_handler = options.get("use_static_handler", staticfiles_installed)
|
||||
insecure_serving = options.get("insecure_serving", False)
|
||||
if use_static_handler and (settings.DEBUG or insecure_serving):
|
||||
return ASGIStaticFilesHandler(get_default_application())
|
||||
else:
|
||||
return get_default_application()
|
||||
|
||||
def log_action(self, protocol, action, details):
|
||||
"""
|
||||
Logs various different kinds of requests to the console.
|
||||
"""
|
||||
# HTTP requests
|
||||
if protocol == "http" and action == "complete":
|
||||
msg = "HTTP %(method)s %(path)s %(status)s [%(time_taken).2f, %(client)s]"
|
||||
|
||||
# Utilize terminal colors, if available
|
||||
if 200 <= details["status"] < 300:
|
||||
# Put 2XX first, since it should be the common case
|
||||
logger.info(self.style.HTTP_SUCCESS(msg), details)
|
||||
elif 100 <= details["status"] < 200:
|
||||
logger.info(self.style.HTTP_INFO(msg), details)
|
||||
elif details["status"] == 304:
|
||||
logger.info(self.style.HTTP_NOT_MODIFIED(msg), details)
|
||||
elif 300 <= details["status"] < 400:
|
||||
logger.info(self.style.HTTP_REDIRECT(msg), details)
|
||||
elif details["status"] == 404:
|
||||
logger.warning(self.style.HTTP_NOT_FOUND(msg), details)
|
||||
elif 400 <= details["status"] < 500:
|
||||
logger.warning(self.style.HTTP_BAD_REQUEST(msg), details)
|
||||
else:
|
||||
# Any 5XX, or any other response
|
||||
logger.error(self.style.HTTP_SERVER_ERROR(msg), details)
|
||||
|
||||
# Websocket requests
|
||||
elif protocol == "websocket" and action == "connected":
|
||||
logger.info("WebSocket CONNECT %(path)s [%(client)s]", details)
|
||||
elif protocol == "websocket" and action == "disconnected":
|
||||
logger.info("WebSocket DISCONNECT %(path)s [%(client)s]", details)
|
||||
elif protocol == "websocket" and action == "connecting":
|
||||
logger.info("WebSocket HANDSHAKING %(path)s [%(client)s]", details)
|
||||
elif protocol == "websocket" and action == "rejected":
|
||||
logger.info("WebSocket REJECT %(path)s [%(client)s]", details)
|
||||
|
|
@ -1,18 +1,10 @@
|
|||
# This has to be done first as Twisted is import-order-sensitive with reactors
|
||||
import asyncio # isort:skip
|
||||
import os # isort:skip
|
||||
import sys # isort:skip
|
||||
import warnings # isort:skip
|
||||
from concurrent.futures import ThreadPoolExecutor # isort:skip
|
||||
from twisted.internet import asyncioreactor # isort:skip
|
||||
|
||||
|
||||
twisted_loop = asyncio.new_event_loop()
|
||||
if "ASGI_THREADS" in os.environ:
|
||||
twisted_loop.set_default_executor(
|
||||
ThreadPoolExecutor(max_workers=int(os.environ["ASGI_THREADS"]))
|
||||
)
|
||||
|
||||
current_reactor = sys.modules.get("twisted.internet.reactor", None)
|
||||
if current_reactor is not None:
|
||||
if not isinstance(current_reactor, asyncioreactor.AsyncioSelectorReactor):
|
||||
|
|
@ -21,7 +13,6 @@ if current_reactor is not None:
|
|||
+ "you can fix this warning by importing daphne.server early in your codebase or "
|
||||
+ "finding the package that imports Twisted and importing it later on.",
|
||||
UserWarning,
|
||||
stacklevel=2,
|
||||
)
|
||||
del sys.modules["twisted.internet.reactor"]
|
||||
asyncioreactor.install(twisted_loop)
|
||||
|
|
@ -31,7 +22,6 @@ else:
|
|||
import logging
|
||||
import time
|
||||
from concurrent.futures import CancelledError
|
||||
from functools import partial
|
||||
|
||||
from twisted.internet import defer, reactor
|
||||
from twisted.internet.endpoints import serverFromString
|
||||
|
|
@ -44,7 +34,7 @@ from .ws_protocol import WebSocketFactory
|
|||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
class Server:
|
||||
class Server(object):
|
||||
def __init__(
|
||||
self,
|
||||
application,
|
||||
|
|
@ -65,7 +55,9 @@ class Server:
|
|||
websocket_handshake_timeout=5,
|
||||
application_close_timeout=10,
|
||||
ready_callable=None,
|
||||
server_name="daphne",
|
||||
server_name="Daphne",
|
||||
# Deprecated and does not work, remove in version 2.2
|
||||
ws_protocols=None,
|
||||
):
|
||||
self.application = application
|
||||
self.endpoints = endpoints or []
|
||||
|
|
@ -211,7 +203,7 @@ class Server:
|
|||
application_instance = self.application(
|
||||
scope=scope,
|
||||
receive=input_queue.get,
|
||||
send=partial(self.handle_reply, protocol),
|
||||
send=lambda message: self.handle_reply(protocol, message),
|
||||
)
|
||||
# Run it, and stash the future for later checking
|
||||
if protocol not in self.connections:
|
||||
|
|
|
|||
|
|
@ -26,9 +26,6 @@ class BaseDaphneTestingInstance:
|
|||
self.request_buffer_size = request_buffer_size
|
||||
self.application = application
|
||||
|
||||
def get_application(self):
|
||||
return self.application
|
||||
|
||||
def __enter__(self):
|
||||
# Option Daphne features
|
||||
kwargs = {}
|
||||
|
|
@ -44,7 +41,7 @@ class BaseDaphneTestingInstance:
|
|||
# Start up process
|
||||
self.process = DaphneProcess(
|
||||
host=self.host,
|
||||
get_application=self.get_application,
|
||||
application=self.application,
|
||||
kwargs=kwargs,
|
||||
setup=self.process_setup,
|
||||
teardown=self.process_teardown,
|
||||
|
|
@ -126,13 +123,13 @@ class DaphneProcess(multiprocessing.Process):
|
|||
port it ends up listening on back to the parent process.
|
||||
"""
|
||||
|
||||
def __init__(self, host, get_application, kwargs=None, setup=None, teardown=None):
|
||||
def __init__(self, host, application, kwargs=None, setup=None, teardown=None):
|
||||
super().__init__()
|
||||
self.host = host
|
||||
self.get_application = get_application
|
||||
self.application = application
|
||||
self.kwargs = kwargs or {}
|
||||
self.setup = setup
|
||||
self.teardown = teardown
|
||||
self.setup = setup or (lambda: None)
|
||||
self.teardown = teardown or (lambda: None)
|
||||
self.port = multiprocessing.Value("i")
|
||||
self.ready = multiprocessing.Event()
|
||||
self.errors = multiprocessing.Queue()
|
||||
|
|
@ -149,26 +146,22 @@ class DaphneProcess(multiprocessing.Process):
|
|||
from .endpoints import build_endpoint_description_strings
|
||||
from .server import Server
|
||||
|
||||
application = self.get_application()
|
||||
|
||||
try:
|
||||
# Create the server class
|
||||
endpoints = build_endpoint_description_strings(host=self.host, port=0)
|
||||
self.server = Server(
|
||||
application=application,
|
||||
application=self.application,
|
||||
endpoints=endpoints,
|
||||
signal_handlers=False,
|
||||
**self.kwargs,
|
||||
**self.kwargs
|
||||
)
|
||||
# Set up a poller to look for the port
|
||||
reactor.callLater(0.1, self.resolve_port)
|
||||
# Run with setup/teardown
|
||||
if self.setup is not None:
|
||||
self.setup()
|
||||
try:
|
||||
self.server.run()
|
||||
finally:
|
||||
if self.teardown is not None:
|
||||
self.teardown()
|
||||
except BaseException as e:
|
||||
# Put the error on our queue so the parent gets it
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@ from zope.interface import implementer
|
|||
|
||||
|
||||
@implementer(IPlugin, IStreamServerEndpointStringParser)
|
||||
class _FDParser:
|
||||
class _FDParser(object):
|
||||
prefix = "fd"
|
||||
|
||||
def _parseServer(self, reactor, fileno, domain=socket.AF_INET):
|
||||
|
|
|
|||
|
|
@ -1,12 +1,7 @@
|
|||
import importlib
|
||||
import re
|
||||
|
||||
from twisted.web.http_headers import Headers
|
||||
|
||||
# Header name regex as per h11.
|
||||
# https://github.com/python-hyper/h11/blob/a2c68948accadc3876dffcf979d98002e4a4ed27/h11/_abnf.py#L10-L21
|
||||
HEADER_NAME_RE = re.compile(rb"[-!#$%&'*+.^_`|~0-9a-zA-Z]+")
|
||||
|
||||
|
||||
def import_by_path(path):
|
||||
"""
|
||||
|
|
|
|||
|
|
@ -31,20 +31,16 @@ class WebSocketProtocol(WebSocketServerProtocol):
|
|||
self.server.protocol_connected(self)
|
||||
self.request = request
|
||||
self.protocol_to_accept = None
|
||||
self.root_path = self.server.root_path
|
||||
self.socket_opened = time.time()
|
||||
self.last_ping = time.time()
|
||||
try:
|
||||
# Sanitize and decode headers, potentially extracting root path
|
||||
# Sanitize and decode headers
|
||||
self.clean_headers = []
|
||||
for name, value in request.headers.items():
|
||||
name = name.encode("ascii")
|
||||
# Prevent CVE-2015-0219
|
||||
if b"_" in name:
|
||||
continue
|
||||
if name.lower() == b"daphne-root-path":
|
||||
self.root_path = unquote(value)
|
||||
else:
|
||||
self.clean_headers.append((name.lower(), value.encode("latin1")))
|
||||
# Get client address if possible
|
||||
peer = self.transport.getPeer()
|
||||
|
|
@ -80,7 +76,6 @@ class WebSocketProtocol(WebSocketServerProtocol):
|
|||
"type": "websocket",
|
||||
"path": unquote(self.path.decode("ascii")),
|
||||
"raw_path": self.path,
|
||||
"root_path": self.root_path,
|
||||
"headers": self.clean_headers,
|
||||
"query_string": self._raw_query_string, # Passed by HTTP protocol
|
||||
"client": self.client_addr,
|
||||
|
|
@ -115,9 +110,9 @@ class WebSocketProtocol(WebSocketServerProtocol):
|
|||
"connecting",
|
||||
{
|
||||
"path": self.request.path,
|
||||
"client": (
|
||||
"%s:%s" % tuple(self.client_addr) if self.client_addr else None
|
||||
),
|
||||
"client": "%s:%s" % tuple(self.client_addr)
|
||||
if self.client_addr
|
||||
else None,
|
||||
},
|
||||
)
|
||||
|
||||
|
|
@ -138,9 +133,9 @@ class WebSocketProtocol(WebSocketServerProtocol):
|
|||
"connected",
|
||||
{
|
||||
"path": self.request.path,
|
||||
"client": (
|
||||
"%s:%s" % tuple(self.client_addr) if self.client_addr else None
|
||||
),
|
||||
"client": "%s:%s" % tuple(self.client_addr)
|
||||
if self.client_addr
|
||||
else None,
|
||||
},
|
||||
)
|
||||
|
||||
|
|
@ -175,9 +170,9 @@ class WebSocketProtocol(WebSocketServerProtocol):
|
|||
"disconnected",
|
||||
{
|
||||
"path": self.request.path,
|
||||
"client": (
|
||||
"%s:%s" % tuple(self.client_addr) if self.client_addr else None
|
||||
),
|
||||
"client": "%s:%s" % tuple(self.client_addr)
|
||||
if self.client_addr
|
||||
else None,
|
||||
},
|
||||
)
|
||||
|
||||
|
|
@ -242,9 +237,9 @@ class WebSocketProtocol(WebSocketServerProtocol):
|
|||
"rejected",
|
||||
{
|
||||
"path": self.request.path,
|
||||
"client": (
|
||||
"%s:%s" % tuple(self.client_addr) if self.client_addr else None
|
||||
),
|
||||
"client": "%s:%s" % tuple(self.client_addr)
|
||||
if self.client_addr
|
||||
else None,
|
||||
},
|
||||
)
|
||||
|
||||
|
|
@ -302,7 +297,7 @@ class WebSocketProtocol(WebSocketServerProtocol):
|
|||
return id(self) == id(other)
|
||||
|
||||
def __repr__(self):
|
||||
return f"<WebSocketProtocol client={self.client_addr!r} path={self.path!r}>"
|
||||
return "<WebSocketProtocol client=%r path=%r>" % (self.client_addr, self.path)
|
||||
|
||||
|
||||
class WebSocketFactory(WebSocketServerFactory):
|
||||
|
|
@ -323,7 +318,7 @@ class WebSocketFactory(WebSocketServerFactory):
|
|||
Builds protocol instances. We use this to inject the factory object into the protocol.
|
||||
"""
|
||||
try:
|
||||
protocol = super().buildProtocol(addr)
|
||||
protocol = super(WebSocketFactory, self).buildProtocol(addr)
|
||||
protocol.factory = self
|
||||
return protocol
|
||||
except Exception:
|
||||
|
|
|
|||
|
|
@ -1,81 +0,0 @@
|
|||
[project]
|
||||
name = "daphne"
|
||||
dynamic = ["version"]
|
||||
description = "Django ASGI (HTTP/WebSocket) server"
|
||||
requires-python = ">=3.9"
|
||||
authors = [
|
||||
{ name = "Django Software Foundation", email = "foundation@djangoproject.com" },
|
||||
]
|
||||
|
||||
license = { text = "BSD" }
|
||||
classifiers = [
|
||||
"Development Status :: 4 - Beta",
|
||||
"Environment :: Web Environment",
|
||||
"Intended Audience :: Developers",
|
||||
"License :: OSI Approved :: BSD License",
|
||||
"Operating System :: OS Independent",
|
||||
"Programming Language :: Python",
|
||||
"Programming Language :: Python :: 3",
|
||||
"Programming Language :: Python :: 3.9",
|
||||
"Programming Language :: Python :: 3.10",
|
||||
"Programming Language :: Python :: 3.11",
|
||||
"Programming Language :: Python :: 3.12",
|
||||
"Programming Language :: Python :: 3.13",
|
||||
"Topic :: Internet :: WWW/HTTP",
|
||||
]
|
||||
|
||||
dependencies = ["asgiref>=3.5.2,<4", "autobahn>=22.4.2", "twisted[tls]>=22.4"]
|
||||
|
||||
[project.optional-dependencies]
|
||||
tests = [
|
||||
"django",
|
||||
"hypothesis",
|
||||
"pytest",
|
||||
"pytest-asyncio",
|
||||
"pytest-cov",
|
||||
"black",
|
||||
"tox",
|
||||
"flake8",
|
||||
"flake8-bugbear",
|
||||
"mypy",
|
||||
]
|
||||
|
||||
[project.urls]
|
||||
homepage = "https://github.com/django/daphne"
|
||||
documentation = "https://channels.readthedocs.io"
|
||||
repository = "https://github.com/django/daphne.git"
|
||||
changelog = "https://github.com/django/daphne/blob/main/CHANGELOG.txt"
|
||||
issues = "https://github.com/django/daphne/issues"
|
||||
|
||||
[project.scripts]
|
||||
daphne = "daphne.cli:CommandLineInterface.entrypoint"
|
||||
|
||||
[build-system]
|
||||
requires = ["setuptools"]
|
||||
build-backend = "setuptools.build_meta"
|
||||
|
||||
[tool.setuptools]
|
||||
packages = ["daphne"]
|
||||
|
||||
[tool.setuptools.dynamic]
|
||||
version = { attr = "daphne.__version__" }
|
||||
readme = { file = "README.rst", content-type = "text/x-rst" }
|
||||
|
||||
[tool.isort]
|
||||
profile = "black"
|
||||
|
||||
[tool.pytest]
|
||||
testpaths = ["tests"]
|
||||
asyncio_mode = "strict"
|
||||
filterwarnings = ["ignore::pytest.PytestDeprecationWarning"]
|
||||
|
||||
[tool.coverage.run]
|
||||
omit = ["tests/*"]
|
||||
concurrency = ["multiprocessing"]
|
||||
|
||||
[tool.coverage.report]
|
||||
show_missing = "true"
|
||||
skip_covered = "true"
|
||||
|
||||
[tool.coverage.html]
|
||||
directory = "reports/coverage_html_report"
|
||||
10
setup.cfg
Normal file
10
setup.cfg
Normal file
|
|
@ -0,0 +1,10 @@
|
|||
[flake8]
|
||||
exclude = venv/*,tox/*,docs/*,testproject/*,js_client/*,.eggs/*
|
||||
extend-ignore = E123, E128, E266, E402, W503, E731, W601
|
||||
max-line-length = 120
|
||||
|
||||
[isort]
|
||||
profile = black
|
||||
|
||||
[tool:pytest]
|
||||
testpaths = tests
|
||||
48
setup.py
Executable file
48
setup.py
Executable file
|
|
@ -0,0 +1,48 @@
|
|||
import os
|
||||
|
||||
from setuptools import find_packages, setup
|
||||
|
||||
from daphne import __version__
|
||||
|
||||
# We use the README as the long_description
|
||||
readme_path = os.path.join(os.path.dirname(__file__), "README.rst")
|
||||
with open(readme_path) as fp:
|
||||
long_description = fp.read()
|
||||
|
||||
setup(
|
||||
name="daphne",
|
||||
version=__version__,
|
||||
url="https://github.com/django/daphne",
|
||||
author="Django Software Foundation",
|
||||
author_email="foundation@djangoproject.com",
|
||||
description="Django ASGI (HTTP/WebSocket) server",
|
||||
long_description=long_description,
|
||||
license="BSD",
|
||||
zip_safe=False,
|
||||
package_dir={"twisted": "daphne/twisted"},
|
||||
packages=find_packages() + ["twisted.plugins"],
|
||||
include_package_data=True,
|
||||
install_requires=["twisted[tls]>=18.7", "autobahn>=0.18", "asgiref>=3.2.10,<4"],
|
||||
python_requires='>=3.6',
|
||||
setup_requires=["pytest-runner"],
|
||||
extras_require={
|
||||
"tests": ["hypothesis==4.23", "pytest~=3.10", "pytest-asyncio~=0.8"]
|
||||
},
|
||||
entry_points={
|
||||
"console_scripts": ["daphne = daphne.cli:CommandLineInterface.entrypoint"]
|
||||
},
|
||||
classifiers=[
|
||||
"Development Status :: 4 - Beta",
|
||||
"Environment :: Web Environment",
|
||||
"Intended Audience :: Developers",
|
||||
"License :: OSI Approved :: BSD License",
|
||||
"Operating System :: OS Independent",
|
||||
"Programming Language :: Python",
|
||||
"Programming Language :: Python :: 3",
|
||||
"Programming Language :: Python :: 3.6",
|
||||
"Programming Language :: Python :: 3.7",
|
||||
"Programming Language :: Python :: 3.8",
|
||||
"Programming Language :: Python :: 3.9",
|
||||
"Topic :: Internet :: WWW/HTTP",
|
||||
],
|
||||
)
|
||||
|
|
@ -182,7 +182,7 @@ class DaphneTestCase(unittest.TestCase):
|
|||
if response.status != 101:
|
||||
raise RuntimeError("WebSocket upgrade did not result in status code 101")
|
||||
# Prepare headers for subprotocol searching
|
||||
response_headers = {n.lower(): v for n, v in response.getheaders()}
|
||||
response_headers = dict((n.lower(), v) for n, v in response.getheaders())
|
||||
response.read()
|
||||
assert not response.closed
|
||||
# Return the raw socket and any subprotocol
|
||||
|
|
@ -252,7 +252,7 @@ class DaphneTestCase(unittest.TestCase):
|
|||
"""
|
||||
try:
|
||||
socket.inet_aton(address)
|
||||
except OSError:
|
||||
except socket.error:
|
||||
self.fail("'%s' is not a valid IP address." % address)
|
||||
|
||||
def assert_key_sets(self, required_keys, optional_keys, actual_keys):
|
||||
|
|
|
|||
|
|
@ -1,21 +0,0 @@
|
|||
import django
|
||||
from django.conf import settings
|
||||
from django.test.utils import override_settings
|
||||
|
||||
from daphne.checks import check_daphne_installed
|
||||
|
||||
|
||||
def test_check_daphne_installed():
|
||||
"""
|
||||
Test check error is raised if daphne is not listed before staticfiles, and vice versa.
|
||||
"""
|
||||
settings.configure(
|
||||
INSTALLED_APPS=["daphne.apps.DaphneConfig", "django.contrib.staticfiles"]
|
||||
)
|
||||
django.setup()
|
||||
errors = check_daphne_installed(None)
|
||||
assert len(errors) == 0
|
||||
with override_settings(INSTALLED_APPS=["django.contrib.staticfiles", "daphne"]):
|
||||
errors = check_daphne_installed(None)
|
||||
assert len(errors) == 1
|
||||
assert errors[0].id == "daphne.E001"
|
||||
|
|
@ -1,7 +1,8 @@
|
|||
# coding: utf8
|
||||
|
||||
import logging
|
||||
import os
|
||||
from argparse import ArgumentError
|
||||
from unittest import TestCase, skipUnless
|
||||
from unittest import TestCase
|
||||
|
||||
from daphne.cli import CommandLineInterface
|
||||
from daphne.endpoints import build_endpoint_description_strings as build
|
||||
|
|
@ -241,27 +242,3 @@ class TestCLIInterface(TestCase):
|
|||
exc.exception.message,
|
||||
"--proxy-headers has to be passed for this parameter.",
|
||||
)
|
||||
|
||||
def test_custom_servername(self):
|
||||
"""
|
||||
Passing `--server-name` will set the default server header
|
||||
from 'daphne' to the passed one.
|
||||
"""
|
||||
self.assertCLI([], {"server_name": "daphne"})
|
||||
self.assertCLI(["--server-name", ""], {"server_name": ""})
|
||||
self.assertCLI(["--server-name", "python"], {"server_name": "python"})
|
||||
|
||||
def test_no_servername(self):
|
||||
"""
|
||||
Passing `--no-server-name` will set server name to '' (empty string)
|
||||
"""
|
||||
self.assertCLI(["--no-server-name"], {"server_name": ""})
|
||||
|
||||
|
||||
@skipUnless(os.getenv("ASGI_THREADS"), "ASGI_THREADS environment variable not set.")
|
||||
class TestASGIThreads(TestCase):
|
||||
def test_default_executor(self):
|
||||
from daphne.server import twisted_loop
|
||||
|
||||
executor = twisted_loop._default_executor
|
||||
self.assertEqual(executor._max_workers, int(os.getenv("ASGI_THREADS")))
|
||||
|
|
|
|||
|
|
@ -1,49 +0,0 @@
|
|||
import unittest
|
||||
|
||||
from daphne.http_protocol import WebRequest
|
||||
|
||||
|
||||
class MockServer:
|
||||
"""
|
||||
Mock server object for testing.
|
||||
"""
|
||||
|
||||
def protocol_connected(self, *args, **kwargs):
|
||||
pass
|
||||
|
||||
|
||||
class MockFactory:
|
||||
"""
|
||||
Mock factory object for testing.
|
||||
"""
|
||||
|
||||
def __init__(self):
|
||||
self.server = MockServer()
|
||||
|
||||
|
||||
class MockChannel:
|
||||
"""
|
||||
Mock channel object for testing.
|
||||
"""
|
||||
|
||||
def __init__(self):
|
||||
self.factory = MockFactory()
|
||||
self.transport = None
|
||||
|
||||
def getPeer(self, *args, **kwargs):
|
||||
return "peer"
|
||||
|
||||
def getHost(self, *args, **kwargs):
|
||||
return "host"
|
||||
|
||||
|
||||
class TestHTTPProtocol(unittest.TestCase):
|
||||
"""
|
||||
Tests the HTTP protocol classes.
|
||||
"""
|
||||
|
||||
def test_web_request_initialisation(self):
|
||||
channel = MockChannel()
|
||||
request = WebRequest(channel)
|
||||
self.assertIsNone(request.client_addr)
|
||||
self.assertIsNone(request.server_addr)
|
||||
|
|
@ -1,3 +1,5 @@
|
|||
# coding: utf8
|
||||
|
||||
import collections
|
||||
from urllib import parse
|
||||
|
||||
|
|
@ -304,21 +306,9 @@ class TestHTTPRequest(DaphneTestCase):
|
|||
response = self.run_daphne_raw(
|
||||
b"GET /\xc3\xa4\xc3\xb6\xc3\xbc HTTP/1.0\r\n\r\n"
|
||||
)
|
||||
self.assertTrue(b"400 Bad Request" in response)
|
||||
self.assertTrue(response.startswith(b"HTTP/1.0 400 Bad Request"))
|
||||
# Bad querystring
|
||||
response = self.run_daphne_raw(
|
||||
b"GET /?\xc3\xa4\xc3\xb6\xc3\xbc HTTP/1.0\r\n\r\n"
|
||||
)
|
||||
self.assertTrue(b"400 Bad Request" in response)
|
||||
|
||||
def test_invalid_header_name(self):
|
||||
"""
|
||||
Tests that requests with invalid header names fail.
|
||||
"""
|
||||
# Test cases follow those used by h11
|
||||
# https://github.com/python-hyper/h11/blob/a2c68948accadc3876dffcf979d98002e4a4ed27/h11/tests/test_headers.py#L24-L35
|
||||
for header_name in [b"foo bar", b"foo\x00bar", b"foo\xffbar", b"foo\x01bar"]:
|
||||
response = self.run_daphne_raw(
|
||||
f"GET / HTTP/1.0\r\n{header_name}: baz\r\n\r\n".encode("ascii")
|
||||
)
|
||||
self.assertTrue(b"400 Bad Request" in response)
|
||||
self.assertTrue(response.startswith(b"HTTP/1.0 400 Bad Request"))
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
# coding: utf8
|
||||
|
||||
import http_strategies
|
||||
from http_base import DaphneTestCase
|
||||
from hypothesis import given, settings
|
||||
|
|
@ -13,11 +15,10 @@ class TestHTTPResponse(DaphneTestCase):
|
|||
Lowercases and sorts headers, and strips transfer-encoding ones.
|
||||
"""
|
||||
return sorted(
|
||||
[(b"server", b"daphne")]
|
||||
+ [
|
||||
[
|
||||
(name.lower(), value.strip())
|
||||
for name, value in headers
|
||||
if name.lower() not in (b"server", b"transfer-encoding")
|
||||
if name.lower() != b"transfer-encoding"
|
||||
]
|
||||
)
|
||||
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
# coding: utf8
|
||||
|
||||
from unittest import TestCase
|
||||
|
||||
from twisted.web.http_headers import Headers
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
# coding: utf8
|
||||
|
||||
import collections
|
||||
import time
|
||||
from urllib import parse
|
||||
|
|
@ -192,30 +194,6 @@ class TestWebsocket(DaphneTestCase):
|
|||
self.assertEqual(scope["path"], "/foo/bar")
|
||||
self.assertEqual(scope["raw_path"], b"/foo%2Fbar")
|
||||
|
||||
@given(daphne_path=http_strategies.http_path())
|
||||
@settings(max_examples=5, deadline=2000)
|
||||
def test_root_path(self, *, daphne_path):
|
||||
"""
|
||||
Tests root_path handling.
|
||||
"""
|
||||
headers = [("Daphne-Root-Path", parse.quote(daphne_path))]
|
||||
with DaphneTestingInstance() as test_app:
|
||||
test_app.add_send_messages([{"type": "websocket.accept"}])
|
||||
self.websocket_handshake(
|
||||
test_app,
|
||||
path="/",
|
||||
headers=headers,
|
||||
)
|
||||
# Validate the scope and messages we got
|
||||
scope, _ = test_app.get_received()
|
||||
|
||||
# Daphne-Root-Path is not included in the returned 'headers' section.
|
||||
self.assertNotIn(
|
||||
"daphne-root-path", (header[0].lower() for header in scope["headers"])
|
||||
)
|
||||
# And what we're looking for, root_path being set.
|
||||
self.assertEqual(scope["root_path"], daphne_path)
|
||||
|
||||
def test_text_frames(self):
|
||||
"""
|
||||
Tests we can send and receive text frames.
|
||||
|
|
@ -312,7 +290,7 @@ async def cancelling_application(scope, receive, send):
|
|||
from twisted.internet import reactor
|
||||
|
||||
# Stop the server after a short delay so that the teardown is run.
|
||||
reactor.callLater(2, reactor.stop)
|
||||
reactor.callLater(2, lambda: reactor.stop())
|
||||
await send({"type": "websocket.accept"})
|
||||
raise asyncio.CancelledError()
|
||||
|
||||
|
|
|
|||
17
tox.ini
17
tox.ini
|
|
@ -1,8 +1,23 @@
|
|||
[tox]
|
||||
envlist =
|
||||
py{39,310,311,312,313}
|
||||
py{36,37,38,39}-twisted{187,latest}
|
||||
qa
|
||||
|
||||
[testenv]
|
||||
usedevelop = true
|
||||
extras = tests
|
||||
commands =
|
||||
pytest -v {posargs}
|
||||
deps =
|
||||
twisted187: twisted==18.7.0
|
||||
twistedlatest: twisted>=20.3.0
|
||||
|
||||
[testenv:qa]
|
||||
deps =
|
||||
black
|
||||
flake8
|
||||
isort
|
||||
commands =
|
||||
flake8 daphne tests
|
||||
black --check daphne tests
|
||||
isort --check-only --diff daphne tests
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user