driven | Data-Driven Constraint-based analysis | Database library

You are not passing two arguments to the method, but only one. For example, the first call passes an object[] containing two values, 0m and 0.

I find that it's very easy to get confused when using object arrays to pass the information and, of course, it's not type safe. And even if it doesn't confuse you, it's likely to confuse those who read your code.

I'd tend to do something like this instead...

Your domain should exactly match the table, you can use AutoMapper to map DTO and Entity for to and from DB operations, can you not simply do this with EntityFramework and AutoMapper?

Generally in concurrency a "future" is placeholder for a return value and it has an associated "promise" that is fulfilled to pass the final return value.

In C#, they have different names: the future is a Task and the promise is a TaskCompletionSource.

You can create a promise, await on it, and then fulfill it when you get your callback:

This issue is solved after correcting up my code

There's nothing in the SDK that would manage distributed transactions on your behalf. The simplest approach would likely be having a column in your database that allows you to mark when the event was published, and then have your function flow:

1. Write to the database with the "event published" flag unset; on failure abort.
2. Publish the event; on failure abort. (the data stays in written)
3. Write to the database to set the "event published" flag.

You'd need a second Function running on a timer that could scan your database for rows older than XX minutes ago that still need an event, which then do steps 2 and 3 from your initial flow. In failure scenarios, you will have some potential latency between the data being written and the event published or may see duplicate events. (Event Hubs has an at least once guarantee, so you'll need to be able to handle duplicates regardless.)

Using ^ instead of < should do the trick:

That's a great use case for Elsa and is something I am planning to create a sample application + guide for. So far, there are guides and samples about executing long-running "back-end" processes using Elsa, but there is now reason one couldn't also use it to implement application navigation logic such as wizards consisting of steps implemented as individual screens for example.

So that's your answer: yes, it is a relevant scenario. But it is unfortunate that there are no concrete samples to point you to at the moment.

Barring any samples, here's how it might work in a client application:

1. The client application has Elsa services configured.
2. Whether you decide to store workflow within the app (as code or JSON) or on a remote Elsa Server instance doesn't matter - once you have a workflow in memory, you can execute it.
3. Since your workflows will be driving UI, you have to think of how tightly-coupled the workflow will be with that UI. For example, a highly tight-coupled workflow might include activities that represent view (names) to present, including transition configuration if that is something to be configured, and outcomes based on what buttons were clicked. A highly loose-coupled workflow on the other hand might act more as a "conductor" or orchestrator of actions and events, where the workflow consists of nothing more than a bunch of primitives such as "SendCommand" and "Event Received", where a "SendCommand" simply raises some application event with a task name that your application then handles. The "Event Received" activity handles the other way around: your application fires instructions to Elsa, and Elsa drives the workflow. A task might be a "Navigate" instruction with the next view name provided as a parameter.

The "SendCommand" and "EventReceived" activities are very new and part of Elsa 2.1 preview packages. Right now they are directly coupled to webhook scenarios (where the commands are sent in the form of HTTP requests to an external application), but the goal is to have various strategies in place (HTTP out requests would just be one of them, another one might be a simple mediator pattern for in-process scenarios such as your client application one).

To retrieve workflows designed in the designer into your client app, you need to get the workflow definition via the following API endpoint:

http(s)://your-elsa-server/v1/workflow-definitions/{workflow-definition-id}/Published

What you'll get back is a JSON representing the workflow definition, which you can now deserialize using IContentSerializer.Deserialize, which will give you a WorkflowDefinition. But to be able to actually run a workflow, you need a workflow blueprint. To turn the workflow definition into a blueprint, use `IWorkflowBlueprintMaterializer.CreateWorkflowBlueprintAsync(WorkflowDefinition).

Which will give you a blueprint that can then be executed using e.g. IStartsWorkflow.StartWorkflowAsync(IWorkflowBlueprint).

There are various other services that make it more convenient to construct and run workflows.

To make this as frictionless as possible for your client app, you could consider simply implementing IWorkflowProvider, of which we currently have 3 out of the box:

1. ProgrammaticWorkflowProvider: provides workflow blueprints based on the workflows coded with the fluent Workflow Builder API.
2. DatabaseWorkflowProvider: provides blueprints based on those stored in the database (JSON models stored by the designer).
3. StorageWorkflowProvider: provides blueprints based on JSON files stored on some hard drive or blob storage such as Azure Blob Storage.

What you might do, and in fact what I think we should provide out of the box now that you made me think of it, is create a fourth provider that uses the API endpoints to get workflows from.

Then your client app should not have to be bothered with invoking the Elsa API - the provider does it for you.

The PostgreSQL executor produces result tuples (stored in a TupleTableSlot) "on demand". If you need the next result row from an execution plan node, you call its ExecProcNode function, which will return the desired result. This will in turn call ExecProcNode on other, lower plan nodes as needed.

The struct member ExecProcNode is of type ExecProcNodeMtd, which is defined as

The data in each of those topics will be retained as per a property log.retention.{hours|minutes|ms}. At the Kafka server level, this is set to 7 days by default for all topics. You could change this at a topic level as well.

In such a setting, a consumer will not be able to read the entire history if it needed to, so in this instance typically a consumer would:

1. consume the message i.e. "a marble no. 5 was added to red jar" at offset number 5
2. carry out the increment step i.e. redCount++ and store the latest information (redCount = 5) in a local state store
3. Then commit the offset back to Kafka telling that it has read the message at offset number 5
4. Then, just wait for the next message...

If however, your consumer doesn't have a local state store - In this case, you would need to increase the retention period i.e. log.retention.ms=-1 to store the data forever. You could configure the configure the consumers to store that information locally in memory but in the event of failures there would be no choice but for the consumers to read from the beginning. This I agree is inefficient.