Disconnected websocket - No exception is raised when sending a message!

[yoniker]

How can the server detect a situation when the client didn't receive a message sent by the server,
specifically when the client disconnected not gracefully (=without closing the websocket explicitly)?

To my understanding, this should have raised an exception, but it doesn't.
The first time when Starlette notices that anything is wrong, is when the ping interval times out.

To easily see that, run the following server:

from starlette.applications import Starlette
from starlette.responses import JSONResponse
from starlette.endpoints import HTTPEndpoint
from starlette.routing import Route
from starlette.endpoints import WebSocketEndpoint
from starlette.routing import Route, WebSocketRoute
import json


websockets = dict()


class SayHealthy(HTTPEndpoint):
    async def get(self, request):
        return JSONResponse({'status': 'websockets service is healthy!'})


class RelayMessageToWebsocket(HTTPEndpoint):
    async def post(self,request):
        try:
            receiver_id = request.path_params['user_id']
            data = await request.json()
            websocket = websockets[receiver_id]
            try:
                await websocket.send(json.dumps(data))
            except Exception as e:
                if receiver_id in websockets: del websockets[receiver_id]
                raise e
            print('Success: message was sent!')
            return JSONResponse({'result': 'message_sent'})
        except:
            print('Error: message was not sent')
            return JSONResponse({'result': 'message_not_sent'})


class WebsocketBehavior(WebSocketEndpoint):
    encoding = 'json'

    async def on_connect(self, websocket):
        user_id = websocket.headers.get('user_id')
        print(f'on connect called with user_id={user_id}')
        websockets[user_id] = websocket
        await websocket.accept()

    async def on_receive(self, websocket, data):
        print('on recieve called')
        #await websocket.send_json(data={'Got this':data})
        print(f'Got this from websocket:{data}')

    async def on_disconnect(self, websocket, close_code):
        print('on disconnect called')
        try:
            user_id = websocket.headers.get('user_id')
            del websockets[user_id]
            print(f'deleted {user_id} from websockets dict')
        except:
            pass


routes = [
    Route("/websockets/healthcheck", SayHealthy),
    Route('/websockets/message_user/{user_id}',RelayMessageToWebsocket),
WebSocketRoute("/websockets/register", WebsocketBehavior)
]




app = Starlette(routes=routes)

and run it with a higher ping interval:
import uvicorn uvicorn.run('app:app',host='0.0.0.0', port=5000,ws_ping_interval=300, ws_ping_timeout=300)

For the client, use a mobile phone, and put the phone in airplane mode while it is connected to the server.
Call the server via the endpoint /websockets/send_message/<user_id>.
The server will happily describe all of the messages as "sent" for 5 minutes.

If this behavior is expected (to my understanding exception should have been raised), how can I check if the message was actually received by the client?

[Kludex]

I'm not sure if I get what you said. Can you provide the interaction between the client and server, and when you expect an exception?

[yoniker]

@Kludex Okay sure,
Here's the interaction:

1. Client (a mobile phone) connects to the server, so a new websocket connection is created
2. Client disconnected without notifying the server (example scenarios: airplane mode, an area with no reception).
3. Another part of the server decides to send the client a message (since,for example, a friend decided to message this specific client) and tries to do so from the endpoint /websockets/message_user/{user_id}.
4. await websocket.send(json.dumps(data)) is being called. I expected an exception to be raised (so that the server will know that websocket doesn't function, so the server can try other means of delivery more suited to the client being offline). Instead, the running code behaves as if everything is okay (no exception was raised, the coroutine finishes normally, and AFAIK no way to know if the client got the message via the websocket [unless I will implement a custom ACK mechanism]).

[Kludex]

Is there a simple way for me to debug this? 😞

[Kludex]

Do you have the same behavior with hypercorn?

[yoniker]

So there is no "simple way" (I didn't find a nice way to isolate a process such that it suddenly doesn't have network access) AFAIK,
but i made it as easy for you as possible as I could, by creating a minimal working server + client you can run locally.

The client is a Flutter client, which requires a SSL connection, so I made a self-signed certificate (so that the code will be self-reliant).
The repo for both client and server is here:
https://github.com/yoniker/ShowWsBug

BTW if you are not happy with a Flutter client, I have added a client.py file (at the server folder) that you can run, but then you will have to find a way to make it lose connection without letting the server know (like a phone could easily do) - which is something I failed to do.

What you need to do is to run the server on your local machine
(simply python run.py at the server folder),
run the client on an emulator (I used a nexus 5 Emulator on API 29, but I suspect that any emulator will do).
The client should automatically connect to the server.

Then simply go to postman (or requests, or your favorite way to produce post requests),
and use the address:

https://localhost:5000/websockets/message_user/dorr
with any json body(
{"message":"This is a message22 I want to pass to someone","king":"dor"}
)

This should produce (at the server) 'Success: message was sent!'.

Now put the phone on airplane mode (this is a good simulation to a situation where a phone goes into some "no reception" zone as well).
Try the exact same POST request. Notice how the server thinks that the message was sent again.

Hopefully this will be helpful (as you can see, I spent time on this so it will), but if there's anything else I can do to help, do let me know.