কেন Distributed System কঠিন — ৮টা Fallacies আর partial failure

লক্ষ্য: আজকের সব theory একটা 70-line simulation-এ — যেখানে seed fixed, তাই প্রতিটা line-এর ব্যাখ্যা সম্ভব। Channel-এর knobs বদলে নিজের incident বানান।

import random
from collections import deque

P_DROP, DELAY, P_LAG = 0.20, (0, 3), 0.25
TIMEOUT, HORIZON, N_REQ = 6, 42, 4

class UnreliableChannel:
    """দুই দিকের জন্য আলাদা queue — drop, delay, reorder তিনটাই বাস্তব"""

    def __init__(self):
        self.rng  = random.Random(42)
        self.link = {"A->B": deque(), "B->A": deque()}
        self.now  = 0

    def send(self, src, kind, mid):
        dst, ln = ("B", "A->B") if src == "A" else ("A", "B->A")
        if self.rng.random() < P_DROP:
            print(f"t={self.now:>2}  {src}->{dst}  DROP  {kind}#{mid}")
            return
        d = self.rng.randint(*DELAY)
        if self.rng.random() < P_LAG:
            d += self.rng.randint(2, 5)      # পথে আটকে গেল — reorder!
        self.link[ln].append((self.now + d, kind, mid))
        print(f"t={self.now:>2}  {src}->{dst}  SEND  {kind}#{mid}  eta+{d}")

    def drain(self, dst):
        ln   = "A->B" if dst == "B" else "B->A"
        q    = self.link[ln]
        due  = [w for w in q if w[0] <= self.now]
        for w in due:
            q.remove(w)
        return [(k, m) for _, k, m in due]

ch       = UnreliableChannel()
acted    = {}                     # server আসলে কতবার কাজ করল
attempts = {}                     # client কতবার পাঠাল
answered = set()                  # কোন id-র উত্তর পৌঁছাল
pending  = {}                     # id -> শেষ পাঠানোর tick
next_id  = 0

for t in range(HORIZON):
    ch.now = t
    if next_id < N_REQ and not pending:               # একসাথে একটাই request
        pending[next_id], attempts[next_id] = t, 1
        ch.send("A", "REQ", next_id)
        next_id += 1
    for mid, t0 in list(pending.items()):             # client-এর ধৈর্য
        if t - t0 >= TIMEOUT:
            del pending[mid]
            if attempts[mid] < 2:
                attempts[mid] += 1
                pending[mid] = t
                ch.send("A", "REQ", mid)              # retry — নিরাপদ? (দেখুন!)
            else:
                print(f"t={t:>2}  A         FAIL   REQ#{mid} — উত্তর নেই")
    for kind, mid in ch.drain("A"):
        answered.add(mid)
        pending.pop(mid, None)
        print(f"t={t:>2}  A         RESP   #{mid} এলো")
    for kind, mid in ch.drain("B"):
        acted[mid] = acted.get(mid, 0) + 1            # server কাজটা করল
        ch.send("B", "RESP", mid)

print("\n=== অস্পষ্টতা রিপোর্ট ===")
print(f"{'req':>4} {'sent':>5} {'acted':>6} {'resp':>5}  client-এর চোখে")
for i in range(N_REQ):
    s, a, r = attempts[i], acted.get(i, 0), i in answered
    if r:
        v = "OK" if a == 1 else "DUPLICATE ACTION (আসল ক্ষতি!)"
    elif a == 0:
        v = "clean fail — retry নিরাপদ"
    else:
        v = "AMBIGUOUS: কাজ হয়ে গেছে, client জানে না"
    print(f"{i:>4} {s:>5} {a:>6} {'yes' if r else 'no':>5}  {v}")

প্রত্যাশিত output (seed fixed — হুবহু এটাই আসবে):

t= 0  A->B  SEND  REQ#0  eta+0
t= 0  B->A  SEND  RESP#0  eta+1
t= 1  A         RESP   #0 এলো
t= 2  A->B  SEND  REQ#1  eta+0
t= 2  B->A  DROP  RESP#1
t= 8  A->B  DROP  REQ#1
t=14  A         FAIL   REQ#1 — উত্তর নেই
t=15  A->B  SEND  REQ#2  eta+0
t=15  B->A  SEND  RESP#2  eta+7
t=21  A->B  SEND  REQ#2  eta+0
t=21  B->A  DROP  RESP#2
t=22  A         RESP   #2 এলো
t=23  A->B  SEND  REQ#3  eta+6
t=29  A->B  DROP  REQ#3
t=29  B->A  SEND  RESP#3  eta+2
t=31  A         RESP   #3 এলো

=== অস্পষ্টতা রিপোর্ট ===
 req  sent  acted  resp  client-এর চোখে
   0     1      1   yes  OK
   1     2      1    no  AMBIGUOUS: কাজ হয়ে গেছে, client জানে না
   2     2      2   yes  DUPLICATE ACTION (আসল ক্ষতি!)
   3     2      1   yes  OK

রিপোর্ট লাইন-বাই-লাইন:

• req#1 — AMBIGUOUS: প্রথম RESP dropped, retry-র REQ-ও dropped — server চিরকাল “reserved” ভেবে বসে আছে, client জানেই না।
• req#2 — DUPLICATE ACTION: প্রথম attempt সফলই ছিল, উত্তর শুধু দেরিতে (eta+7 > timeout 6); retry-তে server দ্বিতীয়বার কাজ করল — payment-এর জগতে double-charge।
• req#3: প্রথম REQ delayed (eta+6), timeout-এর ঠিক আগে পৌঁছাল; retry dropped — ভাগ্য ভালো হলে এমনও হয়।

নিজে বাড়ান:

1. TIMEOUT = 2 করুন — DUPLICATE সংখ্যার বিস্ফোরণই aggressive timeout-এর বিল।
2. Idempotency-key যোগ করুন — server dedupe করলে কোন verdict বদলায়, কোনটা না? AMBIGUOUS কি মরে?
3. Third node C observer বসান — সে কোন প্রশ্নেরও উত্তর দিতে পারে না, প্রমাণ করুন।