Is there a detailed tutorial on "websocket"?

[hgalytoby]

Sorry, my native language is not English, my English is poor, if communication is not good I will close issues.

I found the websocket example from #41

Before I found this example, it was not clear that the message should be sent after connecting.

Subscribe Msg

{
   request:  {
       method: "subscribe",
       "arguments": {
       "topics": ["event"]
       }
   }
}

I understand that I can receive messages by sending Subscribe Msg.

I understand sending messages to topics using Python.

endpoint = PubSubEndpoint(broadcaster="redis://localhost:6379")
await endpoint.publish(['event'], {'msg': 'ok'})

How can I send a message to a topic from Web JS?

Do you have any examples or documentation to look at?

I have a few questions

1.I want to send a message to Event topic?

let ws = new WebSocket("ws://localhost:8080/pubsub")
ws.send(JSON.stringify(????))

2.After the web receives a message once, there are no more messages.

import asyncio
from fastapi_websocket_pubsub import PubSubEndpoint


async def main():
    endpoint = PubSubEndpoint(broadcaster='redis://localhost:6379')
    while True:
        await endpoint.publish(["event"], data={'msg': 'hello web'})
        await asyncio.sleep(1)


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

But the web can receive the trigger message.

async def events():
    await endpoint.publish(['event'], {"msg": "fastapi"})


@app.get('/trigger')
async def trigger_events():
    asyncio.create_task(events())

[orweis]

Hi, and sorry for the delayed reply- had a busy week.
I think your english is pretty clear, I understand you want to write a Javascript client to connect with the websocket.
This is the same as this discussion: #42 (Which you also linked to).

In order to have the JS client work it must implement the [RPC protocol(https://github.com/permitio/fastapi_websocket_rpc/blob/master/fastapi_websocket_rpc/rpc_channel.py), which is another logical layer on top of the websocket.

The bear minimum here is to implement the right schema for an RPC message and call the pub/sub RPC method publish

Which is something like this:

{
 "request":  {
      "method": "publish",  
      "arguments": {"topics":["event"], "data":{"msg": "hello web"} }, 
      "call_id": "<RANDOM-UUID>" 
  } 
}

[hgalytoby]

Thank you for your reply, my English is translated by Google.

I later flipped through the source code and found publish

fastapi_websocket_pubsub/fastapi_websocket_pubsub/rpc_event_methods.py

Line 47 in 49b8dfc

async def publish(self, topics: TopicList = [], data=None, sync=True, notifier_id=None) -> bool:

I have some questions now, but I'm having a hard time expressing in English.

I have attached a gif, can you take a look?

Why web js subscribe after...

Client.py can't receive the message of test.py?

Then I used fastapi trigger with no problem.

But when I add a web connection.

There is no way to receive fastapi trigger messages.

After I disconnected the initial web connection, I was able to receive messages.

What am I doing wrong? Or am I using the method wrong?

server.py

import asyncio
import uvicorn
from fastapi import FastAPI
from fastapi.routing import APIRouter
from fastapi_websocket_pubsub import PubSubEndpoint
from starlette.websockets import WebSocket

app = FastAPI()
router = APIRouter()
endpoint = PubSubEndpoint(broadcaster='redis://localhost:6379')


@router.websocket('/pubsub')
async def websocket_rpc_endpoint(websocket: WebSocket):
    async with endpoint.broadcaster:
        await endpoint.main_loop(websocket)


async def events(topic):
    await endpoint.publish([topic], {'msg': 'fastapi'})


@app.get('/trigger')
async def trigger_events():
    asyncio.create_task(events('event'))


app.include_router(router)

if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=8000)

client.py

import asyncio
from fastapi_websocket_pubsub import PubSubClient


async def on_events(data, topic):
    print(f"running callback for {data} {topic}!")


async def main():
    client = PubSubClient(["event"], callback=on_events)
    client.start_client(f"ws://localhost:8000/pubsub")
    await client.wait_until_done()


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

test.py

import asyncio
import random
from fastapi_websocket_pubsub import PubSubEndpoint

endpoint = PubSubEndpoint(broadcaster='redis://localhost:6379')


async def run():
    while True:
        await endpoint.publish('event', {'msg': random.randint(1, 100)})
        await asyncio.sleep(1)


if __name__ == '__main__':
    asyncio.run(run())

js

let ws = new WebSocket("ws://127.0.0.1:8000/pubsub")

let payload_str = JSON.stringify({request: {method: "subscribe", "arguments": {"topics": ["event"]}}})

ws.onmessage = (event) => {
    console.log('get event data', JSON.parse(event.data))
}

ws.send(payload_str)

[orweis]

Hi @hgalytoby - as I explained earlier you can't expect this to work without implementing the entire set of protocols, both RPC and PUB/SUB.

You need to write a full version of RPC, and a full version of pub_sub in JS, otherwise things would continue to not work correctly.

In this case for example you're ignoring the fact that the subscribe function on the pub/sub server expects the RPC client on the other side to implement the notify method. Without the notify method sending an RPC response back, which the RPC server is waiting for the server would hang until a configurable timeout (which is forever by default).

!! NOTE !! :
I really do want to help you, but you can't expect to do this with out being serious about it, and implementing a full JS version of the protocols.
I am sorry - but to be respectful of everyone's time - I won't respond to further questions unless you fully try to implement the RPC and pub/sub protocols.

[hgalytoby]

Thanks for taking the time to read, I get it.