Perl Challenge - Iterador de directorio

Question

A veces escuchas decir acerca de Perl que podría haber 6 formas diferentes de abordar el mismo problema. Los desarrolladores de Good Perl suelen tener conocimientos bien razonados para elegir entre los diversos métodos posibles de implementación.

Así un ejemplo Perl problema:

Una secuencia de comandos simple que forma recursiva itera a través de una estructura de directorios, en busca de archivos que se modificaron recientemente (después de una fecha determinada, lo que sería la variable). Guarde los resultados en un archivo.

La pregunta para los desarrolladores de Perl: ¿Cuál es su mejor forma de lograr esto?

Answer 1

Esto suena como un trabajo para File::Find::Rule:

#!/usr/bin/perl 
use strict; 
use warnings; 
use autodie; # Causes built-ins like open to succeed or die. 
       # You can 'use Fatal qw(open)' if autodie is not installed. 

use File::Find::Rule; 
use Getopt::Std; 

use constant SECONDS_IN_DAY => 24 * 60 * 60; 

our %option = (
    m => 1,  # -m switch: days ago modified, defaults to 1 
    o => undef, # -o switch: output file, defaults to STDOUT 
); 

getopts('m:o:', \%option); 

# If we haven't been given directories to search, default to the 
# current working directory. 

if (not @ARGV) { 
    @ARGV = ('.'); 
} 

print STDERR "Finding files changed in the last $option{m} day(s)\n"; 


# Convert our time in days into a timestamp in seconds from the epoch. 
my $last_modified_timestamp = time() - SECONDS_IN_DAY * $option{m}; 

# Now find all the regular files, which have been modified in the last 
# $option{m} days, looking in all the locations specified in 
# @ARGV (our remaining command line arguments). 

my @files = File::Find::Rule->file() 
          ->mtime(">= $last_modified_timestamp") 
          ->in(@ARGV); 

# $out_fh will store the filehandle where we send the file list. 
# It defaults to STDOUT. 

my $out_fh = \*STDOUT; 

if ($option{o}) { 
    open($out_fh, '>', $option{o}); 
} 

# Print our results. 

print {$out_fh} join("\n", @files), "\n"; 

Answer 2

Escribo una subrutina que lee un directorio con readdir, arroja el "." y directorios "..", recurre si encuentra un nuevo directorio y examina los archivos de lo que estoy buscando (en su caso, querrá usar utime o stat). Para cuando se complete la recursión, todos los archivos deberían haber sido examinados.

Creo que todas las funciones que usted necesita para este script se describen brevemente a continuación: http://www.cs.cf.ac.uk/Dave/PERL/node70.html

La semántica de entrada y salida son un ejercicio bastante trivial en el que voy a dejar a usted.

Answer 3

Me arriesgo a obtener downvoted, pero en mi humilde opinión 'ls' (con los parámetros adecuados) lo hace de la mejor manera conocida. En este caso, podría ser una solución bastante buena para conectar 'ls' desde el código perl a través del shell, devolviendo los resultados a un array o hash.

Editar: También podría ser 'encontrado' utilizado, como se propone en los comentarios.

Answer 4

File::Find es la forma correcta de resolver este problema. No sirve de nada volver a implementar cosas que ya existen en otros módulos, pero realmente debería desalentarse la reimplantación de algo que está en un módulo estándar.

Answer 5

Mi método preferido es usar el archivo :: Encuentra módulo como así:

use File::Find; 
find (\&checkFile, $directory_to_check_recursively); 

sub checkFile() 
{ 
    #examine each file in here. Filename is in $_ and you are chdired into it's directory 
    #directory is also available in $File::Find::dir 
} 

Answer 6

Cuando el problema se resuelve principalmente por las bibliotecas estándar de usarlos.

File :: Find en este caso funciona muy bien.

Puede haber muchas formas de hacer cosas en perl, pero cuando existe una biblioteca muy estándar para hacer algo, debe utilizarse a menos que tenga problemas propios.

#!/usr/bin/perl 

use strict; 
use File::Find(); 

File::Find::find({wanted => \&wanted}, "."); 

sub wanted { 
    my (@stat); 
    my ($time) = time(); 
    my ($days) = 5 * 60 * 60 * 24; 

    @stat = stat($_); 
    if (($time - $stat[9]) >= $days) { 
    print "$_ \n"; 
    } 
} 

Answer 7

No hay seis maneras de hacer esto, hay la manera antigua, y la nueva forma. La forma antigua es con File :: Find, y ya tienes un par de ejemplos de eso. File :: Find tiene una interfaz de devolución de llamada bastante horrible, fue genial hace 20 años, pero hemos avanzado desde entonces.

Aquí hay un programa de la vida real (ligeramente modificado) que utilizo para limpiar el cruft en uno de mis servidores de producción. Utiliza File :: Find :: Rule, en lugar de File :: Find. File :: Find :: Rule tiene una interfaz declarativa agradable que se lee fácilmente.

Randal Schwartz también escribió File :: Finder, como un contenedor sobre File :: Find. Es bastante agradable, pero en realidad no ha despegado.

#! /usr/bin/perl -w 

# delete temp files on agr1 

use strict; 
use File::Find::Rule; 
use File::Path 'rmtree'; 

for my $file (

    File::Find::Rule->new 
     ->mtime('<' . days_ago(2)) 
     ->name(qr/^CGItemp\d+$/) 
     ->file() 
     ->in('/tmp'), 

    File::Find::Rule->new 
     ->mtime('<' . days_ago(20)) 
     ->name(qr/^listener-\d{4}-\d{2}-\d{2}-\d{4}.log$/) 
     ->file() 
     ->maxdepth(1) 
     ->in('/usr/oracle/ora81/network/log'), 

    File::Find::Rule->new 
     ->mtime('<' . days_ago(10)) 
     ->name(qr/^batch[_-]\d{8}-\d{4}\.run\.txt$/) 
     ->file() 
     ->maxdepth(1) 
     ->in('/var/log/req'), 

    File::Find::Rule->new 
     ->mtime('<' . days_ago(20)) 
     ->or(
      File::Find::Rule->name(qr/^remove-\d{8}-\d{6}\.txt$/), 
      File::Find::Rule->name(qr/^insert-tp-\d{8}-\d{4}\.log$/), 
     ) 
     ->file() 
     ->maxdepth(1) 
     ->in('/home/agdata/import/logs'), 

    File::Find::Rule->new 
     ->mtime('<' . days_ago(90)) 
     ->or(
      File::Find::Rule->name(qr/^\d{8}-\d{6}\.txt$/), 
      File::Find::Rule->name(qr/^\d{8}-\d{4}\.report\.txt$/), 
     ) 
     ->file() 
     ->maxdepth(1) 
     ->in('/home/agdata/redo/log'), 

) { 
    if (unlink $file) { 
     print "ok $file\n"; 
    } 
    else { 
     print "fail $file: $!\n"; 
    } 
} 

{ 
    my $now; 
    sub days_ago { 
     # days as number of seconds 
     $now ||= time; 
     return $now - (86400 * shift); 
    } 
} 

Answer 8

Otros han mencionado File :: Find, que es la forma me gustaría ir, pero le ha pedido un iterador, que File :: Buscar no es (ni es File :: Buscar :: Regla) . Es posible que desee mirar File::Next o File::Find::Object, que sí tienen interfaces iterativas. Mark Jason Dominus repasa la construcción del suyo en el capítulo 4.2.2 de Higher Order Perl.

Answer 9

Escribí File::Find::Closures como un conjunto de cierres que puede usar con File :: Find para que no tenga que escribir el suyo. Hay un par de funciones mtime que debe manejar

 
use File::Find; 
use File::Find::Closures qw(:all); 

my($wanted, $list_reporter) = find_by_modified_after(time - 86400); 
#my($wanted, $list_reporter) = find_by_modified_before(time - 86400); 

File::Find::find($wanted, @directories); 

my @modified = $list_reporter->(); 

En realidad, no es necesario utilizar el módulo, ya que en su mayoría diseñado como una manera de que usted podría mirar el código y robar las piezas que usted quería. En este caso, es un poco más complicado porque todas las subrutinas que se ocupan de la estadística dependen de una segunda subrutina. Sin embargo, obtendrá rápidamente la idea del código.

Buena suerte,

Answer 10

Ahí está mi File::Finder, como ya se ha mencionado, pero también hay mi iterador-as-a-hash-atado solución de Finding Files Incrementally (Linux Magazine).

Answer 11

El uso de módulos estándar es de hecho una buena idea, pero de aquí no me interesa volver al enfoque básico sin utilizar módulos externos. Sé que la sintaxis del código aquí podría no ser la taza de té de todos.

Podría mejorarse para utilizar menos memoria al proporcionar acceso a un iterador (la lista de entrada podría estar temporalmente en espera una vez que alcanza un cierto tamaño) y la verificación condicional se puede expandir mediante la devolución de llamada ref.

sub mfind { 
    my %done; 

    sub find { 
     my $last_mod = shift; 
     my $path = shift; 

     #determine physical link if symlink 
     $path = readlink($path) || $path;   

     #return if already processed 
     return if $done{$path} > 1; 

     #mark path as processed 
     $done{$path}++; 

     #DFS recursion 
     return grep{$_} @_ 
       ? (find($last_mod, $path), find($last_mod, @_)) 
       : -d $path 
        ? find($last_mod, glob("$path/*")) 
         : -f $path && (stat($path))[9] >= $last_mod 
          ? $path : undef; 
    } 

    return find(@_); 
} 

print join "\n", mfind(time - 1 * 86400, "some path");