def emit(self, record):
"""This function is called each time a message is logged.
In our design, it's role is to invoke a specific handler
for corresponding notification type, registered before
via :meth:`register` function by caller.
Specific notification handler should prepare translated
message string, split one event for particular users
and execute :meth:`send_notification` function for each user
who should be notified.
"""
#
# Emit is called with a lock held, see
# http://docs.python.org/2/library/logging.html#logging.Handler.handle
#
if not NotificationHandler.loaded_notifications and \
'oioioi.notifications' in settings.INSTALLED_APPS:
load_modules('notifications')
NotificationHandler.loaded_notifications = True
if hasattr(record, 'notification'):
notification_type = getattr(record, 'notification')
if notification_type in NotificationHandler.notification_functions:
notification_function = NotificationHandler \
.notification_functions[notification_type]
notification_function(record)
else:
logger.error("Internal error in notification module:"
" Tried to handle a non-exisitent notification \"%s\""
" Please check, if the notification is"
" registered correctly.", notification_type)
def emit(self, record):
"""This function is called each time a message is logged.
In our design, it's role is to invoke a specific handler
for corresponding notification type, registered before
via :meth:`register` function by caller.
Specific notification handler should prepare translated
message string, split one event for particular users
and execute :meth:`send_notification` function for each user
who should be notified.
"""
#
# Emit is called with a lock held, see
# http://docs.python.org/2/library/logging.html#logging.Handler.handle
#
if not NotificationHandler.loaded_notifications:
load_modules('notifications')
NotificationHandler.loaded_notifications = True
if hasattr(record, 'notification'):
notification_type = getattr(record, 'notification')
if notification_type in NotificationHandler.notification_functions:
notification_function = NotificationHandler \
.notification_functions[notification_type]
notification_function(record)
else:
logger.error(
"Internal error in notification module:"
" Tried to handle a non-exisitent notification \"%s\""
" Please check, if the notification is"
" registered correctly.", notification_type)
def evalmgr_job(env):
r"""Takes environment and evaluates it according to its recipe.
To queue environment one shouldn't call ``evalmgr_job.apply_async``
or ``evalmgr_job.delay`` directly. Use ``delay_environ`` instead.
It needs some env elements to be set:
``env['recipe']`` should be a list of tuples
(``phaseName``, ``handler_fun`` [, ``kwargs``])
handler_fun should satisfy this definition:
def handler_fun(``env``, ``\*\*kwargs``):
kwargs will be passed to ``handler_fun``
current environment would be passed as ``env``
It's guaranteed that handler functions would be run in order they're
listed and that environment modified by previous function will be
passed to next function unchanged.
Before running the job, its unique identifier is generated and saved in
``env['job_id']``.
A job may be transferred to an external evaluation system using
``transfer_job``. A recipe handler which want to transfer job should
return environ processed by ``transfer_job``, like::
def prepare_transfer_handler(environ, **kwargs):
do_some_important_stuff(environ, **kwargs)
return transfer_job(environ,
'some.module.transfer_function',
'functions.that.merges.saved.env.and.result')
If during any of the phases an exception other than Ignore is thrown,
and ``env['error_handlers']`` is present (it should be in the same
format as recipe), functions listed there are called with
additional ``exc_info`` argument, which is the ``sys.exc_info()``
triple. If any exceptions are thrown there, they are reported to
the logs and ignored.
If a celery.exceptions.Ignore is thrown, then execution of environment
is stopped. One who does it is responsible for handling corresponding
QueuedJob object.
Returns environment (a processed copy of given environment).
"""
# pylint: disable=global-statement,broad-except
global loaded_controllers
# load controllers to avoid late mix-ins to them
if not loaded_controllers:
load_modules('controllers')
loaded_controllers = True
env = copy.deepcopy(env)
try:
if 'job_id' not in env:
raise RuntimeError('No job_id found in environ')
if 'recipe' not in env:
raise RuntimeError(
'No recipe found in job environment. '
'Did you forget to set environ["run_externally"]?')
if 'error' in env:
raise RuntimeError(
'Error from workers:\n%s\nTB:\n%s' %
(env['error']['message'], env['error']['traceback']))
_mark_job_state(env, 'PROGRESS')
while True:
recipe = env.get('recipe')
if not recipe:
env = _job_finished(env)
break
phase = recipe[0]
env['recipe'] = recipe[1:]
env = _run_phase(env, phase)
if 'transfer' in env:
env = _transfer_job(env, **env.pop('transfer'))
break
return env
# Throwing up celery.exceptions.Ignore is necessary for our custom revoke
# mechanism. Basically, one of the handlers in job's recipe throws Ignore
# if the submission had been revoked and this exception has to be passed
# up so that celery recognizes it and stops execution of this job.
except Ignore:
raise
# pylint: disable=broad-except
except Exception:
return _run_error_handlers(env, sys.exc_info())
"setting"
)
return request.contest
def _send_error_email(self, request, contests):
context = self._error_email_context(request, contests)
message = self._error_email_message(context)
subject = render_to_string(
'contestexcl/exclusive_contests_error_subject.txt')
subject = ' '.join(subject.strip().splitlines())
mail_admins(subject, message)
def _error_email_message(self, context):
return render_to_string(
'contestexcl/exclusive_contests_error_email.txt',
context
)
def _error_email_context(self, request, contests):
contests_data = [(cnst.name, cnst.id) for cnst in contests]
return {
'contests': contests_data,
'username': request.user.username
}
# This causes adding all mixins to ExclusiveContestMiddleware.
# This is needed as middlewares are instantiated before importing
# INSTALLED_APPS, so mixins would be late.
load_modules('middleware')
def evalmgr_job(env):
r"""Takes environment and evaluates it according to its recipe.
It needs some env elements to be set:
``env['recipe']`` should be a list of tuples
(``phaseName``, ``handler_fun`` [, ``kwargs``])
handler_fun should satisfy this definition:
def handler_fun(``env``, ``\*\*kwargs``):
kwargs will be passed to ``handler_fun``
current environment would be passed as ``env``
It's guaranteed that handler functions would be run in order they're
listed and that environment modified by previous function will be
passed to next function unchanged.
Before running the job, its unique identifier is generated and saved in
``env['job_id']``.
If during any of the phases an exception is thrown, and
``env['error_handlers']`` is present (it should be in the same
format as recipe), functions listed there are called with
additional ``exc_info`` argument, which is the ``sys.exc_info()``
triple. If any exceptions are thrown there, they are reported to
the logs and ignored.
Returns environment (a processed copy of given environment).
"""
# pylint: disable=global-statement,broad-except
global loaded_controllers
# load controllers to avoid late mix-ins to them
if not loaded_controllers:
load_modules('controllers')
loaded_controllers = True
env = copy.deepcopy(env)
env['job_id'] = evalmgr_job.request.id
try:
if 'recipe' not in env:
raise RuntimeError('No recipe found in job environment. '
'Did you forget to set environ["run_externally"]?')
if 'error' in env:
raise RuntimeError('Error from workers:\n%s\nTB:\n%s' %
(env['error']['message'], env['error']['traceback']))
while True:
recipe = env.get('recipe')
if not recipe:
break
phase = recipe[0]
env['recipe'] = recipe[1:]
env = _run_phase(env, phase)
if 'workers_jobs' in env:
send_async_jobs(env)
break
return env
# Throwing up celery.exceptions.Ignore is necessary for our custom revoke
# mechanism. Basically, one of the handlers in job's recipe throws Ignore
# if the submission had been revoked and this exception has to be passed
# up so that celery recognizes it and stops execution of this job.
except Ignore:
raise
# pylint: disable=broad-except
except Exception:
return _run_error_handlers(env, sys.exc_info())
if not hasattr(request, 'user'):
raise ImproperlyConfigured(
"django.contrib.auth.middleware.AuthenticationMiddleware is"
"required. If you have it installed check if it comes before "
"ExclusiveContestsMiddleware in your MIDDLEWARE_CLASSES"
"setting")
return request.contest
def _send_error_email(self, request, contests):
context = self._error_email_context(request, contests)
message = self._error_email_message(context)
subject = render_to_string(
'contestexcl/exclusive-contests-error-subject.txt')
subject = ' '.join(subject.strip().splitlines())
mail_admins(subject, message)
def _error_email_message(self, context):
return render_to_string(
'contestexcl/exclusive-contests-error-email.txt', context)
def _error_email_context(self, request, contests):
contests_data = [(cnst.name, cnst.id) for cnst in contests]
return {'contests': contests_data, 'username': request.user.username}
# This causes adding all mixins to ExclusiveContestMiddleware.
# This is needed as middlewares are instantiated before importing
# INSTALLED_APPS, so mixins would be late.
load_modules('middleware')
def evalmgr_job(env):
r"""Takes environment and evaluates it according to its recipe.
To queue environment one shouldn't call ``evalmgr_job.apply_async``
or ``evalmgr_job.delay`` directly. Use ``delay_environ`` instead.
It needs some env elements to be set:
``env['recipe']`` should be a list of tuples
(``phaseName``, ``handler_fun`` [, ``kwargs``])
handler_fun should satisfy this definition:
def handler_fun(``env``, ``\*\*kwargs``):
kwargs will be passed to ``handler_fun``
current environment would be passed as ``env``
It's guaranteed that handler functions would be run in order they're
listed and that environment modified by previous function will be
passed to next function unchanged.
Before running the job, its unique identifier is generated and saved in
``env['job_id']``.
A job may be transferred to an external evaluation system using
``transfer_job``. A recipe handler which want to transfer job should
return environ processed by ``transfer_job``, like::
def prepare_transfer_handler(environ, **kwargs):
do_some_important_stuff(environ, **kwargs)
return transfer_job(environ,
'some.module.transfer_function',
'functions.that.merges.saved.env.and.result')
If during any of the phases an exception other than Ignore is thrown,
and ``env['error_handlers']`` is present (it should be in the same
format as recipe), functions listed there are called with
additional ``exc_info`` argument, which is the ``sys.exc_info()``
triple. If any exceptions are thrown there, they are reported to
the logs and ignored.
If a celery.exceptions.Ignore is thrown, then execution of environment
is stopped. One who does it is responsible for handling corresponding
QueuedJob object.
Returns environment (a processed copy of given environment).
"""
# pylint: disable=global-statement,broad-except
global loaded_controllers
# load controllers to avoid late mix-ins to them
if not loaded_controllers:
load_modules('controllers')
loaded_controllers = True
env = copy.deepcopy(env)
try:
if 'job_id' not in env:
raise RuntimeError('No job_id found in environ')
if 'recipe' not in env:
raise RuntimeError('No recipe found in job environment. '
'Did you forget to set environ["run_externally"]?')
if 'error' in env:
raise RuntimeError('Error from workers:\n%s\nTB:\n%s' %
(env['error']['message'], env['error']['traceback']))
_mark_job_state(env, 'PROGRESS')
while True:
recipe = env.get('recipe')
if not recipe:
env = _job_finished(env)
break
phase = recipe[0]
env['recipe'] = recipe[1:]
env = _run_phase(env, phase)
if 'transfer' in env:
env = _transfer_job(env, **env.pop('transfer'))
break
return env
# Throwing up celery.exceptions.Ignore is necessary for our custom revoke
# mechanism. Basically, one of the handlers in job's recipe throws Ignore
# if the submission had been revoked and this exception has to be passed
# up so that celery recognizes it and stops execution of this job.
except Ignore:
raise
# pylint: disable=broad-except
except Exception:
return _run_error_handlers(env, sys.exc_info())
