Pre-handshake disconnect is reported as duplicate websocket.accept

[DeoLeung]

Summary

When a peer disconnects after the WebSocket request is parsed but before the ASGI application accepts it, the websockets-sansio implementation marks the handshake as complete in connection_lost(). A later websocket.accept from the application then enters the post-handshake branch and raises:

RuntimeError: Expected ASGI message 'websocket.send' or 'websocket.close', but got 'websocket.accept'.

This is reproducible with standalone Uvicorn; Gunicorn isn't involved. The same race also reproduces with wsproto. The deprecated websockets implementation doesn't log an application exception for this reproduction.

Environment

• Uvicorn 0.52.0 (also observed on 0.51.0)
• Python 3.13.14
• websockets 15.0.1
• ws="websockets-sansio"
• Reproduced on macOS; originally observed on Linux

Minimal reproduction

import asyncio
import socket

from uvicorn import Config, Server


async def app(scope, receive, send):
    assert scope["type"] == "websocket"
    message = await receive()
    assert message["type"] == "websocket.connect"
    await asyncio.sleep(0.1)
    await send({"type": "websocket.accept"})


async def main():
    listener = socket.socket()
    listener.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    listener.bind(("127.0.0.1", 0))
    listener.listen()
    listener.setblocking(False)

    server = Server(
        Config(
            app,
            ws="websockets-sansio",
            log_level="error",
            lifespan="off",
        )
    )
    server_task = asyncio.create_task(server.serve(sockets=[listener]))
    while not server.started:
        await asyncio.sleep(0)

    port = listener.getsockname()[1]
    _, writer = await asyncio.open_connection("127.0.0.1", port)
    writer.write(
        (
            "GET /ws HTTP/1.1\r\n"
            f"Host: 127.0.0.1:{port}\r\n"
            "Upgrade: websocket\r\n"
            "Connection: Upgrade\r\n"
            "Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n"
            "Sec-WebSocket-Version: 13\r\n\r\n"
        ).encode()
    )
    await writer.drain()
    writer.close()
    await writer.wait_closed()

    await asyncio.sleep(0.25)
    server.should_exit = True
    await server_task


asyncio.run(main())

Actual behavior

The ASGI application is logged as failing with the duplicate-accept RuntimeError.

Expected behavior

A peer disconnect before acceptance should be treated as a client disconnect, ideally by raising ClientDisconnected (which run_asgi() already handles), rather than as an invalid ASGI message sequence.

Suspected cause

connection_lost() unconditionally sets handshake_complete = True. send() then selects the post-handshake state based on that flag before accounting for the closed transport.

Potential fixes might be to track connection loss separately or raise ClientDisconnected when the transport is already closing before validating a new ASGI send. A regression test covering connection_lost() before websocket.accept would protect both SansIO and wsproto.

[kratos0718]

Your suspected cause is right, and this looks like it's already fixed on master
by #3050 — though as a side effect of a different fix, so it's worth confirming
before this gets closed.

On 0.52.0, connection_lost() sets handshake_complete = True and nothing else
tracks that the peer is gone:

# 0.52.0, connection_lost()
self.handshake_complete = True
if exc is None:
    self.transport.close()

send() then branches purely on that flag, with no disconnect check ahead of it:

# 0.52.0, send()
await self.writable.wait()
if not self.handshake_complete and self.initial_response is None:
    ...

So a pre-handshake disconnect flips handshake_complete, the later
websocket.accept skips the accept branch, and it lands in the post-handshake
elif — hence "Expected ASGI message 'websocket.send' or 'websocket.close'".

On master, #3050 ("Handle connection loss during WebSocket write backpressure")
added a separate self.disconnected flag and a guard at the top of send():

self.disconnected = True     # connection_lost()

await self.writable.wait()   # send()
if self.disconnected:
    raise ClientDisconnected()

Because that guard runs before any handshake-state branching, a pre-handshake
disconnect now raises ClientDisconnected — which run_asgi() already handles —
instead of the RuntimeError. That's exactly the behaviour you asked for.

I ran your reproduction unmodified against both:

uvicorn 0.52.0        -> RuntimeError: Expected ASGI message
                         'websocket.send' or 'websocket.close',
                         but got 'websocket.accept'
master (0.52.1.dev)   -> clean exit, no application error

(Python 3.13, websockets 15.0.1, ws="websockets-sansio".)

Two things that might still be worth doing, since #3050 was aimed at write
backpressure rather than this race:

1. A regression test for connection_lost() arriving before websocket.accept,
   so this can't come back if the disconnect handling is refactored again.
2. wsproto — you mentioned it reproduces there too, and Handle connection loss during WebSocket write backpressure #3050 only touched the
   sansio implementation, so that path may still be affected.

Happy to open a PR for the regression test if that'd be useful.