Guides

Event-Driven Saga


Event-Driven Saga

In an event-driven saga, each step sends a request to an external service and then waits for a confirmation event before proceeding. This is the right approach when external services are asynchronous — such as a payment gateway that processes charges via webhooks, or a warehouse system that confirms inventory reservations through a message queue. The workflow uses wait_for_event_with_timeout to pause until the external system responds, with a timeout to handle cases where the external service never replies.

Request payment
►
Payment Gateway
external
wait_for_event("payment_confirmed")
timeout: 5 min
Request inventory
►
Warehouse
external
wait_for_event("inventory_reserved")
timeout: 10 min
Request shipping
►
Shipping API
external
wait_for_event("shipping_confirmed")
timeout: 30 min
Order Complete
1
use orcher::prelude::*;
2
use anyhow::Result;
3
use std::time::Duration;
4
5
#[derive(Debug, Clone, Serialize, Deserialize)]
6
enum SagaEvent {
7
InventoryReserved { inventory_id: String },
8
PaymentAuthorized { payment_id: String },
9
ShipmentCreated { shipment_id: String },
10
StepFailed { step: String, reason: String },
11
}
12
13
// Event-driven saga
14
#[workflow(name = "event_driven_saga", version = "1.0.0")]
15
pub async fn event_driven_saga(
16
ctx: WorkflowContext,
17
order: OrderData,
18
) -> Result<OrderResult> {
19
println!("Starting event-driven saga");
20
21
let mut state = SagaState::new(order.order_id.clone());
22
23
// Step 1: Reserve inventory (wait for external confirmation)
24
ctx.execute_task(request_inventory_reservation, order.items.clone()).await?;
25
26
let inventory_event: Option<SagaEvent> = ctx
27
.wait_for_event_with_timeout("inventory_result", Duration::from_secs(300))
28
.await?;
29
30
match inventory_event {
31
Some(SagaEvent::InventoryReserved { inventory_id }) => {
32
state.inventory_reserved = true;
33
state.inventory_id = Some(inventory_id);
34
}
35
Some(SagaEvent::StepFailed { reason, .. }) => {
36
println!("Inventory reservation failed: {}", reason);
37
return Ok(OrderResult {
38
order_id: order.order_id,
39
success: false,
40
..Default::default()
41
});
42
}
43
None => {
44
println!("Inventory reservation timed out");
45
return Ok(OrderResult {
46
order_id: order.order_id,
47
success: false,
48
..Default::default()
49
});
50
}
51
_ => unreachable!(),
52
}
53
54
// Step 2: Authorize payment (wait for external confirmation)
55
ctx.execute_task(request_payment_authorization, order.amount).await?;
56
57
let payment_event: Option<SagaEvent> = ctx
58
.wait_for_event_with_timeout("payment_result", Duration::from_secs(300))
59
.await?;
60
61
match payment_event {
62
Some(SagaEvent::PaymentAuthorized { payment_id }) => {
63
state.payment_captured = true;
64
state.payment_id = Some(payment_id);
65
}
66
Some(SagaEvent::StepFailed { reason, .. }) | None => {
67
println!("Payment failed, compensating");
68
compensate_saga(&ctx, &state).await?;
69
return Ok(OrderResult {
70
order_id: order.order_id,
71
success: false,
72
..Default::default()
73
});
74
}
75
_ => unreachable!(),
76
}
77
78
// Step 3: Create shipment (wait for external confirmation)
79
ctx.execute_task(request_shipment_creation, order.order_id.clone()).await?;
80
81
let shipment_event: Option<SagaEvent> = ctx
82
.wait_for_event_with_timeout("shipment_result", Duration::from_secs(300))
83
.await?;
84
85
match shipment_event {
86
Some(SagaEvent::ShipmentCreated { shipment_id }) => {
87
state.shipment_created = true;
88
state.shipment_id = Some(shipment_id);
89
}
90
Some(SagaEvent::StepFailed { reason, .. }) | None => {
91
println!("Shipment failed, compensating");
92
compensate_saga(&ctx, &state).await?;
93
return Ok(OrderResult {
94
order_id: order.order_id,
95
success: false,
96
..Default::default()
97
});
98
}
99
_ => unreachable!(),
100
}
101
102
println!("Event-driven saga completed");
103
Ok(OrderResult {
104
order_id: order.order_id,
105
success: true,
106
payment_id: state.payment_id,
107
inventory_id: state.inventory_id,
108
shipment_id: state.shipment_id,
109
})
110
}

Next Steps