[BACK]Return to CurrentTorrents.pl CVS log [TXT][DIR] Up to [local] / openbsd / OpenBSDTorrents

Diff for /openbsd/OpenBSDTorrents/CurrentTorrents.pl between version 1.14 and 1.37

version 1.14, 2005/05/04 01:11:59 version 1.37, 2010/03/16 23:40:18
Line 1 
Line 1 
 #!/usr/bin/perl -T  #!/usr/bin/perl -T
 #$Id$  #$RedRiver: CurrentTorrents.pl,v 1.36 2010/03/16 22:37:32 andrew Exp $
 use strict;  use strict;
 use warnings;  use warnings;
 use diagnostics;  use diagnostics;
   
 use Time::Local;  use Time::Local;
   use Fcntl ':flock';
   use File::Basename;
   
   use Transmission::Client;
   use Transmission::Utils;
   
   #use YAML;
   
 use lib 'lib';  use lib 'lib';
 use OpenBSDTorrents;  use OpenBSDTorrents;
 use BT::OBTMetaInfo;  use BT::MetaInfo::Cached;
   
 %ENV = ();  %ENV = ();
   
 use YAML;  #justme();
   
 justme();  
   
 my $Name_Filter = shift || '';  my $Name_Filter = shift || '';
 if ($Name_Filter =~ /^(\w*)$/) {  if ( $Name_Filter =~ /^(\w*)$/ ) {
         $Name_Filter = $1;      $Name_Filter = $1;
 } else {  
         die "Invalid filter: $Name_Filter";  
 }  }
   else {
       die "Invalid filter: $Name_Filter";
   }
   
   my %Possible_Torrents;
   Process_Dir( $OBT->{DIR_FTP} );
   
 my %files;  my %files;
 foreach my $DIR ($OBT->{DIR_NEW_TORRENT}, $OBT->{DIR_TORRENT}) {  my @delete;
         opendir DIR, $DIR  foreach my $DIR ( $OBT->{DIR_NEW_TORRENT}, $OBT->{DIR_TORRENT} ) {
                 or die "Couldn't opendir $DIR: $!";      opendir DIR, $DIR
         foreach (readdir DIR) {          or die "Couldn't opendir $DIR: $!";
                 next unless my ($ext) = /\.(torrent|$OBT->{META_EXT})$/;      foreach ( readdir DIR ) {
           next unless my ($ext) = /\.(torrent|$OBT->{META_EXT})$/;
   
                 if (/^([^\/]+)$/) {          if (/^([^\/]+)$/) {
                         $_ = $1;              $_ = $1;
                 } else {          }
                         die "Invalid character in $_: $!";          else {
                 }              die "Invalid character in $_: $!";
                 my ($name, $year, $mon, $mday, $hour, $min) =          }
                    /^(.*)-(\d{4})-(\d{2})-(\d{2})-(\d{2})(\d{2})/;          my $epoch = 0;
           my $name = basename( $_, '.torrent' );
   
                 $mon--;          if ( my ( $base, $year, $mon, $mday, $hour, $min )
                 my $epoch = timegm(0,$min,$hour,$mday,$mon,$year);              = /^(.*)-(\d{4})-(\d{2})-(\d{2})-(\d{2})(\d{2})/ )
           {
   
                 #print "Adding $_\n";              $mon--;
               $epoch = timegm( 0, $min, $hour, $mday, $mon, $year );
               $name = $base;
           }
   
                 $files{$ext}{$name}{$epoch} = {          #print "Adding $DIR/$_\n";
                         file      => $_,  
                         dir       => $DIR,  
                         path      => "$DIR/$_",  
                         ext       => $ext,  
                         year      => $year,  
                         mon       => $mon,  
                         mday      => $mday,  
                         hour      => $hour,  
                         min       => $min,  
                         name      => $name,  
                         epoch     => $epoch,  
                 };  
   
         }          if (exists $files{$ext}{$name}{$epoch}) {
         closedir DIR;              warn "Multiple torrents with $name and epoch $epoch\n";
               push @delete, $files{$ext}{$name}{$epoch};
           }
   
           $files{$ext}{$name}{$epoch} = {
               file => $_,
               dir  => $DIR,
               #path => "$DIR/$_",
               ext  => $ext,
   
               #year      => $year,
               #mon       => $mon,
               #mday      => $mday,
               #hour      => $hour,
               #min       => $min,
               name  => $name,
               epoch => $epoch,
           };
   
           if ( $name =~ m/\A $OBT->{BASENAME} /xms
               && !exists $Possible_Torrents{$name} )
           {
               #print "Would remove $_\n";
               push @delete, $files{$ext}{$name}{$epoch};
           }
       }
       closedir DIR;
 }  }
   
   #print Dump \%files;
   
 my %keep;  my %keep;
 my @delete;  my %seen;
 foreach my $name (keys %{ $files{torrent} }) {  foreach my $name ( sort keys %{ $files{torrent} } ) {
         next unless $name =~ /^$Name_Filter/;      next unless $name =~ /^$Name_Filter/;
         print "Checking $name\n";  
   
         foreach my $epoch ( sort { $b <=> $a } keys %{ $files{torrent}{$name} } ) {      #next if $name !~ /songs/xms;
                 #print "\t$epoch\n";      #next if $name =~ /_packages_/xms;
                 my $torrent = $files{torrent}{$name}{$epoch}{path};      #print "Checking $name\n";
   
                 if (      my $cn = $files{torrent}{$name};
                         keys %{ $files{torrent}{$name} } == 1 &&  
                         $files{torrent}{$name}{$epoch}{dir}  
                                 eq $OBT->{DIR_TORRENT}  
                 ) {  
                         #print "Skipping torrent for $name there is only one.\n";  
                         next;  
                 }  
   
   EPOCH: foreach my $epoch ( sort { $b <=> $a } keys %{$cn} ) {
           my $ct = $cn->{$epoch};
           my $cf = $ct->{dir} . '/' . $ct->{file};
   
                 my $t;          #print "\t$epoch - $cf\n";
                 eval { $t = BT::OBTMetaInfo->new( $torrent ); };  
   
                 if ($@) {          my $t;
                         warn "Error reading torrent $torrent\n";          eval {
                         next;              $t
                 }                  = BT::MetaInfo::Cached->new( $cf,
                   { cache_root => '/tmp/OBTFileCache' } );
           };
   
                 $files{torrent}{$name}{$epoch}{comment}   = $t->{comment};          if ($@) {
                 my ($path) = $t->{comment} =~ /Files from ([^\n]+)\n/s;              warn "Error reading torrent $cf\n";
               push @delete, $ct;
               next EPOCH;
           }
   
                 unless (-d $OBT->{DIR_FTP} . "/$path") {          $ct->{comment} = $t->{comment};
                         #print "Deleting $files{torrent}{$name}{$epoch}{file} the path doesn't exist.\n";          my ($path) = $t->{comment} =~ /($OBT->{BASENAME}\/[^\n]+)\n/s;
                         push @delete, $files{torrent}{$name}{$epoch};  
                         delete $files{torrent}{$name}{$epoch};  
                         next;  
                 }  
   
                 my $hash = $t->info_hash_cached($torrent);          if ( !-e $OBT->{DIR_FTP} . "/$path" ) {
                 $hash = unpack("H*", $hash);              print
                   'Deleting ',
                   $cn->{$epoch}{file}, ' the path (', $path,
                   ") doesn't exist.\n";
               push @delete, $ct;
               next EPOCH;
           }
   
                 $files{torrent}{$name}{$epoch}{info_hash} = $hash;          my $hash = unpack( "H*", $t->info_hash );
           $ct->{info_hash} = $hash;
   
                 undef $t;          undef $t;
   
                 if (exists $keep{$name}) {          if ( $seen{$name} && $seen{$name} ne $hash ) {
                         if (exists $keep{$name}{$hash}) {              print "Removing older [$name] [$hash]\n\t",
                                 push @delete, $keep{$name}{$hash};                  $cf,
                                 delete $files{torrent}{                  "\n";
                                         $keep{$name}{$hash}{name}              $ct->{reason} = 'older';
                                 }{              push @delete, $ct;
                                         $keep{$name}{$hash}{epoch}              next EPOCH;
                                 };          }
                                 $keep{$name}{$hash} =          elsif ( keys %{$cn} == 1 && $ct->{dir} eq $OBT->{DIR_TORRENT} ) {
                                         $files{torrent}{$name}{$epoch};              $ct->{reason} = 'only';
                         } else {          }
                                 push @delete, $files{torrent}{$name}{$epoch};          elsif ( $keep{$hash} ) {
                                 delete $files{torrent}{$name}{$epoch};              if ( $keep{$hash}{epoch} == $epoch ) {
                         }                  next EPOCH;
                 } else {              }
                         $keep{$name}{$hash} =  
                                 $files{torrent}{$name}{$epoch};  
   
                 }              print "Removing duplicate [$name] [$hash]\n\t",
         }                  $keep{$hash}{file}, "\n";
   
               $keep{$hash}{reason} = 'duplicate';
               $ct->{reason} = 'duplicate';
   
               push @delete, $keep{$hash};
           }
           else {
               $ct->{reason} = 'first';
           }
   
           $keep{$hash} = $ct;
           $seen{$name} = $hash;
       }
 }  }
   
 #print Dump \%files, \%keep, \@delete;  #print Dump \%files, \%keep, \@delete;
   #print Dump \%keep, \@delete;
   #exit;
   
   my $client = Transmission::Client->new;
   my %seeding;
   foreach my $torrent ( @{ $client->torrents } ) {
   
       #my $status = Transmission::Utils::from_numeric_status($torrent->status);
       my $hash = $torrent->hash_string;
       if ( exists $keep{$hash} ) {
           $seeding{$hash} = $torrent;
       }
       else {
           print "No longer seeding [$hash]\n";
           $torrent->stop or warn $torrent->error_string;
           $client->remove( $torrent->id ) or warn $client->error;
       }
   }
   
   #print Dump \%keep;
   foreach my $hash ( keys %keep ) {
       my $file = $keep{$hash}{file} || q{};
       my $dir  = $keep{$hash}{dir}  || q{};
   
       my $name  = $keep{$hash}{name};
       my $epoch = $keep{$hash}{epoch};
       my $reason = $keep{$hash}{reason} ? $keep{$hash}{reason} . q{ } : q{};
   
       #if ($reason && $reason ne 'only') {
       #    print "Keeping $reason instance of [$file] [$hash]\n",
       #        "\t", $file, "\n";
       #}
   
       if ( $dir eq $OBT->{DIR_NEW_TORRENT} ) {
           print "Moving $file to current torrents\n";
           rename( "$dir/$file", $OBT->{DIR_TORRENT} . "/" . $file )
               or die "Couldn't rename '$file': $!";
   
           $dir = $OBT->{DIR_TORRENT};
           $keep{$hash}{dir} = $dir;
   
           if ( exists $files{txt}{$name}{$epoch} ) {
               my $m_file = $files{txt}{$name}{$epoch}{file};
               my $m_dir  = $files{txt}{$name}{$epoch}{dir};
               rename( "$m_dir/$m_file", $OBT->{DIR_TORRENT} . "/" . $m_file )
                   or die "Couldn't rename '$m_file': $!";
               $files{txt}{$name}{$epoch}{dir} = $OBT->{DIR_TORRENT};
           }
       }
   
       if ( !$seeding{$hash} ) {
           print 'Starting seed of ' . $reason . "[$file] [$hash]\n";
           if (!$client->add(
                   filename     => "$dir/$file",
                   download_dir => $OBT->{DIR_FTP},
               )
               )
           {
   
               #warn $client->error, ": $dir/$file\n";
               print "Removing invalid torrent\n\t", $keep{$hash}{file}, "\n";
               push @delete, $keep{$hash};
           }
       }
   }
   
 foreach (@delete) {  foreach (@delete) {
         print "Deleting '$_->{path}'\n";      my $path = $_->{dir} . '/' . $_->{file};
         unlink $_->{path} or die "Couldn't unlink $_->{path}";      if ( -e $path ) {
           print "Deleting '$path'\n";
           unlink $path or die "Couldn't delete $path";
           delete $files{torrent}{ $_->{name} }{ $_->{epoch} };
       }
       else {
           use Data::Dumper;
           print Dumper $_;
       }
 }  }
   
 foreach my $name (keys %{ $files{$OBT->{META_EXT} } }) {  foreach my $name ( keys %{ $files{ $OBT->{META_EXT} } } ) {
         foreach my $epoch (keys %{ $files{ $OBT->{META_EXT} }{$name} }) {      foreach my $epoch ( keys %{ $files{ $OBT->{META_EXT} }{$name} } ) {
                 unless ( exists $files{torrent}{$name}{$epoch} ) {          unless ( exists $files{torrent}{$name}{$epoch} ) {
                         my $path = $files{$OBT->{META_EXT}}{$name}{$epoch}{path};              my $path = $files{ $OBT->{META_EXT} }{$name}{$epoch}{dir}
                         print "Unlinking '$path'\n";                       . '/'
                         unlink $path or die "couldn't unlink '$path': $!";                       . $files{ $OBT->{META_EXT} }{$name}{$epoch}{file};
                 }  
         }              print "Unlinking '$path'\n";
               unlink $path or die "couldn't unlink '$path': $!";
           }
       }
 }  }
   
   $client->start;
   
 #print Dump \%keep;  sub Process_Dir {
 foreach my $name (keys %keep) {      my $basedir = shift;
         foreach my $hash (keys %{ $keep{$name} }) {  
                 my $file = $keep{$name}{$hash}{file};  
                 my $dir  = $keep{$name}{$hash}{dir };  
                 if ($dir eq $OBT->{DIR_NEW_TORRENT}) {  
                         print "Moving $file to current torrents\n";  
                         rename("$dir/$file", $OBT->{DIR_TORRENT} . "/" . $file)  
                                 or die "Couldn't rename '$file': $!";  
   
                         my $name = $keep{$name}{$hash}{name};      my ( $dirs, $files ) = Get_Files_and_Dirs($basedir);
                         my $epoch = $keep{$name}{$hash}{epoch};      if (@$files) {
           my $dir = $basedir;
           $dir =~ s/^$OBT->{DIR_FTP}\///;
           Make_Possible($dir);
           foreach my $file (@$files) {
               if ( $file =~ /$INSTALL_ISO_REGEX/ ) {
                   Make_Possible("$dir/$file");
               }
           }
       }
   
                         if (exists $files{txt}{$name}{$epoch}) {      foreach my $subdir (@$dirs) {
                                 my $m_file = $files{txt}{$name}{$epoch}{file};          next if $subdir eq '.';
                                 my $m_dir  = $files{txt}{$name}{$epoch}{dir };          next if $subdir eq '..';
                                 rename(          Process_Dir("$basedir/$subdir");
                                         "$m_dir/$m_file",      }
                                         $OBT->{DIR_TORRENT} . "/" . $m_file  }
                                 ) or die "Couldn't rename '$m_file': $!";  
                         }  sub Make_Possible {
                 }      my ($path) = @_;
         }  
       my $torrent = Name_Torrent($path);
       $torrent =~ s/-.*$//;
       $Possible_Torrents{$torrent} = 1;
   
       return $torrent;
 }  }
Legend:
Removed from v.1.14  
changed lines
  Added in v.1.37
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>