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())