pub mod capabilities;
pub mod reporter;
use std::path::PathBuf;
use std::sync::Arc;
use std::sync::atomic::AtomicBool;
use std::time::Duration;
use crate::config::{ConversionConfig, EncoderConfig};
use crate::converter::ThreadBudget;
use crate::pipeline::{self, FileResult, RunStats};
pub use capabilities::{Capabilities, EncoderInfo, capabilities};
#[cfg(feature = "logs")]
pub use reporter::JsonlReporter;
pub use reporter::{JobEvent, NullReporter, Reporter, StdoutReporter, TeeReporter};
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum InputSelection {
Pattern(String),
Files(Vec<PathBuf>),
}
#[derive(Clone, Debug)]
pub struct JobSpec {
pub inputs: InputSelection,
pub output: Option<PathBuf>,
pub encoder: EncoderConfig,
pub common: ConversionConfig,
}
impl JobSpec {
#[must_use]
pub fn from_conversion(common: ConversionConfig, encoder: EncoderConfig) -> Self {
JobSpec {
inputs: InputSelection::Pattern(common.pattern.clone()),
output: None,
encoder,
common,
}
}
}
#[derive(Clone, Debug, Default)]
pub struct StopFlag(Arc<AtomicBool>);
impl StopFlag {
#[must_use]
pub fn new() -> Self {
Self::default()
}
#[must_use]
pub fn raised(&self) -> bool {
self.0.load(std::sync::atomic::Ordering::Relaxed)
}
pub fn raise(&self) {
self.0.store(true, std::sync::atomic::Ordering::Relaxed);
}
}
#[derive(Clone, Copy, Debug)]
pub struct Session {
pub thread_budget: ThreadBudget,
}
impl Default for Session {
fn default() -> Self {
Self::new()
}
}
impl Session {
#[must_use]
pub fn new() -> Self {
Session {
thread_budget: ThreadBudget::global(),
}
}
}
#[derive(Clone, Debug, Default, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
pub struct Totals {
pub input_files: u64,
pub successful: u64,
pub skipped: u64,
pub discarded: u64,
pub collisions: u64,
pub errors: u64,
pub aborted: u64,
pub input_size: u64,
pub output_size: u64,
}
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct RunReport {
pub elapsed: Duration,
pub files: Vec<FileResult>,
pub totals: Totals,
pub metadata_dropped_count: u64,
pub error: Option<String>,
}
impl From<RunStats> for RunReport {
fn from(stats: RunStats) -> Self {
RunReport {
elapsed: stats.elapsed,
files: stats.results,
totals: Totals {
input_files: stats.input_files,
successful: stats.successful,
skipped: stats.skipped,
discarded: stats.discarded,
collisions: stats.collisions,
errors: stats.errors,
aborted: stats.aborted,
input_size: stats.input_size,
output_size: stats.output_size,
},
metadata_dropped_count: stats.metadata_dropped,
error: None,
}
}
}
impl From<Result<RunStats, crate::Error>> for RunReport {
fn from(result: Result<RunStats, crate::Error>) -> Self {
match result {
Ok(stats) => RunReport::from(stats),
Err(err) => RunReport {
error: Some(err.to_string()),
..RunReport::default()
},
}
}
}
impl RunReport {
pub fn into_stats(self) -> Result<RunStats, crate::Error> {
if let Some(message) = self.error {
return Err(crate::Error::from_string(message));
}
Ok(RunStats {
input_files: self.totals.input_files,
successful: self.totals.successful,
skipped: self.totals.skipped,
discarded: self.totals.discarded,
collisions: self.totals.collisions,
errors: self.totals.errors,
aborted: self.totals.aborted,
metadata_dropped: self.metadata_dropped_count,
input_size: self.totals.input_size,
output_size: self.totals.output_size,
results: self.files,
elapsed: self.elapsed,
})
}
}
pub struct JobHandle {
thread: Option<std::thread::JoinHandle<Result<RunStats, crate::Error>>>,
}
impl JobHandle {
pub fn start(
spec: JobSpec,
reporter: Box<dyn Reporter>,
stop: StopFlag,
session: &Session,
) -> JobHandle {
let reporter: Arc<dyn Reporter> = Arc::from(reporter);
let budget = session.thread_budget;
let thread = std::thread::spawn(move || pipeline::execute(&spec, reporter, &stop, budget));
JobHandle {
thread: Some(thread),
}
}
#[must_use]
pub fn join(mut self) -> RunReport {
let result = match self.thread.take() {
Some(thread) => match thread.join() {
Ok(result) => result,
Err(_panic) => Err(crate::Error::from_string(
"job worker thread panicked".to_string(),
)),
},
None => Ok(RunStats::default()),
};
RunReport::from(result)
}
}