¿Cómo implemento las tablas de envío en Perl?

Question

Necesito escribir una aplicación relacionada con el almacenamiento en Perl. La aplicación necesita cargar archivos desde la máquina local a otros nodos de almacenamiento. Actualmente, el método de carga es FTP, pero en el futuro puede ser bittorrent o algún método desconocido de transferencia de superarchivos.

Para cada archivo que debe cargarse, hay un archivo de configuración que define el nombre del archivo, el nodo de almacenamiento al que se cargará el archivo y el método de transferencia que se debe utilizar durante la carga.

Por supuesto, puede utilizar el siguiente método para resolver mi problema:

{ 
    if ($trans_type == "ftp") { ###FTP the FILE} 
    if ($trans_type == "bit") { ###BIT the FILE} 
    ### etC### 
} 

Pero incluso con mis conocimientos básicos OO aprendido en la escuela, todavía siento que esto no es un buen diseño. (El título de la pregunta podría ser un poco engañoso. Si crees que mi problema puede resolverse correctamente con una solución que no sea de OO, está bien para mí. En realidad, será mejor, ya que tengo conocimiento limitado de OO)

Entonces, ¿podrían darme algunos consejos en general? Por supuesto, si proporciona un código de muestra también, esto será de gran ayuda.

Answer 1

En primer lugar, prueba de igualdad de cadenas en Perl es eq, no ==.

Si tiene métodos para hacer el trabajo, digamos llamado bit y ftp,

my %proc = (
    bit => \&bit, 
    ftp => \&ftp, 
); 

my $proc = $proc{$trans_type}; 
$proc->() if defined $proc; 

Answer 2

OO sería una exageración. Mi solución sería probablemente algo parecido a esto:

sub ftp_transfer { ... } 
sub bit_transfer { ... } 
my $transfer_sub = { 'ftp' => \&ftp_transfer, 'bit' => \&bit_transfer, ... }; 
... 
sub upload_file { 
    my ($file, ...) = @_; 
    ... 
    $transfer_sub->{$file->{trans_type}}->(...); 
} 

Answer 3

Se puede utilizar un hash de esta ...

1. Haga que cada método de transferencia de registrarse en el hash. Puedes hacer esto OO (llamando a un método en alguna fábrica de método de transferencia) o de procedimiento (simplemente haz que el hash sea una variable de paquete, o incluso podrías ponerlo en el paquete principal si no quieres modularizarlo).

   package MyApp::Transfer::FTP; 
   $MyApp::TransferManager::METHODS{ftp} = \&do_ftp; 
   sub do_ftp { ... } 
   1; 
   

2. Cada método de transferencia utiliza una API consistente. Tal vez sea solo una función, o podría ser una interfaz de objeto.

3. Llame la transferencia a través del hash.

   sub do_transfer { 
       # ... 
       my $sub = $MyApp::TransferManager::METHODS{$method} 
        or croak "Unknown transfer method $method"; 
       $sub->($arg1, $arg2, ...); 
       # ... 
   } 
   

Por cierto: El método de registro OO sería algo como esto:

package MyApp::TransferManager; 
use Carp; 
use strict; 

my %registered_method; 

sub register { 
    my ($class, $method, $sub) = @_; 

    exists $registered_method{$method} 
     and croak "method $method already registered"; 

    $registered_method{$method} = $sub; 
} 

# ... 

1; 

(Ninguna de este código se prueba; por favor, perdona y comas que faltan)

Answer 4

El diseño correcto aquí es una fábrica Eche un vistazo a cómo lo maneja el DBI. Concluirá con una clase TransferAgent que ejemplifica una de una serie de TransferAgent::* clases. Obviamente, deseará más comprobación de errores de la que proporciona la implementación a continuación. Usar una fábrica como esta significa que puede agregar nuevos tipos de agentes de transferencia sin tener que agregar o modificar ningún código.

TransferAgent.pm - la clase de fábrica:

package TransferAgent; 

use strict; 
use warnings; 

sub connect { 
    my ($class, %args) = @_; 

    require "$class/$args{type}.pm"; 

    my $ta = "${class}::$args{type}"->new(%args); 
    return $ta->connect; 
} 

1; 

TransferAgent/Base.pm - contiene la funcionalidad básica de una clase TransferAgent::*:

package TransferAgent::Base; 

use strict; 
use warnings; 

use Carp; 

sub new { 
    my ($class, %self) = @_; 
    $self{_files_transferred} = []; 
    $self{_bytes_transferred} = 0; 
    return bless \%self, $class; 
} 

sub files_sent { 
    return wantarray ? @{$_[0]->{_files_sent}} : 
     scalar @{$_[0]->{_files_sent}}; 
} 

sub files_received { 
    return wantarray ? @{$_[0]->{_files_recv}} : 
     scalar @{$_[0]->{_files_recv}}; 
} 

sub cwd { return $_[0]->{_cwd}  } 
sub status { return $_[0]->{_connected} } 

sub _subname { 
    return +(split "::", (caller 1)[3])[-1]; 
} 

sub connect { croak _subname, " is not implemented by ", ref $_[0] } 
sub disconnect { croak _subname, " is not implemented by ", ref $_[0] } 
sub chdir  { croak _subname, " is not implemented by ", ref $_[0] } 
sub mode  { croak _subname, " is not implemented by ", ref $_[0] } 
sub put  { croak _subname, " is not implemented by ", ref $_[0] } 
sub get  { croak _subname, " is not implemented by ", ref $_[0] } 
sub list  { croak _subname, " is not implemented by ", ref $_[0] } 

1; 

TransferAgent/FTP.pm - implementa un cliente (simulacro) FTP:

package TransferAgent::FTP; 

use strict; 
use warnings; 

use Carp; 

use base "TransferAgent::Base"; 

our %modes = map { $_ => 1 } qw/ascii binary ebcdic/; 

sub new { 
    my $class = shift; 
    my $self = $class->SUPER::new(@_); 
    $self->{_mode} = "ascii"; 
    return $self; 
} 

sub connect { 
    my $self = shift; 
    #pretend to connect 
    $self->{_connected} = 1; 
    return $self; 
} 

sub disconnect { 
    my $self = shift; 
    #pretend to disconnect 
    $self->{_connected} = 0; 
    return $self; 
} 

sub chdir { 
    my $self = shift; 
    #pretend to chdir 
    $self->{_cwd} = shift; 
    return $self; 
} 

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

    if (defined $mode) { 
     croak "'$mode' is not a valid mode" 
      unless exists $modes{$mode}; 
     #pretend to change mode 
     $self->{_mode} = $mode; 
     return $self; 
    } 

    #return current mode 
    return $self->{_mode}; 
} 

sub put { 
    my ($self, $file) = @_; 
    #pretend to put file 
    push @{$self->{_files_sent}}, $file; 
    return $self; 
} 

sub get { 
    my ($self, $file) = @_; 
    #pretend to get file 
    push @{$self->{_files_recv}}, $file; 
    return $self; 
} 

sub list { 
    my $self = shift; 
    #pretend to list remote files 
    return qw/foo bar baz quux/; 
} 

1; 

script.pl - cómo utilizar TransferAgent:

#!/usr/bin/perl 

use strict; 
use warnings; 

use TransferAgent; 

my $ta = TransferAgent->connect(
    type  => "FTP", 
    host  => "foo", 
    user  => "bar", 
    password => "baz", 
); 

print "files to get: ", join(", ", $ta->list), "\n"; 
for my $file ($ta->list) { 
    $ta->get($file); 
} 
print "files gotten: ", join(", ", $ta->files_received), "\n"; 

$ta->disconnect; 

Answer 5

Usted dijo inicialmente que usará FTP y pasará a otros métodos de transferencia más tarde. No me pondría "elegante" hasta que realmente necesite agregar la segunda o tercera tecnología. Ese segundo método de transferencia puede no ser necesario. :-)

Si quieres hacerlo como un "proyecto de ciencia", entonces genial.

Estoy cansado de ver los patrones de diseño OO que complican las soluciones a los problemas que nunca llegan.

Envuelva el primer método de transferencia en un método uploadFile. Agregue un if if else para el segundo método. Obtenga elegante y refactor en el tercer método. Para entonces, tendrás suficientes ejemplos de que tu solución probablemente sea bastante genérica.

Por supuesto, mi punto principal es que el segundo y el tercer método pueden no ser necesarios.

Answer 6

Ver Implementing Dispatch Tables y MJD's treatment of dispatch tables in HOP.

Answer 7

Tengo varios ejemplos en Mastering Perl en las secciones de subrutinas dinámicas.