#[derive(Debug, Clone, PartialEq)]
pub enum PeerConnectionState {
New,
Connecting {
started_at_ms: u64,
},
Connected {
peer_id: String,
established_at_ms: u64,
},
Disconnected {
peer_id: String,
reason: String,
},
Failed {
error: String,
},
}
pub struct PeerStateMachine {
state: PeerConnectionState,
transition_log: Vec<(u64, PeerConnectionState)>,
}
impl PeerStateMachine {
pub fn new() -> Self {
Self {
state: PeerConnectionState::New,
transition_log: Vec::new(),
}
}
pub fn state(&self) -> &PeerConnectionState {
&self.state
}
pub fn is_connected(&self) -> bool {
matches!(&self.state, PeerConnectionState::Connected { .. })
}
pub fn peer_id(&self) -> Option<&str> {
match &self.state {
PeerConnectionState::Connected { peer_id, .. } => Some(peer_id.as_str()),
_ => None,
}
}
pub fn transition_count(&self) -> usize {
self.transition_log.len()
}
pub fn last_transition_ms(&self) -> Option<u64> {
self.transition_log.last().map(|(ts, _)| *ts)
}
pub fn start_connecting(&mut self, now_ms: u64) -> Result<(), String> {
match &self.state {
PeerConnectionState::New => {
let new_state = PeerConnectionState::Connecting {
started_at_ms: now_ms,
};
self.apply_transition(now_ms, new_state);
Ok(())
}
other => Err(format!(
"start_connecting: invalid transition from {other:?}; expected New"
)),
}
}
pub fn mark_connected(&mut self, peer_id: String, now_ms: u64) -> Result<(), String> {
match &self.state {
PeerConnectionState::Connecting { .. } => {
let new_state = PeerConnectionState::Connected {
peer_id,
established_at_ms: now_ms,
};
self.apply_transition(now_ms, new_state);
Ok(())
}
other => Err(format!(
"mark_connected: invalid transition from {other:?}; expected Connecting"
)),
}
}
pub fn mark_disconnected(&mut self, reason: String, now_ms: u64) -> Result<(), String> {
match &self.state {
PeerConnectionState::Connected { peer_id, .. } => {
let peer_id_clone = peer_id.clone();
let new_state = PeerConnectionState::Disconnected {
peer_id: peer_id_clone,
reason,
};
self.apply_transition(now_ms, new_state);
Ok(())
}
other => Err(format!(
"mark_disconnected: invalid transition from {other:?}; expected Connected"
)),
}
}
pub fn mark_failed(&mut self, error: String) -> Result<(), String> {
let new_state = PeerConnectionState::Failed { error };
self.apply_transition(0, new_state);
Ok(())
}
pub fn reset(&mut self) {
self.state = PeerConnectionState::New;
self.transition_log.clear();
}
fn apply_transition(&mut self, now_ms: u64, new_state: PeerConnectionState) {
self.state = new_state.clone();
self.transition_log.push((now_ms, new_state));
}
}
impl Default for PeerStateMachine {
fn default() -> Self {
Self::new()
}
}
#[cfg(all(test, not(target_arch = "wasm32")))]
mod tests {
use super::{PeerConnectionState, PeerStateMachine};
#[test]
fn test_initial_state_is_new() {
let machine = PeerStateMachine::new();
assert_eq!(
machine.state(),
&PeerConnectionState::New,
"fresh machine must be in New state"
);
assert_eq!(machine.transition_count(), 0);
assert!(machine.last_transition_ms().is_none());
}
#[test]
fn test_new_to_connecting() {
let mut machine = PeerStateMachine::new();
machine
.start_connecting(1000)
.expect("New → Connecting must succeed");
assert_eq!(
machine.state(),
&PeerConnectionState::Connecting {
started_at_ms: 1000
},
);
assert_eq!(machine.transition_count(), 1);
assert_eq!(machine.last_transition_ms(), Some(1000));
}
#[test]
fn test_invalid_transition_connecting_from_connected() {
let mut machine = PeerStateMachine::new();
machine.start_connecting(100).expect("New → Connecting");
machine
.mark_connected("peer-x".to_string(), 200)
.expect("Connecting → Connected");
let result = machine.start_connecting(300);
assert!(
result.is_err(),
"start_connecting from Connected must return Err"
);
assert!(machine.is_connected());
}
#[test]
fn test_connecting_to_connected() {
let mut machine = PeerStateMachine::new();
machine.start_connecting(500).expect("New → Connecting");
machine
.mark_connected("peer-alpha".to_string(), 750)
.expect("Connecting → Connected");
assert!(machine.is_connected());
assert_eq!(machine.peer_id(), Some("peer-alpha"));
assert_eq!(machine.transition_count(), 2);
}
#[test]
fn test_connected_to_disconnected() {
let mut machine = PeerStateMachine::new();
machine.start_connecting(0).expect("step 1");
machine
.mark_connected("peer-beta".to_string(), 100)
.expect("step 2");
machine
.mark_disconnected("network timeout".to_string(), 200)
.expect("Connected → Disconnected");
assert!(!machine.is_connected());
assert_eq!(
machine.state(),
&PeerConnectionState::Disconnected {
peer_id: "peer-beta".to_string(),
reason: "network timeout".to_string(),
}
);
assert_eq!(machine.transition_count(), 3);
}
#[test]
fn test_any_state_to_failed() {
let mut m1 = PeerStateMachine::new();
m1.mark_failed("fatal error from New".to_string())
.expect("New → Failed must succeed");
assert_eq!(
m1.state(),
&PeerConnectionState::Failed {
error: "fatal error from New".to_string()
}
);
let mut m2 = PeerStateMachine::new();
m2.start_connecting(0).expect("step");
m2.mark_failed("fatal error from Connecting".to_string())
.expect("Connecting → Failed must succeed");
assert!(matches!(m2.state(), PeerConnectionState::Failed { .. }));
let mut m3 = PeerStateMachine::new();
m3.start_connecting(0).expect("step");
m3.mark_connected("p".to_string(), 1).expect("step");
m3.mark_failed("fatal error from Connected".to_string())
.expect("Connected → Failed must succeed");
assert!(matches!(m3.state(), PeerConnectionState::Failed { .. }));
let mut m4 = PeerStateMachine::new();
m4.start_connecting(0).expect("step");
m4.mark_connected("p".to_string(), 1).expect("step");
m4.mark_disconnected("bye".to_string(), 2).expect("step");
m4.mark_failed("fatal error from Disconnected".to_string())
.expect("Disconnected → Failed must succeed");
assert!(matches!(m4.state(), PeerConnectionState::Failed { .. }));
}
#[test]
fn test_reset() {
let mut machine = PeerStateMachine::new();
machine.start_connecting(10).expect("step");
machine
.mark_connected("peer-z".to_string(), 20)
.expect("step");
assert_eq!(machine.transition_count(), 2);
machine.reset();
assert_eq!(machine.state(), &PeerConnectionState::New);
assert_eq!(
machine.transition_count(),
0,
"transition log must be cleared after reset"
);
assert!(machine.last_transition_ms().is_none());
machine
.start_connecting(30)
.expect("must be able to reconnect after reset");
assert_eq!(machine.transition_count(), 1);
}
#[test]
fn test_is_connected() {
let mut machine = PeerStateMachine::new();
assert!(!machine.is_connected(), "New is not connected");
machine.start_connecting(0).expect("step");
assert!(!machine.is_connected(), "Connecting is not connected");
machine
.mark_connected("peer-q".to_string(), 1)
.expect("step");
assert!(machine.is_connected(), "Connected must be connected");
machine
.mark_disconnected("done".to_string(), 2)
.expect("step");
assert!(!machine.is_connected(), "Disconnected is not connected");
}
#[test]
fn test_peer_id() {
let mut machine = PeerStateMachine::new();
assert_eq!(machine.peer_id(), None, "New has no peer_id");
machine.start_connecting(0).expect("step");
assert_eq!(machine.peer_id(), None, "Connecting has no peer_id");
machine
.mark_connected("my-peer".to_string(), 1)
.expect("step");
assert_eq!(machine.peer_id(), Some("my-peer"));
machine
.mark_disconnected("bye".to_string(), 2)
.expect("step");
assert_eq!(machine.peer_id(), None, "Disconnected has no peer_id");
}
#[test]
fn test_transition_log() {
let mut machine = PeerStateMachine::new();
assert_eq!(machine.transition_count(), 0);
assert!(machine.last_transition_ms().is_none());
machine.start_connecting(1_000).expect("t=1000");
assert_eq!(machine.transition_count(), 1);
assert_eq!(machine.last_transition_ms(), Some(1_000));
machine
.mark_connected("log-peer".to_string(), 2_000)
.expect("t=2000");
assert_eq!(machine.transition_count(), 2);
assert_eq!(machine.last_transition_ms(), Some(2_000));
machine
.mark_disconnected("log test".to_string(), 3_000)
.expect("t=3000");
assert_eq!(machine.transition_count(), 3);
assert_eq!(machine.last_transition_ms(), Some(3_000));
}
}