Consistent naming for save_taskset/restore_taskset

celery/backends/base.py

@@ -57,34 +57,14 @@ class BaseBackend(object):
         """Convert serialized exception to Python exception."""
         return get_pickled_exception(exc)
 
-    def get_status(self, task_id):
-        """Get the status of a task."""
-        raise NotImplementedError(
-                "get_status is not supported by this backend.")
-
     def prepare_value(self, result):
         """Prepare value for storage."""
         return result
 
-    def get_result(self, task_id):
-        """Get the result of a task."""
-        raise NotImplementedError(
-                "get_result is not supported by this backend.")
-
-    def get_traceback(self, task_id):
-        """Get the traceback for a failed task."""
-        raise NotImplementedError(
-                "get_traceback is not supported by this backend.")
-
     def is_successful(self, task_id):
         """Returns ``True`` if the task was successfully executed."""
         return self.get_status(task_id) == states.SUCCESS
 
-    def cleanup(self):
-        """Backend cleanup. Is run by
-        :class:`celery.task.DeleteExpiredTaskMetaTask`."""
-        pass
-
     def wait_for(self, task_id, timeout=None):
         """Wait for task and return its result.
 
@@ -112,19 +92,39 @@ class BaseBackend(object):
             if timeout and time_elapsed >= timeout:
                 raise TimeoutError("The operation timed out.")
 
+    def cleanup(self):
+        """Backend cleanup. Is run by
+        :class:`celery.task.DeleteExpiredTaskMetaTask`."""
+        pass
+
     def process_cleanup(self):
         """Cleanup actions to do at the end of a task worker process."""
         pass
 
-    def store_taskset(self, taskset_id, result):
+    def get_status(self, task_id):
+        """Get the status of a task."""
+        raise NotImplementedError(
+                "get_status is not supported by this backend.")
+
+    def get_result(self, task_id):
+        """Get the result of a task."""
+        raise NotImplementedError(
+                "get_result is not supported by this backend.")
+
+    def get_traceback(self, task_id):
+        """Get the traceback for a failed task."""
+        raise NotImplementedError(
+                "get_traceback is not supported by this backend.")
+
+    def save_taskset(self, taskset_id, result):
         """Store the result and status of a task."""
         raise NotImplementedError(
-                "store_taskset is not supported by this backend.")
+                "save_taskset is not supported by this backend.")
 
-    def get_taskset(self, taskset_id):
+    def restore_taskset(self, taskset_id):
         """Get the result of a taskset."""
         raise NotImplementedError(
-                "get_taskset is not supported by this backend.")
+                "restore_taskset is not supported by this backend.")
 
 
 class BaseDictBackend(BaseBackend):
@@ -156,15 +156,15 @@ class BaseDictBackend(BaseBackend):
         else:
             return meta["result"]
 
-    def get_taskset(self, taskset_id):
+    def restore_taskset(self, taskset_id):
         """Get the result for a taskset."""
-        meta = self._get_taskset_meta_for(taskset_id)
+        meta = self._restore_taskset(taskset_id)
         if meta:
             return meta["result"]
 
-    def store_taskset(self, taskset_id, result):
+    def save_taskset(self, taskset_id, result):
         """Store the result of an executed taskset."""
-        return self._store_taskset(taskset_id, result)
+        return self._save_taskset(taskset_id, result)
 
 
 class KeyValueStoreBackend(BaseDictBackend):
@@ -188,7 +188,7 @@ class KeyValueStoreBackend(BaseDictBackend):
         self.set(self.get_key_for_task(task_id), pickle.dumps(meta))
         return result
 
-    def _store_taskset(self, taskset_id, result):
+    def _save_taskset(self, taskset_id, result):
         meta = {"result": result}
         self.set(self.get_key_for_taskset(taskset_id), pickle.dumps(meta))
         return result
@@ -205,7 +205,7 @@ class KeyValueStoreBackend(BaseDictBackend):
             self._cache[task_id] = meta
         return meta
 
-    def _get_taskset_meta_for(self, taskset_id):
+    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]

celery/backends/database.py

@@ -12,7 +12,7 @@ class DatabaseBackend(BaseDictBackend):
                                       traceback=traceback)
         return result
 
-    def _store_taskset(self, taskset_id, result):
+    def _save_taskset(self, taskset_id, result):
         """Store the result of an executed taskset."""
         TaskSetMeta.objects.store_result(taskset_id, result)
         return result
@@ -28,11 +28,11 @@ class DatabaseBackend(BaseDictBackend):
                 self._cache[task_id] = meta
             return meta
 
-    def _get_taskset_meta_for(self, taskset_id):
+    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.get_taskset(taskset_id)
+        meta = TaskSetMeta.objects.restore_taskset(taskset_id)
         if meta:
             meta = self._cache[taskset_id] = meta.to_dict()
             return meta

celery/managers.py

@@ -131,7 +131,7 @@ class TaskSetManager(ResultManager):
 
 
     @transaction_retry(max_retries=1)
-    def get_taskset(self, taskset_id):
+    def restore_taskset(self, taskset_id):
         """Get taskset meta for task by ``taskset_id``."""
         try:
             return self.get(taskset_id=taskset_id)

celery/result.py

@@ -320,12 +320,12 @@ class TaskSetResult(object):
             >>> result = TaskSetResult.restore(task_id)
 
         """
-        backend.store_taskset(self.taskset_id, self)
+        backend.save_taskset(self.taskset_id, self)
 
     @classmethod
     def restore(self, taskset_id, backend=default_backend):
         """Restore previously saved taskset result."""
-        return backend.get_taskset(taskset_id)
+        return backend.restore_taskset(taskset_id)
 
     @property
     def total(self):

celery/tests/test_backends/test_base.py

@@ -37,13 +37,13 @@ class TestBaseBackendInterface(unittest.TestCase):
         self.assertRaises(NotImplementedError,
                 b.get_result, "SOMExx-N0nex1stant-IDxx-")
 
-    def test_get_taskset(self):
+    def test_restore_taskset(self):
         self.assertRaises(NotImplementedError,
-                b.get_taskset, "SOMExx-N0nex1stant-IDxx-")
+                b.restore_taskset, "SOMExx-N0nex1stant-IDxx-")
 
-    def test_store_taskset(self):
+    def test_save_taskset(self):
         self.assertRaises(NotImplementedError,
-                b.store_taskset, "SOMExx-N0nex1stant-IDxx-", "blergh")
+                b.save_taskset, "SOMExx-N0nex1stant-IDxx-", "blergh")
 
     def test_get_traceback(self):
         self.assertRaises(NotImplementedError,

celery/tests/test_backends/test_database.py

@@ -60,11 +60,11 @@ class TestDatabaseBackend(unittest.TestCase):
         b = DatabaseBackend()
         tid = gen_unique_id()
 
-        self.assertTrue(b.get_taskset(tid) is None)
+        self.assertTrue(b.restore_taskset(tid) is None)
 
         result = {"foo": "baz", "bar": SomeClass(12345)}
-        b.store_taskset(tid, result)
-        rindb = b.get_taskset(tid)
+        b.save_taskset(tid, result)
+        rindb = b.restore_taskset(tid)
         self.assertTrue(rindb is not None)
         self.assertEquals(rindb.get("foo"), "baz")
         self.assertEquals(rindb.get("bar").data, 12345)

celery/tests/test_models.py

@@ -58,7 +58,7 @@ class TestModels(unittest.TestCase):
         self.assertTrue(isinstance(m1.date_done, datetime))
 
         self.assertEquals(
-                TaskSetMeta.objects.get_taskset(m1.taskset_id).taskset_id,
+                TaskSetMeta.objects.restore_taskset(m1.taskset_id).taskset_id,
                 m1.taskset_id)
 
         # Have to avoid save() because it applies the auto_now=True.

pavement.py

@@ -74,8 +74,8 @@ def clean_readme(options):
 @needs("clean_readme")
 def readme(options):
     sh("python contrib/release/sphinx-to-rst.py docs/templates/readme.txt \
-            > README.txt")
-    sh("ln -s README.rst README")
+            > README.rst")
+    sh("ln -sf README.rst README")
 
 
 @task