X-Git-Url: http://gb7djk.dxcluster.net/gitweb/gitweb.cgi?a=blobdiff_plain;f=perl%2FDXCron.pm;h=c011d7b3d3e3df0740bfbdc3662edd6646b95d30;hb=refs%2Fheads%2Fnew-spawn;hp=961fa3a60df61c6aab1a096c16ef8412ba8e2806;hpb=cce161221036760959ff1d0b7628a55942bf558a;p=spider.git diff --git a/perl/DXCron.pm b/perl/DXCron.pm index 961fa3a6..c011d7b3 100644 --- a/perl/DXCron.pm +++ b/perl/DXCron.pm @@ -3,7 +3,7 @@ # # Copyright (c) 1998 - Dirk Koopman G1TLH # -# $Id$ +# # package DXCron; @@ -12,16 +12,18 @@ use DXVars; use DXUtil; use DXM; use DXDebug; -use FileHandle; -use Carp; +use IO::File; +use DXLog; + +use Mojo::IOLoop::Subprocess; use strict; -use vars qw{@crontab $mtime $lasttime}; +use vars qw{@crontab @lcrontab @scrontab $mtime $lasttime $lastmin}; -@crontab = (); $mtime = 0; $lasttime = 0; +$lastmin = 0; my $fn = "$main::cmd/crontab"; @@ -30,18 +32,25 @@ my $localfn = "$main::localcmd/crontab"; # cron initialisation / reading in cronjobs sub init { - my $t; - - if (-e $localfn) { - if (-e $localfn && ($t = -M $localfn) != $mtime) { - cread($localfn); - $mtime = $t; + if ((-e $localfn && -M $localfn < $mtime) || (-e $fn && -M $fn < $mtime) || $mtime == 0) { + my $t; + + # first read in the standard one + if (-e $fn) { + $t = -M $fn; + + @scrontab = cread($fn); + $mtime = $t if !$mtime || $t <= $mtime; } - return; - } - if (($t = -M $fn) != $mtime) { - cread($fn); - $mtime = $t; + + # then read in any local ones + if (-e $localfn) { + $t = -M $localfn; + + @lcrontab = cread($localfn); + $mtime = $t if $t <= $mtime; + } + @crontab = (@scrontab, @lcrontab); } } @@ -49,18 +58,18 @@ sub init sub cread { my $fn = shift; - my $fh = new FileHandle; + my $fh = new IO::File; my $line = 0; + my @out; - dbg('cron', "reading $fn\n"); - open($fh, $fn) or confess("can't open $fn $!"); - @crontab = (); # clear out the old stuff + dbg("DXCron::cread reading $fn\n") if isdbg('cron'); + open($fh, $fn) or confess("cron: can't open $fn $!"); while (<$fh>) { $line++; - + chomp; next if /^\s*#/o or /^\s*$/o; - my ($min, $hour, $mday, $month, $wday, $cmd) = /^\s*(\w+)\s+(\w+)\s+(\w+)\s+(\w+)\s+(\w+)\s+(.+)$/o; - next if !$min; + my ($min, $hour, $mday, $month, $wday, $cmd) = /^\s*(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(.+)$/o; + next unless defined $min; my $ref = bless {}; my $err; @@ -71,13 +80,14 @@ sub cread $err |= parse($ref, 'wday', $wday, 0, 6, "sun", "mon", "tue", "wed", "thu", "fri", "sat"); if (!$err) { $ref->{cmd} = $cmd; - push @crontab, $ref; - dbg('cron', "adding $_\n"); + push @out, $ref; + dbg("DXCron::cread: adding $_\n") if isdbg('cron'); } else { - dbg('cron', "error on line $line '$_'\n"); + dbg("DXCron::cread: error on line $line '$_'\n") if isdbg('cron'); } } close($fh); + return @out; } sub parse @@ -111,6 +121,8 @@ sub parse push @req, 0 + $_; } } + $ref->{$sort} = \@req; + return 0; } @@ -118,11 +130,190 @@ sub parse sub process { my $now = $main::systime; + return if $now-$lasttime < 1; - if ($now - $lasttime >= 60) { - my ($sec, $min, $hour, $mday, $mon, $wday) = (gmtime($main::systime))[0-4,6]; + my ($sec, $min, $hour, $mday, $mon, $wday) = (gmtime($now))[0,1,2,3,4,6]; + + # are we at a minute boundary? + if ($min != $lastmin) { - $lasttime = $now; + # read in any changes if the modification time has changed + init(); + + $mon += 1; # months otherwise go 0-11 + my $cron; + foreach $cron (@crontab) { + if ((!$cron->{min} || grep $_ eq $min, @{$cron->{min}}) && + (!$cron->{hour} || grep $_ eq $hour, @{$cron->{hour}}) && + (!$cron->{mday} || grep $_ eq $mday, @{$cron->{mday}}) && + (!$cron->{mon} || grep $_ eq $mon, @{$cron->{mon}}) && + (!$cron->{wday} || grep $_ eq $wday, @{$cron->{wday}}) ){ + + if ($cron->{cmd}) { + dbg("cron: $min $hour $mday $mon $wday -> doing '$cron->{cmd}'") if isdbg('cron'); + eval "$cron->{cmd}"; + dbg("cron: cmd error $@") if $@ && isdbg('cron'); + } + } + } + } + + # remember when we are now + $lasttime = $now; + $lastmin = $min; +} + +# +# these are simple stub functions to make connecting easy in DXCron contexts +# + +# is it locally connected? +sub connected +{ + my $call = uc shift; + return DXChannel::get($call); +} + +# is it remotely connected anywhere (with exact callsign)? +sub present +{ + my $call = uc shift; + return Route::get($call); +} + +# is it remotely connected anywhere (ignoring SSIDS)? +sub presentish +{ + my $call = uc shift; + my $c = Route::get($call); + unless ($c) { + for (1..15) { + $c = Route::get("$call-$_"); + last if $c; + } + } + return $c; +} + +# is it remotely connected anywhere (with exact callsign) and on node? +sub present_on +{ + my $call = uc shift; + my $ncall = uc shift; + my $node = Route::Node::get($ncall); + return ($node) ? grep $call eq $_, $node->users : undef; +} + +# is it remotely connected (ignoring SSIDS) and on node? +sub presentish_on +{ + my $call = uc shift; + my $ncall = uc shift; + my $node = Route::Node::get($ncall); + my $present; + if ($node) { + $present = grep {/^$call/ } $node->users; + } + return $present; +} + +# last time this thing was connected +sub last_connect +{ + my $call = uc shift; + return $main::systime if DXChannel::get($call); + my $user = DXUser::get($call); + return $user ? $user->lastin : 0; +} + +# disconnect a locally connected thing +sub disconnect +{ + my $call = shift; + run_cmd("disconnect $call"); +} + +# start a connect process off +sub start_connect +{ + my $call = shift; + # connecting is now done in one place - Yeah! + run_cmd("connect $call"); +} + +# spawn any old job off +sub spawn +{ + my $line = shift; + + dbg("DXCron::spawn: $line") if isdbg("cron"); + my $fc = Mojo::IOLoop::Subprocess->new(); + $fc->run( + sub {my @res = `$line`; return @res}, + sub { + my ($fc, $err, @res) = @_; + if ($err) { + my $s = "DXCron::spawn: error $err"; + dbg($s); + return; + } + for (@res) { + chomp; + dbg("DXCron::spawn: $_") if isdbg("cron"); + } + } + ); +} + +sub spawn_cmd +{ + my $line = shift; + + dbg("DXCron::spawn_cmd run: $line") if isdbg('cron'); + my $fc = Mojo::IOLoop::Subprocess->new(); + $fc->run( + sub { + $main::me->{_nospawn} = 1; + my @res = $main::me->run_cmd($line); + delete $main::me->{_nospawn}; + return @res; + }, + sub { + my ($fc, $err, @res) = @_; + if ($err) { + my $s = "DXCron::spawn_cmd: error $err"; + dbg($s); + } + for (@res) { + chomp; + dbg("DXCron::spawn_cmd: $_") if isdbg("cron"); + } + } + ); +} + +# do an rcmd to another cluster from the crontab +sub rcmd +{ + my $call = uc shift; + my $line = shift; + + # can we see it? Is it a node? + my $noderef = Route::Node::get($call); + return unless $noderef && $noderef->version; + + # send it + DXProt::addrcmd($main::me, $call, $line); +} + +sub run_cmd +{ + my $line = shift; + my @in = $main::me->run_cmd($line); + dbg("DXCron::run_cmd: $line") if isdbg('cron'); + for (@in) { + s/\s*$//og; + dbg("DXCron::cmd out: $_") if isdbg('cron'); } }