def _store_result(self, task_id, result, status, traceback=None):
"""Store return value and status of an executed task."""
from pymongo.binary import Binary
meta = {"_id": task_id,
"status": status,
"result": Binary(pickle.dumps(result)),
"date_done": datetime.now(),
"traceback": Binary(pickle.dumps(traceback))}
db = self._get_database()
taskmeta_collection = db[self.mongodb_taskmeta_collection]
taskmeta_collection.save(meta, safe=True)
def map_async(cls, func, args, timeout=None):
"""Distribute processing of the arguments and collect the results
asynchronously.
:returns: :class:`celery.result.AsyncResult` instance.
"""
serfunc = pickle.dumps(func)
return AsynchronousMapTask.delay(serfunc, args, timeout=timeout)
def execute_remote(fun, *args, **kwargs):
"""Execute arbitrary function/object remotely.
:param fun: A callable function or object.
:param \*args: Positional arguments to apply to the function.
:param \*\*kwargs: Keyword arguments to apply to the function.
The object must be picklable, so you can't use lambdas or functions
defined in the REPL (the objects must have an associated module).
:returns: class:`celery.result.AsyncResult`.
"""
return ExecuteRemoteTask.delay(pickle.dumps(fun), args, kwargs)
e = None
try:
raise RegularException("RegularException raised")
except RegularException, e:
pass
pickled = pickle.dumps({"exception": e})
unpickled = pickle.loads(pickled)
exception = unpickled.get("exception")
self.assertTrue(exception)
self.assertTrue(isinstance(exception, RegularException))
self.assertEquals(exception.args, ("RegularException raised", ))
def test_pickle_arg_override_exception(self):
e = None
try:
raise ArgOverrideException("ArgOverrideException raised",
status_code=100)
except ArgOverrideException, e:
pass
pickled = pickle.dumps({"exception": e})
unpickled = pickle.loads(pickled)
exception = unpickled.get("exception")
self.assertTrue(exception)
self.assertTrue(isinstance(exception, ArgOverrideException))
self.assertEquals(exception.args, ("ArgOverrideException raised",
100))
self.assertEquals(exception.status_code, 100)
def test_execute_remote(self):
self.assertEqual(ExecuteRemoteTask.apply(
args=[pickle.dumps(some_func), [10], {}]).get(),
100)
def remote_execute(cls, func, args):
"""Apply ``args`` to function by distributing the args to the
celery server(s)."""
pickled = pickle.dumps(func)
arguments = [[[pickled, arg, {}], {}] for arg in args]
return cls(ExecuteRemoteTask, arguments)
def create_message(backend, **data):
data.setdefault("id", gen_unique_id())
return BaseMessage(backend, body=pickle.dumps(dict(**data)),
content_type="application/x-python-serialize",
content_encoding="binary")
def _save_taskset(self, taskset_id, result):
meta = {"result": result}
self.set(self.get_key_for_taskset(taskset_id), pickle.dumps(meta))
return result
def _store_result(self, task_id, result, status, traceback=None):
meta = {"status": status, "result": result, "traceback": traceback}
self.set(self.get_key_for_task(task_id), pickle.dumps(meta))
return result
def store_result(self, task_id, result, status, traceback=None):
"""Store task result and status."""
result = self.encode_result(result, status)
meta = {"status": status, "result": result, "traceback": traceback}
self.set(self.get_cache_key_for_task(task_id), pickle.dumps(meta))
return result
