Distributed Lock ও তার বিপদ — Redlock বিতর্কসহ

ধাপ ১ — দুই session, এক advisory lock:

# Terminal 1 — holder:
psql -d postgres -c 'SELECT pg_advisory_lock(424242);'   # ধরে রাখে
# Terminal 2 — চেষ্টাকারী (প্রথমবার):
psql -d postgres -c 'SELECT pg_try_advisory_lock(424242);'   # → f (deny)
# Terminal 1-এর session খুন করুন:
psql -d postgres -c "SELECT pg_terminate_backend(pid) FROM pg_stat_activity \
                     WHERE datname='postgres' AND pid <> pg_backend_pid();"
# Terminal 2 — আবার:
psql -d postgres -c 'SELECT pg_try_advisory_lock(424242);'   # → t (মুক্ত!)

কোনো TTL সেট করেননি, unlock চালাননি — connection-মৃত্যুই release- event। এটাই lease-semantics-এর পরিচ্ছন্নতম বাস্তবায়ন; DB-advisory lock-এ GC-pause-দুশ্চিন্তাও ছোট (জীবিত connection ধরে রাখে, মরলেই সত্যিই মুক্ত)।

ধাপ ২ — GC-pause simulation, fencing on/off:

"""gc_pause_fencing.py — python3 gc_pause_fencing.py fenced|unfenced"""
import sys, threading, time

TTL, PAUSE = 0.30, 0.60            # pause ইচ্ছা করে TTL ছাড়িয়ে যায়
FENCED = (sys.argv[1] if len(sys.argv) > 1 else 'unfenced') == 'fenced'

tok, expires, cv = [0], [0.0], threading.Condition()

def acquire():
    with cv:
        now = time.monotonic()
        if expires[0] > now:
            return None                    # live lease আছে
        tok[0] += 1                        # fencing token: একমুখী বৃদ্ধি
        expires[0] = now + TTL
        return tok[0]

balance = {'v': 500}                       # shared ledger
last_seen, glock, trail = [0], threading.Lock(), []

def guarded_write(writer, new_value, my_tok):
    if FENCED:
        with glock:
            if my_tok <= last_seen[0]:
                return False               # ★ stale token — reject
            last_seen[0] = my_tok
    balance['v'] = new_value
    trail.append((writer, new_value))
    return True

def worker_a():
    my_tok = acquire()                     # token 1, তারপর read —
    snap = balance['v']                    # B শুরুর আগেই হয়ে যায়
    print(f'A: tok={my_tok}, read={snap}, pause {PAUSE}s...')
    time.sleep(PAUSE)                      # ← THE PAUSE (lease মরে যায়)
    planned = snap - 60                    # পুরনো snapshot-এ হিসাব!
    ok = guarded_write('A', planned, my_tok)
    print(f'A: woke, write {planned} tok={my_tok} → {"ACCEPTED" if ok else "REJECTED"}')

def worker_b():
    while True:
        my_tok = acquire()
        if my_tok: break
        time.sleep(0.05)                   # lease ফুরোলেই পাবে
    ok = guarded_write('B', balance['v'] - 50, my_tok)
    print(f'B: tok={my_tok} → {"ACCEPTED" if ok else "REJECTED"}')

a = threading.Thread(target=worker_a); a.start()
b = threading.Thread(target=worker_b); b.start()
a.join(); b.join()
print(f'final = {balance["v"]}  (expected: 450)')
assert balance['v'] == 450, 'LOST UPDATE — stale write overwrote fresh!'
print(f'PASS [{sys.argv[1] if len(sys.argv)>1 else "unfenced"}] — {trail}')

$ python3 gc_pause_fencing.py unfenced
A: tok=1, read=500, pause 0.6s...
B: tok=2 → ACCEPTED
A: woke, write 440 tok=1 → ACCEPTED
final = 440  (expected: 450)
AssertionError: LOST UPDATE

$ python3 gc_pause_fencing.py fenced
B: tok=2 → ACCEPTED
A: woke, write 440 tok=1 → REJECTED
final = 450  (expected: 450)
PASS [fenced]

তিন পাঠ: unfenced run-এ A কোনো exception পায়নি — silent corruption-ই এই বিপদের স্বভাব; reject এলো storage-guard থেকে, lock-service থেকে না — theory-র হুবহু প্রতিধ্বনি; আর বাস্তব PAUSE হতো ৫০ ms GC, TTL ৩০ s — ratio আলাদা, গঠন একই।