Isolation Levels & Distributed Sagas

# Python Async Saga Orchestrator with Compensations
class OrderSagaOrchestrator:
    def __init__(self):
        self.compensations = []

    async def execute(self, order_id: str, amount: float):
        try:
            # Step 1: Create Order
            await order_service.create(order_id, amount)
            self.compensations.append(lambda: order_service.cancel(order_id))

            # Step 2: Authorize Payment
            payment_id = await payment_service.charge(order_id, amount)
            self.compensations.append(lambda: payment_service.refund(payment_id))

            # Step 3: Reserve Inventory (May Fail!)
            await inventory_service.reserve(order_id)
            self.compensations.append(lambda: inventory_service.release(order_id))

            return "SAGA_COMPLETED"
        except Exception as e:
            # Rollback in reverse order
            for compensate in reversed(self.compensations):
                await compensate()
            raise Exception(f"Saga Failed, rolled back: {e}")

// C++20 Distributed Saga Pipeline
#include <vector>
#include <functional>

class SagaOrchestrator {
    std::vector<std::function<void()>> compensations;
public:
    bool executeOrderSaga(std::string orderId, double amount) {
        if (!orderService.create(orderId)) return false;
        compensations.push_back([=]() { orderService.cancel(orderId); });

        if (!paymentService.charge(orderId, amount)) { rollback(); return false; }
        compensations.push_back([=]() { paymentService.refund(orderId); });

        if (!inventoryService.reserve(orderId)) { rollback(); return false; }
        return true;
    }
    void rollback() {
        for (auto it = compensations.rbegin(); it != compensations.rend(); ++it) (*it)();
    }
};

// Java Temporal.io Saga Workflow
@WorkflowInterface
public interface OrderWorkflow {
    @WorkflowMethod
    void processOrder(OrderRequest request);
}

public class OrderWorkflowImpl implements OrderWorkflow {
    @Override
    public void processOrder(OrderRequest req) {
        Saga saga = new Saga(new Saga.Options.Builder().setParallelCompensation(false).build());
        try {
            activities.createOrder(req.getId());
            saga.addCompensation(activities::cancelOrder, req.getId());

            activities.chargePayment(req.getId(), req.getAmount());
            saga.addCompensation(activities::refundPayment, req.getId());

            activities.reserveInventory(req.getId());
        } catch (Exception e) {
            saga.compensate(); // Automatically executes in reverse!
            throw e;
        }
    }
}

// Go Saga Execution Engine
type Saga struct {
    compensations []func() error
}

func (s *Saga) AddCompensation(fn func() error) {
    s.compensations = append(s.compensations, fn)
}

func (s *Saga) Rollback() {
    for i := len(s.compensations) - 1; i >= 0; i-- {
        _ = s.compensations[i]()
    }
}

// TypeScript Orchestrator Step Engine
export class SagaOrchestrator {
  private compensations: Array<() => Promise<void>> = [];

  async step(action: () => Promise<void>, compensate: () => Promise<void>) {
    try {
      await action();
      this.compensations.push(compensate);
    } catch (err) {
      await this.rollback();
      throw err;
    }
  }

  async rollback() {
    for (const undo of this.compensations.reverse()) {
      await undo();
    }
  }
}