Server side: keep connection open when client incorrectly disconnects

[Time0o]

In the docs there are ample examples showing how a client can reopen a connection after loosing it, but what about the other way around? I am writing a server that should allow for clients to reconnect after a websockets.ConnectionClosedError has been thrown. This seems like it should be a common use case. Is it possible? If so, how? My server code looks something like this:

class MyServer:
    async def _ws_handler(self, ws):
            try:
                async for data in ws:
                    pass # TODO: do something

            except websockets.ConnectionClosedOK:
                pass

            except websockets.ConnectionClosedError as e:
                pass # TODO: reconnect?

    def serve(self):
        return websockets.serve(self._ws_handler, MY_HOST, MY_PORT)

I tried to simpy wrap the try ... catch inside the handler in a while loop but that does not work since an asyncio.exceptions.InvalidStateError will be thrown once the client reconnects.

[aaugustin]

You need to preserve session state somewhere, authenticate the client when it reconnects, and pick up where you left off. I'm afraid the details are going to be quite specific to each application.

As soon as you have more than one websockets process, you need to rebuild the whole state in the memory of a new process, so the kind of pseudocode you provided doesn't make sense.

If you want that kind of behavior, it would probably be easier to structure it it as:

1. a component that maintains connections with clients and routes messages from / to them; this component should be stateless so that disconnections and reconnections are transparent;
2. some kind of central process that handles incoming messages and sends outgoing messages; this component can be stateful; this is how you get the "pick up where you left off" behavior.