What is two-phase commit and its drawbacks?

// Two-phase commit on a fake clock: one coordinator, three participants.
// Each participant is a separate database; "rtt" is the round trip to it in ms.
// A forced log write (fsync) costs 1 ms. No real network or disk is used.
const FSYNC = 1;

function makeParts(votes) {
  return [
    { name: "orders", rtt: 2, vote: votes[0], state: "init" },
    { name: "payments", rtt: 4, vote: votes[1], state: "init" },
    { name: "inventory", rtt: 60, vote: votes[2], state: "init" },
  ];
}

// Phase 1: send PREPARE, each participant forces a PREPARED (or ABORT) record and votes.
function phase1(parts) {
  let votesAt = 0;
  for (const p of parts) {
    p.lockedAt = p.rtt / 2; // PREPARE arrives; rows stay locked from here on
    p.state = p.vote === "YES" ? "prepared" : "aborted";
    if (p.vote === "NO") p.releasedAt = p.lockedAt + FSYNC; // a NO voter rolls back at once
    votesAt = Math.max(votesAt, p.rtt + FSYNC);
  }
  return votesAt;
}

// Phase 2: coordinator forces the decision, then tells everyone.
function phase2(parts, decision, decidedAt) {
  for (const p of parts) {
    if (p.releasedAt !== undefined) continue;
    if (p.state === "prepared") p.state = decision === "COMMIT" ? "committed" : "aborted";
    p.releasedAt = decidedAt + p.rtt / 2 + FSYNC;
  }
}

function show(parts) {
  for (const p of parts) {
    const held = p.releasedAt === undefined ? "still locked" : `locks held ${p.releasedAt - p.lockedAt} ms`;
    console.log(`  ${p.name.padEnd(9)} rtt ${String(p.rtt).padStart(2)} ms  vote ${p.vote.padEnd(3)} -> ${p.state.toUpperCase().padEnd(9)} ${held}`);
  }
}

console.log("== 1. Happy path: all three vote YES");
let parts = makeParts(["YES", "YES", "YES"]);
let votesAt = phase1(parts);
let decidedAt = votesAt + FSYNC;
phase2(parts, "COMMIT", decidedAt);
show(parts);
console.log(`  votes in at t=${votesAt} ms, COMMIT forced at t=${decidedAt} ms, client told OK at t=${decidedAt} ms`);
console.log(`  messages ${parts.length * 4}, forced log writes ${parts.length * 2 + 1} (a single-database commit: 1 write, ${FSYNC} ms)`);

console.log("\n== 2. One NO vote: payments cannot reserve funds");
parts = makeParts(["YES", "NO", "YES"]);
phase1(parts);
const noAt = parts[1].rtt + FSYNC; // the first NO is enough to decide
decidedAt = noAt + FSYNC;
phase2(parts, "ABORT", decidedAt);
show(parts);
console.log(`  NO arrives at t=${noAt} ms, ABORT forced at t=${decidedAt} ms without waiting for inventory`);

console.log("\n== 3. Coordinator crashes after collecting YES votes, before deciding");
parts = makeParts(["YES", "YES", "YES"]);
votesAt = phase1(parts);
show(parts);
const outageMs = 30000;
const hotRowRps = 50;
console.log(`  every participant is IN DOUBT: it voted YES, so it may not abort on its own`);
const asked = parts.map((p) => `${p.name}=${p.state}`).join(", ");
console.log(`  termination protocol: ask peers -> ${asked} -> nobody knows the outcome`);
console.log(`  coordinator down ${outageMs / 1000} s; ${hotRowRps} req/s need the locked stock row -> ${(outageMs / 1000) * hotRowRps} requests blocked`);
const recoveredAt = votesAt + outageMs;
phase2(parts, "ABORT", recoveredAt); // log has no decision record -> presumed abort
console.log(`  recovery at t=${recoveredAt} ms: no decision in the coordinator log -> presumed ABORT`);
show(parts);

console.log("\n== 4. COMMIT forced, coordinator crashes before sending it; payments gives up after 5 s");
parts = makeParts(["YES", "YES", "YES"]);
votesAt = phase1(parts);
decidedAt = votesAt + FSYNC;
parts[1].state = "aborted"; // heuristic decision: an operator or timeout rolled it back
parts[1].releasedAt = parts[1].lockedAt + 5000;
const restartAt = decidedAt + outageMs;
for (const p of parts) {
  if (p.state === "prepared") { p.state = "committed"; p.releasedAt = restartAt + p.rtt / 2 + FSYNC; }
}
show(parts);
const outcomes = new Set(parts.map((p) => p.state));
console.log(`  outcomes: ${[...outcomes].join(" + ")} -> atomicity broken (heuristic hazard)`);