6
votes

Comment puis-je gérer une piscine de fourche à Perl?

Je fixe quelque chose jusqu'à SSH à plusieurs serveurs dans des "lots". Je veux fondamentalement gérer 5 connexions à la fois, et quand on se termine, ouvrez un autre (suivant un tableau de serveur IPS).

Je me demande pour quelque chose comme ça devrais-je utiliser Fork () ? Si oui, quelle logique puis-je utiliser pour vous assurer que je maintiens 5 enfants à la fois?

perl logic fork

1 commentaires

Voir aussi Stackoverflow.com/Questtions/2453432/...

4 Réponses :

11
votes

Forking (ou filetage) est ce que vous voulez, mais vous devriez regarder cpan pour les modules qui fourniront la plupart des de ce que vous devez vous empêcher de réinventer la roue et de traverser les douleurs d'apprentissage de ce que vous devez faire.

Par exemple, Parallel :: ForkManager semble être exactement ce que vous voulez. xxx

2 commentaires

Mais ForkManager ne semble-t-il pas vraiment supporter une piscine mais juste une casquette dans le nombre concurrent de processus? Le début semble documenté pour toujours faire une nouvelle fourche pour chaque itération. Y a-t-il une bibliothèque à l'appui de la réelle mise en commun de processus de fourche afin de ne pas avoir besoin d'être fourchue pour chaque itération?

Cela peut être correct. Ce que j'utilise généralement ces jours-ci est le fil :: piscine :: simple. Il gère automatiquement une quantité min / max de threads que vous pouvez définir et gère le montant actif basé sur la charge de travail et permet aux actions pré / poster pour chaque travail. Je l'ai utilisé à bon effet pendant plusieurs années maintenant. Il faut des threads, ce qui est regrettable pour ceux qui utilisent un Perl compilé sans ithreads. Anyevent :: Fourche :: La piscine ressemble à un bon choix si c'est le cas, mais je n'ai aucune expérience avec elle.

5
votes

Il existe plusieurs modules qui résolvent exactement ce problème. Voir Parallel :: ForkManager , Forks :: Super , ou proc :: Queue , par exemple.

1 commentaires

Proc :: Queue Rocks pour les scripts existants depuis que l'action de forking ne doit pas être modifiée. Grande suggestion. Merci.

0
votes

My Forking personnel (!) Favoris est Proc :: Fourche Code >

Vue d'ensemble générale de POD: P>

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;
        }
    }
}

2 commentaires

Proc :: Fourche accélérite-t-il le nombre de processus d'arrière-plan? Comment cela répond-il à l'OP?

@mobrule: Désolé a été appelé! Il n'y a rien de spécifique (que je sais!) Dans Proc: Fourchette pour la portée de la portée. Donc, revenez aux mesures d'attente normales (voir mon exemple mis à jour).

1
votes

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;

0 commentaires