Struct DistributedTransaction 

pub struct DistributedTransaction {
    pub id: String,
    pub participants: Vec<TransactionParticipant>,
    pub state: TransactionState,
    pub metadata: HashMap<String, String>,
}

Distributed transaction using Two-Phase Commit (2PC) protocol

Coordinates transactions across multiple databases to ensure atomicity.

Example

use rust_logic_graph::multi_db::DistributedTransaction;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let mut txn = DistributedTransaction::new("order_txn_123");
     
    // Register participants
    txn.add_participant("orders_db", "Insert order");
    txn.add_participant("inventory_db", "Decrement stock");
    txn.add_participant("payments_db", "Charge customer");
     
    // Phase 1: Prepare
    txn.prepare().await?;
     
    // Phase 2: Commit (or abort if any participant fails)
    if txn.can_commit() {
        txn.commit().await?;
    } else {
        txn.abort().await?;
    }
     
    Ok(())
}

Fields

id: String

participants: Vec<TransactionParticipant>

state: TransactionState

metadata: HashMap<String, String>

Implementations

impl DistributedTransaction

pub fn new(id: impl Into<String>) -> Self

Create a new distributed transaction

pub fn add_participant( &mut self, database: impl Into<String>, id: impl Into<String>, ) -> &mut Self

Add a participant to the transaction

pub fn add_metadata( &mut self, key: impl Into<String>, value: impl Into<String>, ) -> &mut Self

Add metadata to the transaction

pub async fn prepare(&mut self) -> Result<bool, RustLogicGraphError>

Phase 1: Prepare - Ask all participants if they can commit

In a real implementation, this would:

1. Lock resources in each database
2. Validate constraints
3. Write to transaction log
4. Return ready/abort status

pub fn can_commit(&self) -> bool

Check if transaction can commit (all participants prepared)

pub async fn commit(&mut self) -> Result<(), RustLogicGraphError>

Phase 2: Commit - Instruct all participants to commit

pub async fn abort(&mut self) -> Result<(), RustLogicGraphError>

Abort/rollback the transaction

Trait Implementations

impl Clone for DistributedTransaction

fn clone(&self) -> DistributedTransaction

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.