[Websocket] Websocket server is not stateful?

[mirusu400]

I think we can use this library to create a websocket server very easily. However, there was a question about maintaining the state, so make this issue: How to make websocket stateful?

on the websockets library, we can simply using while loop, we can make websocket stateful. Therefore, we can continue to keep the previous data and get new data.

However, In socketify, only accepts by event handler, so it seems that we cannot keep the previous data (because after ws_message event handler was end, and after next ws_message handler there are no way to identify which is previous data)

Even if we check ws, which is the only object transmitted, it seems that the ws object of ws_open and ws_message object are different and are not stateful.

So, how can I make socketify websocket server stateful?

Here are some sample ws server using socketify:

import socketify

def ws_open(ws):
    print("WebSocket opened")
    # print ws object id
    print(ws)


def ws_message(ws, message, opcode):
    # How can I increase idx so this websocket server make stateful?
    idx = 1
    print(f"idx: {idx}")
    print(f"WebSocket message: {message}")
    # why this ws object is different from ws object in ws_open?
    print(ws)


app.ws(
    "/*",
    {
        "compression": socketify.CompressOptions.SHARED_COMPRESSOR,
        "max_payload_length": 16 * 1024 * 1024,
        "idle_timeout": 12,
        "open": ws_open,
        "message": ws_message,
        "drain": lambda ws: print(
            "WebSocket backpressure: %s", ws.get_buffered_amount()
        ),
        "close": lambda ws, code, message: print("WebSocket closed"),
    },
)

app.any("/", lambda req, res: res.send("Hello, World!"))
app.listen(8765)
app.run()

Comparison with websockets:

#!/usr/bin/env python

import asyncio

from websockets.asyncio.server import serve


async def hello(websocket):
    idx = 0
    # We can simply recv, send in while loop so make them stateful
    while True:
        name = await websocket.recv()
        print(f"<<< {name}")

        greeting = f"Hello {name}!"

        await websocket.send(greeting)
        print(f">>> {greeting} {idx}")
        idx += 1


async def main():
    async with serve(hello, "localhost", 8765):
        await asyncio.get_running_loop().create_future()  # run forever


if __name__ == "__main__":
    asyncio.run(main())

[cirospaciari]

the object can be different on each callback in the current implementation (this will change) today we can use get_user_data if you pass a dict object in the upgrade call, and it will be the same and preserved in all callbacks.
https://docs.socketify.dev/websockets-backpressure.html#use-the-websocketget_user_data-feature