S070 · CAP & PACELC — the Actual Trade-Offs

"""s070_cap_sim.py — a 100-line simulator to make CAP concrete.
 
Two nodes, one key. A client writes to Node A; Node A tries to replicate to Node B.
You control:
  * partition on/off  (drop messages between A and B)
  * mode: 'CP' (reject writes if replication fails) or 'AP' (accept and diverge)
 
Run:  python s070_cap_sim.py
"""
from __future__ import annotations
from dataclasses import dataclass, field
from typing import Optional
import time
 
 
@dataclass
class Node:
    name: str
    store: dict[str, str] = field(default_factory=dict)
 
 
@dataclass
class Cluster:
    a: Node
    b: Node
    partitioned: bool = False
    mode: str = "CP"           # "CP" or "AP"
    replication_delay_ms: int = 10
 
    # ---- write path ----
    def write(self, key: str, value: str) -> tuple[bool, str]:
        """Client always writes to node A. A tries to replicate to B."""
        self.a.store[key] = value
        if self.partitioned:
            if self.mode == "CP":
                # Consistency: undo local write, tell client we failed
                del self.a.store[key]
                return False, "REJECTED (partition, CP: won't accept without replica ack)"
            else:  # AP
                # Availability: accept, replicas will diverge
                return True, "ACCEPTED on A (partition, AP: will reconcile later)"
        # Normal path: replicate to B
        time.sleep(self.replication_delay_ms / 1000)
        self.b.store[key] = value
        return True, "ACCEPTED (replicated to B)"
 
    # ---- read path ----
    def read(self, key: str, from_node: str = "a") -> tuple[Optional[str], str]:
        node = self.a if from_node == "a" else self.b
        val = node.store.get(key)
        return val, f"read from {node.name.upper()}"
 
 
def print_state(c: Cluster) -> None:
    print(f"  A={c.a.store}  B={c.b.store}  partition={c.partitioned}  mode={c.mode}")
 
 
def main() -> None:
    c = Cluster(a=Node("a"), b=Node("b"))
 
    print("\n=== SCENARIO 1: normal write, replication OK ===")
    ok, msg = c.write("balance", "1000")
    print(f"write balance=1000 → {ok} · {msg}")
    print_state(c)
 
    print("\n=== SCENARIO 2: partition + CP mode ===")
    c.partitioned = True
    c.mode = "CP"
    ok, msg = c.write("balance", "1200")
    print(f"write balance=1200 → {ok} · {msg}")
    print_state(c)
    print("  Read from A:", c.read("balance", "a"))
    print("  Read from B:", c.read("balance", "b"))
    print("  Correct: system refused inconsistent write; both nodes still show old value.")
 
    print("\n=== SCENARIO 3: partition + AP mode (concurrent divergent writes) ===")
    c.mode = "AP"
    ok, msg = c.write("balance", "800")           # A accepts
    print(f"client-1 writes balance=800 on A → {ok} · {msg}")
    # Meanwhile a client hits B directly (simulate)
    c.b.store["balance"] = "1500"
    print("client-2 writes balance=1500 directly on B (available side)")
    print_state(c)
    print("  Read from A:", c.read("balance", "a"))
    print("  Read from B:", c.read("balance", "b"))
    print("  DIVERGENCE — same key, two values. Standard AP behaviour during partition.")
 
    print("\n=== SCENARIO 4: partition heals, we need conflict resolution ===")
    c.partitioned = False
    # Simplest strategy: last-write-wins by an imaginary timestamp
    print("  Applying LWW reconciliation (choose one)...")
    winner = c.b.store["balance"]                  # pretend B's write was later
    c.a.store["balance"] = winner
    print_state(c)
    print("  Note: LWW SILENTLY LOSES client-1's write. This is the ‘lost update’ pitfall of AP.")
    print("  Real systems use vector clocks / CRDTs / application-level merge to do better.")
 
    print("\n=== SCENARIO 5: PACELC — even without partition, replica reads may be stale ===")
    c.a.store["balance"] = "2000"
    print("write balance=2000 to A (no partition)")
    print("  IMMEDIATE read from A:", c.read("balance", "a"))
    print("  IMMEDIATE read from B (before replication):", c.read("balance", "b"),
          "← STALE — replication is async")
    time.sleep(c.replication_delay_ms / 1000)
    c.b.store["balance"] = "2000"                   # replication catches up
    print("  After replication delay, read from B:", c.read("balance", "b"))
 
 
if __name__ == "__main__":
    main()