feat!: report hardlinks to progress

Author: KSXGitHub

src/app.rs

@@ -180,18 +180,24 @@ impl App {
             }
         }
 
-        trait HardlinkDeduplicationSystem<const DEDUPLICATE_HARDLINKS: bool>: GetSizeUtils {
-            type Hook: hook::Hook<Self::Size> + sub::DeduplicateHardlinkSizes<Self::Size>;
+        trait HardlinkDeduplicationSystem<
+            const DEDUPLICATE_HARDLINKS: bool,
+            const REPORT_PROGRESS: bool,
+        >: CreateReporter<REPORT_PROGRESS>
+        {
+            type Hook: hook::Hook<Self::Size, Self::Reporter>
+                + sub::DeduplicateHardlinkSizes<Self::Size>;
             fn create_hook(
                 record: <Self::Hook as sub::DeduplicateHardlinkSizes<Self::Size>>::HardlinkRecord,
             ) -> Self::Hook;
             fn init_hardlink_record(
             ) -> <Self::Hook as sub::DeduplicateHardlinkSizes<Self::Size>>::HardlinkRecord;
         }
 
-        impl<SizeGetter> HardlinkDeduplicationSystem<false> for SizeGetter
+        impl<const REPORT_PROGRESS: bool, SizeGetter>
+            HardlinkDeduplicationSystem<false, REPORT_PROGRESS> for SizeGetter
         where
-            SizeGetter: GetSizeUtils,
+            SizeGetter: CreateReporter<REPORT_PROGRESS>,
             SizeGetter::Size: Send + Sync,
         {
             type Hook = hook::DoNothing;
@@ -202,10 +208,12 @@ impl App {
         }
 
         #[cfg(unix)]
-        impl<SizeGetter> HardlinkDeduplicationSystem<true> for SizeGetter
+        impl<const REPORT_PROGRESS: bool, SizeGetter>
+            HardlinkDeduplicationSystem<true, REPORT_PROGRESS> for SizeGetter
         where
-            SizeGetter: GetSizeUtils,
+            SizeGetter: CreateReporter<REPORT_PROGRESS>,
             SizeGetter::Size: Send + Sync + 'static,
+            SizeGetter::Reporter: crate::reporter::Reporter<SizeGetter::Size>,
         {
             type Hook = hook::RecordHardLink<'static, Self::Size>;
             fn create_hook(record: &'static hook::RecordHardLinkStorage<Self::Size>) -> Self::Hook {
@@ -239,8 +247,8 @@ impl App {
                     ..
                 } => {
                     const DEDUPLICATE_HARDLINKS: bool = cfg!(unix) && $deduplicate_hardlinks;
-                    let hardlink_record = <$size_getter as HardlinkDeduplicationSystem<DEDUPLICATE_HARDLINKS>>::init_hardlink_record();
-                    let hook = <$size_getter as HardlinkDeduplicationSystem<DEDUPLICATE_HARDLINKS>>::create_hook(hardlink_record);
+                    let hardlink_record = <$size_getter as HardlinkDeduplicationSystem<DEDUPLICATE_HARDLINKS, $progress>>::init_hardlink_record();
+                    let hook = <$size_getter as HardlinkDeduplicationSystem<DEDUPLICATE_HARDLINKS, $progress>>::create_hook(hardlink_record);
 
                     Sub {
                         direction: Direction::from_top_down(top_down),

src/app/sub.rs

@@ -21,7 +21,7 @@ where
     Report: ParallelReporter<Size> + Sync,
     Size: size::Size + Into<u64> + Serialize + Send + Sync,
     SizeGetter: GetSize<Size = Size> + Copy + Sync,
-    Hook: hook::Hook<Size> + DeduplicateHardlinkSizes<Size> + Copy + Sync,
+    Hook: hook::Hook<Size, Report> + DeduplicateHardlinkSizes<Size> + Copy + Sync,
     DataTreeReflection<String, Size>: Into<UnitAndTree>,
 {
     /// List of files and/or directories.
@@ -57,7 +57,7 @@ where
     Size: size::Size + Into<u64> + Serialize + Send + Sync,
     Report: ParallelReporter<Size> + Sync,
     SizeGetter: GetSize<Size = Size> + Copy + Sync,
-    Hook: hook::Hook<Size> + DeduplicateHardlinkSizes<Size> + Copy + Sync,
+    Hook: hook::Hook<Size, Report> + DeduplicateHardlinkSizes<Size> + Copy + Sync,
     DataTreeReflection<String, Size>: Into<UnitAndTree>,
 {
     /// Run the sub program.

src/fs_tree_builder.rs

@@ -31,18 +31,18 @@ use std::{
 ///     root: std::env::current_dir().unwrap(),
 ///     hook: hook::DoNothing,
 ///     size_getter: GetApparentSize,
-///     reporter: ErrorOnlyReporter::new(ErrorReport::SILENT),
+///     reporter: &ErrorOnlyReporter::new(ErrorReport::SILENT),
 ///     max_depth: 10,
 /// };
 /// let data_tree: DataTree<OsStringDisplay, Bytes> = builder.into();
 /// ```
 #[derive(Debug)]
-pub struct FsTreeBuilder<Size, SizeGetter, Hook, Report>
+pub struct FsTreeBuilder<'a, Size, SizeGetter, Hook, Report>
 where
-    Report: Reporter<Size> + Sync,
+    Report: Reporter<Size> + Sync + ?Sized,
     Size: size::Size + Send + Sync,
     SizeGetter: GetSize<Size = Size> + Sync,
-    Hook: hook::Hook<Size> + Sync,
+    Hook: hook::Hook<Size, Report> + Sync,
 {
     /// Root of the directory tree.
     pub root: PathBuf,
@@ -51,18 +51,18 @@ where
     /// Hook to run after [`Self::size_getter`].
     pub hook: Hook,
     /// Reports progress to external system.
-    pub reporter: Report,
+    pub reporter: &'a Report,
     /// Deepest level of descendent display in the graph. The sizes beyond the max depth still count toward total.
     pub max_depth: u64,
 }
 
-impl<Size, SizeGetter, Hook, Report> From<FsTreeBuilder<Size, SizeGetter, Hook, Report>>
+impl<'a, Size, SizeGetter, Hook, Report> From<FsTreeBuilder<'a, Size, SizeGetter, Hook, Report>>
     for DataTree<OsStringDisplay, Size>
 where
-    Report: Reporter<Size> + Sync,
+    Report: Reporter<Size> + Sync + ?Sized,
     Size: size::Size + Send + Sync,
     SizeGetter: GetSize<Size = Size> + Sync,
-    Hook: hook::Hook<Size> + Sync,
+    Hook: hook::Hook<Size, Report> + Sync,
 {
     /// Create a [`DataTree`] from an [`FsTreeBuilder`].
     fn from(builder: FsTreeBuilder<Size, SizeGetter, Hook, Report>) -> Self {
@@ -97,7 +97,7 @@ where
                         let is_dir = stats.is_dir();
                         let size = size_getter.get_size(&stats);
                         reporter.report(Event::ReceiveData(size));
-                        hook.run_hook(HookArgument::new(path, &stats, size));
+                        hook.run_hook(HookArgument::new(path, &stats, size, reporter));
                         (is_dir, size)
                     }
                 };

src/hook.rs

@@ -2,28 +2,39 @@ use std::{fs::Metadata, path::Path};
 
 /// Argument to pass to [`Hook::run_hook`].
 #[derive(Debug, Clone, Copy)]
-pub struct HookArgument<'a, Size> {
+pub struct HookArgument<'a, Size, Report: ?Sized> {
     pub path: &'a Path,
     pub stats: &'a Metadata,
     pub size: Size,
+    pub reporter: &'a Report,
 }
 
-impl<'a, Size> HookArgument<'a, Size> {
-    pub(crate) fn new(path: &'a Path, stats: &'a Metadata, size: Size) -> Self {
-        HookArgument { path, stats, size }
+impl<'a, Size, Report: ?Sized> HookArgument<'a, Size, Report> {
+    pub(crate) fn new(
+        path: &'a Path,
+        stats: &'a Metadata,
+        size: Size,
+        reporter: &'a Report,
+    ) -> Self {
+        HookArgument {
+            path,
+            stats,
+            size,
+            reporter,
+        }
     }
 }
 
 /// Hook to run with a [`Path`] and its corresponding [`Metadata`] and size.
-pub trait Hook<Size> {
-    fn run_hook(&self, argument: HookArgument<Size>);
+pub trait Hook<Size, Reporter: ?Sized> {
+    fn run_hook(&self, argument: HookArgument<Size, Reporter>);
 }
 
 /// A [hook](Hook) that does nothing.
 #[derive(Debug, Clone, Copy)]
 pub struct DoNothing;
-impl<Size> Hook<Size> for DoNothing {
-    fn run_hook(&self, _: HookArgument<Size>) {}
+impl<Size, Reporter> Hook<Size, Reporter> for DoNothing {
+    fn run_hook(&self, _: HookArgument<Size, Reporter>) {}
 }
 
 // `RecordHardlink` is POSIX-exclusive, because whilst Windows does have `MetadataExt::number_of_links`, it requires Nightly.

src/hook/record_hardlink.rs

@@ -1,4 +1,8 @@
 use super::{Hook, HookArgument};
+use crate::{
+    reporter::{event::EncounterHardlink, Event, Reporter},
+    size,
+};
 use dashmap::DashMap;
 use std::{fmt::Debug, os::unix::fs::MetadataExt, path::PathBuf};
 
@@ -19,14 +23,35 @@ impl<'a, Size> RecordHardLink<'a, Size> {
     }
 }
 
-impl<'a, Size: Eq + Debug> Hook<Size> for RecordHardLink<'a, Size> {
-    fn run_hook(&self, argument: HookArgument<Size>) {
-        let HookArgument { path, stats, size } = argument;
+impl<'a, Size, Report> Hook<Size, Report> for RecordHardLink<'a, Size>
+where
+    Size: size::Size + Eq + Debug,
+    Report: Reporter<Size> + ?Sized,
+{
+    fn run_hook(&self, argument: HookArgument<Size, Report>) {
+        let HookArgument {
+            path,
+            stats,
+            size,
+            reporter,
+        } = argument;
 
-        if stats.is_dir() || stats.nlink() <= 1 {
+        if stats.is_dir() {
             return;
         }
 
+        let links = stats.nlink();
+        if links <= 1 {
+            return;
+        }
+
+        reporter.report(Event::EncounterHardlink(EncounterHardlink {
+            path,
+            stats,
+            size,
+            links,
+        }));
+
         self.storage
             .entry(stats.ino())
             .and_modify(|(expected_size, paths)| {

src/reporter.rs

@@ -29,7 +29,7 @@ pub trait ParallelReporter<Size: size::Size>: Reporter<Size> {
 impl<Size, Target> Reporter<Size> for &Target
 where
     Size: size::Size,
-    Target: Reporter<Size>,
+    Target: Reporter<Size> + ?Sized,
 {
     fn report(&self, event: Event<Size>) {
         Target::report(*self, event)

src/reporter/event.rs

@@ -1,9 +1,24 @@
 use super::ErrorReport;
 use crate::size;
+use std::{fs::Metadata, path::Path};
 
 /// Report trigger event.
 #[derive(Debug)]
 pub enum Event<'a, Size: size::Size> {
     ReceiveData(Size),
     EncounterError(ErrorReport<'a>),
+    EncounterHardlink(EncounterHardlink<'a, Size>),
+}
+
+/// Data of [`Event::EncounterHardlink`].
+#[derive(Debug, Clone, Copy)]
+pub struct EncounterHardlink<'a, Size: size::Size> {
+    /// Path of the detected hardlink.
+    pub path: &'a Path,
+    /// Stats of the detected hardlink.
+    pub stats: &'a Metadata,
+    /// Size of the file.
+    pub size: Size,
+    /// Number of links, including this one.
+    pub links: u64,
 }

src/reporter/progress_and_error_reporter.rs

@@ -98,6 +98,10 @@ where
                 report_error(error_report);
                 bump!(errors += 1);
             }
+            EncounterHardlink(info) => {
+                bump!(linked += info.links);
+                bump!(shared += info.size.into());
+            }
         }
     }
 }

src/reporter/progress_and_error_reporter/progress_report_state.rs

@@ -15,6 +15,10 @@ pub struct ProgressReportState {
     pub total: AtomicU64,
     /// Number of occurred errors.
     pub errors: AtomicU64,
+    /// Total number of detected hardlinks.
+    pub linked: AtomicU64,
+    /// Total size of detected hardlinks.
+    pub shared: AtomicU64,
 }
 
 impl ProgressReportState {
@@ -38,10 +42,14 @@ impl ProgressReportState {
         let items = load!(items);
         let total = load!(total).into();
         let errors = load!(errors);
+        let linked = load!(linked);
+        let shared = load!(shared);
         ControlFlow::Continue(ProgressReport {
             items,
             total,
             errors,
+            linked,
+            shared,
         })
     }
 }

src/reporter/progress_report.rs

@@ -10,6 +10,10 @@ pub struct ProgressReport<Size: size::Size> {
     pub total: Size,
     /// Number of occurred errors.
     pub errors: u64,
+    /// Total number of detected hardlinks.
+    pub linked: u64,
+    /// Total size of detected hardlinks.
+    pub shared: u64,
 }
 
 impl<Size: size::Size + Into<u64>> ProgressReport<Size> {
@@ -19,6 +23,8 @@ impl<Size: size::Size + Into<u64>> ProgressReport<Size> {
             items,
             total,
             errors,
+            linked,
+            shared,
         } = report;
         let mut text = String::new();
         write!(
@@ -31,6 +37,12 @@ impl<Size: size::Size + Into<u64>> ProgressReport<Size> {
         if errors != 0 {
             write!(text, ", erred {errors}").unwrap();
         }
+        if linked != 0 {
+            write!(text, ", linked {linked}").unwrap();
+        }
+        if shared != 0 {
+            write!(text, ", shared {shared}").unwrap();
+        }
         write!(text, ")").unwrap();
         GLOBAL_STATUS_BOARD.temporary_message(&text);
     };