shutdown after peer WebSocket close can raise before connection_lost

[sunxiuguo]

A downstream report prompted this investigation: itda-work/django-wireview#226 . I am not the downstream reporter. This is an AI-assisted, independently rerun controlled protocol-level reproduction, not a real-socket integration test.

On Uvicorn main 9d81c12a2c411d3bf104368472b708a3218d9b4e, a client completes the handshake and sends a normal close frame. Before the transport's deferred connection_lost callback, calling the protocol's shutdown() raises:

• WebSocketsSansIOProtocol: InvalidState: connection is closing
• WSProtocol: LocalProtocolError: Event CloseConnection(code=1012, reason=None) cannot be sent in state ConnectionState.CLOSED.

Both corresponding open-connection controls shut down without exceptions. The close frames are produced by the real websockets client codec and passed through production data_received; the synthetic transport controls the callback gap. close_sent remains false although peer-close handling has already advanced the codec and requested transport closure.

Expected: shutdown during this already-closing interval should be safe. I have not run Server.shutdown() or demonstrated how often real sockets hit this interval. Its unguarded connection-shutdown loop suggests a possible interruption of later cleanup, but that impact is only static inference here. The reproduction's finally block manually cleans up; it is not evidence of successful production cleanup.

Environment: Linux, Python 3.12.14; click 8.5.0, h11 0.16.0, websockets 17.1, wsproto 1.3.2. From the source checkout with those dependencies installed:

PYTHONPATH="$PWD" python ../reproduce.py

Would maintainers consider this an upstream issue and welcome a focused regression test/fix? Adjacent merged #3053 and #3138 concern server-initiated close and handshake denial respectively; open #3163's inspected diff does not change these shutdown/close handlers. Please point me to an existing discussion if this is already tracked.

Complete synthetic reproduction

import asyncio, json
from uvicorn import Config
from uvicorn.server import ServerState
from uvicorn.protocols.websockets.websockets_sansio_impl import WebSocketsSansIOProtocol
from uvicorn.protocols.websockets.wsproto_impl import WSProtocol
from websockets.client import ClientProtocol
from websockets.uri import parse_uri

class Transport:
    def __init__(self): self.buffer=b''; self.closed=False
    def get_extra_info(self,name,default=None): return {'sockname':('127.0.0.1',8000),'peername':('127.0.0.1',8001)}.get(name,default)
    def write(self,data): self.buffer+=data
    def close(self): self.closed=True
    def is_closing(self): return self.closed
    def pause_reading(self): pass
    def resume_reading(self): pass

async def case(cls,peer_close):
    accepted=asyncio.Event(); events=[]
    async def app(scope,receive,send):
        events.append(await receive()); await send({'type':'websocket.accept'}); accepted.set()
        events.append(await receive())
    config=Config(app,ws=cls,http='h11',loop='asyncio',lifespan='off',log_config=None,ws_ping_interval=None)
    config.load(); state=ServerState(); protocol=cls(config=config,server_state=state,app_state={}); transport=Transport()
    protocol.connection_made(transport)
    client=ClientProtocol(parse_uri('ws://127.0.0.1/'))
    client.send_request(client.connect()); protocol.data_received(b''.join(client.data_to_send()))
    await asyncio.wait_for(accepted.wait(),1)
    client.receive_data(transport.buffer); list(client.events_received())
    if peer_close:
        client.send_close(1000); protocol.data_received(b''.join(client.data_to_send()))
    before={'protocol_close_sent':protocol.close_sent,'transport_closing':transport.closed,'codec_state':str(protocol.conn.state)}
    error=None
    try: protocol.shutdown()
    except Exception as exc: error={'type':type(exc).__name__,'message':str(exc)}
    finally:
        protocol.connection_lost(None)
        await asyncio.wait_for(asyncio.gather(*list(state.tasks)),1)
    return {'protocol':cls.__name__,'peer_close':peer_close,'before':before,'exception':error,'app_events':events}
async def main():
    results=[await case(cls,closed) for cls in (WebSocketsSansIOProtocol,WSProtocol) for closed in (False,True)]
    print(json.dumps(results,indent=2))
    assert all(r['exception'] is None for r in results if not r['peer_close'])
    assert all(r['exception'] is not None for r in results if r['peer_close'])
asyncio.run(main())

Observed output

[
  {
    "protocol": "WebSocketsSansIOProtocol",
    "peer_close": false,
    "before": {
      "protocol_close_sent": false,
      "transport_closing": false,
      "codec_state": "1"
    },
    "exception": null,
    "app_events": [
      {
        "type": "websocket.connect"
      },
      {
        "type": "websocket.disconnect",
        "code": 1012
      }
    ]
  },
  {
    "protocol": "WebSocketsSansIOProtocol",
    "peer_close": true,
    "before": {
      "protocol_close_sent": false,
      "transport_closing": true,
      "codec_state": "2"
    },
    "exception": {
      "type": "InvalidState",
      "message": "connection is closing"
    },
    "app_events": [
      {
        "type": "websocket.connect"
      },
      {
        "type": "websocket.disconnect",
        "code": 1000,
        "reason": ""
      }
    ]
  },
  {
    "protocol": "WSProtocol",
    "peer_close": false,
    "before": {
      "protocol_close_sent": false,
      "transport_closing": false,
      "codec_state": "ConnectionState.OPEN"
    },
    "exception": null,
    "app_events": [
      {
        "type": "websocket.connect"
      },
      {
        "type": "websocket.disconnect",
        "code": 1012
      }
    ]
  },
  {
    "protocol": "WSProtocol",
    "peer_close": true,
    "before": {
      "protocol_close_sent": false,
      "transport_closing": true,
      "codec_state": "ConnectionState.CLOSED"
    },
    "exception": {
      "type": "LocalProtocolError",
      "message": "Event CloseConnection(code=1012, reason=None) cannot be sent in state ConnectionState.CLOSED."
    },
    "app_events": [
      {
        "type": "websocket.connect"
      },
      {
        "type": "websocket.disconnect",
        "code": 1000,
        "reason": ""
      }
    ]
  }
]