def get_timeuntil(self):
"""
Returns a string representing the time until the next
time this Job will be run (actually, the "string" returned
is really an instance of ``ugettext_lazy``).
>>> from chronograph.compatibility.dates import now
>>> job = Job(next_run=now())
>>> job.get_timeuntil().translate('en')
u'due'
"""
if self.disabled:
return _('never (disabled)')
delta = self.next_run - dates.now()
if delta.days < 0:
# The job is past due and should be run as soon as possible
if self.check_is_running():
return _('running')
return _('due')
elif delta.seconds < 60:
# Adapted from django.utils.timesince
count = lambda n: ungettext('second', 'seconds', n)
return ugettext('%(number)d %(type)s') % {'number': delta.seconds,
'type': count(delta.seconds)}
return timeuntil(self.next_run)
def get_timeuntil(self):
"""
Returns a string representing the time until the next
time this Job will be run (actually, the "string" returned
is really an instance of ``ugettext_lazy``).
>>> from chronograph.compatibility.dates import now
>>> job = Job(next_run=now())
>>> job.get_timeuntil().translate('en')
u'due'
"""
if self.disabled:
return _('never (disabled)')
delta = self.next_run - dates.now()
if delta.days < 0:
# The job is past due and should be run as soon as possible
if self.check_is_running():
return _('running')
return _('due')
elif delta.seconds < 60:
# Adapted from django.utils.timesince
count = lambda n: ungettext('second', 'seconds', n)
return ugettext('%(number)d %(type)s') % {'number': delta.seconds,
'type': count(delta.seconds)}
return timeuntil(self.next_run)
def due(self):
"""
Returns a ``QuerySet`` of all jobs waiting to be run. NOTE: this may
return ``Job``s that are still currently running; it is your
responsibility to call ``Job.check_is_running()`` to determine whether
or not the ``Job`` actually needs to be run.
"""
return self.filter(disabled=False).filter(models.Q(next_run__lte=dates.now()) | models.Q(force_run=True))
def due(self):
"""
Returns a ``QuerySet`` of all jobs waiting to be run. NOTE: this may
return ``Job``s that are still currently running; it is your
responsibility to call ``Job.check_is_running()`` to determine whether
or not the ``Job`` actually needs to be run.
"""
return self.filter(disabled=False).filter(models.Q(next_run__lte=dates.now()) | models.Q(force_run=True))
def run(self):
"""
This method implements the code to actually run a ``Job``.
"""
args = None
options = None
job = None
last_run_successful = None
heartbeat = None
job_is_running = False
run_date = dates.now()
# Update job with running data.
with transaction.commit_on_success():
job = Job.objects.lock_job(self.job_id)
if not job.check_is_running():
args, options = job.get_args()
heartbeat = JobHeartbeatThread()
job.is_running = True
job.lock_file = heartbeat.lock_file.name
job.save()
else:
job_is_running = True
# Only proceed if the job is not already running.
if not job_is_running:
# Redirect output so that we can log it if there is any
stdout = StringIO()
stderr = StringIO()
ostdout = sys.stdout
ostderr = sys.stderr
sys.stdout = stdout
sys.stderr = stderr
stdout_str, stderr_str = "", ""
# Start job heartbeat.
heartbeat.start()
try:
logger.debug("Calling command '%s'" % job.command)
call_command(job.command, *args, **options)
logger.debug("Command '%s' completed" % job.command)
last_run_successful = True
except Exception, e:
try:
# The command failed to run; log the exception
t = loader.get_template('chronograph/error_message.txt')
c = Context({
'exception': unicode(e),
'traceback': ['\n'.join(traceback.format_exception(*sys.exc_info()))]
})
stderr_str += t.render(c)
except Exception, e2:
sys.stderr.write('Caught exception (%s) while handling job exception (%s)' % (e2, e))
last_run_successful = False
def get_timeuntil(self, obj):
if obj.force_run:
next_run = dates.localtime(dates.now())
time_until = _("forced")
else:
next_run = dates.localtime(obj.next_run)
time_until = obj.get_timeuntil()
value = capfirst(dates.local_dateformat(next_run))
return "%s<br /><span class='mini'>(%s)</span>" % (value, time_until)
def get_timeuntil(self, obj):
if obj.force_run:
next_run = dates.localtime(dates.now())
time_until = _("forced")
else:
next_run = dates.localtime(obj.next_run)
time_until = obj.get_timeuntil()
value = capfirst(dates.local_dateformat(next_run))
return "%s<br /><span class='mini'>(%s)</span>" % (value, time_until)
def handle_run(self):
"""
This method implements the code to actually run a ``Job``. This is
meant to be run, primarily, by the `run_job` management command as a
subprocess, which can be invoked by calling this ``Job``\'s ``run``
method.
"""
args, options = self.get_args()
stdout = StringIO()
stderr = StringIO()
# Redirect output so that we can log it if there is any
ostdout = sys.stdout
ostderr = sys.stderr
sys.stdout = stdout
sys.stderr = stderr
stdout_str, stderr_str = "", ""
heartbeat = JobHeartbeatThread()
run_date = dates.now()
self.is_running = True
self.pid = os.getpid()
self.lock_file = heartbeat.lock_file.name
was_forced = False
if self.force_run:
self.force_run = False
was_forced = True
self.save(force_update=True)
heartbeat.start()
try:
logger.debug("Calling command '%s'" % self.command)
call_command(self.command, *args, **options)
logger.debug("Command '%s' completed" % self.command)
self.last_run_successful = True
except Exception, e:
# The command failed to run; log the exception
t = loader.get_template('chronograph/error_message.txt')
c = Context({
'exception': unicode(e),
'traceback': ['\n'.join(traceback.format_exception(*sys.exc_info()))]
})
stderr_str += t.render(c)
self.last_run_successful = False
def save(self, *args, **kwargs):
if not self.disabled:
if self.pk:
j = Job.objects.get(pk=self.pk)
else:
j = self
if not self.next_run or j.params != self.params:
logger.debug("Updating 'next_run")
next_run = self.next_run
if not next_run:
next_run = dates.now()
self.next_run = dates.make_aware(self.rrule.after(next_run))
else:
self.next_run = None
super(Job, self).save(*args, **kwargs)
def save(self, *args, **kwargs):
if not self.disabled:
if self.pk:
j = Job.objects.get(pk=self.pk)
else:
j = self
if not self.next_run or j.params != self.params:
logger.debug("Updating 'next_run")
next_run = self.next_run
if not next_run:
next_run = dates.now()
next_run = dates.make_naive(next_run)
self.next_run = dates.make_aware(self.rrule.after(next_run))
else:
self.next_run = None
super(Job, self).save(*args, **kwargs)
def handle_run(self):
"""
This method implements the code to actually run a ``Job``. This is
meant to be run, primarily, by the `run_job` management command as a
subprocess, which can be invoked by calling this ``Job``\'s ``run``
method.
"""
args, options = self.get_args()
stdout = StringIO()
stderr = StringIO()
# Redirect output so that we can log it if there is any
ostdout = sys.stdout
ostderr = sys.stderr
sys.stdout = stdout
sys.stderr = stderr
stdout_str, stderr_str = "", ""
heartbeat = JobHeartbeatThread()
run_date = dates.now()
self.is_running = True
self.lock_file = heartbeat.lock_file.name
self.save()
heartbeat.start()
try:
logger.debug("Calling command '%s'" % self.command)
call_command(self.command, *args, **options)
logger.debug("Command '%s' completed" % self.command)
self.last_run_successful = True
except Exception, e:
# The command failed to run; log the exception
t = loader.get_template('chronograph/error_message.txt')
c = Context({
'exception':
unicode(e),
'traceback':
['\n'.join(traceback.format_exception(*sys.exc_info()))]
})
stderr_str += t.render(c)
self.last_run_successful = False
def is_due(self):
"""
>>> from chronograph.compatibility.dates import now
>>> job = Job(next_run=now())
>>> job.is_due()
True
>>> job = Job(next_run=now()+timedelta(seconds=60))
>>> job.is_due()
False
>>> job.force_run = True
>>> job.is_due()
True
>>> job = Job(next_run=now(), disabled=True)
>>> job.is_due()
False
"""
reqs = (self.next_run <= dates.now() and self.disabled == False
and self.check_is_running() == False)
return (reqs or self.force_run)
def is_due(self):
"""
>>> from chronograph.compatibility.dates import now
>>> job = Job(next_run=now())
>>> job.is_due()
True
>>> job = Job(next_run=now()+timedelta(seconds=60))
>>> job.is_due()
False
>>> job.force_run = True
>>> job.is_due()
True
>>> job = Job(next_run=now(), disabled=True)
>>> job.is_due()
False
"""
reqs = (self.next_run <= dates.now() and self.disabled == False
and self.check_is_running() == False)
return (reqs or self.force_run)
class Job(models.Model):
"""
A recurring ``django-admin`` command to be run.
"""
name = models.CharField(_("name"), max_length=200)
frequency = models.CharField(_("frequency"), choices=freqs, max_length=10)
params = models.TextField(_("params"),
null=True,
blank=True,
help_text=_(
'Comma-separated list of '
'<a href="http://labix.org/python-dateutil" '
'target="_blank">rrule parameters</a>. '
'e.g: interval:15'))
command = models.CharField(_("command"),
max_length=200,
blank=True,
help_text=_("A valid django-admin command to "
"run."))
args = models.CharField(
_("args"),
max_length=200,
blank=True,
help_text=_("Space separated list; e.g: arg1 option1=True"))
disabled = models.BooleanField(default=False,
help_text=_('If checked this '
'job will never '
'run.'))
next_run = models.DateTimeField(_("next run"),
blank=True,
null=True,
help_text=_(
"If you don't set this it will"
" be determined automatically"))
last_run = models.DateTimeField(_("last run"),
editable=False,
blank=True,
null=True)
is_running = models.BooleanField(default=False, editable=False)
last_run_successful = models.BooleanField(default=True,
blank=False,
null=False,
editable=False)
subscribers = models.ManyToManyField(User,
blank=True,
limit_choices_to={'is_staff': True})
lock_file = models.CharField(max_length=255, blank=True, editable=False)
force_run = models.BooleanField(default=False)
objects = JobManager()
class Meta:
ordering = (
'disabled',
'next_run',
)
def __unicode__(self):
if self.disabled:
return _(u"%(name)s - disabled") % {'name': self.name}
return u"%s - %s" % (self.name, self.timeuntil)
def save(self, *args, **kwargs):
if not self.disabled:
if self.pk:
j = Job.objects.get(pk=self.pk)
else:
j = self
if not self.next_run or j.params != self.params:
logger.debug("Updating 'next_run")
next_run = self.next_run
if not next_run:
next_run = dates.now()
next_run = dates.make_naive(next_run)
self.next_run = dates.make_aware(self.rrule.after(next_run))
else:
self.next_run = None
super(Job, self).save(*args, **kwargs)
def get_timeuntil(self):
"""
Returns a string representing the time until the next
time this Job will be run (actually, the "string" returned
is really an instance of ``ugettext_lazy``).
>>> from chronograph.compatibility.dates import now
>>> job = Job(next_run=now())
>>> job.get_timeuntil().translate('en')
u'due'
"""
if self.disabled:
return _('never (disabled)')
delta = self.next_run - dates.now()
if delta.days < 0:
# The job is past due and should be run as soon as possible
if self.check_is_running():
return _('running')
return _('due')
elif delta.seconds < 60:
# Adapted from django.utils.timesince
count = lambda n: ungettext('second', 'seconds', n)
return ugettext('%(number)d %(type)s') % {
'number': delta.seconds,
'type': count(delta.seconds)
}
return timeuntil(self.next_run)
get_timeuntil.short_description = _('time until next run')
timeuntil = property(get_timeuntil)
def get_rrule(self):
"""
Returns the rrule objects for this ``Job``. Can also be accessed via the
``rrule`` property of the ``Job``.
# Every minute
>>> last_run = datetime(2011, 8, 4, 7, 19)
>>> job = Job(frequency="MINUTELY", params="interval:1", last_run=last_run)
>>> print job.get_rrule().after(last_run)
2011-08-04 07:20:00
# Every 2 hours
>>> job = Job(frequency="HOURLY", params="interval:2", last_run=last_run)
>>> print job.get_rrule().after(last_run)
2011-08-04 09:19:00
"""
frequency = eval('rrule.%s' % self.frequency)
return rrule.rrule(frequency,
dtstart=self.last_run,
**self.get_params())
rrule = property(get_rrule)
def param_to_int(self, param_value):
"""
Converts a valid rrule parameter to an integer if it is not already one, else
raises a ``ValueError``. The following are equivalent:
>>> job = Job(params = "byweekday:1,2,4,5")
>>> job.get_params()
{'byweekday': [1, 2, 4, 5]}
>>> job = Job(params = "byweekday:TU,WE,FR,SA")
>>> job.get_params()
{'byweekday': [1, 2, 4, 5]}
"""
if param_value in RRULE_WEEKDAY_DICT:
return RRULE_WEEKDAY_DICT[param_value]
try:
val = int(param_value)
except ValueError:
raise ValueError('rrule parameter should be integer or weekday '
'constant (e.g. MO, TU, etc.). '
'Error on: %s' % param_value)
else:
return val
def get_params(self):
"""
Converts a string of parameters into a dict.
>>> job = Job(params = "count:1;bysecond:1;byminute:1,2,4,5")
>>> job.get_params()
{'count': 1, 'byminute': [1, 2, 4, 5], 'bysecond': 1}
"""
if self.params is None:
return {}
params = self.params.split(';')
param_dict = []
for param in params:
if param.strip() == "":
continue # skip blanks
param = param.split(':')
if len(param) == 2:
param = (str(param[0]).strip(), [
self.param_to_int(p.strip()) for p in param[1].split(',')
])
if len(param[1]) == 1:
param = (param[0], param[1][0])
param_dict.append(param)
return dict(param_dict)
def get_args(self):
"""
Processes the args and returns a tuple or (args, options) for passing
to ``call_command``.
>>> job = Job(args="arg1 arg2 kwarg1='some value'")
>>> job.get_args()
(['arg1', 'arg2', "value'"], {'kwarg1': "'some"})
"""
args = []
options = {}
for arg in self.args.split():
if arg.find('=') > -1:
key, value = arg.split('=')
options[smart_str(key)] = smart_str(value)
else:
args.append(arg)
return (args, options)
def is_due(self):
"""
>>> from chronograph.compatibility.dates import now
>>> job = Job(next_run=now())
>>> job.is_due()
True
>>> job = Job(next_run=now()+timedelta(seconds=60))
>>> job.is_due()
False
>>> job.force_run = True
>>> job.is_due()
True
>>> job = Job(next_run=now(), disabled=True)
>>> job.is_due()
False
"""
reqs = (self.next_run <= dates.now() and self.disabled == False
and self.check_is_running() == False)
return (reqs or self.force_run)
def run(self):
"""
Runs this ``Job``. A ``Log`` will be created if there is any output
from either stdout or stderr.
Returns ``True`` if the ``Job`` ran, ``False`` otherwise.
"""
if not self.disabled:
if not self.check_is_running() and self.is_due():
call_command('run_job', str(self.pk))
return True
return False
def handle_run(self):
"""
This method implements the code to actually run a ``Job``. This is
meant to be run, primarily, by the `run_job` management command as a
subprocess, which can be invoked by calling this ``Job``\'s ``run``
method.
"""
args, options = self.get_args()
stdout = StringIO()
stderr = StringIO()
# Redirect output so that we can log it if there is any
ostdout = sys.stdout
ostderr = sys.stderr
sys.stdout = stdout
sys.stderr = stderr
stdout_str, stderr_str = "", ""
heartbeat = JobHeartbeatThread()
run_date = dates.now()
self.is_running = True
self.lock_file = heartbeat.lock_file.name
self.save()
heartbeat.start()
try:
logger.debug("Calling command '%s'" % self.command)
call_command(self.command, *args, **options)
logger.debug("Command '%s' completed" % self.command)
self.last_run_successful = True
except Exception, e:
# The command failed to run; log the exception
t = loader.get_template('chronograph/error_message.txt')
c = Context({
'exception':
unicode(e),
'traceback':
['\n'.join(traceback.format_exception(*sys.exc_info()))]
})
stderr_str += t.render(c)
self.last_run_successful = False
# Stop the heartbeat
logger.debug("Stopping heartbeat")
heartbeat.stop()
heartbeat.join()
duration = dates.total_seconds(dates.now() - run_date)
self.is_running = False
self.lock_file = ""
# Only care about minute-level resolution
self.last_run = dates.localtime(
dates.make_aware(
datetime(run_date.year, run_date.month, run_date.day,
run_date.hour, run_date.minute)))
# If this was a forced run, then don't update the
# next_run date
if self.force_run:
logger.debug("Resetting 'force_run'")
self.force_run = False
else:
logger.debug("Determining 'next_run'")
while self.next_run < dates.now():
self.next_run = dates.make_aware(
self.rrule.after(self.next_run))
logger.debug("'next_run = ' %s" % self.next_run)
self.save()
# If we got any output, save it to the log
stdout_str += stdout.getvalue()
stderr_str += stderr.getvalue()
if stderr_str:
# If anything was printed to stderr, consider the run
# unsuccessful
self.last_run_successful = False
if stdout_str or stderr_str:
log = Log.objects.create(job=self,
run_date=run_date,
stdout=stdout_str,
stderr=stderr_str,
success=self.last_run_successful,
duration=duration)
# Redirect output back to default
sys.stdout = ostdout
sys.stderr = ostderr
def handle_run(self):
"""
This method implements the code to actually run a ``Job``. This is
meant to be run, primarily, by the `run_job` management command as a
subprocess, which can be invoked by calling this ``Job``\'s ``run``
method.
"""
args, options = self.get_args()
stdout = StringIO()
stderr = StringIO()
# Redirect output so that we can log it if there is any
ostdout = sys.stdout
ostderr = sys.stderr
sys.stdout = stdout
sys.stderr = stderr
stdout_str, stderr_str = "", ""
heartbeat = JobHeartbeatThread()
run_date = dates.now()
self.is_running = True
self.lock_file = heartbeat.lock_file.name
self.save()
heartbeat.start()
try:
logger.debug("Calling command '%s'" % self.command)
call_command(self.command, *args, **options)
logger.debug("Command '%s' completed" % self.command)
self.last_run_successful = True
except Exception as e:
# The command failed to run; log the exception
t = loader.get_template('chronograph/error_message.txt')
c = Context({
'exception':
unicode(e),
'traceback':
['\n'.join(traceback.format_exception(*sys.exc_info()))]
})
stderr_str += t.render(c)
self.last_run_successful = False
# Stop the heartbeat
logger.debug("Stopping heartbeat")
heartbeat.stop()
heartbeat.join()
duration = (dates.now() - run_date).total_seconds()
self.is_running = False
self.lock_file = ""
# Only care about minute-level resolution
self.last_run = dates.make_aware(
datetime(run_date.year, run_date.month, run_date.day,
run_date.hour, run_date.minute))
# If this was a forced run, then don't update the
# next_run date
if self.force_run:
logger.debug("Resetting 'force_run'")
self.force_run = False
else:
logger.debug("Determining 'next_run'")
while self.next_run < dates.now():
self.next_run = dates.make_aware(
self.rrule.after(self.next_run))
logger.debug("'next_run = ' %s" % self.next_run)
self.save()
# If we got any output, save it to the log
stdout_str += stdout.getvalue()
stderr_str += stderr.getvalue()
if stderr_str:
# If anything was printed to stderr, consider the run
# unsuccessful
self.last_run_successful = False
if stdout_str or stderr_str:
log = Log.objects.create(job=self,
run_date=run_date,
stdout=stdout_str,
stderr=stderr_str,
success=self.last_run_successful,
duration=duration)
# Redirect output back to default
sys.stdout = ostdout
sys.stderr = ostderr
class JobRunner(object):
"""
Class that handles the actual running of a job.
"""
def __init__(self, job):
self.job_id = job.id
def run(self):
"""
This method implements the code to actually run a ``Job``.
"""
args = None
options = None
job = None
last_run_successful = None
heartbeat = None
job_is_running = False
run_date = dates.now()
# Update job with running data.
with transaction.commit_on_success():
job = Job.objects.lock_job(self.job_id)
if not job.check_is_running():
args, options = job.get_args()
heartbeat = JobHeartbeatThread()
job.is_running = True
job.lock_file = heartbeat.lock_file.name
job.save()
else:
job_is_running = True
# Only proceed if the job is not already running.
if not job_is_running:
# Redirect output so that we can log it if there is any
stdout = StringIO()
stderr = StringIO()
ostdout = sys.stdout
ostderr = sys.stderr
sys.stdout = stdout
sys.stderr = stderr
stdout_str, stderr_str = "", ""
# Start job heartbeat.
heartbeat.start()
try:
logger.debug("Calling command '%s'" % job.command)
call_command(job.command, *args, **options)
logger.debug("Command '%s' completed" % job.command)
last_run_successful = True
except Exception, e:
try:
# The command failed to run; log the exception
t = loader.get_template('chronograph/error_message.txt')
c = Context({
'exception': unicode(e),
'traceback': ['\n'.join(traceback.format_exception(*sys.exc_info()))]
})
stderr_str += t.render(c)
except Exception, e2:
sys.stderr.write('Caught exception (%s) while handling job exception (%s)' % (e2, e))
last_run_successful = False
# Stop the heartbeat
logger.debug("Stopping heartbeat")
heartbeat.stop()
heartbeat.join()
# Get stdout/stderr.
stdout_str += stdout.getvalue()
stderr_str += stderr.getvalue()
duration = dates.total_seconds((dates.now()-run_date))
with transaction.commit_on_success():
job = Job.objects.lock_job(self.job_id)
# If anything was printed to stderr, consider the run
# unsuccessful
if stderr_str:
job.last_run_successful = False
else:
job.last_run_successful = last_run_successful
job.is_running = False
job.lock_file = ""
# Only care about minute-level resolution
job.last_run = dates.make_aware(datetime(
run_date.year, run_date.month, run_date.day,
run_date.hour, run_date.minute))
# If this was a forced run, then don't update the
# next_run date
if job.force_run:
logger.debug("Resetting 'force_run'")
job.force_run = False
else:
logger.debug("Determining 'next_run'")
while job.next_run < dates.now():
job.next_run = dates.make_aware(job.rrule.after(job.next_run))
logger.debug("'next_run = ' %s" % job.next_run)
job.save()
# Redirect output back to default
sys.stdout = ostdout
sys.stderr = ostderr
if stdout_str or stderr_str:
log = Log.objects.create(
job=job,
run_date=run_date,
stdout=stdout_str,
stderr=stderr_str,
success=job.last_run_successful,
duration=duration
)
# Send emails
if (job.only_email_on_error and stderr_str) or (not job.only_email_on_error):
print 'emailing'
log.email_subscribers()