def save_result(task):
traceback = "Some traceback"
if task["status"] == states.SUCCESS:
default_backend.mark_as_done(task["id"], task["result"])
elif task["status"] == states.RETRY:
default_backend.mark_as_retry(task["id"], task["result"],
traceback=traceback)
else:
default_backend.mark_as_failure(task["id"], task["result"],
traceback=traceback)
def save_result(task):
traceback = "Some traceback"
if task["status"] == states.SUCCESS:
default_backend.mark_as_done(task["id"], task["result"])
elif task["status"] == states.RETRY:
default_backend.mark_as_retry(task["id"], task["result"],
traceback=traceback)
else:
default_backend.mark_as_failure(task["id"], task["result"],
traceback=traceback)
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:
default_backend.mark_as_failure(task_id, exc)
retval = ExceptionInfo(sys.exc_info())
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())
def handle_failure(self, exc, exc_info):
"""Handle exception."""
### Task ended in failure.
type_, value_, tb = exc_info
strtb = "\n".join(traceback.format_exception(type_, value_, tb))
# mark_as_failure returns an exception that is guaranteed to
# be pickleable.
stored_exc = default_backend.mark_as_failure(self.task_id, exc, strtb)
# wrap exception info + traceback and return it to caller.
retval = ExceptionInfo((type_, stored_exc, tb))
# Run error handler last to be sure the status is stored.
error_handler = getattr(self.fun, "on_failure", noop)
error_handler(stored_exc, self.task_id, self.args, self.kwargs)
return retval
def save_result(task):
if task["status"] == "DONE":
default_backend.mark_as_done(task["id"], task["result"])
else:
default_backend.mark_as_failure(task["id"], task["result"])
