In perl, zu töten Kind und seine Kinder, als Kind wurde erstellt mit open

Hier ist mein code, mit Fehlerbehandlung und andere Sachen entfernt, die für Klarheit:

sub launch_and_monitor {  

    my ($script, $timeout) = @_;

    sub REAPER {
        while ((my $child = waitpid(-1, &WNOHANG)) > 0) {}
        $SIG{CHLD} = \&REAPER;
    }
    $SIG{CHLD} = \&REAPER;

    my $pid = fork;
    if (defined $pid) {
        if ($pid == 0) {
            # in child
            monitor($timeout);
        }
        else {
            launch($script);
        }
    }
}

Den Start sub führt ein shell-Skript, das wiederum startet andere Prozesse, etwa so:

sub launch($) {

    my ($script) = @_;

    my $pid = open(PIPE, "$script|");

    # write pid to pidfile

    if ($pid != 0) {
        while(<PIPE>) {
            # do stuff with output
        }
        close(PIPE) or die $!;
    }
}

Den monitor sub im Grunde nur darauf wartet für eine bestimmte Zeit und dann versucht zu töten das shell-Skript.

sub monitor($) {

    my ($timeout) = @_;

    sleep $timeout;

    # check if script is still running and if so get pid from pidfile
    if (...) {
        my $pid = getpid(...);        
        kill 9, $pid;
    }
}

Dieser tötet das Skript, aber es tötet nicht, es ist sub-Prozesse. Wie zu beheben?

Ich habe keine Antwort auf deine Hauptfrage, aber ich würde empfehlen, machen REAPER eine anonyme sub, z.B. my $reaper = sub { ... }; $SIG{CHLD} = $reaper; Setzen eines namens sub in einem anderen sub nicht verstecken Sie von anderen Bereichen. Alle genannten subs sind package-Symbole in Perl
speculation.org/garrick/kill-9.html
guter Punkt, danke für den Hinweis

InformationsquelleAutor richard | 2009-11-04

12

Können Sie dies tun mit Gruppen, wenn Ihr Betriebssystem unterstützt wird. Sie benötigen, um den Skript-Prozess zu einem Prozess Gruppenleiter. Die Kind-Prozesse, die es ausgeführt wird, übernehmen die Prozess-Gruppe von Ihrer Muttergesellschaft. Sie können dann mittels kill sendet ein signal an jeden Prozess in der Gruppe zur gleichen Zeit.

In launch(), müssen Sie ersetzen die open Linie mit einer Gabel. Dann in das Kind, Sie nennen würde setpgrp() vor exec ' Ing der Befehl. Etwas, das wie folgt funktionieren sollte:
```
my $pid = open(PIPE, "-|");
if (0 == $pid) {
    setpgrp(0, 0);
    exec $script;
    die "exec failed: $!\n";
}
else {
    while(<PIPE>) {
        # do stuff with output
    }
    close(PIPE) or die $!;
}
```
Später, zu töten, die Skript-Prozess und dessen Kinder, Annulliere die Prozess-ID, die du bist-Signal:
```
kill 9, -$pid;
```
- Ich denke, Sie sollten Annulliere die signal-Nummer (oder der name) nicht der PID: kill '-9', $pid.
InformationsquelleAutor Kenster
2

Im Allgemeinen, ich glaube nicht, dass Sie erwarten können Signale weitergegeben werden in alle untergeordneten Prozesse; dies ist nicht spezifisch für perl.

Sagte, Sie könnten in der Lage sein, das Verfahren Gruppe signal-Funktion integriert perl kill():

...wenn das SIGNAL negativ ist, es tötet die Prozess-Gruppen anstelle von Prozessen...

Müssen Sie wahrscheinlich verwenden setpgrp() auf Ihre (direkte) Kind-Prozess, dann ändern Sie Ihre kill-Aufruf etwas wie:
```
kill -9, $pgrp;
```
InformationsquelleAutor dlowe
2

Versuchen Sie, hinzufügen:
```
use POSIX qw(setsid);
setsid;
```
oben Ihre launch_and_monitor Funktion. Dies wird Ihre Prozesse in einer separaten Sitzung, und führen die Dinge zu beenden, wenn die "session leader" (also der master) beendet.

InformationsquelleAutor Emil Sit

Tötung eines processgroup arbeiten, aber vergessen Sie nicht, die Eltern können getötet werden, auch allein. Vorausgesetzt, untergeordnete Prozesse, die eine Ereignis-Schleife, können Sie den übergeordneten socket erstellt wurde, in ein socketpair vor tut die Gabel() für validness. In der Tat, wählen Sie() sauber beendet, wenn das parent-Buchse ist Weg, alles, das getan werden muss, ist überprüfen Sie die Steckdose.

E. g.:

use strict; use warnings;
use Socket;

$SIG{CHLD} = sub {};

socketpair(my $p, my $c, AF_UNIX, SOCK_STREAM, PF_UNSPEC) or die $!;

print "parent $$, fork 2 kids\n";
for (0..1){
    my $kid = fork();
    unless($kid){
        child_loop($p, $c);
        exit; 
    }
    print "parent $$, forked kid $kid\n";
}

print "parent $$, waiting 5s\n";
sleep 5;
print "parent $$ exit, closing sockets\n";

sub child_loop {
    my ($p_s, $c_s) = @_;
    print "kid: $$\n";
    close($c_s);
    my $rin = '';
    vec($rin, fileno($p_s), 1) = 1;
    while(1){
        select my $rout = $rin, undef, undef, undef;
        if(vec($rout, fileno($p_s), 1)){
            print "kid: $$, parent gone, exiting\n";
            last;
        }
    }
}

Läuft so:

tim@mint:~$ perl ~/abc.pl
parent 5638, fork 2 kids
parent 5638, forked kid 5639
kid: 5639
parent 5638, forked kid 5640
parent 5638, waiting 5s
kid: 5640
parent 5638 exit, closing sockets
kid: 5640, parent gone, exiting
kid: 5639, parent gone, exiting
tim@mint:~$

InformationsquelleAutor CowboyTim

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.