openrtc 1.0.4

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
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

use serde::{Deserialize, Serialize};
use std::collections::{HashMap, HashSet};

#[derive(Default)]
pub(super) struct ConnectionStore {
    pub by_id: HashMap<String, ConnectionRecord>,
    pub by_node_id: HashMap<String, HashSet<String>>,
    pub by_device_id: HashMap<String, HashSet<String>>,
    pub by_device_hint_id: HashMap<String, HashSet<String>>,
    pub by_endpoint_id: HashMap<String, HashSet<String>>,
    pub history_by_connection_id: HashMap<String, ConnectionHistory>,
    pub health_by_peer: HashMap<String, ConnectionHealth>,
    pub scopes_by_peer: HashMap<String, HashSet<String>>,
    /// Per-transport health for each peer: peer_id -> transport_name -> health.
    /// Used to aggregate to a single peer-level health via `report_transport_health`.
    pub transport_health_by_peer: HashMap<String, HashMap<String, ConnectionHealth>>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "camelCase")]
pub enum ConnectionState {
    Pending,
    Connecting,
    Connected,
    Closing,
    Closed,
    Failed,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "camelCase")]
pub enum ConnectionHealth {
    Unknown,
    Healthy,
    Suspect,
    Stale,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConnectionRecord {
    pub connection_id: String,
    pub node_id: Option<String>,
    pub device_id: Option<String>,
    pub device_id_hint: Option<String>,
    pub endpoint_id: Option<String>,
    pub transport_generation: u64,
    pub route_generation: u64,
    pub transport_stable_id: Option<u64>,
    pub transport_source: Option<String>,
    pub active_transport: String,
    pub parallel_transport: Option<String>,
    pub last_state_change_at_ms: i64,
    pub last_transport_change_at_ms: i64,
    pub last_route_change_at_ms: i64,
    pub state: ConnectionState,
    pub status_reason: Option<String>,
    pub transition_count: u64,
    pub connecting_transition_count: u64,
    pub replacement_count: u64,
    pub retire_count: u64,
    pub last_disconnect_reason: Option<String>,
    pub last_reconnect_reason: Option<String>,
    pub created_at_ms: i64,
    pub updated_at_ms: i64,
}

#[derive(Debug, Clone, Default)]
pub(super) struct ConnectionHistory {
    pub transport_generation: u64,
    pub route_generation: u64,
    pub transition_count: u64,
    pub connecting_transition_count: u64,
    pub replacement_count: u64,
    pub retire_count: u64,
    pub last_disconnect_reason: Option<String>,
    pub last_reconnect_reason: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PeerSnapshot {
    pub peer_id: String,
    pub device_id: Option<String>,
    pub device_id_hint: Option<String>,
    pub node_id: Option<String>,
    pub connection_ids: Vec<String>,
    pub active_transport_stable_id: Option<u64>,
    pub active_transport_generation: u64,
    pub active_route_generation: u64,
    pub active_transport: String,
    pub parallel_transport: Option<String>,
    pub last_route_change_at_ms: i64,
    pub last_lifecycle_transition_at_ms: i64,
    pub status: ConnectionState,
    pub health: ConnectionHealth,
    pub transition_count: u64,
    pub connecting_transition_count: u64,
    pub replacement_count: u64,
    pub retire_count: u64,
    pub last_disconnect_reason: Option<String>,
    pub last_reconnect_reason: Option<String>,
    pub scopes: Vec<String>,
    pub last_seen_at_ms: i64,
    pub error: Option<String>,
}

impl ConnectionRecord {
    pub(super) fn new(
        connection_id: String,
        node_id: Option<String>,
        device_id_hint: Option<String>,
        endpoint_id: Option<String>,
    ) -> Self {
        let now = super::store::unix_ms_now();
        Self {
            connection_id,
            node_id,
            device_id: None,
            device_id_hint,
            endpoint_id,
            transport_generation: 0,
            route_generation: 0,
            transport_stable_id: None,
            transport_source: None,
            active_transport: "iroh".to_string(),
            parallel_transport: None,
            last_state_change_at_ms: now,
            last_transport_change_at_ms: now,
            last_route_change_at_ms: now,
            state: ConnectionState::Pending,
            status_reason: None,
            transition_count: 0,
            connecting_transition_count: 0,
            replacement_count: 0,
            retire_count: 0,
            last_disconnect_reason: None,
            last_reconnect_reason: None,
            created_at_ms: now,
            updated_at_ms: now,
        }
    }
}

impl From<&ConnectionRecord> for ConnectionHistory {
    fn from(record: &ConnectionRecord) -> Self {
        Self {
            transport_generation: record.transport_generation,
            route_generation: record.route_generation,
            transition_count: record.transition_count,
            connecting_transition_count: record.connecting_transition_count,
            replacement_count: record.replacement_count,
            retire_count: record.retire_count,
            last_disconnect_reason: record.last_disconnect_reason.clone(),
            last_reconnect_reason: record.last_reconnect_reason.clone(),
        }
    }
}