watchctl 0.1.0

Process supervisor with wait, watch, and retry phases
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
101
102
103
104
105
106
107

use crate::cli::Args;
use crate::duration::parse_duration;
use crate::error::Result;
use std::collections::HashSet;
use std::time::Duration;

#[derive(Debug)]
pub struct Config {
    pub wait: WaitConfig,
    pub watch: WatchConfig,
    pub retry: RetryConfig,
    pub command: Vec<String>,
}

#[derive(Debug)]
pub struct WaitConfig {
    pub tcp: Vec<String>,
    pub tcp_timeout: Duration,
    pub http: Vec<String>,
    pub http_timeout: Duration,
    pub files: Vec<String>,
    pub delays: Vec<Duration>,
    pub timeout: Duration,
}

#[derive(Debug)]
pub struct WatchConfig {
    pub http: Vec<String>,
    pub http_interval: Duration,
    pub http_timeout: Duration,
    pub tcp: Vec<String>,
    pub tcp_interval: Duration,
    pub tcp_timeout: Duration,
    pub files: Vec<String>,
    pub file_interval: Duration,
    pub timeout: Option<Duration>,
}

#[derive(Debug)]
pub struct RetryConfig {
    pub times: u32,
    pub delay: Duration,
    pub backoff: bool,
    pub exit_codes: Option<HashSet<i32>>,
    pub with_wait: bool,
}

impl Config {
    pub fn from_args(args: Args) -> Result<Self> {
        let wait = WaitConfig {
            tcp: args.wait_tcp,
            tcp_timeout: parse_duration(&args.wait_tcp_timeout)?,
            http: args.wait_http,
            http_timeout: parse_duration(&args.wait_http_timeout)?,
            files: args.wait_file,
            delays: args
                .wait_delay
                .iter()
                .map(|s| parse_duration(s))
                .collect::<Result<Vec<_>>>()?,
            timeout: parse_duration(&args.wait_timeout)?,
        };

        let watch = WatchConfig {
            http: args.watch_http,
            http_interval: parse_duration(&args.watch_http_interval)?,
            http_timeout: parse_duration(&args.watch_http_timeout)?,
            tcp: args.watch_tcp,
            tcp_interval: parse_duration(&args.watch_tcp_interval)?,
            tcp_timeout: parse_duration(&args.watch_tcp_timeout)?,
            files: args.watch_file,
            file_interval: parse_duration(&args.watch_file_interval)?,
            timeout: args.watch_timeout.map(|s| parse_duration(&s)).transpose()?,
        };

        let exit_codes = if args.retry_if.is_empty() {
            None
        } else {
            let mut codes = HashSet::new();
            for s in &args.retry_if {
                for code_str in s.split(',') {
                    let code: i32 = code_str
                        .trim()
                        .parse()
                        .map_err(|_| crate::error::Error::InvalidExitCode(code_str.to_string()))?;
                    codes.insert(code);
                }
            }
            Some(codes)
        };

        let retry = RetryConfig {
            times: args.retry_times,
            delay: parse_duration(&args.retry_delay)?,
            backoff: args.retry_backoff,
            exit_codes,
            with_wait: args.retry_with_wait,
        };

        Ok(Config {
            wait,
            watch,
            retry,
            command: args.command,
        })
    }
}