wait3 0.4.0

Wait for arbitrary conditions (e.g.: time, TCP connetions, etc on the command-line)
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

// #![allow(unused)]
use ansi_term::Colour::Fixed;
use ansi_term::Style;
use chrono::Duration;
use clap::{Parser};
use regex::Regex;
use spinners::{Spinner, Spinners};


use std::thread::{sleep};


use wait3::clap::{Cli, Commands};
use wait3::func::wait_for_subprocess;

pub fn main() {
    let cli = Cli::parse();
    match cli.command {
        Commands::Cmd(opts) | Commands::Command(opts) | Commands::Subp(opts) => {
            let cmd = opts.shell_command.clone();

            let msg = Style::new()
                .fg(Fixed(33))
                .bold()
                .paint(&format!(
                    "Running command {}\r",
                    Style::new().fg(Fixed(208)).bold().paint(cmd)
                ))
                .to_string();
            let mut indicator = Spinner::with_timer(Spinners::OrangeBluePulse, msg);
            let mut output = wait_for_subprocess(opts.shell_command.clone());
            while Some(opts.exit_code) != output.status.code() {
                output = wait_for_subprocess(opts.shell_command.clone());
            }
            indicator.stop_with_newline();
        }
        Commands::Time(opts) => {
            let smh = Regex::new(r"^(\d+)(s|m|h|ms|ml|ns)$").unwrap();
            match smh.captures(&opts.amount) {
                Some(caps) => {
                    let number = caps.get(1).unwrap().as_str().parse::<u64>().unwrap();
                    let duration: Duration = match caps.get(2).unwrap().as_str() {
                        "ns" => Duration::nanoseconds(number.try_into().expect("invalid integer")),
                        "ms" => Duration::microseconds(number.try_into().expect("invalid integer")),
                        "ml" => Duration::milliseconds(number.try_into().expect("invalid integer")),
                        "s" => Duration::seconds(number.try_into().expect("invalid integer")),
                        "m" => Duration::minutes(number.try_into().expect("invalid integer")),
                        "h" => Duration::hours(number.try_into().expect("invalid integer")),
                        measure => {
                            eprintln!("measure of time duration not implemented {}", measure);
                            std::process::exit(0x54);
                        }
                    };
                    // 0x4c 0x69 0x62 0x65 0x72 0x74 0x61 0x73 0x51 0x75 0xe6 0x53 0x65 0x72 0x61 0x54 0x61 0x6d 0x65 0x6e
                    // 0x31 0x39 0x38 0x38
                    let msg = Style::new()
                        .fg(Fixed(220))
                        .bold()
                        .paint(&format!("Waiting for {}", opts.amount))
                        .to_string();
                    let mut indicator = Spinner::with_timer(Spinners::Layer, msg);
                    for _ in 0..duration.num_seconds() {
                        sleep(std::time::Duration::from_millis(1));
                    }
                    indicator.stop_with_newline();
                }
                None => {
                    eprintln!("invalid amount {}", opts.amount);
                    eprintln!(
                        "should a valid integer suffixed with {{ns,ms,ml}},s,m or h ({{nano,micro,milli,}}seconds, minutes, hours)"
                    );
                    eprintln!("example:");
                    eprintln!("\twait-for time 2m");
                    std::process::exit(0x54);
                }
            }
        }
    }
}