use crate::plan::{PlannedHook, PlannedProgram};
use crate::template::Id;
use serde_json::{Value, json};
use std::{
cell::{Cell, RefCell},
collections::BTreeMap,
io::Read,
path::Path,
process::{Command, Stdio},
};
#[derive(Clone, PartialEq, Eq)]
pub struct HookOutcome {
pub success: bool,
pub code: Option<i32>,
pub stdout: Option<Vec<u8>>,
pub stderr: Option<Vec<u8>>,
}
impl std::fmt::Debug for HookOutcome {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("HookOutcome")
.field("success", &self.success)
.field("code", &self.code)
.finish()
}
}
#[derive(Debug, thiserror::Error)]
pub enum HookError {
#[error("{0}")]
Io(#[from] std::io::Error),
#[error("empty hook command")]
EmptyCommand,
}
pub(crate) fn decode(bytes: Vec<u8>) -> Result<String, usize> {
let text = String::from_utf8(bytes).map_err(|e| e.utf8_error().valid_up_to())?;
Ok(text.trim_end_matches(['\r', '\n']).to_owned())
}
pub trait HookRunner {
fn run(&self, hook: &PlannedHook, target: &Path) -> Result<HookOutcome, HookError>;
}
pub struct ProcessRunner;
impl ProcessRunner {
fn command(hook: &PlannedHook, target: &Path) -> Result<Command, HookError> {
let mut command = match &hook.program {
PlannedProgram::Run(argv) => {
let Some(program) = argv.first().filter(|v| !v.is_empty()) else {
return Err(HookError::EmptyCommand);
};
let resolved = if program.contains(['/', '\\']) {
None
} else {
crate::requirement::locate(program)
};
let mut c = match resolved {
Some(path) => Command::new(path),
None => Command::new(program),
};
c.args(&argv[1..]);
c
}
PlannedProgram::Script { path, args } => {
let mut c = Command::new(path);
c.args(args);
c
}
};
if let Some(path) = crate::requirement::search_path() {
command.env("PATH", path);
}
command.current_dir(
target.join(
hook.cwd
.as_ref()
.map(|v| v.as_path())
.unwrap_or(Path::new("")),
),
);
Ok(command)
}
}
impl HookRunner for ProcessRunner {
fn run(&self, hook: &PlannedHook, target: &Path) -> Result<HookOutcome, HookError> {
let mut command = Self::command(hook, target)?;
let capture = hook.capture;
match (capture.stdout, capture.stderr) {
(false, false) => {
let status = command.status()?;
Ok(HookOutcome {
success: status.success(),
code: status.code(),
stdout: None,
stderr: None,
})
}
(true, true) => {
let output = command
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.output()?;
Ok(HookOutcome {
success: output.status.success(),
code: output.status.code(),
stdout: Some(output.stdout),
stderr: Some(output.stderr),
})
}
(stdout_captured, _) => {
command.stdout(if stdout_captured {
Stdio::piped()
} else {
Stdio::inherit()
});
command.stderr(if stdout_captured {
Stdio::inherit()
} else {
Stdio::piped()
});
let mut child = command.spawn()?;
let mut buffer = Vec::new();
if stdout_captured {
child
.stdout
.take()
.expect("piped stdout")
.read_to_end(&mut buffer)?;
} else {
child
.stderr
.take()
.expect("piped stderr")
.read_to_end(&mut buffer)?;
}
let status = child.wait()?;
let (stdout, stderr) = if stdout_captured {
(Some(buffer), None)
} else {
(None, Some(buffer))
};
Ok(HookOutcome {
success: status.success(),
code: status.code(),
stdout,
stderr,
})
}
}
}
}
pub struct ScriptedRunner;
impl HookRunner for ScriptedRunner {
fn run(&self, hook: &PlannedHook, target: &Path) -> Result<HookOutcome, HookError> {
if hook.capture.stdout {
return ProcessRunner.run(hook, target);
}
use std::io::Write;
let mut command = ProcessRunner::command(hook, target)?;
command.stdout(Stdio::piped());
if hook.capture.stderr {
let output = command.stderr(Stdio::piped()).output()?;
std::io::stderr().write_all(&output.stdout)?;
Ok(HookOutcome {
success: output.status.success(),
code: output.status.code(),
stdout: None,
stderr: Some(output.stderr),
})
} else {
let mut child = command.spawn()?;
let mut buffer = Vec::new();
child
.stdout
.take()
.expect("piped stdout")
.read_to_end(&mut buffer)?;
let status = child.wait()?;
std::io::stderr().write_all(&buffer)?;
Ok(HookOutcome {
success: status.success(),
code: status.code(),
stdout: None,
stderr: None,
})
}
}
}
#[derive(Debug, Default)]
pub struct RecordingRunner {
calls: RefCell<Vec<(Vec<String>, String)>>,
failed: Cell<Option<usize>>,
}
impl RecordingRunner {
pub fn new() -> Self {
Self::default()
}
pub fn fail_at(index: usize) -> Self {
Self {
failed: Cell::new(Some(index)),
..Self::default()
}
}
pub fn calls(&self) -> Vec<(Vec<String>, String)> {
self.calls.borrow().clone()
}
}
impl HookRunner for RecordingRunner {
fn run(&self, hook: &PlannedHook, _target: &Path) -> Result<HookOutcome, HookError> {
let mut argv = hook.argv();
if let PlannedProgram::Script { path, .. } = &hook.program {
argv[0] = path
.strip_prefix(&hook.template_root)
.unwrap_or(path)
.display()
.to_string()
.replace('\\', "/");
}
let cwd = hook
.cwd
.as_ref()
.map(ToString::to_string)
.unwrap_or_default();
let index = self.calls.borrow().len();
self.calls.borrow_mut().push((argv, cwd));
let success = self.failed.get() != Some(index);
Ok(HookOutcome {
success,
code: Some(if success { 0 } else { 1 }),
stdout: None,
stderr: None,
})
}
}
#[derive(Debug, Clone)]
pub(crate) struct ResultSpec {
pub id: Id,
pub json: bool,
pub status_id: Option<Id>,
}
#[derive(Debug, Default)]
pub(crate) struct HookResults {
bindings: BTreeMap<String, Value>,
}
impl HookResults {
fn meta(exit_code: Option<i32>, stdout: &Option<String>, stderr: &Option<String>) -> Value {
json!({
"exit_code": exit_code,
"stdout": stdout,
"stderr": stderr,
})
}
pub(crate) fn seed(&mut self, spec: &ResultSpec) {
if spec.json {
self.bindings
.insert(spec.id.as_str().to_owned(), Value::Null);
if let Some(status) = &spec.status_id {
let mut meta = Self::meta(None, &None, &None);
meta["parsed"] = Value::Bool(false);
self.bindings.insert(status.as_str().to_owned(), meta);
}
} else {
self.bindings
.insert(spec.id.as_str().to_owned(), Self::meta(None, &None, &None));
}
}
pub(crate) fn record_text(
&mut self,
id: &Id,
exit_code: Option<i32>,
stdout: Option<String>,
stderr: Option<String>,
) {
self.bindings.insert(
id.as_str().to_owned(),
Self::meta(exit_code, &stdout, &stderr),
);
}
pub(crate) fn record_json(
&mut self,
spec: &ResultSpec,
exit_code: Option<i32>,
stdout: Option<String>,
stderr: Option<String>,
value: Option<Value>,
parsed: bool,
) {
self.bindings
.insert(spec.id.as_str().to_owned(), value.unwrap_or(Value::Null));
if let Some(status) = &spec.status_id {
let mut meta = Self::meta(exit_code, &stdout, &stderr);
meta["parsed"] = Value::Bool(parsed);
self.bindings.insert(status.as_str().to_owned(), meta);
}
}
pub(crate) fn project(&self, ctx: &mut BTreeMap<String, Value>) {
for (name, value) in &self.bindings {
ctx.insert(name.clone(), value.clone());
}
}
}
#[cfg(all(test, unix))]
mod tests {
use super::*;
use crate::plan::PlannedProgram;
use crate::template::{Capture, Id};
fn planned(capture: Capture) -> PlannedHook {
PlannedHook {
program: PlannedProgram::Run(vec!["sh".into(), "-c".into(), "printf data".into()]),
cwd: None,
template_root: std::path::PathBuf::from("."),
id: Some(Id::parse("probe").unwrap()),
capture,
allow_failure: false,
parse_json: false,
status_id: None,
}
}
#[test]
fn process_runner_captures_only_the_declared_stream() {
let target = tempfile::tempdir().unwrap();
let captured = ProcessRunner
.run(
&planned(Capture {
stdout: true,
stderr: false,
}),
target.path(),
)
.unwrap();
assert!(captured.success);
assert_eq!(captured.code, Some(0));
assert_eq!(captured.stdout.as_deref(), Some(b"data".as_slice()));
assert_eq!(captured.stderr, None);
let inherited = ProcessRunner
.run(&planned(Capture::default()), target.path())
.unwrap();
assert!(inherited.success);
assert_eq!(inherited.stdout, None);
assert_eq!(inherited.stderr, None);
}
}