use std::error::Error as StdError;
use std::fmt;
use std::num::NonZeroUsize;
use std::path::{Path, PathBuf};
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::Arc;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Recovery {
Percentage(u8),
Blocks(u16),
}
impl Default for Recovery {
fn default() -> Self {
Self::Percentage(10)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum SliceStrategy {
#[default]
Automatic,
Size(usize),
Count(usize),
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum OutputPolicy {
#[default]
FailIfExists,
ReplaceExisting,
}
#[derive(Debug, Clone, Default)]
pub struct CreateCancellation {
cancelled: Arc<AtomicBool>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub enum CreateErrorKind {
InvalidRequest,
Cancelled,
OutputExists {
path: PathBuf,
},
Io,
Other,
}
#[derive(Debug)]
pub struct CreateError {
kind: CreateErrorKind,
source: anyhow::Error,
}
impl CreateError {
pub fn kind(&self) -> &CreateErrorKind {
&self.kind
}
pub(super) fn from_operation(source: anyhow::Error) -> Self {
let kind = if source.downcast_ref::<CancelledFailure>().is_some() {
CreateErrorKind::Cancelled
} else if let Some(output) = source.downcast_ref::<OutputExistsFailure>() {
CreateErrorKind::OutputExists {
path: output.path.clone(),
}
} else if source.downcast_ref::<InvalidRequestFailure>().is_some() {
CreateErrorKind::InvalidRequest
} else if source.chain().any(|error| error.is::<std::io::Error>()) {
CreateErrorKind::Io
} else {
CreateErrorKind::Other
};
Self { kind, source }
}
}
impl fmt::Display for CreateError {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
self.source.fmt(formatter)
}
}
impl StdError for CreateError {
fn source(&self) -> Option<&(dyn StdError + 'static)> {
Some(self.source.as_ref())
}
}
#[derive(Debug)]
pub(super) struct InvalidRequestFailure(pub(super) &'static str);
impl fmt::Display for InvalidRequestFailure {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(self.0)
}
}
impl StdError for InvalidRequestFailure {}
#[derive(Debug)]
pub(super) struct CancelledFailure;
impl fmt::Display for CancelledFailure {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str("PAR2 creation cancelled")
}
}
impl StdError for CancelledFailure {}
#[derive(Debug)]
pub(super) struct OutputExistsFailure {
pub(super) path: PathBuf,
}
impl fmt::Display for OutputExistsFailure {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(
formatter,
"output file already exists: `{}`",
self.path.display()
)
}
}
impl StdError for OutputExistsFailure {}
impl CreateCancellation {
pub fn new() -> Self {
Self::default()
}
pub fn cancel(&self) {
self.cancelled.store(true, Ordering::Release);
}
pub fn is_cancelled(&self) -> bool {
self.cancelled.load(Ordering::Acquire)
}
pub(super) fn as_atomic(&self) -> &AtomicBool {
&self.cancelled
}
}
#[derive(Debug, Clone)]
pub struct CreateRequest {
input_paths: Vec<PathBuf>,
output_dir: PathBuf,
base_name: Option<String>,
recovery: Recovery,
slice_strategy: SliceStrategy,
memory_limit: usize,
threads: Option<NonZeroUsize>,
output_policy: OutputPolicy,
recurse: bool,
creator: Option<String>,
recovery_offset: u32,
}
impl CreateRequest {
pub fn from_paths<I, P>(paths: I) -> Self
where
I: IntoIterator<Item = P>,
P: AsRef<Path>,
{
Self {
input_paths: paths
.into_iter()
.map(|path| path.as_ref().to_path_buf())
.collect(),
output_dir: PathBuf::from("."),
base_name: None,
recovery: Recovery::default(),
slice_strategy: SliceStrategy::default(),
memory_limit: 1024 * 1024 * 1024,
threads: None,
output_policy: OutputPolicy::default(),
recurse: false,
creator: None,
recovery_offset: 0,
}
}
#[must_use]
pub fn output_dir(mut self, path: impl AsRef<Path>) -> Self {
self.output_dir = path.as_ref().to_path_buf();
self
}
#[must_use]
pub fn base_name(mut self, name: impl Into<String>) -> Self {
self.base_name = Some(name.into());
self
}
#[must_use]
pub fn recovery(mut self, recovery: Recovery) -> Self {
self.recovery = recovery;
self
}
#[must_use]
pub fn slice_strategy(mut self, strategy: SliceStrategy) -> Self {
self.slice_strategy = strategy;
self
}
#[must_use]
pub fn memory_limit(mut self, bytes: usize) -> Self {
self.memory_limit = bytes;
self
}
#[must_use]
pub fn threads(mut self, threads: NonZeroUsize) -> Self {
self.threads = Some(threads);
self
}
#[must_use]
pub fn output_policy(mut self, policy: OutputPolicy) -> Self {
self.output_policy = policy;
self
}
#[must_use]
pub fn recurse(mut self) -> Self {
self.recurse = true;
self
}
#[must_use]
pub fn creator(mut self, creator: impl Into<String>) -> Self {
self.creator = Some(creator.into());
self
}
#[must_use]
pub fn recovery_offset(mut self, offset: u32) -> Self {
self.recovery_offset = offset;
self
}
pub fn input_paths(&self) -> &[PathBuf] {
&self.input_paths
}
pub fn output_directory(&self) -> &Path {
&self.output_dir
}
pub fn output_base_name(&self) -> Option<&str> {
self.base_name.as_deref()
}
pub fn recovery_strategy(&self) -> Recovery {
self.recovery
}
pub fn requested_slice_strategy(&self) -> SliceStrategy {
self.slice_strategy
}
pub fn requested_memory_limit(&self) -> usize {
self.memory_limit
}
pub fn requested_threads(&self) -> Option<NonZeroUsize> {
self.threads
}
pub fn requested_output_policy(&self) -> OutputPolicy {
self.output_policy
}
pub fn recurses(&self) -> bool {
self.recurse
}
pub fn creator_text(&self) -> Option<&str> {
self.creator.as_deref()
}
pub fn requested_recovery_offset(&self) -> u32 {
self.recovery_offset
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub struct CreateGeometry {
pub slice_size: usize,
pub input_slices: usize,
pub recovery_blocks: usize,
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub struct CreateReport {
pub recovery_set_id: [u8; 16],
pub geometry: CreateGeometry,
pub index_path: Option<PathBuf>,
pub volume_paths: Vec<PathBuf>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub enum CreateEvent {
Planned {
input_files: usize,
input_bytes: u64,
geometry: CreateGeometry,
},
PassStarted {
pass: usize,
first_exponent: u32,
recovery_blocks: usize,
},
BytesRead {
pass: usize,
bytes_read: u64,
},
IndexWritten {
path: PathBuf,
},
VolumeWritten {
path: PathBuf,
},
Cancelled,
}