Disable result cache for all backends but the AMQP backend.

celery/backends/base.py

@@ -134,7 +134,6 @@ class BaseDictBackend(BaseBackend):
 
     def __init__(self, *args, **kwargs):
         super(BaseDictBackend, self).__init__(*args, **kwargs)
-        self._cache = {}
 
     def store_result(self, task_id, result, status, traceback=None):
         """Store task result and status."""
@@ -196,22 +195,15 @@ class KeyValueStoreBackend(BaseDictBackend):
 
     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 _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

celery/backends/database.py

@@ -19,22 +19,16 @@ class DatabaseBackend(BaseDictBackend):
 
     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 = TaskMeta.objects.get_task(task_id)
         if meta:
             meta = meta.to_dict()
-            if meta["status"] == states.SUCCESS:
-                self._cache[task_id] = meta
             return meta
 
     def _restore_taskset(self, taskset_id):
         """Get taskset metadata for a taskset by id."""
-        if taskset_id in self._cache:
-            return self._cache[taskset_id]
         meta = TaskSetMeta.objects.restore_taskset(taskset_id)
         if meta:
-            meta = self._cache[taskset_id] = meta.to_dict()
+            meta = meta.to_dict()
             return meta
 
     def cleanup(self):

celery/backends/mongodb.py

@@ -63,7 +63,6 @@ class MongoBackend(BaseDictBackend):
                 'taskmeta_collection', self.mongodb_taskmeta_collection)
 
         super(MongoBackend, self).__init__(*args, **kwargs)
-        self._cache = {}
         self._connection = None
         self._database = None
 
@@ -113,8 +112,6 @@ class MongoBackend(BaseDictBackend):
 
     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]
@@ -129,8 +126,6 @@ class MongoBackend(BaseDictBackend):
             "date_done": obj["date_done"],
             "traceback": pickle.loads(str(obj["traceback"])),
         }
-        if meta["status"] == states.SUCCESS:
-            self._cache[task_id] = meta
 
         return meta
 

celery/backends/pyredis.py

@@ -92,7 +92,8 @@ class RedisBackend(KeyValueStoreBackend):
     def close(self):
         """Close the connection to redis."""
         if self._connection is not None:
-            self._connection.disconnect()
+            self._connection.save()
+            self._connection.connection.disconnect()
             self._connection = None
 
     def process_cleanup(self):

celery/tests/test_backends/test_cache.py

@@ -31,7 +31,6 @@ class TestCacheBackend(unittest.TestCase):
         self.assertTrue(cb.is_successful(tid))
         self.assertEquals(cb.get_status(tid), states.SUCCESS)
         self.assertEquals(cb.get_result(tid), 42)
-        self.assertTrue(cb._cache.get(tid))
         self.assertTrue(cb.get_result(tid), 42)
 
     def test_save_restore_taskset(self):

celery/tests/test_backends/test_database.py

@@ -35,7 +35,6 @@ class TestDatabaseBackend(unittest.TestCase):
         self.assertTrue(b.is_successful(tid))
         self.assertEquals(b.get_status(tid), states.SUCCESS)
         self.assertEquals(b.get_result(tid), 42)
-        self.assertTrue(b._cache.get(tid))
         self.assertTrue(b.get_result(tid), 42)
 
         tid2 = gen_unique_id()
@@ -68,4 +67,3 @@ class TestDatabaseBackend(unittest.TestCase):
         self.assertTrue(rindb is not None)
         self.assertEquals(rindb.get("foo"), "baz")
         self.assertEquals(rindb.get("bar").data, 12345)
-        self.assertTrue(b._cache.get(tid))

celery/tests/test_backends/test_redis.py

@@ -72,7 +72,6 @@ class TestRedisBackend(unittest.TestCase):
         self.assertTrue(tb.is_successful(tid))
         self.assertEquals(tb.get_status(tid), states.SUCCESS)
         self.assertEquals(tb.get_result(tid), 42)
-        self.assertTrue(tb._cache.get(tid))
         self.assertTrue(tb.get_result(tid), 42)
 
     def test_is_pickled(self):

celery/tests/test_backends/test_tyrant.py

@@ -74,7 +74,6 @@ class TestTyrantBackend(unittest.TestCase):
         self.assertTrue(tb.is_successful(tid))
         self.assertEquals(tb.get_status(tid), states.SUCCESS)
         self.assertEquals(tb.get_result(tid), 42)
-        self.assertTrue(tb._cache.get(tid))
         self.assertTrue(tb.get_result(tid), 42)
 
     def test_is_pickled(self):