openrtc 1.0.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

//! Native peer-send route ordering policy.
//!
//! Native can see both the durable iroh path and optional upgraded transports.
//! Keep the ordering decision side-effect free so transport orchestration does
//! not grow another inline priority table.

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum NativePeerSendOrder {
    OptionalTransportsFirst,
    IrohFirstAllowOptionalFallback,
}

pub(crate) fn peer_send_order(
    active_transport: Option<&str>,
    iroh_transport: Option<&str>,
) -> NativePeerSendOrder {
    if active_transport
        .map(crate::transport_label::is_optional)
        .unwrap_or(false)
    {
        return NativePeerSendOrder::OptionalTransportsFirst;
    }

    if iroh_transport
        .map(crate::transport_label::is_direct_iroh)
        .unwrap_or(false)
        || active_transport
            .map(crate::transport_label::is_direct_iroh)
            .unwrap_or(false)
    {
        return NativePeerSendOrder::IrohFirstAllowOptionalFallback;
    }

    NativePeerSendOrder::OptionalTransportsFirst
}

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

    #[derive(serde::Deserialize)]
    #[serde(rename_all = "camelCase")]
    struct TransportPolicyVectors {
        send_order: Vec<SendOrderVector>,
    }

    #[derive(serde::Deserialize)]
    #[serde(rename_all = "camelCase")]
    struct SendOrderVector {
        active_transport: Option<String>,
        iroh_transport: Option<String>,
        order: String,
    }

    fn parse_order(value: &str) -> NativePeerSendOrder {
        match value {
            "optionalTransportsFirst" => NativePeerSendOrder::OptionalTransportsFirst,
            "irohFirstAllowOptionalFallback" => NativePeerSendOrder::IrohFirstAllowOptionalFallback,
            other => panic!("unknown send-order vector: {other}"),
        }
    }

    #[test]
    fn active_optional_transport_stays_first() {
        assert_eq!(
            peer_send_order(Some("webrtc"), Some("iroh-quic")),
            NativePeerSendOrder::OptionalTransportsFirst
        );
        assert_eq!(
            peer_send_order(Some("moq"), Some("iroh-lan")),
            NativePeerSendOrder::OptionalTransportsFirst
        );
    }

    #[test]
    fn direct_iroh_paths_are_primary() {
        assert_eq!(
            peer_send_order(Some("iroh-quic"), Some("iroh-quic")),
            NativePeerSendOrder::IrohFirstAllowOptionalFallback
        );
        assert_eq!(
            peer_send_order(Some("iroh-lan"), Some("iroh-lan")),
            NativePeerSendOrder::IrohFirstAllowOptionalFallback
        );
        assert_eq!(
            peer_send_order(Some("ble"), Some("ble")),
            NativePeerSendOrder::IrohFirstAllowOptionalFallback
        );
    }

    #[test]
    fn relay_or_unknown_paths_probe_optional_transports_first() {
        assert_eq!(
            peer_send_order(Some("iroh-relay"), Some("iroh-relay")),
            NativePeerSendOrder::OptionalTransportsFirst
        );
        assert_eq!(
            peer_send_order(Some("iroh"), Some("iroh")),
            NativePeerSendOrder::OptionalTransportsFirst
        );
        assert_eq!(
            peer_send_order(None, None),
            NativePeerSendOrder::OptionalTransportsFirst
        );
    }

    #[test]
    fn matches_shared_transport_policy_vectors() {
        let vectors: TransportPolicyVectors =
            serde_json::from_str(include_str!("../testdata/transport_policy_vectors.json"))
                .expect("transport policy vectors");
        for vector in vectors.send_order {
            assert_eq!(
                peer_send_order(
                    vector.active_transport.as_deref(),
                    vector.iroh_transport.as_deref()
                ),
                parse_order(&vector.order),
                "active={:?} iroh={:?}",
                vector.active_transport,
                vector.iroh_transport
            );
        }
    }
}