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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

mod child_process;
mod process;

use crate::prelude::*;
use child_process::*;
use process::*;

pub type ExitCode = i32;

#[derive(Debug, Clone, PartialEq, Getters)]
pub struct Exit {
    code: ExitCode,

    #[getter(skip)]
    stdout_wrote_length: Option<u64>,

    #[getter(skip)]
    stderr_wrote_length: Option<u64>,
}

#[cfg(test)]
impl Exit {
    pub fn new(code: ExitCode) -> Self {
        Self {
            code,
            stdout_wrote_length: None,
            stderr_wrote_length: None,
        }
    }
}

trait AsyncReadUnpin: AsyncRead + Unpin + Send {}
trait AsyncWriteUnpin: AsyncWrite + Unpin + Send {}

trait ChildProcess: std::future::Future<Output = Result<ExitCode>> + Unpin + Send {
    fn stdout(&mut self) -> Result<Box<dyn AsyncReadUnpin>>;
    fn stderr(&mut self) -> Result<Box<dyn AsyncReadUnpin>>;
}

#[async_trait]
trait SpawnChild {
    async fn spawn(&self, command: &str) -> Result<Box<dyn ChildProcess + Send>>;
}

trait Process {
    fn stdout(&self) -> Box<dyn AsyncWriteUnpin>;
    fn stderr(&self) -> Box<dyn AsyncWriteUnpin>;
}

#[async_trait]
pub trait PipedCmdExecutor: Send + Sync {
    async fn piped_exec(&self, command: &str) -> Result<Exit>;
}

pub struct TokioPipedCmdExecutor {
    process: Box<dyn Process + Send + Sync>,
    cmd_executor: Box<dyn SpawnChild + Send + Sync>,
}

impl TokioPipedCmdExecutor {
    pub fn new() -> Self {
        Self {
            process: Box::new(TokioProcess),
            cmd_executor: Box::new(TokioCmdExecutor),
        }
    }
}

#[async_trait]
impl PipedCmdExecutor for TokioPipedCmdExecutor {
    async fn piped_exec(&self, command: &str) -> Result<Exit> {
        let mut child = self.cmd_executor.spawn(command).await?;

        let mut child_stdout = child.stdout()?;
        let mut process_stdout = self.process.stdout();
        let handle_stdout = tokio::io::copy(&mut child_stdout, &mut process_stdout);

        let mut child_stderr = child.stderr()?;
        let mut process_stderr = self.process.stderr();
        let handle_stderr = tokio::io::copy(&mut child_stderr, &mut process_stderr);

        let (code, stdout_wrote_length, stderr_wrote_length) =
            tokio::join!(child, handle_stdout, handle_stderr);

        Ok(Exit {
            code: code?,
            stdout_wrote_length: stdout_wrote_length.ok(),
            stderr_wrote_length: stderr_wrote_length.ok(),
        })
    }
}

#[cfg(test)]
pub struct StubPipedCmdExecutor {
    pub output: Box<dyn Fn() -> Result<Exit> + Send + Sync>,
}

#[async_trait]
#[cfg(test)]
impl PipedCmdExecutor for StubPipedCmdExecutor {
    async fn piped_exec(&self, _: &str) -> Result<Exit> {
        (*self.output)()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[tokio::test]
    async fn expect_stdout_3byte_stderr_4byte() {
        let executor = TokioPipedCmdExecutor {
            process: Box::new(StubProcess {
                stdout: Vec::new(),
                stderr: Vec::new(),
            }),
            cmd_executor: Box::new(StubCmdExecutor {
                child_stdout: vec![0x00, 0x01, 0x02],
                child_stderr: vec![0x03, 0x04, 0x05, 0x06],
            }),
        };

        let actual = executor.piped_exec("dummy").await.unwrap();
        let expected = Exit {
            code: 0,
            stdout_wrote_length: Some(3),
            stderr_wrote_length: Some(4),
        };

        assert_eq!(actual, expected);
    }
}