package Smokeping::probes::basefork; =head1 301 Moved Permanently This is a Smokeping probe module. Please use the command C to view the documentation or the command C to generate the POD document. =cut use strict; use base qw(Smokeping::probes::basevars); use Symbol; use Carp; use IO::Select; use POSIX; # for ceil() and floor() use Config; # for signal names my $DEFAULTFORKS = 5; sub pod_hash { return { name => < < < method that forks the requested number of concurrent processes and calls the B method that derived classes must provide. The B method is called with one argument: a hash containing the target that is to be measured. The contents of the hash are described in I(3pm). The number of concurrent processes is determined by the probe-specific variable `forks' and is $DEFAULTFORKS by default. If there are more targets than this value, another round of forks is done after the first processes are finished. This continues until all the targets have been tested. The timeout in which each child has to finish is set to 5 seconds multiplied by the maximum number of 'pings' of the targets. You can set the base timeout differently if you want to, using the timeout property of the probe in the master config file (this again will be multiplied by the maximum number of pings). The probe itself can also provide another default value if desired by modifying the _default value of the timeout variable. If the child isn't finished when the timeout occurs, it will be killed along with any processes it has started. The number of pings sent can be specified in the target-specific variable 'pings'. DOC authors => <<'DOC', Niko Tyni DOC see_also => <, L DOC } } my %signo; my @signame; { # from perlipc man page my $i = 0; defined $Config{sig_name} || die "No sigs?"; foreach my $name (split(' ', $Config{sig_name})) { $signo{$name} = $i; $signame[$i] = $name; $i++; } } die("Missing TERM signal?") unless exists $signo{TERM}; die("Missing KILL signal?") unless exists $signo{KILL}; sub pingone { croak "pingone: this must be overridden by the subclass"; } sub probevars { my $class = shift; my $h = $class->SUPER::probevars; delete $h->{pings}; return $class->_makevars($h, { forks => { _re => '\d+', _example => 5, _doc => "Run this many concurrent processes at maximum", _default => $DEFAULTFORKS, }, timeout => { _re => '\d+', _example => 15, _default => 5, _doc => "How long a single 'ping' takes at maximum", }, }); } sub targetvars { my $class = shift; return $class->_makevars($class->SUPER::targetvars, { pings => { _re => '\d+', _sub => sub { my $val = shift; return "ERROR: The pings value must be at least 3." if $val < 3; return undef; }, _example => 5, _doc => <increment_rounds_count; my @targets = @{$self->targets}; return unless @targets; my $forks = $self->{properties}{forks}; my $maxpings = 0; my $maxtimeout = $self->{properties}{timeout}; for (@targets) { my $p = $self->pings($_); $maxpings = $p if $p > $maxpings; # some probes have a target-specific timeout variable # dig out the maximum timeout my $t = $_->{vars}{timeout}; $maxtimeout = $t if $t > $maxtimeout; } # we add 1 so that the probes doing their own timeout handling # have time to do it even in the worst case my $timeout = $maxpings * $maxtimeout + 1; $self->{rtts}={}; $self->do_debug("forks $forks, timeout for each target $timeout"); while (@targets) { my %targetlookup; my %pidlookup; my $s = IO::Select->new(); my $starttime = time(); for (1..$forks) { last unless @targets; my $t = pop @targets; my $pid; my $handle = gensym; my $sleep_count = 0; do { $pid = open($handle, "-|"); unless (defined $pid) { $self->do_log("cannot fork: $!"); $self->fatal("bailing out") if $sleep_count++ > 6; sleep 10; } } until defined $pid; if ($pid) { #parent $s->add($handle); $targetlookup{$handle} = $t; $pidlookup{$handle} = $pid; } else { #child # we detach from the parent's process group setpgrp(0, $$); # re-initialize the RNG for each subprocess srand(time()+$$); my @times = $self->pingone($t); print join(" ", @times), "\n"; exit; } } my $timeleft = $timeout - (time() - $starttime); while ($s->handles and $timeleft > 0) { for my $ready ($s->can_read($timeleft)) { $s->remove($ready); my $response = <$ready>; close $ready; chomp $response; my @times = split(/ /, $response); my $target = $targetlookup{$ready}; my $tree = $target->{tree}; $self->{rtts}{$tree} = \@times; $self->do_debug("$target->{addr}: got $response"); } $timeleft = $timeout - (time() - $starttime); } my @left = $s->handles; for my $handle (@left) { $self->do_log("$targetlookup{$handle}{addr}: timeout ($timeout s) reached, killing the probe."); # we kill the child's process group (negative signal) # this should finish off the actual pinger process as well my $pid = $pidlookup{$handle}; kill -$signo{TERM}, $pid; sleep 1; kill -$signo{KILL}, $pid; close $handle; $s->remove($handle); } } } # the "private" method that takes a "tree" argument is used by Smokeping.pm sub _pings { my $self = shift; my $tree = shift; my $vars = $self->vars($tree); return $vars->{pings} if defined $vars->{pings}; return $self->SUPER::pings(); } # the "public" method that takes a "target" argument is used by the probes sub pings { my $self = shift; my $target = shift; return $self->SUPER::pings() unless ref $target; return $self->_pings($target->{tree}); } sub ProbeDesc { return "Probe that can fork and doesn't override the ProbeDesc method"; } sub pod_variables { my $class = shift; my $pod = $class->SUPER::pod_variables; my $targetvars = $class->targetvars; $pod .= "Supported target-specific variables:\n\n"; $pod .= $class->_pod_variables($targetvars); return $pod; } 1;