Wie kann ich einen Fork-Pool in Perl verwalten?

Question

Ich stelle etwas auf SSH auf mehreren Servern in "Chargen" aus. Ich möchte grundsätzlich 5 Verbindungen auf einmal aufrechterhalten, und wenn man fertig ist, öffne ein anderes (nach einem Array von Server-IPs).

Ich frage mich für etwas wie das sollte ich fork() verwenden? Wenn ja, welche Logik kann ich verwenden, um sicherzustellen, dass ich 5 Kinder gleichzeitig behalte?

Answer 1

Forking (oder Threading) ist was Sie wollen, aber Sie sollten sich CPAN für Module ansehen, die das meiste von dem bieten, was Sie brauchen, um das Rad nicht neu zu erfinden und die Lernschwierigkeiten zu überwinden.

Zum Beispiel, Parallel::ForkManager sieht aus wie es genau ist, was Sie wollen.

use Parallel::ForkManager; 

$pm = new Parallel::ForkManager($MAX_PROCESSES); 

foreach $data (@all_data) { 
    # Forks and returns the pid for the child: 
    my $pid = $pm->start and next; 

    ... do some work with $data in the child process ... 

    $pm->finish; # Terminates the child process 
} 

Answer 2

Es gibt mehrere Module, die genau dieses Problem lösen. Siehe beispielsweise Parallel::ForkManager, Forks::Super oder Proc::Queue. (!)

Answer 3

Mein persönlicher Forking Favorit ist Proc::Fork

Allgemeine Übersicht von pod:

use Proc::Fork; 

run_fork { 
    child { 
     # child code goes here. 
    } 
    parent { 
     my $child_pid = shift; 
     # parent code goes here. 
     waitpid $child_pid, 0; 
    } 
    retry { 
     my $attempts = shift; 
     # what to do if if fork() fails: 
     # return true to try again, false to abort 
     return if $attempts > 5; 
     sleep 1, return 1; 
    } 
    error { 
     # Error-handling code goes here 
     # (fork() failed and the retry block returned false) 
    } 
}; 

Und die Anzahl der maximalen Prozesse für so etwas wie SSH Chargen laufen zu begrenzen dann soll dies das tun Trick:

use strict; 
use warnings; 
use 5.010; 
use POSIX qw(:sys_wait_h); 
use Proc::Fork; 

my $max = 5; 
my %pids; 

my @ssh_files = (
    sub { system "scp file0001 baz@foo:/somedir/." }, 
    ... 
    sub { system "scp file9999 baz@foo:/somedir/." }, 

); 

while (my $proc = shift @ssh_files) { 

    # max limit reached 
    while ($max == keys %pids) { 
     # loop thru pid list until a child is released 
     for my $pid (keys %procs) { 
      if (my $kid = waitpid($pid, WNOHANG)) { 
       delete $pids{ $kid }; 
       last; 
      } 
     } 
    } 

    run_fork { 
     parent { 
      my $child = shift; 
      $pids{ $child } = 1; 
     } 
     child { 
      $proc->(); 
      exit; 
     } 
    } 
} 

/I3az/

auch

Answer 4

use Net::OpenSSH::Parallel; 

my $pssh = Net::OpenSSH::Parallel->new(connections => 5); 

for my $ip (@ips) { 
    $pssh->add_host($ip); 
} 

$pssh->push('*', command => 'do this'); 
$pssh->push('*', command => 'do that'); 
$pssh->push('*', scp_get => 'foo', 'bar-%HOST%'); 
$pssh->push('*', scp_put => 'doz', 'there'); 

$pssh->run;