xbp 10.17.2

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

#[cfg(feature = "docker")]
use crate::utils::command_exists;
use crate::{
    cli::{
        commands,
        error::{CliResult, ErrorFactory},
    },
    logging::{log_error, log_info},
};
use tokio::process::Command;

#[cfg(feature = "docker")]
pub async fn handle_docker(cmd: commands::DockerCmd, debug: bool) -> CliResult<()> {
    if !command_exists("docker") {
        let _ = log_error("docker", "docker not installed or not in PATH", None).await;
        return Err(ErrorFactory::dependency(
            "docker",
            "docker not installed or not in PATH",
            Some("Install Docker and ensure `docker` is available in PATH."),
        ));
    }

    let args = if cmd.args.is_empty() {
        vec!["--help".to_string()]
    } else {
        cmd.args.clone()
    };

    if debug {
        let _ = log_info("docker", &format!("docker {}", args.join(" ")), None).await;
    }

    let mut process = Command::new("docker");
    for arg in &args {
        process.arg(arg);
    }

    let output = process.output().await.map_err(|e| {
        ErrorFactory::operation("docker", "spawn docker process", e.to_string(), None)
    })?;

    let command_rendered = format!("docker {}", args.join(" "));
    if !output.stdout.is_empty() {
        let stdout = String::from_utf8_lossy(&output.stdout).to_string();
        print!("{}", stdout);
        crate::data::athena::persist_docker_log(
            None,
            Some(&command_rendered),
            "stdout",
            &stdout,
            serde_json::json!({ "source": "handle_docker" }),
        )
        .await;
    }
    if !output.stderr.is_empty() {
        let stderr = String::from_utf8_lossy(&output.stderr).to_string();
        eprint!("{}", stderr);
        crate::data::athena::persist_docker_log(
            None,
            Some(&command_rendered),
            "stderr",
            &stderr,
            serde_json::json!({ "source": "handle_docker" }),
        )
        .await;
    }

    if !output.status.success() {
        let stderr = String::from_utf8_lossy(&output.stderr);
        let _ = log_error("docker", "docker command failed", Some(&stderr)).await;
        return Err(ErrorFactory::operation(
            "docker",
            "execute docker command",
            format!("docker exited with {}", output.status),
            Some("Try re-running with `--debug` to inspect full command output."),
        ));
    }

    Ok(())
}