Broadcast and ChannelId

[feitzi]

I'm having some confusion regarding the functionality of Broadcast Channels in the Microsoft Orleans framework. It appears that in order to create a ChannelId, a Namespace and Key are required. However, it's not entirely clear what the Key should be used for.

After some debugging, I discovered that the Key of the ChannelId seems to correspond to the Id of the subscriber Grain. However, I am not sure how this would enable a broadcast functionality.

In my demo application, I have instances of the following grains:

• Publisher/0
• Subscriber/0
• Subscriber/1
• Subscriber/2.

The publisher writes its broadcast messages to a Channel with Namespace "myNamespaceAbc." The subscriber grains are set up to receive these messages via the [ImplicitChannelSubscription("myNamespaceAbc")] attribute.

Ideally, this setup should ensure that every instance of the subscriber grain receives all messages from the publisher. However, I have encountered an issue where a new subscriber grain with Id "Subscriber/ABCD" is created and only that grain receives the broadcast message when the Key is set to "ABCD." The other subscriber grains do not receive the message.

I am unsure if I have misunderstood the intended behavior of Broadcast Channels or if there is an issue with my implementation

[benjaminpetit]

The Key from the ChannelId will be the GrainKey of the subscriber. So, the behavior you see is expected.

The broadcast will work if you have different types of grain that are implicitly subscribed to this channel. If you want to have a more control on the subscription mechanism, you need to look at streams.

[feitzi]

But then you don't have a decoupling of the Publisher and the Subscriber. This is not a Broadcast. It's more like "send a message to that specific grain"! 

Why is that called a broadcast channel? Also, the documentation is misleading as it says that the publisher and the subscriber are decoupled. 

In the example of Broadcast channels you have a subscriber grain LiveStockGrain , as I understand the documentation every instance of that grain should get all messages from the channel. But as you explained this is not the case.

[benjaminpetit]

The decoupling is meant like "the publisher doesn't know the subscribers of this stream".

If you want true decoupling, use streaming instead. This will also allow explicit subscriptions, so multiple grains (even the same grain type) can subscribe to the same stream.

Broadcast Channel was introduced as a replacement for SMS. Unless you have very specific/niche requirement, you would be better off with memory streams.

[KSemenenko]

We also faced the problem of not understanding how it works.

As a result, we realize that this is a way to send messages to grain from «stream» Without calling its methods.

And "each instance" is one grain, or several, when its StatlessWorker?