The trick is to keep track of the PID as you launch the process. On non-Windows systems, this is easiest done through the magic of exec, which replaces the current process by the other process, keeping the PID ($$) the same. So you can store $$ and then exec the "real" process:

sub launch {
    my ($pid_file,@process_and_args) = @_;
    open my $fh, '>', $pid_file # or print to STDOUT for easier handli
+ng by ssh?
       or die "Couldn't create '$pid_file': $!";
    print {$fh} $$;
    exec(@process_and_args)
        or die "Couldn't launch [@process_and_args]: $!";
};
[download]

You have to decide whether to output the PID to a file or to directly output it to STDOUT and read it from your ssh launcher and store it in the controlling master.

I have never had to deal with infanticide across multiple machines, but when it comes to child management I have found Parallel::Forker very helpful for monitoring, polling and if nessecary (sp.?), brutally murdering processes.

You can also use it for scheduling launches, for example a cleanup job like the one you describe. It also handles process trees, which might be a way of avoiding the "when one user Ctrl-C's, how do i only kill their processes?" problem, i.e. by keeping a separate tree for each user?

Anyway, have a play and hopefully it will help and not bee too much of a pain to refactor into your code.

#!/usr/bin/perl
print STDERR "PID: $$\n";
exec @ARGV;
[download]

$ ssh my.host.com tellpid echo 'hello world'
PID: 15079
hello world
[download]

You can, as you suggest, give the forked process, a unique name, and kill the process later by searching for the pid of the name

#!/usr/bin/perl -w
use strict;
use Proc::ProcessTable;

my $t1 = new Proc::ProcessTable;
my $pid;
my $commandline = shift || $0;
foreach my $p (@{$t1->table}){
   if($p->cmndline =~ /\Q$commandline\E/){
        $pid = $p->pid;
        print "$pid\n";
     }
}
###################################################
[download]

The one thing to watch out for, is quite often, you get the pid of a shell (like bash or sh) which runs your external process... so you often need to kill the pid and all it's children, to get the whole shebang killed.

...this may be useful, as a guide

#!/usr/bin/perl -w
use strict;

use Proc::ProcessTable;

#--
#-- we will ignore the child
#--
$SIG{CHLD} = 'IGNORE';

#--
#-- create 5 child processes for demo purpose. arrange them so they st
+ay
#-- long enough so we can find them later
#--
for(1..5){
        sleep(10) and exit if(fork == 0);
}

#--
#-- list all process running in your machine and find all 
#-- child process
#--
for my $p (@{new Proc::ProcessTable->table}){
        print $p->pid," child of $$\n" if($p->ppid == $$);
}
[download]

i don't think this gonna work . what i did is :

#!/usr/bin/perl

use strict;

my @mch = ('compute-0-0','compute-0-1');

my @children;
for (my $i = 0;$i<=1;$i++){
    my $pid = fork();
    if ($pid){
        push @children, $pid;
    }
    elsif ($pid == 0){
        print $$ . "\n";
        print "$mch[$i] \n";
        exec("ssh $mch[$i] ./sleep.pl") || die "cannot execute process
+\n";
        exit;
    }
    else{
        die "could not fork! \n";
    }
}
foreach (@children){
    waitpid($_,0);
}




sleep.pl

#!/usr/bin/perl

use strict;

for (1..10000000){
  my $rez = 1;
  for (1..500){
    $rez *=$_;
  }
}
[download]

so the problem is sending a job to a remote machine and retrieving the pid of the process executed on that machine... any more ideas ??? or this really cannot be done ??

Update:

THE WRAPPER !!!! :) hey it's sunday (rough night last night :)) so :

and i get reported pid 1 = 9776 pid 2 = 9777 but on a compute-0-0 id of the proc is 24356 and on compute-0-1 4443

The value returned by fork is not the PIDs of the remote processes but the PID of the new local process (the one that will become ssh after the exec call).

On the remote machine, when the SSH connection is stablished, sshd forks a new process that then forks a new shell that finally forks and executes the requested command.