Active-Active vs Active-Passive Multi-Region - Data, Write Routing & Home Regions

# Home-region writes: each user's data has ONE writable region; other regions serve
# (possibly stale) reads. A version token gives read-your-writes after a write.
class Region:
    def __init__(self, name):
        self.name, self.data, self.applied_version = name, {}, 0

class Cluster:
    def __init__(self):
        self.regions = {"us-east": Region("us-east"), "eu-west": Region("eu-west")}
        self.log = []                      # replication log owned by the home region

    def write(self, home, key, value):
        r = self.regions[home]
        self.log.append((key, value))
        r.data[key] = value
        r.applied_version = len(self.log)
        return r.applied_version           # token returned to the client

    def replicate(self, region, upto):
        r = self.regions[region]
        for key, value in self.log[r.applied_version:upto]:
            r.data[key] = value
        r.applied_version = max(r.applied_version, upto)

    def read(self, region, key, min_version=0, home="us-east"):
        r = self.regions[region]
        if r.applied_version < min_version:  # replica too stale for this client: go to home region
            return self.regions[home].data.get(key), f"{home} (fallback, replica at v{r.applied_version})"
        return r.data.get(key), region

c = Cluster()
token = c.write("us-east", "profile:7", "new avatar")
print("eu read, no token :", c.read("eu-west", "profile:7"))
print("eu read, token v%d:" % token, c.read("eu-west", "profile:7", min_version=token))
c.replicate("eu-west", upto=token)
print("after replication :", c.read("eu-west", "profile:7", min_version=token))

eu read, no token : (None, 'eu-west')
eu read, token v1: ('new avatar', 'us-east (fallback, replica at v0)')
after replication : ('new avatar', 'eu-west')

// Active-active with last-writer-wins (LWW): two regions accept a write to the same key
// during a partition. When they reconcile, the "later" timestamp silently wins.
type Write = { region: string; value: number; ts: number };

// Balance starts at 100. Two concurrent debits happen in different regions.
const usEast: Write = { region: "us-east", value: 100 - 30, ts: 1_000_002 }; // -30
const euWest: Write = { region: "eu-west", value: 100 - 50, ts: 1_000_001 }; // -50 (clock 1 ms behind)

const lww = usEast.ts >= euWest.ts ? usEast : euWest;
console.log(`LWW result: ${lww.value} from ${lww.region}  (expected 20 after both debits)`);
console.log(`lost update: the ${lww === usEast ? "eu-west" : "us-east"} debit vanished`);

// Fix options: route the account to a home region (no concurrent writers),
// or model the balance as commutative operations (a CRDT-style counter of deltas).
const deltas = [-30, -50];
const merged = 100 + deltas.reduce((a, b) => a + b, 0);
console.log(`delta merge (commutative): ${merged}`);
console.log(`but deltas alone cannot enforce "balance >= 0" across regions -> needs a single writer or consensus`);

LWW result: 70 from us-east  (expected 20 after both debits)
lost update: the eu-west debit vanished
delta merge (commutative): 20
but deltas alone cannot enforce "balance >= 0" across regions -> needs a single writer or consensus