CAP ও PACELC — theorem যেটা সবাই ভুল বোঝে

লক্ষ্য: “CP partition-এ unavailable”, “AP stale দেয়”, “sync ধীর” — তিনটা textbook-বাক্যই এক matrix-row-এ সংখ্যা হয়ে ফুটবে।

import statistics

class Lab:
    """Two-node KV; W=1 local-ack-only, W=2 replica-apply-পরে-ack"""

    def __init__(self, sync_w2=False, net_delay=2):
        self.w2 = sync_w2
        self.delay = net_delay
        self.down = False
        self.inflight = []            # (arrive_tick, seq) — wire
        self.retained = []            # partition-চলাকালীন জমা WAL
        self.seq = 0                  # primary-র write-counter
        self.acked = 0                # client-confirm'd সর্বশেষ seq
        self.applied = 0              # B-তে apply'd সর্বশেষ seq
        self.m = {"ok": 0, "blocked": 0}
        self.lat = []
        self.max_stale = 0
        self.probes = 0

    def write(self, tick):
        if self.down:
            if self.w2:               # CP: replica-ছাড়া confirm নয়
                self.m["blocked"] += 1
                self.lat.append(20)   # timeout-abort cost
                return
            self.seq += 1             # AP: local-ই যথেষ্ট; log জমা থাকে
            self.retained.append((tick + self.delay, self.seq))
            self.acked = self.seq     # local ack — এটাই A-র দাম
            self.m["ok"] += 1
            self.lat.append(1)
            return
        self.seq += 1
        self.inflight.append((tick + self.delay, self.seq))
        if self.w2:                   # CP: apply-পর্যন্ত ack ঝুলিয়ে
            self.lat.append(1 + self.delay)
        else:                         # AP: সঙ্গে-সঙ্গে ack (Else-L)
            self.acked = self.seq
            self.lat.append(1)
        self.m["ok"] += 1

    def advance(self, tick):
        if self.down:
            return                    # partition: delivery বন্ধ
        due = [w for w in self.inflight if w[0] <= tick]
        self.inflight = [w for w in self.inflight if w[0] > tick]
        for _, s in sorted(due):
            self.applied = s
            if self.w2:
                self.acked = s        # sync-ack এখানেই ফিরে

    def probe(self):
        """standby-B-র চোখে staleness — version-gap-এ"""
        self.probes += 1
        gap = self.acked - min(self.applied, self.acked)
        self.max_stale = max(self.max_stale, gap)


def run(sync_w2, partitioned, n_writes=200):
    lab = Lab(sync_w2)
    heal_at = None
    for t in range(1, n_writes + 1):
        if partitioned and t == 121:
            lab.down = False          # cable ফিরল — retained flush
            lab.inflight.extend(lab.retained)
            lab.retained.clear()
        lab.down = lab.down or (partitioned and t <= 120)
        lab.write(t)
        lab.advance(t)
        if t % 5 == 0:
            lab.probe()
    return lab


print(f"{'mode':<24}{'avail%':>8}{'avg-lat':>9}"
      f"{'max-stale':>10}")
for name, s, p in [("AP (W=1) normal", False, False),
                   ("AP (W=1) partition", False, True),
                   ("CP (W=2) normal", True, False),
                   ("CP (W=2) partition", True, True)]:
    lab = run(s, p)
    total = lab.m["ok"] + lab.m["blocked"]
    avail = 100 * lab.m["ok"] / total
    avg = statistics.mean(lab.lat)
    print(f"{name:<24}{avail:>7.0f}%{avg:>9.1f}"
          f"{lab.max_stale:>10.0f}")

প্রত্যাশিত output:

mode                       avail%  avg-lat  max-stale
AP (W=1) normal              100%      1.0          2
AP (W=1) partition           100%      1.0        ~115
CP (W=2) normal              100%      3.0          0
CP (W=2) partition             0%     20.0          0

Matrix পড়ুন — চার row-ই একটা করে theorem:

• AP-partition: available ১০০%, কিন্তু staleness partition- জুড়ে জমে ~১১৫ version — এই gap-টাই async replication-এর RPO-জানালা; heal-এর পরে retained-log burst-apply-তে convergence
• AP-normal: max-stale = net_delay — partition না থাকলেও async-এর ছোট, স্থির lag (PACELC-র Else-L-লাভের উৎস)
• CP-normal: staleness শূন্য, কিন্তু avg-latency ৩× — PACELC-র Else-C-র কর!
• CP-partition: availability শূন্য — “during partition, choose” — এই row-ই CAP-এর হৃদয়বাক্য

নিজে বাড়ান:

1. Read-your-writes session-affinity mode — client সবসময় leader থেকে পড়লে stale% কোথায় যায়?
2. Quorum-W=1,R=2 বনাম W=2,R=2 — partition-এর কোন পাশ serve করবে হিসাব করুন (Level 9-এর quorum-গণিতের আভাস)
3. LWW-conflict inject — partition-চলাকালীন দুই পাশে ভিন্ন key- value, heal-এ কে জেতে দেখুন (clock-ভিত্তিক LWW-র বিপদ)