curfew 0.0.5

A deadline-aware fork-join model where multiple tasks run in parallel, but only those that finish before a specified absolute clock time are joined and their results collected.
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

#![cfg(feature = "tokio")]

use curfew::{
    join_with_deadline_async, DeadlineJoinerAsync, JoinOutcomeAsync,
    TaskOutcome,
};
use std::time::{Duration, Instant};

#[tokio::test]
async fn async_joiner_collects_on_time() {
    let deadline = Instant::now() + Duration::from_millis(150);
    let mut joiner = DeadlineJoinerAsync::new(deadline);

    for value in 0..3u32 {
        joiner.spawn(async move {
            tokio::time::sleep(Duration::from_millis(20)).await;
            value * 2
        });
    }

    let summary = joiner.join_ready().await;
    assert_eq!(summary.completed_count(), 3);
    assert_eq!(summary.timed_out_count(), 0);
}

#[tokio::test]
async fn async_joiner_respects_deadline() {
    let deadline = Instant::now() + Duration::from_millis(80);
    let mut joiner = DeadlineJoinerAsync::new(deadline);

    joiner.spawn(async {
        tokio::time::sleep(Duration::from_millis(30)).await;
        1
    });
    joiner.spawn(async {
        tokio::time::sleep(Duration::from_millis(150)).await;
        2
    });

    let summary = joiner.join_ready().await;
    assert_eq!(summary.completed_count(), 1);
    assert_eq!(summary.timed_out_count(), 1);
}

#[tokio::test]
async fn join_with_deadline_async_reports_timeout() {
    let future = async {
        tokio::time::sleep(Duration::from_millis(120)).await;
        42
    };

    let deadline = Instant::now() + Duration::from_millis(40);
    match join_with_deadline_async(future, deadline).await {
        JoinOutcomeAsync::Completed(_) => {
            panic!("future should not complete before deadline")
        }
        JoinOutcomeAsync::TimedOut(late) => {
            let result = late.wait().await;
            match result.outcome {
                TaskOutcome::Completed(value) => assert_eq!(value, 42),
                TaskOutcome::Panicked(info) => {
                    panic!("unexpected panic: {info}")
                }
            }
        }
    }
}