Skip to content
TheChatArchiveThe Chat Archive
ClaudeClaude Haiku 4.5· anthropicHugging Face Frontier Reasoning Traces

Simulate two-phase commit with a coordinator and 3 participant classes. Implement…

  1. User

    Simulate two-phase commit with a coordinator and 3 participant classes. Implement prepare and commit phases and handle coordinator failure where if it crashes after sending prepare, participants must query each other to decide whether to abort or commit.

  2. Claude Assistant

    This is a comprehensive request for implementing the Two-Phase Commit (2PC) protocol with failure handling. Let me create a complete implementation that includes:

    1. Coordinator class - manages the 2PC protocol
    2. Participant class - handles prepare and commit phases
    3. Failure recovery mechanism - handles coordinator crashes
    4. Message/Transaction management
    5. Logging for recovery
    6. Proper synchronization

    Let me think about the architecture:

    1. Coordinator:

      • Maintains state of transaction
      • Sends prepare requests
      • Collects votes
      • Sends commit/abort decision
      • Can crash and recover
    2. Participant:

      • Can vote YES or NO on prepare
      • Must implement redo/undo logs
      • Can query other participants if coordinator is down
      • Must be able to commit/abort based on majority decision
    3. Failure Scenarios:

      • Coordinator crashes after sending prepare (participants need to recover)
      • Participants can query each other
      • State persistence for recovery

    Let me write comprehensive code:

    import threading
    import time
    from enum import Enum
    from typing import Dict, List, Tuple
    from dataclasses import dataclass, field
    from collections import defaultdict
    import logging
    from datetime import datetime
    
    # Setup logging
    logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(message)s')
    
    class TransactionState(Enum):
        """States of a transaction"""
        INITIAL = "INITIAL"
        PREPARE_SENT = "PREPARE_SENT"
        PREPARED = "PREPARED"
        COMMITTED = "COMMITTED"
        ABORTED = "ABORTED"
    
    class ParticipantVote(Enum):
        """Participant votes"""
        UNDECIDED = "UNDECIDED"
        YES = "YES"
        NO = "NO"
    
    @dataclass
    class TransactionLog:
        """Persistent transaction log entry"""
        transaction_id: str
        participant_id: str
        operation: str
        timestamp: float
        state: TransactionState
        redo_log: Dict = field(default_factory=dict)
        undo_log: Dict = field(default_factory=dict)
    
    @dataclass
    class TransactionData:
        """Transaction data to be committed"""
        transaction_id: str
        data: Dict
        metadata: Dict = field(default_factory=dict)
    
    class TransactionLog:
        """Manages transaction logs for recovery"""
        def __init__(self):
            self.logs: Dict
    

    I need to define the core data structures for tracking transaction state and recovery information. The TransactionLog class will store persistent records of each operation, including redo and undo logs for recovery purposes. The TransactionData class encapsulates the actual data being committed along with metadata about the transaction.

    The logs dictionary maps transaction IDs to lists of entries, protected by a lock for thread safety. When writing an entry, I create a new TransactionLog record with the current timestamp and operation details, then append it to the transaction's history. Reading retrieves all logs for a given transaction, and getting the final state extracts the most recent entry's state or returns INITIAL if no logs exist.

    The Coordinator class orchestrates the two-phase commit protocol, maintaining registries of participants and active transactions. It includes a transaction log for recovery and fields to simulate failure scenarios during the commit process. logging.error(f"Coordinator: Error executing transaction {tx_id}: {e}") self._abort_transaction(tx_id) return False

    def _prepare_phase(self, tx_id: str) -> bool:
        """Phase 1: Ask all participants to prepare"""
        logging.info(f"Coordinator: Starting prepare phase for {tx_id}")
        
        self.log.write(tx_id, self.coordinator_id, "PREPARE_START", TransactionState.PREPARE_SENT)
        
        votes = {}
        
        # Send prepare requests to all participants
        threads = []
        for participant_id, participant in self.participants.items():
            thread = threading.Thread(
                target=self._get_vote,
                args=(tx_id, participant, votes)
            )
            threa
    

    I cannot complete this thought as the next thinking appears to be cut off mid-word. To properly finish the rewritten thinking, I would need the complete next section. abort to all participants""" logging.info(f"Coordinator: Starting commit phase for {tx_id}")

        self.log.write(tx_id, self.coordinator_id, "COMMIT_START", TransactionState.COMMITTED)
        
        threads = []
        results = {}
        
        # Send commit to all participants
        for participant_id, participant in self.participants.items():
            thread = threading.Thread(
                target=self._send_commit,
                args=(tx_id, participant, results)
            )
            thread.start()
            threads.append(thread)
        
        # Wait for all commits
        for thread in threads:
            thread.join()
        
        all_committed = all(results.values())
        
        if all_committed:
            logging.info(f"Coordinator: All participants committed {tx_id}")
            self.log.write(tx_id, self.coordinator_id, "COMMIT_SUCCESS", TransactionState.COMMITTED)
        else:
            logging.warning(f"Coordinator: Commit failed for {tx_id}")
            self.log.write(tx_id, self.coordinator_id, "COMMIT_FAILED", TransactionState.ABORTED)
        
        return all_committed
    

    I'm spawning threads to send commit messages to each participant concurrently, then waiting for all of them to complete. Once they're done, I check if every participant successfully committed. If they all did, I log success and update the transaction state to committed; otherwise I log the failure and mark it as aborted. d not in self.participants: return False, None

        participant = self.participants[participant_id]
        state = participant.get_transaction_state(tx_id)
        return True, state
    

    class Participant: """Two-Phase Commit Participant"""

    def __init__(self, participant_id: str, coordinator: Coordinator = None):
        self.participant_id = participant_id
        self.coordinator = coordinator
        self.prepared_transactions: Dict[str, TransactionData] = {}
        self.transaction_states: Dict[str, TransactionState] = {}
        self.transaction_lock = threading.Lock()
        self.log = TransactionLog()
        self.vote_delay = 0
        self.can_prepare = True
        self.other_participants: List['Participant'] = []
        
    
    def prepare(self, tx_id: str, transaction_data: TransactionData) -> ParticipantVote:
        """Phase 1: Prepare to commit"""
        logging.info(f"Participant {self.participant_id}: Preparing {tx_id}")
        
        time.sleep(self.vote_delay)  # Simulate processing delay
        
        with self.transaction_lock:
            self.log.write(tx_id, self.participant_id, "PREPARE", 
                          TransactionState.PREPARED,
                          redo_log={'data': transaction_data.data})
            
            vote = ParticipantVote.YES if self.can_prepare else ParticipantVote.NO
            
            if vote == ParticipantVote.YES:
                #
                self.prepared_transactions[tx_id] = transaction_data
                self.transaction_states[tx_id] = TransactionState.PREPARED
                logging.info(f"Participant {self.participant_id}: Voted YES for {tx_id}")
            else:
                self.transaction_states[tx_id] = TransactionState.ABORTED
                logging.info(f"Participant {self.participant_id}: Voted NO for {tx_id}")
            
            return vote
    
    def commit(self, tx_id: str) -> bool:
        """Phase 2: Commit the transaction"""
        logging.info(f"Participant {self.participant_id}: Committing {tx_id}")
        
        with self.transaction_lock:
            if tx_id not in self.prepared_transactions:
                logging.error(f"Participant {self.participant_id}: No prepared transaction {tx_id}")
                return False
            
            try:
                transaction_data = self.prepared_transactions[tx_id]
                self._apply_transaction(transaction_data)
                
                self.log.write(tx_id, self.participant_id, "COMMIT",
                              TransactionState.COMMITTED,
                              redo_log={'data': transaction_data.data})
                
                self.transaction_states[tx_id] = TransactionState.COMMITTED
                del self.prepared_transactions[tx_id]
                
                logging.info(f"Participant {self.participant_id}: Committed {tx_id}")
                return True
                
            except Exception as e:
                logging.error(f"Participant {self.participant_id}: Error committing {tx_id}: {e}")
                self.transaction_states[tx_id] = TransactionState.ABORTED
                return False
    
    def abort(self, tx_id: str) -> bool:
        """Abort the transaction"""
        logging.info(f"Participant {self.participant_id}: Aborting {tx_id}")
        
        with self.transaction_lock:
            self.log.write(tx_id, self.participant_id, "ABORT", TransactionState.ABORTED)
            
            if tx_id in self.prepared_transactions:
                del self.prepared_transactions[tx_id]
            
            self.transaction_states[tx_id] = TransactionState.ABORTED
            logging.info(f"Participant {self.participant_id}: Aborted {tx_id}")
            return True
    
    def _apply_transaction(self, transaction_data: TransactionData):
        """Apply transaction (simulated)"""
        logging.info(f"Participant {self.participant_id}: Applying transaction data: {transaction_data.data}")
    
    def get_transaction_state(self, tx_id: str) -> TransactionState:
        """Get current state of a transaction"""
        with self.transaction_lock:
            return self.transaction_states.get(tx_id, TransactionState.INITIAL)
    
    def set_other_participants(self, participants: List['Participant']):
        """Set references to other participants for recovery"""
        self.other_participants = [p for p in participants if p.participant_id != self.participant_id]
    
    def query_other_participants(self, tx_id: str) -> Tuple[int, int]:
        """Query other participants about their transaction state"""
        logging.info(f"Participant {self.participant_id}: Querying others about {tx_id}")
        
        committed_count = 0
        aborted_count = 0
        
        for participant in self.other_participants:
            state = participant.get_transaction_state(tx_id)
            
            if state == TransactionState.COMMITTED:
                committed_count += 1
            elif state == TransactionState.ABORTED:
                aborted_count += 1
            
            logging.info(f"Participant {self.participant_id}: {participant.participant_id} state: {state}")
        
        return committed_count, aborted_count
    
    def recover_from_coordinator_failure
    

    (self, tx_id: str) -> bool: """Recover when coordinator has failed""" logging.warning(f"Participant {self.participant_id}: Recovering from coordinator failure for {tx_id}")

        current_state = self.get_transaction_state(tx_id)
        
        if current_state in [TransactionState.COMMITTED, TransactionState.ABORTED]:
            logging.info(f"Participant {self.participant_id}: Already decided: {current_state}")
            return current_state == TransactionState.COMMITTED
        
        committed_count, aborted_count = self.query_other_participants(tx_id)
        total_participants = len(self.other_participants) + 1
        
        if committed_count > 0:
            logging.warning(f"Participant {self.participant_id}: Another participant committed, must commit")
            self.commit(tx_id)
            return True
        elif aborted_count >= total_participants // 2:
            logging.warning(f"Participant {self.participant_id}: Majority aborted, aborting")
            self.abort(tx_id)
            return False
        else:
            logging.warning(f"Participant {self.participant_id}: Undecided state, waiting for coordinator")
            return
    

    I can't complete this thought since the next thinking provided is empty. tx_data = TransactionData( transaction_id="TX_002", data={"account": "B", "amount": 200} )

        result = self.coordinator.execute_transaction("TX_002", tx_data)
        
        print(f"\nTransaction Result: {'SUCCESS' if result else 'FAILED'}")
        print(f"Final States:")
        for participant in self.participants:
            state = participant.get_transaction_state("TX_002")
            print(f"  {participant.participant_id}: {state.value}")
    
    def test_coordinator_crash_recovery(self):
        """Test recovery when coordinator crashes after prepare"""
        print("\n" + "="*60)
        print("TEST 3: Coordinator Crash After Prepare - Peer Recovery")
        print("="*60)
    

    I'm executing the transaction with the second participant unable to prepare, which should cause the overall transaction to fail. Then I move into testing coordinator crash recovery scenarios.

    For the crash recovery test, I'm manually triggering the prepare phase by logging the start state and collecting votes from all participants. Once all votes are gathered, I simulate a coordinator crash right after the prepare phase completes. The participants then need to recover by querying each other to determine the transaction outcome, since the coordinator is no longer available to coordinate the commit decision. = [] for i in range(5): thread = threading.Thread(target=execute_transaction, args=(i+4,)) threads.append(thread) thread.start()

        for thread in threads:
            thread.join()
        
        print(f"\nAll concurrent transactions completed")
    

    I'm spawning five threads to execute transactions concurrently, each with a unique ID starting from 4. After launching all threads, I wait for them to complete before moving forward. Once all concurrent operations finish, I print a completion message.

    The main simulation orchestrates the full test suite by running each test case sequentially: the normal two-phase commit flow, a scenario where a participant aborts, recovery from coordinator failure, and finally the concurrent transaction test. = TransactionLogEntry( transaction_id=tx_id, participant_id=participant_id, operation=operation, timestamp=time.time(), state=state, redo_log=redo_log or {}, undo_log=undo_log or {} ) self.logs[tx_id].append(entry)

    def get_logs(self, tx_id: str) -> List[TransactionLogEntry]:
        """Retrieve logs for a transaction"""
        with self.lock:
            return self.logs.get(tx_id, [])
    
    def clear_logs(self, tx_id: str):
        """Clear logs after successful commit"""
        with self.lock:
            if tx_id in self.logs:
                del self.logs[tx_id]
    

    I'm setting up the data structures needed for the two-phase commit protocol. The TransactionLogEntry captures all the details needed for recovery, including redo and undo logs for each operation. The PersistentLog class manages these entries with thread-safe operations, allowing me to write entries during transaction execution, retrieve them for recovery purposes, and clean them up after successful commits. .transactions[tx_id] = { 'data': transaction_data, 'votes': {}, 'state': TransactionState.INITIAL, 'timestamp': time.time() }

        try:
            # Phase 1: Prepare
            if not self._prepare_phase(tx_id):
                logging.warning(f"[COORDINATOR] Prepare phase failed for {tx_id}")
                self._abort_transaction(tx_id)
                return False
            
            # Simulate coordinator crash after prepare
            if self.failed and self.failure_point == "after_prepare":
                logging.error(f"[COORDINATOR] ⚠️  CRASHED after prepare phase for {tx_id}")
                return False
            
            # Phase 2: Commit
            if not self._commit_phase(tx_id):
                logging.warning(f"[COORDINATOR] Commit phase failed for {tx_id}")
                self._abort_transaction(tx_id)
                return False
            
            self.transactions[tx_id]['state'] = TransactionState.COMMITTED
            logging.info(f"[COORDINATOR] ✓ Transaction {tx_id} committed successfully")
            return True
            
        except Exception as e:
            logging.error(f"[COORDINATOR] Exception during transaction {tx_id}: {e}")
            self._abort_transaction(tx_id)
            return False
    

    I'm initializing the transaction record with its data and state, then executing the two-phase commit protocol. First I attempt the prepare phase, checking for a simulated crash point, then proceed to commit if preparation succeeds. If either phase fails, I abort the transaction and return False; otherwise I mark it committed and return True. .PREPARED) else: logging.warning(f"[COORDINATOR] ✗ Not all participants voted YES") self.log.write(tx_id, self.coordinator_id, "PREPARE_FAILED", TransactionState.ABORTED)

        return all_yes
    
    def _get_vote(self, tx_id: str, participant: 'Participant', votes: Dict):
        """Get vote from a participant"""
        try:
            transaction_data = self.transactions[tx_id]['data']
            vote = participant.prepare(tx_id, transaction_data)
            votes[participant.participant_id] = vote
        except Exception as e:
            logging.error(f"[COORDINATOR] Error getting vote: {e}")
            votes[participant.participant_id] = ParticipantVote.NO
    
    def _commit_phase(self, tx_id: str) -> bool:
        """Phase 2: Send commit to all participants"""
        logging.info(f"[COORDINATOR] Phase 2 (Commit): Sending commit decision...")
        
        self.log.write(tx_id, self.coordinator_id, "COMMIT_START", TransactionState.COMMITTED)
        
        threads = []
        results = {}
        
        for participant_id, participant in self.participants.items():
            thread = threading.Thread(
                target=self._send_commit,
                args=(tx_id, participant, results)
            )
            thread.start()
            threads.append(thread)
        
        for thread in threads:
            thread.join()
        
        all_committed = all(results.values())
        
        if all_committed:
            logging.info(f"[COORDINATOR] ✓ All participants committed")
            self.log.write(tx_id, self.coordinator_id, "COMMIT_SUCCESS", TransactionState.COMMITTED)
        else:
            logging.error(f"[COORDINATOR] ✗ Commit phase failed")
        
        return all_committed
    
    def _send_commit(self, tx_id: str, participant: 'Participant', results: Dict):
        """Send commit decision to a participant"""
        try:
            result = participant.commit(tx_id)
            results[participant.participant_id] = result
        except Exception as e:
            logging.error(f"[COORDINATOR] Error sending commit: {e}")
            results[participant.participant_id] = False
    
    def _abort_transaction(self, tx_id: str):
        """Abort transaction on all participants"""
        logging.warning(f"[COORDINATOR] Aborting transaction {tx_id}")
        
        for participant in self.participants.values():
            try:
                participant.abort(tx_id)
            except Exception as e:
                logging.error(f"[COORDINATOR] Abort error: {e}")
    
    def crash(self, failure_point: str = "after_prepare"):
        """Simulate coordinator crash"""
        self.failed = True
        self.failure_point = failure_point
        logging.error(f"[COORDINATOR] ⚠️  FAILURE INJECTED at: {failure_point}")
    
    def recover(self) -> bool:
        """Recover from crash"""
        logging.info("[COORDINATOR] Recovering from failure...")
        self.failed = False
        return True
    

    class Participant: """Two-Phase Commit Participant"""

    def __init__(self, participant_id: str, coordinator: Coordinator = None):
        self.participant_id = participant_id
        self.coordinator = coordinator
        self.prepared_transactions: Dict[str, TransactionData] = {}
        self.transaction_states: Dict[str, TransactionState] = {}
        self.transaction_lock = threading.Lock()
        self.log = PersistentLog()
        self.vote_delay = 0
        self.can_prepare = True
        self.other_participants: List['Participant'] = []
        
    def prepare(self, tx_id: str, transaction_data: TransactionData) -> ParticipantVote:
        """Phase 1: Prepare to commit"""
        logging.info(f"[{self.participant_id}] Phase 1 - Preparing {tx_id}")
        
        time.sleep(self.vote_delay)
        
        with self.transaction_lock:
            self.log.write(tx_id, self.participant_id, "PREPARE", 
                          TransactionState.PREPARED,
                          transaction_data)
            
            vote = ParticipantVote.YES if self.can_prepare else ParticipantVote.NO
            
            if vote == ParticipantVote.YES:
                self.prepared_transactions[tx_id] = transaction_data
                self.transaction_states[tx_id] = TransactionState.PREPARED
                logging.info(f"[{self.participant_id}] ✓ Voted YES for {tx_id}")
            else:
                self.transaction_states[tx_id] = TransactionState.ABORTED
                logging.info(f"[{self.participant_id}] ✗ Voted NO for {tx_id}")
            
            return vote
    
    def commit(self, tx_id: str) -> bool:
        """Phase 2: Commit the transaction"""
        logging.info(f"[{self.participant_id}] Phase 2 - Committing {tx_id}")
        
        with self.transaction_lock:
            if tx_id not in self.prepared_transactions:
                logging.error(f"[{self.participant_id}] No prepared transaction {tx_id}")
                return False
            
            try:
                transaction_data = self.prepared_transactions[tx_id]
                self._apply_transaction(transaction_data)
                
                self.log.write(tx_id, self.participant_id, "COMMIT", 
                              TransactionState.COMMITTED,
                              transaction_data)
                
                self.transaction_states[tx_id] = TransactionState.COMMITTED
                del self.prepared_transactions[tx_id]
                
                logging.info(f"[{self.participant_id}] ✓ Committed {tx_id}")
    

    During the prepare phase, I check if I can proceed and cast my vote accordingly—storing the transaction if approved or marking it aborted if not. In the commit phase, I apply the prepared transaction to my state, log the completion, and clean up the prepared transaction record. decided_count += 1 logging.info(f"[{self.participant_id}] {participant.participant_id}: {state.value}")

        return committed_count, aborted_count, undecided_count
    

    When the coordinator fails, I need to query other participants about the transaction state. If any have committed, I must commit as well. If all have aborted, I can safely abort. Otherwise, I wait for the coordinator to recover. When no consensus emerges yet, I return None to signal waiting for the coordinator's decision. Then I define setter methods for controlling participant behavior—one to toggle preparation capability and another to introduce voting delays for testing purposes. The simulation class itself initializes a coordinator and three participants that will execute the two-phase commit protocol.

    After creating the participants, I register each one with the coordinator and establish peer references among them to enable recovery mechanisms. The utility methods format output for readability—one prints section headers with dividers, while another displays the final transaction states for each participant, using checkmarks or X marks to indicate whether they committed or aborted.

    For the first test, I reset the participants' preparation flags and create a transaction, then execute it through the coordinator and print the results. The second test begins by checking participant abort scenarios.

    In test 2, I configure the second participant to reject the prepare phase by setting its ability to false, then execute a similar transaction flow. The test verifies that the coordinator correctly aborts when a participant refuses to prepare. After execution, I check that the result is false (indicating proper abort behavior) and display the transaction results.

    For test 3, I need to simulate a coordinator crash scenario after the prepare phase completes, testing whether peers can recover the transaction state. I reset the coordinator's failure flags and participant states, then manually walk through the two-phase commit with crash injection at a specific point. The prepare phase begins with the coordinator logging its initial state before sending prepare requests to participants.

    All participants vote affirmatively on the prepare request. Then I inject a coordinator crash right after the prepare phase succeeds but before the commit phase begins. The participants detect this failure and attempt peer-based recovery by consulting each other to determine the correct outcome.

    Each participant queries its peers and collects their responses. Based on the consensus from these peer queries—since all voted YES during prepare—they collectively decide to commit the transaction. Finally, I reset the coordinator's failed state and restore all participants' prepare capabilities for the next test scenario.

    Now I'm setting up concurrent transaction execution by defining a helper function that creates and processes individual transactions with unique IDs and data. I spawn five threads to run these transactions in parallel, then wait for all threads to complete before summarizing the results.

    After collecting the execution outcomes, I iterate through each transaction to display whether it succeeded or failed with a visual indicator. Then I move into a more complex test scenario involving recovery procedures, where I reset the coordinator and participants to a clean state before attempting a multi-phase transaction with prepare and commit stages.

    During the prepare phase, all participants vote affirmatively. To simulate a partial commit state, the first participant commits independently. The coordinator then crashes, forcing the remaining participants to detect the failure and query their peers for recovery information. Since one participant has already committed, all others must follow suit to maintain consistency.

    The simulation then displays the final state of all participants. The main function sets up the test harness with a formatted header, instantiates the simulation, and runs through a series of test scenarios including normal commits, participant aborts, coordinator recovery, concurrent transactions, and partial recovery scenarios with brief delays between each test. The implementation handles coordinator failures through a recovery mechanism where participants detect the crash and use peer-to-peer consensus to determine the correct outcome. If any participant has committed, all must commit based on write-ahead logs; if any voted to abort, the transaction safely aborts. It includes comprehensive test scenarios covering normal commits, participant rejections, coordinator crashes with peer recovery, concurrent transactions, and complex recovery situations. The system uses thread-safe locks for concurrent operations, maintains persistent logs for durability, provides detailed logging output, manages transaction state properly, and simulates realistic delays and failure conditions.

    Two-Phase Commit Protocol with Coordinator Failure Recovery

    Here's a comprehensive implementation of 2PC with coordinator failure handling and peer recovery:

    import threading
    import time
    from enum import Enum
    from typing import Dict, List, Tuple
    from dataclasses import dataclass, field
    from collections import defaultdict
    import logging
    
    # Setup logging
    logging.basicConfig(
        level=logging.INFO,
        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
    )
    
    class TransactionState(Enum):
        """Transaction states during 2PC"""
        INITIAL = "INITIAL"
        PREPARE_SENT = "PREPARE_SENT"
        PREPARED = "PREPARED"
        COMMITTED = "COMMITTED"
        ABORTED = "ABORTED"
    
    class ParticipantVote(Enum):
        """Participant voting response"""
        UNDECIDED = "UNDECIDED"
        YES = "YES"
        NO = "NO"
    
    @dataclass
    class TransactionLogEntry:
        """Persistent log entry for recovery"""
        transaction_id: str
        participant_id: str
        operation: str
        timestamp: float
        state: TransactionState
        redo_log: Dict = field(default_factory=dict)
        undo_log: Dict = field(default_factory=dict)
    
    @dataclass
    class TransactionData:
        """Transaction to be committed"""
        transaction_id: str
        data: Dict
        metadata: Dict = field(default_factory=dict)
    
    class PersistentLog:
        """Write-Ahead Log for crash recovery"""
        def __init__(self):
            self.logs: Dict[str, List[TransactionLogEntry]] = defaultdict(list)
            self.lock = threading.RLock()
        
        def write(self, tx_id: str, participant_id: str, operation: str, 
                  state: TransactionState, redo_log: Dict = None, undo_log: Dict = None):
            """Write log entry (WAL)"""
            with self.lock:
                entry = TransactionLogEntry(
                    transaction_id=tx_id,
                    participant_id=participant_id,
                    operation=operation,
                    timestamp=time.time(),
                    state=state,
                    redo_log=redo_log or {},
                    undo_log=undo_log or {}
                )
                self.logs[tx_id].append(entry)
                logging.debug(f"[LOG] {participant_id}: {operation} → {state.value}")
        
        def read(self, tx_id: str) -> List[TransactionLogEntry]:
            """Read all logs for a transaction"""
            with self.lock:
                return self.logs.get(tx_id, [])
        
        def get_final_state(self, tx_id: str) -> TransactionState:
            """Get final committed state from logs"""
            logs = self.read(tx_id)
            if logs:
                return logs[-1].state
            return TransactionState.INITIAL
    
    class Coordinator:
        """Two-Phase Commit Coordinator"""
        
        def __init__(self, coordinator_id: str):
            self.coordinator_id = coordinator_id
            self.participants: Dict[str, 'Participant'] = {}
            self.transactions: Dict[str, Dict] = {}
            self.transaction_lock = threading.RLock()
            self.log = PersistentLog()
            self.failed = False
            self.failure_point = None
            logging.info(f"[COORDINATOR] Initialized {coordinator_id}")
            
        def register_participant(self, participant: 'Participant'):
            """Register participant in the transaction"""
            self.participants[participant.participant_id] = participant
            logging.info(f"[COORDINATOR] Registered {participant.participant_id}")
        
        def execute_transaction(self, tx_id: str, transaction_data: TransactionData) -> bool:
            """Execute full 2PC protocol: Prepare → Commit"""
            logging.info(f"[COORDINATOR] ▶ Starting transaction {tx_id}")
            
            with self.transaction_lock:
                self.transactions[tx_id] = {
                    'data': transaction_data,
                    'votes': {},
                    'state': TransactionState.INITIAL,
                    'timestamp': time.time()
                }
            
            try:
                # PHASE 1: Prepare
                if not self._prepare_phase(tx_id):
                    logging.warning(f"[COORDINATOR] Prepare failed → Aborting {tx_id}")
                    self._abort_transaction(tx_id)
                    return False
                
                # Simulate coordinator crash after prepare
                if self.failed and self.failure_point == "after_prepare":
                    logging.error(f"[COORDINATOR] ⚠️  CRASHED after prepare phase")
                    raise RuntimeError("Coordinator crashed")
                
                # PHASE 2: Commit
                if not self._commit_phase(tx_id):
                    logging.warning(f"[COORDINATOR] Commit failed → Aborting")
                    self._abort_transaction(tx_id)
                    return False
                
                logging.info(f"[COORDINATOR] ✓ {tx_id} committed successfully")
                return True
                
            except Exception as e:
                logging.error(f"[COORDINATOR] Exception: {e}")
                self._abort_transaction(tx_id)
                return False
        
        def _prepare_phase(self, tx_id: str) -> bool:
            """Phase 1: Request all participants to prepare"""
            logging.info(f"[COORDINATOR] ═════ PHASE 1: PREPARE ═════")
            
            self.log.write(tx_id, self.coordinator_id, "PREPARE_START", TransactionState.PREPARE_SENT)
            
            votes = {}
            threads = []
            
            # Send prepare requests in parallel
            for participant_id, participant in self.participants.items():
                thread = threading.Thread(
                    target=self._get_vote,
                    args=(tx_id, participant, votes)
                )
                thread.start()
                threads.append(thread)
            
            # Wait for all votes
            for thread in threads:
                thread.join()
            
            with self.transaction_lock:
                self.transactions[tx_id]['votes'] = votes
            
            # Check if all voted YES (unanimous consent required)
            all_yes = all(vote == ParticipantVote.YES for vote in votes.values())
            
            vote_summary = {pid: v.value for pid, v in votes.items()}
            logging.info(f"[COORDINATOR] Votes: {vote_summary}")
            
            if all_yes:
                logging.info(f"[COORDINATOR] ✓ All participants voted YES")
                self.log.write(tx_id, self.coordinator_id, "PREPARE_SUCCESS", 
                              TransactionState.PREPARED)
            else:
                logging.warning(f"[COORDINATOR] ✗ Prepare failed - not all YES")
                self.log.write(tx_id, self.coordinator_id, "PREPARE_FAILED", 
                              TransactionState.ABORTED)
            
            return all_yes
        
        def _get_vote(self, tx_id: str, participant: 'Participant', votes: Dict):
            """Collect vote from a participant"""
            try:
                transaction_data = self.transactions[tx_id]['data']
                vote = participant.prepare(tx_id, transaction_data)
                votes[participant.participant_id] = vote
            except Exception as e:
                logging.error(f"[COORDINATOR] Vote error: {e}")
                votes[participant.participant_id] = ParticipantVote.NO
        
        def _commit_phase(self, tx_id: str) -> bool:
            """Phase 2: Send commit decision to all participants"""
            logging.info(f"[COORDINATOR] ═════ PHASE 2: COMMIT ═════")
            
            self.log.write(tx_id, self.coordinator_id, "COMMIT_START", TransactionState.COMMITTED)
            
            threads = []
            results = {}
            
            # Send commit requests in parallel
            for participant_id, participant in self.participants.items():
                thread = threading.Thread(
                    target=self._send_commit,
                    args=(tx_id, participant, results)
                )
                thread.start()
                threads.append(thread)
            
            # Wait for all commits
            for thread in threads:
                thread.join()
            
            all_committed = all(results.values())
            
            logging.info(f"[COORDINATOR] Commit results: {results}")
            
            if all_committed:
                logging.info(f"[COORDINATOR] ✓ All participants committed")
                self.log.write(tx_id, self.coordinator_id, "COMMIT_SUCCESS", 
                              TransactionState.COMMITTED)
            else:
                logging.error(f"[COORDINATOR] ✗ Commit incomplete")
            
            return all_committed
        
        def _send_commit(self, tx_id: str, participant: 'Participant', results: Dict):
            """Send commit message to participant"""
            try:
                result = participant.commit(tx_id)
                results[participant.participant_id] = result
            except Exception as e:
                logging.error(f"[COORDINATOR] Commit send error: {e}")
                results[participant.participant_id] = False
        
        def _abort_transaction(self, tx_id: str):
            """Abort transaction on all participants"""
            logging.warning(f"[COORDINATOR] Aborting {tx_id} on all participants")
            
            for participant in self.participants.values():
                try:
                    participant.abort(tx_id)
                except Exception as e:
                    logging.error(f"[COORDINATOR] Abort error: {e}")
        
        def crash(self, failure_point: str = "after_prepare"):
            """Inject coordinator failure"""
            self.failed = True
            self.failure_point = failure_point
            logging.error(f"[COORDINATOR] ⚠️  FAILURE INJECTED at: {failure_point}")
        
        def recover(self) -> bool:
            """Recover from crash"""
            logging.info("[COORDINATOR] Recovering from crash...")
            self.failed = False
            return True
    
    class Participant:
        """Two-Phase Commit Participant/Resource Manager"""
        
        def __init__(self, participant_id: str):
            self.participant_id = participant_id
            self.prepared_transactions: Dict[str, TransactionData] = {}
            self.transaction_states: Dict[str, TransactionState] = {}
            self.transaction_lock = threading.RLock()
            self.log = PersistentLog()
            self.can_prepare = True
            self.other_participants: List['Participant'] = []
            logging.info(f"[{participant_id}] Initialized")
            
        def prepare(self, tx_id: str, transaction_data: TransactionData) -> ParticipantVote:
            """Phase 1: Prepare to commit
            
            - Lock resources
            - Perform redo logging
            - Return YES if ready to commit, NO otherwise
            """
            logging.info(f"[{self.participant_id}] Phase 1 - Preparing {tx_id}")
            
            with self.transaction_lock:
                try:
                    # Log redo information for recovery
                    self.log.write(tx_id, self.participant_id, "PREPARE", 
                                  TransactionState.PREPARED,
                                  redo_log={'data': transaction_data.data})
                    
                    # Simulate prepare decision
                    vote = ParticipantVote.YES if self.can_prepare else ParticipantVote.NO
                    
                    if vote == ParticipantVote.YES:
                        # Lock resources and store prepared transaction
                        self.prepared_transactions[tx_id] = transaction_data
                        self.transaction_states[tx_id] = TransactionState.PREPARED
                        logging.info(f"[{self.participant_id}] ✓ Voted YES - {tx_id}")
                    else:
                        self.transaction_states[tx_id] = TransactionState.ABORTED
                        logging.info(f"[{self.participant_id}] ✗ Voted NO - {tx_id}")
                    
                    return vote
                    
                except Exception as e:
                    logging.error(f"[{self.participant_id}] Prepare error: {e}")
                    self.transaction_states[tx_id] = TransactionState.ABORTED
                    return ParticipantVote.NO
        
        def commit(self, tx_id: str) -> bool:
            """Phase 2: Commit the transaction
            
            - Apply changes using redo log
            - Release locks
            - Perform undo logging
            """
            logging.info(f"[{self.participant_id}] Phase 2 - Committing {tx_id}")
            
            with self.transaction_lock:
                if tx_id not in self.prepared_transactions:
                    logging.error(f"[{self.participant_id}] No prepared tx: {tx_id}")
                    return False
                
                try:
                    transaction_data = self.prepared_transactions[tx_id]
                    
                    # Apply transaction (in real system: apply to database)
                    self._apply_transaction(transaction_data)
                    
                    # Log successful commit
                    self.log.write(tx_id, self.participant_id, "COMMIT", 
                                  TransactionState.COMMITTED,
                                  redo_log={'data': transaction_data.data})
                    
                    self.transaction_states[tx_id] = TransactionState.COMMITTED
                    del self.prepared_transactions[tx_id]
                    
                    logging.info(f"[{self.participant_id}] ✓ Committed {tx_id}")
                    return True
                    
                except Exception as e:
                    logging.error(f"[{self.participant_id}] Commit error: {e}")
                    self.transaction_states[tx_id] = TransactionState.ABORTED
                    return False
        
        def abort(self, tx_id: str) -> bool:
            """Abort the transaction
            
            - Release locks
            - Discard prepared changes
            """
            logging.info(f"[{self.participant_id}] Aborting {tx_id}")
            
            with self.transaction_lock:
                self.log.write(tx_id, self.participant_id, "ABORT", TransactionState.ABORTED)
                
                if tx_id in self.prepared_transactions:
                    del self.prepared_transactions[tx_id]
                
                self.transaction_states[tx_id] = TransactionState.ABORTED
                logging.info(f"[{self.participant_id}] ✓ Aborted {tx_id}")
                return True
        
        def _apply_transaction(self, transaction_data: TransactionData):
            """Apply transaction to resource (simulated)"""
            logging.info(f"[{self.participant_id}] Applying: {transaction_data.data}")
            # In real system: modify database state
        
        def get_transaction_state(self, tx_id: str) -> TransactionState:
            """Query transaction state"""
            with self.transaction_lock:
                return self.transaction_states.get(tx_id, TransactionState.INITIAL)
        
        def set_other_participants(self, participants: List['Participant']):
            """Set peer references for failure recovery"""
            self.other_participants = [p for p in participants 
                                      if p.participant_id != self.participant_id]
        
        def query_other_participants(self, tx_id: str) -> Tuple[int, int, int]:
            """Query peers about transaction state
            
            Returns: (committed_count, aborted_count, undecided_count)
            
            Strategy for consensus when coordinator fails:
            - If ANY participant committed → ALL must commit
            - Block until consensus is reached
            """
            logging.warning(f"[{self.participant_id}] 📢 Querying peers about {tx_id}")
            
            committed_count = 0
            aborted_count = 0
            undecided_count = 0
            
            for participant in self.other_participants:
                state = participant.get_transaction_state(tx_id)
                
                if state == TransactionState.COMMITTED:
                    committed_count += 1
                    status = "COMMITTED ✓"
                elif state == TransactionState.ABORTED:
                    aborted_count += 1
                    status = "ABORTED ✗"
                else:
                    undecided_count += 1
                    status = "UNDECIDED ?"
                
                logging.info(f"[{self.participant_id}]   {participant.participant_id}: {status}")
            
            return committed_count, aborted_count, undecided_count
        
        def recover_from_coordinator_failure(self, tx_id: str) -> bool:
            """Recover when coordinator crashes after prepare
            
            Blocking protocol:
            1. Query all peers about transaction state
            2. If ANY committed → MUST commit (consensus)
            3. If ALL aborted → can abort
            4. Otherwise → wait for coordinator recovery
            """
            logging.warning(f"[{self.participant_id}] ⚠️  COORDINATOR FAILURE - Recovering {tx_id}")
            
            current_state = self.get_transaction_state(tx_id)
            
            # Already decided - no recovery needed
            if current_state in [TransactionState.COMMITTED, TransactionState.ABORTED]:
                logging.info(f"[{self.participant_id}] Already decided: {current_state.value}")
                return current_state == TransactionState.COMMITTED
            
            # Query peer participants
            committed_count, aborted_count, undecided_count = self.query_other_participants(tx_id)
            total = len(self.other_participants)
            
            print(f"\n  Summary for {self.participant_id}:")
            print(f"    Committed: {committed_count}/{total}")
            print(f"    Aborted:   {aborted_count}/{total}")
            print(f"    Undecided: {undecided_count}/{total}\n")
            
            # CONSENSUS RULES
            if committed_count > 0:
                # At least one participant committed → ALL MUST commit
                logging.warning(f"[{self.participant_id}] Following leader: Must COMMIT")
                self.commit(tx_id)
                return True
                
            elif aborted_count == total:
                # All peers aborted → Can safely abort
                logging.warning(f"[{self.participant_id}] All peers aborted → ABORT")
                self.abort(tx_id)
                return False
                
            else:
                # No consensus yet → Block and wait
                logging.warning(f"[{self.participant_id}] No consensus - will retry")
                return None
        
        def set_prepare_ability(self, can_prepare: bool):
            """Control whether this participant can prepare"""
            self.can_prepare = can_prepare
    
    
    class TwoPhaseCommitSimulation:
        """Simulation orchestrator"""
        
        def __init__(self):
            self.coordinator = Coordinator("COORDINATOR_1")
            self.participants = [
                Participant("PARTICIPANT_1"),
                Participant("PARTICIPANT_2"),
                Participant("PARTICIPANT_3"),
            ]
            
            # Register and interconnect
            for p in self.participants:
                self.coordinator.register_participant(p)
                p.set_other_participants(self.participants)
        
        def print_header(self, title: str):
            """Print test header"""
            print("\n" + "█"*75)
            print(f"█ {title:<73} █")
            print("█"*75 + "\n")
        
        def print_results(self, tx_id: str):
            """Print final transaction states"""
            print("\n" + "─"*75)
            print("FINAL TRANSACTION STATES:")
            for p in self.participants:
                state = p.get_transaction_state(tx_id)
                icon = "✓" if state == TransactionState.COMMITTED else "✗"
                print(f"  {icon} {p.participant_id}: {state.value}")
            print("─"*75 + "\n")
        
        def test_normal_commit(self):
            """Test 1: Normal 2PC without failures"""
            self.print_header("TEST 1: Normal Two-Phase Commit")
            
            # Reset state
            for p in self.participants:
                p.can_prepare = True
            
            tx_data = TransactionData(
                transaction_id="TX_001",
                data={"account": "ACC_001", "amount": 1000}
            )
            
            result = self.coordinator.execute_transaction("TX_001", tx_data)
            
            print(f"Result: {'✓ SUCCESS' if result else '✗ FAILED'}")
            self.print_results("TX_001")
        
        def test_participant_vote_no(self):
            """Test 2: One participant votes NO"""
            self.print_header("TEST 2: Participant Votes NO")
            
            self.coordinator = Coordinator("COORDINATOR_2")
            for p in self.participants:
                p.can_prepare = True
                self.coordinator.register_participant(p)
            
            # Participant 2 cannot prepare
            self.participants[1].set_prepare_ability(False)
            
            tx_data = TransactionData(
                transaction_id="TX_002",
                data={"account": "ACC_002", "amount": 2000}
            )
            
            result = self.coordinator.execute_transaction("TX_002", tx_data)
            
            print(f"Result: {'✓ Correctly ABORTED' if not result else '✗ FAILED'}")
            self.print_results("TX_002")
        
        def test_coordinator_crash_recovery(self):
            """Test 3: Coordinator crashes after prepare"""
            self.print_header("TEST 3: Coordinator Crash After Prepare - Peer Recovery")
            
            self.coordinator = Coordinator("COORDINATOR_3")
            for p in self.participants:
                p.can_prepare = True
                self.coordinator.register_participant(p)
            
            tx_id = "TX_003"
            tx_data = TransactionData(
                transaction_id=tx_id,
                data={"account": "ACC_003", "amount": 3000}
            )
            
            # Manual 2PC with crash
            print("PHASE 1: PREPARE")
            self.coordinator.log.write(tx_id, self.coordinator_id, "PREPARE_START", 
                                      TransactionState.PREPARE_SENT)
            
            for p in self.participants:
                p.prepare(tx_id, tx_data)
            
            print("\n⚠️  COORDINATOR CRASHES after prepare (before commit)\n")
            self.coordinator.crash("after_prepare")
            
            # Recovery: participants query each other
            print("RECOVERY PHASE: Peer Consensus")
            print("─"*75)
            
            for p in self.participants:
                print(f"\n{p.participant_id} initiating recovery...\n")
                result = p.recover_from_coordinator_failure(tx_id)
                
            print("─"*75)
            self.print_results(tx_id)
        
        def test_cascading_commit(self):
            """Test 4: One participant already committed"""
            self.print_header("TEST 4: Cascading Commit After Coordinator Crash")
            
            self.coordinator = Coordinator("COORDINATOR_4")
            for p in self.participants:
                p.can_prepare = True
                self.coordinator.register_participant(p)
            
            tx_id = "TX_004"
            tx_data = TransactionData(
                transaction_id=tx_id,
                data={"account": "ACC_004", "amount": 4000}
            )
            
            print("PHASE 1: PREPARE")
            for p in self.participants:
                p.prepare(tx_id, tx_data)
            
            print("\nSimulating partial state: First participant commits early")
            self.participants[0].commit(tx_id)
            
            print("⚠️  COORDINATOR CRASHES\n")
            self.coordinator.crash("after_prepare")
            
            print("RECOVERY PHASE: Following committed participant")
            print("─"*75)
            
            # Other participants must follow
            for i in range(1, len(self.participants)):
                print(f"\n{self.participants[i].participant_id} recovery...\n")
                self.participants[i].recover_from_coordinator_failure(tx_id)
            
            print("─"*75)
            self.print_results(tx_id)
        
        def test_concurrent_transactions(self):
            """Test 5: Multiple concurrent transactions"""
            self.print_header("TEST 5: Concurrent Transactions")
            
            self.coordinator = Coordinator("COORDINATOR_5")
            for p in self.participants:
                p.can_prepare = True
                self.coordinator.register_participant(p)
            
            def execute_tx(tx_num: int):
                tx_id = f"TX_{200+tx_num}"
                tx_data = TransactionData(
                    transaction_id=tx_id,
                    data={"id": tx_num, "value": tx_num * 100}
                )
                result = self.coordinator.execute_transaction(tx_id, tx_data)
                return tx_id, result
            
            print("Executing 4 concurrent transactions...\n")
            
            threads = []
            results = []
            lock = threading.Lock()
            
            def thread_func(n):
                tx_id, success = execute_tx(n)
                with lock:
                    results.append((tx_id, success))
            
            for i in range(4):
                t = threading.Thread(target=thread_func, args=(i,))
                threads.append(t)
                t.start()
            
            for t in threads:
                t.join()
            
            print("\n" + "─"*75)
            print("TRANSACTION SUMMARY:")
            for tx_id, success in sorted(results):
                icon = "✓" if success else "✗"
                print(f"  {icon} {tx_id}: {'COMMITTED' if success else 'ABORTED'}")
            print("─"*75 + "\n")
    
    
    def main():
        """Execute all tests"""
        print("\n" + "╔" + "═"*73 + "╗")
        print("║" + " "*18 + "TWO-PHASE COMMIT PROTOCOL SIMULATION" + " "*20 + "║")
        print("║" + " "*17 + "With Coordinator Failure & Peer Recovery" + " "*15 + "║")
        print("╚" + "═"*73 + "╝")
        
        simulation = TwoPhaseCommitSimulation()
        
        try:
            simulation.test_normal_commit()
            time.sleep(0.5)
            
            simulation.test_participant_vote_no()
            time.sleep(0.5)
            
            simulation.test_coordinator_crash_recovery()
            time.sleep(0.5)
            
            simulation.test_cascading_commit()
            time.sleep(0.5)
            
            simulation.test_concurrent_transactions()
            
        except KeyboardInterrupt:
            print("\nSimulation interrupted")
        except Exception as e:
            logging.error(f"Error: {e}", exc_info=True)
        
        print("\n" + "═"*75)
        print("SIMULATION COMPLETE")
        print("═"*75 + "\n")
    
    if __name__ == "__main__":
        main()
    

    Key Features:

    ✅ Two-Phase Commit Protocol

    • Phase 1 (Prepare): Coordinator requests readiness from all participants
    • Phase 2 (Commit): Send final decision to all participants

    ✅ Coordinator Failure Handling

    • Crash injection after prepare phase
    • Participants detect failure and query peers
    • Consensus-based recovery mechanism

    ✅ Recovery Strategy

    • If ANY committed: All must commit (durability guarantee)
    • If ALL aborted: Safe to abort
    • Otherwise: Wait for coordinator recovery

    ✅ Thread-Safe Operations

    • RLock for re-entrant locking
    • Parallel prepare and commit phases
    • Concurrent transaction support

    ✅ Persistent Logging

    • Write-Ahead Log (WAL) for redo/undo
    • Recovery points for crash scenarios
    • State persistence across failures

    ✅ 5 Test Scenarios

    1. Normal commit flow
    2. Participant rejection
    3. Coordinator crash with peer recovery
    4. Cascading commit scenario
    5. Concurrent transactions

    This implementation accurately models real distributed systems like databases!

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.