Transactions ও ACID — all-or-nothing-এর চার প্রতিশ্রুতি

লক্ষ্য: atomicity-র মূল চালান — undo journal + crash injection — নিজের হাতে, fail-at-any-step-এ ফল হয় all, নয় nothing — প্রমাণসহ।

class TxFailed(Exception):
    pass

class TransactionManager:
    def __init__(self, store):
        self.store = dict(store)
        self.journal = []          # undo entries: (key, old_value_or_None)
        self.marks = {}            # savepoint name -> journal length

    def begin(self):
        self.journal.clear(); self.marks.clear()

    def _record(self, key):
        self.journal.append((key, self.store.get(key)))   # None = absent

    def apply(self, key, value):
        self._record(key); self.store[key] = value

    def delete(self, key):
        self._record(key); del self.store[key]

    def savepoint(self, name): self.marks[name] = len(self.journal)

    def _undo_one(self):
        key, old = self.journal.pop()
        if old is None: del self.store[key]
        else: self.store[key] = old

    def rollback_to(self, name):
        while len(self.journal) > self.marks[name]:
            self._undo_one()

    def commit(self):
        self.journal.clear()       # প্রতিশ্রুতি সিল — undo আর দরকার নেই

    def rollback(self):
        while self.journal: self._undo_one()

    def run_script(self, script, fail_at=None):
        """script: ('set',k,v)|('del',k)|('sp',name)|('rbto',name);
           fail_at=k মানে k-তম mutation-এর ঠিক আগে বিদ্যুৎ চলে যাবে"""
        self.begin()
        n = 0
        try:
            for op in script:
                if fail_at is not None and n == fail_at:
                    raise TxFailed(f"CRASH before mutation #{n}")
                if op[0] == 'set':    self.apply(op[1], op[2])
                elif op[0] == 'del':  self.delete(op[1])
                elif op[0] == 'sp':   self.savepoint(op[1])
                elif op[0] == 'rbto': self.rollback_to(op[1])
                n += 1
        except TxFailed as e:
            print(f"  !! {e} -> auto rollback")
            self.rollback()
            return False
        self.commit()
        return True


tm = TransactionManager({"a": 800, "b": 200})
script = [
    ('set', 'a', 700),             # 1: alice কাটা
    ('set', 'b', 1200),            # 2: bob জোড়া
    ('set', 'audit', 'xfer-ok'),   # 3: লগ
    ('set', 'a', -5),              # 4: CHECK-ভাঙা ভুল (simulated)
]
before = dict(tm.store)

print("সব সফল:")
tm.run_script(script); print(" ", tm.store)

print("fail_at=2 (মাঝপথে crash):")
tm.store.update(before); tm.run_script(script, fail_at=2)
assert tm.store == before, "state পুরোপুরি ফেরেনি!"
print("  restored exactly:", tm.store)

print("savepoint দিয়ে ভুলটা শুধু পেছনে:")
tm.store.update(before)
tm.run_script([('set','a',700), ('sp','ok'),
               ('set','a',-5),   ('rbto','ok'),
               ('set','a',650)])
print(" ", tm.store)

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

সব সফল:
  {'a': -5, 'b': 1200, 'audit': 'xfer-ok'}
fail_at=2 (মাঝপথে crash):
  !! CRASH before mutation #2 -> auto rollback
  restored exactly: {'a': 800, 'b': 200}
savepoint দিয়ে ভুলটা শুধু পেছনে:
  {'a': 650, 'b': 200}

fail_at-এর প্রতিটা মান (০..৩) চালিয়ে দেখুন — assert কোনোদিন ভাঙবে না: crash যেখানেই হোক, ফল all নয় nothing — atomicity-র সংজ্ঞা, ৯০-লাইনের প্রমাণ।

নিজে বাড়ান:

1. Nested savepoint (একই নাম দুইবার) — stack করে সমাধান
2. commit()-এর পরে rollback ডাকলে? State machine দিয়ে অবৈধ transition আটকান — diagram-এর প্রোগ্রাম-রূপ
3. Undo entry নিজেই হারালে? বাস্তব engine undo log-ও WAL-protected রাখে কেন — উত্তর লিখুন