Change behavior of existing PROPAGATE setting, remove new RERAISE setting.

celery/execute/trace.py

@@ -22,9 +22,13 @@ class TraceInfo(object):
             self.strtb = "\n".join(traceback.format_exception(*exc_info))
 
     @classmethod
-    def trace(cls, fun, args, kwargs, reraise=False):
+    def trace(cls, fun, args, kwargs, propagate=False):
         """Trace the execution of a function, calling the appropiate callback
-        if the function raises retry, an failure or returned successfully."""
+        if the function raises retry, an failure or returned successfully.
+
+        :keyword propagate: If true, errors will propagate to the caller.
+
+        """
         try:
             return cls(states.SUCCESS, retval=fun(*args, **kwargs))
         except (SystemExit, KeyboardInterrupt):
@@ -32,20 +36,20 @@ class TraceInfo(object):
         except RetryTaskError, exc:
             return cls(states.RETRY, retval=exc, exc_info=sys.exc_info())
         except Exception, exc:
-            if reraise:
+            if propagate:
                 raise
             return cls(states.FAILURE, retval=exc, exc_info=sys.exc_info())
         except:
-            if reraise:
-                raise
             # For Python2.4 where raising strings are still allowed.
+            if propagate:
+                raise
             return cls(states.FAILURE, retval=None, exc_info=sys.exc_info())
 
 
 class TaskTrace(object):
 
     def __init__(self, task_name, task_id, args, kwargs, task=None,
-            request=None, **_):
+            request=None, propagate=None, **_):
         self.task_id = task_id
         self.task_name = task_name
         self.args = args
@@ -54,6 +58,7 @@ class TaskTrace(object):
         self.request = request or {}
         self.status = states.PENDING
         self.strtb = None
+        self.propagate = propagate
         self._trace_handlers = {states.FAILURE: self.handle_failure,
                                 states.RETRY: self.handle_retry,
                                 states.SUCCESS: self.handle_success}
@@ -61,13 +66,13 @@ class TaskTrace(object):
     def __call__(self):
         return self.execute()
 
-    def execute(self, reraise=False):
+    def execute(self):
         self.task.request.update(self.request, args=self.args,
                                                kwargs=self.kwargs)
         signals.task_prerun.send(sender=self.task, task_id=self.task_id,
                                  task=self.task, args=self.args,
                                  kwargs=self.kwargs)
-        retval = self._trace(reraise)
+        retval = self._trace()
 
         signals.task_postrun.send(sender=self.task, task_id=self.task_id,
                                   task=self.task, args=self.args,
@@ -75,9 +80,9 @@ class TaskTrace(object):
         self.task.request.clear()
         return retval
 
-    def _trace(self, reraise=False):
+    def _trace(self):
         trace = TraceInfo.trace(self.task, self.args, self.kwargs,
-                reraise=reraise)
+                propagate=self.propagate)
         self.status = trace.status
         self.strtb = trace.strtb
         self.handle_after_return(trace.status, trace.retval,

celery/task/base.py

@@ -554,9 +554,6 @@ class BaseTask(object):
         :keyword throw: Re-raise task exceptions.  Defaults to
                         the :setting:`CELERY_EAGER_PROPAGATES_EXCEPTIONS`
                         setting.
-        :keyword reraise: Re-raise task exceptions with a full traceback. 
-                        Defaults to the
-                        :setting:`CELERY_EAGER_PROPAGATES_EXCEPTIONS` setting.
 
         :rtype :class:`celery.result.EagerResult`:
 
@@ -567,8 +564,6 @@ class BaseTask(object):
         retries = options.get("retries", 0)
         throw = self.app.either("CELERY_EAGER_PROPAGATES_EXCEPTIONS",
                                 options.pop("throw", None))
-        reraise = self.app.either("CELERY_EAGER_RERAISES_EXCEPTIONS",
-                                options.pop("reraise", None))
 
         # Make sure we get the task instance, not class.
         task = tasks[self.name]
@@ -594,11 +589,9 @@ class BaseTask(object):
             kwargs.update(extend_with)
 
         trace = TaskTrace(task.name, task_id, args, kwargs,
-                          task=task, request=request)
-        retval = trace.execute(reraise=reraise)
+                          task=task, request=request, propagate=throw)
+        retval = trace.execute()
         if isinstance(retval, ExceptionInfo):
-            if throw:
-                raise retval.exception
             retval = retval.exception
         return EagerResult(task_id, retval, trace.status,
                            traceback=trace.strtb)