use crate::error::IronError;
pub fn capture(program: &str, args: &[&str]) -> Result<String, IronError> {
capture_with_timeout(program, args, DEFAULT_TIMEOUT)
}
const DEFAULT_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(30);
pub fn capture_with_timeout(
program: &str,
args: &[&str],
timeout: std::time::Duration,
) -> Result<String, IronError> {
use std::io::Read;
use std::process::{Command, Stdio};
let mut child = Command::new(program)
.args(args)
.stdin(Stdio::null())
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.spawn()
.map_err(|e| IronError::CommandFailed(format!("{program}: {e}")))?;
let mut out_pipe = child.stdout.take();
let mut err_pipe = child.stderr.take();
let out_reader = std::thread::spawn(move || {
let mut buf = Vec::new();
if let Some(p) = out_pipe.as_mut() {
let _ = p.read_to_end(&mut buf);
}
buf
});
let err_reader = std::thread::spawn(move || {
let mut buf = Vec::new();
if let Some(p) = err_pipe.as_mut() {
let _ = p.read_to_end(&mut buf);
}
buf
});
let deadline = std::time::Instant::now() + timeout;
let status = loop {
match child.try_wait() {
Ok(Some(status)) => break status,
Ok(None) => {
if std::time::Instant::now() >= deadline {
let _ = child.kill();
let _ = child.wait();
return Err(IronError::CommandFailed(format!(
"{program} did not finish within {}s and was killed",
timeout.as_secs()
)));
}
std::thread::sleep(std::time::Duration::from_millis(20));
}
Err(e) => {
let _ = child.kill();
let _ = child.wait();
return Err(IronError::CommandFailed(format!(
"{program}: could not wait for it: {e}"
)));
}
}
};
let stdout = out_reader.join().unwrap_or_default();
let stderr = err_reader.join().unwrap_or_default();
let output = std::process::Output {
status,
stdout,
stderr,
};
if !output.status.success() {
let stderr = String::from_utf8_lossy(&output.stderr);
let detail = stderr.trim();
return Err(IronError::CommandFailed(if detail.is_empty() {
format!("{program} exited {}", output.status)
} else {
format!("{program} exited {}: {detail}", output.status)
}));
}
String::from_utf8(output.stdout)
.map_err(|e| IronError::Parse(format!("{program} output is not UTF-8: {e}")))
}
pub fn capture_json(program: &str, args: &[&str]) -> Result<Option<serde_json::Value>, IronError> {
let text = capture(program, args)?;
if text.trim().is_empty() {
return Ok(None);
}
serde_json::from_str(&text)
.map(Some)
.map_err(|e| IronError::Parse(format!("{program} output is not JSON: {e}")))
}
pub fn json_items(value: &serde_json::Value) -> Vec<serde_json::Value> {
match value {
serde_json::Value::Array(arr) => arr.clone(),
obj @ serde_json::Value::Object(_) => vec![obj.clone()],
_ => Vec::new(),
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_missing_program_is_an_error_not_an_empty_result() {
let err = capture("ironmon-no-such-program-exists", &[]).unwrap_err();
assert!(
err.to_string().contains("ironmon-no-such-program-exists"),
"the error should name the program that failed: {err}"
);
}
#[test]
fn a_program_that_never_exits_is_killed_and_reported() {
#[cfg(target_os = "windows")]
let (prog, args) = ("cmd", vec!["/C", "ping -n 30 127.0.0.1 > NUL"]);
#[cfg(not(target_os = "windows"))]
let (prog, args) = ("sh", vec!["-c", "sleep 30"]);
let start = std::time::Instant::now();
let err = capture_with_timeout(prog, &args, std::time::Duration::from_millis(300))
.expect_err("a program that outlives its deadline must be an error");
let waited = start.elapsed();
assert!(
err.to_string().contains("did not finish"),
"the error must say it timed out rather than blaming the machine: {err}"
);
assert!(
waited < std::time::Duration::from_secs(10),
"gave up after {waited:?}, which is not a deadline"
);
}
#[test]
fn a_program_that_answers_in_time_is_not_killed() {
#[cfg(target_os = "windows")]
let (prog, args) = ("cmd", vec!["/C", "echo ready"]);
#[cfg(not(target_os = "windows"))]
let (prog, args) = ("sh", vec!["-c", "echo ready"]);
let out = capture_with_timeout(prog, &args, std::time::Duration::from_secs(30))
.expect("a fast program must succeed");
assert!(out.contains("ready"), "{out:?}");
}
#[test]
fn output_larger_than_a_pipe_buffer_is_captured_whole() {
#[cfg(target_os = "windows")]
let (prog, args) = ("powershell", vec!["-NoProfile", "-Command", "'x' * 524288"]);
#[cfg(not(target_os = "windows"))]
let (prog, args) = ("sh", vec!["-c", "yes x | head -c 524288"]);
let out = capture_with_timeout(prog, &args, std::time::Duration::from_secs(60))
.expect("a chatty program must not deadlock the wait");
assert!(
out.len() >= 524_288,
"captured only {} bytes; the pipe was not drained",
out.len()
);
}
#[test]
fn a_nonzero_exit_is_an_error() {
#[cfg(target_os = "windows")]
let (prog, args) = ("cmd", vec!["/C", "echo partial & exit 3"]);
#[cfg(not(target_os = "windows"))]
let (prog, args) = ("sh", vec!["-c", "echo partial; exit 3"]);
let err = capture(prog, &args).unwrap_err();
assert!(err.to_string().contains('3'), "{err}");
}
#[test]
fn empty_output_is_no_devices_rather_than_a_parse_error() {
#[cfg(target_os = "windows")]
let (prog, args) = ("cmd", vec!["/C", "exit 0"]);
#[cfg(not(target_os = "windows"))]
let (prog, args) = ("sh", vec!["-c", "true"]);
assert_eq!(capture_json(prog, &args).unwrap(), None);
}
#[test]
fn one_object_and_an_array_of_one_both_yield_one_item() {
let obj = serde_json::json!({"Name": "a"});
let arr = serde_json::json!([{"Name": "a"}]);
assert_eq!(json_items(&obj).len(), 1);
assert_eq!(json_items(&arr).len(), 1);
assert_eq!(json_items(&serde_json::json!(null)).len(), 0);
}
}