iroh 0.92.0

p2p quic connections dialed by public key
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

use n0_future::time::{Duration, Instant};

/// How long we trust a UDP address as the exclusive path (i.e. without also sending via the relay).
///
/// Trust for a UDP address begins when we receive a DISCO UDP pong on that address.
/// It is then further extended by this duration every time we receive QUIC payload data while it's
/// currently trusted.
///
/// If trust goes away, it can be brought back with another valid DISCO UDP pong.
const TRUST_UDP_ADDR_DURATION: Duration = Duration::from_millis(6500);

/// Tracks a path's validity.
///
/// A path is valid:
/// - For [`Source::trust_duration`] after a successful [`PongReply`].
/// - For [`Source::trust_duration`] longer starting at the most recent
///   received application payload *while the path was valid*.
///
/// [`PongReply`]: super::node_state::PongReply
#[derive(Debug, Clone, Default)]
pub(super) struct PathValidity(Option<Inner>);

#[derive(Debug, Clone)]
struct Inner {
    latest_pong: Instant,
    latency: Duration,
    trust_until: Instant,
}

#[derive(Debug)]
pub(super) enum Source {
    ReceivedPong,
    QuicPayload,
}

impl Source {
    fn trust_duration(&self) -> Duration {
        match self {
            Source::ReceivedPong => TRUST_UDP_ADDR_DURATION,
            Source::QuicPayload => TRUST_UDP_ADDR_DURATION,
        }
    }
}

impl PathValidity {
    pub(super) fn new(pong_at: Instant, latency: Duration) -> Self {
        Self(Some(Inner {
            trust_until: pong_at + Source::ReceivedPong.trust_duration(),
            latest_pong: pong_at,
            latency,
        }))
    }

    pub(super) fn empty() -> Self {
        Self(None)
    }

    pub(super) fn is_empty(&self) -> bool {
        self.0.is_none()
    }

    pub(super) fn is_valid(&self, now: Instant) -> bool {
        let Some(state) = self.0.as_ref() else {
            return false;
        };

        state.is_valid(now)
    }

    pub(super) fn latency_if_valid(&self, now: Instant) -> Option<Duration> {
        let state = self.0.as_ref()?;
        state.is_valid(now).then_some(state.latency)
    }

    pub(super) fn is_outdated(&self, now: Instant) -> bool {
        let Some(state) = self.0.as_ref() else {
            return false;
        };

        // We *used* to be valid, but are now outdated.
        // This happens when we had a DISCO pong but didn't receive
        // any payload data or further pongs for at least TRUST_UDP_ADDR_DURATION
        state.is_outdated(now)
    }

    pub(super) fn latency_if_outdated(&self, now: Instant) -> Option<Duration> {
        let state = self.0.as_ref()?;
        state.is_outdated(now).then_some(state.latency)
    }

    /// Reconfirms path validity, if a payload was received while the
    /// path was valid.
    pub(super) fn receive_payload(&mut self, now: Instant, source: Source) {
        let Some(state) = self.0.as_mut() else {
            return;
        };

        if state.is_valid(now) {
            state.trust_until = now + source.trust_duration();
        }
    }

    pub(super) fn latency(&self) -> Option<Duration> {
        Some(self.0.as_ref()?.latency)
    }

    pub(super) fn latest_pong(&self) -> Option<Instant> {
        Some(self.0.as_ref()?.latest_pong)
    }
}

impl Inner {
    fn is_valid(&self, now: Instant) -> bool {
        self.latest_pong <= now && now < self.trust_until
    }

    fn is_outdated(&self, now: Instant) -> bool {
        self.latest_pong <= now && self.trust_until <= now
    }
}

#[cfg(test)]
mod tests {
    use n0_future::time::{Duration, Instant};

    use super::{PathValidity, Source, TRUST_UDP_ADDR_DURATION};

    #[tokio::test(start_paused = true)]
    async fn test_basic_path_validity_lifetime() {
        let mut validity = PathValidity(None);
        assert!(!validity.is_valid(Instant::now()));
        assert!(!validity.is_outdated(Instant::now()));

        validity = PathValidity::new(Instant::now(), Duration::from_millis(20));
        assert!(validity.is_valid(Instant::now()));
        assert!(!validity.is_outdated(Instant::now()));

        tokio::time::advance(TRUST_UDP_ADDR_DURATION / 2).await;
        assert!(validity.is_valid(Instant::now()));
        assert!(!validity.is_outdated(Instant::now()));

        validity.receive_payload(Instant::now(), Source::QuicPayload);
        assert!(validity.is_valid(Instant::now()));
        assert!(!validity.is_outdated(Instant::now()));

        tokio::time::advance(TRUST_UDP_ADDR_DURATION / 2).await;
        assert!(validity.is_valid(Instant::now()));
        assert!(!validity.is_outdated(Instant::now()));

        tokio::time::advance(TRUST_UDP_ADDR_DURATION / 2).await;
        assert!(!validity.is_valid(Instant::now()));
        assert!(validity.is_outdated(Instant::now()));
    }
}