Sagaway

https://github.com/zio-net/sagaway
Admin
Sagaway is a distributed application framework that implements the Saga pattern for orchestrating...
Tokens:7,938
Snippets:63
Trust Score:5.1
License:MIT
Update:5 months ago
Show doc for...
Tokens:
Raw
### Configure ASP.NET Host with Dapr and Callback Routing

Source: https://context7.com/zio-net/sagaway/llms.txt

Sets up an ASP.NET Core application with Dapr integration, actor services, JSON serialization, and Sagaway's callback router. Ensure Dapr SDK and Sagaway packages are installed.

```csharp
using System.Text.Json;
using System.Text.Json.Serialization;
using Dapr.Actors;
using Dapr.Actors.Client;
using Microsoft.AspNetCore.Mvc;
using OpenTelemetry.Trace;
using Sagaway.Callback.Router;
using Sagaway.OpenTelemetry;

var builder = WebApplication.CreateBuilder(args);

// Configure JSON serialization
builder.Services.AddControllers().AddDapr().AddJsonOptions(options =>
{
    options.JsonSerializerOptions.PropertyNamingPolicy = JsonNamingPolicy.CamelCase;
    options.JsonSerializerOptions.Converters.Add(new JsonStringEnumConverter());
    options.JsonSerializerOptions.PropertyNameCaseInsensitive = true;
});

// Register Dapr actors
builder.Services.AddActors(options =>
{
    options.Actors.RegisterActor<CarReservationActor>();
    options.Actors.RegisterActor<CarReservationCancellationActor>();

    options.ActorIdleTimeout = TimeSpan.FromMinutes(10);
    options.ActorScanInterval = TimeSpan.FromSeconds(35);
    options.DrainOngoingCallTimeout = TimeSpan.FromSeconds(35);
    options.DrainRebalancedActors = true;

    options.JsonSerializerOptions = new JsonSerializerOptions
    {
        PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
        Converters = { new JsonStringEnumConverter() },
        PropertyNameCaseInsensitive = true
    };
});

// Add OpenTelemetry for distributed tracing
builder.Services.AddSagawayOpenTelemetry(tracerProvider =>
{
    tracerProvider
        .AddAspNetCoreInstrumentation(opt => opt.Filter = ctx => ctx.Request.Path != "/healthz")
        .AddHttpClientInstrumentation()
        .AddZipkinExporter(opt => opt.Endpoint = new Uri("http://zipkin:9411/api/v2/spans"))
        .SetSampler(new AlwaysOnSampler());
}, "ReservationManagerService");

builder.Services.AddHealthChecks();

var app = builder.Build();

// Enable automatic callback routing for the specified Dapr binding
app.UseSagawayCallbackRouter("reservation-response-queue");

// API endpoint to start a saga
app.MapPost("/reserve", async (
    [FromQuery] Guid? reservationId,
    [FromQuery] string customerName,
    [FromQuery] string carClass,
    [FromServices] IActorProxyFactory actorProxyFactory) =>
{
    reservationId ??= Guid.NewGuid();

    var proxy = actorProxyFactory.CreateActorProxy<ICarReservationActor>(
        new ActorId(reservationId.Value.ToString("D")), "CarReservationActor");

    var reservationInfo = new ReservationInfo
    {
        ReservationId = reservationId.Value,
        CustomerName = customerName,
        CarClass = carClass
    };

    await proxy.ReserveCarAsync(reservationInfo);
    return reservationInfo;
});

app.MapHealthChecks("/healthz");
app.MapControllers();
app.MapSubscribeHandler();
app.UseRouting();
app.MapActorsHandlers();

app.Run();

```

--------------------------------

### Callback Handler for Payment Result

Source: https://context7.com/zio-net/sagaway/llms.txt

This example demonstrates a callback handler that reports operation outcomes based on payment results. It uses `sagaFastOutcome: SagaFastOutcome.Failure` for immediate failure when a card is declined.

```csharp
// Complete callback handler example
private async Task OnPaymentResultAsync(PaymentResult result)
{
    if (result.Status == PaymentStatus.Declined)
    {
        // Card declined - fail fast, no point in retrying
        await ReportCompleteOperationOutcomeAsync(
            OrderOperations.ProcessPayment,
            isSuccess: false,
            sagaFastOutcome: SagaFastOutcome.Failure);
    }
    else if (result.Status == PaymentStatus.Approved)
    {
        await ReportCompleteOperationOutcomeAsync(
            OrderOperations.ProcessPayment,
            isSuccess: true);
    }
    else
    {
        // Pending or error - report failure, saga will retry
        await ReportCompleteOperationOutcomeAsync(
            OrderOperations.ProcessPayment,
            isSuccess: false);
    }
}
```

--------------------------------

### Calculate Default Exponential Backoff Intervals

Source: https://context7.com/zio-net/sagaway/llms.txt

Get default retry intervals in seconds, starting at 10 seconds, capping at 32 seconds, with 10% jitter.

```csharp
// Exponential backoff in seconds (default: 10s initial, 32s max, 10% jitter)
var retryInSeconds = ExponentialBackoff.InSeconds();
```

--------------------------------

### Invoke Dapr Method and Binding

Source: https://context7.com/zio-net/sagaway/llms.txt

Demonstrates invoking a Dapr method to get reservation state and invoking a Dapr binding for a compensation operation. Ensure Dapr client is configured.

```csharp
var state = await DaprClient.InvokeMethodAsync<ReservationState>(
            HttpMethod.Get, "booking-management", $"/reservations/{_reservationInfo!.ReservationId}");
        return state.IsReserved;
    }

    // Compensation (undo) operation
    private async Task RevertBookCarReservationAsync()
    {
        var request = new CarReservationRequest
        {
            ActionType = CarReservationRequestActionType.Cancel,
            ReservationId = _reservationInfo!.ReservationId
        };
        await DaprClient.InvokeBindingAsync("booking-queue", "create", request,
            GetCallbackMetadata(nameof(OnRevertBookCarReservationAsync)));
    }

    private async Task OnRevertBookCarReservationAsync(ReservationOperationResult result)
    {
        await ReportUndoOperationOutcomeAsync(CarReservationActorOperations.CarBooking, result.IsSuccess);
    }

    private async Task<bool> ValidateRevertBookCarReservationAsync() => !await ValidateBookCarReservationAsync();

    // Similar implementations for other operations...
    private Task ReserveInventoryAsync() => Task.CompletedTask;
    private Task<bool> ValidateReserveInventoryAsync() => Task.FromResult(true);
    private Task RevertReserveInventoryAsync() => Task.CompletedTask;
    private Task<bool> ValidateRevertReserveInventoryAsync() => Task.FromResult(true);
    private Task BillReservationAsync() => Task.CompletedTask;
    private Task<bool> ValidateBillReservationAsync() => Task.FromResult(true);
    private Task RevertBillReservationAsync() => Task.CompletedTask;
    private Task<bool> ValidateRevertBillReservationAsync() => Task.FromResult(true);
}
```

--------------------------------

### API Endpoint to Check Saga Status

Source: https://context7.com/zio-net/sagaway/llms.txt

Expose an API endpoint using MapGet to retrieve the current status of a saga. This uses an IActorProxyFactory to get the saga status from the actor.

```csharp
// Checking saga status before reset
app.MapGet("/saga-status/{reservationId}", async (
    [FromRoute] Guid reservationId,
    [FromServices] IActorProxyFactory actorProxyFactory) =>
{
    var proxy = actorProxyFactory.CreateActorProxy<ICarReservationActor>(
        new ActorId(reservationId.ToString("D")), "CarReservationActor");

    var status = proxy.GetSagaStatus();
    return Results.Ok(status);
});
```

--------------------------------

### Configure Saga Operation Retries with Exponential Backoff

Source: https://context7.com/zio-net/sagaway/llms.txt

Set maximum retries and custom retry intervals for both the main operation and its undo operation within a saga. The example shows specific retry intervals for payment processing and refund operations.

```csharp
// Usage in saga builder
var saga = Saga<OrderOperations>.Create(orderId, sagaSupport, logger)
    .WithOnSuccessCompletionCallback(log => { })
    .WithOnRevertedCallback(log => { })

    .WithOperation(OrderOperations.ProcessPayment)
    .WithDoOperation(ProcessPaymentAsync)
    .WithMaxRetries(5)
    .WithRetryIntervalTime(ExponentialBackoff.InSeconds(initDelay: 3, maxSeconds: 60))
    .WithValidateFunction(ValidatePaymentAsync)
    .WithUndoOperation(RefundPaymentAsync)
    .WithMaxRetries(10)
    .WithUndoRetryInterval(ExponentialBackoff.InMinutes(initDelay: 1, maxMinutes: 15))
    .WithValidateFunction(ValidateRefundAsync)

    .Build();

// Retry intervals will be approximately:
// Attempt 1: ~3s, Attempt 2: ~5s, Attempt 3: ~11s, Attempt 4: ~19s, Attempt 5: ~35s (capped at 60s)
```

--------------------------------

### Configure Order Saga Actor with External Step Recorder

Source: https://context7.com/zio-net/sagaway/llms.txt

Implement an actor that uses an externally registered IStepRecorder. Ensure the saga is built with the provided step recorder instance.

```csharp
// Actor implementation
public class OrderSagaActor : DaprActorHost<OrderOperations>, IOrderSagaActor
{
    private readonly IStepRecorder _stepRecorder;

    public OrderSagaActor(ActorHost host, ILogger<OrderSagaActor> logger,
        IServiceProvider serviceProvider)
        : base(host, logger, serviceProvider)
    {
        _stepRecorder = serviceProvider.GetRequiredService<IStepRecorder>();
    }

    protected override ISaga<OrderOperations> ReBuildSaga()
    {
        return Saga<OrderOperations>.Create(ActorHost.Id.ToString(), this, Logger)
            .WithStepRecorder(_stepRecorder)  // Use external step recorder
            .WithOnSuccessCompletionCallback(log => Logger.LogInformation(log))
            .WithOnRevertedCallback(log => Logger.LogWarning(log))
            // ... operations
            .Build();
    }
}
```

--------------------------------

### Configure Custom Exponential Backoff Intervals in Minutes

Source: https://context7.com/zio-net/sagaway/llms.txt

Set custom retry intervals in minutes, including initial delay, maximum duration, and jitter percentage.

```csharp
// Custom exponential backoff in minutes
var customMinutesBackoff = ExponentialBackoff.InMinutes(
    initDelay: 2,     // Start with 2 minutes
    maxMinutes: 30,   // Cap at 30 minutes
    jitterFactor: 0.15 // 15% variance
);
```

--------------------------------

### Build a Saga with Fluent API

Source: https://context7.com/zio-net/sagaway/llms.txt

Construct a Saga instance using the fluent builder. Configure operations, their execution logic, retry policies, validation functions, and compensation actions. Supports sequential and parallel execution with defined preconditions.

```csharp
// Build a saga with multiple operations
var saga = Saga<OrderSagaOperations>.Create(orderId.ToString(), sagaSupport, logger)
    .WithOnSuccessCompletionCallback(log => Console.WriteLine($"Order completed: {log}"))
    .WithOnRevertedCallback(log => Console.WriteLine($"Order rolled back: {log}"))
    .WithOnFailedRevertedCallback(log => Console.WriteLine($"Partial rollback failure: {log}"))
    .WithOnFailedCallback(log => Console.WriteLine($"Order failed, starting compensation: {log}"))

    // First operation - runs immediately
    .WithOperation(OrderSagaOperations.CreateOrder)
    .WithDoOperation(CreateOrderAsync)
    .WithMaxRetries(3)
    .WithRetryIntervalTime(TimeSpan.FromSeconds(10))
    .WithValidateFunction(ValidateOrderCreatedAsync)
    .WithUndoOperation(CancelOrderAsync)
    .WithMaxRetries(3)
    .WithUndoRetryInterval(TimeSpan.FromSeconds(15))
    .WithValidateFunction(ValidateOrderCancelledAsync)

    // Second operation - runs in parallel with CreateOrder
    .WithOperation(OrderSagaOperations.ReserveInventory)
    .WithDoOperation(ReserveInventoryAsync)
    .WithMaxRetries(5)
    .WithRetryIntervalTime(ExponentialBackoff.InSeconds(initDelay: 5, maxSeconds: 60))
    .WithValidateFunction(ValidateInventoryReservedAsync)
    .WithUndoOperation(ReleaseInventoryAsync)
    .WithMaxRetries(3)
    .WithUndoRetryInterval(ExponentialBackoff.InSeconds())
    .WithValidateFunction(ValidateInventoryReleasedAsync)

    // Third operation - waits for CreateOrder AND ReserveInventory to complete
    .WithOperation(OrderSagaOperations.ProcessPayment)
    .WithDoOperation(ProcessPaymentAsync)
    .WithMaxRetries(3)
    .WithRetryIntervalTime(ExponentialBackoff.InMinutes())
    .WithValidateFunction(ValidatePaymentProcessedAsync)
    .WithPreconditions(OrderSagaOperations.CreateOrder | OrderSagaOperations.ReserveInventory)
    .WithUndoOperation(RefundPaymentAsync)
    .WithMaxRetries(5)
    .WithUndoRetryInterval(ExponentialBackoff.InMinutes())
    .WithValidateFunction(ValidatePaymentRefundedAsync)

    .Build();
```

--------------------------------

### Calculate Default Exponential Backoff Intervals in Minutes

Source: https://context7.com/zio-net/sagaway/llms.txt

Retrieve default retry intervals in minutes, with a 1-minute initial delay, an 8-minute maximum, and 10% jitter.

```csharp
// Exponential backoff in minutes (default: 1min initial, 8min max, 10% jitter)
var retryInMinutes = ExponentialBackoff.InMinutes();
```

--------------------------------

### Implement Dapr Actor Host with Sagaway

Source: https://context7.com/zio-net/sagaway/llms.txt

Implements the Dapr Actor host for car reservations, extending DaprActorHost and configuring the saga lifecycle.

```csharp
[Actor(TypeName = "CarReservationActor")]
public class CarReservationActor : DaprActorHost<CarReservationActorOperations>, ICarReservationActor
{
    private readonly ILogger<CarReservationActor> _logger;
    private ReservationInfo? _reservationInfo;

    public CarReservationActor(ActorHost host, ILogger<CarReservationActor> logger, IServiceProvider serviceProvider)
        : base(host, logger, serviceProvider)
    {
        _logger = logger;
    }

    // Required: specify the callback binding for async responses
    protected override string GetCallbackBindingName() => "reservation-response-queue";

    // Required: rebuild the saga configuration on each activation
    protected override ISaga<CarReservationActorOperations> ReBuildSaga()
    {
        return Saga<CarReservationActorOperations>.Create(ActorHost.Id.ToString(), this, _logger)
            .WithOnSuccessCompletionCallback(log => _logger.LogInformation("Reservation succeeded"))
            .WithOnRevertedCallback(log => _logger.LogWarning("Reservation reverted"))
            .WithOnFailedRevertedCallback(log => _logger.LogError("Reservation partially failed"))
            .WithOnFailedCallback(log => _logger.LogError("Reservation failed"))

            .WithOperation(CarReservationActorOperations.CarBooking)
            .WithDoOperation(BookCarReservationAsync)
            .WithMaxRetries(3)
            .WithRetryIntervalTime(TimeSpan.FromMinutes(2))
            .WithValidateFunction(ValidateBookCarReservationAsync)
            .WithUndoOperation(RevertBookCarReservationAsync)
            .WithMaxRetries(3)
            .WithUndoRetryInterval(TimeSpan.FromMinutes(10))
            .WithValidateFunction(ValidateRevertBookCarReservationAsync)

            .WithOperation(CarReservationActorOperations.InventoryReserving)
            .WithDoOperation(ReserveInventoryAsync)
            .WithMaxRetries(3)
            .WithRetryIntervalTime(ExponentialBackoff.InSeconds())
            .WithValidateFunction(ValidateReserveInventoryAsync)
            .WithUndoOperation(RevertReserveInventoryAsync)
            .WithMaxRetries(3)
            .WithUndoRetryInterval(ExponentialBackoff.InSeconds())
            .WithValidateFunction(ValidateRevertReserveInventoryAsync)

            .WithOperation(CarReservationActorOperations.Billing)
            .WithDoOperation(BillReservationAsync)
            .WithMaxRetries(3)
            .WithRetryIntervalTime(ExponentialBackoff.InSeconds())
            .WithValidateFunction(ValidateBillReservationAsync)
            .WithPreconditions(CarReservationActorOperations.CarBooking | CarReservationActorOperations.InventoryReserving)
            .WithUndoOperation(RevertBillReservationAsync)
            .WithMaxRetries(3)
            .WithUndoRetryInterval(ExponentialBackoff.InSeconds())
            .WithValidateFunction(ValidateRevertBillReservationAsync)

            .Build();
    }

    // Optional: load custom state when saga activates
    protected override async Task OnActivateSagaAsync()
    {
        _reservationInfo = (await StateManager.TryGetStateAsync<ReservationInfo>("reservationInfo")).Value;
    }

    // Public actor method to start the saga
    public async Task ReserveCarAsync(ReservationInfo reservationInfo)
    {
        await StateManager.SetStateAsync("reservationInfo", reservationInfo);
        _reservationInfo = reservationInfo;
        await SagaRunAsync();
    }

    // Operation implementation with async callback
    private async Task BookCarReservationAsync()
    {
        var request = new CarReservationRequest
        {
            ActionType = CarReservationRequestActionType.Reserve,
            CarClass = _reservationInfo!.CarClass,
            CustomerName = _reservationInfo.CustomerName,
            ReservationId = _reservationInfo.ReservationId
        };

        // Use GetCallbackMetadata to enable automatic callback routing
        await DaprClient.InvokeBindingAsync("booking-queue", "create", request,
            GetCallbackMetadata(nameof(OnCarBookingResultAsync)));
    }

    // Callback handler - automatically dispatched by Sagaway
    private async Task OnCarBookingResultAsync(ReservationOperationResult result)
    {
        await ReportCompleteOperationOutcomeAsync(CarReservationActorOperations.CarBooking, result.IsSuccess);
    }

    // Validation function for timeout scenarios
    private async Task<bool> ValidateBookCarReservationAsync()
    {

```

--------------------------------

### Execute the Saga

Source: https://context7.com/zio-net/sagaway/llms.txt

Initiate the execution of the configured Saga. This asynchronous method will run the defined operations according to their configurations, including retries and compensations.

```csharp
// Execute the saga
await saga.RunAsync();
```

--------------------------------

### Configure Custom Exponential Backoff Intervals in Seconds

Source: https://context7.com/zio-net/sagaway/llms.txt

Define custom retry intervals in seconds, specifying initial delay, maximum duration, and jitter factor.

```csharp
// Custom exponential backoff in seconds
var customSecondsBackoff = ExponentialBackoff.InSeconds(
    initDelay: 5,      // Start with 5 seconds
    maxSeconds: 120,   // Cap at 2 minutes
    jitterFactor: 0.2  // 20% variance
);
```

--------------------------------

### Configure Dapr with Sagaway Context Propagation

Source: https://context7.com/zio-net/sagaway/llms.txt

Set up ASP.NET Core services to include Dapr and Sagaway's context propagation. Ensure JSON serialization uses camel case and string enums.

```csharp
using System.Text.Json;
using System.Text.Json.Serialization;
using Dapr.Client;
using Microsoft.AspNetCore.Mvc;
using Sagaway.Callback.Propagator;

var builder = WebApplication.CreateBuilder(args);

// Add Dapr with Sagaway context propagation support
builder.Services.AddControllers().AddDaprWithSagawayContextPropagator().AddJsonOptions(options =>
{
    options.JsonSerializerOptions.PropertyNamingPolicy = JsonNamingPolicy.CamelCase;
    options.JsonSerializerOptions.Converters.Add(new JsonStringEnumConverter());
});

// Register context propagator services
builder.Services.AddSagawayContextPropagator();
builder.Services.AddHealthChecks();

var app = builder.Build();

// Enable context propagation middleware
app.UseSagawayContextPropagator();

// Participant service endpoint - receives requests from Saga
app.MapPost("/booking-queue", async (
    [FromBody] CarReservationRequest request,
    [FromHeader(Name = "x-sagaway-dapr-message-dispatch-time")] string messageDispatchTime,
    [FromServices] ICallbackBindingNameProvider callbackBindingNameProvider,
    [FromServices] DaprClient daprClient,
    [FromServices] ILogger<Program> logger) =>
{
    logger.LogInformation("Processing booking request for {ReservationId}, dispatched at {Time}",
        request.ReservationId, messageDispatchTime);

    // Process the request
    var success = await ProcessBookingAsync(request);

    // Send result back to the Saga using the callback binding
    var result = new ReservationOperationResult
    {
        ReservationId = request.ReservationId,
        IsSuccess = success
    };

    // The callback binding name and metadata are automatically propagated
    await daprClient.InvokeBindingAsync(
        callbackBindingNameProvider.CallbackBindingName,
        "create",
        result);

    return Results.Ok();
});

// Validation endpoint for the Saga to poll
app.MapGet("/reservations/{reservationId}", async (
    [FromRoute] Guid reservationId,
    [FromServices] IReservationRepository repository) =>
{
    var state = await repository.GetReservationStateAsync(reservationId);
    return Results.Ok(new ReservationState { IsReserved = state != null });
});

app.MapHealthChecks("/healthz");
app.Run();

async Task<bool> ProcessBookingAsync(CarReservationRequest request)
{
    // Simulate booking logic
    await Task.Delay(100);
    return request.ActionType == CarReservationRequestActionType.Reserve;
}

```

--------------------------------

### Subscribe to Saga Completion Event

Source: https://context7.com/zio-net/sagaway/llms.txt

Subscribe to the Saga's completion event to log the final status. This allows for external monitoring and reaction to the Saga's outcome.

```csharp
// Subscribe to completion event
saga.OnSagaCompleted += (sender, args) =>
{
    Console.WriteLine($"Saga {args.SagaId} finished with status: {args.Status}");
};
```

--------------------------------

### Register Dapr Store Step Recorder in C#

Source: https://context7.com/zio-net/sagaway/llms.txt

Register the DaprStoreStepRecorder for external saga logging. This reduces overhead for long-running sagas by storing logs in a Dapr state store.

```csharp
builder.Services.RegisterSagawayStepRecorderDaprStore("statestore");
```

```csharp
// Alternative: Manual registration
builder.Services.AddSingleton<IStepRecorder>(sp =>
{
    var daprClient = sp.GetRequiredService<DaprClient>();
    return new DaprStoreStepRecorder("statestore", daprClient);
});
```

--------------------------------

### API Endpoint to Trigger Saga Reset

Source: https://context7.com/zio-net/sagaway/llms.txt

Expose an API endpoint using MapPost to trigger the saga reset process for a specific reservation. This requires an IActorProxyFactory to create a proxy to the target actor.

```csharp
// API endpoint to trigger saga reset
app.MapPost("/reset-reservation/{reservationId}", async (
    [FromRoute] Guid reservationId,
    [FromServices] IActorProxyFactory actorProxyFactory) =>
{
    var proxy = actorProxyFactory.CreateActorProxy<ICarReservationActor>(
        new ActorId(reservationId.ToString("D")), "CarReservationActor");

    await proxy.RetryReservationAsync();
    return Results.Ok($"Reservation {reservationId} has been reset");
});
```

--------------------------------

### Report Operation Outcomes with SagaFastOutcome

Source: https://context7.com/zio-net/sagaway/llms.txt

Use `ReportCompleteOperationOutcomeAsync` to report success or failure. The `sagaFastOutcome` parameter allows for immediate saga completion or failure, bypassing standard compensation flows.

```csharp
// Standard operation success reporting
await ReportCompleteOperationOutcomeAsync(OrderOperations.CreateOrder, isSuccess: true);
```

```csharp
// Standard operation failure reporting
await ReportCompleteOperationOutcomeAsync(OrderOperations.CreateOrder, isSuccess: false);
```

```csharp
// Fast-fail: Immediately fail saga and start compensation
await ReportCompleteOperationOutcomeAsync(OrderOperations.CreateOrder,
    isSuccess: false,
    sagaFastOutcome: SagaFastOutcome.Failure);
```

```csharp
// Fast-success: Immediately complete saga, mark unstarted operations as succeeded
await ReportCompleteOperationOutcomeAsync(OrderOperations.FinalStep,
    isSuccess: true,
    sagaFastOutcome: SagaFastOutcome.Success);
```

```csharp
// Report undo operation outcome during compensation
await ReportUndoOperationOutcomeAsync(OrderOperations.CreateOrder, isSuccess: true);
```

--------------------------------

### Sub-Saga Actor Performing Addition and Callback

Source: https://context7.com/zio-net/sagaway/llms.txt

The `SubSagaActor` implements the `AddNumbersAsync` operation, performs the addition, and then uses `CallbackMainSagaAsync` to send the result back to the main saga. It also reports its own operation outcome.

```csharp
// Sub-Saga Actor
public class SubSagaActor : DaprActorHost<SubSagaOperations>, ISubSagaActor
{
    public async Task AddNumbersAsync(int a, int b)
    {
        Logger.LogInformation("Sub-saga: Adding {A} + {B}", a, b);

        var result = a + b;

        // Send result back to main saga
        await CallbackMainSagaAsync(new AddResult { Result = result });

        // Report operation success to sub-saga
        await ReportCompleteOperationOutcomeAsync(SubSagaOperations.Add, true);
    }
}
```

--------------------------------

### Dapr RabbitMQ Binding Configuration

Source: https://context7.com/zio-net/sagaway/llms.txt

Configure Dapr components for RabbitMQ queues used for asynchronous communication. This includes setting queue names, host, and durability.

```yaml
# dapr/components/reservation-response-queue.yaml
apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: reservation-response-queue
spec:
  type: bindings.rabbitmq
  version: v1
  metadata:
  - name: queueName
    value: reservation-response-queue
  - name: host
    value: "amqp://rabbitmq:5672"
  - name: durable
    value: true
  - name: deleteWhenUnused
    value: false
  - name: ttlInSeconds
    value: 60
  - name: prefetchCount
    value: 0
  - name: exclusive
    value: false
  - name: maxPriority
    value: 5
  - name: contentType
    value: "text/plain"
---
# dapr/components/booking-queue.yaml
apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: booking-queue
spec:
  type: bindings.rabbitmq
  version: v1
  metadata:
  - name: queueName
    value: booking-queue
  - name: host
    value: "amqp://rabbitmq:5672"
  - name: durable
    value: true

```

--------------------------------

### Dapr Redis State Store Configuration

Source: https://context7.com/zio-net/sagaway/llms.txt

Configure a Dapr component for a Redis state store. This includes specifying the Redis host and marking it as an actor state store.

```yaml
# dapr/components/statestore.yaml
apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: statestore
spec:
  type: state.redis
  version: v1
  metadata:
  - name: redisHost
    value: redis:6379
  - name: actorStateStore
    value: "true"

```

--------------------------------

### Disable Step Recording in Saga Actor

Source: https://context7.com/zio-net/sagaway/llms.txt

Configure a saga actor to disable step recording entirely for performance. This is achieved by using a null step recorder.

```csharp
// Alternative: Disable step recording entirely for performance
protected override ISaga<OrderOperations> ReBuildSaga()
{
    return Saga<OrderOperations>.Create(ActorHost.Id.ToString(), this, Logger)
        .WithNullStepRecorder()  // No logging overhead
        .WithOnSuccessCompletionCallback(_ => { })
        .WithOnRevertedCallback(_ => { })
        // ... operations
        .Build();
}
```

--------------------------------

### Main Saga Actor Invoking a Sub-Saga

Source: https://context7.com/zio-net/sagaway/llms.txt

The `MainSagaActor` uses `CallSubSagaAsync` to invoke a sub-saga's operation. It specifies the actor type, ID, and callback method, along with custom metadata for the call.

```csharp
public interface ISubSagaActor : ISagawayActor
{
    Task AddNumbersAsync(int a, int b);
}

public class AddResult
{
    public int Result { get; set; }
}

// Main Saga Actor
public class MainSagaActor : DaprActorHost<MainSagaOperations>, IMainSagaActor
{
    // Operation that calls a sub-saga
    private async Task OnCallSubSagaAsync()
    {
        Logger.LogInformation("Main saga: Starting sub-saga...");

        // Call sub-saga with callback method specified
        await CallSubSagaAsync<ISubSagaActor>(
            subSaga => subSaga.AddNumbersAsync(38, 4),
            actorTypeName: "SubSagaActor",
            newActorId: "Sub_" + ActorHost.Id,
            options: new CallSubSagaOptions(
                CallbackMethodName: nameof(OnSubSagaCallbackAsync),
                CustomSagawayMetadata: "calculation-context",
                CustomBindingMetadata: new Dictionary<string, string>
                {
                    { "priority", "high" }
                }
            )
        );
    }

    // Callback handler for sub-saga result
    private async Task OnSubSagaCallbackAsync(AddResult result)
    {
        if (result.Result == 42)
        {
            Logger.LogInformation("Main saga: Sub-saga completed with result: {Result}", result.Result);
            await ReportCompleteOperationOutcomeAsync(MainSagaOperations.SubSagaCall, true);
        }
        else
        {
            Logger.LogError("Main saga: Unexpected result from sub-saga");
            await ReportCompleteOperationOutcomeAsync(MainSagaOperations.SubSagaCall, false);
        }
    }
}
```

--------------------------------

### Define Actor Interface

Source: https://context7.com/zio-net/sagaway/llms.txt

Defines the contract for the Dapr Actor, specifying the public methods available to clients.

```csharp
public interface ICarReservationActor : IActor
{
    Task ReserveCarAsync(ReservationInfo reservationInfo);
}
```

--------------------------------

### Reset Saga State in C# Actor

Source: https://context7.com/zio-net/sagaway/llms.txt

Implement an actor method to reset its saga state using `ResetSagaAsync`. This clears persisted state and custom state, preparing for re-execution.

```csharp
// Actor method to reset saga state
public async Task RetryReservationAsync()
{
    // Reset the saga state in the Dapr actor state store
    await ResetSagaAsync();

    // Clear any custom state
    await StateManager.RemoveStateAsync("reservationInfo");

    // Log the reset
    Logger.LogInformation("Saga {SagaId} has been reset and is ready for re-execution", ActorHost.Id);
}
```

--------------------------------

### Define Actor Operations Enum

Source: https://context7.com/zio-net/sagaway/llms.txt

Defines the distinct operations within the car reservation saga using a Flags enum for bitwise operations.

```csharp
[Flags]
public enum CarReservationActorOperations
{
    CarBooking = 1,
    InventoryReserving = 2,
    Billing = 4
}
```

--------------------------------

### Define Saga Operations Enum

Source: https://context7.com/zio-net/sagaway/llms.txt

Define operations for a Saga using a flags enum. This allows for clear and concise representation of distinct steps within the transaction flow.

```csharp
// Define operations as a flags enum
[Flags]
public enum OrderSagaOperations
{
    CreateOrder = 1,
    ReserveInventory = 2,
    ProcessPayment = 4
}
```
Tokens:
Raw