rty 0.2.2

A simple command line retry tool.
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
108
109

use crate::exec::*;
use crate::prelude::*;

#[derive(new)]
pub struct CmdExecutor {
    command: String,
    executor: Arc<dyn PipedCmdExecutor>,
}

#[async_trait]
impl super::Component for CmdExecutor {
    type Output = Result<Exit>;

    async fn handle(&self) -> Self::Output {
        self.executor.piped_exec(self.command.as_str()).await
    }
}

#[derive(new)]
pub struct PrintableCmdNotFound<C> {
    command: String,
    inner: C,
}

#[async_trait]
impl<T: 'static, C: super::Component<Output = Result<T>> + Send + Sync> super::Component
    for PrintableCmdNotFound<C>
{
    type Output = Result<T>;

    async fn handle(&self) -> Self::Output {
        let result = self.inner.handle().await;

        match &result {
            Err(_) => {
                if self.command.is_empty() {
                    eprintln!("rty: no command entered")
                } else {
                    eprintln!("rty: command not found '{}'", self.command)
                }
            }
            _ => (),
        };

        result
    }
}

pub struct WaitSec {
    sec: f64,
}

#[async_trait]
impl super::Component for WaitSec {
    type Output = ();

    async fn handle(&self) -> Self::Output {
        tokio::time::delay_for(tokio::time::Duration::from_secs_f64(self.sec)).await
    }
}

#[derive(new)]
pub struct SharedState<C> {
    command: String,
    interval: f64,
    executor: Arc<dyn PipedCmdExecutor>,
    inner: C,
}

#[async_trait]
impl<T: 'static, C: super::Component<Output = T> + Send + Sync> super::Component
    for SharedState<C>
{
    type Output = T;

    async fn handle(&self) -> Self::Output {
        self.inner.handle().await
    }
}

impl From<SharedState<PrintableCmdNotFound<CmdExecutor>>> for SharedState<WaitSec> {
    fn from(state: SharedState<PrintableCmdNotFound<CmdExecutor>>) -> Self {
        Self {
            inner: WaitSec {
                sec: state.interval,
            },
            command: state.command,
            interval: state.interval,
            executor: state.executor,
        }
    }
}

impl From<SharedState<WaitSec>> for SharedState<PrintableCmdNotFound<CmdExecutor>> {
    fn from(state: SharedState<WaitSec>) -> Self {
        Self {
            inner: PrintableCmdNotFound {
                command: state.command.to_owned(),
                inner: CmdExecutor {
                    command: state.command.to_owned(),
                    executor: state.executor.clone(),
                },
            },
            command: state.command,
            interval: state.interval,
            executor: state.executor,
        }
    }
}