Skip to main content

yaiko_core/
transaction.rs

1//! Deterministic transaction state helpers.
2#[derive(Debug, Clone, Copy, PartialEq, Eq)]
3pub enum TransactionState {
4    Active,
5    Committed,
6    RolledBack,
7}
8#[derive(Debug, Clone, PartialEq, Eq)]
9pub enum TransactionError {
10    InvalidState,
11    Capacity,
12    InvalidRetries,
13}
14#[derive(Debug, Clone, PartialEq, Eq)]
15pub struct Transaction {
16    pub id: String,
17    pub operations: Vec<String>,
18    pub retries: u32,
19    pub max_retries: u32,
20    pub state: TransactionState,
21}
22impl Transaction {
23    pub fn begin(id: impl Into<String>, max_retries: u32) -> Result<Self, TransactionError> {
24        if max_retries > 32 {
25            return Err(TransactionError::InvalidRetries);
26        }
27        Ok(Self {
28            id: id.into(),
29            operations: Vec::new(),
30            retries: 0,
31            max_retries,
32            state: TransactionState::Active,
33        })
34    }
35    pub fn record(&mut self, operation: impl Into<String>) -> Result<(), TransactionError> {
36        if self.state != TransactionState::Active {
37            return Err(TransactionError::InvalidState);
38        }
39        let operation = operation.into();
40        if operation.is_empty() || operation.len() > 256 {
41            return Err(TransactionError::Capacity);
42        }
43        self.operations.push(operation);
44        Ok(())
45    }
46    pub fn commit(&mut self) -> Result<(), TransactionError> {
47        if self.state != TransactionState::Active {
48            return Err(TransactionError::InvalidState);
49        }
50        self.state = TransactionState::Committed;
51        Ok(())
52    }
53    pub fn rollback(&mut self) -> Result<(), TransactionError> {
54        if self.state != TransactionState::Active {
55            return Err(TransactionError::InvalidState);
56        }
57        self.state = TransactionState::RolledBack;
58        Ok(())
59    }
60    pub fn retry(&mut self) -> Result<(), TransactionError> {
61        if self.state != TransactionState::Active {
62            return Err(TransactionError::InvalidState);
63        }
64        if self.retries >= self.max_retries {
65            return Err(TransactionError::InvalidRetries);
66        }
67        self.retries += 1;
68        Ok(())
69    }
70}
71#[cfg(test)]
72mod tests {
73    use super::*;
74    #[test]
75    fn records_and_commits_once() {
76        let mut t = Transaction::begin("tx-1", 1).unwrap();
77        t.record("insert media").unwrap();
78        t.commit().unwrap();
79        assert_eq!(t.state, TransactionState::Committed);
80        assert!(t.record("late").is_err())
81    }
82    #[test]
83    fn rolls_back_and_bounds_retries() {
84        let mut t = Transaction::begin("tx-2", 1).unwrap();
85        t.retry().unwrap();
86        assert!(t.retry().is_err());
87        t.rollback().unwrap();
88        assert!(t.commit().is_err())
89    }
90}