def execute(self):
# Convenience variables
fun = self.fun
task_id = self.task_id
task_name = self.task_name
args = self.args
kwargs = self.kwargs
# Run task loader init handler.
current_loader.on_task_init(task_id, fun)
# Backend process cleanup
default_backend.process_cleanup()
# Send pre-run signal.
signals.task_prerun.send(sender=fun, task_id=task_id, task=fun, args=args, kwargs=kwargs)
retval = None
timer_stat = TaskTimerStats.start(task_id, task_name, args, kwargs)
try:
result = fun(*args, **kwargs)
except (SystemExit, KeyboardInterrupt):
raise
except RetryTaskError, exc:
retval = self.handle_retry(exc, sys.exc_info())
def jail(task_id, task_name, func, args, kwargs):
"""Wraps the task in a jail, which catches all exceptions, and
saves the status and result of the task execution to the task
meta backend.
If the call was successful, it saves the result to the task result
backend, and sets the task status to ``"DONE"``.
If the call results in an exception, it saves the exception as the task
result, and sets the task status to ``"FAILURE"``.
:param task_id: The id of the task.
:param task_name: The name of the task.
:param func: Callable object to execute.
:param args: List of positional args to pass on to the function.
:param kwargs: Keyword arguments mapping to pass on to the function.
:returns: the function return value on success, or
the exception instance on failure.
"""
ignore_result = getattr(func, "ignore_result", False)
timer_stat = TaskTimerStats.start(task_id, task_name, args, kwargs)
# See: http://groups.google.com/group/django-users/browse_thread/
# thread/78200863d0c07c6d/38402e76cf3233e8?hl=en&lnk=gst&
# q=multiprocessing#38402e76cf3233e8
from django.db import connection
connection.close()
# Reset cache connection only if using memcached/libmemcached
from django.core import cache
# XXX At Opera we use a custom memcached backend that uses libmemcached
# instead of libmemcache (cmemcache). Should find a better solution for
# this, but for now "memcached" should probably be unique enough of a
# string to not make problems.
cache_backend = cache.settings.CACHE_BACKEND
if hasattr(cache, "parse_backend_uri"):
cache_scheme = cache.parse_backend_uri(cache_backend)[0]
else:
# Django <= 1.0.2
cache_scheme = cache_backend.split(":", 1)[0]
if "memcached" in cache_scheme:
cache.cache.close()
# Backend process cleanup
default_backend.process_cleanup()
try:
result = func(*args, **kwargs)
except (SystemExit, KeyboardInterrupt):
raise
except Exception, exc:
stored_exc = default_backend.mark_as_failure(task_id, exc)
type_, _, tb = sys.exc_info()
retval = ExceptionInfo((type_, stored_exc, tb))
def jail(task_id, func, args, kwargs):
"""Wraps the task in a jail, which catches all exceptions, and
saves the status and result of the task execution to the task
meta backend.
If the call was successful, it saves the result to the task result
backend, and sets the task status to ``"DONE"``.
If the call results in an exception, it saves the exception as the task
result, and sets the task status to ``"FAILURE"``.
:param task_id: The id of the task.
:param func: Callable object to execute.
:param args: List of positional args to pass on to the function.
:param kwargs: Keyword arguments mapping to pass on to the function.
:returns: the function return value on success, or
the exception instance on failure.
"""
# See: http://groups.google.com/group/django-users/browse_thread/
# thread/78200863d0c07c6d/38402e76cf3233e8?hl=en&lnk=gst&
# q=multiprocessing#38402e76cf3233e8
from django.db import connection
connection.close()
# Reset cache connection
from django.core.cache import cache
cache.close()
# Backend process cleanup
default_backend.process_cleanup()
# Convert any unicode keys in the keyword arguments to ascii.
kwargs = dict([(k.encode("utf-8"), v)
for k, v in kwargs.items()])
try:
result = func(*args, **kwargs)
except Exception, exc:
default_backend.mark_as_failure(task_id, exc)
return ExceptionInfo(sys.exc_info())
