How to observe/wait for a Grain state

[burgerTo]

hi everyone,
i'm looking for a best practices to observe a grain state. More precise i want to wait for a specific grain state in another grain.

I've the following scenario:

• I've a grain with a internal state ... lets call the state int x;

• This state could be modified from outside for example with Task SetX(123)

• Now, i want to provide a method in the grain interface which returns when X reached a value. For example: Task WaitForMax()

I want to wait for a specific state in the grain.

Without orleans i would implement it with a task completion source. And return the corresponding Task in WaitForMax().

But what is the correct technqiue to implement it with orelans as a backend?

Of course my real scenario is not a int value. In the grain i get messages via a orleans stream. The grain is doing some processing on this messages and should signal a completed processing somehow to other grains. But in a simplified view it's similart to the integer example.

Thanks :).
Toni

[ReubenBond]

Hi Toni,

One way to accomplish this is via a callback: your waiter grain can call the observee grain with await targetGrain.CallMeWhenX(IWaiterGrain) and your observee grain can issue a callback when it's time.
Another option is to poll / long poll: Task<Status> PollForX() which can return after 5 seconds with a timeout status if the condition is not met (mark it as [AlwaysInterleave] so that other methods can execute while it's running).
A third option is a hybrid of those two: registering a callback periodically. The benefit of that approach is that it doesn't require any persistence in the observee.
Another option is to use streams: the observee can push a notification that the condition was met to a stream which the observer is listening to.

Within the observee grain, you can use a TaskCompletionSource if you wish. I would advise creating the TCS with TaskCreationOptions.RunContinuationsAsynchronously specified, since it gives the most predictable behavior.

How do those suggestions sound to you, will one of them be appropriate?

[burgerTo]

Hi Reuben,
thanks for the fast response.
Yes, that sounds good. I think i will try the stream approach. I need to wait for different types of grains in the "observer-grain". Therefore the "callback-interface" will get bigger and bigger.
With the usage of streams i can prevent that :).
I will try it out, but it sounds like a solution.

Thanks.
Toni

[ReubenBond]

For the callback approach note that grains can implement multiple interfaces. That means you could have a common callback grain interface which all the observers implement