Bonjour,
 
J'ai un programme qui appelle des connexions SSH sur différents serveurs dans une boucle.
Pour simuler un timeout j'utilise des fork, et si le timeout arrive a expiration je tue le fils.
Si la connexion plante ou qu'il y a un problème, je demande également au fils de se tuer.  
 
Mon problème est que si je lui demande de se tuer a l'intérieur d'une fonction qui est dans le code mais a l'extérieur du "if $fork == 0" le programme se tue, si je place la fonction à l'intérieur par contre j'ai le comportement souhaité (mais j'aimerai bien mettre mes fonctions a l'extérieur dans un souci de lisibilité).
 
En bref, le comportement suivant est-il normal ?
 

ben fork te donnes le pid tu fils créé.

Pourquoi ne pas passer par kill?
J'ai pas testé, mais je ferais ainsi pour ton premier cas

for my $hosts (@hosts) {
    my $pid = fork;
    if ($pid == 0) {
        &kill-me($pid);
    }
}
sub kill-me {
    my $pid = shift;
    kill 9, $pid;
}

 
Je ne sais pas trop ce que signifie

if ($pid == 0) {
  sub kill-me {
   die;
  }

car habituellement, on ne définit pas un sub à l'intérieur d'une autre procédure.
Le fils meurt et pas le père? bizarre.
A+,

for my $hosts (@hosts) {
    my $pid = fork;
    if ($pid == 0) {
        &kill-me($pid);
    }
}
sub kill-me {
    my $pid = shift;
    kill 9, $pid;
}

if ($pid == 0) {
  sub kill-me {
   die;
  }

T'es obligé de kill. Sinon tu peux tenter des fourberies avec alarm + nettoyage des fils du fils ...

for my $hosts (@hosts) {
    my $pid = fork;
    if ($pid == 0) {
        &kill-me($pid);
    }
}
sub kill-me {
    my $pid = shift;
    kill 9, $pid;
}

 
 
En fait peut importe comment on tue le fils, tu peux envoyer un signal ou bien lui demander de faire ça lui même.
 
Dans mon cas, je gère effectivement les timeout des fils en envoyant des signaux de fin, mais là c'est dans le cas ou par exemple la connexion ssh plante, pour ne pas lancer les commandes suivantes de copies de fichier.
Dans ce cas le père ne peut pas savoir le statut de la commande, donc c'est au fils de se terminer, d'où le die.
 
Exemple :

if ($pid == 0) {
  sub kill-me {
   die;
  }

 
Justement c'est ça qui le chagrine, si je ne définie pas le sub à l'intérieur de la procédure contenant le "if $pid == 0", ce n'est pas le fils qui meurt, mais le père.
Dans le cas où j'ai 150 serveurs à traiter c'est gênant, car dès qu'une connexion échoue, je dois tout recommencer.
 
Le problème n'est pas handicapant outre mesure car en mettant les subs a l'intérieur du code du fils ça fonctionne mais je préférerais déclarer mes subs ailleurs..
 
Pour le peu que je connais du fork, il me semblait que le code était dupliqué :
- Est-ce tout le code ou juste le code dans lequel on définit "if $pid==0" ?
- Est-ce possible que le fils appelle la fonction du père plutôt que de dupliquer le code ?

Comme je code en java ces temps ci, je n'avais pas les idées nettes.
 
Je procéderais ainsi:
 

#/usr/bin/perl
 
my $father = $$;
 
for my $host (1..6) {
    if ($$ == $father) { #si on veut éviter que les fils ne forkent eux aussi
        fork;
    }
}
&byebye();
 
sub byebye {
    if ($$ != $father) {
        exit(0); #ou die, qui est plus verbeux
    }
}

Ici, byebye est une fonction commune, qui ne tuera que les fils
A+,

Noter aussi qu'on peut passer par un pointeur de fonction:
 

#/usr/bin/perl
 
sub do_nothing {}
sub do_exit {exit(0);}
my $functionref = \&do_nothing;
 
for my $host (1..3) {
        my $pid = fork;
        if ($pid == 0) {
            $functionref = \&do_exit;
        }
}
 
&$functionref();

Noter qu'ici, je n'ai pas mis le code qui évite au fils de forker, pour plus de clarté.
&$functionref() sera un appel a do_nothing dans le père et a do_exit dans les fils.
 
A+,