use crate::util::cancel::Cancelled;
use anyhow::{bail, Context, Result};
use std::{
path::{Path, PathBuf},
process::{Command, Stdio},
};
use thiserror::Error;
use tokio::io::{AsyncBufReadExt, BufReader};
use tokio_util::sync::CancellationToken;
#[derive(Debug, Clone)]
pub struct ProcessOutput {
pub success: bool,
pub code: Option<i32>,
pub stdout: String,
pub stderr: String,
}
#[derive(Debug, Error)]
#[error("ffmpeg failed (exit {code:?}): {stderr}\ncommand: {command}")]
pub struct ProcessError {
pub command: String,
pub code: Option<i32>,
pub stdout: String,
pub stderr: String,
}
pub trait ProcessRunner {
fn run(&self, binary: &str, args: &[String]) -> Result<ProcessOutput>;
}
pub struct RealRunner;
impl ProcessRunner for RealRunner {
fn run(&self, binary: &str, args: &[String]) -> Result<ProcessOutput> {
let output = Command::new(binary).args(args).output()?;
Ok(ProcessOutput {
success: output.status.success(),
code: output.status.code(),
stdout: String::from_utf8_lossy(&output.stdout).into_owned(),
stderr: String::from_utf8_lossy(&output.stderr).into_owned(),
})
}
}
pub struct Ffmpeg<R> {
binary: PathBuf,
verbose: bool,
runner: R,
}
impl<R: ProcessRunner> Ffmpeg<R> {
pub fn new(binary: Option<PathBuf>, verbose: bool, runner: R) -> Self {
Self {
binary: binary.unwrap_or_else(|| PathBuf::from("ffmpeg")),
verbose,
runner,
}
}
pub fn run(&self, args: Vec<String>) -> Result<()> {
let binary = self.binary.to_string_lossy();
if self.verbose {
eprintln!("[ffmpeg] {binary} {}", args.join(" "));
}
let output = self.runner.run(&binary, &args)?;
if output.success {
Ok(())
} else {
if self.verbose && !output.stdout.is_empty() {
eprintln!("{}", output.stdout);
}
bail!(ProcessError {
command: format!("{binary} {}", args.join(" ")),
code: output.code,
stdout: output.stdout,
stderr: output.stderr
});
}
}
}
impl<R> Ffmpeg<R> {
pub fn binary(&self) -> &Path {
&self.binary
}
}
pub async fn run_async(
binary: &Path,
args: Vec<String>,
cancel: CancellationToken,
log_tx: Option<tokio::sync::mpsc::UnboundedSender<String>>,
) -> Result<()> {
let stderr_cfg = if log_tx.is_some() {
Stdio::piped()
} else {
Stdio::null()
};
let mut child = tokio::process::Command::new(binary)
.args(&args)
.stdout(Stdio::null())
.stderr(stderr_cfg)
.kill_on_drop(true)
.spawn()
.with_context(|| format!("spawning {} {}", binary.display(), args.join(" ")))?;
let log_task = if let (Some(stderr), Some(tx)) = (child.stderr.take(), log_tx) {
Some(tokio::spawn(async move {
let mut lines = BufReader::new(stderr).lines();
while let Ok(Some(line)) = lines.next_line().await {
let _ = tx.send(line);
}
}))
} else {
None
};
let result = tokio::select! {
r = child.wait() => r,
_ = cancel.cancelled() => {
let _ = child.kill().await;
if let Some(task) = log_task {
let _ = task.await;
}
return Err(Cancelled.into());
}
};
if let Some(task) = log_task {
let _ = task.await;
}
match result {
Ok(status) if status.success() => Ok(()),
Ok(status) => bail!("ffmpeg exited with {status}"),
Err(e) => Err(e.into()),
}
}
#[cfg(test)]
mod tests {
use super::*;
struct Fake;
impl ProcessRunner for Fake {
fn run(&self, _: &str, _: &[String]) -> Result<ProcessOutput> {
Ok(ProcessOutput {
success: false,
code: Some(2),
stdout: String::new(),
stderr: "bad input".into(),
})
}
}
#[test]
fn error_has_stderr() {
let error = Ffmpeg::new(None, false, Fake)
.run(vec!["-i".into(), "x".into()])
.unwrap_err();
assert!(error.to_string().contains("bad input"));
}
}