Removes built-in ping task (celery.ping) scheduled for removal since 2.3

celery/task/__init__.py

@@ -11,10 +11,7 @@
 """
 from __future__ import absolute_import
 
-import warnings
-
 from ..app import app_or_default
-from ..exceptions import CDeprecationWarning
 
 from .base import Task, PeriodicTask        # noqa
 from .sets import group, TaskSet, subtask   # noqa
@@ -91,22 +88,3 @@ def periodic_task(*args, **options):
 @task(name="celery.backend_cleanup")
 def backend_cleanup():
     backend_cleanup.backend.cleanup()
-
-
-class PingTask(Task):  # ✞
-    name = "celery.ping"
-
-    def run(self, **kwargs):
-        return "pong"
-
-
-def ping():  # ✞
-    """Deprecated and scheduled for removal in Celery 2.3.
-
-    Please use :meth:`celery.task.control.ping` instead.
-
-    """
-    warnings.warn(CDeprecationWarning(
-        "The ping task has been deprecated and will be removed in Celery "
-        "v2.3.  Please use inspect.ping instead."))
-    return PingTask.apply_async().get()

celery/task/base.py

@@ -14,7 +14,7 @@ from __future__ import absolute_import
 from .. import current_app
 from ..app.task import Context, TaskType, BaseTask  # noqa
 from ..schedules import maybe_schedule
-from ..utils import deprecated, timeutils
+from ..utils import timeutils
 
 Task = current_app.Task
 

celery/tests/test_app/test_routes.py

@@ -6,10 +6,16 @@ from functools import wraps
 from celery import routes
 from celery import current_app
 from celery.exceptions import QueueNotFound
+from celery.task import task
 from celery.utils import maybe_promise
 from celery.tests.utils import Case
 
 
+@task
+def mytask():
+    pass
+
+
 def E(queues):
     def expand(answer):
         return routes.Router([], queues).expand_destination(answer)
@@ -52,17 +58,17 @@ class test_MapRoute(Case):
     @with_queues(foo=a_queue, bar=b_queue)
     def test_route_for_task_expanded_route(self):
         expand = E(current_app.conf.CELERY_QUEUES)
-        route = routes.MapRoute({"celery.ping": {"queue": "foo"}})
+        route = routes.MapRoute({mytask.name: {"queue": "foo"}})
         self.assertDictContainsSubset(a_queue,
-                             expand(route.route_for_task("celery.ping")))
+                             expand(route.route_for_task(mytask.name)))
         self.assertIsNone(route.route_for_task("celery.awesome"))
 
     @with_queues(foo=a_queue, bar=b_queue)
     def test_route_for_task(self):
         expand = E(current_app.conf.CELERY_QUEUES)
-        route = routes.MapRoute({"celery.ping": b_queue})
+        route = routes.MapRoute({mytask.name: b_queue})
         self.assertDictContainsSubset(b_queue,
-                             expand(route.route_for_task("celery.ping")))
+                             expand(route.route_for_task(mytask.name)))
         self.assertIsNone(route.route_for_task("celery.awesome"))
 
     def test_expand_route_not_found(self):
@@ -80,11 +86,11 @@ class test_lookup_route(Case):
 
     @with_queues(foo=a_queue, bar=b_queue)
     def test_lookup_takes_first(self):
-        R = routes.prepare(({"celery.ping": {"queue": "bar"}},
-                            {"celery.ping": {"queue": "foo"}}))
+        R = routes.prepare(({mytask.name: {"queue": "bar"}},
+                            {mytask.name: {"queue": "foo"}}))
         router = routes.Router(R, current_app.conf.CELERY_QUEUES)
         self.assertDictContainsSubset(b_queue,
-                router.route({}, "celery.ping",
+                router.route({}, mytask.name,
                     args=[1, 2], kwargs={}))
 
     @with_queues()
@@ -98,7 +104,7 @@ class test_lookup_route(Case):
                               "exchange": None,
                               "routing_key": None,
                               "immediate": False},
-                             "celery.ping",
+                             mytask.name,
                              args=[1, 2], kwargs={})
         self.assertDictContainsSubset({"exchange": "testq",
                                        "routing_key": "testq",
@@ -116,10 +122,10 @@ class test_lookup_route(Case):
         current_app.conf.CELERY_DEFAULT_QUEUE: d_queue})
     def test_lookup_paths_traversed(self):
         R = routes.prepare(({"celery.xaza": {"queue": "bar"}},
-                            {"celery.ping": {"queue": "foo"}}))
+                            {mytask.name: {"queue": "foo"}}))
         router = routes.Router(R, current_app.amqp.queues)
         self.assertDictContainsSubset(a_queue,
-                router.route({}, "celery.ping",
+                router.route({}, mytask.name,
                     args=[1, 2], kwargs={}))
         self.assertEqual(router.route({}, "celery.poza"),
                 dict(d_queue, queue=current_app.conf.CELERY_DEFAULT_QUEUE))

celery/tests/test_task/__init__.py

@@ -230,10 +230,6 @@ class TestCeleryTasks(Case):
         self.assertEqual(result.backend, RetryTask.backend)
         self.assertEqual(result.task_id, task_id)
 
-    @with_eager_tasks
-    def test_ping(self):
-        self.assertEqual(task.ping(), 'pong')
-
     def assertNextTaskDataEqual(self, consumer, presult, task_name,
             test_eta=False, test_expires=False, **kwargs):
         next_task = consumer.fetch()

celery/tests/test_task/test_result.py

@@ -7,12 +7,18 @@ from celery.utils import uuid
 from celery.utils.serialization import pickle
 from celery.result import AsyncResult, EagerResult, TaskSetResult, ResultSet
 from celery.exceptions import TimeoutError
+from celery.task import task
 from celery.task.base import Task
 
 from celery.tests.utils import AppCase
 from celery.tests.utils import skip_if_quick
 
 
+@task
+def mytask():
+    pass
+
+
 def mock_task(name, state, result):
     return dict(id=uuid(), name=name, state=state, result=result)
 
@@ -48,10 +54,10 @@ class TestAsyncResult(AppCase):
             save_result(task)
 
     def test_reduce(self):
-        a1 = AsyncResult("uuid", task_name="celery.ping")
+        a1 = AsyncResult("uuid", task_name=mytask.name)
         restored = pickle.loads(pickle.dumps(a1))
         self.assertEqual(restored.task_id, "uuid")
-        self.assertEqual(restored.task_name, "celery.ping")
+        self.assertEqual(restored.task_name, mytask.name)
 
         a2 = AsyncResult("uuid")
         self.assertEqual(pickle.loads(pickle.dumps(a2)).task_id, "uuid")

celery/tests/test_task/test_task_builtins.py

@@ -1,34 +1,9 @@
 from __future__ import absolute_import
-from __future__ import with_statement
 
-from celery.task import ping, PingTask, backend_cleanup
-from celery.exceptions import CDeprecationWarning
+from celery.task import backend_cleanup
 from celery.tests.utils import Case
 
 
-def some_func(i):
-    return i * i
-
-
-class test_deprecated(Case):
-
-    def test_ping(self):
-        with self.assertWarnsRegex(CDeprecationWarning,
-                r'ping task has been deprecated'):
-            prev = PingTask.app.conf.CELERY_ALWAYS_EAGER
-            PingTask.app.conf.CELERY_ALWAYS_EAGER = True
-            try:
-                self.assertEqual(ping(), "pong")
-            finally:
-                PingTask.app.conf.CELERY_ALWAYS_EAGER = prev
-
-    def test_TaskSet_import_from_task_base(self):
-        with self.assertWarnsRegex(CDeprecationWarning, r'is deprecated'):
-            from celery.task.base import TaskSet, subtask
-            TaskSet()
-            subtask(PingTask)
-
-
 class test_backend_cleanup(Case):
 
     def test_run(self):

celery/tests/test_task/test_task_control.py

@@ -7,11 +7,16 @@ from kombu.pidbox import Mailbox
 
 from celery.app import app_or_default
 from celery.task import control
-from celery.task import PingTask
+from celery.task import task
 from celery.utils import uuid
 from celery.tests.utils import Case
 
 
+@task
+def mytask():
+    pass
+
+
 class MockMailbox(Mailbox):
     sent = []
 
@@ -144,7 +149,7 @@ class test_Broadcast(Case):
 
     @with_mock_broadcast
     def test_rate_limit(self):
-        self.control.rate_limit(PingTask.name, "100/m")
+        self.control.rate_limit(mytask.name, "100/m")
         self.assertIn("rate_limit", MockMailbox.sent)
 
     @with_mock_broadcast

celery/tests/test_worker/test_worker_control.py

@@ -13,7 +13,6 @@ from celery import current_app
 from celery.datastructures import AttributeDict
 from celery.task import task
 from celery.registry import tasks
-from celery.task import PingTask
 from celery.utils import uuid
 from celery.utils.timer2 import Timer
 from celery.worker.buckets import FastQueue
@@ -155,7 +154,7 @@ class test_ControlPanel(Case):
     def test_active(self):
         from celery.worker.job import TaskRequest
 
-        r = TaskRequest(PingTask.name, "do re mi", (), {})
+        r = TaskRequest(mytask.name, "do re mi", (), {})
         state.active_requests.add(r)
         try:
             self.assertTrue(self.panel.handle("dump_active"))
@@ -228,7 +227,7 @@ class test_ControlPanel(Case):
         consumer = Consumer()
         panel = self.create_panel(consumer=consumer)
         self.assertFalse(panel.handle("dump_schedule"))
-        r = TaskRequest("celery.ping", "CAFEBABE", (), {})
+        r = TaskRequest(mytask.name, "CAFEBABE", (), {})
         consumer.eta_schedule.schedule.enter(
                 consumer.eta_schedule.Entry(lambda x: x, (r, )),
                     datetime.now() + timedelta(seconds=10))
@@ -277,7 +276,7 @@ class test_ControlPanel(Case):
         consumer = Consumer()
         panel = self.create_panel(consumer=consumer)
 
-        task = tasks[PingTask.name]
+        task = tasks[mytask.name]
         old_rate_limit = task.rate_limit
         try:
             panel.handle("rate_limit", arguments=dict(task_name=task.name,

celery/worker/buckets.py

@@ -44,11 +44,11 @@ class TaskBucket(object):
     while the :meth:`get` operation iterates over the buckets and retrieves
     the first available item.
 
-    Say we have three types of tasks in the registry: `celery.ping`,
+    Say we have three types of tasks in the registry: `twitter.update`,
     `feed.refresh` and `video.compress`, the TaskBucket will consist
     of the following items::
 
-        {"celery.ping": TokenBucketQueue(fill_rate=300),
+        {"twitter.update": TokenBucketQueue(fill_rate=300),
          "feed.refresh": Queue(),
          "video.compress": TokenBucketQueue(fill_rate=2)}