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
68
69
70
71
72
73
74
75

#[cfg(feature = "tokio")]
use curfew::{
    join_with_deadline_async, DeadlineJoinerAsync, JoinOutcomeAsync,
    TaskOutcome,
};
#[cfg(feature = "tokio")]
use std::time::{Duration, Instant};

#[cfg(feature = "tokio")]
#[tokio::main(flavor = "current_thread")]
async fn main() {
    let deadline = Instant::now() + Duration::from_millis(200);
    let mut joiner = DeadlineJoinerAsync::new(deadline);

    for value in 0..4u32 {
        joiner.spawn(async move {
            tokio::time::sleep(Duration::from_millis(u64::from(
                40 * (value + 1),
            )))
            .await;
            format!("async-job-{value}")
        });
    }

    let summary = joiner.join_ready().await;
    println!("{} async tasks finished on time", summary.completed_count());
    println!("{} async tasks missed the deadline", summary.timed_out_count());

    for task in summary.completed {
        match task.outcome {
            TaskOutcome::Completed(value) => {
                println!("task {} => {}", task.task_id, value)
            }
            TaskOutcome::Panicked(info) => {
                println!("task {} panicked: {}", task.task_id, info)
            }
        }
    }

    if !summary.timed_out.is_empty() {
        println!(
            "still running: {:?}",
            summary.timed_out.iter().map(|t| t.task_id).collect::<Vec<_>>()
        );
    }

    let future = async {
        tokio::time::sleep(Duration::from_millis(250)).await;
        99
    };

    match join_with_deadline_async(
        future,
        Instant::now() + Duration::from_millis(80),
    )
    .await
    {
        JoinOutcomeAsync::Completed(result) => match result.outcome {
            TaskOutcome::Completed(value) => {
                println!("completed on time: {value}")
            }
            TaskOutcome::Panicked(info) => println!("future panicked: {info}"),
        },
        JoinOutcomeAsync::TimedOut(late) => {
            println!("future missed the deadline; awaiting late completion");
            let result = late.wait().await;
            println!("late outcome: {:?}", result.outcome);
        }
    }
}

#[cfg(not(feature = "tokio"))]
fn main() {
    eprintln!("Enable the `tokio` feature to run this example.");
}