rings-core 0.20.0

Chord DHT implementation with ICE
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

use std::future::Future;
use std::time::Duration;

use futures::FutureExt;

use crate::utils::try_sleep;

pub(super) enum InboundDeadline<T> {
    Completed(T),
    TimedOut,
    TimerUnavailable,
}

pub(super) async fn await_inbound_deadline<F, T>(
    future: F,
    timeout: Duration,
) -> InboundDeadline<T>
where
    F: Future<Output = T>,
{
    await_inbound_deadline_with_timer(future, try_sleep(timeout)).await
}

async fn await_inbound_deadline_with_timer<F, T, D>(future: F, deadline: D) -> InboundDeadline<T>
where
    F: Future<Output = T>,
    D: Future<Output = bool>,
{
    let future = future.fuse();
    let deadline = deadline.fuse();
    futures::pin_mut!(future, deadline);
    futures::select! {
        output = future => InboundDeadline::Completed(output),
        completed = deadline => if completed {
            InboundDeadline::TimedOut
        } else {
            InboundDeadline::TimerUnavailable
        },
    }
}

#[cfg(all(test, not(target_family = "wasm")))]
mod tests {
    use super::*;

    #[tokio::test]
    async fn rejected_timer_fails_closed_without_polling_forever() {
        let outcome = await_inbound_deadline_with_timer(
            futures::future::pending::<()>(),
            futures::future::ready(false),
        )
        .await;
        assert!(matches!(outcome, InboundDeadline::TimerUnavailable));
    }
}