use std::io::Read;
use std::process::{Command, Output, Stdio};
use std::sync::{mpsc, Arc, Mutex};
use std::thread;
use std::time::{Duration, Instant};
pub const ITEM_TIMEOUT: Duration = Duration::from_secs(60);
pub const PHASE_TIMEOUT: Duration = Duration::from_secs(300);
const DRAIN_GRACE: Duration = Duration::from_secs(2);
const POLL: Duration = Duration::from_millis(20);
pub fn captured(mut command: Command, label: &str, timeout: Duration) -> Result<Output, String> {
command
.stdin(Stdio::null())
.stdout(Stdio::piped())
.stderr(Stdio::piped());
let mut child = command
.spawn()
.map_err(|e| format!("could not run {label}: {e}"))?;
let out_rx = drain(child.stdout.take());
let err_rx = drain(child.stderr.take());
let deadline = Instant::now() + timeout;
let mut timed_out = false;
let status = loop {
match child.try_wait() {
Ok(Some(status)) => break status,
Ok(None) => {}
Err(e) => return Err(format!("could not wait for {label}: {e}")),
}
if Instant::now() >= deadline {
let _ = child.kill();
let _ = child.wait();
timed_out = true;
break child.wait().unwrap_or_else(|_| exited_nonzero());
}
thread::sleep(POLL);
};
let stdout = out_rx.take(DRAIN_GRACE);
let stderr = err_rx.take(DRAIN_GRACE);
if timed_out {
return Err(format!(
"{label} gave no answer in {}s and was killed, which usually means \
it is waiting on something nobody is going to type{}",
timeout.as_secs(),
tail(&stderr)
));
}
Ok(Output {
status,
stdout,
stderr,
})
}
struct Drain {
buf: Arc<Mutex<Vec<u8>>>,
done: mpsc::Receiver<()>,
}
impl Drain {
fn take(self, grace: Duration) -> Vec<u8> {
let _ = self.done.recv_timeout(grace);
match self.buf.lock() {
Ok(b) => b.clone(),
Err(poisoned) => poisoned.into_inner().clone(),
}
}
}
fn drain(pipe: Option<impl Read + Send + 'static>) -> Drain {
let buf = Arc::new(Mutex::new(Vec::new()));
let (tx, done) = mpsc::channel();
let into = Arc::clone(&buf);
thread::spawn(move || {
if let Some(mut p) = pipe {
let mut chunk = [0u8; 8192];
loop {
match p.read(&mut chunk) {
Ok(0) | Err(_) => break,
Ok(n) => {
let Ok(mut held) = into.lock() else { break };
held.extend_from_slice(&chunk[..n]);
}
}
}
}
let _ = tx.send(());
});
Drain { buf, done }
}
fn tail(stderr: &[u8]) -> String {
let text = String::from_utf8_lossy(stderr);
let trimmed = text.trim();
if trimmed.is_empty() {
return String::new();
}
let shown: String = trimmed
.chars()
.rev()
.take(160)
.collect::<Vec<_>>()
.into_iter()
.rev()
.collect();
format!(". stderr: {shown}")
}
fn exited_nonzero() -> std::process::ExitStatus {
#[cfg(unix)]
{
use std::os::unix::process::ExitStatusExt;
std::process::ExitStatus::from_raw(9)
}
#[cfg(windows)]
{
use std::os::windows::process::ExitStatusExt;
std::process::ExitStatus::from_raw(9)
}
}
#[cfg(all(test, unix))]
mod tests {
use super::*;
fn sh(script: &str) -> Command {
let mut c = Command::new("sh");
c.args(["-c", script]);
c
}
#[test]
fn a_tool_that_answers_is_answered() {
let out = captured(sh("echo hello"), "sh", Duration::from_secs(5)).expect("ran");
assert_eq!(String::from_utf8_lossy(&out.stdout).trim(), "hello");
assert!(out.status.success());
}
#[test]
fn both_streams_come_back() {
let out =
captured(sh("echo out; echo err >&2"), "sh", Duration::from_secs(5)).expect("ran");
assert_eq!(String::from_utf8_lossy(&out.stdout).trim(), "out");
assert_eq!(String::from_utf8_lossy(&out.stderr).trim(), "err");
}
#[test]
fn a_failing_tool_is_not_an_error_here() {
let out = captured(sh("echo why >&2; exit 3"), "sh", Duration::from_secs(5)).expect("ran");
assert_eq!(out.status.code(), Some(3));
assert_eq!(String::from_utf8_lossy(&out.stderr).trim(), "why");
}
#[test]
fn a_tool_that_never_answers_is_killed_and_says_so() {
let started = Instant::now();
let err = captured(sh("sleep 30"), "sh", Duration::from_millis(150))
.expect_err("it should have been killed");
assert!(started.elapsed() < Duration::from_secs(10), "it waited");
assert!(err.contains("gave no answer in"), "got {err}");
}
#[test]
fn a_tool_that_waits_on_input_does_not_hold_the_run() {
let out = captured(sh("cat; echo done"), "sh", Duration::from_secs(5)).expect("ran");
assert_eq!(String::from_utf8_lossy(&out.stdout).trim(), "done");
}
#[test]
fn a_noisy_tool_does_not_deadlock_on_a_full_pipe() {
let out = captured(
sh("i=0; while [ $i -lt 20000 ]; do echo 'a line of output'; i=$((i+1)); done"),
"sh",
Duration::from_secs(20),
)
.expect("ran");
assert_eq!(String::from_utf8_lossy(&out.stdout).lines().count(), 20000);
}
#[test]
fn a_missing_program_is_reported_with_its_name() {
let err = captured(
Command::new("definitely-not-installed-anywhere"),
"definitely-not-installed-anywhere",
Duration::from_secs(5),
)
.expect_err("there is no such program");
assert!(err.contains("could not run"), "got {err}");
assert!(
err.contains("definitely-not-installed-anywhere"),
"got {err}"
);
}
}