def test_memcache_wrapper(self):
try:
from django.core.cache.backends import memcached
from django.core.cache.backends import locmem
except InvalidCacheBackendError:
sys.stderr.write(
"\n* Memcache library is not installed. Skipping test.\n")
return
prev_cache_cls = memcached.CacheClass
memcached.CacheClass = locmem.CacheClass
prev_backend_module = sys.modules.pop("celery.backends.cache")
try:
from celery.backends.cache import cache, DjangoMemcacheWrapper
self.assertIsInstance(cache, DjangoMemcacheWrapper)
key = "cu.test_memcache_wrapper"
val = "The quick brown fox."
default = "The lazy dog."
self.assertEqual(cache.get(key, default=default), default)
cache.set(key, val)
self.assertEqual(pickle.loads(cache.get(key, default=default)),
val)
finally:
memcached.CacheClass = prev_cache_cls
sys.modules["celery.backends.cache"] = prev_backend_module
def run(self, ser_callable, fargs, fkwargs, **kwargs):
"""
:param ser_callable: A pickled function or callable object.
:param fargs: Positional arguments to apply to the function.
:param fkwargs: Keyword arguments to apply to the function.
"""
return pickle.loads(ser_callable)(*fargs, **fkwargs)
def _restore_taskset(self, taskset_id):
"""Get task metadata for a task by id."""
if taskset_id in self._cache:
return self._cache[taskset_id]
meta = self.get(self.get_key_for_taskset(taskset_id))
if meta:
meta = pickle.loads(str(meta))
self._cache[taskset_id] = meta
return meta
def _get_task_meta_for(self, task_id):
"""Get task metadata for a task by id."""
db = self._get_database()
taskmeta_collection = db[self.mongodb_taskmeta_collection]
obj = taskmeta_collection.find_one({"_id": task_id})
if not obj:
return {"status": states.PENDING, "result": None}
meta = {
"task_id": obj["_id"],
"status": obj["status"],
"result": pickle.loads(str(obj["result"])),
"date_done": obj["date_done"],
"traceback": pickle.loads(str(obj["traceback"])),
}
return meta
def _get_task_meta_for(self, task_id):
"""Get task metadata for a task by id."""
if task_id in self._cache:
return self._cache[task_id]
meta = self.get(self.get_key_for_task(task_id))
if not meta:
return {"status": states.PENDING, "result": None}
meta = pickle.loads(str(meta))
if meta.get("status") == states.SUCCESS:
self._cache[task_id] = meta
return meta
def _get_task_meta_for(self, task_id):
"""Get task metadata for a task by id."""
if task_id in self._cache:
return self._cache[task_id]
db = self._get_database()
taskmeta_collection = db[self.mongodb_taskmeta_collection]
obj = taskmeta_collection.find_one({"_id": task_id})
if not obj:
return {"status": "PENDING", "result": None}
meta = {
"task_id": obj["_id"],
"status": obj["status"],
"result": pickle.loads(str(obj["result"])),
"date_done": obj["date_done"],
"traceback": pickle.loads(str(obj["traceback"])),
}
if meta["status"] == "SUCCESS":
self._cache[task_id] = meta
return meta
def test_memcache_wrapper(self):
from django.core.cache.backends import memcached
from django.core.cache.backends import locmem
prev_cache_cls = memcached.CacheClass
memcached.CacheClass = locmem.CacheClass
prev_backend_module = sys.modules.pop("celery.backends.cache")
try:
from celery.backends.cache import cache, DjangoMemcacheWrapper
self.assertTrue(isinstance(cache, DjangoMemcacheWrapper))
key = "cu.test_memcache_wrapper"
val = "The quick brown fox."
default = "The lazy dog."
self.assertEquals(cache.get(key, default=default), default)
cache.set(key, val)
self.assertEquals(pickle.loads(cache.get(key, default=default)),
val)
finally:
memcached.CacheClass = prev_cache_cls
sys.modules["celery.backends.cache"] = prev_backend_module
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 run(self, serfunc, args, **kwargs):
"""The method run by ``celeryd``."""
timeout = kwargs.get("timeout")
return TaskSet.map(pickle.loads(serfunc), args, timeout=timeout)
def _restore_taskset(self, taskset_id):
"""Get task metadata for a task by id."""
meta = self.get(self.get_key_for_taskset(taskset_id))
if meta:
meta = pickle.loads(str(meta))
return meta
def _get_task_meta_for(self, task_id):
"""Get task metadata for a task by id."""
meta = self.get(self.get_key_for_task(task_id))
if not meta:
return {"status": states.PENDING, "result": None}
return pickle.loads(str(meta))
def run(self, ser_callable, args, timeout=None, **kwargs):
""":see :meth:`TaskSet.dmap_async`."""
return TaskSet.map(pickle.loads(ser_callable), args, timeout=timeout)
