Using Orleans as the server

[ElderJames]

Orleans is a cross-platform framework for building robust, scalable distributed applications.

https://github.com/dotnet/orleans

From the Orleans, we can implement the following features:

• Use virtual Actors to manage process instances.
• Support distributed hosting natively

[sfmskywalker]

It took me a while, but I've been growing more fond towards this idea.

Right now, every instance of Elsa will be handling workflow messages, some of which targeting the exact same workflow instance ID. Depending on the worker configuration, multiple messages could be processed in parallel. So, to avoid concurrency issues when updating the same workflow instance (loaded separately from the persistence store), the engine ensures this doesn't happen by using a distributed locking mechanism.

Although that works, it's not perfect either. One specific case coming to mind is that when a message is redelivered because it wasn't processed in a timely fashion (e.g. because the workflow message worker is still executing a given workflow instance, holding on to a lock). Right now this message simply gets sent back to the queue. It works, but it's not quite elegant because the queue grows and grows, easily causing delays for other workflow instances to be executed.

So I have been thinking about maybe introducing a worker queue per workflow instance, where each workflow instance only processes one message at a time.

If that sounds similar to an actor pattern, then I think you're right. I'm no expert on the matter, but it's what I got when watching a video about Akka.net yesterday (which made me remind @ElderJames started this topic last year).

So I would like to continue this discussion about possible designs to implement Orleans or Akka.NET for distributed hosting natively. Perhaps ideally we could provide Elsa without a dependency on either of those, but when it's time to host Elsa in a distributed fashion, one can simply reference e.g. Elsa.Hosting.Orleans or Elsa.Hosting.Akka.

/discuss

[ClementeGao]

wow Pretty good！Support you！

[jdevillard]

about Orleans implementation, this link could be a good reading to see how Microsoft WF Activities was implemented on Orleans https://github.com/OrleansContrib/Orleans.Activities

[sfmskywalker]

That’s really helpful, thanks!

[geffzhang]

Perhaps dapr is a better choice, dapr actor comes from Orleans, dapr is more suitable for cloud-native environments, dapr also has workflow projects https://github.com/dapr/workflows

[sfmskywalker]

I can totally see support packages for building workflow-driven applications with Dapr and Elsa. These might exist in addition to Orleans and/or Akka, since those seem to be a little bit more low-level. That being said, I'm very unfamiliar with all of the above, so we'll see what lands where :)

[ElderJames]

Orleans can be used as a built-in server to manage process instances within a process, so I think it's more appropriate.

[sfmskywalker]

Orleans is now implemented as a workflow dispatch provider. Which means that workflows can now be executed within grains.

[gentledepp]

wow cool! is there a sample for this?

[sfmskywalker]

I'm not sure. Either I mistyped "Proto.Actor" as "Orleans", or it was actually there at some point in time, but honestly I have no recollection of that. Even so, the Proto.Actor implementation might serve well as a conceptual example for how it could work in Orleans.

https://github.com/elsa-workflows/elsa-extensions/tree/main/src/modules/runtimes/Elsa.Workflows.Runtime.ProtoActor