use std::io::{self, BufRead, BufReader, Read};
use std::path::PathBuf;
use std::process::{Command, Stdio};
use std::sync::Mutex;
use beez_policy::SandboxPolicy;
use beez_sandbox::SandboxedCommand;
use crate::execution::ExecutionRequest;
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum OutputStream {
Stdout,
Stderr,
}
pub type OutputSink<'sink> = dyn Fn(OutputStream, &[u8]) + Send + Sync + 'sink;
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct ProcessOutput {
stdout: Vec<u8>,
stderr: Vec<u8>,
status_code: Option<i32>,
}
impl ProcessOutput {
#[must_use]
pub fn stdout(&self) -> &[u8] {
&self.stdout
}
#[must_use]
pub fn stderr(&self) -> &[u8] {
&self.stderr
}
#[must_use]
pub fn status_code(&self) -> Option<i32> {
self.status_code
}
#[must_use]
pub fn succeeded(&self) -> bool {
self.status_code == Some(0)
}
}
#[derive(Clone, Debug)]
pub struct ProcessRunner {
working_directory: PathBuf,
}
impl ProcessRunner {
#[must_use]
pub fn new(working_directory: impl Into<PathBuf>) -> Self {
Self {
working_directory: working_directory.into(),
}
}
pub fn here() -> io::Result<Self> {
Ok(Self::new(std::env::current_dir()?))
}
pub fn run(&self, request: ExecutionRequest) -> io::Result<ProcessOutput> {
self.run_streaming(request, None, &|_, _| {})
}
pub fn run_streaming(
&self,
request: ExecutionRequest,
sandbox: Option<&SandboxPolicy>,
sink: &OutputSink<'_>,
) -> io::Result<ProcessOutput> {
let harness = request.harness();
let (program, arguments) = request.into_parts();
if let Some(policy) = sandbox {
let mut sandboxed = SandboxedCommand::new(
policy,
harness,
&program,
&arguments,
&self.working_directory,
)?;
relay(sandboxed.command_mut(), sink)
} else {
let mut command = Command::new(program);
command.args(arguments).current_dir(&self.working_directory);
relay(&mut command, sink)
}
}
}
fn relay(command: &mut Command, sink: &OutputSink<'_>) -> io::Result<ProcessOutput> {
command.stdout(Stdio::piped()).stderr(Stdio::piped());
let mut child = command.spawn()?;
let stdout = child.stdout.take();
let stderr = child.stderr.take();
let collected = Mutex::new((Vec::new(), Vec::new()));
let collect = |stream: OutputStream, line: &[u8]| {
if let Ok(mut collected) = collected.lock() {
match stream {
OutputStream::Stdout => collected.0.extend_from_slice(line),
OutputStream::Stderr => collected.1.extend_from_slice(line),
}
}
sink(stream, line);
};
let collect: &OutputSink<'_> = &collect;
std::thread::scope(|scope| {
if let Some(stdout) = stdout {
scope.spawn(move || forward(stdout, OutputStream::Stdout, collect));
}
if let Some(stderr) = stderr {
scope.spawn(move || forward(stderr, OutputStream::Stderr, collect));
}
});
let status = child.wait()?;
let (stdout, stderr) = collected
.into_inner()
.map_err(|_| io::Error::other("output collection lock is poisoned"))?;
Ok(ProcessOutput {
stdout,
stderr,
status_code: status.code(),
})
}
fn forward(reader: impl Read, stream: OutputStream, sink: &OutputSink<'_>) {
let mut reader = BufReader::new(reader);
let mut line = Vec::new();
loop {
line.clear();
match reader.read_until(b'\n', &mut line) {
Ok(0) | Err(_) => return,
Ok(_) => sink(stream, &line),
}
}
}