分布式数据一致性

// Saga 编排器伪代码
func CreateOrderSaga(ctx context.Context, req CreateOrderRequest) error {
    // Step 1: 创建订单
    order, err := orderService.Create(ctx, req)
    if err != nil { return err }

    // Step 2: 扣减库存
    err = inventoryService.Reserve(ctx, order.Items)
    if err != nil {
        // 补偿 Step 1
        orderService.Cancel(ctx, order.ID)
        return err
    }

    // Step 3: 扣款
    err = paymentService.Charge(ctx, order.UserID, order.Total)
    if err != nil {
        // 补偿 Step 2 + Step 1
        inventoryService.Release(ctx, order.Items)
        orderService.Cancel(ctx, order.ID)
        return err
    }

    // 全部成功 → 确认订单
    orderService.Confirm(ctx, order.ID)
    return nil
}

// 订单状态机
const (
    OrderPending   = "pending"    // 已创建,等待库存确认
    OrderConfirmed = "confirmed"  // 库存+支付确认
    OrderCancelled = "cancelled"  // 补偿完成
    OrderCompleted = "completed"  // 最终完成
)

// 状态变迁只允许合法路径
var validTransitions = map[string][]string{
    OrderPending:   {OrderConfirmed, OrderCancelled},
    OrderConfirmed: {OrderCompleted, OrderCancelled},
}

func (o *Order) TransitionTo(newState string) error {
    allowed := validTransitions[o.State]
    if !contains(allowed, newState) {
        return fmt.Errorf("invalid transition: %s → %s", o.State, newState)
    }
    o.State = newState
    return nil
}

// Saga 状态持久化 + 恢复(核心逻辑)
type SagaState struct {
    SagaID      string
    CurrentStep int
    StepResults []StepResult // 每步的执行结果
    Status      string       // "running" / "compensating" / "completed" / "failed"
}

func (s *SagaOrchestrator) Resume(ctx context.Context, sagaID string) error {
    // 从数据库恢复状态
    state, _ := s.repo.Load(ctx, sagaID)

    if state.Status == "compensating" {
        // 从断点继续补偿
        return s.compensateFrom(ctx, state, state.CurrentStep)
    }
    // 从断点继续正向执行
    return s.executeFrom(ctx, state, state.CurrentStep)
}