Wait until Saga is Completed

[vecherkin]

Is there any "legal" way to wait until the Saga is Completed?
Sometimes need to start Saga and block, for example, UI operation until Saga is Completed or Rejected.

var coordinator = app.ApplicationServices.GetService<ISagaCoordinator>();

var context = SagaContext
    .Create()
    .WithCorrelationId(Guid.NewGuid())
    .Build();

// Sending initial Message/Event
coordinator.ProcessAsync(new Message1 { Text = "Hello" }, context);

// Desired behavior: block until Saga is Completed or Rejected and return ISagaState
var state = coordinator.WaitAsync(context);

Now I can do it with a few stupid lines of code:

// Helper extensions
public static class SagaExtensions
    {
        public static async Task<ISagaState> WaitAsync(this ISagaCoordinator coordinator, ISagaContext context, ISagaStateRepository sagaStateRepository)
        {
            var sagaState = await sagaStateRepository.GetStateAsync(context);
            while (sagaState is null || sagaState.State == SagaStates.Pending)
            {
                await Task.Delay(TimeSpan.FromSeconds(1));
                sagaState = await sagaStateRepository.GetStateAsync(context);
            }

            return sagaState;
        }

        public static async Task<ISagaState> GetStateAsync(this ISagaStateRepository sagaStateRepo, ISagaContext context)
        {
            return await sagaStateRepo.ReadAsync(context.SagaId, (Type) context.Metadata.First(md => md.Key == "sagaType").Value);
        }
    }

// Then in some place
var coordinator = app.ApplicationServices.GetService<ISagaCoordinator>();

var context = SagaContext
    .Create()
    .WithSagaId(SagaId.NewSagaId())
    .WithOriginator("Test")
    .WithMetadata("key", "lulz")
    .WithMetadata("sagaType", typeof(SampleSaga))
    .Build();

// Sending initial Message/Event
coordinator.ProcessAsync(new Message1 { Text = "Hello" }, context);

// Block until Saga is Completed or Rejected and return ISagaState
var sagaStateRepo = app.ApplicationServices.GetService<ISagaStateRepository>();
var state = await coordinator.WaitAsync(context, sagaStateRepo);

if (sagaState.State is SagaStates.Rejected)
{
// onRejected()
}

[GooRiOn]

ProcessAsync has an optional parameter beeing a lifecycle hook called "on completed". This should solve your issue in more elegant way :D

[vecherkin]

@GooRiOn thanks, but we want the following behavior:

1. User sends a message using endpoint, for example :

var coordinator = app.ApplicationServices.GetService<ISagaCoordinator>();
...
// Saga Started
await coordinator.ProcessAsync(new Message1 {Text = "Start"},
                onCompleted: (m, ctx) =>
                {
                    Console.WriteLine("My work is done. Message 1");
                    return Task.CompletedTask;
                },
                onRejected: (m, ctx) =>
                {
                    Console.WriteLine("My work is rejected. Message 1");
                    return Task.CompletedTask;
                },
                context);

2. Another process sends a message to Complete Saga:

var coordinator = app.ApplicationServices.GetService<ISagaCoordinator>();
...
// Saga Completed
await coordinator.ProcessAsync(
                    new Message2
                    {
                        Text =
                            "Finish"
                    },
                    onCompleted: (m, ctx) =>
                    {
                        Console.WriteLine("My work is done. Message 2");
                        return Task.CompletedTask;
                    },
                    onRejected: (m, ctx) =>
                    {
                        Console.WriteLine("My work is rejected. Message 2");
                        return Task.CompletedTask;
                    },
                    context: context);

In this case onCompleted will be called only with Message2:

await coordinator.ProcessAsync(
                    new Message2
                    {
                        Text =
                            "Finish"
                    },
                    onCompleted: (m, ctx) =>
                    {
                        Console.WriteLine("My work is done. Message 2");
                        return Task.CompletedTask;
                    },
                    onRejected: (m, ctx) =>
                    {
                        Console.WriteLine("My work is rejected. Message 2");
                        return Task.CompletedTask;
                    },
                    context: context);

But we want onCompleted will be called also with Message1.
Maybe I am wrong?

[vecherkin]

@GooRiOn And by the way, onCompleted is not blocking Thread, but I want User to wait until Saga is Completed