Respond to ping request during non-blocking call

[wenleix]

Hi,

I noted aiohttp websocket client seems only respond to ping request from server in the .send() or receive() call. As such, if I cannot do them for over 40s (e.g. await for some other service result in a non-block call). Server will terminate the connection due to keepalive ping timeout .

An demonstration can be found in https://github.com/wenleix/ping-pong . I also tested with websockets Library which can handle ping request during non-blocking call.

I am wondering:

1. How should I respond to server's ping on client side during non-blocking await?
2. Should aiohttp websocket client being able to automatically respond to ping request, as long as there is no blocking event? This seems to preferred (although not must) as per WebSocket RFC states:

Upon receipt of a Ping frame, an endpoint MUST send a Pong frame in response, unless it already received a Close frame. It SHOULD respond with Pong frame as soon as is practical.

[Dreamsorcerer]

It does autoping, but as you've spotted, this only happens inside the .receive() method:

aiohttp/aiohttp/client_ws.py

Line 288 in edd49b5

await self.pong(msg.data)

I'm not sure if there's really any other way to do it. We can't see the ping message until we read it from the websocket, so how would we know how to respond before this call is made? e.g. We would need to constantly read all messages from the reader prematurely, but if there are a lot of non-ping messages, then this could cause a memory issue, as we now have to store all the pending messages in memory.

I'd suggest that you need to rethink your implementation to work within these constraints. e.g. If it's normal to require a long delay between processing each message, then get the server to use a longer timeout. Or, if it's not necessary to process each message sequentially, then start processing in background tasks, so your receive loop can be called a lot more frequently.

[Dreamsorcerer]

OK, well, that's exactly what websockets does. It reads messages in a loop and stores them in a queue to be read by recv().
https://github.com/python-websockets/websockets/blob/main/src/websockets/legacy/protocol.py#L954

I'm not sure this is really the best approach, and I suspect that if you want that behaviour, it's best if you write your own loop to do that. Something along the lines of:

async def read_messages():
    ...
    async for msg in ws:
        await queue.put(await ws.receive())

async def main():
    t = asyncio.create_task(read_messages())
    async for msg in queue:
        ...
    t.cancel()
    with contextlib.suppress(asyncio.CancelledError):
        await t