File Coverage

lib/App/dupfind/App.pm

Criterion	Covered	Total	%
statement	26	28	92.8
branch			n/a
condition			n/a
subroutine	9	9	100.0
pod			n/a
total	35	37	94.5

# ABSTRACT: This is the application that gets run() by $bin/dupfind

use strict;
use warnings;

package App::dupfind::App;
{
  $App::dupfind::App::VERSION = '0.140230'; # TRIAL
}

BEGIN { select STDERR; $|++; select STDOUT; $|++; }

use 5.010;

use Getopt::Long;
use Benchmark ':hireswallclock';

use lib 'lib';

use App::dupfind;
use App::dupfind::Threaded;

use Moo;

exit run() unless caller;

has opts =>
(
   is       => 'rw',
   required => 1,
   builder  => '_build_opts'
);

has metrics =>
(
   is       => 'rw',
   required => 1,
   builder  => sub
   {
      {
         scan_count     => 0,
         size_dup_count => 0,
         real_dup_count => 0,
      }
   }
);

has benchmarks =>
(
   is       => 'rw',
   required => 1,
   builder  => sub
   {
      {
         scanfs   => { },
         prune    => { },
         weed     => { },
         digest   => { },
         remove   => { },
         run      => { },
      }
   }
);

has deduper =>
(
   is       => 'ro',
   required => 1,
   lazy     => 1,
   builder  => sub
   {
      my $self    = shift;
      my $ddclass = $self->opts->{threads}
         ? 'App::dupfind::Threaded'
         : 'App::dupfind';

      $ddclass->new( opts => $self->opts );
   }
);


sub BUILD
{
   my $self = shift;
   my $opts = $self->opts;

   $opts->{threads} //= 0;

   $opts->{progress}  = 1 if $opts->{verbose};

   $opts->{remove}    = 1 if $opts->{prompt};

   $opts->{weed}      = 0 if $opts->{weed} =~ /^(n|no)$/i;

   $opts->{weed}      = 1 if !! @{ $opts->{wpass} };

   $opts->{wpass}     = [ 'first_middle_last' ]
      if $opts->{weed} && ! @{ $opts->{wpass} };

   die 'Bogus cache parameters provided!  Just use the defaults buddy.'
      if $opts->{cachestop} < 0 || $opts->{ramcache} < 0;

   die 'Invalid cachestop size; must be a small fraction of total ramcache.'
      if $opts->{ramcache} && $opts->{cachestop} > ( $opts->{ramcache} / 100 );

   $opts->{cachesize} = int ( $opts->{ramcache} / $opts->{cachestop} );
}

sub _build_opts
{
   my $self = shift;

   my $opts =
   {
      bytes     => 1024 ** 3,           # 1 GB max read
      cachestop => ( 1024 ** 2 ) * 2,   # 2 MB file size limit on cache candidacy
      dir       => undef,
      format    => 'human',             # options are "human" or "robot"
      help      => undef,
      links     => 0,
      maxdepth  => 50,
      progress  => 0,
      prompt    => 0,
      quiet     => 0,
      ramcache  => ( 1024 ** 2 ) * 300, # 300 MB default cache size
      remove    => 0,
      threads   => 0,
      verbose   => 0,
      weed      => 1,
      wpass     => [ ],
      wpsize    => 32,
   };

   GetOptions
   (
      'bytes|b=i'    => \$opts->{bytes},
      'cachestop=i'  => \$opts->{cachestop},
      'dir|d=s'      => \$opts->{dir},
      'format|f=s'   => \$opts->{format},
      'help|h|?'     => \$opts->{help},
      'links|l'      => \$opts->{links},
      'maxdepth|m=i' => \$opts->{maxdepth},
      'progress'     => \$opts->{progress},
      'prompt|p'     => \$opts->{prompt},
      'quiet|q'      => \$opts->{quiet},
      'ramcache=i'   => \$opts->{ramcache},
      'remove|x'     => \$opts->{remove},
      'threads|t=i'  => \$opts->{threads},
      'verbose|v'    => \$opts->{verbose},
      'weedout|w=s'  => \$opts->{weed},
      'wpass=s'      =>  $opts->{wpass},
      'wpsize=i'     => \$opts->{wpsize},
   ) or exit _usage();

   exit _usage() unless defined $opts->{dir};

   return $opts;
}

sub _usage
{
   # This is just the help message:

   require Pod::Usage;

   Pod::Usage::pod2usage( { -exitval => 1, -verbose => 2 } )
}

sub _bench_this
{
   my ( $self, $mark, $event ) = @_;

   $self->benchmarks->{ $mark }->{ $event } = Benchmark->new();
}

sub _calculate_bench_times
{
   my $self       = shift;
   my $benchmarks = $self->benchmarks;

   for my $mark ( keys %$benchmarks )
   {
      next unless $benchmarks->{ $mark }->{start};

      $self->benchmarks->{ $mark }->{result} =
         timestr timediff
         (
            $benchmarks->{ $mark }->{end},
            $benchmarks->{ $mark }->{start}
         );
   }

   $self->benchmarks->{weed}->{result}   ||= 'did not weed';
   $self->benchmarks->{remove}->{result} ||= 'no deletions';
}

sub _run_summary
{
   my $self        = shift;
   my $opts        = $self->opts;
   my $benchmarks  = $self->benchmarks;
   my $metrics     = $self->metrics;

   my ( $cache_hits, $cache_misses ) = $self->deduper->cache_stats;

   $self->_stderr( <<__SUMMARY__ );
------------------------------
** THREADS...............$opts->{threads}
** RAM CACHE.............$opts->{ramcache} bytes
** CACHE HITS/MISSES.....$cache_hits/$cache_misses
** TOTAL FILES SCANNED...$metrics->{scan_count}
** TOTAL SAME SIZE.......$metrics->{size_dup_count}
** TOTAL ACTUAL DUPES....$metrics->{real_dup_count}
      -- TIMES --
** TREE SCAN TIME........$benchmarks->{scanfs}->{result}
** HARDLINK PRUNE TIME...$benchmarks->{prune}->{result}
** WEED-OUT TIME.........$benchmarks->{weed}->{result}
** CRYPTO-HASHING TIME...$benchmarks->{digest}->{result}
** DELETION TIME.........$benchmarks->{remove}->{result}
** TOTAL RUN TIME........$benchmarks->{run}->{result}
__SUMMARY__
}

sub run
{
   my $self = __PACKAGE__->new();

   $self->_bench_this( run => 'start' );

   my( $size_dups, $pruned_dups, $weeded_dups, $digest_dups );

   $size_dups   = $self->scanfs;

   $pruned_dups = $self->prune( $size_dups );

   $weeded_dups = $self->weed( $pruned_dups ) if $self->opts->{weed};

   $digest_dups = $self->digest( $weeded_dups // $pruned_dups );

   $self->metrics->{real_dup_count} = $self->deduper->count_dups( $digest_dups );

   $self->_stderr( '** DISPLAYING OUTPUT', '-' x 30 );

   $self->deduper->show_dups( $digest_dups );

   $self->remove( $digest_dups ) if $self->opts->{remove};

   $self->_bench_this( run => 'end' );

   $self->_calculate_bench_times;

   $self->_run_summary;
}

sub scanfs
{
   my $self = shift;

   $self->_stderr( '** SCANNING ALL FILES FOR SIZE DUPLICATES' );

   $self->_bench_this( scanfs => 'start' );

   my ( $size_dups, $scan_ct, $size_dup_ct ) = $self->deduper->get_size_dups();

   $self->metrics->{scan_count}     = $scan_ct;

   $self->metrics->{size_dup_count} = $size_dup_ct;

   $self->_bench_this( scanfs => 'end' );

   say '** NO DUPLICATES FOUND' and exit unless keys %$size_dups;

   return $size_dups;
}

sub prune
{
   my ( $self, $size_dups ) = @_;

   $self->_stderr( '** PRUNING HARD LINKS' );

   $self->_bench_this( prune => 'start' );

   $size_dups = $self->deduper->toss_out_hardlinks( $size_dups );

   $self->_bench_this( prune => 'end' );

   say '** NO DUPLICATES FOUND' and exit unless keys %$size_dups;

   return $size_dups;
}

sub weed
{
   my ( $self, $size_dups ) = @_;

   $self->_stderr( '** WEEDING-OUT FILES THAT ARE OBVIOUSLY DIFFERENT' );

   $self->_bench_this( weed => 'start' );

   my $weeded_dups = $self->deduper->weed_dups( $size_dups );

   $self->_bench_this( weed => 'end' );

   say '** NO DUPLICATES FOUND' and exit unless keys %$weeded_dups;

   return $weeded_dups;
}

sub digest
{
   my ( $self, $size_dups ) = @_;

   $self->_stderr( '** CHECKSUMMING SIZE DUPLICATES' );

   $self->_bench_this( digest => 'start' );

   my $digest_dups = $self->deduper->digest_dups( $size_dups );

   $self->_bench_this( digest => 'end' );

   say '** NO DUPLICATES FOUND' and exit unless keys %$digest_dups;

   return $digest_dups;
}

sub remove
{
   my ( $self, $digests ) = @_;

   $self->_bench_this( remove => 'start' );

   $self->deduper->delete_dups( $digests );

   $self->_bench_this( remove => 'end' );
}

sub _stderr { return if shift->opts->{quiet}; warn "$_\n" for @_ };

__PACKAGE__->meta->make_immutable;

1;

__END__