pistonite-cu 0.8.3

Battery-included common utils to speed up development of rust tools
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

use pistonite_cu as cu;
use std::time::Duration;

#[cu::cli]
fn main(_: cu::cli::Flags) -> cu::Result<()> {
    sync_main()?;
    cu::co::run(async move { async_auto_check().await })?;
    cu::co::run(async move { async_manual_check().await })?;
    Ok(())
}

fn sync_main() -> cu::Result<()> {
    let result = cu::cli::ctrlc_frame().execute(move |ctrlc| {
        for _ in 0..30 {
            cu::print!("(sync) please press Ctrl-C");
            std::thread::sleep(Duration::from_millis(100));
            ctrlc.check()?;
        }
        cu::warn!("(sync) about to return!");
        cu::Ok(42)
    });
    match result {
        Ok(None) => cu::info!("(sync) was aborted!"),
        Ok(Some(n)) => cu::info!("(sync) was finished: {n}"),
        Err(e) => cu::error!("(sync) error: {e:?}"),
    }
    Ok(())
}

async fn async_manual_check() -> cu::Result<()> {
    let result = cu::cli::ctrlc_frame()
        .abort_threshold(3)
        .on_signal(|ctrlc| {
            if !ctrlc.should_abort() {
                cu::warn!("Ctrl-C 3 times to abort!")
            }
        })
        .co_execute(async |ctrlc| {
            for _ in 0..10 {
                cu::print!("(async) please press Ctrl-C");
                cu::co::sleep(Duration::from_secs(1)).await;
                if ctrlc.should_abort() {
                    cu::info!("just kidding, we never abort");
                }
            }
            cu::warn!("(async) about to return!");
            cu::Ok(42)
        })
        .await;
    match result {
        Ok(None) => cu::info!("(async) was aborted!"),
        Ok(Some(n)) => cu::info!("(async) was finished: {n}"),
        Err(e) => cu::error!("(async) error: {e:?}"),
    }
    Ok(())
}

async fn async_auto_check() -> cu::Result<()> {
    let (send, mut recv) = tokio::sync::mpsc::unbounded_channel();
    let result = cu::cli::ctrlc_frame()
        .on_signal(move |_| {
            let _ = send.send(());
        })
        .co_execute(async move |ctrlc| {
            let waiter = async move {
                loop {
                    if recv.recv().await.is_none() {
                        return;
                    }
                    if ctrlc.should_abort() {
                        return;
                    }
                }
            };
            tokio::select! {
                result = my_long_running_task() => {
                    result
                }
                _ = waiter => {
                    // does not matter what the value is -
                    // co_execute will ensure None is returned
                    // when aborted
                    Ok(0)
                }
            }
        })
        .await?;
    match result {
        Some(x) => cu::info!("valud is: {x}"),
        None => cu::error!("aborted!"),
    }
    Ok(())
}

async fn my_long_running_task() -> cu::Result<i32> {
    loop {
        cu::print!("will run forever if you don't abort");
        cu::co::sleep(Duration::from_secs(1)).await;
    }
}