baraddur 0.1.6

Project-agnostic file watcher that surfaces issues before CI
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

use anyhow::{Context, Result, anyhow};
use std::path::Path;
use std::time::{Duration, Instant};
use tokio::process::Command;

use crate::config::Step;

/// Maximum bytes captured per step. Output beyond this is truncated.
const MAX_CAPTURE_BYTES: usize = 100 * 1024; // 100 KiB

#[derive(Debug, Clone)]
pub struct StepResult {
    pub name: String,
    pub success: bool,
    pub exit_code: Option<i32>,
    pub stdout: String,
    pub stderr: String,
    pub duration: Duration,
    /// True when `stdout` was clipped at `MAX_CAPTURE_BYTES`.
    pub stdout_truncated: bool,
    /// True when `stderr` was clipped at `MAX_CAPTURE_BYTES`.
    pub stderr_truncated: bool,
}

/// Runs a single step and returns its result.
///
/// A step that exits non-zero is a failing `StepResult`, not an `Err`.
/// Only returns `Err` for things like malformed `cmd` strings.
pub async fn run(step: &Step, cwd: &Path) -> Result<StepResult> {
    let parts = shell_words::split(&step.cmd)
        .with_context(|| format!("parsing cmd `{}` for step `{}`", step.cmd, step.name))?;

    let (program, args) = parts
        .split_first()
        .ok_or_else(|| anyhow!("empty cmd for step `{}`", step.name))?;

    let start = Instant::now();

    let output = Command::new(program)
        .args(args)
        .current_dir(cwd)
        .kill_on_drop(true)
        .output()
        .await;

    let duration = start.elapsed();

    let result = match output {
        Ok(out) => {
            let (stdout, stdout_truncated) = truncate_capture(&out.stdout);
            let (stderr, stderr_truncated) = truncate_capture(&out.stderr);
            StepResult {
                name: step.name.clone(),
                success: out.status.success(),
                exit_code: out.status.code(),
                stdout,
                stderr,
                duration,
                stdout_truncated,
                stderr_truncated,
            }
        }
        Err(e) => StepResult {
            name: step.name.clone(),
            success: false,
            exit_code: None,
            stdout: String::new(),
            stderr: format!("failed to launch `{program}`: {e}"),
            duration,
            stdout_truncated: false,
            stderr_truncated: false,
        },
    };

    Ok(result)
}

fn truncate_capture(bytes: &[u8]) -> (String, bool) {
    if bytes.len() <= MAX_CAPTURE_BYTES {
        (String::from_utf8_lossy(bytes).into_owned(), false)
    } else {
        let mut s = String::from_utf8_lossy(&bytes[..MAX_CAPTURE_BYTES]).into_owned();
        s.push_str("\n... [output truncated at 100 KiB] ...\n");
        (s, true)
    }
}