--- /dev/null
+# Copyright (C) 2002 Stanislav Sinyagin
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
+
+# $Id: Scheduler.pm,v 1.1 2010-12-27 00:03:39 ivan Exp $
+# Stanislav Sinyagin <ssinyagin@yahoo.com>
+
+
+# Task scheduler.
+# Task object MUST implement two methods:
+# run() -- the running cycle
+# whenNext() -- returns the next time it must be run.
+# See below the Torrus::Scheduler::PeriodicTask class definition
+#
+# Options:
+# -Tree => tree name
+# -ProcessName => process name and commandline options
+# -RunOnce => 1 -- this prevents from infinite loop.
+
+
+package Torrus::Scheduler;
+
+use strict;
+use Torrus::SchedulerInfo;
+use Torrus::Log;
+
+sub new
+{
+ my $self = {};
+ my $class = shift;
+ my %options = @_;
+ bless $self, $class;
+
+ %{$self->{'options'}} = %options;
+ %{$self->{'data'}} = ();
+
+ if( not defined( $options{'-Tree'} ) or
+ not defined( $options{'-ProcessName'} ) )
+ {
+ die();
+ }
+
+ $self->{'stats'} = new Torrus::SchedulerInfo( -Tree => $options{'-Tree'},
+ -WriteAccess => 1 );
+ return $self;
+}
+
+
+sub DESTROY
+{
+ my $self = shift;
+ delete $self->{'stats'};
+}
+
+sub treeName
+{
+ my $self = shift;
+ return $self->{'options'}{'-Tree'};
+}
+
+sub setProcessStatus
+{
+ my $self = shift;
+ my $text = shift;
+ $0 = $self->{'options'}{'-ProcessName'} . ' [' . $text . ']';
+}
+
+sub addTask
+{
+ my $self = shift;
+ my $task = shift;
+ my $when = shift;
+
+ if( not defined $when )
+ {
+ # If not specified, run immediately
+ $when = time() - 1;
+ }
+ $self->storeTask( $task, $when );
+ $self->{'stats'}->clearStats( $task->id() );
+}
+
+
+sub storeTask
+{
+ my $self = shift;
+ my $task = shift;
+ my $when = shift;
+
+ if( not defined( $self->{'tasks'}{$when} ) )
+ {
+ $self->{'tasks'}{$when} = [];
+ }
+ push( @{$self->{'tasks'}{$when}}, $task );
+}
+
+
+sub flushTasks
+{
+ my $self = shift;
+
+ if( defined( $self->{'tasks'} ) )
+ {
+ foreach my $when ( keys %{$self->{'tasks'}} )
+ {
+ foreach my $task ( @{$self->{'tasks'}{$when}} )
+ {
+ $self->{'stats'}->clearStats( $task->id() );
+ }
+ }
+ undef $self->{'tasks'};
+ }
+}
+
+
+sub run
+{
+ my $self = shift;
+
+ my $stop = 0;
+
+ while( not $stop )
+ {
+ $self->setProcessStatus('initializing scheduler');
+ while( not $self->beforeRun() )
+ {
+ &Torrus::DB::checkInterrupted();
+
+ Error('Scheduler initialization error. Sleeping ' .
+ $Torrus::Scheduler::failedInitSleep . ' seconds');
+
+ &Torrus::DB::setUnsafeSignalHandlers();
+ sleep($Torrus::Scheduler::failedInitSleep);
+ &Torrus::DB::setSafeSignalHandlers();
+ }
+ $self->setProcessStatus('');
+ my $nextRun = time() + 3600;
+ foreach my $when ( keys %{$self->{'tasks'}} )
+ {
+ # We have 1-second rounding error
+ if( $when <= time() + 1 )
+ {
+ foreach my $task ( @{$self->{'tasks'}{$when}} )
+ {
+ &Torrus::DB::checkInterrupted();
+
+ my $startTime = time();
+
+ $self->beforeTaskRun( $task, $startTime, $when );
+ $task->beforeRun( $self->{'stats'} );
+
+ $self->setProcessStatus('running');
+ $task->run();
+ my $whenNext = $task->whenNext();
+
+ $task->afterRun( $self->{'stats'}, $startTime );
+ $self->afterTaskRun( $task, $startTime );
+
+ if( $whenNext > 0 )
+ {
+ if( $whenNext == $when )
+ {
+ Error("Incorrect time returned by task");
+ }
+ $self->storeTask( $task, $whenNext );
+ if( $nextRun > $whenNext )
+ {
+ $nextRun = $whenNext;
+ }
+ }
+ }
+ delete $self->{'tasks'}{$when};
+ }
+ elsif( $nextRun > $when )
+ {
+ $nextRun = $when;
+ }
+ }
+
+ if( $self->{'options'}{'-RunOnce'} or
+ ( scalar( keys %{$self->{'tasks'}} ) == 0 and
+ not $self->{'options'}{'-RunAlways'} ) )
+ {
+ $self->setProcessStatus('');
+ $stop = 1;
+ }
+ else
+ {
+ if( scalar( keys %{$self->{'tasks'}} ) == 0 )
+ {
+ Info('Tasks list is empty. Will sleep until ' .
+ scalar(localtime($nextRun)));
+ }
+
+ $self->setProcessStatus('sleeping');
+ &Torrus::DB::setUnsafeSignalHandlers();
+ Debug('We will sleep until ' . scalar(localtime($nextRun)));
+
+ if( $Torrus::Scheduler::maxSleepTime > 0 )
+ {
+ Debug('This is a VmWare-like clock. We devide the sleep ' .
+ 'interval into small pieces');
+ while( time() < $nextRun )
+ {
+ my $sleep = $nextRun - time();
+ if( $sleep > $Torrus::Scheduler::maxSleepTime )
+ {
+ $sleep = $Torrus::Scheduler::maxSleepTime;
+ }
+ Debug('Sleeping ' . $sleep . ' seconds');
+ sleep( $sleep );
+ }
+ }
+ else
+ {
+ my $sleep = $nextRun - time();
+ if( $sleep > 0 )
+ {
+ sleep( $sleep );
+ }
+ }
+
+ &Torrus::DB::setSafeSignalHandlers();
+ }
+ }
+}
+
+
+# A method to override by ancestors. Executed every time before the
+# running cycle. Must return true value when finishes.
+sub beforeRun
+{
+ my $self = shift;
+ Debug('Torrus::Scheduler::beforeRun() - doing nothing');
+ return 1;
+}
+
+
+sub beforeTaskRun
+{
+ my $self = shift;
+ my $task = shift;
+ my $startTime = shift;
+ my $plannedStartTime = shift;
+
+ if( not $task->didNotRun() and $startTime > $plannedStartTime + 1 )
+ {
+ my $late = $startTime - $plannedStartTime;
+ Verbose(sprintf('Task delayed %d seconds', $late));
+ $self->{'stats'}->setStatsValues( $task->id(), 'LateStart', $late );
+ }
+}
+
+
+sub afterTaskRun
+{
+ my $self = shift;
+ my $task = shift;
+ my $startTime = shift;
+
+ my $len = time() - $startTime;
+ Verbose(sprintf('%s task finished in %d seconds', $task->name(), $len));
+
+ $self->{'stats'}->setStatsValues( $task->id(), 'RunningTime', $len );
+}
+
+
+# User data can be stored here
+sub data
+{
+ my $self = shift;
+ return $self->{'data'};
+}
+
+
+# Periodic task base class
+# Options:
+# -Period => seconds -- cycle period
+# -Offset => seconds -- time offset from even period moments
+# -Name => "string" -- Symbolic name for log messages
+# -Instance => N -- instance number
+
+package Torrus::Scheduler::PeriodicTask;
+
+use Torrus::Log;
+use strict;
+
+sub new
+{
+ my $self = {};
+ my $class = shift;
+ my %options = @_;
+ bless $self, $class;
+
+ if( not defined( $options{'-Instance'} ) )
+ {
+ $options{'-Instance'} = 0;
+ }
+
+ %{$self->{'options'}} = %options;
+
+ $self->{'options'}{'-Period'} = 0 unless
+ defined( $self->{'options'}{'-Period'} );
+
+ $self->{'options'}{'-Offset'} = 0 unless
+ defined( $self->{'options'}{'-Offset'} );
+
+ $self->{'options'}{'-Name'} = "PeriodicTask" unless
+ defined( $self->{'options'}{'-Name'} );
+
+ $self->{'missedPeriods'} = 0;
+
+ $self->{'options'}{'-Started'} = time();
+
+ # Array of (Name, Value) pairs for any kind of stats
+ $self->{'statValues'} = [];
+
+ Debug("New Periodic Task created: period=" .
+ $self->{'options'}{'-Period'} .
+ " offset=" . $self->{'options'}{'-Offset'});
+
+ return $self;
+}
+
+
+sub whenNext
+{
+ my $self = shift;
+
+ if( $self->period() > 0 )
+ {
+ my $now = time();
+ my $period = $self->period();
+ my $offset = $self->offset();
+ my $previous;
+
+ if( defined $self->{'previousSchedule'} )
+ {
+ if( $now - $self->{'previousSchedule'} <= $period )
+ {
+ $previous = $self->{'previousSchedule'};
+ }
+ elsif( not $Torrus::Scheduler::ignoreClockSkew )
+ {
+ Error('Last run of ' . $self->{'options'}{'-Name'} .
+ ' was more than ' . $period . ' seconds ago');
+ $self->{'missedPeriods'} =
+ int( ($now - $self->{'previousSchedule'}) / $period );
+ }
+ }
+ if( not defined( $previous ) )
+ {
+ $previous = $now - ($now % $period) + $offset;
+ }
+
+ my $whenNext = $previous + $period;
+ $self->{'previousSchedule'} = $whenNext;
+
+ Debug("Task ". $self->{'options'}{'-Name'}.
+ " wants to run next time at " . scalar(localtime($whenNext)));
+ return $whenNext;
+ }
+ else
+ {
+ return undef;
+ }
+}
+
+
+sub beforeRun
+{
+ my $self = shift;
+ my $stats = shift;
+
+ Verbose(sprintf('%s periodic task started. Period: %d:%.2d; ' .
+ 'Offset: %d:%.2d',
+ $self->name(),
+ int( $self->period() / 60 ), $self->period() % 60,
+ int( $self->offset() / 60 ), $self->offset() % 60));
+}
+
+
+sub afterRun
+{
+ my $self = shift;
+ my $stats = shift;
+ my $startTime = shift;
+
+ my $len = time() - $startTime;
+ if( $len > $self->period() )
+ {
+ Warn(sprintf('%s task execution (%d) longer than period (%d)',
+ $self->name(), $len, $self->period()));
+
+ $stats->setStatsValues( $self->id(), 'TooLong', $len );
+ $stats->incStatsCounter( $self->id(), 'OverrunPeriods',
+ int( $len > $self->period() ) );
+ }
+
+ if( $self->{'missedPeriods'} > 0 )
+ {
+ $stats->incStatsCounter( $self->id(), 'MissedPeriods',
+ $self->{'missedPeriods'} );
+ $self->{'missedPeriods'} = 0;
+ }
+
+ foreach my $pair( @{$self->{'statValues'}} )
+ {
+ $stats->setStatsValues( $self->id(), @{$pair} );
+ }
+ @{$self->{'statValues'}} = [];
+}
+
+
+sub run
+{
+ my $self = shift;
+ Error("Dummy class Torrus::Scheduler::PeriodicTask was run");
+}
+
+
+sub period
+{
+ my $self = shift;
+ return $self->{'options'}->{'-Period'};
+}
+
+
+sub offset
+{
+ my $self = shift;
+ return $self->{'options'}->{'-Offset'};
+}
+
+
+sub didNotRun
+{
+ my $self = shift;
+ return( not defined( $self->{'previousSchedule'} ) );
+}
+
+
+sub name
+{
+ my $self = shift;
+ return $self->{'options'}->{'-Name'};
+}
+
+sub instance
+{
+ my $self = shift;
+ return $self->{'options'}->{'-Instance'};
+}
+
+
+sub whenStarted
+{
+ my $self = shift;
+ return $self->{'options'}->{'-Started'};
+}
+
+
+sub id
+{
+ my $self = shift;
+ return join(':', 'P', $self->name(), $self->instance(),
+ $self->period(), $self->offset());
+}
+
+sub setStatValue
+{
+ my $self = shift;
+ my $name = shift;
+ my $value = shift;
+
+ push( @{$self->{'statValues'}}, [$name, $value] );
+}
+
+1;
+
+
+# Local Variables:
+# mode: perl
+# indent-tabs-mode: nil
+# perl-indent-level: 4
+# End:
projects / freeside.git / blobdiff