59 lines
1.7 KiB
Rust
59 lines
1.7 KiB
Rust
use std::io::{BufRead, BufReader};
|
|
use std::process::Command;
|
|
|
|
use log::{info, trace};
|
|
|
|
pub struct Process {
|
|
pub command: Vec<String>,
|
|
pub cwd: Option<String>,
|
|
pub env: Vec<String>,
|
|
}
|
|
|
|
impl Process {
|
|
pub fn new(command: Vec<String>, cwd: Option<String>, env: Vec<String>) -> Process {
|
|
Process { command, cwd, env }
|
|
}
|
|
|
|
pub fn command<S: Into<String>>(cmd: Vec<S>) -> Process {
|
|
Process::new(cmd.into_iter().map(|v| v.into()).collect(), None, vec![])
|
|
}
|
|
|
|
pub fn spawn(&self) -> std::io::Result<std::process::Child> {
|
|
trace!("Spawning process: {:?}", self.command);
|
|
let mut child = Command::new(&self.command[0])
|
|
.args(&self.command[1..])
|
|
.current_dir(self.cwd.clone().unwrap_or(".".to_string()))
|
|
.envs(self.env.iter().map(|v| {
|
|
let mut split = v.split('=');
|
|
(
|
|
split.next().unwrap().to_string(),
|
|
split.next().unwrap().to_string(),
|
|
)
|
|
}))
|
|
.stdout(std::process::Stdio::piped())
|
|
.stderr(std::process::Stdio::piped())
|
|
.spawn()?;
|
|
let stdout = child.stdout.take().unwrap();
|
|
let stderr = child.stderr.take().unwrap();
|
|
|
|
trace!("Processing lines from stdout and stderr");
|
|
for line in BufReader::new(stdout).lines() {
|
|
info!(target: "command:stdout", "{}", line.unwrap());
|
|
}
|
|
|
|
for line in BufReader::new(stderr).lines() {
|
|
info!(target: "command:stderr", "{}", line.unwrap());
|
|
}
|
|
|
|
trace!("End of process");
|
|
|
|
trace!("Returning child");
|
|
Ok(child)
|
|
}
|
|
}
|
|
|
|
impl Default for Process {
|
|
fn default() -> Process {
|
|
Process::new(vec![], None, vec![])
|
|
}
|
|
}
|