Make the Rust implementation the only one: crate at the root, Go tree removed
This commit is contained in:
Andy Dixon
+216
@@ -0,0 +1,216 @@
|
||||
//! Wires the command-line modes together: interactive TUI, non-interactive
|
||||
//! reports, snapshots and comparisons. TUI and CLI share the same scanner
|
||||
//! and inventory.
|
||||
|
||||
use crate::cancel::Cancel;
|
||||
use crate::config::Settings;
|
||||
use crate::inventory::{Kind, SizeMode, Tree, FLAG_HARDLINK_DUP};
|
||||
use crate::scan::{self, Scanner};
|
||||
use crate::{duplicate, export, snapshot, textutil, tui, Error};
|
||||
use std::io::{IsTerminal, Write};
|
||||
use std::path::Path;
|
||||
use std::sync::{Arc, RwLock};
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
/// The fully-resolved command line.
|
||||
pub struct Config {
|
||||
pub paths: Vec<String>,
|
||||
pub scan_opts: scan::Options,
|
||||
pub no_ui: bool,
|
||||
pub json: bool,
|
||||
pub csv: bool,
|
||||
pub depth: i64,
|
||||
pub top: usize,
|
||||
pub largest_files: usize,
|
||||
pub save: String,
|
||||
pub load: String,
|
||||
pub compare: Option<(String, String)>,
|
||||
pub duplicates: bool,
|
||||
pub read_only: bool,
|
||||
pub theme: String,
|
||||
pub size_mode: SizeMode,
|
||||
pub mouse: bool,
|
||||
pub color: String,
|
||||
pub settings: Settings,
|
||||
}
|
||||
|
||||
impl Config {
|
||||
pub fn new(settings: Settings) -> Config {
|
||||
Config {
|
||||
paths: Vec::new(), scan_opts: Default::default(), no_ui: false, json: false, csv: false, depth: -1,
|
||||
top: 0, largest_files: 0, save: String::new(), load: String::new(), compare: None, duplicates: false,
|
||||
read_only: false, theme: settings.theme.clone(), size_mode: SizeMode::Allocated, mouse: settings.mouse,
|
||||
color: "auto".into(), settings,
|
||||
}
|
||||
}
|
||||
|
||||
/// Whether any non-interactive output was requested.
|
||||
pub fn report(&self) -> bool {
|
||||
self.no_ui || self.json || self.csv || self.top > 0 || self.largest_files > 0 || self.duplicates
|
||||
}
|
||||
}
|
||||
|
||||
/// Executes the configured mode.
|
||||
pub fn run(cfg: Config) -> Result<(), Error> {
|
||||
if cfg.compare.is_some() {
|
||||
return run_compare(cfg);
|
||||
}
|
||||
if !cfg.report() {
|
||||
return run_tui(cfg);
|
||||
}
|
||||
run_report(cfg)
|
||||
}
|
||||
|
||||
/// Begins a scan (or loads a snapshot). The scanner is None when the tree
|
||||
/// came from a snapshot.
|
||||
fn start_source(cancel: Cancel, load: &str, paths: &[String], opts: &scan::Options) -> Result<(Option<Scanner>, Arc<RwLock<Tree>>), Error> {
|
||||
if !load.is_empty() {
|
||||
return Ok((None, Arc::new(RwLock::new(snapshot::load_file(Path::new(load))?))));
|
||||
}
|
||||
let root = paths.first().map_or(".", |s| s.as_str());
|
||||
let s = scan::start(root.as_bytes(), opts.clone(), cancel)?;
|
||||
let t = s.tree.clone();
|
||||
Ok((Some(s), t))
|
||||
}
|
||||
|
||||
/// Cancels on SIGINT for report mode, like Go's signal.NotifyContext.
|
||||
fn interrupt_cancel() -> Cancel {
|
||||
static CANCEL: std::sync::OnceLock<Cancel> = std::sync::OnceLock::new();
|
||||
extern "C" fn on_sigint(_: libc::c_int) {
|
||||
if let Some(c) = CANCEL.get() {
|
||||
// Only an atomic store happens here; the channel drop is deferred.
|
||||
c.cancel_flag_only();
|
||||
}
|
||||
}
|
||||
let c = CANCEL.get_or_init(Cancel::new).clone();
|
||||
unsafe { libc::signal(libc::SIGINT, on_sigint as libc::sighandler_t) };
|
||||
c
|
||||
}
|
||||
|
||||
fn run_report(cfg: Config) -> Result<(), Error> {
|
||||
let cancel = interrupt_cancel();
|
||||
let (s, tree) = start_source(cancel.clone(), &cfg.load, &cfg.paths, &cfg.scan_opts)?;
|
||||
if let Some(s) = &s {
|
||||
wait_with_progress(s, &cancel);
|
||||
}
|
||||
let mut out = std::io::stdout().lock();
|
||||
if cfg.duplicates && !cfg.json && !cfg.csv {
|
||||
// find takes its own read lock; never nest read locks.
|
||||
run_duplicates(&mut out, &cancel, &tree)?;
|
||||
}
|
||||
let t = tree.read().unwrap();
|
||||
if s.is_some() && !cfg.save.is_empty() {
|
||||
snapshot::save_file(Path::new(&cfg.save), &t)?;
|
||||
eprintln!("Saved snapshot {}", cfg.save);
|
||||
}
|
||||
if cfg.json {
|
||||
return Ok(export::json(&mut out, &t, t.root(), cfg.depth)?);
|
||||
}
|
||||
if cfg.csv {
|
||||
return Ok(export::csv(&mut out, &t, t.root(), cfg.depth)?);
|
||||
}
|
||||
if cfg.top > 0 {
|
||||
let mut ids = t.sorted_children(t.root(), cfg.size_mode);
|
||||
ids.truncate(cfg.top);
|
||||
export::table(&mut out, &t, &ids, cfg.size_mode)?;
|
||||
writeln!(out)?;
|
||||
}
|
||||
if cfg.largest_files > 0 {
|
||||
let m = cfg.size_mode;
|
||||
let ids = t.top(t.root(), cfg.largest_files, |n| n.kind == Kind::File && n.flags & FLAG_HARDLINK_DUP == 0, |n| n.own(m));
|
||||
export::table(&mut out, &t, &ids, m)?;
|
||||
writeln!(out)?;
|
||||
}
|
||||
export::summary(&mut out, &t)?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Blocks until the scan finishes, printing a progress line to stderr if it
|
||||
/// is a terminal.
|
||||
fn wait_with_progress(s: &Scanner, cancel: &Cancel) {
|
||||
let tty = std::io::stderr().is_terminal();
|
||||
let start = Instant::now();
|
||||
let mut forwarded = false;
|
||||
loop {
|
||||
match s.done().recv_timeout(Duration::from_millis(250)) {
|
||||
Err(crossbeam_channel::RecvTimeoutError::Timeout) => {}
|
||||
_ => {
|
||||
if tty {
|
||||
eprint!("\r\x1b[K");
|
||||
}
|
||||
return;
|
||||
}
|
||||
}
|
||||
if cancel.is_cancelled() && !forwarded {
|
||||
cancel.cancel(); // complete the signal-handler cancellation
|
||||
forwarded = true;
|
||||
}
|
||||
if tty {
|
||||
let p = s.progress();
|
||||
let el = start.elapsed();
|
||||
eprint!(
|
||||
"\r\x1b[Kscanning… {} entries {}/s queue {} {}",
|
||||
textutil::count(p.entries),
|
||||
textutil::count((p.entries as f64 / el.as_secs_f64()) as i64),
|
||||
p.pending,
|
||||
textutil::duration(el)
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn run_tui(cfg: Config) -> Result<(), Error> {
|
||||
let (load, paths, opts) = (cfg.load.clone(), cfg.paths.clone(), cfg.scan_opts.clone());
|
||||
tui::run(tui::Options {
|
||||
read_only: cfg.read_only, theme: cfg.theme, size_mode: cfg.size_mode, mouse: cfg.mouse, color: cfg.color,
|
||||
save: cfg.save, settings: cfg.settings, diff: None,
|
||||
start: Arc::new(move |c| start_source(c, &load, &paths, &opts)),
|
||||
})
|
||||
}
|
||||
|
||||
fn run_compare(cfg: Config) -> Result<(), Error> {
|
||||
let (a, b) = cfg.compare.clone().unwrap();
|
||||
let old = snapshot::load_file(Path::new(&a)).map_err(|e| format!("{a}: {e}"))?;
|
||||
let nw = snapshot::load_file(Path::new(&b)).map_err(|e| format!("{b}: {e}"))?;
|
||||
let d = snapshot::compare(old, &nw);
|
||||
if !cfg.report() {
|
||||
let tree = Arc::new(RwLock::new(nw));
|
||||
return tui::run(tui::Options {
|
||||
read_only: true, theme: cfg.theme, size_mode: cfg.size_mode, mouse: cfg.mouse, color: cfg.color,
|
||||
save: String::new(), settings: cfg.settings, diff: Some(d),
|
||||
start: Arc::new(move |_| Ok((None, tree.clone()))),
|
||||
});
|
||||
}
|
||||
let k = if cfg.top > 0 { cfg.top } else { 30 };
|
||||
let m = cfg.size_mode;
|
||||
let mut out = std::io::stdout().lock();
|
||||
let (ro, rn) = (d.old.node(0), nw.node(0));
|
||||
writeln!(out, "{} → {}", textutil::sanitize(&d.old.stats.from_snapshot), textutil::sanitize(&nw.stats.from_snapshot))?;
|
||||
writeln!(out, "Total {} → {} ({})\n", textutil::size(ro.total(m)), textutil::size(rn.total(m)), textutil::signed_size(rn.total(m) - ro.total(m)))?;
|
||||
for c in d.changes(&nw, k, m) {
|
||||
writeln!(out, "{:<10} {:>14} {}", c.status.name(), textutil::signed_size(c.delta), textutil::sanitize(&c.path))?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn run_duplicates(out: &mut dyn Write, cancel: &Cancel, tree: &RwLock<Tree>) -> Result<(), Error> {
|
||||
let f = duplicate::Finder::default();
|
||||
let groups = f.find(cancel, tree, duplicate::Options { min_size: 1, workers: 0 }).ok_or("cancelled")?;
|
||||
let t = tree.read().unwrap();
|
||||
let mut wasted = 0;
|
||||
for g in &groups {
|
||||
wasted += g.wasted();
|
||||
let h: String = g.hash[..6].iter().map(|b| format!("{b:02x}")).collect();
|
||||
writeln!(out, "{} × {} (sha256 {h}…)", textutil::size(g.size), g.files.len())?;
|
||||
for &id in &g.files {
|
||||
writeln!(out, " {}", textutil::sanitize_bytes(&t.path_bytes(id)))?;
|
||||
}
|
||||
}
|
||||
let p = f.progress();
|
||||
writeln!(
|
||||
out,
|
||||
"\n{} verified duplicate groups, {} reclaimable ({} candidates by size, {} unreadable/changed)\n",
|
||||
groups.len(), textutil::size(wasted), p.candidates, p.skipped
|
||||
)?;
|
||||
Ok(())
|
||||
}
|
||||
Reference in New Issue
Block a user