openrtc 0.2.1

OpenRTC: a Rust-first P2P runtime for device discovery, signaling, and iroh/QUIC networking.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

use crate::connection_manager::ConnectionHealth;
use std::collections::HashMap;

/// Per-transport health tracker. Stateless — caller drives transitions by
/// reporting last_pong_at_ms and now_ms.
pub struct TransportHealthEvaluator {
    pub suspect_after_ms: i64,
    pub stale_after_ms: i64,
}

impl TransportHealthEvaluator {
    pub fn new(suspect_after_ms: i64, stale_after_ms: i64) -> Self {
        Self {
            suspect_after_ms,
            stale_after_ms,
        }
    }

    pub fn evaluate(
        &self,
        last_pong_at_ms: Option<i64>,
        first_ping_sent_at_ms: Option<i64>,
        now_ms: i64,
    ) -> ConnectionHealth {
        let reference_ms = last_pong_at_ms.or(first_ping_sent_at_ms);
        let Some(ref_ms) = reference_ms else {
            return ConnectionHealth::Unknown;
        };
        let silence_ms = now_ms.saturating_sub(ref_ms);
        if silence_ms >= self.stale_after_ms {
            ConnectionHealth::Stale
        } else if silence_ms >= self.suspect_after_ms {
            ConnectionHealth::Suspect
        } else {
            ConnectionHealth::Healthy
        }
    }
}

/// Aggregate per-transport healths into a single peer-level health.
/// Priority: any Healthy → Healthy, all Stale → Stale, else Suspect.
/// Empty map → Unknown.
pub fn aggregate_peer_health(healths: &HashMap<String, ConnectionHealth>) -> ConnectionHealth {
    if healths.is_empty() {
        return ConnectionHealth::Unknown;
    }
    let mut any_healthy = false;
    let mut all_stale = true;
    for h in healths.values() {
        match h {
            ConnectionHealth::Healthy => {
                any_healthy = true;
                all_stale = false;
            }
            ConnectionHealth::Suspect | ConnectionHealth::Unknown => {
                all_stale = false;
            }
            ConnectionHealth::Stale => {}
        }
    }
    if any_healthy {
        ConnectionHealth::Healthy
    } else if all_stale {
        ConnectionHealth::Stale
    } else {
        ConnectionHealth::Suspect
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    fn eval(last_pong: Option<i64>, first_ping: Option<i64>, now: i64) -> ConnectionHealth {
        TransportHealthEvaluator::new(10_000, 30_000).evaluate(last_pong, first_ping, now)
    }

    #[test]
    fn unknown_when_no_ping_sent() {
        assert_eq!(eval(None, None, 1000), ConnectionHealth::Unknown);
    }

    #[test]
    fn healthy_shortly_after_pong() {
        assert_eq!(eval(Some(0), None, 5_000), ConnectionHealth::Healthy);
    }

    #[test]
    fn suspect_after_missed_pings() {
        assert_eq!(eval(Some(0), None, 15_000), ConnectionHealth::Suspect);
    }

    #[test]
    fn stale_after_threshold() {
        assert_eq!(eval(Some(0), None, 35_000), ConnectionHealth::Stale);
    }

    #[test]
    fn recovery_resets_to_healthy() {
        // Last pong 2s ago — healthy
        assert_eq!(eval(Some(98_000), None, 100_000), ConnectionHealth::Healthy);
    }

    #[test]
    fn aggregate_any_healthy_wins() {
        let mut map = HashMap::new();
        map.insert("iroh".into(), ConnectionHealth::Stale);
        map.insert("webrtc".into(), ConnectionHealth::Healthy);
        assert_eq!(aggregate_peer_health(&map), ConnectionHealth::Healthy);
    }

    #[test]
    fn aggregate_all_stale() {
        let mut map = HashMap::new();
        map.insert("iroh".into(), ConnectionHealth::Stale);
        map.insert("webrtc".into(), ConnectionHealth::Stale);
        assert_eq!(aggregate_peer_health(&map), ConnectionHealth::Stale);
    }

    #[test]
    fn aggregate_mixed_suspect() {
        let mut map = HashMap::new();
        map.insert("iroh".into(), ConnectionHealth::Suspect);
        map.insert("webrtc".into(), ConnectionHealth::Stale);
        assert_eq!(aggregate_peer_health(&map), ConnectionHealth::Suspect);
    }

    #[test]
    fn aggregate_empty_unknown() {
        assert_eq!(
            aggregate_peer_health(&HashMap::new()),
            ConnectionHealth::Unknown
        );
    }
}