.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

.github/dependabot.yml

@@ -1,6 +0,0 @@
-version: 2
-updates:
-- package-ecosystem: github-actions
-  directory: "/"
-  schedule:
-    interval: weekly

.github/workflows/tests.yml

@@ -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.6
-        - "3.10"
+        - 3.7
-        - "3.11"
+        - 3.8
-        - "3.12"
+        - 3.9
-        - "3.13"
 
     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 pip wheel setuptools tox
-          python -m pip install --upgrade 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

.gitignore

@@ -13,4 +13,3 @@ test_consumer*
 .python-version
 .pytest_cache/
 .vscode
-.coverage

.pre-commit-config.yaml

@@ -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

CHANGELOG.txt

@@ -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)
 ------------------
 

MANIFEST.in

@@ -1,2 +1 @@
 include LICENSE
-recursive-include tests *.py

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 <https://github.com/django/asgiref/blob/master/specs/asgi.rst>`_ and
-`ASGI-HTTP <https://github.com/django/asgiref/blob/main/specs/www.rst>`_,
+`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>`_.

daphne/__init__.py

@@ -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

daphne/access.py

@@ -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.

daphne/apps.py

@@ -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)

daphne/checks.py

@@ -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",
-                )
-            ]

daphne/cli.py

@@ -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",
+            default="Daphne",
-        )
-        self.parser.add_argument(
-            "--no-server-name", dest="server_name", action="store_const", const=""
         )
 
         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=(
+            action_logger=AccessLogGenerator(access_log_stream)
-                AccessLogGenerator(access_log_stream) if access_log_stream else None
+            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=(
+            proxy_forwarded_proto_header="X-Forwarded-Proto"
-                "X-Forwarded-Proto" if args.proxy_headers else None
+            if args.proxy_headers
-            ),
+            else None,
             server_name=args.server_name,
         )
         self.server.run()

daphne/http_protocol.py

@@ -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"):
+            if self.server.server_name and self.server.server_name.lower() != "daphne":
-                self.setHeader(b"server", self.server.server_name.encode())
+                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": (
+                            "client": "%s:%s" % tuple(self.client_addr)
-                                "%s:%s" % tuple(self.client_addr)
+                            if self.client_addr
-                                if self.client_addr
+                            else None,
-                                else None
-                            ),
                             "time_taken": self.duration(),
                             "size": self.sentLength,
                         },

daphne/management/commands/runserver.py

@@ -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)

daphne/server.py

@@ -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:

daphne/testing.py

@@ -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.setup = setup or (lambda: None)
-        self.teardown = teardown
+        self.teardown = teardown or (lambda: None)
         self.port = multiprocessing.Value("i")
         self.ready = multiprocessing.Event()
         self.errors = multiprocessing.Queue()
@@ -149,27 +146,23 @@ 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()
-                self.setup()
             try:
                 self.server.run()
             finally:
-                if self.teardown is not None:
+                self.teardown()
-                    self.teardown()
         except BaseException as e:
             # Put the error on our queue so the parent gets it
             self.errors.put((e, traceback.format_exc()))

daphne/twisted/plugins/fd_endpoint.py

@@ -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):

daphne/utils.py

@@ -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):
     """

daphne/ws_protocol.py

@@ -31,21 +31,17 @@ 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.clean_headers.append((name.lower(), value.encode("latin1")))
-                    self.root_path = unquote(value)
-                else:
-                    self.clean_headers.append((name.lower(), value.encode("latin1")))
             # Get client address if possible
             peer = self.transport.getPeer()
             host = self.transport.getHost()
@@ -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": (
+                "client": "%s:%s" % tuple(self.client_addr)
-                    "%s:%s" % tuple(self.client_addr) if self.client_addr else None
+                if self.client_addr
-                ),
+                else None,
             },
         )
 
@@ -138,9 +133,9 @@ class WebSocketProtocol(WebSocketServerProtocol):
             "connected",
             {
                 "path": self.request.path,
-                "client": (
+                "client": "%s:%s" % tuple(self.client_addr)
-                    "%s:%s" % tuple(self.client_addr) if self.client_addr else None
+                if self.client_addr
-                ),
+                else None,
             },
         )
 
@@ -175,9 +170,9 @@ class WebSocketProtocol(WebSocketServerProtocol):
             "disconnected",
             {
                 "path": self.request.path,
-                "client": (
+                "client": "%s:%s" % tuple(self.client_addr)
-                    "%s:%s" % tuple(self.client_addr) if self.client_addr else None
+                if self.client_addr
-                ),
+                else None,
             },
         )
 
@@ -242,9 +237,9 @@ class WebSocketProtocol(WebSocketServerProtocol):
             "rejected",
             {
                 "path": self.request.path,
-                "client": (
+                "client": "%s:%s" % tuple(self.client_addr)
-                    "%s:%s" % tuple(self.client_addr) if self.client_addr else None
+                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:

pyproject.toml

@@ -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"

setup.cfg

@@ -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

setup.py

@@ -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",
+    ],
+)

tests/http_base.py

@@ -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):

tests/test_checks.py

@@ -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"

tests/test_cli.py

@@ -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")))

tests/test_http_protocol.py

@@ -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)

tests/test_http_request.py

@@ -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)
+        self.assertTrue(response.startswith(b"HTTP/1.0 400 Bad Request"))
-
-    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)

tests/test_http_response.py

@@ -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"
             ]
         )
 

tests/test_utils.py

@@ -1,3 +1,5 @@
+# coding: utf8
+
 from unittest import TestCase
 
 from twisted.web.http_headers import Headers

tests/test_websocket.py

@@ -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()
 

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