Detect/handle closed client connections

It appears like starlette does not cancel inner processing for when a client disconnects.

With the following code it will keep on fetching from the remote, although the client has disconnected already, e.g. when cancelling a curl call.

@app.route(…)
async def foo(request):
    …
    if content_type.startswith("video/"):
        bytes_total = req.headers["Content-Length"]
        logger.info("Streaming {} bytes...", bytes_total)

        async def generator(bytes_total):
            import aiohttp
            async with aiohttp.ClientSession() as session:
                chunk = 0
                chunk_size = 102400
                bytes_read = 0
                async with session.request(method, str(url), chunked=chunk_size) as resp:
                    async for data, end_of_http_chunk in resp.content.iter_chunks():
                        chunk += 1
                        bytes_read += chunk_size
                        logger.info("chunk {} {}/{}", chunk, bytes_read, bytes_total)
                        yield data
        return StreamingResponse(generator(bytes_total), media_type=content_type)

It might be useful if the handler could be notified of this, in case it wants to handle this, but in general I think a late middleware, responsible for sending could handle this maybe?!

[tomchristie]

I think the following would also do the trick, for a non-blocking receive: message = await asyncio.wait_for(receive, timeout=0).

[tomchristie]

I’m trying to implement SSE manually by returning a StreamingResponse, but the generator cannot know when the client disconnects and will keep sending events (although to a no-op) indefinitely.

Right. The thing is that the disconnect needs to be handled in an event driven way, rather than raising an exception on send().

I’ve initially tried await receive(), where a disconnect message would appear, but that might block without any message(s)

Sure, so I think what you’d need is something like:

done, pending = await asyncio.wait([receive, response.content.read], return_when=FIRST_COMPLETED)
task = done[0]
if task is receive:
    message = task.result()
else:
    data = task.result()

Not wild about how akward it is to do a await either this thing or that thing and switch on either, but there we are.