Distributed Transactions — Senior chuqurlik

2PC ning "bloklovchi" muammosi — aniq stsenariy

XA va 3PC

XA — 2PC’ning sanoat standarti (X/Open): Transaction Manager + Resource Managerlar, xa_prepare/xa_commit chaqiruvlari. An’anaviy bazalar (Postgres, MySQL, ba’zi brokerlar) qo‘llab-quvvatlaydi. 3PC esa 2PC’ga "pre-commit" fazasini qo‘shib, bloklashni kamaytirishga urinadi — lekin qo‘shimcha kechikish keltiradi va tarmoq bo‘linishida (11-mavzu) baribir ishonchsiz. Shuning uchun amalda kam ishlatiladi.

// SEMANTIC LOCK: oraliq holatni "*_PENDING" bilan belgila -> boshqalar biladi
await this.orders.update(id, { status: "PENDING_PAYMENT" });   // qulf-belgisi
// boshqa tranzaksiya PENDING ko'rsa -> kutadi YOKI e'tiborsiz qoldiradi (dirty read yo'q)
// saga tugagach: "CONFIRMED" (muvaffaqiyat) yoki "CANCELLED" (kompensatsiya)

Nega state machine + persistence

Har saga nusxasi o‘z holatiga ega (qaysi qadamda, nima bajarilgan). Bu holat har qadamdan keyin saqlanadi — shunda orkestrator qulab tushsa, qayta ishga tushganda tugallanmagan saga’larni yuklab, davom ettiradi (yoki kompensatsiya qiladi):

// ORCHESTRATOR = SAQLANADIGAN state machine. Har qadamdan keyin holat saqlanadi.
enum SagaState { STARTED, INV_RESERVED, PAID, COMPLETED, COMPENSATING, FAILED }

async advance(sagaId: string) {
  const saga = await this.repo.load(sagaId);         // saqlangan holatni yukla
  switch (saga.state) {
    case SagaState.STARTED:
      await this.inventory.reserve(saga.orderId);
      saga.state = SagaState.INV_RESERVED; break;
    case SagaState.INV_RESERVED:
      await this.payment.charge(saga.orderId);
      saga.state = SagaState.PAID; break;
    case SagaState.PAID:
      await this.orders.confirm(saga.orderId);
      saga.state = SagaState.COMPLETED; break;
  }
  await this.repo.save(saga);   // HAR qadamdan keyin SAQLA -> crash bo'lsa davom ettiriladi
}
// ishga tushganda: tugallanmagan saga'larni yuklab, davom ettiradi yoki kompensatsiya qiladi

Yechim — Transactional Outbox

Har qadamda mahalliy o‘zgarish va chiqadigan eventni bitta mahalliy tranzaksiyada yozamiz (outbox jadvaliga). Alohida relay outbox’dan ishonchli publish qiladi:

// Har saga qadami: mahalliy o'zgarish + event BITTA tranzaksiyada (Outbox, 3-mavzu)
await this.prisma.$transaction(async (tx) => {
  await tx.inventory.update({ where: { id }, data: { reserved: true } });   // biznes
  await tx.outbox.create({ data: { type: "inventory.reserved", payload } }); // event
});
// alohida relay outbox'dan o'qib, event'ni ishonchli publish qiladi
// -> mahalliy o'zgarish VA uning eventi atomik (dual-write muammosi hal bo'ldi)

Uch faza

Saga qadamlarni to‘liq commit qilib, xatolikda kompensatsiya qiladi. TCC boshqacha: avval hammani band (reserve) qiladi (yakuniy emas), hammasi muvaffaqiyatli bo‘lsa Confirm, aks holda Cancel:

// TCC — Try / Confirm / Cancel: resurs OLDINDAN band qilinadi (dirty commit yo'q)
async try_(orderId: string) {                 // 1) TRY — band qil (yakuniy emas)
  await this.inventory.hold(orderId);         //    inventarni "hold"
  await this.payment.authorize(orderId);      //    pulni "hold" (yechmaydi)
}
async confirm(orderId: string) {              // 2) CONFIRM — yakunlash
  await this.inventory.deduct(orderId);       //    hold'dan yech
  await this.payment.capture(orderId);        //    hold qilingan pulni ol
}
async cancel(orderId: string) {               // 3) CANCEL — bekor qilish
  await this.inventory.release(orderId);      //    hold'ni bo'shat
  await this.payment.void(orderId);           //    authorizatsiyani bekor qil
}

Retriable vs non-retriable — forward vs backward recovery

• Retriable (o‘tkinchi): timeout, vaqtincha ishlamaslik, tarmoq. Bu qadam aslida bajarilishi mumkin edi — kompensatsiya qilma, qayta urin (forward recovery, 14-mavzu).
• Non-retriable (biznes): "mablag‘ yetarli emas", "mahsulot yo‘q". Bu qadam hech qachon bajarilmaydi — oldingilarni bekor qil (backward recovery, kompensatsiya).

// Xatoni TASNIFLA: retriable (o'tkinchi) -> qayta urin; non-retriable (biznes) -> kompensatsiya
catch (err) {
  if (isTransient(err)) {                    // timeout, 503, tarmoq -> FORWARD recovery
    await retryWithBackoff(() => this.step());  // to'xtatmaydi, oldinga davom (14-mavzu)
  } else {                                   // "mablag' yetarli emas" -> BACKWARD recovery
    await this.compensate();                 // oldingi qadamlarni bekor qil
  }
}

Saga observability — kuzatish qiyin

Ishonchli saga arxitekturasi — yig‘ma ko‘rinish

Senior tayyorlik cheklisti