Websocket/Multiplexing/Streams

[GeroL]

Hi,

I am doing currently some research on how to adapt a websocket to orleans.
The source is a websocket will push data about every 15 seconds and has some multiplexing in it with different streams.
I now try to consume this websocket within orleans.

Solution 1:
My first idea was a grain which holds a websocket and some streams. It would fire up a long running Task with a loop processing the websocket.
The loop would write the incoming messages from the socket to a Channel and the grain itself would write the data in a loop itself to the corresponding stream.
A Reminder or Timer would hold the Grain active.

I think this could work and would unblock me.

Solution 2:
Would an IQueueAdapter implementation instead of a grain be a better pattern?
The question I have here is when I request a stream with this adapter, would it be per silo? I mean a websocket connection per silo?
Or would orleans detect that there is some other silo already active with an IQueueAdapter?

I read about the pulling agents. I assume they do a long wait with a configurable timeout after they read data, right?

Also, what would happen if the silo with an IQueueAdapter goes down? Would another silo take over and create this adapter?

Any hints on other solutions?

Thanks

[m17kea]

Did you make any progress with this?

[GeroL]

I ended up terminating the websockets in webservices using BackgroundServices.
The services would then just relay the messages to a pulsar cluster because there were several other independent service interested in these messages.

I developed an IQueueAdapter, IQueueAdapterFactory and IQueueAdapterReceiver for this to use PersistentStreamProvider.

I have the classical single-writer/multiple-reader pattern. This solves this quite well.

Another solution before I had access to the pulsar cluster:

I created some sort of proxy grain. A fixed silo placement director (https://learn.microsoft.com/en-us/dotnet/orleans/grains/grain-placement#sample-custom-placement-strategy) should make sure that these grains are one per-silo only.

The WebServices would use SignalR to send messages to hubs where the local proxy grain are subscribed.
(https://github.com/OrleansContrib/SignalR.Orleans)

These per-silo grains would receive these messages and distributes them using per-silo-streams.
Individual grains then subscribe to these streams locally. Maybe this would also work even without the proxy grains.

This solution worked but was rather complex and lacks many features available using pulsar.