parmesan-par2 0.6.0

Fast, standalone PAR2 (Reed-Solomon) creation, verification and repair tool
Documentation
use super::cli::{Command, CreateArgs, RepairArgs, VerifyArgs};
use anyhow::{Context, Result};
use parmesan::create::{
    create_with_options, CreateEvent, CreateRequest, EngineOptions, OutputPolicy, Recovery,
    SliceStrategy,
};
use parmesan::recovery_set::RecoverySet;
use parmesan::repair::{self, RepairOptions};
use parmesan::verify::{self, FileStatus, VerifyReport};
use std::path::PathBuf;

pub(super) async fn run(command: Command) -> Result<()> {
    match command {
        Command::Create(args) => run_create(args).await,
        Command::Verify(args) => run_verify(args),
        Command::Repair(args) => run_repair(args),
    }
}

fn parse_size(s: &str) -> Result<u64> {
    let s = s.trim().to_ascii_lowercase();
    let split = s
        .find(|c: char| !c.is_ascii_digit() && c != '.')
        .unwrap_or(s.len());
    let (num_str, unit) = s.split_at(split);
    let value: f64 = num_str.trim().parse().context("invalid number")?;
    let multiplier: f64 = match unit.trim() {
        "" | "b" => 1.0,
        "k" | "kb" | "kib" => 1024.0,
        "m" | "mb" | "mib" => 1024.0 * 1024.0,
        "g" | "gb" | "gib" => 1024.0 * 1024.0 * 1024.0,
        other => anyhow::bail!("unknown unit `{other}`"),
    };
    Ok((value * multiplier) as u64)
}

async fn run_create(cli: CreateArgs) -> Result<()> {
    let recovery = match cli.recovery_count {
        Some(count) => Recovery::Blocks(
            u16::try_from(count).context("recovery block count must not exceed 65535")?,
        ),
        None => Recovery::Percentage(cli.recovery_pct),
    };
    let slice_strategy = match (cli.slice_size.as_deref(), cli.slice_count) {
        (Some(size), _) => SliceStrategy::Size(parse_size(size)? as usize),
        (None, Some(count)) => SliceStrategy::Count(count),
        (None, None) => SliceStrategy::Automatic,
    };
    let memory_limit = parse_size(&cli.memory_limit)? as usize;
    let mut request = CreateRequest::from_paths(&cli.files)
        .recovery(recovery)
        .slice_strategy(slice_strategy)
        .memory_limit(memory_limit)
        .output_policy(if cli.overwrite {
            OutputPolicy::ReplaceExisting
        } else {
            OutputPolicy::FailIfExists
        })
        .creator(if cli.comment.is_empty() {
            "parmesan".to_owned()
        } else {
            format!("parmesan | {}", cli.comment.join(" | "))
        })
        .recovery_offset(
            u32::try_from(cli.recovery_offset)
                .context("recovery offset exceeds the PAR2 exponent range")?,
        );
    if let Some(out_dir) = &cli.out_dir {
        request = request.output_dir(out_dir);
    }
    if let Some(base_name) = &cli.base_name {
        request = request.base_name(base_name);
    }
    if let Some(threads) = cli.threads.and_then(std::num::NonZeroUsize::new) {
        request = request.threads(threads);
    }
    if cli.recurse {
        request = request.recurse();
    }

    let quiet = cli.quiet;
    create_with_options(
        request,
        EngineOptions {
            simd: cli.simd,
            layout: cli.encoder,
            write_index: !cli.no_index,
        },
        |event| {
            if quiet {
                return;
            }
            match event {
                CreateEvent::Planned {
                    input_files,
                    geometry,
                    ..
                } => {
                    println!("PAR2 Geometry:");
                    println!("  Input files    : {input_files}");
                    println!("  Input slices   : {}", geometry.input_slices);
                    println!("  Recovery blocks: {}", geometry.recovery_blocks);
                    println!("  Slice size     : {} bytes", geometry.slice_size);
                    if cli.recovery_offset > 0 {
                        println!("  Recovery offset: {}", cli.recovery_offset);
                    }
                    let memory_plan = parmesan::ops::plan_memory_layout(
                        geometry.slice_size,
                        geometry.recovery_blocks,
                        memory_limit,
                    );
                    if memory_plan.slice_chunk < geometry.slice_size {
                        println!(
                            "  Memory plan    : slice-chunk {} bytes × {} recovery (limit {})",
                            memory_plan.slice_chunk, memory_plan.recovery_per_pass, memory_limit
                        );
                    }
                }
                CreateEvent::PassStarted {
                    pass,
                    first_exponent,
                    recovery_blocks,
                } => println!(
                    "\nPass {} (recovery blocks {}-{}):",
                    pass + 1,
                    first_exponent,
                    first_exponent + recovery_blocks as u32 - 1
                ),
                CreateEvent::IndexWritten { path } => println!("Wrote {}", path.display()),
                CreateEvent::VolumeWritten { path } => println!("Finished {}", path.display()),
                CreateEvent::BytesRead { .. } => {}
                _ => {}
            }
        },
    )
    .await?;
    if !quiet {
        println!("\nAll recovery volumes created successfully.");
    }
    Ok(())
}

fn run_verify(args: VerifyArgs) -> Result<()> {
    let set = RecoverySet::load_metadata(&args.index)
        .with_context(|| format!("loading recovery set from `{}`", args.index.display()))?;
    let base_dir = args
        .index
        .parent()
        .filter(|p| !p.as_os_str().is_empty())
        .map(PathBuf::from)
        .unwrap_or_else(|| PathBuf::from("."));

    let report = verify::verify(&set, &base_dir)?;

    if args.json {
        print_json_report(&report);
    } else {
        if !args.quiet {
            for f in &report.files {
                let status = match f.status {
                    FileStatus::Ok => "OK",
                    FileStatus::Damaged => "DAMAGED",
                    FileStatus::Missing => "MISSING",
                };
                println!(
                    "{status:<8} {} ({}/{} slices ok)",
                    f.name,
                    f.total_slices - f.bad_slices,
                    f.total_slices
                );
            }
        }
        if report.is_ok() {
            println!("\nAll files verified OK.");
        } else if report.is_repairable() {
            println!(
                "\n{} slice(s) need repair; {} recovery block(s) available — repairable.",
                report.total_bad_slices(),
                report.available_recovery_blocks
            );
        } else {
            println!(
                "\n{} slice(s) need repair; only {} recovery block(s) available — NOT repairable.",
                report.total_bad_slices(),
                report.available_recovery_blocks
            );
        }
    }

    std::process::exit(report.exit_code());
}

fn run_repair(args: RepairArgs) -> Result<()> {
    let mut set = RecoverySet::load_metadata(&args.index)
        .with_context(|| format!("loading recovery set from `{}`", args.index.display()))?;
    let base_dir = args
        .index
        .parent()
        .filter(|p| !p.as_os_str().is_empty())
        .map(PathBuf::from)
        .unwrap_or_else(|| PathBuf::from("."));

    let report = verify::verify(&set, &base_dir)?;

    if report.is_ok() {
        if args.json {
            println!(
                r#"{{"repaired_files":[],"dry_run":{},"needed_repair":false}}"#,
                args.dry_run
            );
        } else if !args.quiet {
            println!("All files verified OK — nothing to repair.");
        }
        return Ok(());
    }
    if !report.is_repairable() {
        if args.json {
            println!(
                r#"{{"error":"not enough recovery data","bad_slices":{},"available_recovery_blocks":{}}}"#,
                report.total_bad_slices(),
                report.available_recovery_blocks
            );
        }
        anyhow::bail!(
            "not enough recovery data to repair: {} bad slice(s), only {} recovery block(s) available",
            report.total_bad_slices(),
            report.available_recovery_blocks
        );
    }

    let options = RepairOptions {
        out_dir: args.out_dir.clone(),
        dry_run: args.dry_run,
    };
    set.load_recovery_blocks(Some(report.total_bad_slices()))?;
    let plan = repair::repair(&set, &report, &base_dir, &options)?;

    if args.json {
        print_json_repair_plan(&plan);
        return Ok(());
    }

    if !args.quiet {
        let verb = if plan.dry_run {
            "Would repair"
        } else {
            "Repaired"
        };
        for f in &plan.repaired_files {
            println!(
                "{verb:<13} {} ({} slice(s)) -> {}",
                f.name,
                f.slices_repaired,
                f.path.display()
            );
        }
    }

    if plan.dry_run {
        println!(
            "\nDry run: {} file(s) would be repaired.",
            plan.repaired_files.len()
        );
    } else {
        println!(
            "\n{} file(s) repaired successfully.",
            plan.repaired_files.len()
        );
    }

    Ok(())
}

fn print_json_repair_plan(plan: &repair::RepairPlan) {
    let mut out = String::from("{\"repaired_files\":[");
    for (i, f) in plan.repaired_files.iter().enumerate() {
        if i > 0 {
            out.push(',');
        }
        out.push_str(&format!(
            "{{\"name\":{},\"path\":{},\"slices_repaired\":{},\"verified\":{}}}",
            json_string(&f.name),
            json_string(&f.path.display().to_string()),
            f.slices_repaired,
            f.verified
        ));
    }
    out.push_str(&format!(
        "],\"dry_run\":{},\"needed_repair\":true}}",
        plan.dry_run
    ));
    println!("{out}");
}

fn print_json_report(report: &VerifyReport) {
    let mut out = String::from("{\"files\":[");
    for (i, f) in report.files.iter().enumerate() {
        if i > 0 {
            out.push(',');
        }
        let status = match f.status {
            FileStatus::Ok => "ok",
            FileStatus::Damaged => "damaged",
            FileStatus::Missing => "missing",
        };
        out.push_str(&format!(
            "{{\"name\":{},\"status\":\"{}\",\"total_slices\":{},\"bad_slices\":{}}}",
            json_string(&f.name),
            status,
            f.total_slices,
            f.bad_slices
        ));
    }
    out.push_str(&format!(
        "],\"available_recovery_blocks\":{},\"repairable\":{},\"ok\":{}}}",
        report.available_recovery_blocks,
        report.is_repairable(),
        report.is_ok()
    ));
    println!("{out}");
}

fn json_string(s: &str) -> String {
    let mut out = String::with_capacity(s.len() + 2);
    out.push('"');
    for c in s.chars() {
        match c {
            '"' => out.push_str("\\\""),
            '\\' => out.push_str("\\\\"),
            '\n' => out.push_str("\\n"),
            '\r' => out.push_str("\\r"),
            '\t' => out.push_str("\\t"),
            c if (c as u32) < 0x20 => out.push_str(&format!("\\u{:04x}", c as u32)),
            c => out.push(c),
        }
    }
    out.push('"');
    out
}