xbp 10.15.4

XBP is a zero-config build pack that can also interact with proxies, kafka, sockets, synthetic monitors.
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
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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165

use anyhow::Context;
use std::process::Output;
use std::process::Stdio;
use tokio::process::Command;
use tracing::debug;

use crate::sdk::{command_debug_log, command_failure_message, decode_output};

/// Normalized command execution result.
#[derive(Debug)]
pub struct CommandOutcome {
    pub output: Output,
    pub stdout: String,
    pub stderr: String,
}

impl CommandOutcome {
    pub fn is_success(&self) -> bool {
        self.output.status.success()
    }
}

/// Thin async runner with optional debug tracing.
#[derive(Clone, Debug)]
pub struct CommandRunner {
    debug: bool,
}

impl CommandRunner {
    pub fn new(debug: bool) -> Self {
        Self { debug }
    }

    pub async fn run(&self, program: &str, args: &[&str]) -> anyhow::Result<CommandOutcome> {
        let output = Command::new(program)
            .args(args)
            .output()
            .await
            .with_context(|| format!("Failed to execute {} {}", program, args.join(" ")))?;

        command_debug_log(self.debug, program, args, &output, |msg| debug!("{}", msg));

        let stdout = decode_output(&output.stdout);
        let stderr = decode_output(&output.stderr);

        Ok(CommandOutcome {
            output,
            stdout,
            stderr,
        })
    }

    pub async fn run_checked(
        &self,
        program: &str,
        args: &[&str],
        hint: Option<&str>,
    ) -> anyhow::Result<CommandOutcome> {
        let outcome = self.run(program, args).await?;
        if !outcome.output.status.success() {
            let message = command_failure_message(program, args, &outcome.output, hint);
            return Err(anyhow::anyhow!(message));
        }
        Ok(outcome)
    }

    pub async fn run_with_stdio(
        &self,
        program: &str,
        args: &[&str],
    ) -> anyhow::Result<std::process::ExitStatus> {
        let status = Command::new(program)
            .args(args)
            .stdout(Stdio::inherit())
            .stderr(Stdio::inherit())
            .status()
            .await
            .with_context(|| format!("Failed to execute {} {}", program, args.join(" ")))?;

        if self.debug {
            debug!(
                "{} {} -> status={}",
                program,
                args.join(" "),
                status
                    .code()
                    .map(|c| c.to_string())
                    .unwrap_or_else(|| "SIG".into())
            );
        }
        Ok(status)
    }

    pub async fn run_builder<F>(
        &self,
        program: &str,
        args: &[&str],
        configure: F,
    ) -> anyhow::Result<CommandOutcome>
    where
        F: FnOnce(&mut Command),
    {
        let mut cmd = Command::new(program);
        cmd.args(args);
        configure(&mut cmd);

        let output = cmd
            .output()
            .await
            .with_context(|| format!("Failed to execute {} {}", program, args.join(" ")))?;

        command_debug_log(self.debug, program, args, &output, |msg| debug!("{}", msg));

        let stdout = decode_output(&output.stdout);
        let stderr = decode_output(&output.stderr);

        Ok(CommandOutcome {
            output,
            stdout,
            stderr,
        })
    }
}

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

    #[tokio::test]
    async fn command_runner_success() {
        let runner = CommandRunner::new(true);
        #[cfg(windows)]
        let outcome = runner
            .run_checked("cmd", &["/C", "echo hello"], None)
            .await
            .unwrap();

        #[cfg(not(windows))]
        let outcome = runner
            .run_checked("sh", &["-c", "echo hello"], None)
            .await
            .unwrap();

        assert!(outcome.is_success());
        assert_eq!(outcome.stdout, "hello");
    }

    #[tokio::test]
    async fn command_runner_failure_returns_error() {
        let runner = CommandRunner::new(false);
        #[cfg(windows)]
        let err = runner
            .run_checked("cmd", &["/C", "exit /b 1"], Some("intentional failure"))
            .await
            .unwrap_err();

        #[cfg(not(windows))]
        let err = runner
            .run_checked("sh", &["-c", "false"], Some("intentional failure"))
            .await
            .unwrap_err();

        assert!(err.to_string().contains("failed with status"));
    }
}