magicpak 1.4.0

Build minimal docker images without static linking
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

use std::io::Result;
use std::process::{Child, Command, ExitStatus, Output};

pub trait CommandLogExt {
    fn spawn_with_log(&mut self) -> Result<Child>;

    fn output_with_log(&mut self) -> Result<Output>;

    fn status_with_log(&mut self) -> Result<ExitStatus> {
        Ok(self.output_with_log()?.status)
    }
}

pub trait ChildLogExt {
    fn wait_output_with_log(self) -> Result<Output>;
}

impl CommandLogExt for Command {
    fn spawn_with_log(&mut self) -> Result<Child> {
        tracing::debug!(command = ?self, "spawn");
        self.spawn()
    }

    fn output_with_log(&mut self) -> Result<Output> {
        let output = self.output()?;
        let command_line = format!("{:?}", self);
        log_output(&command_line, &output);
        Ok(output)
    }
}

impl ChildLogExt for Child {
    fn wait_output_with_log(self) -> Result<Output> {
        let output = self.wait_with_output()?;
        log_output("<spawned>", &output);
        Ok(output)
    }
}

pub fn log_output(command_line: &str, output: &Output) {
    let mut message = format!("command: {}\n  => {}", command_line, output.status);

    if !output.stdout.is_empty() {
        let stdout = format_lines(String::from_utf8_lossy(&output.stdout));
        message.push_str("\n  => stdout: ");
        message.push_str(&stdout);
    }
    if !output.stderr.is_empty() {
        let stderr = format_lines(String::from_utf8_lossy(&output.stderr));
        message.push_str("\n  => stderr: ");
        message.push_str(&stderr);
    }

    tracing::debug!("{}", message);
}

fn format_lines<S>(s: S) -> String
where
    S: AsRef<str>,
{
    let string = s.as_ref().trim();
    if string.lines().nth(1).is_some() {
        string
            .lines()
            .fold(String::new(), |acc, line| format!("{}\n  |  {}", acc, line))
    } else {
        string.to_owned()
    }
}